/// <summary>
/// Returns a value indicting whether the specified direction is forward.
/// </summary>
/// <param name="direction">The direction.</param>
/// <returns>True if the direction is forward.</returns>
private static bool IsForward(NavigationDirection direction)
{
return direction == NavigationDirection.Next ||
direction == NavigationDirection.Last ||
direction == NavigationDirection.Right ||
direction == NavigationDirection.Down;
}
/// <summary>
/// Gets the next control in the specified navigation direction.
/// </summary>
/// <param name="element">The element.</param>
/// <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 the requested direction.
/// </returns>
public static IInputElement GetNext(
IInputElement element,
NavigationDirection direction)
{
Contract.Requires<ArgumentNullException>(element != null);
Contract.Requires<ArgumentException>(
direction != NavigationDirection.Next &&
direction != NavigationDirection.Previous);
var container = element.GetVisualParent<IInputElement>();
if (container != null)
{
var mode = KeyboardNavigation.GetDirectionalNavigation((InputElement)container);
switch (mode)
{
case KeyboardNavigationMode.Continue:
return GetNextInContainer(element, container, direction) ??
GetFirstInNextContainer(element, direction);
case KeyboardNavigationMode.Cycle:
return GetNextInContainer(element, container, direction) ??
GetFocusableDescendent(container, direction);
case KeyboardNavigationMode.Contained:
return GetNextInContainer(element, container, direction);
default:
return null;
}
}
else
{
return GetFocusableDescendents(element).FirstOrDefault();
}
}
private void OnNavigationRequested(NavigationDirection navigationDirection)
{
if (NavigationRequested != null)
{
NavigationRequested(this, new NavigationRequestedEventArgs(navigationDirection));
}
}
private int _flags; // bitwise combination of constants above
/// <summary>
/// Construct a ProcessKeyResult structure with the given action
/// </summary>
/// <param name="action"></param>
internal ProcessKeyResult(KeyAction action)
{
_columnType = null;
_branchType = null;
_flags = LOCAL;
_treeNav = NavigationDirection.Right;
_action = action;
}
private void Navigate (string current, string to, NavigationDirection direction)
{
_direction = direction;
if (direction == NavigationDirection.Child)
_parentHistory.Push(current);
else
_childHistory.Push(current);
_setSelectedRevision(to);
_direction = null;
}
public void ChangeFile(NavigationDirection navigationDirection)
{
if (navigationDirection == NavigationDirection.Forward)
{
MoveForward();
}
else
{
MoveBackward();
}
OnFileNameChanged();
}
/// <summary>
/// Gets the next control in the specified navigation direction.
/// </summary>
/// <param name="element">The element.</param>
/// <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,
NavigationDirection direction)
{
Contract.Requires<ArgumentNullException>(element != null);
if (direction == NavigationDirection.Next || direction == NavigationDirection.Previous)
{
return TabNavigation.GetNextInTabOrder(element, direction);
}
else
{
return DirectionalNavigation.GetNext(element, direction);
}
}
/// <summary>
/// Moves the focus in the specified direction.
/// </summary>
/// <param name="element">The current element.</param>
/// <param name="direction">The direction to move.</param>
/// <param name="modifiers">Any input modifiers active at the time of focus.</param>
public void Move(
IInputElement element,
NavigationDirection direction,
InputModifiers modifiers = InputModifiers.None)
{
Contract.Requires<ArgumentNullException>(element != null);
var next = GetNext(element, direction);
if (next != null)
{
var method = direction == NavigationDirection.Next ||
direction == NavigationDirection.Previous ?
NavigationMethod.Tab : NavigationMethod.Directional;
FocusManager.Instance.Focus(next, method, modifiers);
}
}
/// <summary>
/// Gets the next control in the specified direction.
/// </summary>
/// <param name="direction">The movement direction.</param>
/// <param name="from">The control from which movement begins.</param>
/// <returns>The control.</returns>
IInputElement INavigableContainer.GetControl(NavigationDirection direction, IInputElement from)
{
var horiz = Orientation == Orientation.Horizontal;
int index = Children.IndexOf((IControl)from);
switch (direction)
{
case NavigationDirection.First:
index = 0;
break;
case NavigationDirection.Last:
index = Children.Count - 1;
break;
case NavigationDirection.Next:
++index;
break;
case NavigationDirection.Previous:
--index;
break;
case NavigationDirection.Left:
index = horiz ? index - 1 : -1;
break;
case NavigationDirection.Right:
index = horiz ? index + 1 : -1;
break;
case NavigationDirection.Up:
index = horiz ? -1 : index - 1;
break;
case NavigationDirection.Down:
index = horiz ? -1 : index + 1;
break;
}
if (index >= 0 && index < Children.Count)
{
return Children[index];
}
else
{
return null;
}
}
/// <summary>
/// Check that the current page is synchronised with the XCore navigation framework
/// They can get our of wack as navigation can be kicked off by things outside the framework
/// ... like the default back button in the NavigationPage
/// </summary>
/// <param name="direction"></param>
void _synchroniseNavigation(NavigationDirection direction)
{
//var page = _rootElement.Content as XPage;
//if (page != null && page.DataContext != null)
//{
// if (page.DataContext != _xNavigation.CurrentContentObject)
// {
// if (direction == NavigationDirection.Back)
// {
// _rootFrame.NavigateBack();
// }
// else
// {
// _rootFrame.NavigateTo(page.DataContext);
// }
// }
//}
}
protected override IInputElement GetControlInDirection(NavigationDirection direction, IControl from)
{
var logicalScrollable = Parent as ILogicalScrollable;
var fromControl = from as IControl;
if (logicalScrollable?.IsLogicalScrollEnabled == true && fromControl != null)
{
return logicalScrollable.GetControlInDirection(direction, fromControl);
}
else
{
return base.GetControlInDirection(direction, from);
}
}
/// <inheritdoc/> bool IMenuElement.MoveSelection(NavigationDirection direction, bool wrap) => MoveSelection(direction, wrap);
/// <inheritdoc/>
IControl ILogicalScrollable.GetControlInDirection(NavigationDirection direction, IControl from)
{
return _virtualizer?.GetControlInDirection(direction, from);
}
public IControl GetControlInDirection(NavigationDirection direction, IControl from)
{
return(null);
}
/// <summary>
/// Gets the next control in the specified direction.
/// </summary>
/// <param name="direction">The movement direction.</param>
/// <param name="from">The control from which movement begins.</param>
/// <returns>The control.</returns>
public virtual IControl GetControlInDirection(NavigationDirection direction, IControl from)
{
return null;
}
public NavigationRequestedEventArgs(NavigationDirection direction)
{
Direction = direction;
}
public XNavigationEventArgs(NavigationDirection direction)
{
_direction = direction;
}
private static CodeExpression GetRefreshLink(string key, NavigationDirection direction)
{
CodeMethodInvokeExpression navigationLink = new CodeMethodInvokeExpression();
navigationLink.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(StateController), CodeTypeReferenceOptions.GlobalReference)), "GetRefreshLink");
if (key.Length != 0)
{
CodePropertyReferenceExpression state = new CodePropertyReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(StateContext), CodeTypeReferenceOptions.GlobalReference)), "State");
CodeMethodInvokeExpression parseNavigationData = new CodeMethodInvokeExpression();
parseNavigationData.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(StateInfoConfig), CodeTypeReferenceOptions.GlobalReference)), "ParseNavigationDataExpression");
parseNavigationData.Parameters.Add(new CodePrimitiveExpression(key));
parseNavigationData.Parameters.Add(state);
parseNavigationData.Parameters.Add(new CodePrimitiveExpression(true));
navigationLink.Parameters.Add(parseNavigationData);
}
else
{
navigationLink.Parameters.Add(new CodePrimitiveExpression(null));
}
return navigationLink;
}
private static CodeExpression GetNavigationBackLink(string key, NavigationDirection direction, ControlBuilder controlBuilder, CodeLinePragma linePragma)
{
CodeMethodInvokeExpression navigationLink = new CodeMethodInvokeExpression();
navigationLink.Method = new CodeMethodReferenceExpression(new CodeTypeReferenceExpression(new CodeTypeReference(typeof(StateController), CodeTypeReferenceOptions.GlobalReference)), "GetNavigationBackLink");
try
{
navigationLink.Parameters.Add(new CodePrimitiveExpression(Convert.ToInt32(key, CultureInfo.CurrentCulture)));
}
catch (FormatException)
{
throw new HttpParseException(string.Format(CultureInfo.CurrentCulture, Resources.InvalidDistanceString, key), null, controlBuilder.PageVirtualPath, null, linePragma.LineNumber);
}
catch (OverflowException)
{
throw new HttpParseException(string.Format(CultureInfo.CurrentCulture, Resources.InvalidDistanceString, key), null, controlBuilder.PageVirtualPath, null, linePragma.LineNumber);
}
return navigationLink;
}
/// <summary>
/// Gets the next control in the specified direction.
/// </summary>
/// <param name="direction">The movement direction.</param>
/// <param name="from">The control from which movement begins.</param>
/// <returns>The control.</returns>
public IControl GetControlInDirection(NavigationDirection direction, IControl from)
{
throw new NotImplementedException();
}
/// <summary>
/// Initiate a navigation interaction in the <see cref="NavigationDirection"/> given as parameter
/// </summary>
/// <param name="direction"><see cref="NavigationDirection"/> for the interaction</param>
private void NavigationInteraction(NavigationDirection direction)
{
presenter.NavigationInteraction(gameObject, direction);
}
public bool TryGetMenuNeighbor(NavigationDirection Direction, out IGamepadControllable Neighbor)
{
return(MenuNeighbors.TryGetValue(Direction, out Neighbor));
}
public bool TryGetSlotNeighbor(Rectangle?ItemSlot, NavigationDirection Direction, NavigationWrappingMode HorizontalWrapping, NavigationWrappingMode VerticalWrapping, out Rectangle?Neighbor)
{
return(GamepadControls.TryGetSlotNeighbor(SlotBounds, ItemSlot, ColumnCount, Direction, HorizontalWrapping, VerticalWrapping, out Neighbor));
}
public IControl GetControlInDirection(NavigationDirection direction, IControl from)
{
throw new NotImplementedException();
}
internal void MoveSelection(NavigationDirection direction)
{
if (root == null || !root.Any())
return;
var selectedCategory = root.ElementAt(selectedCategoryIndex);
var selectedMemberGroup = selectedCategory.MemberGroups.ElementAt(selectedMemberGroupIndex);
// Clear the current selection, no matter what.
CurrentSelection.IsSelected = false;
if (direction == NavigationDirection.Backward)
{
if (selectedMemberIndex != 0)
{
selectedMemberIndex--;
}
else
{
if (selectedMemberGroupIndex != 0)
{
selectedMemberGroupIndex--;
// Select last member of new member group.
var category = root.ElementAt(selectedCategoryIndex);
var group = category.MemberGroups.ElementAt(selectedMemberGroupIndex);
selectedMemberIndex = group.Members.Count() - 1;
}
else
{
if (selectedCategoryIndex != 0)
{
selectedCategoryIndex--;
// Select last group and last member of this group.
var category = root.ElementAt(selectedCategoryIndex);
selectedMemberGroupIndex = category.MemberGroups.Count() - 1;
var group = category.MemberGroups.ElementAt(selectedMemberGroupIndex);
selectedMemberIndex = group.Members.Count() - 1;
}
}
}
}
else
{
// Determine the current group size.
var members = selectedMemberGroup.Members.Count();
if (selectedMemberIndex < members - 1) // There's still next member.
{
selectedMemberIndex++;
}
else
{
var memberGroups = root.ElementAt(selectedCategoryIndex).MemberGroups.Count();
if (selectedMemberGroupIndex < memberGroups - 1) // There's still next group.
{
selectedMemberIndex = 0;
selectedMemberGroupIndex++;
}
else if (selectedCategoryIndex < root.Count() - 1) // There's still next category.
{
selectedMemberIndex = 0;
selectedMemberGroupIndex = 0;
selectedCategoryIndex++;
}
}
}
// Get the new selection and mark it as selected.
CurrentSelection.IsSelected = true;
}
private void Navigate (NavigationDirection direction)
{
int index = -1;
switch (direction)
{
case NavigationDirection.Left:
if (Loop && Layout.Loop) {
index = (SelectedIndex <= 0) ? Items.Count - 1 : SelectedIndex - 1;
} else {
index = Math.Max(-1, SelectedIndex - 1);
}
break;
case NavigationDirection.Right:
if (Loop && Layout.Loop) {
index = (SelectedIndex >= Items.Count - 1) ? 0 : SelectedIndex + 1;
} else {
index = Math.Min(Items.Count - 1, SelectedIndex + 1);
}
break;
case NavigationDirection.Up:
break;
case NavigationDirection.Down:
break;
}
if (index != -1)
{
SelectedIndex = index;
}
}
public override IControl GetControlInDirection(NavigationDirection direction, IControl from)
{
var generator = Owner.ItemContainerGenerator;
var panel = VirtualizingPanel;
var itemIndex = generator.IndexFromContainer(from);
var vertical = VirtualizingPanel.ScrollDirection == Orientation.Vertical;
if (itemIndex == -1)
{
return null;
}
var newItemIndex = -1;
switch (direction)
{
case NavigationDirection.First:
newItemIndex = 0;
break;
case NavigationDirection.Last:
newItemIndex = ItemCount - 1;
break;
case NavigationDirection.Up:
if (vertical)
{
newItemIndex = itemIndex - 1;
}
break;
case NavigationDirection.Down:
if (vertical)
{
newItemIndex = itemIndex + 1;
}
break;
case NavigationDirection.Left:
if (!vertical)
{
newItemIndex = itemIndex - 1;
}
break;
case NavigationDirection.Right:
if (!vertical)
{
newItemIndex = itemIndex + 1;
}
break;
case NavigationDirection.PageUp:
newItemIndex = Math.Max(0, itemIndex - (int)ViewportValue);
break;
case NavigationDirection.PageDown:
newItemIndex = Math.Min(ItemCount - 1, itemIndex + (int)ViewportValue);
break;
}
return ScrollIntoView(newItemIndex);
}
private static PageTransitionState CalculateTransitionState(bool isCurrentPage, bool wasCurrentPage, bool isNavigating, NavigationDirection navigationDirection)
{
if (isNavigating && (isCurrentPage || wasCurrentPage))
{
if (navigationDirection == NavigationDirection.Forward)
{
if (isCurrentPage)
{
return(PageTransitionState.NavigatingToForward);
}
return(PageTransitionState.NavigatingAwayForward);
}
if (isCurrentPage)
{
return(PageTransitionState.NavigatingToBackward);
}
return(PageTransitionState.NavigatingAwayBackward);
}
if (isCurrentPage)
{
return(PageTransitionState.IdleActive);
}
return(PageTransitionState.IdleInactive);
}
public override IControl GetControlInDirection(NavigationDirection direction, IControl from)
{
var generator = Owner.ItemContainerGenerator;
var panel = VirtualizingPanel;
var itemIndex = generator.IndexFromContainer(from);
var vertical = VirtualizingPanel.ScrollDirection == Orientation.Vertical;
if (itemIndex == -1)
{
return(null);
}
var newItemIndex = -1;
switch (direction)
{
case NavigationDirection.First:
newItemIndex = 0;
break;
case NavigationDirection.Last:
newItemIndex = ItemCount - 1;
break;
case NavigationDirection.Up:
if (vertical)
{
newItemIndex = itemIndex - 1;
}
break;
case NavigationDirection.Down:
if (vertical)
{
newItemIndex = itemIndex + 1;
}
break;
case NavigationDirection.Left:
if (!vertical)
{
newItemIndex = itemIndex - 1;
}
break;
case NavigationDirection.Right:
if (!vertical)
{
newItemIndex = itemIndex + 1;
}
break;
case NavigationDirection.PageUp:
newItemIndex = Math.Max(0, itemIndex - (int)ViewportValue);
break;
case NavigationDirection.PageDown:
newItemIndex = Math.Min(ItemCount - 1, itemIndex + (int)ViewportValue);
break;
}
return(ScrollIntoView(newItemIndex));
}
private static PageTransitionState CalculateTransitionState(bool isCurrentPage, bool wasCurrentPage, bool isNavigating, NavigationDirection navigationDirection)
{
if (isNavigating && (isCurrentPage || wasCurrentPage))
{
if (navigationDirection == NavigationDirection.Forward)
{
if (isCurrentPage)
{
return PageTransitionState.NavigatingToForward;
}
return PageTransitionState.NavigatingAwayForward;
}
if (isCurrentPage)
{
return PageTransitionState.NavigatingToBackward;
}
return PageTransitionState.NavigatingAwayBackward;
}
if (isCurrentPage)
{
return PageTransitionState.IdleActive;
}
return PageTransitionState.IdleInactive;
}
public DateChangingEventArgs(NavigationDirection direction,
DateTime oldStartDate, DateTime oldEndDate, DateTime newStartDate, DateTime newEndDate)
: base(direction, oldStartDate, oldEndDate, newStartDate, newEndDate)
{
}
//if nav up, folderId doesn't matter
private void NavigateTo(string folderId, string folderPathName, NavigationDirection navDirection, bool directCall)
{
if (IsBusy())
return;
switch (navDirection)
{
case NavigationDirection.LevelDown:
if (folderId == null)
return;
_navState.LevelDown(folderId, folderPathName);
break;
case NavigationDirection.LevelUp:
if (_navState.LevelUp() == null)
return;
break;
}
FetchEntries(directCall);
}
public DateChangedEventArgs(NavigationDirection direction,
DateTime oldStartDate, DateTime oldEndDate, DateTime newStartDate, DateTime newEndDate)
{
_Direction = direction;
_OldStartDate = oldStartDate;
_OldEndDate = oldEndDate;
_NewStartDate = newStartDate;
_NewEndDate = newEndDate;
}
/// <summary>
/// Initializes an instance of PageNavigatedEventArgs<TPage> class.
/// </summary>
/// <param name="from">Navigation origin.</param>
/// <param name="to">Navigation destination.</param>
/// <param name="direction">Navigation direction.</param>
public PageNavigatedEventArgs(TPage from, TPage to, NavigationDirection direction)
{
From = from;
To = to;
Direction = direction;
}
private static TreeNavigation TranslateNavigationDirection(NavigationDirection treeNav)
{
switch (treeNav)
{
case NavigationDirection.Left:
return TreeNavigation.LeftColumn;
case NavigationDirection.Right:
return TreeNavigation.RightColumn;
case NavigationDirection.Up:
return TreeNavigation.Up;
case NavigationDirection.Down:
return TreeNavigation.Down;
}
return default(TreeNavigation);
}
/// <summary>
/// Used during library search key navigation. Counts next selected member index.
/// </summary>
public void MoveSelection(NavigationDirection direction)
{
selectionNavigator.MoveSelection(direction);
}
/// <summary>
/// Gets the next control in the specified direction.
/// </summary>
/// <param name="direction">The movement direction.</param>
/// <param name="from">The control from which movement begins.</param>
/// <returns>The control.</returns>
protected virtual IInputElement GetControlInDirection(NavigationDirection direction, IControl from)
{
var horiz = Orientation == Orientation.Horizontal;
int index = from != null?Children.IndexOf(from) : -1;
switch (direction)
{
case NavigationDirection.First:
index = 0;
break;
case NavigationDirection.Last:
index = Children.Count - 1;
break;
case NavigationDirection.Next:
if (index != -1)
{
++index;
}
break;
case NavigationDirection.Previous:
if (index != -1)
{
--index;
}
break;
case NavigationDirection.Left:
if (index != -1)
{
index = horiz ? index - 1 : -1;
}
break;
case NavigationDirection.Right:
if (index != -1)
{
index = horiz ? index + 1 : -1;
}
break;
case NavigationDirection.Up:
if (index != -1)
{
index = horiz ? -1 : index - 1;
}
break;
case NavigationDirection.Down:
if (index != -1)
{
index = horiz ? -1 : index + 1;
}
break;
default:
index = -1;
break;
}
if (index >= 0 && index < Children.Count)
{
return(Children[index]);
}
else
{
return(null);
}
}
private bool DoDateChanging(NavigationDirection direction,
DateTime oldStartDate, DateTime oldEndDate, ref DateTime newStartDate, ref DateTime newEndDate)
{
if (DateChanging != null)
{
DateChangingEventArgs ev = new DateChangingEventArgs(
direction, oldStartDate, oldEndDate, newStartDate, newEndDate);
DateChanging(this, ev);
if (ev.Cancel == true)
return (true);
newStartDate = ev.NewStartDate;
newEndDate = ev.NewEndDate;
}
return (false);
}
private void DoDateChanged(NavigationDirection direction,
DateTime oldStartDate, DateTime oldEndDate, DateTime newStartDate, DateTime newEndDate)
{
if (DateChanged != null)
{
DateChangedEventArgs ev = new DateChangedEventArgs(
direction, oldStartDate, oldEndDate, newStartDate, newEndDate);
DateChanged(this, ev);
}
}
public int getNavigatedDocumentIndex(NavigationDirection direction)
{
if (files.Count == 0) return -1;
if (direction == NavigationDirection.Next)
{
fileIndex++;
if (fileIndex >= files.Count)
fileIndex = 0;
}
else
{
fileIndex--;
if (fileIndex < 0)
fileIndex = files.Count - 1;
}
return fileIndex;
}
internal static bool IsNavigationButtonPressed(NavigationDirection Direction)
{
return(NavigationButtonsPressedTime != null && NavigationButtonsPressedTime.TryGetValue(Direction, out DateTime Time));
}
