tsai
/
Avalonia
mirror of https://github.com/AvaloniaUI/Avalonia.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

Refactored tab navigation. 

In preparation for directional navigation.
pull/72/merge
Steven Kirk 11 years ago
parent
2472bf26cc
commit
3870c4792f
7 changed files with 179 additions and 182 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 1
      Perspex.Controls/Perspex.Controls.csproj
  2. 8
      Perspex.Controls/StackPanel.cs
  3. 14
      Perspex.Input/INavigableContainer.cs
  4. 41
      Perspex.Input/KeyboardNavigation.cs
  5. 192
      Perspex.Input/KeyboardNavigationHandler.cs
  6. 1
      Perspex.Input/Perspex.Input.csproj
  7. 104
      Tests/Perspex.Input.UnitTests/KeyboardNavigationTests_Tab.cs

1
Perspex.Controls/Perspex.Controls.csproj
View File

@ -55,7 +55,6 @@
<Compile Include="DropDown.cs" />
<Compile Include="IContentControl.cs" />
<Compile Include="IReparentingControl.cs" />
<Compile Include="INavigablePanel.cs" />
<Compile Include="Deck.cs" />
<Compile Include="Platform\IPopupImpl.cs" />
<Compile Include="Platform\ITopLevelImpl.cs" />

8
Perspex.Controls/StackPanel.cs
View File

@ -28,7 +28,7 @@ namespace Perspex.Controls
/// <summary>
/// A panel which lays out its children horizontally or vertically.
/// </summary>
public class StackPanel : Panel, INavigablePanel
public class StackPanel : Panel, INavigableContainer
{
/// <summary>
/// Defines the <see cref="Gap"/> property.
@ -75,10 +75,10 @@ namespace Perspex.Controls
/// <param name="direction">The movement direction.</param>
/// <param name="from">The control from which movement begins.</param>
/// <returns>The control.</returns>
IControl INavigablePanel.GetControl(FocusNavigationDirection direction, IControl from)
IInputElement INavigableContainer.GetControl(FocusNavigationDirection direction, IInputElement from)
{
var horiz = this.Orientation == Orientation.Horizontal;
int index = this.Children.IndexOf(from);
int index = this.Children.IndexOf((IControl)from);
switch (direction)
{
@ -92,7 +92,7 @@ namespace Perspex.Controls
++index;
break;
case FocusNavigationDirection.Previous:
++index;
--index;
break;
case FocusNavigationDirection.Left:
index = horiz ? index - 1 : -1;

14
Perspex.Controls/INavigablePanel.cs → Perspex.Input/INavigableContainer.cs
View File

@ -1,17 +1,15 @@
// -----------------------------------------------------------------------
// <copyright file="INavigablePanel.cs" company="Steven Kirk">
// Copyright 2014 MIT Licence. See licence.md for more information.
// <copyright file="INavigableContainer.cs" company="Steven Kirk">
// Copyright 2015 MIT Licence. See licence.md for more information.
// </copyright>
// -----------------------------------------------------------------------
namespace Perspex.Controls
namespace Perspex.Input
{
using Perspex.Input;
/// <summary>
/// Defines a panel in which the child controls can be navigated by keyboard.
/// Defines a container in which the child controls can be navigated by keyboard.
/// </summary>
public interface INavigablePanel
public interface INavigableContainer
{
/// <summary>
/// Gets the next control in the specified direction.
@ -19,6 +17,6 @@ namespace Perspex.Controls
/// <param name="direction">The movement direction.</param>
/// <param name="from">The control from which movement begins.</param>
/// <returns>The control.</returns>
IControl GetControl(FocusNavigationDirection direction, IControl from);
IInputElement GetControl(FocusNavigationDirection direction, IInputElement from);
}
}

41
Perspex.Input/KeyboardNavigation.cs
View File

@ -11,6 +11,19 @@ namespace Perspex.Input
/// </summary>
public static class KeyboardNavigation
{
/// <summary>
/// Defines the DirectionalNavigation attached property.
/// </summary>
/// <remarks>
/// The DirectionalNavigation attached property defines how pressing arrow keys causes
/// focus to be navigated between the children of the container.
/// </remarks>
public static readonly PerspexProperty<KeyboardNavigationMode> DirectionalNavigationProperty =
PerspexProperty.RegisterAttached<InputElement, KeyboardNavigationMode>(
"DirectionalNavigation",
typeof(KeyboardNavigation),
KeyboardNavigationMode.None);
/// <summary>
/// Defines the TabNavigation attached property.
/// </summary>
@ -19,7 +32,9 @@ namespace Perspex.Input
/// be navigated between the children of the container.
/// </remarks>
public static readonly PerspexProperty<KeyboardNavigationMode> TabNavigationProperty =
PerspexProperty.RegisterAttached<InputElement, KeyboardNavigationMode>("TabNavigation", typeof(KeyboardNavigation));
PerspexProperty.RegisterAttached<InputElement, KeyboardNavigationMode>(
"TabNavigation",
typeof(KeyboardNavigation));
/// <summary>
/// Defines the TabOnceActiveElement attached property.
@ -30,7 +45,29 @@ namespace Perspex.Input
/// defines to which child the focus should move.
/// </remarks>
public static readonly PerspexProperty<IInputElement> TabOnceActiveElementProperty =
PerspexProperty.RegisterAttached<InputElement, IInputElement>("TabOnceActiveElement", typeof(KeyboardNavigation));
PerspexProperty.RegisterAttached<InputElement, IInputElement>(
"TabOnceActiveElement",
typeof(KeyboardNavigation));
/// <summary>
/// Gets the <see cref="DirectionalNavigationProperty"/> for a container.
/// </summary>
/// <param name="element">The container.</param>
/// <returns>The <see cref="KeyboardNavigationMode"/> for the container.</returns>
public static KeyboardNavigationMode GetDirectionalNavigation(InputElement element)
{
return element.GetValue(DirectionalNavigationProperty);
}
/// <summary>
/// Sets the <see cref="DirectionalNavigationProperty"/> for a container.
/// </summary>
/// <param name="element">The container.</param>
/// <param name="value">The <see cref="KeyboardNavigationMode"/> for the container.</param>
public static void SetDirectionalNavigation(InputElement element, KeyboardNavigationMode value)
{
element.SetValue(DirectionalNavigationProperty, value);
}
/// <summary>
/// Gets the <see cref="TabNavigationProperty"/> for a container.

192
Perspex.Input/KeyboardNavigationHandler.cs
View File

@ -43,11 +43,17 @@ namespace Perspex.Input
}
/// <summary>
/// Gets the next element in tab order.
/// Gets the next control in the specified navigation direction.
/// </summary>
/// <param name="element">The element.</param>
/// <returns>The next element in tab order.</returns>
public static IInputElement GetNextInTabOrder(IInputElement element)
/// <param name="direction">The navigation direction.</param>
/// <returns>
/// The next element in the specified direction, or null if <paramref name="element"/>
/// was the last in therequested direction.
/// </returns>
public static IInputElement GetNext(
IInputElement element,
FocusNavigationDirection direction)
{
Contract.Requires<ArgumentNullException>(element != null);
@ -55,60 +61,39 @@ namespace Perspex.Input
if (container != null)
{
var mode = KeyboardNavigation.GetTabNavigation((InputElement)container);
KeyboardNavigationMode mode;
switch (mode)
if (direction == FocusNavigationDirection.Next || direction == FocusNavigationDirection.Previous)
{
case KeyboardNavigationMode.Continue:
return GetNextInContainer(element, container) ??
GetFirstInNextContainer(container);
case KeyboardNavigationMode.Cycle:
return GetNextInContainer(element, container) ??
GetDescendents(container).FirstOrDefault();
case KeyboardNavigationMode.Contained:
return GetNextInContainer(element, container);
default:
return GetFirstInNextContainer(container);
mode = KeyboardNavigation.GetTabNavigation((InputElement)container);
}
else
{
mode = KeyboardNavigation.GetDirectionalNavigation((InputElement)container);
}
}
else
{
return GetDescendents(element).FirstOrDefault();
}
}
/// <summary>
/// Gets the next element in tab order.
/// </summary>
/// <param name="element">The element.</param>
/// <returns>The next element in tab order.</returns>
public static IInputElement GetPreviousInTabOrder(IInputElement element)
{
Contract.Requires<ArgumentNullException>(element != null);
var container = element.GetVisualParent<IInputElement>();
if (container != null)
{
var mode = KeyboardNavigation.GetTabNavigation((InputElement)container);
bool forward = direction == FocusNavigationDirection.Next ||
direction == FocusNavigationDirection.Last ||
direction == FocusNavigationDirection.Right ||
direction == FocusNavigationDirection.Down;
switch (mode)
{
case KeyboardNavigationMode.Continue:
return GetPreviousInContainer(element, container) ??
GetLastInPreviousContainer(element);
return GetNextInContainer(element, container, direction) ??
GetFirstInNextContainer(element, forward);
case KeyboardNavigationMode.Cycle:
return GetPreviousInContainer(element, container) ??
GetDescendents(container).LastOrDefault();
return GetNextInContainer(element, container, direction) ??
GetDescendent(container, forward);
case KeyboardNavigationMode.Contained:
return GetPreviousInContainer(element, container);
return GetNextInContainer(element, container, direction);
default:
return GetLastInPreviousContainer(container);
return GetFirstInNextContainer(container, forward);
}
}
else
{
return GetDescendents(element).LastOrDefault();
return GetDescendents(element).FirstOrDefault();
}
}
@ -120,7 +105,7 @@ namespace Perspex.Input
{
Contract.Requires<ArgumentNullException>(element != null);
var next = GetNextInTabOrder(element);
var next = GetNext(element, FocusNavigationDirection.Next);
if (next != null)
{
@ -136,7 +121,7 @@ namespace Perspex.Input
{
Contract.Requires<ArgumentNullException>(element != null);
var next = GetPreviousInTabOrder(element);
var next = GetNext(element, FocusNavigationDirection.Previous);
if (next != null)
{
@ -158,6 +143,19 @@ namespace Perspex.Input
/// <returns>True if a descendent of the element can be focused.</returns>
private static bool CanFocusDescendent(IInputElement e) => e.IsEnabledCore && e.IsVisible;
/// <summary>
/// Gets the first or last focusable descendent of the specified element.
/// </summary>
/// <param name="container">The element.</param>
/// <param name="forward">Whether to search forward or backwards.</param>
/// <returns>The element or null if not found.##</returns>
private static IInputElement GetDescendent(IInputElement container, bool forward)
{
return forward ?
GetDescendents(container).FirstOrDefault() :
GetDescendents(container).LastOrDefault();
}
/// <summary>
/// Gets the focusable descendents of the specified element, depending on the element's
/// <see cref="KeyboardNavigation.TabNavigationProperty"/>.
@ -212,8 +210,12 @@ namespace Perspex.Input
/// </summary>
/// <param name="element">The starting element/</param>
/// <param name="container">The container.</param>
/// <param name="direction">The direction.</param>
/// <returns>The next element, or null if the element is the last.</returns>
private static IInputElement GetNextInContainer(IInputElement element, IInputElement container)
private static IInputElement GetNextInContainer(
IInputElement element,
IInputElement container,
FocusNavigationDirection direction)
{
var descendent = GetDescendents(element).FirstOrDefault();
@ -223,98 +225,54 @@ namespace Perspex.Input
}
else if (container != null)
{
var sibling = container.GetVisualChildren()
.OfType<IInputElement>()
.Where(CanFocus)
.SkipWhile(x => x != element)
.Skip(1)
.FirstOrDefault();
var navigable = container as INavigableContainer;
if (sibling != null)
// TODO: Do a spatial search here.
if (navigable != null)
{
return sibling;
while (element != null)
{
var sibling = navigable.GetControl(direction, element);
if (sibling != null && CanFocus(sibling))
{
return sibling;
}
element = sibling;
}
}
}
return null;
}
/// <summary>
/// Gets the previous item that should be focused in the specified container.
/// </summary>
/// <param name="element">The starting element/</param>
/// <param name="container">The container.</param>
/// <returns>The previous element, or null if the element is the first.</returns>
private static IInputElement GetPreviousInContainer(IInputElement element, IInputElement container)
{
return container.GetVisualChildren()
.OfType<IInputElement>()
.Where(CanFocus)
.TakeWhile(x => x != element)
.LastOrDefault();
}
/// <summary>
/// Gets the first item that should be focused in the next container.
/// </summary>
/// <param name="container">The container.</param>
/// <param name="forward">Whether to search forward or backwards.</param>
/// <returns>The first element, or null if there are no more elements.</returns>
private static IInputElement GetFirstInNextContainer(IInputElement container)
private static IInputElement GetFirstInNextContainer(IInputElement container, bool forward)
{
var parent = container.GetVisualParent<IInputElement>();
IInputElement next = null;
if (parent != null)
{
var sibling = parent.GetVisualChildren()
var siblings = parent.GetVisualChildren()
.OfType<IInputElement>()
.Where(CanFocusDescendent)
.SkipWhile(x => x != container)
.Skip(1)
.FirstOrDefault();
.Where(CanFocusDescendent);
IInputElement sibling;
if (sibling != null)
if (forward)
{
if (CanFocus(sibling))
{
next = sibling;
}
else
{
next = GetDescendents(sibling).FirstOrDefault();
}
sibling = siblings.SkipWhile(x => x != container).Skip(1).FirstOrDefault();
}
if (next == null)
else
{
next = GetFirstInNextContainer(parent);
sibling = siblings.TakeWhile(x => x != container).LastOrDefault();
}
}
else
{
next = GetDescendents(container).FirstOrDefault();
}
return next;
}
/// <summary>
/// Gets the last item that should be focused in the previous container.
/// </summary>
/// <param name="container">The container.</param>
/// <returns>The next element, or null if there are no more elements.</returns>
private static IInputElement GetLastInPreviousContainer(IInputElement container)
{
var parent = container.GetVisualParent<IInputElement>();
IInputElement next = null;
if (parent != null)
{
var sibling = parent.GetVisualChildren()
.OfType<IInputElement>()
.Where(CanFocusDescendent)
.TakeWhile(x => x != container)
.LastOrDefault();
if (sibling != null)
{
@ -324,18 +282,22 @@ namespace Perspex.Input
}
else
{
next = GetDescendents(sibling).LastOrDefault();
next = forward ?
GetDescendents(sibling).FirstOrDefault() :
GetDescendents(sibling).LastOrDefault();
}
}
if (next == null)
{
next = GetLastInPreviousContainer(parent);
next = GetFirstInNextContainer(parent, forward);
}
}
else
{
next = GetDescendents(container).LastOrDefault();
next = forward ?
GetDescendents(container).FirstOrDefault() :
GetDescendents(container).LastOrDefault();
}
return next;

1
Perspex.Input/Perspex.Input.csproj
View File

@ -75,6 +75,7 @@
<Compile Include="IKeyboardDevice.cs" />
<Compile Include="IKeyboardNavigationHandler.cs" />
<Compile Include="IMouseDevice.cs" />
<Compile Include="INavigableContainer.cs" />
<Compile Include="InputElement.cs" />
<Compile Include="InputExtensions.cs" />
<Compile Include="InputManager.cs" />

104
Tests/Perspex.Input.UnitTests/KeyboardNavigationTests_Tab.cs
View File

@ -12,7 +12,7 @@ namespace Perspex.Input.UnitTests
public class KeyboardNavigationTests_Tab
{
[Fact]
public void GetNextInTabOrder_Continue_Returns_Next_Control_In_Container()
public void Next_Continue_Returns_Next_Control_In_Container()
{
StackPanel container;
Button current;
@ -43,13 +43,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Continue_Returns_First_Control_In_Next_Sibling_Container()
public void Next_Continue_Returns_First_Control_In_Next_Sibling_Container()
{
StackPanel container;
Button current;
@ -80,13 +80,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Continue_Returns_Next_Sibling()
public void Next_Continue_Returns_Next_Sibling()
{
StackPanel container;
Button current;
@ -109,13 +109,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Continue_Returns_First_Control_In_Next_Uncle_Container()
public void Next_Continue_Returns_First_Control_In_Next_Uncle_Container()
{
StackPanel container;
Button current;
@ -152,13 +152,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Continue_Returns_Child_Of_Top_Level()
public void Next_Continue_Returns_Child_Of_Top_Level()
{
Button next;
@ -170,13 +170,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(top);
var result = KeyboardNavigationHandler.GetNext(top, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Continue_Wraps()
public void Next_Continue_Wraps()
{
StackPanel container;
Button current;
@ -213,13 +213,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Cycle_Returns_Next_Control_In_Container()
public void Next_Cycle_Returns_Next_Control_In_Container()
{
StackPanel container;
Button current;
@ -251,13 +251,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Cycle_Wraps_To_First()
public void Next_Cycle_Wraps_To_First()
{
StackPanel container;
Button current;
@ -289,13 +289,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Contained_Returns_Next_Control_In_Container()
public void Next_Contained_Returns_Next_Control_In_Container()
{
StackPanel container;
Button current;
@ -327,13 +327,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Contained_Stops_At_End()
public void Next_Contained_Stops_At_End()
{
StackPanel container;
Button current;
@ -365,13 +365,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Null(result);
}
[Fact]
public void GetNextInTabOrder_Once_Moves_To_Next_Container()
public void Next_Once_Moves_To_Next_Container()
{
StackPanel container;
Button current;
@ -403,13 +403,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Once_Moves_To_Active_Element()
public void Next_Once_Moves_To_Active_Element()
{
StackPanel container;
Button current;
@ -443,13 +443,13 @@ namespace Perspex.Input.UnitTests
KeyboardNavigation.SetTabOnceActiveElement(container, next);
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Never_Moves_To_Next_Container()
public void Next_Never_Moves_To_Next_Container()
{
StackPanel container;
Button current;
@ -481,13 +481,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetNextInTabOrder_Never_Skips_Container()
public void Next_Never_Skips_Container()
{
StackPanel container;
Button current;
@ -521,13 +521,13 @@ namespace Perspex.Input.UnitTests
KeyboardNavigation.SetTabOnceActiveElement(container, next);
var result = KeyboardNavigationHandler.GetNextInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Next);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Continue_Returns_Previous_Control_In_Container()
public void Previous_Continue_Returns_Previous_Control_In_Container()
{
StackPanel container;
Button current;
@ -558,13 +558,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Continue_Returns_Last_Control_In_Previous_Sibling_Container()
public void Previous_Continue_Returns_Last_Control_In_Previous_Sibling_Container()
{
StackPanel container;
Button current;
@ -595,13 +595,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Continue_Returns_Last_Child_Of_Sibling()
public void Previous_Continue_Returns_Last_Child_Of_Sibling()
{
StackPanel container;
Button current;
@ -624,13 +624,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Continue_Returns_Last_Control_In_Previous_Nephew_Container()
public void Previous_Continue_Returns_Last_Control_In_Previous_Nephew_Container()
{
StackPanel container;
Button current;
@ -667,13 +667,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Continue_Wraps()
public void Previous_Continue_Wraps()
{
StackPanel container;
Button current;
@ -710,13 +710,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Cycle_Returns_Previous_Control_In_Container()
public void Previous_Cycle_Returns_Previous_Control_In_Container()
{
StackPanel container;
Button current;
@ -748,13 +748,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Cycle_Wraps_To_Last()
public void Previous_Cycle_Wraps_To_Last()
{
StackPanel container;
Button current;
@ -786,13 +786,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Contained_Returns_Previous_Control_In_Container()
public void Previous_Contained_Returns_Previous_Control_In_Container()
{
StackPanel container;
Button current;
@ -824,13 +824,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Contained_Stops_At_Beginning()
public void Previous_Contained_Stops_At_Beginning()
{
StackPanel container;
Button current;
@ -862,13 +862,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Null(result);
}
[Fact]
public void GetPreviousInTabOrder_Once_Moves_To_Previous_Container()
public void Previous_Once_Moves_To_Previous_Container()
{
StackPanel container;
Button current;
@ -900,13 +900,13 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Once_Moves_To_Active_Element()
public void Previous_Once_Moves_To_Active_Element()
{
StackPanel container;
Button current;
@ -940,13 +940,13 @@ namespace Perspex.Input.UnitTests
KeyboardNavigation.SetTabOnceActiveElement(container, next);
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}
[Fact]
public void GetPreviousInTabOrder_Once_Moves_To_First_Element()
public void Previous_Once_Moves_To_First_Element()
{
StackPanel container;
Button current;
@ -978,7 +978,7 @@ namespace Perspex.Input.UnitTests
}
};
var result = KeyboardNavigationHandler.GetPreviousInTabOrder(current);
var result = KeyboardNavigationHandler.GetNext(current, FocusNavigationDirection.Previous);
Assert.Equal(next, result);
}

Write Preview
Loading…
Cancel
Save