src/Tizen.NUI/src/public/BaseComponents/ViewEvent.cs

   1 /*
   2  * Copyright(c) 2021 Samsung Electronics Co., Ltd.
   3  *
   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
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  *
  16  */
  17
  18 using System;
  19 using System.ComponentModel;
  20 using System.Runtime.InteropServices;
  21
  22 namespace Tizen.NUI.BaseComponents
  23 {
  24     /// <summary>
  25     /// View is the base class for all views.
  26     /// </summary>
  27     /// <since_tizen> 3 </since_tizen>
  28     public partial class View
  29     {
  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;
  47
  48         private KeyInputFocusGainedCallbackType keyInputFocusGainedCallback;
  49         private EventHandler keyInputFocusLostEventHandler;
  50
  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;
  64
  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);
  81
  82         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  83         private delegate void KeyInputFocusGainedCallbackType(IntPtr control);
  84         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  85         private delegate void KeyInputFocusLostCallbackType(IntPtr control);
  86
  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);
  93
  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;
 109
 110
 111         /// <summary>
 112         /// Event when a child is removed.
 113         /// </summary>
 114         /// <since_tizen> 5 </since_tizen>
 115         public new event EventHandler<ChildRemovedEventArgs> ChildRemoved;
 116         /// <summary>
 117         /// Event when a child is added.
 118         /// </summary>
 119         /// <since_tizen> 5 </since_tizen>
 120         public new event EventHandler<ChildAddedEventArgs> ChildAdded;
 121
 122         /// <summary>
 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 />
 125         /// </summary>
 126         /// <since_tizen> 3 </since_tizen>
 127         public event EventHandler FocusGained
 128         {
 129             add
 130             {
 131                 if (keyInputFocusGainedEventHandler == null)
 132                 {
 133                     keyInputFocusGainedCallback = OnKeyInputFocusGained;
 134                     Interop.ViewSignal.KeyInputFocusGainedConnect(SwigCPtr, keyInputFocusGainedCallback.ToHandleRef(this));
 135                     NDalicPINVOKE.ThrowExceptionIfExists();
 136                 }
 137                 keyInputFocusGainedEventHandler += value;
 138             }
 139
 140             remove
 141             {
 142                 keyInputFocusGainedEventHandler -= value;
 143                 if (keyInputFocusGainedEventHandler == null && keyInputFocusGainedCallback != null)
 144                 {
 145                     Interop.ViewSignal.KeyInputFocusGainedDisconnect(SwigCPtr, keyInputFocusGainedCallback.ToHandleRef(this));
 146                     NDalicPINVOKE.ThrowExceptionIfExists();
 147                     keyInputFocusGainedCallback = null;
 148                 }
 149             }
 150         }
 151
 152         /// <summary>
 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 />
 155         /// </summary>
 156         /// <since_tizen> 3 </since_tizen>
 157         public event EventHandler FocusLost
 158         {
 159             add
 160             {
 161                 if (keyInputFocusLostEventHandler == null)
 162                 {
 163                     keyInputFocusLostCallback = OnKeyInputFocusLost;
 164                     Interop.ViewSignal.KeyInputFocusLostConnect(SwigCPtr, keyInputFocusLostCallback.ToHandleRef(this));
 165                     NDalicPINVOKE.ThrowExceptionIfExists();
 166                 }
 167                 keyInputFocusLostEventHandler += value;
 168             }
 169
 170             remove
 171             {
 172                 keyInputFocusLostEventHandler -= value;
 173                 if (keyInputFocusLostEventHandler == null && keyInputFocusLostCallback != null)
 174                 {
 175                     Interop.ViewSignal.KeyInputFocusLostDisconnect(SwigCPtr, keyInputFocusLostCallback.ToHandleRef(this));
 176                     NDalicPINVOKE.ThrowExceptionIfExists();
 177                     keyInputFocusLostCallback = null;
 178                 }
 179             }
 180         }
 181
 182         /// <summary>
 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 />
 185         /// </summary>
 186         /// <since_tizen> 3 </since_tizen>
 187         public event EventHandlerWithReturnType<object, KeyEventArgs, bool> KeyEvent
 188         {
 189             add
 190             {
 191                 if (keyEventHandler == null)
 192                 {
 193                     keyCallback = OnKeyEvent;
 194                     Interop.ViewSignal.KeyEventConnect(SwigCPtr, keyCallback.ToHandleRef(this));
 195                     NDalicPINVOKE.ThrowExceptionIfExists();
 196                 }
 197                 keyEventHandler += value;
 198             }
 199
 200             remove
 201             {
 202                 keyEventHandler -= value;
 203                 if (keyEventHandler == null && keyCallback != null)
 204                 {
 205                     Interop.ViewSignal.KeyEventDisconnect(SwigCPtr, keyCallback.ToHandleRef(this));
 206                     NDalicPINVOKE.ThrowExceptionIfExists();
 207                     keyCallback = null;
 208                 }
 209             }
 210         }
 211
 212         /// <summary>
 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 />
 215         /// </summary>
 216         /// <since_tizen> 3 </since_tizen>
 217         public event EventHandler Relayout
 218         {
 219             add
 220             {
 221                 if (onRelayoutEventHandler == null)
 222                 {
 223                     onRelayoutEventCallback = OnRelayout;
 224                     Interop.ActorSignal.OnRelayoutConnect(SwigCPtr, onRelayoutEventCallback.ToHandleRef(this));
 225                     NDalicPINVOKE.ThrowExceptionIfExists();
 226                 }
 227                 onRelayoutEventHandler += value;
 228             }
 229
 230             remove
 231             {
 232                 onRelayoutEventHandler -= value;
 233                 if (onRelayoutEventHandler == null && onRelayoutEventCallback != null)
 234                 {
 235                     Interop.ActorSignal.OnRelayoutDisconnect(SwigCPtr, onRelayoutEventCallback.ToHandleRef(this));
 236                     NDalicPINVOKE.ThrowExceptionIfExists();
 237                     onRelayoutEventCallback = null;
 238                 }
 239             }
 240         }
 241
 242         /// <summary>
 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 />
 247         /// </summary>
 248         [EditorBrowsable(EditorBrowsableState.Never)]
 249         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> InterceptTouchEvent
 250         {
 251             add
 252             {
 253                 if (interceptTouchDataEventHandler == null)
 254                 {
 255                     interceptTouchDataCallback = OnInterceptTouch;
 256                     Interop.ActorSignal.InterceptTouchConnect(SwigCPtr, interceptTouchDataCallback.ToHandleRef(this));
 257                     NDalicPINVOKE.ThrowExceptionIfExists();
 258                 }
 259                 interceptTouchDataEventHandler += value;
 260             }
 261
 262             remove
 263             {
 264                 interceptTouchDataEventHandler -= value;
 265                 if (interceptTouchDataEventHandler == null && interceptTouchDataCallback != null)
 266                 {
 267                     Interop.ActorSignal.InterceptTouchDisconnect(SwigCPtr, interceptTouchDataCallback.ToHandleRef(this));
 268                     NDalicPINVOKE.ThrowExceptionIfExists();
 269                     interceptTouchDataCallback = null;
 270                 }
 271             }
 272         }
 273
 274         /// <summary>
 275         /// If child view doesn't want the parent's view to intercept the touch, you can set it to true.
 276         /// for example :
 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.
 282         /// </summary>
 283         [EditorBrowsable(EditorBrowsableState.Never)]
 284         public bool DisallowInterceptTouchEvent { get; set; }
 285
 286
 287         /// <summary>
 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 />
 290         /// </summary>
 291         /// <since_tizen> 3 </since_tizen>
 292         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> TouchEvent
 293         {
 294             add
 295             {
 296                 if (touchDataEventHandler == null)
 297                 {
 298                     touchDataCallback = OnTouch;
 299                     Interop.ActorSignal.TouchConnect(SwigCPtr, touchDataCallback.ToHandleRef(this));
 300                     NDalicPINVOKE.ThrowExceptionIfExists();
 301                 }
 302                 touchDataEventHandler += value;
 303             }
 304
 305             remove
 306             {
 307                 touchDataEventHandler -= value;
 308                 if (touchDataEventHandler == null && touchDataCallback != null)
 309                 {
 310                     Interop.ActorSignal.TouchDisconnect(SwigCPtr, touchDataCallback.ToHandleRef(this));
 311                     NDalicPINVOKE.ThrowExceptionIfExists();
 312                     touchDataCallback = null;
 313                 }
 314             }
 315         }
 316
 317         /// <summary>
 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 />
 320         /// </summary>
 321         /// <since_tizen> 3 </since_tizen>
 322         public event EventHandlerWithReturnType<object, HoverEventArgs, bool> HoverEvent
 323         {
 324             add
 325             {
 326                 if (hoverEventHandler == null)
 327                 {
 328                     hoverEventCallback = OnHoverEvent;
 329                     Interop.ActorSignal.HoveredConnect(SwigCPtr, hoverEventCallback.ToHandleRef(this));
 330                     NDalicPINVOKE.ThrowExceptionIfExists();
 331                 }
 332                 hoverEventHandler += value;
 333             }
 334
 335             remove
 336             {
 337                 hoverEventHandler -= value;
 338                 if (hoverEventHandler == null && hoverEventCallback != null)
 339                 {
 340                     Interop.ActorSignal.HoveredDisconnect(SwigCPtr, hoverEventCallback.ToHandleRef(this));
 341                     NDalicPINVOKE.ThrowExceptionIfExists();
 342                     hoverEventCallback = null;
 343                 }
 344             }
 345         }
 346
 347         /// <summary>
 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 />
 352         /// </summary>
 353         [EditorBrowsable(EditorBrowsableState.Never)]
 354         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> InterceptWheelEvent
 355         {
 356             add
 357             {
 358                 if (interceptWheelHandler == null)
 359                 {
 360                     interceptWheelCallback = OnInterceptWheel;
 361                     Interop.ActorSignal.InterceptWheelConnect(SwigCPtr, interceptWheelCallback.ToHandleRef(this));
 362                     NDalicPINVOKE.ThrowExceptionIfExists();
 363                 }
 364                 interceptWheelHandler += value;
 365             }
 366
 367             remove
 368             {
 369                 interceptWheelHandler -= value;
 370                 if (interceptWheelHandler == null && interceptWheelCallback != null)
 371                 {
 372                     Interop.ActorSignal.InterceptWheelDisconnect(SwigCPtr, interceptWheelCallback.ToHandleRef(this));
 373                     NDalicPINVOKE.ThrowExceptionIfExists();
 374                     interceptWheelCallback = null;
 375                 }
 376             }
 377         }
 378
 379         /// <summary>
 380         /// If child view doesn't want the parent's view to intercept the wheel event, you can set it to true.
 381         /// for example :
 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.
 387         /// </summary>
 388         [EditorBrowsable(EditorBrowsableState.Never)]
 389         public bool DisallowInterceptWheelEvent { get; set; }
 390
 391         /// <summary>
 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 />
 394         /// </summary>
 395         /// <since_tizen> 3 </since_tizen>
 396         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelEvent
 397         {
 398             add
 399             {
 400                 if (wheelEventHandler == null)
 401                 {
 402                     wheelEventCallback = OnWheelEvent;
 403                     Interop.ActorSignal.WheelEventConnect(SwigCPtr, wheelEventCallback.ToHandleRef(this));
 404                     NDalicPINVOKE.ThrowExceptionIfExists();
 405                 }
 406                 wheelEventHandler += value;
 407             }
 408
 409             remove
 410             {
 411                 wheelEventHandler -= value;
 412                 if (wheelEventHandler == null && wheelEventCallback != null)
 413                 {
 414                     Interop.ActorSignal.WheelEventDisconnect(SwigCPtr, wheelEventCallback.ToHandleRef(this));
 415                     NDalicPINVOKE.ThrowExceptionIfExists();
 416                     wheelEventCallback = null;
 417                 }
 418             }
 419         }
 420
 421         /// <summary>
 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 />
 424         /// </summary>
 425         /// <since_tizen> 3 </since_tizen>
 426         public event EventHandler AddedToWindow
 427         {
 428             add
 429             {
 430                 if (onWindowEventHandler == null)
 431                 {
 432                     onWindowEventCallback = OnWindow;
 433                     Interop.ActorSignal.OnSceneConnect(SwigCPtr, onWindowEventCallback.ToHandleRef(this));
 434                     NDalicPINVOKE.ThrowExceptionIfExists();
 435                 }
 436                 onWindowEventHandler += value;
 437             }
 438
 439             remove
 440             {
 441                 onWindowEventHandler -= value;
 442                 if (onWindowEventHandler == null && onWindowEventCallback != null)
 443                 {
 444                     Interop.ActorSignal.OnSceneDisconnect(SwigCPtr, onWindowEventCallback.ToHandleRef(this));
 445                     NDalicPINVOKE.ThrowExceptionIfExists();
 446                     onWindowEventCallback = null;
 447                 }
 448             }
 449         }
 450
 451         /// <summary>
 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 />
 454         /// </summary>
 455         /// <since_tizen> 3 </since_tizen>
 456         public event EventHandler RemovedFromWindow
 457         {
 458             add
 459             {
 460                 if (offWindowEventHandler == null)
 461                 {
 462                     offWindowEventCallback = OffWindow;
 463                     Interop.ActorSignal.OffSceneConnect(SwigCPtr, offWindowEventCallback.ToHandleRef(this));
 464                     NDalicPINVOKE.ThrowExceptionIfExists();
 465                 }
 466                 offWindowEventHandler += value;
 467             }
 468
 469             remove
 470             {
 471                 offWindowEventHandler -= value;
 472                 if (offWindowEventHandler == null && offWindowEventCallback != null)
 473                 {
 474                     Interop.ActorSignal.OffSceneDisconnect(SwigCPtr, offWindowEventCallback.ToHandleRef(this));
 475                     NDalicPINVOKE.ThrowExceptionIfExists();
 476                     offWindowEventCallback = null;
 477                 }
 478             }
 479         }
 480         /// <summary>
 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 />
 483         /// </summary>
 484         /// <remarks>
 485         /// <para>
 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.
 488         /// </para>
 489         /// <para>
 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.
 493         /// </para>
 494         /// </remarks>
 495         /// <since_tizen> 3 </since_tizen>
 496         public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
 497         {
 498             add
 499             {
 500                 if (visibilityChangedEventHandler == null)
 501                 {
 502                     visibilityChangedEventCallback = OnVisibilityChanged;
 503                     Interop.ActorSignal.VisibilityChangedConnect(SwigCPtr, visibilityChangedEventCallback.ToHandleRef(this));
 504                     NDalicPINVOKE.ThrowExceptionIfExists();
 505                 }
 506                 visibilityChangedEventHandler += value;
 507             }
 508
 509             remove
 510             {
 511                 visibilityChangedEventHandler -= value;
 512                 if (visibilityChangedEventHandler == null && visibilityChangedEventCallback != null)
 513                 {
 514                     Interop.ActorSignal.VisibilityChangedDisconnect(SwigCPtr, visibilityChangedEventCallback.ToHandleRef(this));
 515                     NDalicPINVOKE.ThrowExceptionIfExists();
 516                     visibilityChangedEventCallback = null;
 517                 }
 518             }
 519         }
 520
 521         /// <summary>
 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 />
 524         /// </summary>
 525         /// <since_tizen> 4 </since_tizen>
 526         public event EventHandler<LayoutDirectionChangedEventArgs> LayoutDirectionChanged
 527         {
 528             add
 529             {
 530                 if (layoutDirectionChangedEventHandler == null)
 531                 {
 532                     layoutDirectionChangedEventCallback = OnLayoutDirectionChanged;
 533                     Interop.ActorSignal.LayoutDirectionChangedConnect(SwigCPtr, layoutDirectionChangedEventCallback.ToHandleRef(this));
 534                     NDalicPINVOKE.ThrowExceptionIfExists();
 535                 }
 536
 537                 layoutDirectionChangedEventHandler += value;
 538             }
 539
 540             remove
 541             {
 542                 layoutDirectionChangedEventHandler -= value;
 543
 544                 if (layoutDirectionChangedEventHandler == null && layoutDirectionChangedEventCallback != null)
 545                 {
 546                     Interop.ActorSignal.LayoutDirectionChangedDisconnect(SwigCPtr, layoutDirectionChangedEventCallback.ToHandleRef(this));
 547                     NDalicPINVOKE.ThrowExceptionIfExists();
 548                     layoutDirectionChangedEventCallback = null;
 549                 }
 550             }
 551         }
 552
 553         /// <summary>
 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 />
 556         /// </summary>
 557         /// <since_tizen> 3 </since_tizen>
 558         public event EventHandler ResourcesLoaded
 559         {
 560             add
 561             {
 562                 if (resourcesLoadedEventHandler == null)
 563                 {
 564                     resourcesLoadedCallback = OnResourcesLoaded;
 565                     Interop.ViewSignal.ResourceReadyConnect(SwigCPtr, resourcesLoadedCallback.ToHandleRef(this));
 566                     NDalicPINVOKE.ThrowExceptionIfExists();
 567                 }
 568                 resourcesLoadedEventHandler += value;
 569             }
 570
 571             remove
 572             {
 573                 resourcesLoadedEventHandler -= value;
 574                 if (resourcesLoadedEventHandler == null && resourcesLoadedCallback != null)
 575                 {
 576                     Interop.ViewSignal.ResourceReadyDisconnect(SwigCPtr, resourcesLoadedCallback.ToHandleRef(this));
 577                     NDalicPINVOKE.ThrowExceptionIfExists();
 578                     resourcesLoadedCallback = null;
 579                 }
 580             }
 581         }
 582
 583         private EventHandler _backKeyPressed;
 584
 585         /// <summary>
 586         /// An event for getting notice when physical back key is pressed.<br />
 587         /// This event is emitted BackKey is up.<br />
 588         /// </summary>
 589         [EditorBrowsable(EditorBrowsableState.Never)]
 590         public event EventHandler BackKeyPressed
 591         {
 592             add
 593             {
 594                 _backKeyPressed += value;
 595                 BackKeyManager.Instance.Subscriber.Add(this);
 596             }
 597
 598             remove
 599             {
 600                 BackKeyManager.Instance.Subscriber.Remove(this);
 601                 _backKeyPressed -= value;
 602             }
 603         }
 604
 605         /// <summary>
 606         /// Function for emitting BackKeyPressed event outside of View instance
 607         /// </summary>
 608         [EditorBrowsable(EditorBrowsableState.Never)]
 609         internal void EmitBackKeyPressed()
 610         {
 611             _backKeyPressed.Invoke(this, null);
 612         }
 613
 614
 615         internal event EventHandler<BackgroundResourceLoadedEventArgs> BackgroundResourceLoaded
 616         {
 617             add
 618             {
 619                 if (backgroundResourceLoadedEventHandler == null)
 620                 {
 621                     backgroundResourceLoadedCallback = OnBackgroundResourceLoaded;
 622                     Interop.ViewSignal.ResourceReadyConnect(SwigCPtr, backgroundResourceLoadedCallback.ToHandleRef(this));
 623                     NDalicPINVOKE.ThrowExceptionIfExists();
 624                 }
 625                 backgroundResourceLoadedEventHandler += value;
 626             }
 627
 628             remove
 629             {
 630                 backgroundResourceLoadedEventHandler -= value;
 631                 if (backgroundResourceLoadedEventHandler == null && backgroundResourceLoadedCallback != null)
 632                 {
 633                     Interop.ViewSignal.ResourceReadyDisconnect(SwigCPtr, backgroundResourceLoadedCallback.ToHandleRef(this));
 634                     NDalicPINVOKE.ThrowExceptionIfExists();
 635                     backgroundResourceLoadedCallback = null;
 636                 }
 637             }
 638         }
 639
 640         private void OnColorChanged(float r, float g, float b, float a)
 641         {
 642             Color = new Color(r, g, b, a);
 643         }
 644
 645         private void OnMinimumSizeChanged(int width, int height)
 646         {
 647             MinimumSize = new Size2D(width, height);
 648         }
 649
 650         private void OnMaximumSizeChanged(int width, int height)
 651         {
 652             MaximumSize = new Size2D(width, height);
 653         }
 654
 655         private void OnPosition2DChanged(int x, int y)
 656         {
 657             SetPosition((float)x, (float)y, 0);
 658         }
 659
 660         private void OnPositionChanged(float x, float y, float z)
 661         {
 662             SetPosition(x, y, z);
 663         }
 664
 665         private void OnSize2DChanged(int width, int height)
 666         {
 667             SetSize((float)width, (float)height, 0);
 668         }
 669
 670         private void OnSizeChanged(float width, float height, float depth)
 671         {
 672             SetSize(width, height, depth);
 673         }
 674
 675         private void OnParentOriginChanged(float x, float y, float z)
 676         {
 677             ParentOrigin = new Position(x, y, z);
 678         }
 679
 680         private void OnPivotPointChanged(float x, float y, float z)
 681         {
 682             PivotPoint = new Position(x, y, z);
 683         }
 684
 685         private void OnImageShadowChanged(ShadowBase instance)
 686         {
 687             ImageShadow = (ImageShadow)instance;
 688         }
 689
 690         private void OnBoxShadowChanged(ShadowBase instance)
 691         {
 692             BoxShadow = (Shadow)instance;
 693         }
 694
 695         private void OnBackgroundImageBorderChanged(int left, int right, int bottom, int top)
 696         {
 697             BackgroundImageBorder = new Rectangle(left, right, bottom, top);
 698         }
 699
 700         private void OnKeyInputFocusGained(IntPtr view)
 701         {
 702             if (IsNativeHandleInvalid())
 703             {
 704                 if (this.Disposed)
 705                 {
 706                     if (keyInputFocusGainedEventHandler != null)
 707                     {
 708                         using var process = global::System.Diagnostics.Process.GetCurrentProcess();
 709                         var processId = process.Id;
 710                         var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
 711                         var me = this.GetType().FullName;
 712
 713                         throw new ObjectDisposedException(nameof(SwigCPtr), $"Error! NUI's native dali object is already disposed. " +
 714                             $"OR the native dali object handle of NUI becomes null! \n" +
 715                             $" process:{processId} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
 716                     }
 717                 }
 718                 else
 719                 {
 720                     if (this.IsDisposeQueued)
 721                     {
 722                         var process = global::System.Diagnostics.Process.GetCurrentProcess().Id;
 723                         var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
 724                         var me = this.GetType().FullName;
 725
 726                         //in this case, the View object is ready to be disposed waiting on DisposeQueue, so event callback should not be invoked!
 727                         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" +
 728                             $"process:{process} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
 729                         return;
 730                     }
 731                 }
 732             }
 733
 734             keyInputFocusGainedEventHandler?.Invoke(this, null);
 735         }
 736
 737         private void OnKeyInputFocusLost(IntPtr view)
 738         {
 739             if (IsNativeHandleInvalid())
 740             {
 741                 if (this.Disposed)
 742                 {
 743                     if (keyInputFocusLostEventHandler != null)
 744                     {
 745                         var process = global::System.Diagnostics.Process.GetCurrentProcess().Id;
 746                         var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
 747                         var me = this.GetType().FullName;
 748
 749                         throw new ObjectDisposedException(nameof(SwigCPtr), $"Error! NUI's native dali object is already disposed. " +
 750                             $"OR the native dali object handle of NUI becomes null! \n" +
 751                             $" process:{process} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
 752                     }
 753                 }
 754                 else
 755                 {
 756                     if (this.IsDisposeQueued)
 757                     {
 758                         var process = global::System.Diagnostics.Process.GetCurrentProcess().Id;
 759                         var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
 760                         var me = this.GetType().FullName;
 761
 762                         //in this case, the View object is ready to be disposed waiting on DisposeQueue, so event callback should not be invoked!
 763                         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" +
 764                             $"process:{process} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
 765                         return;
 766                     }
 767                 }
 768             }
 769
 770             keyInputFocusLostEventHandler?.Invoke(this, null);
 771         }
 772
 773         private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
 774         {
 775             if (keyEvent == global::System.IntPtr.Zero)
 776             {
 777                 NUILog.Error("keyEvent should not be null!");
 778                 return true;
 779             }
 780
 781             KeyEventArgs e = new KeyEventArgs();
 782
 783             bool result = false;
 784
 785             e.Key = Tizen.NUI.Key.GetKeyFromPtr(keyEvent);
 786
 787             if (keyEventHandler != null)
 788             {
 789                 Delegate[] delegateList = keyEventHandler.GetInvocationList();
 790
 791                 // Oring the result of each callback.
 792                 foreach (EventHandlerWithReturnType<object, KeyEventArgs, bool> del in delegateList)
 793                 {
 794                     result |= del(this, e);
 795                 }
 796             }
 797
 798             return result;
 799         }
 800
 801         // Callback for View OnRelayout signal
 802         private void OnRelayout(IntPtr data)
 803         {
 804             if (onRelayoutEventHandler != null)
 805             {
 806                 onRelayoutEventHandler(this, null);
 807             }
 808         }
 809
 810         // Callback for View HitTestResultSignal
 811         private bool OnHitTestResult(IntPtr view, IntPtr touchData)
 812         {
 813             if (touchData == global::System.IntPtr.Zero)
 814             {
 815                 NUILog.Error("touchData should not be null!");
 816                 return true;
 817             }
 818
 819             TouchEventArgs e = new TouchEventArgs();
 820             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 821             return HitTest(e.Touch);
 822         }
 823
 824         // Callback for View TouchSignal
 825         private bool OnInterceptTouch(IntPtr view, IntPtr touchData)
 826         {
 827             if (touchData == global::System.IntPtr.Zero)
 828             {
 829                 NUILog.Error("touchData should not be null!");
 830                 return true;
 831             }
 832
 833             // DisallowInterceptTouchEvent prevents the parent from intercepting touch.
 834             if (DisallowInterceptTouchEvent)
 835             {
 836                 return false;
 837             }
 838
 839             TouchEventArgs e = new TouchEventArgs();
 840             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 841
 842             // If DispatchTouchMotion is false, Motion event is not dispatched.
 843             if (DispatchTouchMotion == false && e.Touch.GetState(0) == PointStateType.Motion)
 844             {
 845                 return true;
 846             }
 847
 848             bool consumed = false;
 849
 850             if (interceptTouchDataEventHandler != null)
 851             {
 852                 consumed = interceptTouchDataEventHandler(this, e);
 853             }
 854
 855             return consumed;
 856         }
 857
 858         // Callback for View TouchSignal
 859         private bool OnTouch(IntPtr view, IntPtr touchData)
 860         {
 861             if (touchData == global::System.IntPtr.Zero)
 862             {
 863                 NUILog.Error("touchData should not be null!");
 864                 return true;
 865             }
 866
 867             if (DispatchTouchEvents == false)
 868             {
 869                 NUILog.Debug("If DispatchTouchEvents is false, it can not dispatch.");
 870                 return true;
 871             }
 872
 873             TouchEventArgs e = new TouchEventArgs();
 874             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 875
 876             // If DispatchTouchMotion is false, Motion event is not dispatched.
 877             if (DispatchTouchMotion == false && e.Touch.GetState(0) == PointStateType.Motion)
 878             {
 879                 return true;
 880             }
 881
 882
 883             bool consumed = false;
 884
 885             if (touchDataEventHandler != null)
 886             {
 887                 consumed = touchDataEventHandler(this, e);
 888             }
 889
 890             if (enableControlState && !consumed)
 891             {
 892                 consumed = HandleControlStateOnTouch(e.Touch);
 893             }
 894
 895             if (DispatchParentTouchEvents == false)
 896             {
 897                 NUILog.Debug("If DispatchParentTouchEvents is false, it can not dispatch to parent.");
 898                 return true;
 899             }
 900
 901             return consumed;
 902         }
 903
 904         // Callback for View Hover signal
 905         private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
 906         {
 907             if (hoverEvent == global::System.IntPtr.Zero)
 908             {
 909                 NUILog.Error("hoverEvent should not be null!");
 910                 return true;
 911             }
 912
 913             if (DispatchHoverEvents == false)
 914             {
 915                 NUILog.Debug("If DispatchHoverEvents is false, it can not dispatch.");
 916                 return true;
 917             }
 918
 919             HoverEventArgs e = new HoverEventArgs();
 920             e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);
 921
 922             // If DispatchHoverMotion is false, Motion event is not dispatched.
 923             if (DispatchHoverMotion == false && e.Hover.GetState(0) == PointStateType.Motion)
 924             {
 925                 return true;
 926             }
 927
 928             bool consumed = false;
 929
 930             if (hoverEventHandler != null)
 931             {
 932                 consumed = hoverEventHandler(this, e);
 933             }
 934
 935             if (DispatchParentHoverEvents == false && consumed == false)
 936             {
 937                 NUILog.Debug("If DispatchParentHoverEvents is false, it can not dispatch to parent.");
 938                 return true;
 939             }
 940
 941             return consumed;
 942         }
 943
 944         // Callback for View InterceptWheel signal
 945         private bool OnInterceptWheel(IntPtr view, IntPtr wheelEvent)
 946         {
 947             if (wheelEvent == global::System.IntPtr.Zero)
 948             {
 949                 NUILog.Error("wheelEvent should not be null!");
 950                 return true;
 951             }
 952
 953             // DisallowInterceptWheelEvent prevents the parent from intercepting wheel.
 954             if (DisallowInterceptWheelEvent)
 955             {
 956                 return false;
 957             }
 958
 959             WheelEventArgs e = new WheelEventArgs();
 960
 961             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 962
 963             bool consumed = false;
 964
 965             if (interceptWheelHandler != null)
 966             {
 967                 consumed = interceptWheelHandler(this, e);
 968             }
 969
 970             return consumed;
 971         }
 972
 973         // Callback for View Wheel signal
 974         private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
 975         {
 976             if (wheelEvent == global::System.IntPtr.Zero)
 977             {
 978                 NUILog.Error("wheelEvent should not be null!");
 979                 return true;
 980             }
 981
 982             WheelEventArgs e = new WheelEventArgs();
 983
 984             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 985
 986             if (wheelEventHandler != null)
 987             {
 988                 return wheelEventHandler(this, e);
 989             }
 990             return false;
 991         }
 992
 993         // Callback for View OnWindow signal
 994         private void OnWindow(IntPtr data)
 995         {
 996             if (onWindowEventHandler != null)
 997             {
 998                 onWindowEventHandler(this, null);
 999             }
1000         }
1001
1002         // Callback for View OffWindow signal
1003         private void OffWindow(IntPtr data)
1004         {
1005             if (offWindowEventHandler != null)
1006             {
1007                 offWindowEventHandler(this, null);
1008             }
1009         }
1010
1011         // Callback for View visibility change signal
1012         private void OnVisibilityChanged(IntPtr data, bool visibility, VisibilityChangeType type)
1013         {
1014             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
1015             if (data != IntPtr.Zero)
1016             {
1017                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
1018             }
1019             e.Visibility = visibility;
1020             e.Type = type;
1021
1022             if (visibilityChangedEventHandler != null)
1023             {
1024                 visibilityChangedEventHandler(this, e);
1025             }
1026         }
1027
1028         // Callback for View layout direction change signal
1029         private void OnLayoutDirectionChanged(IntPtr data, ViewLayoutDirectionType type)
1030         {
1031             LayoutDirectionChangedEventArgs e = new LayoutDirectionChangedEventArgs();
1032             if (data != IntPtr.Zero)
1033             {
1034                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
1035             }
1036             e.Type = type;
1037
1038             if (layoutDirectionChangedEventHandler != null)
1039             {
1040                 layoutDirectionChangedEventHandler(this, e);
1041             }
1042         }
1043
1044         private void OnResourcesLoaded(IntPtr view)
1045         {
1046             if(!CheckResourceReady())
1047             {
1048                 return;
1049             }
1050
1051             if (resourcesLoadedEventHandler != null)
1052             {
1053                 resourcesLoadedEventHandler(this, null);
1054             }
1055         }
1056
1057         private void OnBackgroundResourceLoaded(IntPtr view)
1058         {
1059             BackgroundResourceLoadedEventArgs e = new BackgroundResourceLoadedEventArgs();
1060             e.Status = (ResourceLoadingStatusType)Interop.View.GetVisualResourceStatus(this.SwigCPtr, Property.BACKGROUND);
1061
1062             if (backgroundResourceLoadedEventHandler != null)
1063             {
1064                 backgroundResourceLoadedEventHandler(this, e);
1065             }
1066         }
1067
1068         /// <summary>
1069         /// Event argument passed through the ChildAdded event.
1070         /// </summary>
1071         /// <since_tizen> 5 </since_tizen>
1072         public class ChildAddedEventArgs : EventArgs
1073         {
1074             /// <summary>
1075             /// Added child view at moment.
1076             /// </summary>
1077             /// <since_tizen> 5 </since_tizen>
1078             public View Added { get; set; }
1079         }
1080
1081         /// <summary>
1082         /// Event argument passed through the ChildRemoved event.
1083         /// </summary>
1084         /// <since_tizen> 5 </since_tizen>
1085         public class ChildRemovedEventArgs : EventArgs
1086         {
1087             /// <summary>
1088             /// Removed child view at moment.
1089             /// </summary>
1090             /// <since_tizen> 5 </since_tizen>
1091             public View Removed { get; set; }
1092         }
1093
1094         /// <summary>
1095         /// Event arguments that passed via the KeyEvent signal.
1096         /// </summary>
1097         /// <since_tizen> 3 </since_tizen>
1098         public class KeyEventArgs : EventArgs
1099         {
1100             private Key _key;
1101
1102             /// <summary>
1103             /// Key - is the key sent to the view.
1104             /// </summary>
1105             /// <since_tizen> 3 </since_tizen>
1106             public Key Key
1107             {
1108                 get
1109                 {
1110                     return _key;
1111                 }
1112                 set
1113                 {
1114                     _key = value;
1115                 }
1116             }
1117         }
1118
1119         /// <summary>
1120         /// Event arguments that passed via the touch signal.
1121         /// </summary>
1122         /// <since_tizen> 3 </since_tizen>
1123         public class TouchEventArgs : EventArgs
1124         {
1125             private Touch _touch;
1126
1127             /// <summary>
1128             /// Touch - contains the information of touch points.
1129             /// </summary>
1130             /// <since_tizen> 3 </since_tizen>
1131             public Touch Touch
1132             {
1133                 get
1134                 {
1135                     return _touch;
1136                 }
1137                 set
1138                 {
1139                     _touch = value;
1140                 }
1141             }
1142         }
1143
1144         /// <summary>
1145         /// Event arguments that passed via the hover signal.
1146         /// </summary>
1147         /// <since_tizen> 3 </since_tizen>
1148         public class HoverEventArgs : EventArgs
1149         {
1150             private Hover _hover;
1151
1152             /// <summary>
1153             /// Hover - contains touch points that represent the points that are currently being hovered or the points where a hover has stopped.
1154             /// </summary>
1155             /// <since_tizen> 3 </since_tizen>
1156             public Hover Hover
1157             {
1158                 get
1159                 {
1160                     return _hover;
1161                 }
1162                 set
1163                 {
1164                     _hover = value;
1165                 }
1166             }
1167         }
1168
1169         /// <summary>
1170         /// Event arguments that passed via the wheel signal.
1171         /// </summary>
1172         /// <since_tizen> 3 </since_tizen>
1173         public class WheelEventArgs : EventArgs
1174         {
1175             private Wheel _wheel;
1176
1177             /// <summary>
1178             /// WheelEvent - store a wheel rolling type: MOUSE_WHEEL or CUSTOM_WHEEL.
1179             /// </summary>
1180             /// <since_tizen> 3 </since_tizen>
1181             public Wheel Wheel
1182             {
1183                 get
1184                 {
1185                     return _wheel;
1186                 }
1187                 set
1188                 {
1189                     _wheel = value;
1190                 }
1191             }
1192         }
1193
1194         /// <summary>
1195         /// Event arguments of visibility changed.
1196         /// </summary>
1197         /// <since_tizen> 3 </since_tizen>
1198         public class VisibilityChangedEventArgs : EventArgs
1199         {
1200             private View _view;
1201             private bool _visibility;
1202             private VisibilityChangeType _type;
1203
1204             /// <summary>
1205             /// The view, or child of view, whose visibility has changed.
1206             /// </summary>
1207             /// <since_tizen> 3 </since_tizen>
1208             public View View
1209             {
1210                 get
1211                 {
1212                     return _view;
1213                 }
1214                 set
1215                 {
1216                     _view = value;
1217                 }
1218             }
1219
1220             /// <summary>
1221             /// Whether the view is now visible or not.
1222             /// </summary>
1223             /// <since_tizen> 3 </since_tizen>
1224             public bool Visibility
1225             {
1226                 get
1227                 {
1228                     return _visibility;
1229                 }
1230                 set
1231                 {
1232                     _visibility = value;
1233                 }
1234             }
1235
1236             /// <summary>
1237             /// Whether the view's visible property has changed or a parent's.
1238             /// </summary>
1239             /// <since_tizen> 3 </since_tizen>
1240             public VisibilityChangeType Type
1241             {
1242                 get
1243                 {
1244                     return _type;
1245                 }
1246                 set
1247                 {
1248                     _type = value;
1249                 }
1250             }
1251         }
1252
1253         /// <summary>
1254         /// Event arguments of layout direction changed.
1255         /// </summary>
1256         /// <since_tizen> 4 </since_tizen>
1257         public class LayoutDirectionChangedEventArgs : EventArgs
1258         {
1259             private View _view;
1260             private ViewLayoutDirectionType _type;
1261
1262             /// <summary>
1263             /// The view, or child of view, whose layout direction has changed.
1264             /// </summary>
1265             /// <since_tizen> 4 </since_tizen>
1266             public View View
1267             {
1268                 get
1269                 {
1270                     return _view;
1271                 }
1272                 set
1273                 {
1274                     _view = value;
1275                 }
1276             }
1277
1278             /// <summary>
1279             /// Whether the view's layout direction property has changed or a parent's.
1280             /// </summary>
1281             /// <since_tizen> 4 </since_tizen>
1282             public ViewLayoutDirectionType Type
1283             {
1284                 get
1285                 {
1286                     return _type;
1287                 }
1288                 set
1289                 {
1290                     _type = value;
1291                 }
1292             }
1293         }
1294
1295         internal class BackgroundResourceLoadedEventArgs : EventArgs
1296         {
1297             private ResourceLoadingStatusType status = ResourceLoadingStatusType.Invalid;
1298             public ResourceLoadingStatusType Status
1299             {
1300                 get
1301                 {
1302                     return status;
1303                 }
1304                 set
1305                 {
1306                     status = value;
1307                 }
1308             }
1309         }
1310
1311         /// <summary>
1312         /// The class represents the information of the situation where the View's control state changes.
1313         /// </summary>
1314         [EditorBrowsable(EditorBrowsableState.Never)]
1315         public class ControlStateChangedEventArgs : EventArgs
1316         {
1317             /// <summary>
1318             /// Create an instance with mandatory fields.
1319             /// </summary>
1320             /// <param name="previousState">The previous control state.</param>
1321             /// <param name="currentState">The current control state.</param>
1322             [EditorBrowsable(EditorBrowsableState.Never)]
1323             public ControlStateChangedEventArgs(ControlState previousState, ControlState currentState)
1324             {
1325                 PreviousState = previousState;
1326                 CurrentState = currentState;
1327             }
1328
1329             /// <summary>
1330             /// The previous control state.
1331             /// </summary>
1332             [EditorBrowsable(EditorBrowsableState.Never)]
1333             public ControlState PreviousState { get; }
1334
1335             /// <summary>
1336             /// The current control state.
1337             /// </summary>
1338             [EditorBrowsable(EditorBrowsableState.Never)]
1339             public ControlState CurrentState { get; }
1340         }
1341
1342         /// <summary>
1343         /// The expanded touch area.
1344         /// TouchArea can expand the view's touchable area.<br/>
1345         /// 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/>
1346         /// </summary>
1347         /// <remarks>
1348         /// This is based on the top left x, y coordinates.<br/>
1349         /// For example) <br/>
1350         /// <code>
1351         ///  view.Size = new Size(100, 100);
1352         ///  view.TouchAreaOffset = new Offset(-10, 20, 30, -40); // left, right, bottom, top
1353         /// </code>
1354         /// Then, touch area is 130x170.<br/>
1355         /// This is view.width + TouchAreaOffset.right - TouchAreaOffset.left and view.height + TouchAreaOffset.bottom - TouchAreaOffset.top <br/>
1356         /// +---------------------+ <br/>
1357         /// |         ^           | <br/>
1358         /// |         |           | <br/>
1359         /// |         | -40       | <br/>
1360         /// |         |           | <br/>
1361         /// |         |           | <br/>
1362         /// |    +----+----+      | <br/>
1363         /// |    |         |      | <br/>
1364         /// | -10|         | 20   | <br/>
1365         /// |&lt;---+         +-----&gt;| <br/>
1366         /// |    |         |      | <br/>
1367         /// |    |         |      | <br/>
1368         /// |    +----+----+      | <br/>
1369         /// |         |           | <br/>
1370         /// |         | 30        | <br/>
1371         /// |         |           | <br/>
1372         /// |         v           | <br/>
1373         /// +---------------------+ <br/>
1374         /// </remarks>
1375         [EditorBrowsable(EditorBrowsableState.Never)]
1376         public Offset TouchAreaOffset
1377         {
1378             get
1379             {
1380                 return (Offset)GetValue(TouchAreaOffsetProperty);
1381             }
1382             set
1383             {
1384                 SetValue(TouchAreaOffsetProperty, value);
1385                 NotifyPropertyChanged();
1386             }
1387         }
1388
1389         private Offset InternalTouchAreaOffset
1390         {
1391             get
1392             {
1393                 Interop.ActorInternal.GetTouchAreaOffset(SwigCPtr, out int left, out int right, out int bottom, out int top);
1394                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1395                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1396                 return new Offset(left, right, bottom, top);
1397             }
1398             set
1399             {
1400                 Interop.ActorInternal.SetTouchAreaOffset(SwigCPtr, value.Left, value.Right, value.Bottom, value.Top);
1401                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1402                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1403             }
1404         }
1405
1406
1407         /// <summary>
1408         /// Gets or sets the status of whether the view should emit key event signals.
1409         /// If a View's DispatchKeyEvents is set to false, then itself and parents will not receive key event signals.
1410         /// </summary>
1411         [EditorBrowsable(EditorBrowsableState.Never)]
1412         public bool DispatchKeyEvents
1413         {
1414             get
1415             {
1416                 return (bool)GetValue(DispatchKeyEventsProperty);
1417             }
1418             set
1419             {
1420                 SetValue(DispatchKeyEventsProperty, value);
1421                 NotifyPropertyChanged();
1422             }
1423         }
1424
1425         /// <summary>
1426         /// Gets or sets the status of whether touch events can be dispatched.
1427         /// 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.
1428         /// This works without adding a TouchEvent callback in the View.
1429         /// <note>
1430         /// 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.
1431         /// </note>
1432         /// </summary>
1433         [EditorBrowsable(EditorBrowsableState.Never)]
1434         public bool DispatchTouchEvents
1435         {
1436             get
1437             {
1438                 return dispatchTouchEvents;
1439             }
1440             set
1441             {
1442                 if (dispatchTouchEvents != value)
1443                 {
1444                     dispatchTouchEvents = value;
1445                     if (dispatchTouchEvents == false)
1446                     {
1447                         TouchEvent += OnDispatchTouchEvent;
1448                     }
1449                     else
1450                     {
1451                         TouchEvent -= OnDispatchTouchEvent;
1452                     }
1453                 }
1454             }
1455         }
1456
1457         private bool OnDispatchTouchEvent(object source, View.TouchEventArgs e)
1458         {
1459             return true;
1460         }
1461
1462         /// <summary>
1463         /// Gets or sets the status of whether touch events can be dispatched to the parent.
1464         /// If a View's DispatchParentTouchEvents is set to false, then parents will not receive a touch event signal either.
1465         /// This works without adding a TouchEvent callback in the View.
1466         /// <note>
1467         /// 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.
1468         /// </note>
1469         /// </summary>
1470         [EditorBrowsable(EditorBrowsableState.Never)]
1471         public bool DispatchParentTouchEvents
1472         {
1473             get
1474             {
1475                 return dispatchParentTouchEvents;
1476             }
1477             set
1478             {
1479                 if (dispatchParentTouchEvents != value)
1480                 {
1481                     dispatchParentTouchEvents = value;
1482                     if (dispatchParentTouchEvents == false)
1483                     {
1484                         TouchEvent += OnDispatchParentTouchEvent;
1485                     }
1486                     else
1487                     {
1488                         TouchEvent -= OnDispatchParentTouchEvent;
1489                     }
1490                 }
1491             }
1492         }
1493
1494         private bool OnDispatchParentTouchEvent(object source, View.TouchEventArgs e)
1495         {
1496             return true;
1497         }
1498
1499         /// <summary>
1500         /// Gets or sets the status of whether hover events can be dispatched.
1501         /// 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.
1502         /// This works without adding a HoverEvent callback in the View.
1503         /// <note>
1504         /// 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.
1505         /// </note>
1506         /// </summary>
1507         [EditorBrowsable(EditorBrowsableState.Never)]
1508         public bool DispatchHoverEvents
1509         {
1510             get
1511             {
1512                 return dispatchHoverEvents;
1513             }
1514             set
1515             {
1516                 if (dispatchHoverEvents != value)
1517                 {
1518                     dispatchHoverEvents = value;
1519                     if (dispatchHoverEvents == false)
1520                     {
1521                         HoverEvent += OnDispatchHoverEvent;
1522                     }
1523                     else
1524                     {
1525                         HoverEvent -= OnDispatchHoverEvent;
1526                     }
1527                 }
1528             }
1529         }
1530
1531         private bool OnDispatchHoverEvent(object source, View.HoverEventArgs e)
1532         {
1533             return true;
1534         }
1535
1536         /// <summary>
1537         /// Gets or sets the status of whether hover events can be dispatched to the parent.
1538         /// If a View's DispatchParentHoverEvents is set to false, then parents will not receive a hover event signal either.
1539         /// This works without adding a HoverEvent callback in the View.
1540         /// <note>
1541         /// 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.
1542         /// </note>
1543         /// </summary>
1544         [EditorBrowsable(EditorBrowsableState.Never)]
1545         public bool DispatchParentHoverEvents
1546         {
1547             get
1548             {
1549                 return dispatchParentHoverEvents;
1550             }
1551             set
1552             {
1553                 if (dispatchParentHoverEvents != value)
1554                 {
1555                     dispatchParentHoverEvents = value;
1556                     if (dispatchParentHoverEvents == false)
1557                     {
1558                         HoverEvent += OnDispatchParentHoverEvent;
1559                     }
1560                     else
1561                     {
1562                         HoverEvent -= OnDispatchParentHoverEvent;
1563                     }
1564                 }
1565             }
1566         }
1567
1568         private bool OnDispatchParentHoverEvent(object source, View.HoverEventArgs e)
1569         {
1570             return true;
1571         }
1572
1573         /// <summary>
1574         /// Gets or sets the status of whether the view should emit Gesture event signals.
1575         /// If a View's DispatchGestureEvents is set to false, then itself and parents will not receive all gesture event signals.
1576         /// The itself and parents does not receive tap, pinch, pan, rotation, or longpress gestures.
1577         /// </summary>
1578         [EditorBrowsable(EditorBrowsableState.Never)]
1579         public bool DispatchGestureEvents
1580         {
1581             get
1582             {
1583                 return dispatchGestureEvents;
1584             }
1585             set
1586             {
1587                 if (dispatchGestureEvents != value)
1588                 {
1589                     dispatchGestureEvents = value;
1590                     ConfigGestureDetector(dispatchGestureEvents);
1591                 }
1592             }
1593         }
1594
1595         /// <summary>
1596         /// Gets or sets the status of whether the view should emit Gesture event signals.
1597         /// If a View's DispatchParentGestureEvents is set to false, then parents will not receive all gesture event signals.
1598         /// The parents does not receive tap, pinch, pan, rotation, or longpress gestures.
1599         /// </summary>
1600         [EditorBrowsable(EditorBrowsableState.Never)]
1601         public bool DispatchParentGestureEvents
1602         {
1603             get
1604             {
1605                 return dispatchParentGestureEvents;
1606             }
1607             set
1608             {
1609                 if (dispatchParentGestureEvents != value)
1610                 {
1611                     dispatchParentGestureEvents = value;
1612                     ConfigGestureDetector(dispatchParentGestureEvents);
1613                 }
1614             }
1615         }
1616
1617         private void ConfigGestureDetector(bool dispatch)
1618         {
1619             if (panGestureDetector == null) panGestureDetector = new PanGestureDetector();
1620             if (longGestureDetector == null) longGestureDetector = new LongPressGestureDetector();
1621             if (pinchGestureDetector == null) pinchGestureDetector = new PinchGestureDetector();
1622             if (tapGestureDetector == null) tapGestureDetector = new TapGestureDetector();
1623             if (rotationGestureDetector == null) rotationGestureDetector = new RotationGestureDetector();
1624
1625             if (dispatch == true)
1626             {
1627                 configGestureCount = configGestureCount > 0 ? configGestureCount - 1 : 0;
1628                 if (configGestureCount == 0)
1629                 {
1630                     panGestureDetector.Detach(this);
1631                     longGestureDetector.Detach(this);
1632                     pinchGestureDetector.Detach(this);
1633                     tapGestureDetector.Detach(this);
1634                     rotationGestureDetector.Detach(this);
1635
1636                     panGestureDetector.Detected -= OnGestureDetected;
1637                     longGestureDetector.Detected -= OnGestureDetected;
1638                     pinchGestureDetector.Detected -= OnGestureDetected;
1639                     tapGestureDetector.Detected -= OnGestureDetected;
1640                     rotationGestureDetector.Detected -= OnGestureDetected;
1641                 }
1642             }
1643             else
1644             {
1645                 if (configGestureCount == 0)
1646                 {
1647                     panGestureDetector.Attach(this);
1648                     longGestureDetector.Attach(this);
1649                     pinchGestureDetector.Attach(this);
1650                     tapGestureDetector.Attach(this);
1651                     rotationGestureDetector.Attach(this);
1652
1653                     panGestureDetector.Detected += OnGestureDetected;
1654                     longGestureDetector.Detected += OnGestureDetected;
1655                     pinchGestureDetector.Detected += OnGestureDetected;
1656                     tapGestureDetector.Detected += OnGestureDetected;
1657                     rotationGestureDetector.Detected += OnGestureDetected;
1658                 }
1659                 configGestureCount++;
1660             }
1661         }
1662
1663         private void OnGestureDetected(object source, EventArgs e)
1664         {
1665             // Does notting. This is to consume the gesture.
1666         }
1667
1668         /// <summary>
1669         /// Gets or sets the status of whether motion event of Touch can be dispatched.
1670         /// If a View's DispatchTouchMotion is set to false, then it's can not will receive motion event of TouchEvent.
1671         /// </summary>
1672         [EditorBrowsable(EditorBrowsableState.Never)]
1673         public bool DispatchTouchMotion
1674         {
1675             get
1676             {
1677                 return dispatchTouchMotion;
1678             }
1679             set
1680             {
1681                 dispatchTouchMotion = value;
1682             }
1683         }
1684
1685         /// <summary>
1686         /// Gets or sets the status of whether motion event of Hover can be dispatched.
1687         /// If a View's DispatchHoverMotion is set to false, then it's can not will receive motion event of HoverEvent.
1688         /// </summary>
1689         [EditorBrowsable(EditorBrowsableState.Never)]
1690         public bool DispatchHoverMotion
1691         {
1692             get
1693             {
1694                 return dispatchHoverMotion;
1695             }
1696             set
1697             {
1698                 dispatchHoverMotion = value;
1699             }
1700         }
1701
1702     }
1703 }