src/Tizen.NUI/src/public/Window/WindowEvent.cs

   1 /*
   2  * Copyright(c) 2023 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 using Tizen.NUI.BaseComponents;
  22 using System.Collections.Generic;
  23
  24 namespace Tizen.NUI
  25 {
  26     /// <summary>
  27     /// The window class is used internally for drawing.<br />
  28     /// The window has an orientation and indicator properties.<br />
  29     /// </summary>
  30     /// <since_tizen> 3 </since_tizen>
  31     public partial class Window
  32     {
  33         private WindowFocusChangedEventCallbackType windowFocusChangedEventCallback;
  34         private RootLayerTouchDataCallbackType rootLayerTouchDataCallback;
  35         private RootLayerTouchDataCallbackType rootLayerInterceptTouchDataCallback;
  36         private WheelEventCallbackType wheelEventCallback;
  37         private EventCallbackDelegateType1 stageKeyCallbackDelegate;
  38         private InterceptKeyEventDelegateType stageInterceptKeyCallbackDelegate;
  39         private EventCallbackDelegateType0 stageEventProcessingFinishedEventCallbackDelegate;
  40         private EventHandler stageContextLostEventHandler;
  41         private EventCallbackDelegateType0 stageContextLostEventCallbackDelegate;
  42         private EventHandler stageContextRegainedEventHandler;
  43         private EventCallbackDelegateType0 stageContextRegainedEventCallbackDelegate;
  44         private EventHandler stageSceneCreatedEventHandler;
  45         private EventCallbackDelegateType0 stageSceneCreatedEventCallbackDelegate;
  46         private WindowResizeEventCallbackType windowResizeEventCallback;
  47         private WindowFocusChangedEventCallbackType windowFocusChangedEventCallback2;
  48         private TransitionEffectEventCallbackType transitionEffectEventCallback;
  49         private MovedEventCallbackType movedEventCallback;
  50         private OrientationChangedEventCallbackType orientationChangedEventCallback;
  51         private KeyboardRepeatSettingsChangedEventCallbackType keyboardRepeatSettingsChangedEventCallback;
  52         private AuxiliaryMessageEventCallbackType auxiliaryMessageEventCallback;
  53         private WindowMouseInOutEventCallbackType windowMouseInOutEventCallback;
  54         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  55         private delegate void WindowFocusChangedEventCallbackType(IntPtr window, bool focusGained);
  56         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  57         private delegate bool RootLayerTouchDataCallbackType(IntPtr view, IntPtr touchData);
  58         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  59         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
  60         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  61         private delegate void WindowResizeEventCallbackType(IntPtr window, IntPtr windowSize);
  62         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  63         private delegate void WindowFocusChangedEventCallbackType2(IntPtr window, bool focusGained);
  64         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  65         private delegate void TransitionEffectEventCallbackType(IntPtr window, int state, int type);
  66         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  67         private delegate void MovedEventCallbackType(IntPtr window, IntPtr position);
  68         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  69         private delegate void OrientationChangedEventCallbackType(IntPtr window, int orientation);
  70         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  71         private delegate void KeyboardRepeatSettingsChangedEventCallbackType();
  72         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  73         private delegate void AuxiliaryMessageEventCallbackType(IntPtr kData, IntPtr vData, IntPtr optionsArray);
  74         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  75         private delegate bool InterceptKeyEventDelegateType(IntPtr arg1);
  76         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  77         private delegate void WindowMouseInOutEventCallbackType(IntPtr window, IntPtr mouseEvent);
  78
  79         /// <summary>
  80         /// FocusChanged event.
  81         /// </summary>
  82         /// <since_tizen> 3 </since_tizen>
  83         public event EventHandler<FocusChangedEventArgs> FocusChanged
  84         {
  85             add
  86             {
  87                 if (windowFocusChangedEventHandler == null)
  88                 {
  89                     windowFocusChangedEventCallback = OnWindowFocusedChanged;
  90                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
  91                     signal.Ensure()?.Connect(windowFocusChangedEventCallback);
  92                 }
  93                 windowFocusChangedEventHandler += value;
  94             }
  95             remove
  96             {
  97                 windowFocusChangedEventHandler -= value;
  98                 if (windowFocusChangedEventHandler == null && windowFocusChangedEventCallback != null)
  99                 {
 100                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 101                     signal.Ensure()?.Disconnect(windowFocusChangedEventCallback);
 102                     windowFocusChangedEventCallback = null;
 103                 }
 104             }
 105         }
 106
 107         /// <summary>
 108         /// Emits the event when the screen is touched and when the touch ends.<br />
 109         /// If there are multiple touch points then it is emitted when the first touch occurs and
 110         /// when the last finger is lifted too.<br />
 111         /// Even though incoming events are interrupted, the event occurs.<br />
 112         /// </summary>
 113         /// <since_tizen> 3 </since_tizen>
 114         public event EventHandler<TouchEventArgs> TouchEvent
 115         {
 116             add
 117             {
 118                 if (rootLayerTouchDataEventHandler == null)
 119                 {
 120                     rootLayerTouchDataCallback = OnWindowTouch;
 121                     Interop.ActorSignal.TouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
 122                     NDalicPINVOKE.ThrowExceptionIfExists();
 123                 }
 124                 rootLayerTouchDataEventHandler += value;
 125             }
 126             remove
 127             {
 128                 rootLayerTouchDataEventHandler -= value;
 129                 if (rootLayerTouchDataEventHandler == null && rootLayerTouchDataCallback != null)
 130                 {
 131                     Interop.ActorSignal.TouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
 132                     NDalicPINVOKE.ThrowExceptionIfExists();
 133                     rootLayerTouchDataCallback = null;
 134                 }
 135             }
 136         }
 137
 138         /// <summary>
 139         /// An event for the touched signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 140         /// The touched signal is emitted when the touch input is received.<br />
 141         /// This can receive touch events before child. <br />
 142         /// 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 />
 143         /// </summary>
 144         [EditorBrowsable(EditorBrowsableState.Never)]
 145         public event ReturnTypeEventHandler<object, TouchEventArgs, bool> InterceptTouchEvent
 146         {
 147             add
 148             {
 149                 if (rootLayerInterceptTouchDataEventHandler == null)
 150                 {
 151                     rootLayerInterceptTouchDataCallback = OnWindowInterceptTouch;
 152                     Interop.ActorSignal.InterceptTouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
 153                     NDalicPINVOKE.ThrowExceptionIfExists();
 154                 }
 155                 rootLayerInterceptTouchDataEventHandler += value;
 156             }
 157             remove
 158             {
 159                 rootLayerInterceptTouchDataEventHandler -= value;
 160                 if (rootLayerInterceptTouchDataEventHandler == null && rootLayerInterceptTouchDataCallback != null)
 161                 {
 162                     Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
 163                     NDalicPINVOKE.ThrowExceptionIfExists();
 164                     rootLayerInterceptTouchDataCallback = null;
 165                 }
 166             }
 167         }
 168
 169         /// <summary>
 170         /// Emits the event when the wheel event is received.
 171         /// </summary>
 172         /// <since_tizen> 3 </since_tizen>
 173         public event EventHandler<WheelEventArgs> WheelEvent
 174         {
 175             add
 176             {
 177                 if (stageWheelHandler == null)
 178                 {
 179                     wheelEventCallback = OnStageWheel;
 180                     Interop.ActorSignal.WheelEventConnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
 181                     NDalicPINVOKE.ThrowExceptionIfExists();
 182                 }
 183                 stageWheelHandler += value;
 184
 185                 if (DetentEventHandler == null)
 186                 {
 187                     DetentEventCallback = OnDetentEvent;
 188                     using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 189                     signal.Ensure()?.Connect(DetentEventCallback);
 190                 }
 191                 DetentEventHandler += value;
 192             }
 193             remove
 194             {
 195                 stageWheelHandler -= value;
 196                 if (stageWheelHandler == null && wheelEventCallback != null)
 197                 {
 198                     Interop.ActorSignal.WheelEventDisconnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
 199                     NDalicPINVOKE.ThrowExceptionIfExists();
 200                     wheelEventCallback = null;
 201                 }
 202
 203                 DetentEventHandler -= value;
 204                 if (DetentEventHandler == null && DetentEventCallback != null)
 205                 {
 206                     using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 207                     signal.Ensure()?.Disconnect(DetentEventCallback);
 208                     DetentEventCallback = null;
 209                 }
 210             }
 211         }
 212
 213         /// <summary>
 214         /// Emits the event when the key event is received.
 215         /// </summary>
 216         /// <since_tizen> 3 </since_tizen>
 217         public event EventHandler<KeyEventArgs> KeyEvent
 218         {
 219             add
 220             {
 221                 if (stageKeyHandler == null)
 222                 {
 223                     stageKeyCallbackDelegate = OnStageKey;
 224                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
 225                     signal.Ensure()?.Connect(stageKeyCallbackDelegate);
 226                 }
 227                 stageKeyHandler += value;
 228             }
 229             remove
 230             {
 231                 stageKeyHandler -= value;
 232                 if (stageKeyHandler == null && stageKeyCallbackDelegate != null)
 233                 {
 234                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
 235                     signal.Ensure()?.Disconnect(stageKeyCallbackDelegate);
 236                     stageKeyCallbackDelegate = null;
 237                 }
 238             }
 239         }
 240
 241         /// <summary>
 242         /// Intercepts KeyEvents in the window before dispatching KeyEvents to the child.<br />
 243         /// If it returns true(consumed), no KeyEvent is delivered to the child.
 244         /// </summary>
 245         [EditorBrowsable(EditorBrowsableState.Never)]
 246         public event ReturnTypeEventHandler<object, KeyEventArgs, bool> InterceptKeyEvent
 247         {
 248             add
 249             {
 250                 if (stageInterceptKeyHandler == null)
 251                 {
 252                     stageInterceptKeyCallbackDelegate = OnStageInterceptKey;
 253                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
 254                     signal.Ensure()?.Connect(stageInterceptKeyCallbackDelegate);
 255                 }
 256                 stageInterceptKeyHandler += value;
 257             }
 258             remove
 259             {
 260                 stageInterceptKeyHandler -= value;
 261                 if (stageInterceptKeyHandler == null && stageInterceptKeyCallbackDelegate != null)
 262                 {
 263                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
 264                     signal.Ensure()?.Disconnect(stageInterceptKeyCallbackDelegate);
 265                     stageInterceptKeyCallbackDelegate = null;
 266                 }
 267             }
 268         }
 269
 270         /// <summary>
 271         /// Emits the event when the window resized.
 272         /// </summary>
 273         /// <since_tizen> 3 </since_tizen>
 274         public event EventHandler<ResizedEventArgs> Resized
 275         {
 276             add
 277             {
 278                 if (windowResizeEventHandler == null)
 279                 {
 280                     windowResizeEventCallback = OnResized;
 281                     using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
 282                     signal.Ensure()?.Connect(windowResizeEventCallback);
 283                 }
 284
 285                 windowResizeEventHandler += value;
 286             }
 287             remove
 288             {
 289                 windowResizeEventHandler -= value;
 290                 if (windowResizeEventHandler == null && windowResizeEventCallback != null)
 291                 {
 292                     using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
 293                     signal.Ensure()?.Disconnect(windowResizeEventCallback);
 294                     windowResizeEventCallback = null;
 295                 }
 296             }
 297         }
 298
 299         /// <summary>
 300         /// Do not use this, that will be deprecated. Use 'FocusChanged' event instead.
 301         /// </summary>
 302         /// <since_tizen> 3 </since_tizen>
 303         /// Do not use this, that will be deprecated.
 304         /// Instead Use FocusChanged.
 305         [Obsolete("Do not use this, that will be deprecated. Use FocusChanged instead. " +
 306             "Like: " +
 307             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
 308             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
 309         [EditorBrowsable(EditorBrowsableState.Never)]
 310         public event EventHandler<FocusChangedEventArgs> WindowFocusChanged
 311         {
 312             add
 313             {
 314                 if (windowFocusChangedEventHandler2 == null)
 315                 {
 316                     windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
 317                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 318                     signal.Ensure()?.Connect(windowFocusChangedEventCallback2);
 319                 }
 320                 windowFocusChangedEventHandler2 += value;
 321             }
 322             remove
 323             {
 324                 windowFocusChangedEventHandler2 -= value;
 325                 if (windowFocusChangedEventHandler2 == null && windowFocusChangedEventCallback2 != null)
 326                 {
 327                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 328                     signal.Ensure()?.Disconnect(windowFocusChangedEventCallback2);
 329                     windowFocusChangedEventCallback2 = null;
 330                 }
 331             }
 332         }
 333
 334         /// <summary>
 335         /// EffectStart
 336         /// </summary>
 337         [EditorBrowsable(EditorBrowsableState.Never)]
 338         public event EventHandler<TransitionEffectEventArgs> TransitionEffect
 339         {
 340             add
 341             {
 342                 if (transitionEffectHandler == null)
 343                 {
 344                     transitionEffectEventCallback = OnTransitionEffect;
 345                     using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
 346                     signal.Ensure()?.Connect(transitionEffectEventCallback);
 347                 }
 348                 transitionEffectHandler += value;
 349             }
 350             remove
 351             {
 352                 transitionEffectHandler -= value;
 353                 if (transitionEffectHandler == null && transitionEffectEventCallback != null)
 354                 {
 355                     using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
 356                     signal.Ensure()?.Disconnect(transitionEffectEventCallback);
 357                     transitionEffectEventCallback = null;
 358                 }
 359             }
 360         }
 361
 362         /// <summary>
 363         /// MovedEvent
 364         /// </summary>
 365         [EditorBrowsable(EditorBrowsableState.Never)]
 366         public event EventHandler<WindowMovedEventArgs> Moved
 367         {
 368             add
 369             {
 370                 if (movedHandler == null)
 371                 {
 372                     movedEventCallback = OnMoved;
 373                     using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(SwigCPtr), false);
 374                     signal.Ensure()?.Connect(movedEventCallback);
 375                 }
 376                 movedHandler += value;
 377             }
 378             remove
 379             {
 380                 movedHandler -= value;
 381                 if (movedHandler == null && movedEventCallback != null)
 382                 {
 383                     using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(SwigCPtr), false);
 384                     signal.Ensure()?.Disconnect(movedEventCallback);
 385                     movedEventCallback = null;
 386                 }
 387             }
 388         }
 389
 390         /// <summary>
 391         /// Window Orientation Changed event
 392         /// This event is for per windows
 393         /// </summary>
 394         [EditorBrowsable(EditorBrowsableState.Never)]
 395         public event EventHandler<WindowOrientationChangedEventArgs> OrientationChanged
 396         {
 397             add
 398             {
 399                 if (orientationChangedHandler == null)
 400                 {
 401                     orientationChangedEventCallback = OnOrientationChanged;
 402                     using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(SwigCPtr), false);
 403                     signal.Ensure()?.Connect(orientationChangedEventCallback);
 404                 }
 405                 orientationChangedHandler += value;
 406             }
 407             remove
 408             {
 409                 orientationChangedHandler -= value;
 410                 if (orientationChangedHandler == null && orientationChangedEventCallback != null)
 411                 {
 412                     using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(SwigCPtr), false);
 413                     signal.Ensure()?.Disconnect(orientationChangedEventCallback);
 414                     orientationChangedEventCallback = null;
 415                 }
 416             }
 417         }
 418
 419         /// <summary>
 420         /// Keyboard Repeat Settings Changed
 421         /// </summary>
 422         [EditorBrowsable(EditorBrowsableState.Never)]
 423         public event EventHandler KeyboardRepeatSettingsChanged
 424         {
 425             add
 426             {
 427                 if (keyboardRepeatSettingsChangedHandler == null)
 428                 {
 429                     keyboardRepeatSettingsChangedEventCallback = OnKeyboardRepeatSettingsChanged;
 430                     using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
 431                     signal.Ensure()?.Connect(keyboardRepeatSettingsChangedEventCallback);
 432                 }
 433                 keyboardRepeatSettingsChangedHandler += value;
 434             }
 435             remove
 436             {
 437                 keyboardRepeatSettingsChangedHandler -= value;
 438                 if (keyboardRepeatSettingsChangedHandler == null && keyboardRepeatSettingsChangedEventCallback != null)
 439                 {
 440                     using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
 441                     signal.Ensure()?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
 442                     keyboardRepeatSettingsChangedEventCallback = null;
 443                 }
 444             }
 445         }
 446
 447         /// <summary>
 448         /// MouseInOutEvent event.
 449         /// </summary>
 450         [EditorBrowsable(EditorBrowsableState.Never)]
 451         public event EventHandler<MouseInOutEventArgs> MouseInOutEvent
 452         {
 453             add
 454             {
 455                 if (windowMouseInOutEventHandler == null)
 456                 {
 457                     windowMouseInOutEventCallback = OnWindowMouseInOutEvent;
 458                     using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(SwigCPtr), false);
 459                     signal.Ensure()?.Connect(windowMouseInOutEventCallback);
 460                 }
 461                 windowMouseInOutEventHandler += value;
 462             }
 463             remove
 464             {
 465                 windowMouseInOutEventHandler -= value;
 466                 if (windowMouseInOutEventHandler == null && windowMouseInOutEventCallback != null)
 467                 {
 468                     using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(SwigCPtr), false);
 469                     signal.Ensure()?.Disconnect(windowMouseInOutEventCallback);
 470                     windowMouseInOutEventCallback = null;
 471                 }
 472             }
 473         }
 474
 475         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler;
 476         private event EventHandler<TouchEventArgs> rootLayerTouchDataEventHandler;
 477         private ReturnTypeEventHandler<object, TouchEventArgs, bool> rootLayerInterceptTouchDataEventHandler;
 478         private event EventHandler<WheelEventArgs> stageWheelHandler;
 479         private event EventHandler<KeyEventArgs> stageKeyHandler;
 480         private ReturnTypeEventHandler<object, KeyEventArgs, bool> stageInterceptKeyHandler;
 481         private event EventHandler stageEventProcessingFinishedEventHandler;
 482         private event EventHandler<ResizedEventArgs> windowResizeEventHandler;
 483         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler2;
 484         private event EventHandler<TransitionEffectEventArgs> transitionEffectHandler;
 485         private event EventHandler<WindowMovedEventArgs> movedHandler;
 486         private event EventHandler<WindowOrientationChangedEventArgs> orientationChangedHandler;
 487         private event EventHandler keyboardRepeatSettingsChangedHandler;
 488         private event EventHandler<AuxiliaryMessageEventArgs> auxiliaryMessageEventHandler;
 489         private event EventHandler<MouseInOutEventArgs> windowMouseInOutEventHandler;
 490
 491
 492         internal event EventHandler EventProcessingFinished
 493         {
 494             add
 495             {
 496                 if (stageEventProcessingFinishedEventHandler == null)
 497                 {
 498                     stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
 499                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 500                     signal.Ensure()?.Connect(stageEventProcessingFinishedEventCallbackDelegate);
 501                 }
 502                 stageEventProcessingFinishedEventHandler += value;
 503             }
 504             remove
 505             {
 506                 stageEventProcessingFinishedEventHandler -= value;
 507                 if (stageEventProcessingFinishedEventHandler == null && stageEventProcessingFinishedEventCallbackDelegate != null)
 508                 {
 509                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 510                     signal.Ensure()?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
 511                     stageEventProcessingFinishedEventCallbackDelegate = null;
 512                 }
 513             }
 514         }
 515
 516         internal event EventHandler ContextLost
 517         {
 518             add
 519             {
 520                 if (stageContextLostEventHandler == null)
 521                 {
 522                     stageContextLostEventCallbackDelegate = OnContextLost;
 523                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 524                     signal.Ensure()?.Connect(stageContextLostEventCallbackDelegate);
 525                 }
 526                 stageContextLostEventHandler += value;
 527             }
 528             remove
 529             {
 530                 stageContextLostEventHandler -= value;
 531                 if (stageContextLostEventHandler == null && stageContextLostEventCallbackDelegate != null)
 532                 {
 533                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 534                     signal.Ensure()?.Disconnect(stageContextLostEventCallbackDelegate);
 535                     stageContextLostEventCallbackDelegate = null;
 536                 }
 537             }
 538         }
 539
 540         internal event EventHandler ContextRegained
 541         {
 542             add
 543             {
 544                 if (stageContextRegainedEventHandler == null)
 545                 {
 546                     stageContextRegainedEventCallbackDelegate = OnContextRegained;
 547                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 548                     signal.Ensure()?.Connect(stageContextRegainedEventCallbackDelegate);
 549                 }
 550                 stageContextRegainedEventHandler += value;
 551             }
 552             remove
 553             {
 554                 stageContextRegainedEventHandler -= value;
 555                 if (stageContextRegainedEventHandler == null && stageContextRegainedEventCallbackDelegate != null)
 556                 {
 557                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 558                     signal.Ensure()?.Disconnect(stageContextRegainedEventCallbackDelegate);
 559                     stageContextRegainedEventCallbackDelegate = null;
 560                 }
 561             }
 562         }
 563
 564         internal event EventHandler SceneCreated
 565         {
 566             add
 567             {
 568                 if (stageSceneCreatedEventHandler == null)
 569                 {
 570                     stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
 571                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 572                     signal.Ensure()?.Connect(stageSceneCreatedEventCallbackDelegate);
 573                 }
 574                 stageSceneCreatedEventHandler += value;
 575             }
 576             remove
 577             {
 578                 stageSceneCreatedEventHandler -= value;
 579                 if (stageSceneCreatedEventHandler == null && stageSceneCreatedEventCallbackDelegate != null)
 580                 {
 581                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 582                     signal.Ensure()?.Disconnect(stageSceneCreatedEventCallbackDelegate);
 583                     stageSceneCreatedEventCallbackDelegate = null;
 584                 }
 585             }
 586         }
 587
 588         internal System.IntPtr GetNativeWindowHandler()
 589         {
 590             System.IntPtr ret = Interop.Window.GetNativeWindowHandler(HandleRef.ToIntPtr(this.SwigCPtr));
 591             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 592             return ret;
 593         }
 594
 595         /// <summary>
 596         /// Disconnect all native signals
 597         /// </summary>
 598         /// <since_tizen> 5 </since_tizen>
 599         internal void DisconnectNativeSignals()
 600         {
 601             if (HasBody() == false)
 602             {
 603                 NUILog.Debug($"[Dispose] DisConnectFromSignals() No native body! No need to Disconnect Signals!");
 604                 return;
 605             }
 606
 607             if (windowFocusChangedEventCallback != null)
 608             {
 609                 using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
 610                 signal?.Disconnect(windowFocusChangedEventCallback);
 611                 windowFocusChangedEventCallback = null;
 612             }
 613
 614             if (rootLayerTouchDataCallback != null)
 615             {
 616                 Interop.ActorSignal.TouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
 617                 NDalicPINVOKE.ThrowExceptionIfExists();
 618                 rootLayerTouchDataCallback = null;
 619             }
 620
 621             if (rootLayerInterceptTouchDataCallback != null)
 622             {
 623                 Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
 624                 NDalicPINVOKE.ThrowExceptionIfExists();
 625                 rootLayerInterceptTouchDataCallback = null;
 626             }
 627
 628             if (wheelEventCallback != null)
 629             {
 630                 Interop.ActorSignal.WheelEventDisconnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
 631                 NDalicPINVOKE.ThrowExceptionIfExists();
 632                 wheelEventCallback = null;
 633             }
 634
 635             if (DetentEventCallback != null)
 636             {
 637                 using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 638                 signal?.Disconnect(DetentEventCallback);
 639                 DetentEventCallback = null;
 640             }
 641
 642             if (stageKeyCallbackDelegate != null)
 643             {
 644                 using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(GetBaseHandleCPtrHandleRef), false);
 645                 signal?.Disconnect(stageKeyCallbackDelegate);
 646                 stageKeyCallbackDelegate = null;
 647             }
 648
 649             if (stageInterceptKeyCallbackDelegate != null)
 650             {
 651                 using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(GetBaseHandleCPtrHandleRef), false);
 652                 signal?.Disconnect(stageInterceptKeyCallbackDelegate);
 653                 stageInterceptKeyCallbackDelegate = null;
 654             }
 655
 656             if (stageEventProcessingFinishedEventCallbackDelegate != null)
 657             {
 658                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 659                 signal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
 660                 stageEventProcessingFinishedEventCallbackDelegate = null;
 661             }
 662
 663             if (stageContextLostEventCallbackDelegate != null)
 664             {
 665                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 666                 signal?.Disconnect(stageContextLostEventCallbackDelegate);
 667                 stageContextLostEventCallbackDelegate = null;
 668             }
 669
 670             if (stageContextRegainedEventCallbackDelegate != null)
 671             {
 672                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 673                 signal?.Disconnect(stageContextRegainedEventCallbackDelegate);
 674                 stageContextRegainedEventCallbackDelegate = null;
 675             }
 676
 677             if (stageSceneCreatedEventCallbackDelegate != null)
 678             {
 679                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 680                 signal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
 681                 stageSceneCreatedEventCallbackDelegate = null;
 682             }
 683
 684             if (windowResizeEventCallback != null)
 685             {
 686                 using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(GetBaseHandleCPtrHandleRef), false);
 687                 signal?.Disconnect(windowResizeEventCallback);
 688                 windowResizeEventCallback = null;
 689             }
 690
 691             if (windowFocusChangedEventCallback2 != null)
 692             {
 693                 using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
 694                 signal?.Disconnect(windowFocusChangedEventCallback2);
 695                 windowFocusChangedEventCallback2 = null;
 696             }
 697
 698             if (transitionEffectEventCallback != null)
 699             {
 700                 using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 701                 signal?.Disconnect(transitionEffectEventCallback);
 702                 transitionEffectEventCallback = null;
 703             }
 704
 705             if (movedEventCallback != null)
 706             {
 707                 using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 708                 signal?.Disconnect(movedEventCallback);
 709                 movedEventCallback = null;
 710             }
 711
 712             if (orientationChangedEventCallback != null)
 713             {
 714                 using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 715                 signal?.Disconnect(orientationChangedEventCallback);
 716                 orientationChangedEventCallback = null;
 717             }
 718
 719             if (keyboardRepeatSettingsChangedEventCallback != null)
 720             {
 721                 using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 722                 signal?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
 723                 keyboardRepeatSettingsChangedEventCallback = null;
 724             }
 725
 726             if (auxiliaryMessageEventCallback != null)
 727             {
 728                 using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(GetBaseHandleCPtrHandleRef), false);
 729                 signal?.Disconnect(auxiliaryMessageEventCallback);
 730                 auxiliaryMessageEventCallback = null;
 731             }
 732
 733             if (AccessibilityHighlightEventCallback != null)
 734             {
 735                 using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 736                 signal?.Disconnect(AccessibilityHighlightEventCallback);
 737                 AccessibilityHighlightEventCallback = null;
 738             }
 739
 740             if (windowMouseInOutEventCallback != null)
 741             {
 742                 using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 743                 signal?.Disconnect(windowMouseInOutEventCallback);
 744                 windowMouseInOutEventCallback = null;
 745             }
 746
 747         }
 748
 749         private void OnWindowFocusedChanged(IntPtr window, bool focusGained)
 750         {
 751             if (window == IntPtr.Zero)
 752             {
 753                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
 754                 return;
 755             }
 756
 757             if (windowFocusChangedEventHandler != null)
 758             {
 759                 FocusChangedEventArgs e = new FocusChangedEventArgs();
 760                 e.FocusGained = focusGained;
 761                 windowFocusChangedEventHandler(this, e);
 762             }
 763         }
 764
 765         private bool OnWindowTouch(IntPtr view, IntPtr touchData)
 766         {
 767             if (touchData == global::System.IntPtr.Zero)
 768             {
 769                 NUILog.Error("touchData should not be null!");
 770                 return false;
 771             }
 772
 773             if (rootLayerTouchDataEventHandler != null)
 774             {
 775                 TouchEventArgs e = new TouchEventArgs();
 776                 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 777                 rootLayerTouchDataEventHandler(this, e);
 778             }
 779             return false;
 780         }
 781
 782         private bool OnWindowInterceptTouch(IntPtr view, IntPtr touchData)
 783         {
 784             if (touchData == global::System.IntPtr.Zero)
 785             {
 786                 NUILog.Error("touchData should not be null!");
 787                 return true;
 788             }
 789
 790             bool consumed = false;
 791             if (rootLayerInterceptTouchDataEventHandler != null)
 792             {
 793                 TouchEventArgs e = new TouchEventArgs();
 794                 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 795                 consumed = rootLayerInterceptTouchDataEventHandler(this, e);
 796             }
 797             return consumed;
 798         }
 799
 800         private bool OnStageWheel(IntPtr rootLayer, IntPtr wheelEvent)
 801         {
 802             if (wheelEvent == global::System.IntPtr.Zero)
 803             {
 804                 NUILog.Error("wheelEvent should not be null!");
 805                 return true;
 806             }
 807
 808             if (stageWheelHandler != null)
 809             {
 810                 WheelEventArgs e = new WheelEventArgs();
 811                 e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 812                 stageWheelHandler(this, e);
 813             }
 814             return true;
 815         }
 816
 817         // Callback for Stage KeyEventsignal
 818         private void OnStageKey(IntPtr data)
 819         {
 820             if (stageKeyHandler != null)
 821             {
 822                 KeyEventArgs e = new KeyEventArgs();
 823                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
 824                 //here we send all data to user event handlers
 825                 stageKeyHandler(this, e);
 826             }
 827         }
 828
 829         // Callback for Stage InterceptKeyEventsignal
 830         private bool OnStageInterceptKey(IntPtr data)
 831         {
 832             bool consumed = false;
 833             if (stageInterceptKeyHandler != null)
 834             {
 835                 KeyEventArgs e = new KeyEventArgs();
 836                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
 837                 //here we send all data to user event handlers
 838                 consumed = stageInterceptKeyHandler(this, e);
 839             }
 840             return consumed;
 841         }
 842
 843         // Callback for Stage EventProcessingFinishedSignal
 844         private void OnEventProcessingFinished()
 845         {
 846             stageEventProcessingFinishedEventHandler?.Invoke(this, null);
 847         }
 848
 849         // Callback for Stage ContextLostSignal
 850         private void OnContextLost()
 851         {
 852             stageContextLostEventHandler?.Invoke(this, null);
 853         }
 854
 855         // Callback for Stage ContextRegainedSignal
 856         private void OnContextRegained()
 857         {
 858             stageContextRegainedEventHandler?.Invoke(this, null);
 859         }
 860
 861         // Callback for Stage SceneCreatedSignal
 862         private void OnSceneCreated()
 863         {
 864             stageSceneCreatedEventHandler?.Invoke(this, null);
 865         }
 866
 867         private void OnResized(IntPtr window, IntPtr windowSize)
 868         {
 869             if (window == IntPtr.Zero)
 870             {
 871                 NUILog.Error("OnResized() Window is null! Do nothing!");
 872                 return;
 873             }
 874
 875             if (windowResizeEventHandler != null)
 876             {
 877                 ResizedEventArgs e = new ResizedEventArgs();
 878                 // var val = new Uint16Pair(windowSize, false);
 879                 // e.WindowSize = new Size2D(val.GetWidth(), val.GetHeight());
 880                 // val.Dispose();
 881
 882                 // Workaround : windowSize should be valid pointer from dali,
 883                 // but currently it is fixed and is not Uint16Pair class.
 884                 // will be fixed later.
 885                 e.WindowSize = this.WindowSize;
 886                 windowResizeEventHandler(this, e);
 887             }
 888         }
 889
 890         private void OnWindowFocusedChanged2(IntPtr window, bool focusGained)
 891         {
 892             if (window == IntPtr.Zero)
 893             {
 894                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
 895                 return;
 896             }
 897
 898             if (windowFocusChangedEventHandler2 != null)
 899             {
 900                 FocusChangedEventArgs e = new FocusChangedEventArgs();
 901                 e.FocusGained = focusGained;
 902                 windowFocusChangedEventHandler2(this, e);
 903             }
 904         }
 905
 906         private void OnTransitionEffect(IntPtr window, int state, int type)
 907         {
 908             if (window == global::System.IntPtr.Zero)
 909             {
 910                 return;
 911             }
 912
 913             if (transitionEffectHandler != null)
 914             {
 915                 TransitionEffectEventArgs e = new TransitionEffectEventArgs();
 916                 e.State = (EffectState)state;
 917                 e.Type = (EffectType)type;
 918                 transitionEffectHandler(this, e);
 919             }
 920             return;
 921         }
 922
 923         private void OnMoved(IntPtr window, IntPtr position)
 924         {
 925             if (window == global::System.IntPtr.Zero)
 926             {
 927                 return;
 928             }
 929
 930             if (movedHandler != null)
 931             {
 932                 WindowMovedEventArgs e = new WindowMovedEventArgs();
 933                 e.WindowPosition = this.WindowPosition;
 934                 movedHandler(this, e);
 935             }
 936             return;
 937         }
 938
 939         private void OnOrientationChanged(IntPtr window, int orientation)
 940         {
 941             if (window == global::System.IntPtr.Zero)
 942             {
 943                 return;
 944             }
 945
 946             if (orientationChangedHandler != null)
 947             {
 948                 WindowOrientationChangedEventArgs e = new WindowOrientationChangedEventArgs();
 949                 e.WindowOrientation = (WindowOrientation)orientation;
 950                 orientationChangedHandler(this, e);
 951             }
 952             return;
 953         }
 954
 955         private void OnKeyboardRepeatSettingsChanged()
 956         {
 957             keyboardRepeatSettingsChangedHandler?.Invoke(this, null);
 958             return;
 959         }
 960
 961         private void OnWindowMouseInOutEvent(IntPtr view, IntPtr mouseEvent)
 962         {
 963             if (mouseEvent == global::System.IntPtr.Zero)
 964             {
 965                 NUILog.Error("mouseEvent should not be null!");
 966                 return;
 967             }
 968
 969             if (windowMouseInOutEventHandler != null)
 970             {
 971                 MouseInOutEventArgs e = new MouseInOutEventArgs();
 972                 e.MouseInOut = Tizen.NUI.MouseInOut.GetMouseInOutFromPtr(mouseEvent);
 973                 windowMouseInOutEventHandler(this, e);
 974             }
 975         }
 976
 977         /// <summary>
 978         /// The focus changed event argument.
 979         /// </summary>
 980         /// <since_tizen> 3 </since_tizen>
 981         public class FocusChangedEventArgs : EventArgs
 982         {
 983             /// <summary>
 984             /// FocusGained flag.
 985             /// </summary>
 986             /// <since_tizen> 3 </since_tizen>
 987             public bool FocusGained
 988             {
 989                 get;
 990                 set;
 991             }
 992         }
 993
 994         /// <summary>
 995         /// The touch event argument.
 996         /// </summary>
 997         /// <since_tizen> 3 </since_tizen>
 998         public class TouchEventArgs : EventArgs
 999         {
1000             private Touch touch;
1001
1002             /// <summary>
1003             /// Touch.
1004             /// </summary>
1005             /// <since_tizen> 3 </since_tizen>
1006             public Touch Touch
1007             {
1008                 get
1009                 {
1010                     return touch;
1011                 }
1012                 set
1013                 {
1014                     touch = value;
1015                 }
1016             }
1017         }
1018
1019         /// <summary>
1020         /// Wheel event arguments.
1021         /// </summary>
1022         /// <since_tizen> 3 </since_tizen>
1023         public class WheelEventArgs : EventArgs
1024         {
1025             private Wheel wheel;
1026
1027             /// <summary>
1028             /// Wheel.
1029             /// </summary>
1030             /// <since_tizen> 3 </since_tizen>
1031             public Wheel Wheel
1032             {
1033                 get
1034                 {
1035                     return wheel;
1036                 }
1037                 set
1038                 {
1039                     wheel = value;
1040                 }
1041             }
1042         }
1043
1044         /// <summary>
1045         /// Key event arguments.
1046         /// </summary>
1047         /// <since_tizen> 3 </since_tizen>
1048         public class KeyEventArgs : EventArgs
1049         {
1050             private Key key;
1051
1052             /// <summary>
1053             /// Key.
1054             /// </summary>
1055             /// <since_tizen> 3 </since_tizen>
1056             public Key Key
1057             {
1058                 get
1059                 {
1060                     return key;
1061                 }
1062                 set
1063                 {
1064                     key = value;
1065                 }
1066             }
1067         }
1068
1069         /// <summary>
1070         /// Feeds a key event into the window.
1071         /// This resized event arguments.
1072         /// </summary>
1073         /// <since_tizen> 3 </since_tizen>
1074         public class ResizedEventArgs : EventArgs
1075         {
1076             Size2D windowSize;
1077
1078             /// <summary>
1079             /// This window size.
1080             /// </summary>
1081             /// <since_tizen> 4 </since_tizen>
1082             public Size2D WindowSize
1083             {
1084                 get
1085                 {
1086                     return windowSize;
1087                 }
1088                 set
1089                 {
1090                     windowSize = value;
1091                 }
1092             }
1093         }
1094
1095         /// <summary>
1096         /// MouseInOut evnet arguments.
1097         /// </summary>
1098         [EditorBrowsable(EditorBrowsableState.Never)]
1099         public class MouseInOutEventArgs : EventArgs
1100         {
1101             private MouseInOut mouseEvent;
1102
1103             /// <summary>
1104             /// MouseInOut event.
1105             /// </summary>
1106             [EditorBrowsable(EditorBrowsableState.Never)]
1107             public MouseInOut MouseInOut
1108             {
1109                 get
1110                 {
1111                     return mouseEvent;
1112                 }
1113                 set
1114                 {
1115                     mouseEvent = value;
1116                 }
1117             }
1118         }
1119
1120         /// <summary>
1121         /// Do not use this, that will be deprecated.
1122         /// </summary>
1123         /// <since_tizen> 3 </since_tizen>
1124         [Obsolete("Do not use this, that will be deprecated. Use FocusChangedEventArgs instead. " +
1125             "Like: " +
1126             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
1127             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
1128         [EditorBrowsable(EditorBrowsableState.Never)]
1129         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
1130         public class WindowFocusChangedEventArgs : EventArgs
1131         {
1132             /// <summary>
1133             /// Do not use this, that will be deprecated.
1134             /// </summary>
1135             /// <since_tizen> 3 </since_tizen>
1136             public bool FocusGained
1137             {
1138                 get;
1139                 set;
1140             }
1141         }
1142
1143         /// <summary>
1144         /// Contains and encapsulates Native Window handle.
1145         /// </summary>
1146         /// <since_tizen> 4 </since_tizen>
1147         [Obsolete("This has been deprecated in API9 and will be removed in API11. Use Window.NativeHandle instead.")]
1148         public class SafeNativeWindowHandle : SafeHandle
1149         {
1150             /// <summary>
1151             ///Constructor, Native window handle is set to handle.
1152             /// </summary>
1153             /// <since_tizen> 4 </since_tizen>
1154             public SafeNativeWindowHandle() : base(IntPtr.Zero, false)
1155             {
1156                 SetHandle(NUIApplication.GetDefaultWindow().GetNativeWindowHandler());
1157             }
1158             /// <summary>
1159             /// Null check if the handle is valid or not.
1160             /// </summary>
1161             /// <since_tizen> 4 </since_tizen>
1162             public override bool IsInvalid
1163             {
1164                 get
1165                 {
1166                     return this.handle == IntPtr.Zero;
1167                 }
1168             }
1169             /// <summary>
1170             /// Release handle itself.
1171             /// </summary>
1172             /// <returns>true when released successfully.</returns>
1173             /// <since_tizen> 4 </since_tizen>
1174             protected override bool ReleaseHandle()
1175             {
1176                 return true;
1177             }
1178         }
1179
1180         /// <summary>
1181         /// TransitionEffectArgs
1182         /// </summary>
1183         [EditorBrowsable(EditorBrowsableState.Never)]
1184         public class TransitionEffectEventArgs : EventArgs
1185         {
1186             private EffectState state;
1187             private EffectType type;
1188
1189             /// <summary>
1190             /// State
1191             /// </summary>
1192             [EditorBrowsable(EditorBrowsableState.Never)]
1193             public EffectState State
1194             {
1195                 get
1196                 {
1197                     return state;
1198                 }
1199                 set
1200                 {
1201                     state = value;
1202                 }
1203             }
1204             /// <summary>
1205             /// Type
1206             /// </summary>
1207             [EditorBrowsable(EditorBrowsableState.Never)]
1208             public EffectType Type
1209             {
1210                 get
1211                 {
1212                     return type;
1213                 }
1214                 set
1215                 {
1216                     type = value;
1217                 }
1218             }
1219         }
1220
1221         private EventHandler<WheelEventArgs> DetentEventHandler;
1222
1223         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1224         private delegate void DetentEventCallbackType(IntPtr arg1);
1225
1226         private DetentEventCallbackType DetentEventCallback;
1227
1228         private void OnDetentEvent(IntPtr wheelEvent)
1229         {
1230             WheelEventArgs e = new WheelEventArgs();
1231
1232             if (wheelEvent != global::System.IntPtr.Zero)
1233             {
1234                 e.Wheel = Wheel.GetWheelFromPtr(wheelEvent);
1235             }
1236
1237             DetentEventHandler?.Invoke(this, e);
1238         }
1239
1240         /// <summary>
1241         /// VisibilityChangedArgs
1242         /// </summary>
1243         [EditorBrowsable(EditorBrowsableState.Never)]
1244         public class VisibilityChangedEventArgs : EventArgs
1245         {
1246             private bool visibility;
1247             /// <summary>
1248             /// Visibility
1249             /// </summary>
1250             [EditorBrowsable(EditorBrowsableState.Never)]
1251             public bool Visibility
1252             {
1253                 get => visibility;
1254                 set
1255                 {
1256                     visibility = value;
1257                 }
1258             }
1259         }
1260
1261         private void OnVisibilityChanged(IntPtr window, bool visibility)
1262         {
1263             if (window == global::System.IntPtr.Zero)
1264             {
1265                 NUILog.Error("[ERR] OnVisibilityChanged() window is null");
1266                 return;
1267             }
1268
1269             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
1270             e.Visibility = visibility;
1271             if (VisibilityChangedEventHandler != null)
1272             {
1273                 VisibilityChangedEventHandler.Invoke(this, e);
1274             }
1275         }
1276
1277         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1278         private delegate void VisibilityChangedEventCallbackType(IntPtr window, bool visibility);
1279         private VisibilityChangedEventCallbackType VisibilityChangedEventCallback;
1280         private event EventHandler<VisibilityChangedEventArgs> VisibilityChangedEventHandler;
1281         private WindowVisibilityChangedEvent VisibilityChangedEventSignal;
1282
1283         /// <summary>
1284         /// EffectStart
1285         /// </summary>
1286         [EditorBrowsable(EditorBrowsableState.Never)]
1287         public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
1288         {
1289             add
1290             {
1291                 if (VisibilityChangedEventHandler == null)
1292                 {
1293                     VisibilityChangedEventCallback = OnVisibilityChanged;
1294                     using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
1295                     signal.Ensure()?.Connect(VisibilityChangedEventCallback);
1296                 }
1297                 VisibilityChangedEventHandler += value;
1298             }
1299             remove
1300             {
1301                 VisibilityChangedEventHandler -= value;
1302                 if (VisibilityChangedEventHandler == null && VisibilityChangedEventCallback != null)
1303                 {
1304                     using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
1305                     signal.Ensure()?.Disconnect(VisibilityChangedEventCallback);
1306                     VisibilityChangedEventCallback = null;
1307                 }
1308             }
1309         }
1310
1311         /// <summary>
1312         /// VisibiltyChangedSignalEmit
1313         /// </summary>
1314         [EditorBrowsable(EditorBrowsableState.Never)]
1315         public void VisibiltyChangedSignalEmit(bool visibility)
1316         {
1317             if (VisibilityChangedEventSignal == null)
1318             {
1319                 VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this);
1320             }
1321             VisibilityChangedEventSignal.Emit(this, visibility);
1322         }
1323
1324         private void OnAuxiliaryMessage(IntPtr kData, IntPtr vData, IntPtr optionsArray)
1325         {
1326             if (kData == IntPtr.Zero || vData == IntPtr.Zero)
1327             {
1328                 return;
1329             }
1330
1331             using var tmp = new PropertyArray(optionsArray, false);
1332             var size = tmp.Size();
1333
1334             List<string> tmpList = new List<string>();
1335
1336             for (int i = 0; i < size; i++)
1337             {
1338                 string option = "none";
1339                 tmp.GetElementAt((uint)i).Get(out option);
1340                 tmpList.Add(option);
1341             }
1342
1343             tmp.Dispose();
1344
1345             AuxiliaryMessageEventArgs e = new AuxiliaryMessageEventArgs();
1346             e.Key = StringToVoidSignal.GetResult(kData);
1347             e.Value = StringToVoidSignal.GetResult(vData); ;
1348             e.Options = tmpList;
1349
1350             auxiliaryMessageEventHandler?.Invoke(this, e);
1351         }
1352
1353         /// <summary>
1354         /// Auxiliary message is sent by displayer server when window's auxiliary was changed then display server sent the message.
1355         /// When client application added the window's auxiliary hint and if the auxiliary is changed,
1356         /// display server send the auxiliary message.
1357         /// Auxiliary message has the key, value and options.
1358         /// </summary>
1359         [EditorBrowsable(EditorBrowsableState.Never)]
1360         public event EventHandler<AuxiliaryMessageEventArgs> AuxiliaryMessage
1361         {
1362             add
1363             {
1364                 if (auxiliaryMessageEventHandler == null)
1365                 {
1366                     auxiliaryMessageEventCallback = OnAuxiliaryMessage;
1367                     using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
1368                     signal.Ensure()?.Connect(auxiliaryMessageEventCallback);
1369                 }
1370                 auxiliaryMessageEventHandler += value;
1371             }
1372             remove
1373             {
1374                 auxiliaryMessageEventHandler -= value;
1375                 if (auxiliaryMessageEventHandler == null && auxiliaryMessageEventCallback != null)
1376                 {
1377                     using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
1378                     signal.Ensure()?.Disconnect(auxiliaryMessageEventCallback);
1379                     auxiliaryMessageEventCallback = null;
1380                 }
1381             }
1382         }
1383
1384         /// <summary>
1385         /// AccessibilityHighlightArgs
1386         /// </summary>
1387         [EditorBrowsable(EditorBrowsableState.Never)]
1388         public class AccessibilityHighlightEventArgs : EventArgs
1389         {
1390             private bool accessibilityHighlight;
1391             /// <summary>
1392             /// accessibilityHighlight
1393             /// </summary>
1394             [EditorBrowsable(EditorBrowsableState.Never)]
1395             public bool AccessibilityHighlight
1396             {
1397                 get => accessibilityHighlight;
1398                 set
1399                 {
1400                     accessibilityHighlight = value;
1401                 }
1402             }
1403         }
1404
1405         private void OnAccessibilityHighlight(IntPtr window, bool highlight)
1406         {
1407             if (window == global::System.IntPtr.Zero)
1408             {
1409                 NUILog.Error("[ERR] OnAccessibilityHighlight() window is null");
1410                 return;
1411             }
1412
1413             AccessibilityHighlightEventArgs e = new AccessibilityHighlightEventArgs();
1414             e.AccessibilityHighlight = highlight;
1415             if (AccessibilityHighlightEventHandler != null)
1416             {
1417                 AccessibilityHighlightEventHandler.Invoke(this, e);
1418             }
1419         }
1420
1421         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1422         private delegate void AccessibilityHighlightEventCallbackType(IntPtr window, bool highlight);
1423         private AccessibilityHighlightEventCallbackType AccessibilityHighlightEventCallback;
1424         private event EventHandler<AccessibilityHighlightEventArgs> AccessibilityHighlightEventHandler;
1425
1426         /// <summary>
1427         /// Emits the event when the window needs to grab or clear highlight.
1428         /// </summary>
1429         [EditorBrowsable(EditorBrowsableState.Never)]
1430         public event EventHandler<AccessibilityHighlightEventArgs> AccessibilityHighlight
1431         {
1432             add
1433             {
1434                 if (AccessibilityHighlightEventHandler == null)
1435                 {
1436                     AccessibilityHighlightEventCallback = OnAccessibilityHighlight;
1437                     using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(SwigCPtr), false);
1438                     signal.Ensure()?.Connect(AccessibilityHighlightEventCallback);
1439                 }
1440                 AccessibilityHighlightEventHandler += value;
1441             }
1442             remove
1443             {
1444                 AccessibilityHighlightEventHandler -= value;
1445                 if (AccessibilityHighlightEventHandler == null && AccessibilityHighlightEventCallback != null)
1446                 {
1447                     using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(SwigCPtr), false);
1448                     signal.Ensure()?.Disconnect(AccessibilityHighlightEventCallback);
1449                     AccessibilityHighlightEventCallback = null;
1450                 }
1451             }
1452         }
1453     }
1454
1455     /// <summary>
1456     /// MovedArgs
1457     /// </summary>
1458     [EditorBrowsable(EditorBrowsableState.Never)]
1459     public class WindowMovedEventArgs : EventArgs
1460     {
1461         private Position2D position;
1462
1463         [EditorBrowsable(EditorBrowsableState.Never)]
1464         public Position2D WindowPosition
1465         {
1466             get
1467             {
1468                 return position;
1469             }
1470             set
1471             {
1472                 position = value;
1473             }
1474         }
1475     }
1476
1477     /// <summary>
1478     /// OrientationChangedArgs
1479     /// </summary>
1480     [EditorBrowsable(EditorBrowsableState.Never)]
1481     public class WindowOrientationChangedEventArgs : EventArgs
1482     {
1483         private Window.WindowOrientation orientation;
1484
1485         [EditorBrowsable(EditorBrowsableState.Never)]
1486         public Window.WindowOrientation WindowOrientation
1487         {
1488             get
1489             {
1490                 return orientation;
1491             }
1492             set
1493             {
1494                 orientation = value;
1495             }
1496         }
1497     }
1498 }