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.ComponentModel;
20 using System.Runtime.InteropServices;
22 namespace Tizen.NUI.BaseComponents
25 /// View is the base class for all views.
27 /// <since_tizen> 3 </since_tizen>
28 public partial class View
30 private EventHandler offWindowEventHandler;
31 private OffWindowEventCallbackType offWindowEventCallback;
32 private EventHandlerWithReturnType<object, WheelEventArgs, bool> interceptWheelHandler;
33 private WheelEventCallbackType interceptWheelCallback;
34 private EventHandlerWithReturnType<object, WheelEventArgs, bool> wheelEventHandler;
35 private WheelEventCallbackType wheelEventCallback;
36 private EventHandlerWithReturnType<object, KeyEventArgs, bool> keyEventHandler;
37 private KeyCallbackType keyCallback;
38 private EventHandlerWithReturnType<object, TouchEventArgs, bool> interceptTouchDataEventHandler;
39 private TouchDataCallbackType interceptTouchDataCallback;
40 private EventHandlerWithReturnType<object, TouchEventArgs, bool> touchDataEventHandler;
41 private TouchDataCallbackType touchDataCallback;
42 private EventHandlerWithReturnType<object, HoverEventArgs, bool> hoverEventHandler;
43 private HoverEventCallbackType hoverEventCallback;
44 private EventHandler<VisibilityChangedEventArgs> visibilityChangedEventHandler;
45 private VisibilityChangedEventCallbackType visibilityChangedEventCallback;
46 private EventHandler keyInputFocusGainedEventHandler;
48 private KeyInputFocusGainedCallbackType keyInputFocusGainedCallback;
49 private EventHandler keyInputFocusLostEventHandler;
51 private KeyInputFocusLostCallbackType keyInputFocusLostCallback;
52 private EventHandler onRelayoutEventHandler;
53 private OnRelayoutEventCallbackType onRelayoutEventCallback;
54 private EventHandler onWindowEventHandler;
55 private OnWindowEventCallbackType onWindowEventCallback;
56 private EventHandler<LayoutDirectionChangedEventArgs> layoutDirectionChangedEventHandler;
57 private LayoutDirectionChangedEventCallbackType layoutDirectionChangedEventCallback;
58 // Resource Ready Signal
59 private EventHandler resourcesLoadedEventHandler;
60 private ResourcesLoadedCallbackType resourcesLoadedCallback;
61 private EventHandler<BackgroundResourceLoadedEventArgs> backgroundResourceLoadedEventHandler;
62 private _backgroundResourceLoadedCallbackType backgroundResourceLoadedCallback;
63 private TouchDataCallbackType hitTestResultDataCallback;
65 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
66 private delegate void OffWindowEventCallbackType(IntPtr control);
67 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
68 private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
69 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
70 private delegate bool KeyCallbackType(IntPtr control, IntPtr keyEvent);
71 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
72 private delegate bool TouchDataCallbackType(IntPtr view, IntPtr touchData);
73 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
74 private delegate bool HoverEventCallbackType(IntPtr view, IntPtr hoverEvent);
75 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
76 private delegate void VisibilityChangedEventCallbackType(IntPtr data, bool visibility, VisibilityChangeType type);
77 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
78 private delegate void ResourcesLoadedCallbackType(IntPtr control);
79 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
80 private delegate void _backgroundResourceLoadedCallbackType(IntPtr view);
82 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
83 private delegate void KeyInputFocusGainedCallbackType(IntPtr control);
84 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
85 private delegate void KeyInputFocusLostCallbackType(IntPtr control);
87 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
88 private delegate void OnRelayoutEventCallbackType(IntPtr control);
89 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
90 private delegate void OnWindowEventCallbackType(IntPtr control);
91 [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
92 private delegate void LayoutDirectionChangedEventCallbackType(IntPtr data, ViewLayoutDirectionType type);
94 // List of dispatch Event
95 private PanGestureDetector panGestureDetector = null;
96 private LongPressGestureDetector longGestureDetector = null;
97 private PinchGestureDetector pinchGestureDetector = null;
98 private TapGestureDetector tapGestureDetector = null;
99 private RotationGestureDetector rotationGestureDetector = null;
100 private int configGestureCount = 0;
101 private bool dispatchTouchEvents = true;
102 private bool dispatchParentTouchEvents = true;
103 private bool dispatchHoverEvents = true;
104 private bool dispatchParentHoverEvents = true;
105 private bool dispatchGestureEvents = true;
106 private bool dispatchParentGestureEvents = true;
107 private bool dispatchTouchMotion = true;
108 private bool dispatchHoverMotion = true;
112 /// Event when a child is removed.
114 /// <since_tizen> 5 </since_tizen>
115 public new event EventHandler<ChildRemovedEventArgs> ChildRemoved;
117 /// Event when a child is added.
119 /// <since_tizen> 5 </since_tizen>
120 public new event EventHandler<ChildAddedEventArgs> ChildAdded;
123 /// An event for the KeyInputFocusGained signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
124 /// The KeyInputFocusGained signal is emitted when the control gets the key input focus.<br />
126 /// <since_tizen> 3 </since_tizen>
127 public event EventHandler FocusGained
131 if (keyInputFocusGainedEventHandler == null)
133 keyInputFocusGainedCallback = OnKeyInputFocusGained;
134 Interop.ViewSignal.KeyInputFocusGainedConnect(SwigCPtr, keyInputFocusGainedCallback.ToHandleRef(this));
135 NDalicPINVOKE.ThrowExceptionIfExists();
137 keyInputFocusGainedEventHandler += value;
142 keyInputFocusGainedEventHandler -= value;
143 if (keyInputFocusGainedEventHandler == null && keyInputFocusGainedCallback != null)
145 Interop.ViewSignal.KeyInputFocusGainedDisconnect(SwigCPtr, keyInputFocusGainedCallback.ToHandleRef(this));
146 NDalicPINVOKE.ThrowExceptionIfExists();
147 keyInputFocusGainedCallback = null;
153 /// An event for the KeyInputFocusLost signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
154 /// The KeyInputFocusLost signal is emitted when the control loses the key input focus.<br />
156 /// <since_tizen> 3 </since_tizen>
157 public event EventHandler FocusLost
161 if (keyInputFocusLostEventHandler == null)
163 keyInputFocusLostCallback = OnKeyInputFocusLost;
164 Interop.ViewSignal.KeyInputFocusLostConnect(SwigCPtr, keyInputFocusLostCallback.ToHandleRef(this));
165 NDalicPINVOKE.ThrowExceptionIfExists();
167 keyInputFocusLostEventHandler += value;
172 keyInputFocusLostEventHandler -= value;
173 if (keyInputFocusLostEventHandler == null && keyInputFocusLostCallback != null)
175 Interop.ViewSignal.KeyInputFocusLostDisconnect(SwigCPtr, keyInputFocusLostCallback.ToHandleRef(this));
176 NDalicPINVOKE.ThrowExceptionIfExists();
177 keyInputFocusLostCallback = null;
183 /// An event for the KeyPressed signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
184 /// The KeyPressed signal is emitted when the key event is received.<br />
186 /// <since_tizen> 3 </since_tizen>
187 public event EventHandlerWithReturnType<object, KeyEventArgs, bool> KeyEvent
191 if (keyEventHandler == null)
193 keyCallback = OnKeyEvent;
194 Interop.ViewSignal.KeyEventConnect(SwigCPtr, keyCallback.ToHandleRef(this));
195 NDalicPINVOKE.ThrowExceptionIfExists();
197 keyEventHandler += value;
202 keyEventHandler -= value;
203 if (keyEventHandler == null && keyCallback != null)
205 Interop.ViewSignal.KeyEventDisconnect(SwigCPtr, keyCallback.ToHandleRef(this));
206 NDalicPINVOKE.ThrowExceptionIfExists();
213 /// An event for the OnRelayout signal which can be used to subscribe or unsubscribe the event handler.<br />
214 /// The OnRelayout signal is emitted after the size has been set on the view during relayout.<br />
216 /// <since_tizen> 3 </since_tizen>
217 public event EventHandler Relayout
221 if (onRelayoutEventHandler == null)
223 onRelayoutEventCallback = OnRelayout;
224 Interop.ActorSignal.OnRelayoutConnect(SwigCPtr, onRelayoutEventCallback.ToHandleRef(this));
225 NDalicPINVOKE.ThrowExceptionIfExists();
227 onRelayoutEventHandler += value;
232 onRelayoutEventHandler -= value;
233 if (onRelayoutEventHandler == null && onRelayoutEventCallback != null)
235 Interop.ActorSignal.OnRelayoutDisconnect(SwigCPtr, onRelayoutEventCallback.ToHandleRef(this));
236 NDalicPINVOKE.ThrowExceptionIfExists();
237 onRelayoutEventCallback = null;
243 /// An event for the touched signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
244 /// The touched signal is emitted when the touch input is received.<br />
245 /// This can receive touch events before child. <br />
246 /// If it returns false, the child can receive the touch event. If it returns true, the touch event is intercepted. So child cannot receive touch event.<br />
248 [EditorBrowsable(EditorBrowsableState.Never)]
249 public event EventHandlerWithReturnType<object, TouchEventArgs, bool> InterceptTouchEvent
253 if (interceptTouchDataEventHandler == null)
255 interceptTouchDataCallback = OnInterceptTouch;
256 Interop.ActorSignal.InterceptTouchConnect(SwigCPtr, interceptTouchDataCallback.ToHandleRef(this));
257 NDalicPINVOKE.ThrowExceptionIfExists();
259 interceptTouchDataEventHandler += value;
264 interceptTouchDataEventHandler -= value;
265 if (interceptTouchDataEventHandler == null && interceptTouchDataCallback != null)
267 Interop.ActorSignal.InterceptTouchDisconnect(SwigCPtr, interceptTouchDataCallback.ToHandleRef(this));
268 NDalicPINVOKE.ThrowExceptionIfExists();
269 interceptTouchDataCallback = null;
275 /// If child view doesn't want the parent's view to intercept the touch, you can set it to true.
277 /// parent.Add(child);
278 /// parent.InterceptTouchEvent += OnInterceptTouchEvent;
279 /// View view = child.GetParent() as View;
280 /// view.DisallowInterceptTouchEvent = true;
281 /// This prevents the parent from intercepting touch.
283 [EditorBrowsable(EditorBrowsableState.Never)]
284 public bool DisallowInterceptTouchEvent { get; set; }
288 /// An event for the touched signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
289 /// The touched signal is emitted when the touch input is received.<br />
291 /// <since_tizen> 3 </since_tizen>
292 public event EventHandlerWithReturnType<object, TouchEventArgs, bool> TouchEvent
296 if (touchDataEventHandler == null)
298 touchDataCallback = OnTouch;
299 Interop.ActorSignal.TouchConnect(SwigCPtr, touchDataCallback.ToHandleRef(this));
300 NDalicPINVOKE.ThrowExceptionIfExists();
302 touchDataEventHandler += value;
307 touchDataEventHandler -= value;
308 if (touchDataEventHandler == null && touchDataCallback != null)
310 Interop.ActorSignal.TouchDisconnect(SwigCPtr, touchDataCallback.ToHandleRef(this));
311 NDalicPINVOKE.ThrowExceptionIfExists();
312 touchDataCallback = null;
318 /// An event for the hovered signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
319 /// The hovered signal is emitted when the hover input is received.<br />
321 /// <since_tizen> 3 </since_tizen>
322 public event EventHandlerWithReturnType<object, HoverEventArgs, bool> HoverEvent
326 if (hoverEventHandler == null)
328 hoverEventCallback = OnHoverEvent;
329 Interop.ActorSignal.HoveredConnect(SwigCPtr, hoverEventCallback.ToHandleRef(this));
330 NDalicPINVOKE.ThrowExceptionIfExists();
332 hoverEventHandler += value;
337 hoverEventHandler -= value;
338 if (hoverEventHandler == null && hoverEventCallback != null)
340 Interop.ActorSignal.HoveredDisconnect(SwigCPtr, hoverEventCallback.ToHandleRef(this));
341 NDalicPINVOKE.ThrowExceptionIfExists();
342 hoverEventCallback = null;
348 /// An event for the wheel which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
349 /// The wheel event is emitted when the wheel input is received.<br />
350 /// This can receive wheel events before child. <br />
351 /// If it returns false, the child can receive the wheel event. If it returns true, the wheel event is intercepted. So child cannot receive wheel event.<br />
353 [EditorBrowsable(EditorBrowsableState.Never)]
354 public event EventHandlerWithReturnType<object, WheelEventArgs, bool> InterceptWheelEvent
358 if (interceptWheelHandler == null)
360 interceptWheelCallback = OnInterceptWheel;
361 Interop.ActorSignal.InterceptWheelConnect(SwigCPtr, interceptWheelCallback.ToHandleRef(this));
362 NDalicPINVOKE.ThrowExceptionIfExists();
364 interceptWheelHandler += value;
369 interceptWheelHandler -= value;
370 if (interceptWheelHandler == null && interceptWheelCallback != null)
372 Interop.ActorSignal.InterceptWheelDisconnect(SwigCPtr, interceptWheelCallback.ToHandleRef(this));
373 NDalicPINVOKE.ThrowExceptionIfExists();
374 interceptWheelCallback = null;
380 /// If child view doesn't want the parent's view to intercept the wheel event, you can set it to true.
382 /// parent.Add(child);
383 /// parent.InterceptWheelEvent += OnInterceptWheelEvent;
384 /// View view = child.GetParent() as View;
385 /// view.DisallowInterceptWheelEvent = true;
386 /// This prevents the parent from intercepting wheel event.
388 [EditorBrowsable(EditorBrowsableState.Never)]
389 public bool DisallowInterceptWheelEvent { get; set; }
392 /// An event for the WheelMoved signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
393 /// The WheelMoved signal is emitted when the wheel event is received.<br />
395 /// <since_tizen> 3 </since_tizen>
396 public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelEvent
400 if (wheelEventHandler == null)
402 wheelEventCallback = OnWheelEvent;
403 Interop.ActorSignal.WheelEventConnect(SwigCPtr, wheelEventCallback.ToHandleRef(this));
404 NDalicPINVOKE.ThrowExceptionIfExists();
406 wheelEventHandler += value;
411 wheelEventHandler -= value;
412 if (wheelEventHandler == null && wheelEventCallback != null)
414 Interop.ActorSignal.WheelEventDisconnect(SwigCPtr, wheelEventCallback.ToHandleRef(this));
415 NDalicPINVOKE.ThrowExceptionIfExists();
416 wheelEventCallback = null;
422 /// An event for the OnWindow signal which can be used to subscribe or unsubscribe the event handler.<br />
423 /// The OnWindow signal is emitted after the view has been connected to the window.<br />
425 /// <since_tizen> 3 </since_tizen>
426 public event EventHandler AddedToWindow
430 if (onWindowEventHandler == null)
432 onWindowEventCallback = OnWindow;
433 Interop.ActorSignal.OnSceneConnect(SwigCPtr, onWindowEventCallback.ToHandleRef(this));
434 NDalicPINVOKE.ThrowExceptionIfExists();
436 onWindowEventHandler += value;
441 onWindowEventHandler -= value;
442 if (onWindowEventHandler == null && onWindowEventCallback != null)
444 Interop.ActorSignal.OnSceneDisconnect(SwigCPtr, onWindowEventCallback.ToHandleRef(this));
445 NDalicPINVOKE.ThrowExceptionIfExists();
446 onWindowEventCallback = null;
452 /// An event for the OffWindow signal, which can be used to subscribe or unsubscribe the event handler.<br />
453 /// OffWindow signal is emitted after the view has been disconnected from the window.<br />
455 /// <since_tizen> 3 </since_tizen>
456 public event EventHandler RemovedFromWindow
460 if (offWindowEventHandler == null)
462 offWindowEventCallback = OffWindow;
463 Interop.ActorSignal.OffSceneConnect(SwigCPtr, offWindowEventCallback.ToHandleRef(this));
464 NDalicPINVOKE.ThrowExceptionIfExists();
466 offWindowEventHandler += value;
471 offWindowEventHandler -= value;
472 if (offWindowEventHandler == null && offWindowEventCallback != null)
474 Interop.ActorSignal.OffSceneDisconnect(SwigCPtr, offWindowEventCallback.ToHandleRef(this));
475 NDalicPINVOKE.ThrowExceptionIfExists();
476 offWindowEventCallback = null;
481 /// An event for visibility change which can be used to subscribe or unsubscribe the event handler.<br />
482 /// This event is sent when the visibility of this or a parent view is changed.<br />
486 /// When VisibilityChangedEventArgs.Type is SELF, VisibilityChangedEventArgs.Visibility is true means this View's Visibility property is true.
487 /// When VisibilityChangedEventArgs.Type is PARENT, VisibilityChangedEventArgs.Visibility is true means a parent's Visibility property has changed to true.
490 /// This event is NOT sent if the view becomes transparent (or the reverse), it's ONLY linked with View.Show() and View.Hide().
491 /// For reference, a view is only shown if the view and its parents (up to the root view) are also visible, they are not transparent, and the view has a non-zero size.
492 /// So if its parent is not visible, the view is not shown even though VisibilityChangedEventArgs.Type is SELF and VisibilityChangedEventArgs.Visibility is true.
495 /// <since_tizen> 3 </since_tizen>
496 public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
500 if (visibilityChangedEventHandler == null)
502 visibilityChangedEventCallback = OnVisibilityChanged;
503 Interop.ActorSignal.VisibilityChangedConnect(SwigCPtr, visibilityChangedEventCallback.ToHandleRef(this));
504 NDalicPINVOKE.ThrowExceptionIfExists();
506 visibilityChangedEventHandler += value;
511 visibilityChangedEventHandler -= value;
512 if (visibilityChangedEventHandler == null && visibilityChangedEventCallback != null)
514 Interop.ActorSignal.VisibilityChangedDisconnect(SwigCPtr, visibilityChangedEventCallback.ToHandleRef(this));
515 NDalicPINVOKE.ThrowExceptionIfExists();
516 visibilityChangedEventCallback = null;
522 /// Event for layout direction change which can be used to subscribe/unsubscribe the event handler.<br />
523 /// This signal is emitted when the layout direction property of this or a parent view is changed.<br />
525 /// <since_tizen> 4 </since_tizen>
526 public event EventHandler<LayoutDirectionChangedEventArgs> LayoutDirectionChanged
530 if (layoutDirectionChangedEventHandler == null)
532 layoutDirectionChangedEventCallback = OnLayoutDirectionChanged;
533 Interop.ActorSignal.LayoutDirectionChangedConnect(SwigCPtr, layoutDirectionChangedEventCallback.ToHandleRef(this));
534 NDalicPINVOKE.ThrowExceptionIfExists();
537 layoutDirectionChangedEventHandler += value;
542 layoutDirectionChangedEventHandler -= value;
544 if (layoutDirectionChangedEventHandler == null && layoutDirectionChangedEventCallback != null)
546 Interop.ActorSignal.LayoutDirectionChangedDisconnect(SwigCPtr, layoutDirectionChangedEventCallback.ToHandleRef(this));
547 NDalicPINVOKE.ThrowExceptionIfExists();
548 layoutDirectionChangedEventCallback = null;
554 /// An event for the ResourcesLoadedSignal signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
555 /// This signal is emitted after all resources required by a view are loaded and ready.<br />
557 /// <since_tizen> 3 </since_tizen>
558 public event EventHandler ResourcesLoaded
562 if (resourcesLoadedEventHandler == null)
564 resourcesLoadedCallback = OnResourcesLoaded;
565 Interop.ViewSignal.ResourceReadyConnect(SwigCPtr, resourcesLoadedCallback.ToHandleRef(this));
566 NDalicPINVOKE.ThrowExceptionIfExists();
568 resourcesLoadedEventHandler += value;
573 resourcesLoadedEventHandler -= value;
574 if (resourcesLoadedEventHandler == null && resourcesLoadedCallback != null)
576 Interop.ViewSignal.ResourceReadyDisconnect(SwigCPtr, resourcesLoadedCallback.ToHandleRef(this));
577 NDalicPINVOKE.ThrowExceptionIfExists();
578 resourcesLoadedCallback = null;
583 private EventHandler _backKeyPressed;
586 /// An event for getting notice when physical back key is pressed.<br />
587 /// This event is emitted BackKey is up.<br />
589 [EditorBrowsable(EditorBrowsableState.Never)]
590 public event EventHandler BackKeyPressed
594 _backKeyPressed += value;
595 BackKeyManager.Instance.Subscriber.Add(this);
600 BackKeyManager.Instance.Subscriber.Remove(this);
601 _backKeyPressed -= value;
606 /// Function for emitting BackKeyPressed event outside of View instance
608 [EditorBrowsable(EditorBrowsableState.Never)]
609 internal void EmitBackKeyPressed()
611 _backKeyPressed.Invoke(this, null);
615 internal event EventHandler<BackgroundResourceLoadedEventArgs> BackgroundResourceLoaded
619 if (backgroundResourceLoadedEventHandler == null)
621 backgroundResourceLoadedCallback = OnBackgroundResourceLoaded;
622 Interop.ViewSignal.ResourceReadyConnect(SwigCPtr, backgroundResourceLoadedCallback.ToHandleRef(this));
623 NDalicPINVOKE.ThrowExceptionIfExists();
625 backgroundResourceLoadedEventHandler += value;
630 backgroundResourceLoadedEventHandler -= value;
631 if (backgroundResourceLoadedEventHandler == null && backgroundResourceLoadedCallback != null)
633 Interop.ViewSignal.ResourceReadyDisconnect(SwigCPtr, backgroundResourceLoadedCallback.ToHandleRef(this));
634 NDalicPINVOKE.ThrowExceptionIfExists();
635 backgroundResourceLoadedCallback = null;
640 private void OnColorChanged(float r, float g, float b, float a)
642 Color = new Color(r, g, b, a);
645 private void OnMinimumSizeChanged(int width, int height)
647 MinimumSize = new Size2D(width, height);
650 private void OnMaximumSizeChanged(int width, int height)
652 MaximumSize = new Size2D(width, height);
655 private void OnPosition2DChanged(int x, int y)
657 SetPosition((float)x, (float)y, 0);
660 private void OnPositionChanged(float x, float y, float z)
662 SetPosition(x, y, z);
665 private void OnSize2DChanged(int width, int height)
667 SetSize((float)width, (float)height, 0);
670 private void OnSizeChanged(float width, float height, float depth)
672 SetSize(width, height, depth);
675 private void OnParentOriginChanged(float x, float y, float z)
677 ParentOrigin = new Position(x, y, z);
680 private void OnPivotPointChanged(float x, float y, float z)
682 PivotPoint = new Position(x, y, z);
685 private void OnImageShadowChanged(ShadowBase instance)
687 ImageShadow = (ImageShadow)instance;
690 private void OnBoxShadowChanged(ShadowBase instance)
692 BoxShadow = (Shadow)instance;
695 private void OnBackgroundImageBorderChanged(int left, int right, int bottom, int top)
697 BackgroundImageBorder = new Rectangle(left, right, bottom, top);
700 private void OnKeyInputFocusGained(IntPtr view)
702 if (IsNativeHandleInvalid())
706 if (keyInputFocusGainedEventHandler != null)
708 var process = global::System.Diagnostics.Process.GetCurrentProcess().Id;
709 var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
710 var me = this.GetType().FullName;
712 throw new ObjectDisposedException(nameof(SwigCPtr), $"Error! NUI's native dali object is already disposed. " +
713 $"OR the native dali object handle of NUI becomes null! \n" +
714 $" process:{process} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
719 if (this.IsDisposeQueued)
721 var process = global::System.Diagnostics.Process.GetCurrentProcess().Id;
722 var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
723 var me = this.GetType().FullName;
725 //in this case, the View object is ready to be disposed waiting on DisposeQueue, so event callback should not be invoked!
726 Tizen.Log.Error("NUI", "in this case, the View object is ready to be disposed waiting on DisposeQueue, so event callback should not be invoked! just return here! \n" +
727 $"process:{process} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
733 keyInputFocusGainedEventHandler?.Invoke(this, null);
736 private void OnKeyInputFocusLost(IntPtr view)
738 if (IsNativeHandleInvalid())
742 if (keyInputFocusLostEventHandler != null)
744 var process = global::System.Diagnostics.Process.GetCurrentProcess().Id;
745 var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
746 var me = this.GetType().FullName;
748 throw new ObjectDisposedException(nameof(SwigCPtr), $"Error! NUI's native dali object is already disposed. " +
749 $"OR the native dali object handle of NUI becomes null! \n" +
750 $" process:{process} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
755 if (this.IsDisposeQueued)
757 var process = global::System.Diagnostics.Process.GetCurrentProcess().Id;
758 var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
759 var me = this.GetType().FullName;
761 //in this case, the View object is ready to be disposed waiting on DisposeQueue, so event callback should not be invoked!
762 Tizen.Log.Error("NUI", "in this case, the View object is ready to be disposed waiting on DisposeQueue, so event callback should not be invoked! just return here! \n" +
763 $"process:{process} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
769 keyInputFocusLostEventHandler?.Invoke(this, null);
772 private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
774 if (keyEvent == global::System.IntPtr.Zero)
776 NUILog.Error("keyEvent should not be null!");
780 KeyEventArgs e = new KeyEventArgs();
784 e.Key = Tizen.NUI.Key.GetKeyFromPtr(keyEvent);
786 if (keyEventHandler != null)
788 Delegate[] delegateList = keyEventHandler.GetInvocationList();
790 // Oring the result of each callback.
791 foreach (EventHandlerWithReturnType<object, KeyEventArgs, bool> del in delegateList)
793 result |= del(this, e);
800 // Callback for View OnRelayout signal
801 private void OnRelayout(IntPtr data)
803 if (onRelayoutEventHandler != null)
805 onRelayoutEventHandler(this, null);
809 // Callback for View HitTestResultSignal
810 private bool OnHitTestResult(IntPtr view, IntPtr touchData)
812 if (touchData == global::System.IntPtr.Zero)
814 NUILog.Error("touchData should not be null!");
818 TouchEventArgs e = new TouchEventArgs();
819 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
820 return HitTest(e.Touch);
823 // Callback for View TouchSignal
824 private bool OnInterceptTouch(IntPtr view, IntPtr touchData)
826 if (touchData == global::System.IntPtr.Zero)
828 NUILog.Error("touchData should not be null!");
832 // DisallowInterceptTouchEvent prevents the parent from intercepting touch.
833 if (DisallowInterceptTouchEvent)
838 TouchEventArgs e = new TouchEventArgs();
839 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
841 // If DispatchTouchMotion is false, Motion event is not dispatched.
842 if (DispatchTouchMotion == false && e.Touch.GetState(0) == PointStateType.Motion)
847 bool consumed = false;
849 if (interceptTouchDataEventHandler != null)
851 consumed = interceptTouchDataEventHandler(this, e);
857 // Callback for View TouchSignal
858 private bool OnTouch(IntPtr view, IntPtr touchData)
860 if (touchData == global::System.IntPtr.Zero)
862 NUILog.Error("touchData should not be null!");
866 if (DispatchTouchEvents == false)
868 NUILog.Debug("If DispatchTouchEvents is false, it can not dispatch.");
872 TouchEventArgs e = new TouchEventArgs();
873 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
875 // If DispatchTouchMotion is false, Motion event is not dispatched.
876 if (DispatchTouchMotion == false && e.Touch.GetState(0) == PointStateType.Motion)
882 bool consumed = false;
884 if (touchDataEventHandler != null)
886 consumed = touchDataEventHandler(this, e);
889 if (enableControlState && !consumed)
891 consumed = HandleControlStateOnTouch(e.Touch);
894 if (DispatchParentTouchEvents == false)
896 NUILog.Debug("If DispatchParentTouchEvents is false, it can not dispatch to parent.");
903 // Callback for View Hover signal
904 private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
906 if (hoverEvent == global::System.IntPtr.Zero)
908 NUILog.Error("hoverEvent should not be null!");
912 if (DispatchHoverEvents == false)
914 NUILog.Debug("If DispatchHoverEvents is false, it can not dispatch.");
918 HoverEventArgs e = new HoverEventArgs();
919 e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);
921 // If DispatchHoverMotion is false, Motion event is not dispatched.
922 if (DispatchHoverMotion == false && e.Hover.GetState(0) == PointStateType.Motion)
927 bool consumed = false;
929 if (hoverEventHandler != null)
931 consumed = hoverEventHandler(this, e);
934 if (DispatchParentHoverEvents == false && consumed == false)
936 NUILog.Debug("If DispatchParentHoverEvents is false, it can not dispatch to parent.");
943 // Callback for View InterceptWheel signal
944 private bool OnInterceptWheel(IntPtr view, IntPtr wheelEvent)
946 if (wheelEvent == global::System.IntPtr.Zero)
948 NUILog.Error("wheelEvent should not be null!");
952 // DisallowInterceptWheelEvent prevents the parent from intercepting wheel.
953 if (DisallowInterceptWheelEvent)
958 WheelEventArgs e = new WheelEventArgs();
960 e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
962 bool consumed = false;
964 if (interceptWheelHandler != null)
966 consumed = interceptWheelHandler(this, e);
972 // Callback for View Wheel signal
973 private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
975 if (wheelEvent == global::System.IntPtr.Zero)
977 NUILog.Error("wheelEvent should not be null!");
981 WheelEventArgs e = new WheelEventArgs();
983 e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
985 if (wheelEventHandler != null)
987 return wheelEventHandler(this, e);
992 // Callback for View OnWindow signal
993 private void OnWindow(IntPtr data)
995 if (onWindowEventHandler != null)
997 onWindowEventHandler(this, null);
1001 // Callback for View OffWindow signal
1002 private void OffWindow(IntPtr data)
1004 if (offWindowEventHandler != null)
1006 offWindowEventHandler(this, null);
1010 // Callback for View visibility change signal
1011 private void OnVisibilityChanged(IntPtr data, bool visibility, VisibilityChangeType type)
1013 VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
1014 if (data != IntPtr.Zero)
1016 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
1018 e.Visibility = visibility;
1021 if (visibilityChangedEventHandler != null)
1023 visibilityChangedEventHandler(this, e);
1027 // Callback for View layout direction change signal
1028 private void OnLayoutDirectionChanged(IntPtr data, ViewLayoutDirectionType type)
1030 LayoutDirectionChangedEventArgs e = new LayoutDirectionChangedEventArgs();
1031 if (data != IntPtr.Zero)
1033 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
1037 if (layoutDirectionChangedEventHandler != null)
1039 layoutDirectionChangedEventHandler(this, e);
1043 private void OnResourcesLoaded(IntPtr view)
1045 if(!CheckResourceReady())
1050 if (resourcesLoadedEventHandler != null)
1052 resourcesLoadedEventHandler(this, null);
1056 private void OnBackgroundResourceLoaded(IntPtr view)
1058 BackgroundResourceLoadedEventArgs e = new BackgroundResourceLoadedEventArgs();
1059 e.Status = (ResourceLoadingStatusType)Interop.View.GetVisualResourceStatus(this.SwigCPtr, Property.BACKGROUND);
1061 if (backgroundResourceLoadedEventHandler != null)
1063 backgroundResourceLoadedEventHandler(this, e);
1068 /// Event argument passed through the ChildAdded event.
1070 /// <since_tizen> 5 </since_tizen>
1071 public class ChildAddedEventArgs : EventArgs
1074 /// Added child view at moment.
1076 /// <since_tizen> 5 </since_tizen>
1077 public View Added { get; set; }
1081 /// Event argument passed through the ChildRemoved event.
1083 /// <since_tizen> 5 </since_tizen>
1084 public class ChildRemovedEventArgs : EventArgs
1087 /// Removed child view at moment.
1089 /// <since_tizen> 5 </since_tizen>
1090 public View Removed { get; set; }
1094 /// Event arguments that passed via the KeyEvent signal.
1096 /// <since_tizen> 3 </since_tizen>
1097 public class KeyEventArgs : EventArgs
1102 /// Key - is the key sent to the view.
1104 /// <since_tizen> 3 </since_tizen>
1119 /// Event arguments that passed via the touch signal.
1121 /// <since_tizen> 3 </since_tizen>
1122 public class TouchEventArgs : EventArgs
1124 private Touch _touch;
1127 /// Touch - contains the information of touch points.
1129 /// <since_tizen> 3 </since_tizen>
1144 /// Event arguments that passed via the hover signal.
1146 /// <since_tizen> 3 </since_tizen>
1147 public class HoverEventArgs : EventArgs
1149 private Hover _hover;
1152 /// Hover - contains touch points that represent the points that are currently being hovered or the points where a hover has stopped.
1154 /// <since_tizen> 3 </since_tizen>
1169 /// Event arguments that passed via the wheel signal.
1171 /// <since_tizen> 3 </since_tizen>
1172 public class WheelEventArgs : EventArgs
1174 private Wheel _wheel;
1177 /// WheelEvent - store a wheel rolling type: MOUSE_WHEEL or CUSTOM_WHEEL.
1179 /// <since_tizen> 3 </since_tizen>
1194 /// Event arguments of visibility changed.
1196 /// <since_tizen> 3 </since_tizen>
1197 public class VisibilityChangedEventArgs : EventArgs
1200 private bool _visibility;
1201 private VisibilityChangeType _type;
1204 /// The view, or child of view, whose visibility has changed.
1206 /// <since_tizen> 3 </since_tizen>
1220 /// Whether the view is now visible or not.
1222 /// <since_tizen> 3 </since_tizen>
1223 public bool Visibility
1231 _visibility = value;
1236 /// Whether the view's visible property has changed or a parent's.
1238 /// <since_tizen> 3 </since_tizen>
1239 public VisibilityChangeType Type
1253 /// Event arguments of layout direction changed.
1255 /// <since_tizen> 4 </since_tizen>
1256 public class LayoutDirectionChangedEventArgs : EventArgs
1259 private ViewLayoutDirectionType _type;
1262 /// The view, or child of view, whose layout direction has changed.
1264 /// <since_tizen> 4 </since_tizen>
1278 /// Whether the view's layout direction property has changed or a parent's.
1280 /// <since_tizen> 4 </since_tizen>
1281 public ViewLayoutDirectionType Type
1294 internal class BackgroundResourceLoadedEventArgs : EventArgs
1296 private ResourceLoadingStatusType status = ResourceLoadingStatusType.Invalid;
1297 public ResourceLoadingStatusType Status
1311 /// The class represents the information of the situation where the View's control state changes.
1313 [EditorBrowsable(EditorBrowsableState.Never)]
1314 public class ControlStateChangedEventArgs : EventArgs
1317 /// Create an instance with mandatory fields.
1319 /// <param name="previousState">The previous control state.</param>
1320 /// <param name="currentState">The current control state.</param>
1321 [EditorBrowsable(EditorBrowsableState.Never)]
1322 public ControlStateChangedEventArgs(ControlState previousState, ControlState currentState)
1324 PreviousState = previousState;
1325 CurrentState = currentState;
1329 /// The previous control state.
1331 [EditorBrowsable(EditorBrowsableState.Never)]
1332 public ControlState PreviousState { get; }
1335 /// The current control state.
1337 [EditorBrowsable(EditorBrowsableState.Never)]
1338 public ControlState CurrentState { get; }
1342 /// The expanded touch area.
1343 /// TouchArea can expand the view's touchable area.<br/>
1344 /// If you set the TouchAreaOffset on an view, when you touch the view, the touch area is used rather than the size of the view.<br/>
1347 /// This is based on the top left x, y coordinates.<br/>
1348 /// For example) <br/>
1350 /// view.Size = new Size(100, 100);
1351 /// view.TouchAreaOffset = new Offset(-10, 20, 30, -40); // left, right, bottom, top
1353 /// Then, touch area is 130x170.<br/>
1354 /// This is view.width + TouchAreaOffset.right - TouchAreaOffset.left and view.height + TouchAreaOffset.bottom - TouchAreaOffset.top <br/>
1355 /// +---------------------+ <br/>
1361 /// | +----+----+ | <br/>
1363 /// | -10| | 20 | <br/>
1364 /// |<---+ +----->| <br/>
1367 /// | +----+----+ | <br/>
1372 /// +---------------------+ <br/>
1374 [EditorBrowsable(EditorBrowsableState.Never)]
1375 public Offset TouchAreaOffset
1379 return (Offset)GetValue(TouchAreaOffsetProperty);
1383 SetValue(TouchAreaOffsetProperty, value);
1384 NotifyPropertyChanged();
1388 private Offset InternalTouchAreaOffset
1392 Interop.ActorInternal.GetTouchAreaOffset(SwigCPtr, out int left, out int right, out int bottom, out int top);
1393 if (NDalicPINVOKE.SWIGPendingException.Pending)
1394 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1395 return new Offset(left, right, bottom, top);
1399 Interop.ActorInternal.SetTouchAreaOffset(SwigCPtr, value.Left, value.Right, value.Bottom, value.Top);
1400 if (NDalicPINVOKE.SWIGPendingException.Pending)
1401 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1407 /// Gets or sets the status of whether the view should emit key event signals.
1408 /// If a View's DispatchKeyEvents is set to false, then itself and parents will not receive key event signals.
1410 [EditorBrowsable(EditorBrowsableState.Never)]
1411 public bool DispatchKeyEvents
1415 return (bool)GetValue(DispatchKeyEventsProperty);
1419 SetValue(DispatchKeyEventsProperty, value);
1420 NotifyPropertyChanged();
1425 /// Gets or sets the status of whether touch events can be dispatched.
1426 /// If a View's DispatchTouchEvents is set to false, then it's can not will receive touch and parents will not receive a touch event signal either.
1427 /// This works without adding a TouchEvent callback in the View.
1429 /// If the <see cref="Tizen.NUI.BaseComponents.View.Sensitive"/> is a property that determines whether or not to be hittable, then this property prevents the propagation of the hit touch event.
1432 [EditorBrowsable(EditorBrowsableState.Never)]
1433 public bool DispatchTouchEvents
1437 return dispatchTouchEvents;
1441 if (dispatchTouchEvents != value)
1443 dispatchTouchEvents = value;
1444 if (dispatchTouchEvents == false)
1446 TouchEvent += OnDispatchTouchEvent;
1450 TouchEvent -= OnDispatchTouchEvent;
1456 private bool OnDispatchTouchEvent(object source, View.TouchEventArgs e)
1462 /// Gets or sets the status of whether touch events can be dispatched to the parent.
1463 /// If a View's DispatchParentTouchEvents is set to false, then parents will not receive a touch event signal either.
1464 /// This works without adding a TouchEvent callback in the View.
1466 /// If the <see cref="Tizen.NUI.BaseComponents.View.Sensitive"/> is a property that determines whether or not to be hittable, then this property prevents the propagation of the hit touch event.
1469 [EditorBrowsable(EditorBrowsableState.Never)]
1470 public bool DispatchParentTouchEvents
1474 return dispatchParentTouchEvents;
1478 if (dispatchParentTouchEvents != value)
1480 dispatchParentTouchEvents = value;
1481 if (dispatchParentTouchEvents == false)
1483 TouchEvent += OnDispatchParentTouchEvent;
1487 TouchEvent -= OnDispatchParentTouchEvent;
1493 private bool OnDispatchParentTouchEvent(object source, View.TouchEventArgs e)
1499 /// Gets or sets the status of whether hover events can be dispatched.
1500 /// If a View's DispatchHoverEvents is set to false, then it's can not will receive hover event and parents will not receive a hover event signal either.
1501 /// This works without adding a HoverEvent callback in the View.
1503 /// If the <see cref="Tizen.NUI.BaseComponents.View.Sensitive"/> is a property that determines whether or not to be hittable, then this property prevents the propagation of the hit hover event.
1506 [EditorBrowsable(EditorBrowsableState.Never)]
1507 public bool DispatchHoverEvents
1511 return dispatchHoverEvents;
1515 if (dispatchHoverEvents != value)
1517 dispatchHoverEvents = value;
1518 if (dispatchHoverEvents == false)
1520 HoverEvent += OnDispatchHoverEvent;
1524 HoverEvent -= OnDispatchHoverEvent;
1530 private bool OnDispatchHoverEvent(object source, View.HoverEventArgs e)
1536 /// Gets or sets the status of whether hover events can be dispatched to the parent.
1537 /// If a View's DispatchParentHoverEvents is set to false, then parents will not receive a hover event signal either.
1538 /// This works without adding a HoverEvent callback in the View.
1540 /// If the <see cref="Tizen.NUI.BaseComponents.View.Sensitive"/> is a property that determines whether or not to be hittable, then this property prevents the propagation of the hit hover event.
1543 [EditorBrowsable(EditorBrowsableState.Never)]
1544 public bool DispatchParentHoverEvents
1548 return dispatchParentHoverEvents;
1552 if (dispatchParentHoverEvents != value)
1554 dispatchParentHoverEvents = value;
1555 if (dispatchParentHoverEvents == false)
1557 HoverEvent += OnDispatchParentHoverEvent;
1561 HoverEvent -= OnDispatchParentHoverEvent;
1567 private bool OnDispatchParentHoverEvent(object source, View.HoverEventArgs e)
1573 /// Gets or sets the status of whether the view should emit Gesture event signals.
1574 /// If a View's DispatchGestureEvents is set to false, then itself and parents will not receive all gesture event signals.
1575 /// The itself and parents does not receive tap, pinch, pan, rotation, or longpress gestures.
1577 [EditorBrowsable(EditorBrowsableState.Never)]
1578 public bool DispatchGestureEvents
1582 return dispatchGestureEvents;
1586 if (dispatchGestureEvents != value)
1588 dispatchGestureEvents = value;
1589 ConfigGestureDetector(dispatchGestureEvents);
1595 /// Gets or sets the status of whether the view should emit Gesture event signals.
1596 /// If a View's DispatchParentGestureEvents is set to false, then parents will not receive all gesture event signals.
1597 /// The parents does not receive tap, pinch, pan, rotation, or longpress gestures.
1599 [EditorBrowsable(EditorBrowsableState.Never)]
1600 public bool DispatchParentGestureEvents
1604 return dispatchParentGestureEvents;
1608 if (dispatchParentGestureEvents != value)
1610 dispatchParentGestureEvents = value;
1611 ConfigGestureDetector(dispatchParentGestureEvents);
1616 private void ConfigGestureDetector(bool dispatch)
1618 if (panGestureDetector == null) panGestureDetector = new PanGestureDetector();
1619 if (longGestureDetector == null) longGestureDetector = new LongPressGestureDetector();
1620 if (pinchGestureDetector == null) pinchGestureDetector = new PinchGestureDetector();
1621 if (tapGestureDetector == null) tapGestureDetector = new TapGestureDetector();
1622 if (rotationGestureDetector == null) rotationGestureDetector = new RotationGestureDetector();
1624 if (dispatch == true)
1626 configGestureCount = configGestureCount > 0 ? configGestureCount - 1 : 0;
1627 if (configGestureCount == 0)
1629 panGestureDetector.Detach(this);
1630 longGestureDetector.Detach(this);
1631 pinchGestureDetector.Detach(this);
1632 tapGestureDetector.Detach(this);
1633 rotationGestureDetector.Detach(this);
1635 panGestureDetector.Detected -= OnGestureDetected;
1636 longGestureDetector.Detected -= OnGestureDetected;
1637 pinchGestureDetector.Detected -= OnGestureDetected;
1638 tapGestureDetector.Detected -= OnGestureDetected;
1639 rotationGestureDetector.Detected -= OnGestureDetected;
1644 if (configGestureCount == 0)
1646 panGestureDetector.Attach(this);
1647 longGestureDetector.Attach(this);
1648 pinchGestureDetector.Attach(this);
1649 tapGestureDetector.Attach(this);
1650 rotationGestureDetector.Attach(this);
1652 panGestureDetector.Detected += OnGestureDetected;
1653 longGestureDetector.Detected += OnGestureDetected;
1654 pinchGestureDetector.Detected += OnGestureDetected;
1655 tapGestureDetector.Detected += OnGestureDetected;
1656 rotationGestureDetector.Detected += OnGestureDetected;
1658 configGestureCount++;
1662 private void OnGestureDetected(object source, EventArgs e)
1664 // Does notting. This is to consume the gesture.
1668 /// Gets or sets the status of whether motion event of Touch can be dispatched.
1669 /// If a View's DispatchTouchMotion is set to false, then it's can not will receive motion event of TouchEvent.
1671 [EditorBrowsable(EditorBrowsableState.Never)]
1672 public bool DispatchTouchMotion
1676 return dispatchTouchMotion;
1680 dispatchTouchMotion = value;
1685 /// Gets or sets the status of whether motion event of Hover can be dispatched.
1686 /// If a View's DispatchHoverMotion is set to false, then it's can not will receive motion event of HoverEvent.
1688 [EditorBrowsable(EditorBrowsableState.Never)]
1689 public bool DispatchHoverMotion
1693 return dispatchHoverMotion;
1697 dispatchHoverMotion = value;