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