2 * Copyright(c) 2021 Samsung Electronics Co., Ltd.
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
19 using System.Runtime.InteropServices;
20 using Tizen.NUI.BaseComponents;
21 using System.ComponentModel;
26 /// Provides the functionality of handling keyboard navigation and maintaining the two-dimensional keyboard focus chain.<br />
27 /// It provides functionality of setting the focus and moving the focus in four directions( i.e., left, right, up, and down).<br />
28 /// It also draws a highlight for the focused view and sends an event when the focus is changed.<br />
30 /// <since_tizen> 3 </since_tizen>
31 public class FocusManager : BaseHandle
33 private static readonly FocusManager instance = FocusManager.Get();
34 private CustomAlgorithmInterfaceWrapper customAlgorithmInterfaceWrapper;
36 private EventHandlerWithReturnType<object, PreFocusChangeEventArgs, View> preFocusChangeEventHandler;
37 private PreFocusChangeEventCallback preFocusChangeCallback;
39 private EventHandler<FocusChangingEventArgs> focusChangingEventHandler;
40 private PreFocusChangeEventCallback focusChangingCallback;
42 private EventHandler<FocusChangedEventArgs> focusChangedEventHandler;
43 private FocusChangedEventCallback focusChangedEventCallback;
45 private EventHandler<FocusGroupChangedEventArgs> focusGroupChangedEventHandler;
46 private FocusGroupChangedEventCallback focusGroupChangedEventCallback;
48 private EventHandler<FocusedViewActivatedEventArgs> focusedViewEnterKeyEventHandler;
49 private FocusedViewEnterKeyEventCallback focusedViewEnterKeyEventCallback;
51 private EventHandler<FocusedViewActivatedEventArgs> focusedViewEnterKeyEventHandler2;
52 private FocusedViewEnterKeyEventCallback2 focusedViewEnterKeyEventCallback2;
54 internal FocusManager(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
58 internal FocusManager() : this(Interop.FocusManager.NewFocusManager(), true)
60 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
63 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
64 internal delegate IntPtr PreFocusChangeEventCallback(IntPtr current, IntPtr proposed, View.FocusDirection direction);
66 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
67 internal delegate void FocusChangedEventCallback(IntPtr current, IntPtr next);
69 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
70 private delegate void FocusGroupChangedEventCallback(IntPtr current, bool forwardDirection);
72 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
73 private delegate void FocusedViewEnterKeyEventCallback(IntPtr view);
75 [UnmanagedFunctionPointer(CallingConvention.StdCall)]
76 private delegate void FocusedViewEnterKeyEventCallback2(IntPtr view);
78 private View internalFocusIndicator = null;
79 private View nullFocusIndicator = null;
82 /// PreFocusChange will be triggered before the focus is going to be changed.<br />
83 /// The FocusManager makes the best guess for which view to focus towards the given direction, but applications might want to change that.<br />
84 /// By connecting with this event, they can check the proposed view to focus and return a different view if they wish.<br />
85 /// This event is only triggered when the navigation key is pressed and KeyboardFocusManager tries to move the focus automatically.<br />
86 /// It won't be emitted for focus movement by calling the SetCurrentFocusView directly.<br />
88 /// <since_tizen> 3 </since_tizen>
89 [Obsolete("Please do not use! This will be deprecated in API10. Please use FocusChanging instead!")]
90 // this will be deprecated, so suppress warning would be OK.
91 [System.Diagnostics.CodeAnalysis.SuppressMessage("Naming", "CA1710:Identifiers should have correct suffix", Justification = "<Pending>")]
92 public event EventHandlerWithReturnType<object, PreFocusChangeEventArgs, View> PreFocusChange
96 if (preFocusChangeEventHandler == null)
98 preFocusChangeCallback = OnPreFocusChange;
99 using PreFocusChangeSignal signal = PreFocusChangeSignal();
100 signal?.Connect(preFocusChangeCallback);
102 preFocusChangeEventHandler += value;
106 preFocusChangeEventHandler -= value;
107 using PreFocusChangeSignal signal = PreFocusChangeSignal();
108 if (preFocusChangeEventHandler == null && signal?.Empty() == false)
110 signal?.Disconnect(preFocusChangeCallback);
116 /// FocusChanging will be triggered before the focus is going to be changed.<br />
117 /// The FocusManager makes the best guess for which view to focus towards the given direction, but applications might want to change that.<br />
118 /// By connecting with this event, they can check the proposed view to focus and assign a different view if they wish.<br />
119 /// This event is only triggered when the navigation key is pressed and FocusManager tries to move the focus automatically.<br />
120 /// It won't be emitted for focus movement by calling the SetCurrentFocusView directly.<br />
123 /// by setting FocusChangingEventArgs.Proposed with the view to be focused, the focus will be moved to the assigned view.
125 /// <since_tizen> 10 </since_tizen>
126 public event EventHandler<FocusChangingEventArgs> FocusChanging
130 if (focusChangingEventHandler == null)
132 focusChangingCallback = OnFocusChanging;
133 //this is same as old PreFocusChangeSignal, so the body will be same. (only name is changed, behavior is same)
134 using PreFocusChangeSignal signal = PreFocusChangeSignal();
135 signal?.Connect(focusChangingCallback);
137 focusChangingEventHandler += value;
141 focusChangingEventHandler -= value;
142 //this is same as old PreFocusChangeSignal, so the body will be same. (only name is changed, behavior is same)
143 using PreFocusChangeSignal signal = PreFocusChangeSignal();
144 if (focusChangingEventHandler == null && signal?.Empty() == false)
146 signal?.Disconnect(focusChangingCallback);
152 /// The FocusChanged will be triggered after the current focused view has been changed.
154 /// <since_tizen> 3 </since_tizen>
155 public event EventHandler<FocusChangedEventArgs> FocusChanged
159 if (focusChangedEventCallback == null)
161 focusChangedEventCallback = OnFocusChanged;
162 using FocusChangedSignal signal = FocusChangedSignal();
163 signal?.Connect(focusChangedEventCallback);
165 focusChangedEventHandler += value;
169 focusChangedEventHandler -= value;
171 using FocusChangedSignal signal = FocusChangedSignal();
172 if (focusChangedEventCallback == null && signal?.Empty() == false)
174 signal?.Disconnect(focusChangedEventCallback);
180 /// The FocusGroupChanged will be triggered when the focus group has been changed.<br />
181 /// If the current focus group has a parent layout control, the FocusManager will make the best guess for the next focus group to move the focus to in the given direction (forward or backward).<br />
182 /// If not, the application has to set the new focus.<br />
184 /// <since_tizen> 3 </since_tizen>
185 public event EventHandler<FocusGroupChangedEventArgs> FocusGroupChanged
189 if (focusGroupChangedEventCallback == null)
191 focusGroupChangedEventCallback = OnFocusGroupChanged;
192 using FocusGroupChangedSignal signal = FocusGroupChangedSignal();
193 signal?.Connect(focusGroupChangedEventCallback);
195 focusGroupChangedEventHandler += value;
199 focusGroupChangedEventHandler -= value;
201 using FocusGroupChangedSignal signal = FocusGroupChangedSignal();
202 if (focusGroupChangedEventCallback == null && signal?.Empty() == false)
204 signal?.Disconnect(focusGroupChangedEventCallback);
210 /// The FocusedViewActivated will be triggered when the current focused view has the enter key pressed on it.
212 /// <since_tizen> 3 </since_tizen>
213 public event EventHandler<FocusedViewActivatedEventArgs> FocusedViewActivated
217 if (focusedViewEnterKeyEventCallback == null)
219 focusedViewEnterKeyEventCallback = OnFocusedViewEnterKey;
220 using ViewSignal signal = FocusedViewEnterKeySignal();
221 signal?.Connect(focusedViewEnterKeyEventCallback);
223 focusedViewEnterKeyEventHandler += value;
227 focusedViewEnterKeyEventHandler -= value;
229 using ViewSignal signal = FocusedViewEnterKeySignal();
230 if (focusedViewEnterKeyEventCallback != null && signal?.Empty() == false)
232 signal?.Disconnect(focusedViewEnterKeyEventCallback);
238 /// [Obsolete("Please do not use! this will be deprecated")]
240 /// <since_tizen> 3 </since_tizen>
241 /// Please do not use! this will be deprecated!
242 /// Instead please use FocusedViewActivated.
243 [Obsolete("Please do not use! This will be deprecated! Please use FocusManager.FocusedViewActivated instead! " +
245 "FocusManager.Instance.FocusedViewActivated = OnFocusedViewActivated; " +
246 "private void OnFocusedViewActivated(object source, FocusManager.FocusedViewActivatedEventArgs args) {...}")]
247 [EditorBrowsable(EditorBrowsableState.Never)]
248 public event EventHandler<FocusedViewActivatedEventArgs> FocusedViewEnterKeyPressed
252 if (focusedViewEnterKeyEventCallback2 == null)
254 focusedViewEnterKeyEventCallback2 = OnFocusedViewEnterKey2;
255 using ViewSignal signal = FocusedViewEnterKeySignal();
256 signal?.Connect(focusedViewEnterKeyEventCallback2);
258 focusedViewEnterKeyEventHandler2 += value;
262 focusedViewEnterKeyEventHandler2 -= value;
264 using ViewSignal signal = FocusedViewEnterKeySignal();
265 if (focusedViewEnterKeyEventCallback2 != null && signal?.Empty() == false)
267 signal?.Disconnect(focusedViewEnterKeyEventCallback2);
273 /// ICustomFocusAlgorithm is used to provide the custom keyboard focus algorithm for retrieving the next focusable view.<br />
274 /// The application can implement the interface and override the keyboard focus behavior.<br />
275 /// If the focus is changing within a layout container, then the layout container is queried first to provide the next focusable view.<br />
276 /// If this does not provide a valid view, then the Keyboard FocusManager will check focusable properties to determine the next focusable actor.<br />
277 /// If focusable properties are not set, then the keyboard FocusManager calls the GetNextFocusableView() method of this interface.<br />
279 /// <since_tizen> 3 </since_tizen>
280 public interface ICustomFocusAlgorithm
283 /// Get the next focus actor.
285 /// <param name="current">The current focus view.</param>
286 /// <param name="proposed">The proposed focus view</param>
287 /// <param name="direction">The focus move direction</param>
288 /// <returns>The next focus actor.</returns>
289 /// <since_tizen> 3 </since_tizen>
290 View GetNextFocusableView(View current, View proposed, View.FocusDirection direction);
295 /// Gets or sets the status of whether the focus movement should be looped within the same focus group.<br />
296 /// The focus movement is not looped by default.<br />
298 /// <since_tizen> 3 </since_tizen>
299 public bool FocusGroupLoop
303 SetFocusGroupLoop(value);
307 return GetFocusGroupLoop();
312 /// Gets or sets the focus indicator view.<br />
313 /// This will replace the default focus indicator view in the FocusManager and will be added to the focused view as a highlight.<br />
315 /// <since_tizen> 3 </since_tizen>
316 public View FocusIndicator
320 internalFocusIndicator = value;
321 if (internalFocusIndicator == null)
323 if (nullFocusIndicator == null)
325 nullFocusIndicator = new View();
327 SetFocusIndicatorView(nullFocusIndicator);
331 SetFocusIndicatorView(internalFocusIndicator);
336 return internalFocusIndicator;
341 /// Gets the singleton of the FocusManager object.
343 /// <since_tizen> 3 </since_tizen>
344 public static FocusManager Instance
353 /// Moves the keyboard focus to the given view.<br />
354 /// Only one view can be focused at the same time.<br />
355 /// The view must be in the stage already and keyboard focusable.<br />
357 /// <param name="view">The view to be focused.</param>
358 /// <returns>Whether the focus is successful or not.</returns>
359 /// <since_tizen> 3 </since_tizen>
360 public bool SetCurrentFocusView(View view)
364 throw new ArgumentNullException(nameof(view), "the target view should not be null");
367 bool ret = Interop.FocusManager.SetCurrentFocusActor(SwigCPtr, View.getCPtr(view));
368 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
373 /// Gets the current focused view.
375 /// <returns>A handle to the current focused view or an empty handle if no view is focused.</returns>
376 /// <since_tizen> 3 </since_tizen>
377 public View GetCurrentFocusView()
379 //to fix memory leak issue, match the handle count with native side.
380 IntPtr cPtr = Interop.FocusManager.GetCurrentFocusActor(SwigCPtr);
381 View ret = this.GetInstanceSafely<View>(cPtr);
386 /// Moves the focus to the next focusable view in the focus chain in the given direction (according to the focus traversal order).
388 /// <param name="direction">The direction of the focus movement.</param>
389 /// <returns>True if the movement was successful.</returns>
390 /// <since_tizen> 3 </since_tizen>
391 public bool MoveFocus(View.FocusDirection direction)
393 bool ret = Interop.FocusManager.MoveFocus(SwigCPtr, (int)direction);
394 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
399 /// Clears the focus from the current focused view if any, so that no view is focused in the focus chain.<br />
400 /// It will emit the FocusChanged event without the current focused view.<br />
402 /// <since_tizen> 3 </since_tizen>
403 public void ClearFocus()
405 Interop.FocusManager.ClearFocus(SwigCPtr);
406 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
410 /// Move the focus to previous focused view.
412 /// <since_tizen> 3 </since_tizen>
413 public void MoveFocusBackward()
415 Interop.FocusManager.MoveFocusBackward(SwigCPtr);
416 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
420 /// Sets whether the view is a focus group that can limit the scope of the focus movement to its child views in the focus chain.<br />
421 /// Layout controls set themselves as focus groups by default.<br />
423 /// <param name="view">The view to be set as a focus group.</param>
424 /// <param name="isFocusGroup">Whether to set the view as a focus group or not.</param>
425 /// <since_tizen> 3 </since_tizen>
426 public void SetAsFocusGroup(View view, bool isFocusGroup)
428 Interop.FocusManager.SetAsFocusGroup(SwigCPtr, View.getCPtr(view), isFocusGroup);
429 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
433 /// Checks whether the view is set as a focus group or not.
435 /// <param name="view">The view to be checked.</param>
436 /// <returns>Whether the view is set as a focus group.</returns>
437 /// <since_tizen> 3 </since_tizen>
438 public bool IsFocusGroup(View view)
440 bool ret = Interop.FocusManager.IsFocusGroup(SwigCPtr, View.getCPtr(view));
441 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
446 /// Returns the closest ancestor of the given view that is a focus group.
448 /// <param name="view">The view to be checked for its focus group.</param>
449 /// <returns>The focus group the given view belongs to or an empty handle if the given view.</returns>
450 /// <since_tizen> 3 </since_tizen>
451 public View GetFocusGroup(View view)
453 //to fix memory leak issue, match the handle count with native side.
454 IntPtr cPtr = Interop.FocusManager.GetFocusGroup(SwigCPtr, View.getCPtr(view));
455 View ret = this.GetInstanceSafely<View>(cPtr);
460 /// Provides the implementation of a custom focus algorithm interface to allow the application to define the focus logic.<br />
462 /// <param name="arg0">The user's implementation of ICustomFocusAlgorithm.</param>
463 /// <since_tizen> 3 </since_tizen>
464 public void SetCustomAlgorithm(ICustomFocusAlgorithm arg0)
468 customAlgorithmInterfaceWrapper = new CustomAlgorithmInterfaceWrapper();
469 customAlgorithmInterfaceWrapper.SetFocusAlgorithm(arg0);
471 Interop.NDalic.SetCustomAlgorithm(SwigCPtr, CustomAlgorithmInterface.getCPtr(customAlgorithmInterfaceWrapper));
472 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
476 Interop.NDalic.SetCustomAlgorithm(SwigCPtr, new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero));
477 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
482 /// Sets to use the automatic focus moveing algorithm. <br />
483 /// It moves the focus to the view closest to the keyboard movement direction.
485 /// <param name="enable">Whether using default focus algorithm or not</param>
486 [EditorBrowsable(EditorBrowsableState.Never)]
487 public void EnableDefaultAlgorithm(bool enable)
489 Interop.FocusManager.EnableDefaultAlgorithm(SwigCPtr, enable);
490 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
494 /// Checks default focus moveing algorithm is enabled or not
496 /// <returns>Whether default focus algorithm is enabled</returns>
497 [EditorBrowsable(EditorBrowsableState.Never)]
498 public bool IsDefaultAlgorithmEnabled()
500 bool ret = Interop.FocusManager.IsDefaultAlgorithmEnabled(SwigCPtr);
501 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
506 /// Get the nearest focusable view.
508 /// <param name="rootView">The view group in which to find the next focusable view.</param>
509 /// <param name="focusedView">The current focused view.</param>
510 /// <param name="direction">The direction.</param>
511 /// <returns>The nearest focusable view, or an empty handle if none exists.</returns>
512 [EditorBrowsable(EditorBrowsableState.Never)]
513 public View GetNearestFocusableActor(View rootView, View focusedView, View.FocusDirection direction)
515 //to fix memory leak issue, match the handle count with native side.
516 IntPtr cPtr = Interop.FocusManager.GetNearestFocusableActor(View.getCPtr(rootView), View.getCPtr(focusedView), (int)direction);
517 View ret = this.GetInstanceSafely<View>(cPtr);
522 /// Sets the root view to start moving focus when DefaultAlgorithm is enabled.
523 /// This will only look for focusable Views within that View tree when looking for the next focus.
525 /// <param name="rootView">The root view in which to find the next focusable view.</param>
526 [EditorBrowsable(EditorBrowsableState.Never)]
527 public void SetFocusFinderRootView(View rootView)
529 Interop.FocusManager.SetFocusFinderRootView(SwigCPtr, View.getCPtr(rootView));
530 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
534 /// Reset the root view that starts moving focus when DefaultAlgorithm is enabled.
535 /// When reset, the window becomes root.
537 [EditorBrowsable(EditorBrowsableState.Never)]
538 public void ResetFocusFinderRootView()
540 Interop.FocusManager.ResetFocusFinderRootView(SwigCPtr);
541 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
545 /// Get a default focus indicator
548 /// The type actually <see cref="Tizen.NUI.BaseComponents.ImageView"/> of blue border squred png image, so it would be difficult to modify itself.
549 /// To change focus indicator, creating new indicator and assigning it to FocusIndicator are recommended.
552 /// FocusManager.Instance.FocusIndicator = new View()
554 /// PositionUsesPivotPoint = true,
555 /// PivotPoint = new Position(0, 0, 0),
556 /// WidthResizePolicy = ResizePolicyType.FillToParent,
557 /// HeightResizePolicy = ResizePolicyType.FillToParent,
558 /// BorderlineColor = Color.Orange,
559 /// BorderlineWidth = 4.0f,
560 /// BorderlineOffset = -1f,
561 /// BackgroundColor = new Color(0.2f, 0.2f, 0.2f, 0.2f),
565 /// <returns>instance of default focus indicator</returns>
566 [EditorBrowsable(EditorBrowsableState.Never)]
567 public View GetDefaultFocusIndicator()
569 ImageView ret = new ImageView(FrameworkInformation.ResourcePath + "keyboard_focus.9.png")
571 Name = "DefaultFocusIndicatorCreatedByNUI",
572 PositionUsesAnchorPoint = true,
573 ParentOrigin = ParentOrigin.Center,
574 PivotPoint = ParentOrigin.Center,
575 Position2D = new Position2D(0, 0),
577 ret.SetResizePolicy(ResizePolicyType.FillToParent, DimensionType.AllDimensions);
581 internal static FocusManager Get()
583 FocusManager ret = new FocusManager(Interop.FocusManager.Get(), true);
584 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
586 ret.FocusIndicator = ret.GetDefaultFocusIndicator();
590 internal void SetFocusGroupLoop(bool enabled)
592 Interop.FocusManager.SetFocusGroupLoop(SwigCPtr, enabled);
593 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
596 internal bool GetFocusGroupLoop()
598 bool ret = Interop.FocusManager.GetFocusGroupLoop(SwigCPtr);
599 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
603 internal void SetFocusIndicatorView(View indicator)
605 Interop.FocusManager.SetFocusIndicatorActor(SwigCPtr, View.getCPtr(indicator));
606 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
609 internal View GetFocusIndicatorView()
611 //to fix memory leak issue, match the handle count with native side.
612 IntPtr cPtr = Interop.FocusManager.GetFocusIndicatorActor(SwigCPtr);
613 return this.GetInstanceSafely<View>(cPtr);
616 internal PreFocusChangeSignal PreFocusChangeSignal()
618 PreFocusChangeSignal ret = new PreFocusChangeSignal(Interop.FocusManager.PreFocusChangeSignal(SwigCPtr), false);
619 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
623 internal FocusChangedSignal FocusChangedSignal()
625 FocusChangedSignal ret = new FocusChangedSignal(Interop.FocusManager.FocusChangedSignal(SwigCPtr), false);
626 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
630 internal FocusGroupChangedSignal FocusGroupChangedSignal()
632 FocusGroupChangedSignal ret = new FocusGroupChangedSignal(Interop.FocusManager.FocusGroupChangedSignal(SwigCPtr), false);
633 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
637 internal ViewSignal FocusedViewEnterKeySignal()
639 ViewSignal ret = new ViewSignal(Interop.FocusManager.FocusedActorEnterKeySignal(SwigCPtr), false);
640 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
644 private IntPtr OnPreFocusChange(IntPtr current, IntPtr proposed, View.FocusDirection direction)
647 PreFocusChangeEventArgs e = new PreFocusChangeEventArgs();
649 if (current != global::System.IntPtr.Zero)
651 e.CurrentView = Registry.GetManagedBaseHandleFromNativePtr(current) as View;
653 if (proposed != global::System.IntPtr.Zero)
655 e.ProposedView = Registry.GetManagedBaseHandleFromNativePtr(proposed) as View;
657 e.Direction = direction;
659 if (preFocusChangeEventHandler != null)
661 view = preFocusChangeEventHandler(this, e);
666 return view.GetPtrfromView();
670 if (e.ProposedView != null) return proposed;
675 private IntPtr OnFocusChanging(IntPtr current, IntPtr proposed, View.FocusDirection direction)
677 View originallyProposed = null;
678 FocusChangingEventArgs e = new FocusChangingEventArgs();
680 if (current != global::System.IntPtr.Zero)
682 e.Current = Registry.GetManagedBaseHandleFromNativePtr(current) as View;
684 if (proposed != global::System.IntPtr.Zero)
686 originallyProposed = e.Proposed = Registry.GetManagedBaseHandleFromNativePtr(proposed) as View;
688 e.Direction = direction;
690 focusChangingEventHandler?.Invoke(this, e);
692 if (originallyProposed != e.Proposed)
694 //when user has changed Proposed
695 return e.Proposed.GetPtrfromView();
699 if (originallyProposed != null)
710 private void OnFocusChanged(IntPtr current, IntPtr next)
712 if (focusChangedEventHandler != null)
714 FocusChangedEventArgs e = new FocusChangedEventArgs();
716 e.Previous = e.CurrentView = Registry.GetManagedBaseHandleFromNativePtr(current) as View;
717 e.Current = e.NextView = Registry.GetManagedBaseHandleFromNativePtr(next) as View;
718 focusChangedEventHandler(this, e);
722 private void OnFocusGroupChanged(IntPtr current, bool forwardDirection)
724 if (focusGroupChangedEventHandler != null)
726 FocusGroupChangedEventArgs e = new FocusGroupChangedEventArgs();
728 e.CurrentView = Registry.GetManagedBaseHandleFromNativePtr(current) as View;
729 e.ForwardDirection = forwardDirection;
730 focusGroupChangedEventHandler(this, e);
734 private void OnFocusedViewEnterKey(IntPtr view)
736 if (focusedViewEnterKeyEventHandler != null)
738 FocusedViewActivatedEventArgs e = new FocusedViewActivatedEventArgs();
739 e.View = Registry.GetManagedBaseHandleFromNativePtr(view) as View;
740 focusedViewEnterKeyEventHandler(this, e);
745 /// Please do not use! this will be deprecated!
747 /// Please do not use! this will be deprecated!
748 /// Instead please use OnFocusedViewEnterKey.
749 [Obsolete("Please do not use! This will be deprecated! Please use FocusManager.OnFocusedViewEnterKey instead!")]
750 [EditorBrowsable(EditorBrowsableState.Never)]
751 private void OnFocusedViewEnterKey2(IntPtr view)
753 if (focusedViewEnterKeyEventHandler != null)
755 FocusedViewActivatedEventArgs e = new FocusedViewActivatedEventArgs();
756 e.View = Registry.GetManagedBaseHandleFromNativePtr(view) as View;
757 focusedViewEnterKeyEventHandler(this, e);
762 /// Event arguments that passed via the PreFocusChange signal.
764 /// <since_tizen> 3 </since_tizen>
765 [Obsolete("Please do not use! This will be deprecated in API10. Please use FocusChangingEventArgs instead!")]
766 [System.Diagnostics.CodeAnalysis.SuppressMessage("Design", "CA1034:Nested types should not be visible", Justification = "<Pending>")]
767 // this will be deprecated, so suppress warning would be OK.
768 public class PreFocusChangeEventArgs : EventArgs
770 private View current;
771 private View proposed;
772 private View.FocusDirection direction;
775 /// The current focus view.
777 /// <since_tizen> 3 </since_tizen>
778 public View CurrentView
791 /// The proposed view.
793 /// <since_tizen> 3 </since_tizen>
794 public View ProposedView
807 /// The focus move direction.
809 /// <since_tizen> 3 </since_tizen>
810 public View.FocusDirection Direction
824 /// Event arguments that passed via the FocusChanged signal.
826 /// <since_tizen> 3 </since_tizen>
827 public class FocusChangedEventArgs : EventArgs
829 private View currentView;
830 private View nextView;
831 private View previous;
832 private View current;
835 /// The current focus view.
837 /// <since_tizen> 3 </since_tizen>
838 [Obsolete("Please do not use! This will be deprecated! Please use Previous instead!")]
839 public View CurrentView
851 /// The next focus view.
853 /// <since_tizen> 3 </since_tizen>
854 [Obsolete("Please do not use! This will be deprecated! Please use Current instead!")]
867 /// The previously focused view.
869 /// <since_tizen> 10 </since_tizen>
882 /// The current focused view after focus changed.
884 /// <since_tizen> 10 </since_tizen>
899 /// Event arguments that passed via the FocusGroupChanged signal.
901 /// <since_tizen> 3 </since_tizen>
902 public class FocusGroupChangedEventArgs : EventArgs
904 private View current;
905 private bool forwardDirection;
908 /// The current focus view.
910 /// <since_tizen> 3 </since_tizen>
911 public View CurrentView
924 /// The forward direction.
926 /// <since_tizen> 3 </since_tizen>
927 public bool ForwardDirection
931 return forwardDirection;
935 forwardDirection = value;
941 /// Event arguments that passed via the FocusedViewEnterKey signal.
943 /// <since_tizen> 3 </since_tizen>
944 public class FocusedViewActivatedEventArgs : EventArgs
951 /// <since_tizen> 3 </since_tizen>
966 /// Please do not use! this will be deprecated
968 /// <since_tizen> 3 </since_tizen>
969 /// Please do not use! this will be deprecated.
970 /// Instead please use FocusedViewActivatedEventArgs.
971 [Obsolete("Please do not use! This will be deprecated! Please use FocusedViewActivatedEventArgs instead! " +
973 "FocusManager.Instance.FocusedViewActivated = OnFocusedViewActivated; " +
974 "private void OnFocusedViewActivated(object source, FocusManager.FocusedViewActivatedEventArgs arg)" +
976 [EditorBrowsable(EditorBrowsableState.Never)]
977 [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
978 public class FocusedViewEnterKeyEventArgs : EventArgs
985 /// <since_tizen> 3 </since_tizen>
999 private class CustomAlgorithmInterfaceWrapper : CustomAlgorithmInterface
1001 private FocusManager.ICustomFocusAlgorithm customFocusAlgorithm;
1003 public CustomAlgorithmInterfaceWrapper()
1007 public void SetFocusAlgorithm(FocusManager.ICustomFocusAlgorithm customFocusAlgorithm)
1009 this.customFocusAlgorithm = customFocusAlgorithm;
1012 public override View GetNextFocusableView(View current, View proposed, View.FocusDirection direction, string deviceName)
1014 if (customFocusAlgorithm == null)
1016 Tizen.Log.Error("NUI", $"[ERROR] User defined ICustomFocusAlgorithm interface class becomes unreachable. Null will be proposed for next focusing!");
1019 if (customFocusAlgorithm is ICustomAwareDeviceFocusAlgorithm deviceAwared)
1021 return deviceAwared.GetNextFocusableView(current, proposed, direction, deviceName);
1025 return customFocusAlgorithm.GetNextFocusableView(current, proposed, direction);