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 WheelEventCallbackType interceptWheelCallback;
  38         private EventCallbackDelegateType1 stageKeyCallbackDelegate;
  39         private InterceptKeyEventDelegateType stageInterceptKeyCallbackDelegate;
  40         private EventCallbackDelegateType0 stageEventProcessingFinishedEventCallbackDelegate;
  41         private EventHandler stageContextLostEventHandler;
  42         private EventCallbackDelegateType0 stageContextLostEventCallbackDelegate;
  43         private EventHandler stageContextRegainedEventHandler;
  44         private EventCallbackDelegateType0 stageContextRegainedEventCallbackDelegate;
  45         private EventHandler stageSceneCreatedEventHandler;
  46         private EventCallbackDelegateType0 stageSceneCreatedEventCallbackDelegate;
  47         private WindowResizeEventCallbackType windowResizeEventCallback;
  48         private WindowFocusChangedEventCallbackType windowFocusChangedEventCallback2;
  49         private TransitionEffectEventCallbackType transitionEffectEventCallback;
  50         private MovedEventCallbackType movedEventCallback;
  51         private OrientationChangedEventCallbackType orientationChangedEventCallback;
  52         private KeyboardRepeatSettingsChangedEventCallbackType keyboardRepeatSettingsChangedEventCallback;
  53         private AuxiliaryMessageEventCallbackType auxiliaryMessageEventCallback;
  54         private WindowMouseInOutEventCallbackType windowMouseInOutEventCallback;
  55         private WindowMouseRelativeEventCallbackType windowMouseRelativeEventCallback;
  56         private MoveCompletedEventCallbackType moveCompletedEventCallback;
  57         private ResizeCompletedEventCallbackType resizeCompletedEventCallback;
  58         private InsetsChangedEventCallbackType insetsChangedEventCallback;
  59         private WindowPointerConstraintsEventCallback windowPointerConstraintsEventCallback;
  60         private RootLayerHoverDataCallbackType rootLayerHoverDataCallback;
  61         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  62         private delegate void WindowFocusChangedEventCallbackType(IntPtr window, bool focusGained);
  63         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  64         private delegate bool RootLayerTouchDataCallbackType(IntPtr view, IntPtr touchData);
  65         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  66         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
  67         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  68         private delegate void WindowResizeEventCallbackType(IntPtr window, IntPtr windowSize);
  69         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  70         private delegate void WindowFocusChangedEventCallbackType2(IntPtr window, bool focusGained);
  71         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  72         private delegate void TransitionEffectEventCallbackType(IntPtr window, int state, int type);
  73         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  74         private delegate void MovedEventCallbackType(IntPtr window, IntPtr position);
  75         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  76         private delegate void OrientationChangedEventCallbackType(IntPtr window, int orientation);
  77         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  78         private delegate void KeyboardRepeatSettingsChangedEventCallbackType();
  79         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  80         private delegate void AuxiliaryMessageEventCallbackType(IntPtr kData, IntPtr vData, IntPtr optionsArray);
  81         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  82         private delegate bool InterceptKeyEventDelegateType(IntPtr arg1);
  83         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  84         private delegate void WindowMouseInOutEventCallbackType(IntPtr window, IntPtr mouseEvent);
  85         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  86         private delegate void WindowMouseRelativeEventCallbackType(IntPtr window, IntPtr mouseEvent);
  87         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  88         private delegate void MoveCompletedEventCallbackType(IntPtr window, IntPtr position);
  89         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  90         private delegate void ResizeCompletedEventCallbackType(IntPtr window, IntPtr size);
  91         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  92         private delegate void InsetsChangedEventCallbackType(int partType, int partState, IntPtr extents);
  93         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  94         private delegate void WindowPointerConstraintsEventCallback(IntPtr window, IntPtr constraintsEvent);
  95         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  96         private delegate bool RootLayerHoverDataCallbackType(IntPtr view, IntPtr hoverData);
  97
  98
  99         /// <summary>
 100         /// FocusChanged event.
 101         /// </summary>
 102         /// <since_tizen> 3 </since_tizen>
 103         public event EventHandler<FocusChangedEventArgs> FocusChanged
 104         {
 105             add
 106             {
 107                 if (windowFocusChangedEventHandler == null)
 108                 {
 109                     windowFocusChangedEventCallback = OnWindowFocusedChanged;
 110                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 111                     signal.Ensure()?.Connect(windowFocusChangedEventCallback);
 112                 }
 113                 windowFocusChangedEventHandler += value;
 114             }
 115             remove
 116             {
 117                 windowFocusChangedEventHandler -= value;
 118                 if (windowFocusChangedEventHandler == null && windowFocusChangedEventCallback != null)
 119                 {
 120                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 121                     signal.Ensure()?.Disconnect(windowFocusChangedEventCallback);
 122                     windowFocusChangedEventCallback = null;
 123                 }
 124             }
 125         }
 126
 127         /// <summary>
 128         /// Emits the event when the screen is touched and when the touch ends.<br />
 129         /// If there are multiple touch points then it is emitted when the first touch occurs and
 130         /// when the last finger is lifted too.<br />
 131         /// Even though incoming events are interrupted, the event occurs.<br />
 132         /// </summary>
 133         /// <since_tizen> 3 </since_tizen>
 134         public event EventHandler<TouchEventArgs> TouchEvent
 135         {
 136             add
 137             {
 138                 if (rootLayerTouchDataEventHandler == null)
 139                 {
 140                     rootLayerTouchDataCallback = OnWindowTouch;
 141                     Interop.ActorSignal.TouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
 142                     NDalicPINVOKE.ThrowExceptionIfExists();
 143                 }
 144                 rootLayerTouchDataEventHandler += value;
 145             }
 146             remove
 147             {
 148                 rootLayerTouchDataEventHandler -= value;
 149                 if (rootLayerTouchDataEventHandler == null && rootLayerTouchDataCallback != null)
 150                 {
 151                     Interop.ActorSignal.TouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
 152                     NDalicPINVOKE.ThrowExceptionIfExists();
 153                     rootLayerTouchDataCallback = null;
 154                 }
 155             }
 156         }
 157
 158
 159         /// <summary>
 160         /// An event for the touched signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 161         /// The touched signal is emitted when the touch input is received.<br />
 162         /// This can receive touch events before child. <br />
 163         /// 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 />
 164         /// </summary>
 165         [EditorBrowsable(EditorBrowsableState.Never)]
 166         public event ReturnTypeEventHandler<object, TouchEventArgs, bool> InterceptTouchEvent
 167         {
 168             add
 169             {
 170                 if (rootLayerInterceptTouchDataEventHandler == null)
 171                 {
 172                     rootLayerInterceptTouchDataCallback = OnWindowInterceptTouch;
 173                     Interop.ActorSignal.InterceptTouchConnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
 174                     NDalicPINVOKE.ThrowExceptionIfExists();
 175                 }
 176                 rootLayerInterceptTouchDataEventHandler += value;
 177             }
 178             remove
 179             {
 180                 rootLayerInterceptTouchDataEventHandler -= value;
 181                 if (rootLayerInterceptTouchDataEventHandler == null && rootLayerInterceptTouchDataCallback != null)
 182                 {
 183                     Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
 184                     NDalicPINVOKE.ThrowExceptionIfExists();
 185                     rootLayerInterceptTouchDataCallback = null;
 186                 }
 187             }
 188         }
 189
 190         /// <summary>
 191         /// Emits the event when the wheel event is received.
 192         /// </summary>
 193         /// <since_tizen> 3 </since_tizen>
 194         public event EventHandler<WheelEventArgs> WheelEvent
 195         {
 196             add
 197             {
 198                 if (stageWheelHandler == null)
 199                 {
 200                     wheelEventCallback = OnStageWheel;
 201                     Interop.ActorSignal.WheelEventConnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
 202                     NDalicPINVOKE.ThrowExceptionIfExists();
 203                 }
 204                 stageWheelHandler += value;
 205
 206                 if (DetentEventHandler == null)
 207                 {
 208                     DetentEventCallback = OnDetentEvent;
 209                     using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 210                     signal.Ensure()?.Connect(DetentEventCallback);
 211                 }
 212                 DetentEventHandler += value;
 213             }
 214             remove
 215             {
 216                 stageWheelHandler -= value;
 217                 if (stageWheelHandler == null && wheelEventCallback != null)
 218                 {
 219                     Interop.ActorSignal.WheelEventDisconnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
 220                     NDalicPINVOKE.ThrowExceptionIfExists();
 221                     wheelEventCallback = null;
 222                 }
 223
 224                 DetentEventHandler -= value;
 225                 if (DetentEventHandler == null && DetentEventCallback != null)
 226                 {
 227                     using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 228                     signal.Ensure()?.Disconnect(DetentEventCallback);
 229                     DetentEventCallback = null;
 230                 }
 231             }
 232         }
 233
 234         /// <summary>
 235         /// An event for the wheel event signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 236         /// The wheel event signal is emitted when the wheel input is received.<br />
 237         /// This can receive wheel events before child. <br />
 238         /// 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 />
 239         /// </summary>
 240         [EditorBrowsable(EditorBrowsableState.Never)]
 241         public event ReturnTypeEventHandler<object, WheelEventArgs, bool> InterceptWheelEvent
 242         {
 243             add
 244             {
 245                 if (interceptWheelHandler == null)
 246                 {
 247                     interceptWheelCallback = OnWindowInterceptWheel;
 248                     Interop.ActorSignal.InterceptWheelConnect(Layer.getCPtr(GetRootLayer()), interceptWheelCallback.ToHandleRef(this));
 249                     NDalicPINVOKE.ThrowExceptionIfExists();
 250                 }
 251                 interceptWheelHandler += value;
 252             }
 253             remove
 254             {
 255                 interceptWheelHandler -= value;
 256                 if (interceptWheelHandler == null && interceptWheelCallback != null)
 257                 {
 258                     Interop.ActorSignal.InterceptWheelDisconnect(Layer.getCPtr(GetRootLayer()), interceptWheelCallback.ToHandleRef(this));
 259                     NDalicPINVOKE.ThrowExceptionIfExists();
 260                     interceptWheelCallback = null;
 261                 }
 262             }
 263         }
 264
 265         /// <summary>
 266         /// Emits the event when the key event is received.
 267         /// </summary>
 268         /// <since_tizen> 3 </since_tizen>
 269         public event EventHandler<KeyEventArgs> KeyEvent
 270         {
 271             add
 272             {
 273                 if (stageKeyHandler == null)
 274                 {
 275                     stageKeyCallbackDelegate = OnStageKey;
 276                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
 277                     signal.Ensure()?.Connect(stageKeyCallbackDelegate);
 278                 }
 279                 stageKeyHandler += value;
 280             }
 281             remove
 282             {
 283                 stageKeyHandler -= value;
 284                 if (stageKeyHandler == null && stageKeyCallbackDelegate != null)
 285                 {
 286                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
 287                     signal.Ensure()?.Disconnect(stageKeyCallbackDelegate);
 288                     stageKeyCallbackDelegate = null;
 289                 }
 290             }
 291         }
 292
 293         /// <summary>
 294         /// Intercepts KeyEvents in the window before dispatching KeyEvents to the child.<br />
 295         /// If it returns true(consumed), no KeyEvent is delivered to the child.
 296         /// </summary>
 297         [EditorBrowsable(EditorBrowsableState.Never)]
 298         public event ReturnTypeEventHandler<object, KeyEventArgs, bool> InterceptKeyEvent
 299         {
 300             add
 301             {
 302                 if (stageInterceptKeyHandler == null)
 303                 {
 304                     stageInterceptKeyCallbackDelegate = OnStageInterceptKey;
 305                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
 306                     signal.Ensure()?.Connect(stageInterceptKeyCallbackDelegate);
 307                 }
 308                 stageInterceptKeyHandler += value;
 309             }
 310             remove
 311             {
 312                 stageInterceptKeyHandler -= value;
 313                 if (stageInterceptKeyHandler == null && stageInterceptKeyCallbackDelegate != null)
 314                 {
 315                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
 316                     signal.Ensure()?.Disconnect(stageInterceptKeyCallbackDelegate);
 317                     stageInterceptKeyCallbackDelegate = null;
 318                 }
 319             }
 320         }
 321
 322         /// <summary>
 323         /// Emits the event when window is resized by user or the display server.<br />
 324         /// </summary>
 325         /// <since_tizen> 3 </since_tizen>
 326         public event EventHandler<ResizedEventArgs> Resized
 327         {
 328             add
 329             {
 330                 if (windowResizeEventHandler == null)
 331                 {
 332                     windowResizeEventCallback = OnResized;
 333                     using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
 334                     signal.Ensure()?.Connect(windowResizeEventCallback);
 335                 }
 336
 337                 windowResizeEventHandler += value;
 338             }
 339             remove
 340             {
 341                 windowResizeEventHandler -= value;
 342                 if (windowResizeEventHandler == null && windowResizeEventCallback != null)
 343                 {
 344                     using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
 345                     signal.Ensure()?.Disconnect(windowResizeEventCallback);
 346                     windowResizeEventCallback = null;
 347                 }
 348             }
 349         }
 350
 351         /// <summary>
 352         /// An event for the hovered signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 353         /// The hovered signal is emitted when the hover input is received.<br />
 354         /// </summary>
 355         [EditorBrowsable(EditorBrowsableState.Never)]
 356         public event EventHandler<HoverEventArgs> HoverEvent
 357         {
 358             add
 359             {
 360                 if (rootLayerHoverDataEventHandler == null)
 361                 {
 362                     rootLayerHoverDataCallback = OnWindowHover;
 363                     Interop.ActorSignal.HoveredConnect(Layer.getCPtr(GetRootLayer()), rootLayerHoverDataCallback.ToHandleRef(this));
 364                     NDalicPINVOKE.ThrowExceptionIfExists();
 365                 }
 366                 rootLayerHoverDataEventHandler += value;
 367             }
 368             remove
 369             {
 370                 rootLayerHoverDataEventHandler -= value;
 371                 if (rootLayerHoverDataEventHandler == null && rootLayerHoverDataCallback != null)
 372                 {
 373                     Interop.ActorSignal.HoveredDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerHoverDataCallback.ToHandleRef(this));
 374                     NDalicPINVOKE.ThrowExceptionIfExists();
 375                     rootLayerHoverDataCallback = null;
 376                 }
 377             }
 378         }
 379
 380         /// <summary>
 381         /// Do not use this, that will be deprecated. Use 'FocusChanged' event instead.
 382         /// </summary>
 383         /// <since_tizen> 3 </since_tizen>
 384         /// Do not use this, that will be deprecated.
 385         /// Instead Use FocusChanged.
 386         [Obsolete("Do not use this, that will be deprecated. Use FocusChanged instead. " +
 387             "Like: " +
 388             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
 389             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
 390         [EditorBrowsable(EditorBrowsableState.Never)]
 391         public event EventHandler<FocusChangedEventArgs> WindowFocusChanged
 392         {
 393             add
 394             {
 395                 if (windowFocusChangedEventHandler2 == null)
 396                 {
 397                     windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
 398                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 399                     signal.Ensure()?.Connect(windowFocusChangedEventCallback2);
 400                 }
 401                 windowFocusChangedEventHandler2 += value;
 402             }
 403             remove
 404             {
 405                 windowFocusChangedEventHandler2 -= value;
 406                 if (windowFocusChangedEventHandler2 == null && windowFocusChangedEventCallback2 != null)
 407                 {
 408                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 409                     signal.Ensure()?.Disconnect(windowFocusChangedEventCallback2);
 410                     windowFocusChangedEventCallback2 = null;
 411                 }
 412             }
 413         }
 414
 415         /// <summary>
 416         /// EffectStart
 417         /// </summary>
 418         [EditorBrowsable(EditorBrowsableState.Never)]
 419         public event EventHandler<TransitionEffectEventArgs> TransitionEffect
 420         {
 421             add
 422             {
 423                 if (transitionEffectHandler == null)
 424                 {
 425                     transitionEffectEventCallback = OnTransitionEffect;
 426                     using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
 427                     signal.Ensure()?.Connect(transitionEffectEventCallback);
 428                 }
 429                 transitionEffectHandler += value;
 430             }
 431             remove
 432             {
 433                 transitionEffectHandler -= value;
 434                 if (transitionEffectHandler == null && transitionEffectEventCallback != null)
 435                 {
 436                     using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
 437                     signal.Ensure()?.Disconnect(transitionEffectEventCallback);
 438                     transitionEffectEventCallback = null;
 439                 }
 440             }
 441         }
 442
 443         /// <summary>
 444         /// Emits the event when window is moved by user or the display server.<br />
 445         /// </summary>
 446         [EditorBrowsable(EditorBrowsableState.Never)]
 447         public event EventHandler<WindowMovedEventArgs> Moved
 448         {
 449             add
 450             {
 451                 if (movedHandler == null)
 452                 {
 453                     movedEventCallback = OnMoved;
 454                     using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(SwigCPtr), false);
 455                     signal.Ensure()?.Connect(movedEventCallback);
 456                 }
 457                 movedHandler += value;
 458             }
 459             remove
 460             {
 461                 movedHandler -= value;
 462                 if (movedHandler == null && movedEventCallback != null)
 463                 {
 464                     using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(SwigCPtr), false);
 465                     signal.Ensure()?.Disconnect(movedEventCallback);
 466                     movedEventCallback = null;
 467                 }
 468             }
 469         }
 470
 471         /// <summary>
 472         /// Window Orientation Changed event
 473         /// This event is for per windows
 474         /// </summary>
 475         [EditorBrowsable(EditorBrowsableState.Never)]
 476         public event EventHandler<WindowOrientationChangedEventArgs> OrientationChanged
 477         {
 478             add
 479             {
 480                 if (orientationChangedHandler == null)
 481                 {
 482                     orientationChangedEventCallback = OnOrientationChanged;
 483                     using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(SwigCPtr), false);
 484                     signal.Ensure()?.Connect(orientationChangedEventCallback);
 485                 }
 486                 orientationChangedHandler += value;
 487             }
 488             remove
 489             {
 490                 orientationChangedHandler -= value;
 491                 if (orientationChangedHandler == null && orientationChangedEventCallback != null)
 492                 {
 493                     using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(SwigCPtr), false);
 494                     signal.Ensure()?.Disconnect(orientationChangedEventCallback);
 495                     orientationChangedEventCallback = null;
 496                 }
 497             }
 498         }
 499
 500         /// <summary>
 501         /// Keyboard Repeat Settings Changed
 502         /// </summary>
 503         [EditorBrowsable(EditorBrowsableState.Never)]
 504         public event EventHandler KeyboardRepeatSettingsChanged
 505         {
 506             add
 507             {
 508                 if (keyboardRepeatSettingsChangedHandler == null)
 509                 {
 510                     keyboardRepeatSettingsChangedEventCallback = OnKeyboardRepeatSettingsChanged;
 511                     using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
 512                     signal.Ensure()?.Connect(keyboardRepeatSettingsChangedEventCallback);
 513                 }
 514                 keyboardRepeatSettingsChangedHandler += value;
 515             }
 516             remove
 517             {
 518                 keyboardRepeatSettingsChangedHandler -= value;
 519                 if (keyboardRepeatSettingsChangedHandler == null && keyboardRepeatSettingsChangedEventCallback != null)
 520                 {
 521                     using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
 522                     signal.Ensure()?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
 523                     keyboardRepeatSettingsChangedEventCallback = null;
 524                 }
 525             }
 526         }
 527
 528         /// <summary>
 529         /// MouseInOutEvent event.
 530         /// </summary>
 531         [EditorBrowsable(EditorBrowsableState.Never)]
 532         public event EventHandler<MouseInOutEventArgs> MouseInOutEvent
 533         {
 534             add
 535             {
 536                 if (windowMouseInOutEventHandler == null)
 537                 {
 538                     windowMouseInOutEventCallback = OnWindowMouseInOutEvent;
 539                     using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(SwigCPtr), false);
 540                     signal.Ensure()?.Connect(windowMouseInOutEventCallback);
 541                 }
 542                 windowMouseInOutEventHandler += value;
 543             }
 544             remove
 545             {
 546                 windowMouseInOutEventHandler -= value;
 547                 if (windowMouseInOutEventHandler == null && windowMouseInOutEventCallback != null)
 548                 {
 549                     using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(SwigCPtr), false);
 550                     signal.Ensure()?.Disconnect(windowMouseInOutEventCallback);
 551                     windowMouseInOutEventCallback = null;
 552                 }
 553             }
 554         }
 555
 556         /// <summary>
 557         /// Emits the event when window has been moved by the display server.<br />
 558         /// To make the window move by display server, RequestMoveToServer() should be called.<br />
 559         /// After the moving job is completed, this signal will be emitted.<br />
 560         /// </summary>
 561         [EditorBrowsable(EditorBrowsableState.Never)]
 562         public event EventHandler<WindowMoveCompletedEventArgs> MoveCompleted
 563         {
 564             add
 565             {
 566                 if (moveCompletedHandler == null)
 567                 {
 568                     moveCompletedEventCallback = OnMoveCompleted;
 569                     using WindowMoveCompletedSignal signal = new WindowMoveCompletedSignal(Interop.WindowMoveCompletedSignal.GetSignal(SwigCPtr), false);
 570                     signal.Ensure()?.Connect(moveCompletedEventCallback);
 571                 }
 572                 moveCompletedHandler += value;
 573             }
 574             remove
 575             {
 576                 moveCompletedHandler -= value;
 577                 if (moveCompletedHandler == null && moveCompletedEventCallback != null)
 578                 {
 579                     using WindowMoveCompletedSignal signal = new WindowMoveCompletedSignal(Interop.WindowMoveCompletedSignal.GetSignal(SwigCPtr), false);
 580                     signal.Ensure()?.Disconnect(moveCompletedEventCallback);
 581                     moveCompletedEventCallback = null;
 582                 }
 583             }
 584         }
 585
 586         /// <summary>
 587         /// Emits the event when window has been resized by the display server.<br />
 588         /// To make the window resize by display server, RequestResizeToServer() should be called.<br />
 589         /// After the resizing job is completed, this signal will be emitted.<br />
 590         /// </summary>
 591         [EditorBrowsable(EditorBrowsableState.Never)]
 592         public event EventHandler<WindowResizeCompletedEventArgs> ResizeCompleted
 593         {
 594             add
 595             {
 596                 if (resizeCompletedHandler == null)
 597                 {
 598                     resizeCompletedEventCallback = OnResizeCompleted;
 599                     using WindowResizeCompletedSignal signal = new WindowResizeCompletedSignal(Interop.WindowResizeCompletedSignal.GetSignal(SwigCPtr), false);
 600                     signal.Ensure()?.Connect(resizeCompletedEventCallback);
 601                 }
 602                 resizeCompletedHandler += value;
 603             }
 604             remove
 605             {
 606                 resizeCompletedHandler -= value;
 607                 if (resizeCompletedHandler == null && resizeCompletedEventCallback != null)
 608                 {
 609                     using WindowResizeCompletedSignal signal = new WindowResizeCompletedSignal(Interop.WindowResizeCompletedSignal.GetSignal(SwigCPtr), false);
 610                     signal.Ensure()?.Disconnect(resizeCompletedEventCallback);
 611                     resizeCompletedEventCallback = null;
 612                 }
 613             }
 614         }
 615
 616         /// <summary>
 617         /// Emits the event when relative mouse movement occurs in the window.<br />
 618         /// </summary>
 619         [EditorBrowsable(EditorBrowsableState.Never)]
 620         public event EventHandler<MouseRelativeEventArgs> MouseRelativeEvent
 621         {
 622             add
 623             {
 624                 if (windowMouseRelativeEventHandler == null)
 625                 {
 626                     windowMouseRelativeEventCallback = OnWindowMouseRelativeEvent;
 627                     using WindowMouseRelativeEventSignal signal = new WindowMouseRelativeEventSignal(Interop.WindowMouseRelativeEventSignal.GetSignal(SwigCPtr), false);
 628                     signal?.Connect(windowMouseRelativeEventCallback);
 629                 }
 630                 windowMouseRelativeEventHandler += value;
 631             }
 632             remove
 633             {
 634                 windowMouseRelativeEventHandler -= value;
 635                 if (windowMouseRelativeEventHandler == null && windowMouseRelativeEventCallback != null)
 636                 {
 637                     using WindowMouseRelativeEventSignal signal = new WindowMouseRelativeEventSignal(Interop.WindowMouseRelativeEventSignal.GetSignal(SwigCPtr), false);
 638                     signal?.Disconnect(windowMouseRelativeEventCallback);
 639                     windowMouseRelativeEventCallback = null;
 640                 }
 641             }
 642         }
 643
 644         /// <summary>
 645         /// Emits the event when pointer is locked/unlocked<br />
 646         /// </summary>
 647         [EditorBrowsable(EditorBrowsableState.Never)]
 648         public event EventHandler<PointerConstraintsEventArgs> PointerConstraintsEvent
 649         {
 650             add
 651             {
 652                 if (windowPointerConstraintsEventHandler == null)
 653                 {
 654                     windowPointerConstraintsEventCallback = OnWindowPointerConstraintsEvent;
 655                     using WindowPointerConstraintsSignal signal = new WindowPointerConstraintsSignal(Interop.WindowPointerConstraintsSignal.GetSignal(SwigCPtr), false);
 656                     signal?.Connect(windowPointerConstraintsEventCallback);
 657                 }
 658                 windowPointerConstraintsEventHandler += value;
 659             }
 660             remove
 661             {
 662                 windowPointerConstraintsEventHandler -= value;
 663                 if (windowPointerConstraintsEventHandler == null && windowPointerConstraintsEventCallback != null)
 664                 {
 665                     using WindowPointerConstraintsSignal signal = new WindowPointerConstraintsSignal(Interop.WindowPointerConstraintsSignal.GetSignal(SwigCPtr), false);
 666                     signal?.Disconnect(windowPointerConstraintsEventCallback);
 667                     windowPointerConstraintsEventCallback = null;
 668                 }
 669             }
 670         }
 671
 672         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler;
 673         private event EventHandler<TouchEventArgs> rootLayerTouchDataEventHandler;
 674         private ReturnTypeEventHandler<object, TouchEventArgs, bool> rootLayerInterceptTouchDataEventHandler;
 675         private event EventHandler<WheelEventArgs> stageWheelHandler;
 676         private ReturnTypeEventHandler<object, WheelEventArgs, bool> interceptWheelHandler;
 677         private event EventHandler<KeyEventArgs> stageKeyHandler;
 678         private ReturnTypeEventHandler<object, KeyEventArgs, bool> stageInterceptKeyHandler;
 679         private event EventHandler stageEventProcessingFinishedEventHandler;
 680         private event EventHandler<ResizedEventArgs> windowResizeEventHandler;
 681         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler2;
 682         private event EventHandler<TransitionEffectEventArgs> transitionEffectHandler;
 683         private event EventHandler<WindowMovedEventArgs> movedHandler;
 684         private event EventHandler<WindowOrientationChangedEventArgs> orientationChangedHandler;
 685         private event EventHandler keyboardRepeatSettingsChangedHandler;
 686         private event EventHandler<AuxiliaryMessageEventArgs> auxiliaryMessageEventHandler;
 687         private event EventHandler<MouseInOutEventArgs> windowMouseInOutEventHandler;
 688         private event EventHandler<MouseRelativeEventArgs> windowMouseRelativeEventHandler;
 689         private event EventHandler<WindowMoveCompletedEventArgs> moveCompletedHandler;
 690         private event EventHandler<WindowResizeCompletedEventArgs> resizeCompletedHandler;
 691         private event EventHandler<InsetsChangedEventArgs> insetsChangedEventHandler;
 692         private event EventHandler<PointerConstraintsEventArgs> windowPointerConstraintsEventHandler;
 693         private event EventHandler<HoverEventArgs> rootLayerHoverDataEventHandler;
 694
 695
 696         internal event EventHandler EventProcessingFinished
 697         {
 698             add
 699             {
 700                 if (stageEventProcessingFinishedEventHandler == null)
 701                 {
 702                     stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
 703                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 704                     signal.Ensure()?.Connect(stageEventProcessingFinishedEventCallbackDelegate);
 705                 }
 706                 stageEventProcessingFinishedEventHandler += value;
 707             }
 708             remove
 709             {
 710                 stageEventProcessingFinishedEventHandler -= value;
 711                 if (stageEventProcessingFinishedEventHandler == null && stageEventProcessingFinishedEventCallbackDelegate != null)
 712                 {
 713                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 714                     signal.Ensure()?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
 715                     stageEventProcessingFinishedEventCallbackDelegate = null;
 716                 }
 717             }
 718         }
 719
 720         internal event EventHandler ContextLost
 721         {
 722             add
 723             {
 724                 if (stageContextLostEventHandler == null)
 725                 {
 726                     stageContextLostEventCallbackDelegate = OnContextLost;
 727                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 728                     signal.Ensure()?.Connect(stageContextLostEventCallbackDelegate);
 729                 }
 730                 stageContextLostEventHandler += value;
 731             }
 732             remove
 733             {
 734                 stageContextLostEventHandler -= value;
 735                 if (stageContextLostEventHandler == null && stageContextLostEventCallbackDelegate != null)
 736                 {
 737                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 738                     signal.Ensure()?.Disconnect(stageContextLostEventCallbackDelegate);
 739                     stageContextLostEventCallbackDelegate = null;
 740                 }
 741             }
 742         }
 743
 744         internal event EventHandler ContextRegained
 745         {
 746             add
 747             {
 748                 if (stageContextRegainedEventHandler == null)
 749                 {
 750                     stageContextRegainedEventCallbackDelegate = OnContextRegained;
 751                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 752                     signal.Ensure()?.Connect(stageContextRegainedEventCallbackDelegate);
 753                 }
 754                 stageContextRegainedEventHandler += value;
 755             }
 756             remove
 757             {
 758                 stageContextRegainedEventHandler -= value;
 759                 if (stageContextRegainedEventHandler == null && stageContextRegainedEventCallbackDelegate != null)
 760                 {
 761                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 762                     signal.Ensure()?.Disconnect(stageContextRegainedEventCallbackDelegate);
 763                     stageContextRegainedEventCallbackDelegate = null;
 764                 }
 765             }
 766         }
 767
 768         internal event EventHandler SceneCreated
 769         {
 770             add
 771             {
 772                 if (stageSceneCreatedEventHandler == null)
 773                 {
 774                     stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
 775                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 776                     signal.Ensure()?.Connect(stageSceneCreatedEventCallbackDelegate);
 777                 }
 778                 stageSceneCreatedEventHandler += value;
 779             }
 780             remove
 781             {
 782                 stageSceneCreatedEventHandler -= value;
 783                 if (stageSceneCreatedEventHandler == null && stageSceneCreatedEventCallbackDelegate != null)
 784                 {
 785                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 786                     signal.Ensure()?.Disconnect(stageSceneCreatedEventCallbackDelegate);
 787                     stageSceneCreatedEventCallbackDelegate = null;
 788                 }
 789             }
 790         }
 791
 792         internal System.IntPtr GetNativeWindowHandler()
 793         {
 794             System.IntPtr ret = Interop.Window.GetNativeWindowHandler(HandleRef.ToIntPtr(this.SwigCPtr));
 795             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 796             return ret;
 797         }
 798
 799         /// <summary>
 800         /// Disconnect all native signals
 801         /// </summary>
 802         /// <since_tizen> 5 </since_tizen>
 803         internal void DisconnectNativeSignals()
 804         {
 805             if (HasBody() == false)
 806             {
 807                 NUILog.Debug($"[Dispose] DisConnectFromSignals() No native body! No need to Disconnect Signals!");
 808                 return;
 809             }
 810
 811             if (windowFocusChangedEventCallback != null)
 812             {
 813                 using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
 814                 signal?.Disconnect(windowFocusChangedEventCallback);
 815                 windowFocusChangedEventCallback = null;
 816             }
 817
 818             if (rootLayerTouchDataCallback != null)
 819             {
 820                 Interop.ActorSignal.TouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerTouchDataCallback.ToHandleRef(this));
 821                 NDalicPINVOKE.ThrowExceptionIfExists();
 822                 rootLayerTouchDataCallback = null;
 823             }
 824
 825             if (rootLayerInterceptTouchDataCallback != null)
 826             {
 827                 Interop.ActorSignal.InterceptTouchDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerInterceptTouchDataCallback.ToHandleRef(this));
 828                 NDalicPINVOKE.ThrowExceptionIfExists();
 829                 rootLayerInterceptTouchDataCallback = null;
 830             }
 831
 832             if (wheelEventCallback != null)
 833             {
 834                 Interop.ActorSignal.WheelEventDisconnect(Layer.getCPtr(GetRootLayer()), wheelEventCallback.ToHandleRef(this));
 835                 NDalicPINVOKE.ThrowExceptionIfExists();
 836                 wheelEventCallback = null;
 837             }
 838
 839             if (DetentEventCallback != null)
 840             {
 841                 using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 842                 signal?.Disconnect(DetentEventCallback);
 843                 DetentEventCallback = null;
 844             }
 845
 846             if (interceptWheelCallback != null)
 847             {
 848                 Interop.ActorSignal.InterceptWheelDisconnect(Layer.getCPtr(GetRootLayer()), interceptWheelCallback.ToHandleRef(this));
 849                 NDalicPINVOKE.ThrowExceptionIfExists();
 850                 interceptWheelCallback = null;
 851             }
 852
 853             if (stageKeyCallbackDelegate != null)
 854             {
 855                 using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(GetBaseHandleCPtrHandleRef), false);
 856                 signal?.Disconnect(stageKeyCallbackDelegate);
 857                 stageKeyCallbackDelegate = null;
 858             }
 859
 860             if (stageInterceptKeyCallbackDelegate != null)
 861             {
 862                 using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(GetBaseHandleCPtrHandleRef), false);
 863                 signal?.Disconnect(stageInterceptKeyCallbackDelegate);
 864                 stageInterceptKeyCallbackDelegate = null;
 865             }
 866
 867             if (stageEventProcessingFinishedEventCallbackDelegate != null)
 868             {
 869                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 870                 signal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
 871                 stageEventProcessingFinishedEventCallbackDelegate = null;
 872             }
 873
 874             if (stageContextLostEventCallbackDelegate != null)
 875             {
 876                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 877                 signal?.Disconnect(stageContextLostEventCallbackDelegate);
 878                 stageContextLostEventCallbackDelegate = null;
 879             }
 880
 881             if (stageContextRegainedEventCallbackDelegate != null)
 882             {
 883                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 884                 signal?.Disconnect(stageContextRegainedEventCallbackDelegate);
 885                 stageContextRegainedEventCallbackDelegate = null;
 886             }
 887
 888             if (stageSceneCreatedEventCallbackDelegate != null)
 889             {
 890                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 891                 signal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
 892                 stageSceneCreatedEventCallbackDelegate = null;
 893             }
 894
 895             if (windowResizeEventCallback != null)
 896             {
 897                 using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(GetBaseHandleCPtrHandleRef), false);
 898                 signal?.Disconnect(windowResizeEventCallback);
 899                 windowResizeEventCallback = null;
 900             }
 901
 902             if (windowFocusChangedEventCallback2 != null)
 903             {
 904                 using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
 905                 signal?.Disconnect(windowFocusChangedEventCallback2);
 906                 windowFocusChangedEventCallback2 = null;
 907             }
 908
 909             if (transitionEffectEventCallback != null)
 910             {
 911                 using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 912                 signal?.Disconnect(transitionEffectEventCallback);
 913                 transitionEffectEventCallback = null;
 914             }
 915
 916             if (movedEventCallback != null)
 917             {
 918                 using WindowMovedSignal signal = new WindowMovedSignal(Interop.WindowMovedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 919                 signal?.Disconnect(movedEventCallback);
 920                 movedEventCallback = null;
 921             }
 922
 923             if (orientationChangedEventCallback != null)
 924             {
 925                 using WindowOrientationChangedSignal signal = new WindowOrientationChangedSignal(Interop.WindowOrientationChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 926                 signal?.Disconnect(orientationChangedEventCallback);
 927                 orientationChangedEventCallback = null;
 928             }
 929
 930             if (keyboardRepeatSettingsChangedEventCallback != null)
 931             {
 932                 using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 933                 signal?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
 934                 keyboardRepeatSettingsChangedEventCallback = null;
 935             }
 936
 937             if (auxiliaryMessageEventCallback != null)
 938             {
 939                 using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(GetBaseHandleCPtrHandleRef), false);
 940                 signal?.Disconnect(auxiliaryMessageEventCallback);
 941                 auxiliaryMessageEventCallback = null;
 942             }
 943
 944             if (AccessibilityHighlightEventCallback != null)
 945             {
 946                 using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 947                 signal?.Disconnect(AccessibilityHighlightEventCallback);
 948                 AccessibilityHighlightEventCallback = null;
 949             }
 950
 951             if (windowMouseInOutEventCallback != null)
 952             {
 953                 using WindowMouseInOutEventSignal signal = new WindowMouseInOutEventSignal(Interop.WindowMouseInOutEventSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 954                 signal?.Disconnect(windowMouseInOutEventCallback);
 955                 windowMouseInOutEventCallback = null;
 956             }
 957
 958             if (windowMouseRelativeEventCallback != null)
 959             {
 960                 using WindowMouseRelativeEventSignal signal = new WindowMouseRelativeEventSignal(Interop.WindowMouseRelativeEventSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 961                 signal?.Disconnect(windowMouseRelativeEventCallback);
 962                 windowMouseRelativeEventCallback = null;
 963             }
 964
 965             if (moveCompletedEventCallback != null)
 966             {
 967                 using WindowMoveCompletedSignal signal = new WindowMoveCompletedSignal(Interop.WindowMoveCompletedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 968                 signal?.Disconnect(moveCompletedEventCallback);
 969                 moveCompletedEventCallback = null;
 970             }
 971
 972             if (resizeCompletedEventCallback != null)
 973             {
 974                 using WindowResizeCompletedSignal signal = new WindowResizeCompletedSignal(Interop.WindowResizeCompletedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 975                 signal?.Disconnect(resizeCompletedEventCallback);
 976                 resizeCompletedEventCallback = null;
 977             }
 978
 979             if (insetsChangedEventCallback != null)
 980             {
 981                 using WindowInsetsChangedSignal signal = new WindowInsetsChangedSignal(Interop.WindowInsetsChangedSignalType.Get(GetBaseHandleCPtrHandleRef), false);
 982                 signal?.Disconnect(insetsChangedEventCallback);
 983                 insetsChangedEventCallback = null;
 984             }
 985
 986             if (windowPointerConstraintsEventCallback != null)
 987             {
 988                 using WindowPointerConstraintsSignal signal = new WindowPointerConstraintsSignal(Interop.WindowPointerConstraintsSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 989                 signal?.Disconnect(windowPointerConstraintsEventCallback);
 990                 windowPointerConstraintsEventCallback = null;
 991             }
 992
 993             if (rootLayerHoverDataCallback != null)
 994             {
 995                 Interop.ActorSignal.HoveredDisconnect(Layer.getCPtr(GetRootLayer()), rootLayerHoverDataCallback.ToHandleRef(this));
 996                 NDalicPINVOKE.ThrowExceptionIfExists();
 997                 rootLayerHoverDataCallback = null;
 998             }
 999         }
1000
1001         private void OnWindowFocusedChanged(IntPtr window, bool focusGained)
1002         {
1003             if (window == IntPtr.Zero)
1004             {
1005                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
1006                 return;
1007             }
1008
1009             if (windowFocusChangedEventHandler != null)
1010             {
1011                 FocusChangedEventArgs e = new FocusChangedEventArgs();
1012                 e.FocusGained = focusGained;
1013                 windowFocusChangedEventHandler(this, e);
1014             }
1015         }
1016
1017         private bool OnWindowTouch(IntPtr view, IntPtr touchData)
1018         {
1019             if (touchData == global::System.IntPtr.Zero)
1020             {
1021                 NUILog.Error("touchData should not be null!");
1022                 return false;
1023             }
1024
1025             if (rootLayerTouchDataEventHandler != null)
1026             {
1027                 TouchEventArgs e = new TouchEventArgs();
1028                 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
1029                 rootLayerTouchDataEventHandler(this, e);
1030             }
1031             return false;
1032         }
1033
1034         private bool OnWindowInterceptTouch(IntPtr view, IntPtr touchData)
1035         {
1036             if (touchData == global::System.IntPtr.Zero)
1037             {
1038                 NUILog.Error("touchData should not be null!");
1039                 return true;
1040             }
1041
1042             bool consumed = false;
1043             if (rootLayerInterceptTouchDataEventHandler != null)
1044             {
1045                 TouchEventArgs e = new TouchEventArgs();
1046                 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
1047                 consumed = rootLayerInterceptTouchDataEventHandler(this, e);
1048             }
1049             return consumed;
1050         }
1051
1052         private bool OnStageWheel(IntPtr rootLayer, IntPtr wheelEvent)
1053         {
1054             if (wheelEvent == global::System.IntPtr.Zero)
1055             {
1056                 NUILog.Error("wheelEvent should not be null!");
1057                 return true;
1058             }
1059
1060             if (stageWheelHandler != null)
1061             {
1062                 WheelEventArgs e = new WheelEventArgs();
1063                 e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
1064                 stageWheelHandler(this, e);
1065             }
1066             return true;
1067         }
1068
1069         private bool OnWindowInterceptWheel(IntPtr view, IntPtr wheelEvent)
1070         {
1071             if (wheelEvent == global::System.IntPtr.Zero)
1072             {
1073                 NUILog.Error("wheelEvent should not be null!");
1074                 return true;
1075             }
1076
1077             bool consumed = false;
1078             if (interceptWheelHandler != null)
1079             {
1080                 WheelEventArgs e = new WheelEventArgs();
1081                 e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
1082                 consumed = interceptWheelHandler(this, e);
1083             }
1084             return consumed;
1085         }
1086
1087         // Callback for Stage KeyEventsignal
1088         private void OnStageKey(IntPtr data)
1089         {
1090             if (stageKeyHandler != null)
1091             {
1092                 KeyEventArgs e = new KeyEventArgs();
1093                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
1094                 //here we send all data to user event handlers
1095                 stageKeyHandler(this, e);
1096             }
1097         }
1098
1099         // Callback for Stage InterceptKeyEventsignal
1100         private bool OnStageInterceptKey(IntPtr data)
1101         {
1102             bool consumed = false;
1103             if (stageInterceptKeyHandler != null)
1104             {
1105                 KeyEventArgs e = new KeyEventArgs();
1106                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
1107                 //here we send all data to user event handlers
1108                 consumed = stageInterceptKeyHandler(this, e);
1109             }
1110             return consumed;
1111         }
1112
1113         // Callback for Stage EventProcessingFinishedSignal
1114         private void OnEventProcessingFinished()
1115         {
1116             stageEventProcessingFinishedEventHandler?.Invoke(this, null);
1117         }
1118
1119         // Callback for Stage ContextLostSignal
1120         private void OnContextLost()
1121         {
1122             stageContextLostEventHandler?.Invoke(this, null);
1123         }
1124
1125         // Callback for Stage ContextRegainedSignal
1126         private void OnContextRegained()
1127         {
1128             stageContextRegainedEventHandler?.Invoke(this, null);
1129         }
1130
1131         // Callback for Stage SceneCreatedSignal
1132         private void OnSceneCreated()
1133         {
1134             stageSceneCreatedEventHandler?.Invoke(this, null);
1135         }
1136
1137         private void OnResized(IntPtr window, IntPtr windowSize)
1138         {
1139             if (window == IntPtr.Zero)
1140             {
1141                 NUILog.Error("OnResized() Window is null! Do nothing!");
1142                 return;
1143             }
1144
1145             if (windowResizeEventHandler != null)
1146             {
1147                 ResizedEventArgs e = new ResizedEventArgs();
1148                 // var val = new Uint16Pair(windowSize, false);
1149                 // e.WindowSize = new Size2D(val.GetWidth(), val.GetHeight());
1150                 // val.Dispose();
1151
1152                 // Workaround : windowSize should be valid pointer from dali,
1153                 // but currently it is fixed and is not Uint16Pair class.
1154                 // will be fixed later.
1155                 e.WindowSize = this.WindowSize;
1156                 windowResizeEventHandler(this, e);
1157             }
1158         }
1159
1160         private void OnWindowFocusedChanged2(IntPtr window, bool focusGained)
1161         {
1162             if (window == IntPtr.Zero)
1163             {
1164                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
1165                 return;
1166             }
1167
1168             if (windowFocusChangedEventHandler2 != null)
1169             {
1170                 FocusChangedEventArgs e = new FocusChangedEventArgs();
1171                 e.FocusGained = focusGained;
1172                 windowFocusChangedEventHandler2(this, e);
1173             }
1174         }
1175
1176         private void OnTransitionEffect(IntPtr window, int state, int type)
1177         {
1178             if (window == global::System.IntPtr.Zero)
1179             {
1180                 return;
1181             }
1182
1183             if (transitionEffectHandler != null)
1184             {
1185                 TransitionEffectEventArgs e = new TransitionEffectEventArgs();
1186                 e.State = (EffectState)state;
1187                 e.Type = (EffectType)type;
1188                 transitionEffectHandler(this, e);
1189             }
1190             return;
1191         }
1192
1193         private void OnMoved(IntPtr window, IntPtr position)
1194         {
1195             if (window == global::System.IntPtr.Zero)
1196             {
1197                 return;
1198             }
1199
1200             if (movedHandler != null)
1201             {
1202                 WindowMovedEventArgs e = new WindowMovedEventArgs();
1203                 e.WindowPosition = this.WindowPosition;
1204                 movedHandler(this, e);
1205             }
1206             return;
1207         }
1208
1209         private void OnOrientationChanged(IntPtr window, int orientation)
1210         {
1211             if (window == global::System.IntPtr.Zero)
1212             {
1213                 return;
1214             }
1215
1216             if (orientationChangedHandler != null)
1217             {
1218                 WindowOrientationChangedEventArgs e = new WindowOrientationChangedEventArgs();
1219                 e.WindowOrientation = (WindowOrientation)orientation;
1220                 orientationChangedHandler(this, e);
1221             }
1222             return;
1223         }
1224
1225         private void OnKeyboardRepeatSettingsChanged()
1226         {
1227             keyboardRepeatSettingsChangedHandler?.Invoke(this, null);
1228             return;
1229         }
1230
1231         private void OnWindowMouseInOutEvent(IntPtr view, IntPtr mouseEvent)
1232         {
1233             if (mouseEvent == global::System.IntPtr.Zero)
1234             {
1235                 NUILog.Error("mouseEvent should not be null!");
1236                 return;
1237             }
1238
1239             if (windowMouseInOutEventHandler != null)
1240             {
1241                 MouseInOutEventArgs e = new MouseInOutEventArgs();
1242                 e.MouseInOut = Tizen.NUI.MouseInOut.GetMouseInOutFromPtr(mouseEvent);
1243                 windowMouseInOutEventHandler(this, e);
1244             }
1245         }
1246
1247         private void OnMoveCompleted(IntPtr window, IntPtr position)
1248         {
1249             if (window == global::System.IntPtr.Zero)
1250             {
1251                 return;
1252             }
1253
1254             if (moveCompletedHandler != null)
1255             {
1256                 WindowMoveCompletedEventArgs e = new WindowMoveCompletedEventArgs(this.WindowPosition);
1257                 moveCompletedHandler(this, e);
1258             }
1259             return;
1260         }
1261
1262         private void OnResizeCompleted(IntPtr window, IntPtr size)
1263         {
1264             if (window == global::System.IntPtr.Zero)
1265             {
1266                 return;
1267             }
1268
1269             if (resizeCompletedHandler != null)
1270             {
1271                 WindowResizeCompletedEventArgs e = new WindowResizeCompletedEventArgs(this.WindowSize);
1272                 resizeCompletedHandler(this, e);
1273             }
1274             return;
1275         }
1276
1277         private void OnWindowMouseRelativeEvent(IntPtr view, IntPtr mouseEvent)
1278         {
1279             if (mouseEvent == global::System.IntPtr.Zero)
1280             {
1281                 NUILog.Error("mouseEvent should not be null!");
1282                 return;
1283             }
1284
1285             if (windowMouseRelativeEventHandler != null)
1286             {
1287                 MouseRelativeEventArgs e = new MouseRelativeEventArgs();
1288                 e.MouseRelative = Tizen.NUI.MouseRelative.GetMouseRelativeFromPtr(mouseEvent);
1289                 windowMouseRelativeEventHandler(this, e);
1290             }
1291         }
1292
1293         private void OnWindowPointerConstraintsEvent(IntPtr view, IntPtr constraintsEvent)
1294         {
1295             if (constraintsEvent == global::System.IntPtr.Zero)
1296             {
1297                 NUILog.Error("constraintsEvent should not be null!");
1298                 return;
1299             }
1300
1301             if (windowPointerConstraintsEventHandler != null)
1302             {
1303                 PointerConstraintsEventArgs e = new PointerConstraintsEventArgs();
1304                 e.PointerConstraints = Tizen.NUI.PointerConstraints.GetPointerConstraintsFromPtr(constraintsEvent);
1305                 windowPointerConstraintsEventHandler(this, e);
1306             }
1307         }
1308
1309         private bool OnWindowHover(IntPtr view, IntPtr hoverData)
1310         {
1311             if (hoverData == global::System.IntPtr.Zero)
1312             {
1313                 NUILog.Error("hoverData should not be null!");
1314                 return false;
1315             }
1316
1317             if (rootLayerHoverDataEventHandler != null)
1318             {
1319                 HoverEventArgs e = new HoverEventArgs();
1320                 e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverData);
1321                 rootLayerHoverDataEventHandler(this, e);
1322             }
1323             return false;
1324         }
1325
1326         /// <summary>
1327         /// The focus changed event argument.
1328         /// </summary>
1329         /// <since_tizen> 3 </since_tizen>
1330         public class FocusChangedEventArgs : EventArgs
1331         {
1332             /// <summary>
1333             /// FocusGained flag.
1334             /// </summary>
1335             /// <since_tizen> 3 </since_tizen>
1336             public bool FocusGained
1337             {
1338                 get;
1339                 set;
1340             }
1341         }
1342
1343         /// <summary>
1344         /// The touch event argument.
1345         /// </summary>
1346         /// <since_tizen> 3 </since_tizen>
1347         public class TouchEventArgs : EventArgs
1348         {
1349             private Touch touch;
1350
1351             /// <summary>
1352             /// Touch.
1353             /// </summary>
1354             /// <since_tizen> 3 </since_tizen>
1355             public Touch Touch
1356             {
1357                 get
1358                 {
1359                     return touch;
1360                 }
1361                 set
1362                 {
1363                     touch = value;
1364                 }
1365             }
1366         }
1367
1368         /// <summary>
1369         /// Wheel event arguments.
1370         /// </summary>
1371         /// <since_tizen> 3 </since_tizen>
1372         public class WheelEventArgs : EventArgs
1373         {
1374             private Wheel wheel;
1375
1376             /// <summary>
1377             /// Wheel.
1378             /// </summary>
1379             /// <since_tizen> 3 </since_tizen>
1380             public Wheel Wheel
1381             {
1382                 get
1383                 {
1384                     return wheel;
1385                 }
1386                 set
1387                 {
1388                     wheel = value;
1389                 }
1390             }
1391         }
1392
1393         /// <summary>
1394         /// Key event arguments.
1395         /// </summary>
1396         /// <since_tizen> 3 </since_tizen>
1397         public class KeyEventArgs : EventArgs
1398         {
1399             private Key key;
1400
1401             /// <summary>
1402             /// Key.
1403             /// </summary>
1404             /// <since_tizen> 3 </since_tizen>
1405             public Key Key
1406             {
1407                 get
1408                 {
1409                     return key;
1410                 }
1411                 set
1412                 {
1413                     key = value;
1414                 }
1415             }
1416         }
1417
1418         /// <summary>
1419         /// Feeds a key event into the window.
1420         /// This resized event arguments.
1421         /// </summary>
1422         /// <since_tizen> 3 </since_tizen>
1423         public class ResizedEventArgs : EventArgs
1424         {
1425             Size2D windowSize;
1426
1427             /// <summary>
1428             /// This window size.
1429             /// </summary>
1430             /// <since_tizen> 4 </since_tizen>
1431             public Size2D WindowSize
1432             {
1433                 get
1434                 {
1435                     return windowSize;
1436                 }
1437                 set
1438                 {
1439                     windowSize = value;
1440                 }
1441             }
1442         }
1443
1444         /// <summary>
1445         /// MouseInOut evnet arguments.
1446         /// </summary>
1447         [EditorBrowsable(EditorBrowsableState.Never)]
1448         public class MouseInOutEventArgs : EventArgs
1449         {
1450             private MouseInOut mouseEvent;
1451
1452             /// <summary>
1453             /// MouseInOut event.
1454             /// </summary>
1455             [EditorBrowsable(EditorBrowsableState.Never)]
1456             public MouseInOut MouseInOut
1457             {
1458                 get
1459                 {
1460                     return mouseEvent;
1461                 }
1462                 set
1463                 {
1464                     mouseEvent = value;
1465                 }
1466             }
1467         }
1468
1469         /// <summary>
1470         /// MouseRelative evnet arguments.
1471         /// </summary>
1472         [EditorBrowsable(EditorBrowsableState.Never)]
1473         public class MouseRelativeEventArgs : EventArgs
1474         {
1475             private MouseRelative mouseEvent;
1476
1477             /// <summary>
1478             /// MouseRelative event.
1479             /// </summary>
1480             [EditorBrowsable(EditorBrowsableState.Never)]
1481             public MouseRelative MouseRelative
1482             {
1483                 get
1484                 {
1485                     return mouseEvent;
1486                 }
1487                 set
1488                 {
1489                     mouseEvent = value;
1490                 }
1491             }
1492         }
1493
1494
1495         /// <summary>
1496         /// PointerConstraints evnet arguments.
1497         /// </summary>
1498         [EditorBrowsable(EditorBrowsableState.Never)]
1499         public class PointerConstraintsEventArgs : EventArgs
1500         {
1501             private PointerConstraints constraintsEvent;
1502
1503             /// <summary>
1504             /// PointerConstraints event.
1505             /// </summary>
1506             [EditorBrowsable(EditorBrowsableState.Never)]
1507             public PointerConstraints PointerConstraints
1508             {
1509                 get
1510                 {
1511                     return constraintsEvent;
1512                 }
1513                 set
1514                 {
1515                     constraintsEvent = value;
1516                 }
1517             }
1518         }
1519
1520         /// <summary>
1521         /// Event arguments that passed via the hover signal.
1522         /// </summary>
1523         [EditorBrowsable(EditorBrowsableState.Never)]
1524         public class HoverEventArgs : EventArgs
1525         {
1526             private Hover hover;
1527
1528             /// <summary>
1529             /// Hover - contains touch points that represent the points that are currently being hovered or the points where a hover has stopped.
1530             /// </summary>
1531             [EditorBrowsable(EditorBrowsableState.Never)]
1532             public Hover Hover
1533             {
1534                 get
1535                 {
1536                     return hover;
1537                 }
1538                 set
1539                 {
1540                     hover = value;
1541                 }
1542             }
1543         }
1544
1545         /// <summary>
1546         /// Do not use this, that will be deprecated.
1547         /// </summary>
1548         /// <since_tizen> 3 </since_tizen>
1549         [Obsolete("Do not use this, that will be deprecated. Use FocusChangedEventArgs instead. " +
1550             "Like: " +
1551             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
1552             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
1553         [EditorBrowsable(EditorBrowsableState.Never)]
1554         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
1555         public class WindowFocusChangedEventArgs : EventArgs
1556         {
1557             /// <summary>
1558             /// Do not use this, that will be deprecated.
1559             /// </summary>
1560             /// <since_tizen> 3 </since_tizen>
1561             public bool FocusGained
1562             {
1563                 get;
1564                 set;
1565             }
1566         }
1567
1568         /// <summary>
1569         /// Contains and encapsulates Native Window handle.
1570         /// </summary>
1571         /// <since_tizen> 4 </since_tizen>
1572         [Obsolete("This has been deprecated in API9 and will be removed in API11. Use Window.NativeHandle instead.")]
1573         public class SafeNativeWindowHandle : SafeHandle
1574         {
1575             /// <summary>
1576             ///Constructor, Native window handle is set to handle.
1577             /// </summary>
1578             /// <since_tizen> 4 </since_tizen>
1579             public SafeNativeWindowHandle() : base(IntPtr.Zero, false)
1580             {
1581                 SetHandle(NUIApplication.GetDefaultWindow().GetNativeWindowHandler());
1582             }
1583             /// <summary>
1584             /// Null check if the handle is valid or not.
1585             /// </summary>
1586             /// <since_tizen> 4 </since_tizen>
1587             public override bool IsInvalid
1588             {
1589                 get
1590                 {
1591                     return this.handle == IntPtr.Zero;
1592                 }
1593             }
1594             /// <summary>
1595             /// Release handle itself.
1596             /// </summary>
1597             /// <returns>true when released successfully.</returns>
1598             /// <since_tizen> 4 </since_tizen>
1599             protected override bool ReleaseHandle()
1600             {
1601                 return true;
1602             }
1603         }
1604
1605         /// <summary>
1606         /// TransitionEffectArgs
1607         /// </summary>
1608         [EditorBrowsable(EditorBrowsableState.Never)]
1609         public class TransitionEffectEventArgs : EventArgs
1610         {
1611             private EffectState state;
1612             private EffectType type;
1613
1614             /// <summary>
1615             /// State
1616             /// </summary>
1617             [EditorBrowsable(EditorBrowsableState.Never)]
1618             public EffectState State
1619             {
1620                 get
1621                 {
1622                     return state;
1623                 }
1624                 set
1625                 {
1626                     state = value;
1627                 }
1628             }
1629             /// <summary>
1630             /// Type
1631             /// </summary>
1632             [EditorBrowsable(EditorBrowsableState.Never)]
1633             public EffectType Type
1634             {
1635                 get
1636                 {
1637                     return type;
1638                 }
1639                 set
1640                 {
1641                     type = value;
1642                 }
1643             }
1644         }
1645
1646         private EventHandler<WheelEventArgs> DetentEventHandler;
1647
1648         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
1649         private delegate void DetentEventCallbackType(IntPtr arg1);
1650
1651         private DetentEventCallbackType DetentEventCallback;
1652
1653         private void OnDetentEvent(IntPtr wheelEvent)
1654         {
1655             WheelEventArgs e = new WheelEventArgs();
1656
1657             if (wheelEvent != global::System.IntPtr.Zero)
1658             {
1659                 e.Wheel = Wheel.GetWheelFromPtr(wheelEvent);
1660             }
1661
1662             DetentEventHandler?.Invoke(this, e);
1663         }
1664
1665         /// <summary>
1666         /// VisibilityChangedArgs
1667         /// </summary>
1668         [EditorBrowsable(EditorBrowsableState.Never)]
1669         public class VisibilityChangedEventArgs : EventArgs
1670         {
1671             private bool visibility;
1672             /// <summary>
1673             /// Visibility
1674             /// </summary>
1675             [EditorBrowsable(EditorBrowsableState.Never)]
1676             public bool Visibility
1677             {
1678                 get => visibility;
1679                 set
1680                 {
1681                     visibility = value;
1682                 }
1683             }
1684         }
1685
1686         private void OnVisibilityChanged(IntPtr window, bool visibility)
1687         {
1688             if (window == global::System.IntPtr.Zero)
1689             {
1690                 NUILog.Error("[ERR] OnVisibilityChanged() window is null");
1691                 return;
1692             }
1693
1694             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
1695             e.Visibility = visibility;
1696             if (VisibilityChangedEventHandler != null)
1697             {
1698                 VisibilityChangedEventHandler.Invoke(this, e);
1699             }
1700         }
1701
1702         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
1703         private delegate void VisibilityChangedEventCallbackType(IntPtr window, bool visibility);
1704         private VisibilityChangedEventCallbackType VisibilityChangedEventCallback;
1705         private event EventHandler<VisibilityChangedEventArgs> VisibilityChangedEventHandler;
1706         private WindowVisibilityChangedEvent VisibilityChangedEventSignal;
1707
1708         /// <summary>
1709         /// EffectStart
1710         /// </summary>
1711         [EditorBrowsable(EditorBrowsableState.Never)]
1712         public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
1713         {
1714             add
1715             {
1716                 if (VisibilityChangedEventHandler == null)
1717                 {
1718                     VisibilityChangedEventCallback = OnVisibilityChanged;
1719                     using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
1720                     signal.Ensure()?.Connect(VisibilityChangedEventCallback);
1721                 }
1722                 VisibilityChangedEventHandler += value;
1723             }
1724             remove
1725             {
1726                 VisibilityChangedEventHandler -= value;
1727                 if (VisibilityChangedEventHandler == null && VisibilityChangedEventCallback != null)
1728                 {
1729                     using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
1730                     signal.Ensure()?.Disconnect(VisibilityChangedEventCallback);
1731                     VisibilityChangedEventCallback = null;
1732                 }
1733             }
1734         }
1735
1736         /// <summary>
1737         /// VisibiltyChangedSignalEmit
1738         /// </summary>
1739         [EditorBrowsable(EditorBrowsableState.Never)]
1740         public void VisibiltyChangedSignalEmit(bool visibility)
1741         {
1742             if (VisibilityChangedEventSignal == null)
1743             {
1744                 VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this);
1745             }
1746             VisibilityChangedEventSignal.Emit(this, visibility);
1747         }
1748
1749         private void OnAuxiliaryMessage(IntPtr kData, IntPtr vData, IntPtr optionsArray)
1750         {
1751             if (kData == IntPtr.Zero || vData == IntPtr.Zero)
1752             {
1753                 return;
1754             }
1755
1756             using var tmp = new PropertyArray(optionsArray, false);
1757             var size = tmp.Size();
1758
1759             List<string> tmpList = new List<string>();
1760
1761             for (int i = 0; i < size; i++)
1762             {
1763                 string option = "none";
1764                 tmp.GetElementAt((uint)i).Get(out option);
1765                 tmpList.Add(option);
1766             }
1767
1768             tmp.Dispose();
1769
1770             AuxiliaryMessageEventArgs e = new AuxiliaryMessageEventArgs();
1771             e.Key = StringToVoidSignal.GetResult(kData);
1772             e.Value = StringToVoidSignal.GetResult(vData); ;
1773             e.Options = tmpList;
1774
1775             auxiliaryMessageEventHandler?.Invoke(this, e);
1776         }
1777
1778         /// <summary>
1779         /// Auxiliary message is sent by displayer server when window's auxiliary was changed then display server sent the message.
1780         /// When client application added the window's auxiliary hint and if the auxiliary is changed,
1781         /// display server send the auxiliary message.
1782         /// Auxiliary message has the key, value and options.
1783         /// </summary>
1784         [EditorBrowsable(EditorBrowsableState.Never)]
1785         public event EventHandler<AuxiliaryMessageEventArgs> AuxiliaryMessage
1786         {
1787             add
1788             {
1789                 if (auxiliaryMessageEventHandler == null)
1790                 {
1791                     auxiliaryMessageEventCallback = OnAuxiliaryMessage;
1792                     using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
1793                     signal.Ensure()?.Connect(auxiliaryMessageEventCallback);
1794                 }
1795                 auxiliaryMessageEventHandler += value;
1796             }
1797             remove
1798             {
1799                 auxiliaryMessageEventHandler -= value;
1800                 if (auxiliaryMessageEventHandler == null && auxiliaryMessageEventCallback != null)
1801                 {
1802                     using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
1803                     signal.Ensure()?.Disconnect(auxiliaryMessageEventCallback);
1804                     auxiliaryMessageEventCallback = null;
1805                 }
1806             }
1807         }
1808
1809         /// <summary>
1810         /// The type of insets part.
1811         /// </summary>
1812         [EditorBrowsable(EditorBrowsableState.Never)]
1813         public enum InsetsPartType
1814         {
1815             StatusBar = 0,
1816             Keyboard = 1,
1817             Clipboard = 2
1818         }
1819
1820         /// <summary>
1821         /// The state of insets part.
1822         /// </summary>
1823         [EditorBrowsable(EditorBrowsableState.Never)]
1824         public enum InsetsPartState
1825         {
1826             Invisible = 0,
1827             Visible = 1
1828         }
1829
1830         /// <summary>
1831         /// InsetsChangedEventArgs
1832         /// </summary>
1833         [EditorBrowsable(EditorBrowsableState.Never)]
1834         public class InsetsChangedEventArgs : EventArgs
1835         {
1836             private InsetsPartType partType;
1837             private InsetsPartState partState;
1838             private Extents insets;
1839
1840             /// <summary>
1841             /// The type of insets part.
1842             /// e.g. StatusBar, Keyboard, or Clipboard
1843             /// </summary>
1844             [EditorBrowsable(EditorBrowsableState.Never)]
1845             public InsetsPartType PartType
1846             {
1847                 get => partType;
1848                 internal set
1849                 {
1850                     partType = value;
1851                 }
1852             }
1853
1854             /// <summary>
1855             /// The state of insets part.
1856             /// e.g. Invisible or Visible
1857             /// </summary>
1858             [EditorBrowsable(EditorBrowsableState.Never)]
1859             public InsetsPartState PartState
1860             {
1861                 get => partState;
1862                 internal set
1863                 {
1864                     partState = value;
1865                 }
1866             }
1867
1868             /// <summary>
1869             /// The extents value of window insets
1870             /// </summary>
1871             [EditorBrowsable(EditorBrowsableState.Never)]
1872             public Extents Insets
1873             {
1874                 get => insets;
1875                 internal set
1876                 {
1877                     insets = value;
1878                 }
1879             }
1880         }
1881
1882         private void OnInsetsChanged(int partType, int partState, IntPtr extents)
1883         {
1884             if (insetsChangedEventHandler != null)
1885             {
1886                 InsetsChangedEventArgs e = new InsetsChangedEventArgs();
1887                 e.PartType = (InsetsPartType)partType;
1888                 e.PartState = (InsetsPartState)partState;
1889                 e.Insets = new Extents(extents, false);
1890
1891                 insetsChangedEventHandler.Invoke(this, e);
1892             }
1893         }
1894
1895         /// <summary>
1896         /// Emits the event when the window insets changes by status bar, virtual keyboard, or clipboard appears and disappears.
1897         /// </summary>
1898         [EditorBrowsable(EditorBrowsableState.Never)]
1899         public event EventHandler<InsetsChangedEventArgs> InsetsChanged
1900         {
1901             add
1902             {
1903                 if (insetsChangedEventHandler == null)
1904                 {
1905                     insetsChangedEventCallback = OnInsetsChanged;
1906                     using WindowInsetsChangedSignal signal = new WindowInsetsChangedSignal(Interop.WindowInsetsChangedSignalType.Get(SwigCPtr), false);
1907                     signal.Ensure()?.Connect(insetsChangedEventCallback);
1908                 }
1909                 insetsChangedEventHandler += value;
1910             }
1911             remove
1912             {
1913                 insetsChangedEventHandler -= value;
1914                 if (insetsChangedEventHandler == null && insetsChangedEventCallback != null)
1915                 {
1916                     using WindowInsetsChangedSignal signal = new WindowInsetsChangedSignal(Interop.WindowInsetsChangedSignalType.Get(SwigCPtr), false);
1917                     signal.Ensure()?.Disconnect(insetsChangedEventCallback);
1918                     insetsChangedEventCallback = null;
1919                 }
1920             }
1921         }
1922
1923         /// <summary>
1924         /// AccessibilityHighlightArgs
1925         /// </summary>
1926         [EditorBrowsable(EditorBrowsableState.Never)]
1927         public class AccessibilityHighlightEventArgs : EventArgs
1928         {
1929             private bool accessibilityHighlight;
1930             /// <summary>
1931             /// accessibilityHighlight
1932             /// </summary>
1933             [EditorBrowsable(EditorBrowsableState.Never)]
1934             public bool AccessibilityHighlight
1935             {
1936                 get => accessibilityHighlight;
1937                 set
1938                 {
1939                     accessibilityHighlight = value;
1940                 }
1941             }
1942         }
1943
1944         private void OnAccessibilityHighlight(IntPtr window, bool highlight)
1945         {
1946             if (window == global::System.IntPtr.Zero)
1947             {
1948                 NUILog.Error("[ERR] OnAccessibilityHighlight() window is null");
1949                 return;
1950             }
1951
1952             AccessibilityHighlightEventArgs e = new AccessibilityHighlightEventArgs();
1953             e.AccessibilityHighlight = highlight;
1954             if (AccessibilityHighlightEventHandler != null)
1955             {
1956                 AccessibilityHighlightEventHandler.Invoke(this, e);
1957             }
1958         }
1959
1960         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
1961         private delegate void AccessibilityHighlightEventCallbackType(IntPtr window, bool highlight);
1962         private AccessibilityHighlightEventCallbackType AccessibilityHighlightEventCallback;
1963         private event EventHandler<AccessibilityHighlightEventArgs> AccessibilityHighlightEventHandler;
1964
1965         /// <summary>
1966         /// Emits the event when the window needs to grab or clear highlight.
1967         /// </summary>
1968         [EditorBrowsable(EditorBrowsableState.Never)]
1969         public event EventHandler<AccessibilityHighlightEventArgs> AccessibilityHighlight
1970         {
1971             add
1972             {
1973                 if (AccessibilityHighlightEventHandler == null)
1974                 {
1975                     AccessibilityHighlightEventCallback = OnAccessibilityHighlight;
1976                     using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(SwigCPtr), false);
1977                     signal.Ensure()?.Connect(AccessibilityHighlightEventCallback);
1978                 }
1979                 AccessibilityHighlightEventHandler += value;
1980             }
1981             remove
1982             {
1983                 AccessibilityHighlightEventHandler -= value;
1984                 if (AccessibilityHighlightEventHandler == null && AccessibilityHighlightEventCallback != null)
1985                 {
1986                     using WindowAccessibilityHighlightEvent signal = new WindowAccessibilityHighlightEvent(Interop.WindowAccessibilityHighlightSignal.GetSignal(SwigCPtr), false);
1987                     signal.Ensure()?.Disconnect(AccessibilityHighlightEventCallback);
1988                     AccessibilityHighlightEventCallback = null;
1989                 }
1990             }
1991         }
1992     }
1993
1994     /// <summary>
1995     /// Move event is sent when window is resized by user or the display server.
1996     /// </summary>
1997     [EditorBrowsable(EditorBrowsableState.Never)]
1998     public class WindowMovedEventArgs : EventArgs
1999     {
2000         private Position2D position;
2001
2002         [EditorBrowsable(EditorBrowsableState.Never)]
2003         public Position2D WindowPosition
2004         {
2005             get
2006             {
2007                 return position;
2008             }
2009             set
2010             {
2011                 position = value;
2012             }
2013         }
2014     }
2015
2016     /// <summary>
2017     /// OrientationChangedArgs
2018     /// </summary>
2019     [EditorBrowsable(EditorBrowsableState.Never)]
2020     public class WindowOrientationChangedEventArgs : EventArgs
2021     {
2022         private Window.WindowOrientation orientation;
2023
2024         [EditorBrowsable(EditorBrowsableState.Never)]
2025         public Window.WindowOrientation WindowOrientation
2026         {
2027             get
2028             {
2029                 return orientation;
2030             }
2031             set
2032             {
2033                 orientation = value;
2034             }
2035         }
2036     }
2037
2038     /// <summary>
2039     /// Move Completed event is sent when window has been moved the display server.
2040     /// It is triggered by calling RequestMoveToServer().
2041     /// </summary>
2042     [EditorBrowsable(EditorBrowsableState.Never)]
2043     public class WindowMoveCompletedEventArgs : EventArgs
2044     {
2045         public WindowMoveCompletedEventArgs(Position2D completedPosition)
2046         {
2047             WindowCompletedPosition = completedPosition;
2048         }
2049
2050         public Position2D WindowCompletedPosition
2051         {
2052             get;
2053             private set;
2054         }
2055     }
2056
2057     /// <summary>
2058     /// Resize Completed event is sent when window has been resized the display server.
2059     /// It is triggered by calling RequestResizeToServer().
2060     /// </summary>
2061     [EditorBrowsable(EditorBrowsableState.Never)]
2062     public class WindowResizeCompletedEventArgs : EventArgs
2063     {
2064         public WindowResizeCompletedEventArgs(Size2D completedSize)
2065         {
2066             WindowCompletedSize = completedSize;
2067         }
2068
2069         public Size2D WindowCompletedSize
2070         {
2071             get;
2072             private set;
2073         }
2074     }
2075
2076 }