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                         using var process = global::System.Diagnostics.Process.GetCurrentProcess();
 723                         var processId = process.Id;
 724                         var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
 725                         var me = this.GetType().FullName;
 726
 727                         //in this case, the View object is ready to be disposed waiting on DisposeQueue, so event callback should not be invoked!
 728                         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" +
 729                             $"process:{processId} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
 730                         return;
 731                     }
 732                 }
 733             }
 734
 735             keyInputFocusGainedEventHandler?.Invoke(this, null);
 736         }
 737
 738         private void OnKeyInputFocusLost(IntPtr view)
 739         {
 740             if (IsNativeHandleInvalid())
 741             {
 742                 if (this.Disposed)
 743                 {
 744                     if (keyInputFocusLostEventHandler != null)
 745                     {
 746                         using var process = global::System.Diagnostics.Process.GetCurrentProcess();
 747                         var processId = process.Id;
 748                         var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
 749                         var me = this.GetType().FullName;
 750
 751                         throw new ObjectDisposedException(nameof(SwigCPtr), $"Error! NUI's native dali object is already disposed. " +
 752                             $"OR the native dali object handle of NUI becomes null! \n" +
 753                             $" process:{processId} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
 754                     }
 755                 }
 756                 else
 757                 {
 758                     if (this.IsDisposeQueued)
 759                     {
 760                         using var process = global::System.Diagnostics.Process.GetCurrentProcess();
 761                         var processId = process.Id;
 762                         var thread = global::System.Threading.Thread.CurrentThread.ManagedThreadId;
 763                         var me = this.GetType().FullName;
 764
 765                         //in this case, the View object is ready to be disposed waiting on DisposeQueue, so event callback should not be invoked!
 766                         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" +
 767                             $"process:{processId} thread:{thread}, isDisposed:{this.Disposed}, isDisposeQueued:{this.IsDisposeQueued}, me:{me}\n");
 768                         return;
 769                     }
 770                 }
 771             }
 772
 773             keyInputFocusLostEventHandler?.Invoke(this, null);
 774         }
 775
 776         private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
 777         {
 778             if (keyEvent == global::System.IntPtr.Zero)
 779             {
 780                 NUILog.Error("keyEvent should not be null!");
 781                 return true;
 782             }
 783
 784             KeyEventArgs e = new KeyEventArgs();
 785
 786             bool result = false;
 787
 788             e.Key = Tizen.NUI.Key.GetKeyFromPtr(keyEvent);
 789
 790             if (keyEventHandler != null)
 791             {
 792                 Delegate[] delegateList = keyEventHandler.GetInvocationList();
 793
 794                 // Oring the result of each callback.
 795                 foreach (EventHandlerWithReturnType<object, KeyEventArgs, bool> del in delegateList)
 796                 {
 797                     result |= del(this, e);
 798                 }
 799             }
 800
 801             return result;
 802         }
 803
 804         // Callback for View OnRelayout signal
 805         private void OnRelayout(IntPtr data)
 806         {
 807             if (onRelayoutEventHandler != null)
 808             {
 809                 onRelayoutEventHandler(this, null);
 810             }
 811         }
 812
 813         // Callback for View HitTestResultSignal
 814         private bool OnHitTestResult(IntPtr view, IntPtr touchData)
 815         {
 816             if (touchData == global::System.IntPtr.Zero)
 817             {
 818                 NUILog.Error("touchData should not be null!");
 819                 return true;
 820             }
 821
 822             TouchEventArgs e = new TouchEventArgs();
 823             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 824             return HitTest(e.Touch);
 825         }
 826
 827         // Callback for View TouchSignal
 828         private bool OnInterceptTouch(IntPtr view, IntPtr touchData)
 829         {
 830             if (touchData == global::System.IntPtr.Zero)
 831             {
 832                 NUILog.Error("touchData should not be null!");
 833                 return true;
 834             }
 835
 836             // DisallowInterceptTouchEvent prevents the parent from intercepting touch.
 837             if (DisallowInterceptTouchEvent)
 838             {
 839                 return false;
 840             }
 841
 842             TouchEventArgs e = new TouchEventArgs();
 843             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 844
 845             // If DispatchTouchMotion is false, Motion event is not dispatched.
 846             if (DispatchTouchMotion == false && e.Touch.GetState(0) == PointStateType.Motion)
 847             {
 848                 return true;
 849             }
 850
 851             bool consumed = false;
 852
 853             if (interceptTouchDataEventHandler != null)
 854             {
 855                 consumed = interceptTouchDataEventHandler(this, e);
 856             }
 857
 858             return consumed;
 859         }
 860
 861         // Callback for View TouchSignal
 862         private bool OnTouch(IntPtr view, IntPtr touchData)
 863         {
 864             if (touchData == global::System.IntPtr.Zero)
 865             {
 866                 NUILog.Error("touchData should not be null!");
 867                 return true;
 868             }
 869
 870             if (DispatchTouchEvents == false)
 871             {
 872                 NUILog.Debug("If DispatchTouchEvents is false, it can not dispatch.");
 873                 return true;
 874             }
 875
 876             TouchEventArgs e = new TouchEventArgs();
 877             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 878
 879             // If DispatchTouchMotion is false, Motion event is not dispatched.
 880             if (DispatchTouchMotion == false && e.Touch.GetState(0) == PointStateType.Motion)
 881             {
 882                 return true;
 883             }
 884
 885
 886             bool consumed = false;
 887
 888             if (touchDataEventHandler != null)
 889             {
 890                 consumed = touchDataEventHandler(this, e);
 891             }
 892
 893             if (enableControlState && !consumed)
 894             {
 895                 consumed = HandleControlStateOnTouch(e.Touch);
 896             }
 897
 898             if (DispatchParentTouchEvents == false)
 899             {
 900                 NUILog.Debug("If DispatchParentTouchEvents is false, it can not dispatch to parent.");
 901                 return true;
 902             }
 903
 904             return consumed;
 905         }
 906
 907         // Callback for View Hover signal
 908         private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
 909         {
 910             if (hoverEvent == global::System.IntPtr.Zero)
 911             {
 912                 NUILog.Error("hoverEvent should not be null!");
 913                 return true;
 914             }
 915
 916             if (DispatchHoverEvents == false)
 917             {
 918                 NUILog.Debug("If DispatchHoverEvents is false, it can not dispatch.");
 919                 return true;
 920             }
 921
 922             HoverEventArgs e = new HoverEventArgs();
 923             e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);
 924
 925             // If DispatchHoverMotion is false, Motion event is not dispatched.
 926             if (DispatchHoverMotion == false && e.Hover.GetState(0) == PointStateType.Motion)
 927             {
 928                 return true;
 929             }
 930
 931             bool consumed = false;
 932
 933             if (hoverEventHandler != null)
 934             {
 935                 consumed = hoverEventHandler(this, e);
 936             }
 937
 938             if (DispatchParentHoverEvents == false && consumed == false)
 939             {
 940                 NUILog.Debug("If DispatchParentHoverEvents is false, it can not dispatch to parent.");
 941                 return true;
 942             }
 943
 944             return consumed;
 945         }
 946
 947         // Callback for View InterceptWheel signal
 948         private bool OnInterceptWheel(IntPtr view, IntPtr wheelEvent)
 949         {
 950             if (wheelEvent == global::System.IntPtr.Zero)
 951             {
 952                 NUILog.Error("wheelEvent should not be null!");
 953                 return true;
 954             }
 955
 956             // DisallowInterceptWheelEvent prevents the parent from intercepting wheel.
 957             if (DisallowInterceptWheelEvent)
 958             {
 959                 return false;
 960             }
 961
 962             WheelEventArgs e = new WheelEventArgs();
 963
 964             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 965
 966             bool consumed = false;
 967
 968             if (interceptWheelHandler != null)
 969             {
 970                 consumed = interceptWheelHandler(this, e);
 971             }
 972
 973             return consumed;
 974         }
 975
 976         // Callback for View Wheel signal
 977         private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
 978         {
 979             if (wheelEvent == global::System.IntPtr.Zero)
 980             {
 981                 NUILog.Error("wheelEvent should not be null!");
 982                 return true;
 983             }
 984
 985             WheelEventArgs e = new WheelEventArgs();
 986
 987             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 988
 989             if (wheelEventHandler != null)
 990             {
 991                 return wheelEventHandler(this, e);
 992             }
 993             return false;
 994         }
 995
 996         // Callback for View OnWindow signal
 997         private void OnWindow(IntPtr data)
 998         {
 999             if (onWindowEventHandler != null)
1000             {
1001                 onWindowEventHandler(this, null);
1002             }
1003         }
1004
1005         // Callback for View OffWindow signal
1006         private void OffWindow(IntPtr data)
1007         {
1008             if (offWindowEventHandler != null)
1009             {
1010                 offWindowEventHandler(this, null);
1011             }
1012         }
1013
1014         // Callback for View visibility change signal
1015         private void OnVisibilityChanged(IntPtr data, bool visibility, VisibilityChangeType type)
1016         {
1017             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
1018             if (data != IntPtr.Zero)
1019             {
1020                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
1021             }
1022             e.Visibility = visibility;
1023             e.Type = type;
1024
1025             if (visibilityChangedEventHandler != null)
1026             {
1027                 visibilityChangedEventHandler(this, e);
1028             }
1029         }
1030
1031         // Callback for View layout direction change signal
1032         private void OnLayoutDirectionChanged(IntPtr data, ViewLayoutDirectionType type)
1033         {
1034             LayoutDirectionChangedEventArgs e = new LayoutDirectionChangedEventArgs();
1035             if (data != IntPtr.Zero)
1036             {
1037                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
1038             }
1039             e.Type = type;
1040
1041             if (layoutDirectionChangedEventHandler != null)
1042             {
1043                 layoutDirectionChangedEventHandler(this, e);
1044             }
1045         }
1046
1047         private void OnResourcesLoaded(IntPtr view)
1048         {
1049             if(!CheckResourceReady())
1050             {
1051                 return;
1052             }
1053
1054             if (resourcesLoadedEventHandler != null)
1055             {
1056                 resourcesLoadedEventHandler(this, null);
1057             }
1058         }
1059
1060         private void OnBackgroundResourceLoaded(IntPtr view)
1061         {
1062             BackgroundResourceLoadedEventArgs e = new BackgroundResourceLoadedEventArgs();
1063             e.Status = (ResourceLoadingStatusType)Interop.View.GetVisualResourceStatus(this.SwigCPtr, Property.BACKGROUND);
1064
1065             if (backgroundResourceLoadedEventHandler != null)
1066             {
1067                 backgroundResourceLoadedEventHandler(this, e);
1068             }
1069         }
1070
1071         /// <summary>
1072         /// Event argument passed through the ChildAdded event.
1073         /// </summary>
1074         /// <since_tizen> 5 </since_tizen>
1075         public class ChildAddedEventArgs : EventArgs
1076         {
1077             /// <summary>
1078             /// Added child view at moment.
1079             /// </summary>
1080             /// <since_tizen> 5 </since_tizen>
1081             public View Added { get; set; }
1082         }
1083
1084         /// <summary>
1085         /// Event argument passed through the ChildRemoved event.
1086         /// </summary>
1087         /// <since_tizen> 5 </since_tizen>
1088         public class ChildRemovedEventArgs : EventArgs
1089         {
1090             /// <summary>
1091             /// Removed child view at moment.
1092             /// </summary>
1093             /// <since_tizen> 5 </since_tizen>
1094             public View Removed { get; set; }
1095         }
1096
1097         /// <summary>
1098         /// Event arguments that passed via the KeyEvent signal.
1099         /// </summary>
1100         /// <since_tizen> 3 </since_tizen>
1101         public class KeyEventArgs : EventArgs
1102         {
1103             private Key _key;
1104
1105             /// <summary>
1106             /// Key - is the key sent to the view.
1107             /// </summary>
1108             /// <since_tizen> 3 </since_tizen>
1109             public Key Key
1110             {
1111                 get
1112                 {
1113                     return _key;
1114                 }
1115                 set
1116                 {
1117                     _key = value;
1118                 }
1119             }
1120         }
1121
1122         /// <summary>
1123         /// Event arguments that passed via the touch signal.
1124         /// </summary>
1125         /// <since_tizen> 3 </since_tizen>
1126         public class TouchEventArgs : EventArgs
1127         {
1128             private Touch _touch;
1129
1130             /// <summary>
1131             /// Touch - contains the information of touch points.
1132             /// </summary>
1133             /// <since_tizen> 3 </since_tizen>
1134             public Touch Touch
1135             {
1136                 get
1137                 {
1138                     return _touch;
1139                 }
1140                 set
1141                 {
1142                     _touch = value;
1143                 }
1144             }
1145         }
1146
1147         /// <summary>
1148         /// Event arguments that passed via the hover signal.
1149         /// </summary>
1150         /// <since_tizen> 3 </since_tizen>
1151         public class HoverEventArgs : EventArgs
1152         {
1153             private Hover _hover;
1154
1155             /// <summary>
1156             /// Hover - contains touch points that represent the points that are currently being hovered or the points where a hover has stopped.
1157             /// </summary>
1158             /// <since_tizen> 3 </since_tizen>
1159             public Hover Hover
1160             {
1161                 get
1162                 {
1163                     return _hover;
1164                 }
1165                 set
1166                 {
1167                     _hover = value;
1168                 }
1169             }
1170         }
1171
1172         /// <summary>
1173         /// Event arguments that passed via the wheel signal.
1174         /// </summary>
1175         /// <since_tizen> 3 </since_tizen>
1176         public class WheelEventArgs : EventArgs
1177         {
1178             private Wheel _wheel;
1179
1180             /// <summary>
1181             /// WheelEvent - store a wheel rolling type: MOUSE_WHEEL or CUSTOM_WHEEL.
1182             /// </summary>
1183             /// <since_tizen> 3 </since_tizen>
1184             public Wheel Wheel
1185             {
1186                 get
1187                 {
1188                     return _wheel;
1189                 }
1190                 set
1191                 {
1192                     _wheel = value;
1193                 }
1194             }
1195         }
1196
1197         /// <summary>
1198         /// Event arguments of visibility changed.
1199         /// </summary>
1200         /// <since_tizen> 3 </since_tizen>
1201         public class VisibilityChangedEventArgs : EventArgs
1202         {
1203             private View _view;
1204             private bool _visibility;
1205             private VisibilityChangeType _type;
1206
1207             /// <summary>
1208             /// The view, or child of view, whose visibility has changed.
1209             /// </summary>
1210             /// <since_tizen> 3 </since_tizen>
1211             public View View
1212             {
1213                 get
1214                 {
1215                     return _view;
1216                 }
1217                 set
1218                 {
1219                     _view = value;
1220                 }
1221             }
1222
1223             /// <summary>
1224             /// Whether the view is now visible or not.
1225             /// </summary>
1226             /// <since_tizen> 3 </since_tizen>
1227             public bool Visibility
1228             {
1229                 get
1230                 {
1231                     return _visibility;
1232                 }
1233                 set
1234                 {
1235                     _visibility = value;
1236                 }
1237             }
1238
1239             /// <summary>
1240             /// Whether the view's visible property has changed or a parent's.
1241             /// </summary>
1242             /// <since_tizen> 3 </since_tizen>
1243             public VisibilityChangeType Type
1244             {
1245                 get
1246                 {
1247                     return _type;
1248                 }
1249                 set
1250                 {
1251                     _type = value;
1252                 }
1253             }
1254         }
1255
1256         /// <summary>
1257         /// Event arguments of layout direction changed.
1258         /// </summary>
1259         /// <since_tizen> 4 </since_tizen>
1260         public class LayoutDirectionChangedEventArgs : EventArgs
1261         {
1262             private View _view;
1263             private ViewLayoutDirectionType _type;
1264
1265             /// <summary>
1266             /// The view, or child of view, whose layout direction has changed.
1267             /// </summary>
1268             /// <since_tizen> 4 </since_tizen>
1269             public View View
1270             {
1271                 get
1272                 {
1273                     return _view;
1274                 }
1275                 set
1276                 {
1277                     _view = value;
1278                 }
1279             }
1280
1281             /// <summary>
1282             /// Whether the view's layout direction property has changed or a parent's.
1283             /// </summary>
1284             /// <since_tizen> 4 </since_tizen>
1285             public ViewLayoutDirectionType Type
1286             {
1287                 get
1288                 {
1289                     return _type;
1290                 }
1291                 set
1292                 {
1293                     _type = value;
1294                 }
1295             }
1296         }
1297
1298         internal class BackgroundResourceLoadedEventArgs : EventArgs
1299         {
1300             private ResourceLoadingStatusType status = ResourceLoadingStatusType.Invalid;
1301             public ResourceLoadingStatusType Status
1302             {
1303                 get
1304                 {
1305                     return status;
1306                 }
1307                 set
1308                 {
1309                     status = value;
1310                 }
1311             }
1312         }
1313
1314         /// <summary>
1315         /// The class represents the information of the situation where the View's control state changes.
1316         /// </summary>
1317         [EditorBrowsable(EditorBrowsableState.Never)]
1318         public class ControlStateChangedEventArgs : EventArgs
1319         {
1320             /// <summary>
1321             /// Create an instance with mandatory fields.
1322             /// </summary>
1323             /// <param name="previousState">The previous control state.</param>
1324             /// <param name="currentState">The current control state.</param>
1325             [EditorBrowsable(EditorBrowsableState.Never)]
1326             public ControlStateChangedEventArgs(ControlState previousState, ControlState currentState)
1327             {
1328                 PreviousState = previousState;
1329                 CurrentState = currentState;
1330             }
1331
1332             /// <summary>
1333             /// The previous control state.
1334             /// </summary>
1335             [EditorBrowsable(EditorBrowsableState.Never)]
1336             public ControlState PreviousState { get; }
1337
1338             /// <summary>
1339             /// The current control state.
1340             /// </summary>
1341             [EditorBrowsable(EditorBrowsableState.Never)]
1342             public ControlState CurrentState { get; }
1343         }
1344
1345         /// <summary>
1346         /// The expanded touch area.
1347         /// TouchArea can expand the view's touchable area.<br/>
1348         /// 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/>
1349         /// </summary>
1350         /// <remarks>
1351         /// This is based on the top left x, y coordinates.<br/>
1352         /// For example) <br/>
1353         /// <code>
1354         ///  view.Size = new Size(100, 100);
1355         ///  view.TouchAreaOffset = new Offset(-10, 20, 30, -40); // left, right, bottom, top
1356         /// </code>
1357         /// Then, touch area is 130x170.<br/>
1358         /// This is view.width + TouchAreaOffset.right - TouchAreaOffset.left and view.height + TouchAreaOffset.bottom - TouchAreaOffset.top <br/>
1359         /// +---------------------+ <br/>
1360         /// |         ^           | <br/>
1361         /// |         |           | <br/>
1362         /// |         | -40       | <br/>
1363         /// |         |           | <br/>
1364         /// |         |           | <br/>
1365         /// |    +----+----+      | <br/>
1366         /// |    |         |      | <br/>
1367         /// | -10|         | 20   | <br/>
1368         /// |&lt;---+         +-----&gt;| <br/>
1369         /// |    |         |      | <br/>
1370         /// |    |         |      | <br/>
1371         /// |    +----+----+      | <br/>
1372         /// |         |           | <br/>
1373         /// |         | 30        | <br/>
1374         /// |         |           | <br/>
1375         /// |         v           | <br/>
1376         /// +---------------------+ <br/>
1377         /// </remarks>
1378         [EditorBrowsable(EditorBrowsableState.Never)]
1379         public Offset TouchAreaOffset
1380         {
1381             get
1382             {
1383                 return (Offset)GetValue(TouchAreaOffsetProperty);
1384             }
1385             set
1386             {
1387                 SetValue(TouchAreaOffsetProperty, value);
1388                 NotifyPropertyChanged();
1389             }
1390         }
1391
1392         private Offset InternalTouchAreaOffset
1393         {
1394             get
1395             {
1396                 Interop.ActorInternal.GetTouchAreaOffset(SwigCPtr, out int left, out int right, out int bottom, out int top);
1397                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1398                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1399                 return new Offset(left, right, bottom, top);
1400             }
1401             set
1402             {
1403                 Interop.ActorInternal.SetTouchAreaOffset(SwigCPtr, value.Left, value.Right, value.Bottom, value.Top);
1404                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1405                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1406             }
1407         }
1408
1409
1410         /// <summary>
1411         /// Gets or sets the status of whether the view should emit key event signals.
1412         /// If a View's DispatchKeyEvents is set to false, then itself and parents will not receive key event signals.
1413         /// </summary>
1414         [EditorBrowsable(EditorBrowsableState.Never)]
1415         public bool DispatchKeyEvents
1416         {
1417             get
1418             {
1419                 return (bool)GetValue(DispatchKeyEventsProperty);
1420             }
1421             set
1422             {
1423                 SetValue(DispatchKeyEventsProperty, value);
1424                 NotifyPropertyChanged();
1425             }
1426         }
1427
1428         /// <summary>
1429         /// Gets or sets the status of whether touch events can be dispatched.
1430         /// 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.
1431         /// This works without adding a TouchEvent callback in the View.
1432         /// <note>
1433         /// 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.
1434         /// </note>
1435         /// </summary>
1436         [EditorBrowsable(EditorBrowsableState.Never)]
1437         public bool DispatchTouchEvents
1438         {
1439             get
1440             {
1441                 return dispatchTouchEvents;
1442             }
1443             set
1444             {
1445                 if (dispatchTouchEvents != value)
1446                 {
1447                     dispatchTouchEvents = value;
1448                     if (dispatchTouchEvents == false)
1449                     {
1450                         TouchEvent += OnDispatchTouchEvent;
1451                     }
1452                     else
1453                     {
1454                         TouchEvent -= OnDispatchTouchEvent;
1455                     }
1456                 }
1457             }
1458         }
1459
1460         private bool OnDispatchTouchEvent(object source, View.TouchEventArgs e)
1461         {
1462             return true;
1463         }
1464
1465         /// <summary>
1466         /// Gets or sets the status of whether touch events can be dispatched to the parent.
1467         /// If a View's DispatchParentTouchEvents is set to false, then parents will not receive a touch event signal either.
1468         /// This works without adding a TouchEvent callback in the View.
1469         /// <note>
1470         /// 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.
1471         /// </note>
1472         /// </summary>
1473         [EditorBrowsable(EditorBrowsableState.Never)]
1474         public bool DispatchParentTouchEvents
1475         {
1476             get
1477             {
1478                 return dispatchParentTouchEvents;
1479             }
1480             set
1481             {
1482                 if (dispatchParentTouchEvents != value)
1483                 {
1484                     dispatchParentTouchEvents = value;
1485                     if (dispatchParentTouchEvents == false)
1486                     {
1487                         TouchEvent += OnDispatchParentTouchEvent;
1488                     }
1489                     else
1490                     {
1491                         TouchEvent -= OnDispatchParentTouchEvent;
1492                     }
1493                 }
1494             }
1495         }
1496
1497         private bool OnDispatchParentTouchEvent(object source, View.TouchEventArgs e)
1498         {
1499             return true;
1500         }
1501
1502         /// <summary>
1503         /// Gets or sets the status of whether hover events can be dispatched.
1504         /// 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.
1505         /// This works without adding a HoverEvent callback in the View.
1506         /// <note>
1507         /// 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.
1508         /// </note>
1509         /// </summary>
1510         [EditorBrowsable(EditorBrowsableState.Never)]
1511         public bool DispatchHoverEvents
1512         {
1513             get
1514             {
1515                 return dispatchHoverEvents;
1516             }
1517             set
1518             {
1519                 if (dispatchHoverEvents != value)
1520                 {
1521                     dispatchHoverEvents = value;
1522                     if (dispatchHoverEvents == false)
1523                     {
1524                         HoverEvent += OnDispatchHoverEvent;
1525                     }
1526                     else
1527                     {
1528                         HoverEvent -= OnDispatchHoverEvent;
1529                     }
1530                 }
1531             }
1532         }
1533
1534         private bool OnDispatchHoverEvent(object source, View.HoverEventArgs e)
1535         {
1536             return true;
1537         }
1538
1539         /// <summary>
1540         /// Gets or sets the status of whether hover events can be dispatched to the parent.
1541         /// If a View's DispatchParentHoverEvents is set to false, then parents will not receive a hover event signal either.
1542         /// This works without adding a HoverEvent callback in the View.
1543         /// <note>
1544         /// 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.
1545         /// </note>
1546         /// </summary>
1547         [EditorBrowsable(EditorBrowsableState.Never)]
1548         public bool DispatchParentHoverEvents
1549         {
1550             get
1551             {
1552                 return dispatchParentHoverEvents;
1553             }
1554             set
1555             {
1556                 if (dispatchParentHoverEvents != value)
1557                 {
1558                     dispatchParentHoverEvents = value;
1559                     if (dispatchParentHoverEvents == false)
1560                     {
1561                         HoverEvent += OnDispatchParentHoverEvent;
1562                     }
1563                     else
1564                     {
1565                         HoverEvent -= OnDispatchParentHoverEvent;
1566                     }
1567                 }
1568             }
1569         }
1570
1571         private bool OnDispatchParentHoverEvent(object source, View.HoverEventArgs e)
1572         {
1573             return true;
1574         }
1575
1576         /// <summary>
1577         /// Gets or sets the status of whether the view should emit Gesture event signals.
1578         /// If a View's DispatchGestureEvents is set to false, then itself and parents will not receive all gesture event signals.
1579         /// The itself and parents does not receive tap, pinch, pan, rotation, or longpress gestures.
1580         /// </summary>
1581         [EditorBrowsable(EditorBrowsableState.Never)]
1582         public bool DispatchGestureEvents
1583         {
1584             get
1585             {
1586                 return dispatchGestureEvents;
1587             }
1588             set
1589             {
1590                 if (dispatchGestureEvents != value)
1591                 {
1592                     dispatchGestureEvents = value;
1593                     ConfigGestureDetector(dispatchGestureEvents);
1594                 }
1595             }
1596         }
1597
1598         /// <summary>
1599         /// Gets or sets the status of whether the view should emit Gesture event signals.
1600         /// If a View's DispatchParentGestureEvents is set to false, then parents will not receive all gesture event signals.
1601         /// The parents does not receive tap, pinch, pan, rotation, or longpress gestures.
1602         /// </summary>
1603         [EditorBrowsable(EditorBrowsableState.Never)]
1604         public bool DispatchParentGestureEvents
1605         {
1606             get
1607             {
1608                 return dispatchParentGestureEvents;
1609             }
1610             set
1611             {
1612                 if (dispatchParentGestureEvents != value)
1613                 {
1614                     dispatchParentGestureEvents = value;
1615                     ConfigGestureDetector(dispatchParentGestureEvents);
1616                 }
1617             }
1618         }
1619
1620         private void ConfigGestureDetector(bool dispatch)
1621         {
1622             if (panGestureDetector == null) panGestureDetector = new PanGestureDetector();
1623             if (longGestureDetector == null) longGestureDetector = new LongPressGestureDetector();
1624             if (pinchGestureDetector == null) pinchGestureDetector = new PinchGestureDetector();
1625             if (tapGestureDetector == null) tapGestureDetector = new TapGestureDetector();
1626             if (rotationGestureDetector == null) rotationGestureDetector = new RotationGestureDetector();
1627
1628             if (dispatch == true)
1629             {
1630                 configGestureCount = configGestureCount > 0 ? configGestureCount - 1 : 0;
1631                 if (configGestureCount == 0)
1632                 {
1633                     panGestureDetector.Detach(this);
1634                     longGestureDetector.Detach(this);
1635                     pinchGestureDetector.Detach(this);
1636                     tapGestureDetector.Detach(this);
1637                     rotationGestureDetector.Detach(this);
1638
1639                     panGestureDetector.Detected -= OnGestureDetected;
1640                     longGestureDetector.Detected -= OnGestureDetected;
1641                     pinchGestureDetector.Detected -= OnGestureDetected;
1642                     tapGestureDetector.Detected -= OnGestureDetected;
1643                     rotationGestureDetector.Detected -= OnGestureDetected;
1644                 }
1645             }
1646             else
1647             {
1648                 if (configGestureCount == 0)
1649                 {
1650                     panGestureDetector.Attach(this);
1651                     longGestureDetector.Attach(this);
1652                     pinchGestureDetector.Attach(this);
1653                     tapGestureDetector.Attach(this);
1654                     rotationGestureDetector.Attach(this);
1655
1656                     panGestureDetector.Detected += OnGestureDetected;
1657                     longGestureDetector.Detected += OnGestureDetected;
1658                     pinchGestureDetector.Detected += OnGestureDetected;
1659                     tapGestureDetector.Detected += OnGestureDetected;
1660                     rotationGestureDetector.Detected += OnGestureDetected;
1661                 }
1662                 configGestureCount++;
1663             }
1664         }
1665
1666         private void OnGestureDetected(object source, EventArgs e)
1667         {
1668             // Does notting. This is to consume the gesture.
1669         }
1670
1671         /// <summary>
1672         /// Gets or sets the status of whether motion event of Touch can be dispatched.
1673         /// If a View's DispatchTouchMotion is set to false, then it's can not will receive motion event of TouchEvent.
1674         /// </summary>
1675         [EditorBrowsable(EditorBrowsableState.Never)]
1676         public bool DispatchTouchMotion
1677         {
1678             get
1679             {
1680                 return dispatchTouchMotion;
1681             }
1682             set
1683             {
1684                 dispatchTouchMotion = value;
1685             }
1686         }
1687
1688         /// <summary>
1689         /// Gets or sets the status of whether motion event of Hover can be dispatched.
1690         /// If a View's DispatchHoverMotion is set to false, then it's can not will receive motion event of HoverEvent.
1691         /// </summary>
1692         [EditorBrowsable(EditorBrowsableState.Never)]
1693         public bool DispatchHoverMotion
1694         {
1695             get
1696             {
1697                 return dispatchHoverMotion;
1698             }
1699             set
1700             {
1701                 dispatchHoverMotion = value;
1702             }
1703         }
1704
1705     }
1706 }