public override View GetNextFocusableView(View current, View proposed, View.FocusDirection direction) { if (_customFocusAlgorithm == null) { Tizen.Log.Error("NUI", $"[ERROR] User defined ICustomFocusAlgorithm interface class becomes unreachable. Null will be proposed for next focusing!"); return(null); } return(_customFocusAlgorithm.GetNextFocusableView(current, proposed, direction)); }
public virtual View GetNextFocusableView(View current, View proposed, View.FocusDirection direction) { View ret = new View(Interop.CustomAlgorithmInterface.CustomAlgorithmInterface_GetNextFocusableActor(swigCPtr, View.getCPtr(current), View.getCPtr(proposed), (int)direction), true); if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
/// <summary> /// Moves the focus to the next focusable view in the focus chain in the given direction (according to the focus traversal order). /// </summary> /// <param name="direction">The direction of the focus movement.</param> /// <returns>True if the movement was successful.</returns> /// <since_tizen> 3 </since_tizen> public bool MoveFocus(View.FocusDirection direction) { bool ret = NDalicManualPINVOKE.FocusManager_MoveFocus(swigCPtr, (int)direction); if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public View Emit(View arg1, View arg2, View.FocusDirection arg3) { View ret = new View(Interop.PreFocusSignal.PreFocusChangeSignal_Emit(swigCPtr, View.getCPtr(arg1), View.getCPtr(arg2), (int)arg3), true); if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public virtual int GetNextFocusItemID(int itemID, int maxItems, View.FocusDirection direction, bool loopEnabled) { int ret = Interop.ItemLayout.ItemLayout_GetNextFocusItemID(swigCPtr, itemID, maxItems, (int)direction, loopEnabled); if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
/// <summary> /// Show a icon or a new view /// </summary> /// <param name="show">Is show or not</param> /// <param name="direction">direction</param> /// <returns> /// If showing, return the icon that will be shown for KeyboardFocusManager. /// else return a new view. /// </returns> public View Show(bool show, View.FocusDirection direction) { _active = show; _systemMenuAnimation.Clear(); float moveDelta = Constants.SystemMenuWidth; float scaleDelta = 1.0f + (moveDelta / Constants.SystemMenuWidth); AlphaFunction alphaFunction; if (show) { alphaFunction = new AlphaFunction(AlphaFunction.BuiltinFunctions.EaseInOutSine); } else { alphaFunction = new AlphaFunction(AlphaFunction.BuiltinFunctions.EaseOutSine); } _systemMenuAnimation.AnimateTo(_menu, "ScaleX", show ? scaleDelta : 1.0f, alphaFunction); for (int i = 0; i < _systemIcons.Length; ++i) { Position targetPosition = GetSystemIconPosition(i, show); _systemMenuAnimation.AnimateTo(_systemIcons[i], "Scale", show ? new Vector3(1.0f, 1.0f, 1.0f) : new Vector3(0.5f, 0.5f, 0.5f), alphaFunction); _systemMenuAnimation.AnimateTo(_systemIcons[i], "Position", targetPosition, alphaFunction); if (show) { //todor comment targetPosition.X += ((((Constants.SystemMenuWidth * scaleDelta) / 2.0f) - (Constants.SystemMenuWidth / 2.0f)) / scaleDelta); } _systemMenuAnimation.AnimateTo(_systemStencilIcons[i], "Scale", show ? new Vector3(1.0f, 1.0f, 1.0f) : new Vector3(0.5f, 0.5f, 0.5f), alphaFunction); _systemMenuAnimation.AnimateTo(_systemStencilIcons[i], "Position", targetPosition, alphaFunction); } _systemMenuAnimation.Play(); MoveSelector(false, false, direction); if (show) { // If showing, return the icon that will be shown for KeyboardFocusManager. return(_systemIcons[_focusedIcon]); } return(new View()); }
/// <summary> /// This override function supports two dimensional keyboard navigation. /// This function returns the next keyboard focusable actor in ScrollMenu control towards the given direction. /// </summary> /// <param name="currentFocusedView"> the current focused view</param> /// <param name="direction">the direction of the focus move</param> /// <param name="loopEnabled">the focus in scrollmenu is loop enabled or not</param> /// <returns>next focusable view or current focused view</returns> public override View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { if (direction == View.FocusDirection.Left) { return(FocusPrevious(loopEnabled)); } else if (direction == View.FocusDirection.Right) { return(FocusNext(loopEnabled)); } else { return(currentFocusedView); } }
private View A1_PreFocusChange(object o, FocusManager.PreFocusChangeEventArgs e) { View v1 = e.CurrentView; e.CurrentView = v1; View v2 = e.ProposedView; e.ProposedView = v2; View.FocusDirection b1 = e.Direction; e.Direction = b1; return(v1); }
public override View RequestNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { if (currentFocusedView == null) { throw new ArgumentNullException(nameof(currentFocusedView)); } View nextFocusedView = null; int targetSibling = -1; switch (direction) { case View.FocusDirection.Left: { targetSibling = IsHorizontal ? currentFocusedView.SiblingOrder - 1 : targetSibling; break; } case View.FocusDirection.Right: { targetSibling = IsHorizontal ? currentFocusedView.SiblingOrder + 1 : targetSibling; break; } case View.FocusDirection.Up: { targetSibling = IsHorizontal ? targetSibling : currentFocusedView.SiblingOrder - 1; break; } case View.FocusDirection.Down: { targetSibling = IsHorizontal ? targetSibling : currentFocusedView.SiblingOrder + 1; break; } } if (targetSibling > -1 && targetSibling < Container.Children.Count) { RecyclerViewItem candidate = Container.Children[targetSibling] as RecyclerViewItem; if (candidate.Index >= 0 && candidate.Index < colView.InternalItemSource.Count) { nextFocusedView = candidate; } } return(nextFocusedView); }
public override View GetNextFocusableView(View current, View proposed, View.FocusDirection direction, string deviceName) { if (customFocusAlgorithm == null) { Tizen.Log.Error("NUI", $"[ERROR] User defined ICustomFocusAlgorithm interface class becomes unreachable. Null will be proposed for next focusing!"); return(null); } if (customFocusAlgorithm is ICustomAwareDeviceFocusAlgorithm deviceAwared) { return(deviceAwared.GetNextFocusableView(current, proposed, direction, deviceName)); } else { return(customFocusAlgorithm.GetNextFocusableView(current, proposed, direction)); } }
public override View RequestNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { View nextFocusedView = null; int targetSibling = -1; bool isHorizontal = LayoutOrientation == Orientation.Horizontal; switch (direction) { case View.FocusDirection.Left: { targetSibling = isHorizontal ? currentFocusedView.SiblingOrder - 1 : targetSibling; break; } case View.FocusDirection.Right: { targetSibling = isHorizontal ? currentFocusedView.SiblingOrder + 1 : targetSibling; break; } case View.FocusDirection.Up: { targetSibling = isHorizontal ? targetSibling : currentFocusedView.SiblingOrder - 1; break; } case View.FocusDirection.Down: { targetSibling = isHorizontal ? targetSibling : currentFocusedView.SiblingOrder + 1; break; } } if (targetSibling > -1 && targetSibling < Container.Children.Count) { RecycleItem candidate = Container.Children[targetSibling] as RecycleItem; if (candidate != null && candidate.DataIndex >= 0 && candidate.DataIndex < DataCount) { nextFocusedView = candidate; } } return(nextFocusedView); }
/// <summary> /// Overrides the method of GetNextKeyboardFocusableView() for the CustomView class.<br /> /// Gets the next key focusable view in this view towards the given direction.<br /> /// A view needs to override this function in order to support two-dimensional key navigation.<br /> /// </summary> /// <param name="currentFocusedView">The current focused view.</param> /// <param name="direction">The direction to move the focus towards.</param> /// <param name="loopEnabled">Whether the focus movement should be looped within the control.</param> /// <returns>The next keyboard focusable view in this control or an empty handle if no view can be focused.</returns> /// <since_tizen> 3 </since_tizen> public override View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { // Respond to Up/Down keys to change the value while keeping the current spin focused View nextFocusedView = currentFocusedView; if (direction == View.FocusDirection.Up) { this.Value += this.Step; nextFocusedView = textField; } else if (direction == View.FocusDirection.Down) { this.Value -= this.Step; nextFocusedView = textField; } else { // Return null return(null); } return(nextFocusedView); }
public override View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { if (currentFocusedView == hourPicker) { if (direction == View.FocusDirection.Right) { return(minutePicker); } else if (direction == View.FocusDirection.Left) { return(null); } } else if (currentFocusedView == minutePicker) { if (direction == View.FocusDirection.Right) { return(ampmPicker); } else if (direction == View.FocusDirection.Left) { return(hourPicker); } } else if (currentFocusedView == ampmPicker) { if (direction == View.FocusDirection.Right) { return(null); } else if (direction == View.FocusDirection.Left) { return(minutePicker); } } return(null); }
public override View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { if (currentFocusedView == yearPicker) { if (direction == View.FocusDirection.Right) { return(monthPicker); } else if (direction == View.FocusDirection.Left) { return(null); } } else if (currentFocusedView == monthPicker) { if (direction == View.FocusDirection.Right) { return(dayPicker); } else if (direction == View.FocusDirection.Left) { return(yearPicker); } } else if (currentFocusedView == dayPicker) { if (direction == View.FocusDirection.Right) { return(null); } else if (direction == View.FocusDirection.Left) { return(monthPicker); } } return(null); }
private IntPtr OnPreFocusChange(IntPtr current, IntPtr proposed, View.FocusDirection direction) { View view = null; PreFocusChangeEventArgs e = new PreFocusChangeEventArgs(); if (current != global::System.IntPtr.Zero) { e.CurrentView = Registry.GetManagedBaseHandleFromNativePtr(current) as View; } if (proposed != global::System.IntPtr.Zero) { e.ProposedView = Registry.GetManagedBaseHandleFromNativePtr(proposed) as View; } e.Direction = direction; if (preFocusChangeEventHandler != null) { view = preFocusChangeEventHandler(this, e); } if (view != null) { return(view.GetPtrfromView()); } else { if (e.ProposedView != null) { return(proposed); } else { return(current); } } }
public virtual View RequestNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { return(null); }
// This method is called when a direction key is pressed. public View GetNextFocusableView(View current, View proposed, View.FocusDirection direction, string deviceName) { Tizen.Log.Error("NUI", $" GetNextFocusableView deviceName {deviceName}\n"); return(proposed); }
public override View GetNextFocusableView(View current, View proposed, View.FocusDirection direction) { return(_customFocusAlgorithm.GetNextFocusableView(current, proposed, direction)); }
// This method is never called. public View GetNextFocusableView(View current, View proposed, View.FocusDirection direction) { Tizen.Log.Error("NUI", $" GetNextFocusableView \n"); return(proposed); }
public override View GetNextFocusableView(View current, View proposed, View.FocusDirection direction) { return(base.GetNextFocusableView(current, proposed, direction)); }
/// <summary> /// Move selector to certain direction /// </summary> /// <param name="moveOnly">whether only move</param> /// <param name="instant">Whether instant,default is false</param> /// <param name="direction">move direction</param> private void MoveSelector(bool moveOnly, bool instant = false, View.FocusDirection direction = View.FocusDirection.Right) { int targetIconPosition = _focusedIcon; int viewIcon = targetIconPosition; int showSelectorStartTime = 0; bool delaySelectorPositionChange = false; if (!moveOnly) { switch (direction) { case View.FocusDirection.Left: { if (_active) { _focusedIcon = _maxIconIndex; targetIconPosition = _focusedIcon; } break; } case View.FocusDirection.Right: { if (!_active) { targetIconPosition = _maxIconIndex + 1; _focusedIcon = -1; } break; } case View.FocusDirection.Up: { if (!_active) { instant = true; targetIconPosition = _maxIconIndex + 1; } break; } case View.FocusDirection.Down: { if (_active) { if (_focusedIcon == -1) { _focusedIcon = _maxIconIndex; targetIconPosition = _focusedIcon; } showSelectorStartTime = Constants.SystemMenuAnimationDuration; delaySelectorPositionChange = true; } break; } } viewIcon = _focusedIcon; if (viewIcon > _maxIconIndex) { viewIcon = _maxIconIndex; } if (viewIcon == -1) { viewIcon = 0; } } float selectorWidth = (Constants.SystemMenuWidth / (float)_systemIcons.Length); float iconX = _active ? (Constants.SystemMenuWidth / (float)_systemIcons.Length) * (float)(targetIconPosition - (_systemIcons.Length / 2)) : (Constants.SystemMenuWidth - selectorWidth); int startTime = 0; _systemSelectorAnimation.Clear(); // Handle the selector color & transparency. if (instant) { // We are hiding instantly, set the color to transparent and set the position directly (without animating). _systemSelectorColor.Color = new Color(1.0f, 1.0f, 1.0f, 0.0f); _systemSelector.PositionX = iconX; } else { // We animate the fade if we are showing, or if we are hiding *gradually* - IE. not moving the position instantly. Color targetColor = _active ? _systemSelectorColors[viewIcon] : new Color(1.0f, 1.0f, 0.0f, 0.0f); // We set the endtime to starttime + duration so, if necessary, the selector animation can start *after* the menu animation ends _systemSelectorAnimation = _systemSelector.AnimateVisual(_systemSelectorColor, "mixColor", targetColor, showSelectorStartTime, showSelectorStartTime + Constants.SystemMenuAnimationDuration, AlphaFunction.BuiltinFunctions.EaseOutSine); if (delaySelectorPositionChange) { startTime = Constants.SystemMenuSelectorAnimationDuration; } // We allow the start time to be modified but fix the end time. // This allows us to delay a property set if required (by starting and finishing the animation after the menu animation ends). _systemSelectorAnimation.AnimateTo(_systemSelector, "PositionX", iconX, startTime, Constants.SystemMenuSelectorAnimationDuration, new AlphaFunction(AlphaFunction.BuiltinFunctions.EaseOutSine)); _systemSelectorAnimation.Play(); } }
public override View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { return(null); }
public void OnGetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { base.GetNextFocusableView(currentFocusedView, direction, loopEnabled); }
public override View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { if (currentFocusedView == null) { if (navigationContent != null && navigationContent.Focusable) { return(navigationContent); } else if (titleContent != null && titleContent.Focusable) { return(titleContent); } else { return(null); } } else if (currentFocusedView == this) { return(null); } else if (currentFocusedView == navigationContent) { if (direction == View.FocusDirection.Up) { return(null); } else if (direction == View.FocusDirection.Right) { if (titleContent != null && titleContent.Focusable) { return(titleContent); } else { return(null); } } else if (direction == View.FocusDirection.Down) { return(null); } else if (direction == View.FocusDirection.Left) { return(null); } } else if (currentFocusedView == titleContent) { if (direction == View.FocusDirection.Up) { return(null); } else if (direction == View.FocusDirection.Right) { return(null); } else if (direction == View.FocusDirection.Down) { return(null); } else if (direction == View.FocusDirection.Left) { if (navigationContent != null && navigationContent.Focusable) { return(navigationContent); } else { return(null); } } } return(null); }
/// <summary> /// Gets the next keyboard focusable view in this control towards the given direction.<br /> /// A control needs to override this function in order to support two dimensional keyboard navigation.<br /> /// </summary> /// <param name="currentFocusedView">The current focused view.</param> /// <param name="direction">The direction to move the focus towards.</param> /// <param name="loopEnabled">Whether the focus movement should be looped within the control.</param> /// <returns>The next keyboard focusable view in this control or an empty handle if no view can be focused.</returns> /// <since_tizen> 3 </since_tizen> public virtual View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { return(new View()); }
public override View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled) { View nextFocusedView = null; if (!focusedView) { // If focusedView is null, find child which has previous data index if (Children.Count > 0 && Adapter.Data.Count > 0) { for (int i = 0; i < Children.Count; i++) { RecycleItem item = Children[i] as RecycleItem; if (item.DataIndex == prevFocusedDataIndex) { nextFocusedView = item; break; } } } } else { // If this is not first focus, request next focus to LayoutManager if (LayoutManager != null) { nextFocusedView = LayoutManager.RequestNextFocusableView(currentFocusedView, direction, loopEnabled); } } if (nextFocusedView) { // Check next focused view is inside of visible area. // If it is not, move scroll position to make it visible. Position scrollPosition = ContentContainer.CurrentPosition; float targetPosition = -(ScrollingDirection == Direction.Horizontal ? scrollPosition.X : scrollPosition.Y); float left = nextFocusedView.Position.X; float right = nextFocusedView.Position.X + nextFocusedView.Size.Width; float top = nextFocusedView.Position.Y; float bottom = nextFocusedView.Position.Y + nextFocusedView.Size.Height; float visibleRectangleLeft = -scrollPosition.X; float visibleRectangleRight = -scrollPosition.X + Size.Width; float visibleRectangleTop = -scrollPosition.Y; float visibleRectangleBottom = -scrollPosition.Y + Size.Height; if (ScrollingDirection == Direction.Horizontal) { if ((direction == View.FocusDirection.Left || direction == View.FocusDirection.Up) && left < visibleRectangleLeft) { targetPosition = left; } else if ((direction == View.FocusDirection.Right || direction == View.FocusDirection.Down) && right > visibleRectangleRight) { targetPosition = right - Size.Width; } } else { if ((direction == View.FocusDirection.Up || direction == View.FocusDirection.Left) && top < visibleRectangleTop) { targetPosition = top; } else if ((direction == View.FocusDirection.Down || direction == View.FocusDirection.Right) && bottom > visibleRectangleBottom) { targetPosition = bottom - Size.Height; } } focusedView = nextFocusedView; if ((nextFocusedView as RecycleItem) != null) { prevFocusedDataIndex = (nextFocusedView as RecycleItem).DataIndex; } ScrollTo(targetPosition, true); } else { // If nextView is null, it means that we should move focus to outside of Control. // Return FocusableView depending on direction. switch (direction) { case View.FocusDirection.Left: { nextFocusedView = LeftFocusableView; break; } case View.FocusDirection.Right: { nextFocusedView = RightFocusableView; break; } case View.FocusDirection.Up: { nextFocusedView = UpFocusableView; break; } case View.FocusDirection.Down: { nextFocusedView = DownFocusableView; break; } } if (nextFocusedView) { focusedView = null; } else { //If FocusableView doesn't exist, not move focus. nextFocusedView = focusedView; } } return(nextFocusedView); }
private IntPtr OnDummyCallback(IntPtr current, IntPtr proposed, View.FocusDirection direction) { return(proposed); }