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

   1 /*
   2  * Copyright(c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 using System;
  19 using System.ComponentModel;
  20 using System.Runtime.InteropServices;
  21 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 WheelEventCallbackType wheelEventCallback;
  36         private EventCallbackDelegateType1 stageKeyCallbackDelegate;
  37         private InterceptKeyEventDelegateType stageInterceptKeyCallbackDelegate;
  38         private EventCallbackDelegateType0 stageEventProcessingFinishedEventCallbackDelegate;
  39         private EventHandler stageContextLostEventHandler;
  40         private EventCallbackDelegateType0 stageContextLostEventCallbackDelegate;
  41         private EventHandler stageContextRegainedEventHandler;
  42         private EventCallbackDelegateType0 stageContextRegainedEventCallbackDelegate;
  43         private EventHandler stageSceneCreatedEventHandler;
  44         private EventCallbackDelegateType0 stageSceneCreatedEventCallbackDelegate;
  45         private WindowResizeEventCallbackType windowResizeEventCallback;
  46         private WindowFocusChangedEventCallbackType windowFocusChangedEventCallback2;
  47         private TransitionEffectEventCallbackType transitionEffectEventCallback;
  48         private WindowTransitionEffectSignal transitionEffectSignal;
  49         private KeyboardRepeatSettingsChangedEventCallbackType keyboardRepeatSettingsChangedEventCallback;
  50         private KeyboardRepeatSettingsChangedSignal keyboardRepeatSettingsChangedSignal;
  51         private KeyEventSignal interceptKeyEventSignal;
  52         private AuxiliaryMessageEventCallbackType auxiliaryMessageEventCallback;
  53
  54         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
  55         private delegate void WindowFocusChangedEventCallbackType(IntPtr window, bool focusGained);
  56         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  57         private delegate bool RootLayerTouchDataCallbackType(IntPtr view, IntPtr touchData);
  58         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  59         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
  60         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  61         private delegate void WindowResizeEventCallbackType(IntPtr window, IntPtr windowSize);
  62         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  63         private delegate void WindowFocusChangedEventCallbackType2(IntPtr window, bool focusGained);
  64         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  65         private delegate void TransitionEffectEventCallbackType(IntPtr window, int state, int type);
  66         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  67         private delegate void KeyboardRepeatSettingsChangedEventCallbackType();
  68         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  69         private delegate void AuxiliaryMessageEventCallbackType(IntPtr kData, IntPtr vData, IntPtr optionsArray);
  70         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  71         private delegate bool InterceptKeyEventDelegateType(IntPtr arg1);
  72
  73         /// <summary>
  74         /// FocusChanged event.
  75         /// </summary>
  76         /// <since_tizen> 3 </since_tizen>
  77         public event EventHandler<FocusChangedEventArgs> FocusChanged
  78         {
  79             add
  80             {
  81                 if (windowFocusChangedEventHandler == null)
  82                 {
  83                     windowFocusChangedEventCallback = OnWindowFocusedChanged;
  84                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
  85                     signal?.Connect(windowFocusChangedEventCallback);
  86                 }
  87                 windowFocusChangedEventHandler += value;
  88             }
  89             remove
  90             {
  91                 windowFocusChangedEventHandler -= value;
  92                 if (windowFocusChangedEventHandler == null && windowFocusChangedEventCallback != null)
  93                 {
  94                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
  95                     signal?.Disconnect(windowFocusChangedEventCallback);
  96                     if (signal?.Empty() == true)
  97                     {
  98                         windowFocusChangedEventCallback = null;
  99                     }
 100                 }
 101             }
 102         }
 103
 104         /// <summary>
 105         /// Emits the event when the screen is touched and when the touch ends.<br />
 106         /// If there are multiple touch points then it is emitted when the first touch occurs and
 107         /// when the last finger is lifted too.<br />
 108         /// Even though incoming events are interrupted, the event occurs.<br />
 109         /// </summary>
 110         /// <since_tizen> 3 </since_tizen>
 111         public event EventHandler<TouchEventArgs> TouchEvent
 112         {
 113             add
 114             {
 115                 if (rootLayerTouchDataEventHandler == null)
 116                 {
 117                     rootLayerTouchDataCallback = OnWindowTouch;
 118                     using TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.ActorTouchSignal(Layer.getCPtr(GetRootLayer())), false);
 119                     signal?.Connect(rootLayerTouchDataCallback);
 120                 }
 121                 rootLayerTouchDataEventHandler += value;
 122             }
 123             remove
 124             {
 125                 rootLayerTouchDataEventHandler -= value;
 126                 if (rootLayerTouchDataEventHandler == null && rootLayerTouchDataCallback != null)
 127                 {
 128                     using TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.ActorTouchSignal(Layer.getCPtr(GetRootLayer())), false);
 129                     signal?.Disconnect(rootLayerTouchDataCallback);
 130                     if (signal?.Empty() == true)
 131                     {
 132                         rootLayerTouchDataCallback = null;
 133                     }
 134                 }
 135             }
 136         }
 137
 138         /// <summary>
 139         /// Emits the event when the wheel event is received.
 140         /// </summary>
 141         /// <since_tizen> 3 </since_tizen>
 142         public event EventHandler<WheelEventArgs> WheelEvent
 143         {
 144             add
 145             {
 146                 if (stageWheelHandler == null)
 147                 {
 148                     wheelEventCallback = OnStageWheel;
 149                     using WheelSignal signal = new WheelSignal(Interop.ActorSignal.ActorWheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
 150                     signal?.Connect(wheelEventCallback);
 151                 }
 152                 stageWheelHandler += value;
 153
 154                 if (DetentEventHandler == null)
 155                 {
 156                     DetentEventCallback = OnDetentEvent;
 157                     using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 158                     signal?.Connect(DetentEventCallback);
 159                 }
 160                 DetentEventHandler += value;
 161             }
 162             remove
 163             {
 164                 stageWheelHandler -= value;
 165                 if (stageWheelHandler == null && wheelEventCallback != null)
 166                 {
 167                     using WheelSignal signal = new WheelSignal(Interop.ActorSignal.ActorWheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
 168                     signal?.Disconnect(wheelEventCallback);
 169                     if (signal?.Empty() == true)
 170                     {
 171                         wheelEventCallback = null;
 172                     }
 173                 }
 174
 175                 DetentEventHandler -= value;
 176                 if (DetentEventHandler == null && DetentEventCallback != null)
 177                 {
 178                     using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 179                     signal?.Disconnect(DetentEventCallback);
 180                     if (signal?.Empty() == true)
 181                     {
 182                         DetentEventCallback = null;
 183                     }
 184                 }
 185             }
 186         }
 187
 188         /// <summary>
 189         /// Emits the event when the key event is received.
 190         /// </summary>
 191         /// <since_tizen> 3 </since_tizen>
 192         public event EventHandler<KeyEventArgs> KeyEvent
 193         {
 194             add
 195             {
 196                 if (stageKeyHandler == null)
 197                 {
 198                     stageKeyCallbackDelegate = OnStageKey;
 199                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
 200                     signal?.Connect(stageKeyCallbackDelegate);
 201                 }
 202                 stageKeyHandler += value;
 203             }
 204             remove
 205             {
 206                 stageKeyHandler -= value;
 207                 if (stageKeyHandler == null && stageKeyCallbackDelegate != null)
 208                 {
 209                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(SwigCPtr), false);
 210                     signal?.Disconnect(stageKeyCallbackDelegate);
 211                     if (signal?.Empty() == true)
 212                     {
 213                         stageKeyCallbackDelegate = null;
 214                     }
 215                 }
 216             }
 217         }
 218
 219         /// <summary>
 220         /// Intercepts KeyEvents in the window before dispatching KeyEvents to the child.<br />
 221         /// If it returns true(consumed), no KeyEvent is delivered to the child.
 222         /// </summary>
 223         [EditorBrowsable(EditorBrowsableState.Never)]
 224         public event ReturnTypeEventHandler<object, KeyEventArgs, bool> InterceptKeyEvent
 225         {
 226             add
 227             {
 228                 if (stageInterceptKeyHandler == null)
 229                 {
 230                     stageInterceptKeyCallbackDelegate = OnStageInterceptKey;
 231                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
 232                     signal?.Connect(stageInterceptKeyCallbackDelegate);
 233                 }
 234                 stageInterceptKeyHandler += value;
 235             }
 236             remove
 237             {
 238                 stageInterceptKeyHandler -= value;
 239                 if (stageInterceptKeyHandler == null && stageInterceptKeyCallbackDelegate != null)
 240                 {
 241                     using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(SwigCPtr), false);
 242                     signal?.Disconnect(stageInterceptKeyCallbackDelegate);
 243                     if (signal?.Empty() == true)
 244                     {
 245                         stageInterceptKeyCallbackDelegate = null;
 246                     }
 247                 }
 248             }
 249         }
 250
 251         /// <summary>
 252         /// Emits the event when the window resized.
 253         /// </summary>
 254         /// <since_tizen> 3 </since_tizen>
 255         public event EventHandler<ResizedEventArgs> Resized
 256         {
 257             add
 258             {
 259                 if (windowResizeEventHandler == null)
 260                 {
 261                     windowResizeEventCallback = OnResized;
 262                     using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
 263                     signal?.Connect(windowResizeEventCallback);
 264                 }
 265
 266                 windowResizeEventHandler += value;
 267             }
 268             remove
 269             {
 270                 windowResizeEventHandler -= value;
 271                 if (windowResizeEventHandler == null && windowResizeEventCallback != null)
 272                 {
 273                     using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(SwigCPtr), false);
 274                     signal?.Disconnect(windowResizeEventCallback);
 275                     if (signal?.Empty() == true)
 276                     {
 277                         windowResizeEventCallback = null;
 278                     }
 279                 }
 280             }
 281         }
 282
 283         /// <summary>
 284         /// Do not use this, that will be deprecated. Use 'FocusChanged' event instead.
 285         /// </summary>
 286         /// <since_tizen> 3 </since_tizen>
 287         /// Do not use this, that will be deprecated.
 288         /// Instead Use FocusChanged.
 289         [Obsolete("Do not use this, that will be deprecated. Use FocusChanged instead. " +
 290             "Like: " +
 291             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
 292             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
 293         [EditorBrowsable(EditorBrowsableState.Never)]
 294         public event EventHandler<FocusChangedEventArgs> WindowFocusChanged
 295         {
 296             add
 297             {
 298                 if (windowFocusChangedEventHandler2 == null)
 299                 {
 300                     windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
 301                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 302                     signal?.Connect(windowFocusChangedEventCallback2);
 303                 }
 304                 windowFocusChangedEventHandler2 += value;
 305             }
 306             remove
 307             {
 308                 windowFocusChangedEventHandler2 -= value;
 309                 if (windowFocusChangedEventHandler2 == null && windowFocusChangedEventCallback2 != null)
 310                 {
 311                     using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(SwigCPtr), false);
 312                     signal?.Disconnect(windowFocusChangedEventCallback2);
 313                     if (signal?.Empty() == true)
 314                     {
 315                         windowFocusChangedEventCallback2 = null;
 316                     }
 317                 }
 318             }
 319         }
 320
 321         /// <summary>
 322         /// EffectStart
 323         /// </summary>
 324         [EditorBrowsable(EditorBrowsableState.Never)]
 325         public event EventHandler<TransitionEffectEventArgs> TransitionEffect
 326         {
 327             add
 328             {
 329                 if (transitionEffectHandler == null)
 330                 {
 331                     transitionEffectEventCallback = OnTransitionEffect;
 332                     using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
 333                     signal?.Connect(transitionEffectEventCallback);
 334                 }
 335                 transitionEffectHandler += value;
 336             }
 337             remove
 338             {
 339                 transitionEffectHandler -= value;
 340                 if (transitionEffectHandler == null && transitionEffectEventCallback != null)
 341                 {
 342                     using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(SwigCPtr), false);
 343                     signal?.Disconnect(transitionEffectEventCallback);
 344                     if (signal?.Empty() == true)
 345                     {
 346                         transitionEffectEventCallback = null;
 347                     }
 348                 }
 349             }
 350         }
 351
 352         /// <summary>
 353         /// Keyboard Repeat Settings Changed
 354         /// </summary>
 355         [EditorBrowsable(EditorBrowsableState.Never)]
 356         public event EventHandler KeyboardRepeatSettingsChanged
 357         {
 358             add
 359             {
 360                 if (keyboardRepeatSettingsChangedHandler == null)
 361                 {
 362                     keyboardRepeatSettingsChangedEventCallback = OnKeyboardRepeatSettingsChanged;
 363                     using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
 364                     signal?.Connect(keyboardRepeatSettingsChangedEventCallback);
 365                 }
 366                 keyboardRepeatSettingsChangedHandler += value;
 367             }
 368             remove
 369             {
 370                 keyboardRepeatSettingsChangedHandler -= value;
 371                 if (keyboardRepeatSettingsChangedHandler == null && keyboardRepeatSettingsChangedEventCallback != null)
 372                 {
 373                     using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(SwigCPtr), false);
 374                     signal?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
 375                     if (signal?.Empty() == true)
 376                     {
 377                         keyboardRepeatSettingsChangedEventCallback = null;
 378                     }
 379                 }
 380             }
 381         }
 382
 383         /// <summary>
 384         /// ViewAdded will be triggered when the view added on Window
 385         /// </summary>
 386         /// <since_tizen> 6 </since_tizen>
 387         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 388         [EditorBrowsable(EditorBrowsableState.Never)]
 389         public event EventHandler ViewAdded;
 390         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler;
 391         private event EventHandler<TouchEventArgs> rootLayerTouchDataEventHandler;
 392         private event EventHandler<WheelEventArgs> stageWheelHandler;
 393         private event EventHandler<KeyEventArgs> stageKeyHandler;
 394         private ReturnTypeEventHandler<object, KeyEventArgs, bool> stageInterceptKeyHandler;
 395         private event EventHandler stageEventProcessingFinishedEventHandler;
 396         private event EventHandler<ResizedEventArgs> windowResizeEventHandler;
 397         private event EventHandler<FocusChangedEventArgs> windowFocusChangedEventHandler2;
 398         private event EventHandler<TransitionEffectEventArgs> transitionEffectHandler;
 399         private event EventHandler keyboardRepeatSettingsChangedHandler;
 400         private event EventHandler<AuxiliaryMessageEventArgs> auxiliaryMessageEventHandler;
 401
 402         internal void SendViewAdded(View view)
 403         {
 404             ViewAdded?.Invoke(view, EventArgs.Empty);
 405         }
 406
 407         internal event EventHandler EventProcessingFinished
 408         {
 409             add
 410             {
 411                 if (stageEventProcessingFinishedEventHandler == null)
 412                 {
 413                     stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
 414                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 415                     signal?.Connect(stageEventProcessingFinishedEventCallbackDelegate);
 416                 }
 417                 stageEventProcessingFinishedEventHandler += value;
 418             }
 419             remove
 420             {
 421                 stageEventProcessingFinishedEventHandler -= value;
 422                 if (stageEventProcessingFinishedEventHandler == null && stageEventProcessingFinishedEventCallbackDelegate != null)
 423                 {
 424                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 425                     signal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
 426                     if (signal?.Empty() == true)
 427                     {
 428                         stageEventProcessingFinishedEventCallbackDelegate = null;
 429                     }
 430                 }
 431             }
 432         }
 433
 434         internal event EventHandler ContextLost
 435         {
 436             add
 437             {
 438                 if (stageContextLostEventHandler == null)
 439                 {
 440                     stageContextLostEventCallbackDelegate = OnContextLost;
 441                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 442                     signal?.Connect(stageContextLostEventCallbackDelegate);
 443                 }
 444                 stageContextLostEventHandler += value;
 445             }
 446             remove
 447             {
 448                 stageContextLostEventHandler -= value;
 449                 if (stageContextLostEventHandler == null && stageContextLostEventCallbackDelegate != null)
 450                 {
 451                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 452                     signal?.Disconnect(stageContextLostEventCallbackDelegate);
 453                     if (signal?.Empty() == true)
 454                     {
 455                         stageContextLostEventCallbackDelegate = null;
 456                     }
 457                 }
 458             }
 459         }
 460
 461         internal event EventHandler ContextRegained
 462         {
 463             add
 464             {
 465                 if (stageContextRegainedEventHandler == null)
 466                 {
 467                     stageContextRegainedEventCallbackDelegate = OnContextRegained;
 468                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 469                     signal?.Connect(stageContextRegainedEventCallbackDelegate);
 470                 }
 471                 stageContextRegainedEventHandler += value;
 472             }
 473             remove
 474             {
 475                 stageContextRegainedEventHandler -= value;
 476                 if (stageContextRegainedEventHandler == null && stageContextRegainedEventCallbackDelegate != null)
 477                 {
 478                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 479                     signal?.Disconnect(stageContextRegainedEventCallbackDelegate);
 480                     if (signal?.Empty() == true)
 481                     {
 482                         stageContextRegainedEventCallbackDelegate = null;
 483                     }
 484                 }
 485             }
 486         }
 487
 488         internal event EventHandler SceneCreated
 489         {
 490             add
 491             {
 492                 if (stageSceneCreatedEventHandler == null)
 493                 {
 494                     stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
 495                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 496                     signal?.Connect(stageSceneCreatedEventCallbackDelegate);
 497                 }
 498                 stageSceneCreatedEventHandler += value;
 499             }
 500             remove
 501             {
 502                 stageSceneCreatedEventHandler -= value;
 503                 if (stageSceneCreatedEventHandler == null && stageSceneCreatedEventCallbackDelegate != null)
 504                 {
 505                     using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 506                     signal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
 507                     if (signal?.Empty() == true)
 508                     {
 509                         stageSceneCreatedEventCallbackDelegate = null;
 510                     }
 511                 }
 512             }
 513         }
 514
 515         internal System.IntPtr GetNativeWindowHandler()
 516         {
 517             System.IntPtr ret = Interop.Window.GetNativeWindowHandler(HandleRef.ToIntPtr(this.SwigCPtr));
 518             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 519             return ret;
 520         }
 521
 522         /// <summary>
 523         /// Disconnect all native signals
 524         /// </summary>
 525         /// <since_tizen> 5 </since_tizen>
 526         internal void DisconnectNativeSignals()
 527         {
 528             if (HasBody() == false)
 529             {
 530                 NUILog.Debug($"[Dispose] DisConnectFromSignals() No native body! No need to Disconnect Signals!");
 531                 return;
 532             }
 533
 534             if (windowFocusChangedEventCallback != null)
 535             {
 536                 using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
 537                 signal?.Disconnect(windowFocusChangedEventCallback);
 538                 windowFocusChangedEventCallback = null;
 539             }
 540
 541             if (rootLayerTouchDataCallback != null)
 542             {
 543                 using TouchDataSignal signal = new TouchDataSignal(Interop.ActorSignal.ActorTouchSignal(Layer.getCPtr(GetRootLayer())), false);
 544                 signal?.Disconnect(rootLayerTouchDataCallback);
 545                 rootLayerTouchDataCallback = null;
 546             }
 547             if (wheelEventCallback != null)
 548             {
 549                 using WheelSignal signal = new WheelSignal(Interop.ActorSignal.ActorWheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
 550                 signal?.Disconnect(wheelEventCallback);
 551                 wheelEventCallback = null;
 552             }
 553
 554             if (DetentEventCallback != null)
 555             {
 556                 using StageWheelSignal signal = new StageWheelSignal(Interop.StageSignal.WheelEventSignal(stageCPtr), false);
 557                 signal?.Disconnect(DetentEventCallback);
 558                 DetentEventCallback = null;
 559             }
 560
 561             if (stageKeyCallbackDelegate != null)
 562             {
 563                 using KeyEventSignal signal = new KeyEventSignal(Interop.Window.KeyEventSignal(GetBaseHandleCPtrHandleRef), false);
 564                 signal?.Disconnect(stageKeyCallbackDelegate);
 565                 stageKeyCallbackDelegate = null;
 566             }
 567
 568             if (stageInterceptKeyCallbackDelegate != null)
 569             {
 570                 using KeyEventSignal signal = new KeyEventSignal(Interop.Window.InterceptKeyEventSignal(GetBaseHandleCPtrHandleRef), false);
 571                 signal?.Disconnect(stageInterceptKeyCallbackDelegate);
 572                 stageInterceptKeyCallbackDelegate = null;
 573             }
 574
 575             if (stageEventProcessingFinishedEventCallbackDelegate != null)
 576             {
 577                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.EventProcessingFinishedSignal(stageCPtr), false);
 578                 signal?.Disconnect(stageEventProcessingFinishedEventCallbackDelegate);
 579                 stageEventProcessingFinishedEventCallbackDelegate = null;
 580             }
 581
 582             if (stageContextLostEventCallbackDelegate != null)
 583             {
 584                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextLostSignal(stageCPtr), false);
 585                 signal?.Disconnect(stageContextLostEventCallbackDelegate);
 586                 stageContextLostEventCallbackDelegate = null;
 587             }
 588
 589             if (stageContextRegainedEventCallbackDelegate != null)
 590             {
 591                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.ContextRegainedSignal(stageCPtr), false);
 592                 signal?.Disconnect(stageContextRegainedEventCallbackDelegate);
 593                 stageContextRegainedEventCallbackDelegate = null;
 594             }
 595
 596             if (stageSceneCreatedEventCallbackDelegate != null)
 597             {
 598                 using VoidSignal signal = new VoidSignal(Interop.StageSignal.SceneCreatedSignal(stageCPtr), false);
 599                 signal?.Disconnect(stageSceneCreatedEventCallbackDelegate);
 600                 stageSceneCreatedEventCallbackDelegate = null;
 601             }
 602
 603             if (windowResizeEventCallback != null)
 604             {
 605                 using ResizeSignal signal = new ResizeSignal(Interop.Window.ResizeSignal(GetBaseHandleCPtrHandleRef), false);
 606                 signal?.Disconnect(windowResizeEventCallback);
 607                 windowResizeEventCallback = null;
 608             }
 609
 610             if (windowFocusChangedEventCallback2 != null)
 611             {
 612                 using WindowFocusSignalType signal = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(GetBaseHandleCPtrHandleRef), false);
 613                 signal?.Disconnect(windowFocusChangedEventCallback2);
 614                 windowFocusChangedEventCallback2 = null;
 615             }
 616
 617             if (transitionEffectEventCallback != null)
 618             {
 619                 using WindowTransitionEffectSignal signal = new WindowTransitionEffectSignal(Interop.WindowTransitionEffectSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 620                 signal?.Disconnect(transitionEffectEventCallback);
 621                 transitionEffectEventCallback = null;
 622             }
 623
 624             if (keyboardRepeatSettingsChangedEventCallback != null)
 625             {
 626                 using KeyboardRepeatSettingsChangedSignal signal = new KeyboardRepeatSettingsChangedSignal(Interop.KeyboardRepeatSettingsChangedSignal.GetSignal(GetBaseHandleCPtrHandleRef), false);
 627                 signal?.Disconnect(keyboardRepeatSettingsChangedEventCallback);
 628                 keyboardRepeatSettingsChangedEventCallback = null;
 629             }
 630
 631             if (auxiliaryMessageEventCallback != null)
 632             {
 633                 using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(GetBaseHandleCPtrHandleRef), false);
 634                 signal?.Disconnect(auxiliaryMessageEventCallback);
 635                 auxiliaryMessageEventCallback = null;
 636             }
 637         }
 638
 639         private void OnWindowFocusedChanged(IntPtr window, bool focusGained)
 640         {
 641             if (window == IntPtr.Zero)
 642             {
 643                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
 644                 return;
 645             }
 646
 647             if (windowFocusChangedEventHandler != null)
 648             {
 649                 FocusChangedEventArgs e = new FocusChangedEventArgs();
 650                 e.FocusGained = focusGained;
 651                 windowFocusChangedEventHandler(this, e);
 652             }
 653         }
 654
 655         private bool OnWindowTouch(IntPtr view, IntPtr touchData)
 656         {
 657             if (touchData == global::System.IntPtr.Zero)
 658             {
 659                 NUILog.Error("touchData should not be null!");
 660                 return false;
 661             }
 662
 663             if (rootLayerTouchDataEventHandler != null)
 664             {
 665                 TouchEventArgs e = new TouchEventArgs();
 666                 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 667                 rootLayerTouchDataEventHandler(this, e);
 668             }
 669             return false;
 670         }
 671
 672         private bool OnStageWheel(IntPtr rootLayer, IntPtr wheelEvent)
 673         {
 674             if (wheelEvent == global::System.IntPtr.Zero)
 675             {
 676                 NUILog.Error("wheelEvent should not be null!");
 677                 return true;
 678             }
 679
 680             if (stageWheelHandler != null)
 681             {
 682                 WheelEventArgs e = new WheelEventArgs();
 683                 e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 684                 stageWheelHandler(this, e);
 685             }
 686             return true;
 687         }
 688
 689         // Callback for Stage KeyEventsignal
 690         private void OnStageKey(IntPtr data)
 691         {
 692             if (stageKeyHandler != null)
 693             {
 694                 KeyEventArgs e = new KeyEventArgs();
 695                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
 696                 //here we send all data to user event handlers
 697                 stageKeyHandler(this, e);
 698             }
 699         }
 700
 701         // Callback for Stage InterceptKeyEventsignal
 702         private bool OnStageInterceptKey(IntPtr data)
 703         {
 704             bool consumed = false;
 705             if (stageInterceptKeyHandler != null)
 706             {
 707                 KeyEventArgs e = new KeyEventArgs();
 708                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
 709                 //here we send all data to user event handlers
 710                 consumed = stageInterceptKeyHandler(this, e);
 711             }
 712             return consumed;
 713         }
 714
 715         // Callback for Stage EventProcessingFinishedSignal
 716         private void OnEventProcessingFinished()
 717         {
 718             stageEventProcessingFinishedEventHandler?.Invoke(this, null);
 719         }
 720
 721         // Callback for Stage ContextLostSignal
 722         private void OnContextLost()
 723         {
 724             stageContextLostEventHandler?.Invoke(this, null);
 725         }
 726
 727         // Callback for Stage ContextRegainedSignal
 728         private void OnContextRegained()
 729         {
 730             stageContextRegainedEventHandler?.Invoke(this, null);
 731         }
 732
 733         // Callback for Stage SceneCreatedSignal
 734         private void OnSceneCreated()
 735         {
 736             stageSceneCreatedEventHandler?.Invoke(this, null);
 737         }
 738
 739         private void OnResized(IntPtr window, IntPtr windowSize)
 740         {
 741             if (window == IntPtr.Zero)
 742             {
 743                 NUILog.Error("OnResized() Window is null! Do nothing!");
 744                 return;
 745             }
 746
 747             if (windowResizeEventHandler != null)
 748             {
 749                 ResizedEventArgs e = new ResizedEventArgs();
 750                 // var val = new Uint16Pair(windowSize, false);
 751                 // e.WindowSize = new Size2D(val.GetWidth(), val.GetHeight());
 752                 // val.Dispose();
 753
 754                 // Workaround : windowSize should be valid pointer from dali,
 755                 // but currently it is fixed and is not Uint16Pair class.
 756                 // will be fixed later.
 757                 e.WindowSize = this.WindowSize;
 758                 windowResizeEventHandler(this, e);
 759             }
 760         }
 761
 762         private void OnWindowFocusedChanged2(IntPtr window, bool focusGained)
 763         {
 764             if (window == IntPtr.Zero)
 765             {
 766                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
 767                 return;
 768             }
 769
 770             if (windowFocusChangedEventHandler2 != null)
 771             {
 772                 FocusChangedEventArgs e = new FocusChangedEventArgs();
 773                 e.FocusGained = focusGained;
 774                 windowFocusChangedEventHandler2(this, e);
 775             }
 776         }
 777
 778         private void OnTransitionEffect(IntPtr window, int state, int type)
 779         {
 780             if (window == global::System.IntPtr.Zero)
 781             {
 782                 return;
 783             }
 784
 785             if (transitionEffectHandler != null)
 786             {
 787                 TransitionEffectEventArgs e = new TransitionEffectEventArgs();
 788                 e.State = (EffectState)state;
 789                 e.Type = (EffectType)type;
 790                 transitionEffectHandler(this, e);
 791             }
 792             return;
 793         }
 794
 795         private void OnKeyboardRepeatSettingsChanged()
 796         {
 797             keyboardRepeatSettingsChangedHandler?.Invoke(this, null);
 798             return;
 799         }
 800
 801         /// <summary>
 802         /// The focus changed event argument.
 803         /// </summary>
 804         /// <since_tizen> 3 </since_tizen>
 805         public class FocusChangedEventArgs : EventArgs
 806         {
 807             /// <summary>
 808             /// FocusGained flag.
 809             /// </summary>
 810             /// <since_tizen> 3 </since_tizen>
 811             public bool FocusGained
 812             {
 813                 get;
 814                 set;
 815             }
 816         }
 817
 818         /// <summary>
 819         /// The touch event argument.
 820         /// </summary>
 821         /// <since_tizen> 3 </since_tizen>
 822         public class TouchEventArgs : EventArgs
 823         {
 824             private Touch touch;
 825
 826             /// <summary>
 827             /// Touch.
 828             /// </summary>
 829             /// <since_tizen> 3 </since_tizen>
 830             public Touch Touch
 831             {
 832                 get
 833                 {
 834                     return touch;
 835                 }
 836                 set
 837                 {
 838                     touch = value;
 839                 }
 840             }
 841         }
 842
 843         /// <summary>
 844         /// Wheel event arguments.
 845         /// </summary>
 846         /// <since_tizen> 3 </since_tizen>
 847         public class WheelEventArgs : EventArgs
 848         {
 849             private Wheel wheel;
 850
 851             /// <summary>
 852             /// Wheel.
 853             /// </summary>
 854             /// <since_tizen> 3 </since_tizen>
 855             public Wheel Wheel
 856             {
 857                 get
 858                 {
 859                     return wheel;
 860                 }
 861                 set
 862                 {
 863                     wheel = value;
 864                 }
 865             }
 866         }
 867
 868         /// <summary>
 869         /// Key event arguments.
 870         /// </summary>
 871         /// <since_tizen> 3 </since_tizen>
 872         public class KeyEventArgs : EventArgs
 873         {
 874             private Key key;
 875
 876             /// <summary>
 877             /// Key.
 878             /// </summary>
 879             /// <since_tizen> 3 </since_tizen>
 880             public Key Key
 881             {
 882                 get
 883                 {
 884                     return key;
 885                 }
 886                 set
 887                 {
 888                     key = value;
 889                 }
 890             }
 891         }
 892
 893         /// <summary>
 894         /// Feeds a key event into the window.
 895         /// This resized event arguments.
 896         /// </summary>
 897         /// <since_tizen> 3 </since_tizen>
 898         public class ResizedEventArgs : EventArgs
 899         {
 900             Size2D windowSize;
 901
 902             /// <summary>
 903             /// This window size.
 904             /// </summary>
 905             /// <since_tizen> 4 </since_tizen>
 906             public Size2D WindowSize
 907             {
 908                 get
 909                 {
 910                     return windowSize;
 911                 }
 912                 set
 913                 {
 914                     windowSize = value;
 915                 }
 916             }
 917         }
 918
 919         /// <summary>
 920         /// Do not use this, that will be deprecated.
 921         /// </summary>
 922         /// <since_tizen> 3 </since_tizen>
 923         [Obsolete("Do not use this, that will be deprecated. Use FocusChangedEventArgs instead. " +
 924             "Like: " +
 925             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
 926             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
 927         [EditorBrowsable(EditorBrowsableState.Never)]
 928         [System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1034:NestedTypesShouldNotBeVisible")]
 929         public class WindowFocusChangedEventArgs : EventArgs
 930         {
 931             /// <summary>
 932             /// Do not use this, that will be deprecated.
 933             /// </summary>
 934             /// <since_tizen> 3 </since_tizen>
 935             public bool FocusGained
 936             {
 937                 get;
 938                 set;
 939             }
 940         }
 941
 942         /// <summary>
 943         /// Contains and encapsulates Native Window handle.
 944         /// </summary>
 945         /// <since_tizen> 4 </since_tizen>
 946         [Obsolete("This has been deprecated in API9 and will be removed in API11. Use Window.NativeHandle instead.")]
 947         public class SafeNativeWindowHandle : SafeHandle
 948         {
 949             /// <summary>
 950             ///Constructor, Native window handle is set to handle.
 951             /// </summary>
 952             /// <since_tizen> 4 </since_tizen>
 953             public SafeNativeWindowHandle() : base(IntPtr.Zero, false)
 954             {
 955                 SetHandle(NUIApplication.GetDefaultWindow().GetNativeWindowHandler());
 956             }
 957             /// <summary>
 958             /// Null check if the handle is valid or not.
 959             /// </summary>
 960             /// <since_tizen> 4 </since_tizen>
 961             public override bool IsInvalid
 962             {
 963                 get
 964                 {
 965                     return this.handle == IntPtr.Zero;
 966                 }
 967             }
 968             /// <summary>
 969             /// Release handle itself.
 970             /// </summary>
 971             /// <returns>true when released successfully.</returns>
 972             /// <since_tizen> 4 </since_tizen>
 973             protected override bool ReleaseHandle()
 974             {
 975                 return true;
 976             }
 977         }
 978
 979         /// <summary>
 980         /// TransitionEffectArgs
 981         /// </summary>
 982         [EditorBrowsable(EditorBrowsableState.Never)]
 983         public class TransitionEffectEventArgs : EventArgs
 984         {
 985             private EffectState state;
 986             private EffectType type;
 987
 988             /// <summary>
 989             /// State
 990             /// </summary>
 991             [EditorBrowsable(EditorBrowsableState.Never)]
 992             public EffectState State
 993             {
 994                 get
 995                 {
 996                     return state;
 997                 }
 998                 set
 999                 {
1000                     state = value;
1001                 }
1002             }
1003             /// <summary>
1004             /// Type
1005             /// </summary>
1006             [EditorBrowsable(EditorBrowsableState.Never)]
1007             public EffectType Type
1008             {
1009                 get
1010                 {
1011                     return type;
1012                 }
1013                 set
1014                 {
1015                     type = value;
1016                 }
1017             }
1018         }
1019
1020         private EventHandler<WheelEventArgs> DetentEventHandler;
1021
1022         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1023         private delegate void DetentEventCallbackType(IntPtr arg1);
1024
1025         private DetentEventCallbackType DetentEventCallback;
1026
1027         private void OnDetentEvent(IntPtr wheelEvent)
1028         {
1029             WheelEventArgs e = new WheelEventArgs();
1030
1031             if (wheelEvent != global::System.IntPtr.Zero)
1032             {
1033                 e.Wheel = Wheel.GetWheelFromPtr(wheelEvent);
1034             }
1035
1036             DetentEventHandler?.Invoke(this, e);
1037         }
1038
1039         /// <summary>
1040         /// VisibilityChangedArgs
1041         /// </summary>
1042         [EditorBrowsable(EditorBrowsableState.Never)]
1043         public class VisibilityChangedEventArgs : EventArgs
1044         {
1045             private bool visibility;
1046             /// <summary>
1047             /// Visibility
1048             /// </summary>
1049             [EditorBrowsable(EditorBrowsableState.Never)]
1050             public bool Visibility
1051             {
1052                 get => visibility;
1053                 set
1054                 {
1055                     visibility = value;
1056                 }
1057             }
1058         }
1059
1060         private void OnVisibilityChanged(IntPtr window, bool visibility)
1061         {
1062             if (window == global::System.IntPtr.Zero)
1063             {
1064                 NUILog.Error("[ERR] OnVisibilityChanged() window is null");
1065                 return;
1066             }
1067
1068             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
1069             e.Visibility = visibility;
1070             if (VisibilityChangedEventHandler != null)
1071             {
1072                 VisibilityChangedEventHandler.Invoke(this, e);
1073             }
1074         }
1075
1076         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1077         private delegate void VisibilityChangedEventCallbackType(IntPtr window, bool visibility);
1078         private VisibilityChangedEventCallbackType VisibilityChangedEventCallback;
1079         private event EventHandler<VisibilityChangedEventArgs> VisibilityChangedEventHandler;
1080         private WindowVisibilityChangedEvent VisibilityChangedEventSignal;
1081
1082         /// <summary>
1083         /// EffectStart
1084         /// </summary>
1085         [EditorBrowsable(EditorBrowsableState.Never)]
1086         public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
1087         {
1088             add
1089             {
1090                 if (VisibilityChangedEventHandler == null)
1091                 {
1092                     VisibilityChangedEventCallback = OnVisibilityChanged;
1093                     using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
1094                     signal?.Connect(VisibilityChangedEventCallback);
1095                 }
1096                 VisibilityChangedEventHandler += value;
1097             }
1098             remove
1099             {
1100                 VisibilityChangedEventHandler -= value;
1101                 if (VisibilityChangedEventHandler == null && VisibilityChangedEventCallback != null)
1102                 {
1103                     using WindowVisibilityChangedEvent signal = new WindowVisibilityChangedEvent(Interop.WindowVisibilityChangedSignal.GetSignal(Window.getCPtr(this)), false);
1104                     signal?.Disconnect(VisibilityChangedEventCallback);
1105                     if (signal?.Empty() == true)
1106                     {
1107                         VisibilityChangedEventCallback = null;
1108                     }
1109                 }
1110             }
1111         }
1112
1113         /// <summary>
1114         /// VisibiltyChangedSignalEmit
1115         /// </summary>
1116         [EditorBrowsable(EditorBrowsableState.Never)]
1117         public void VisibiltyChangedSignalEmit(bool visibility)
1118         {
1119             if (VisibilityChangedEventSignal == null)
1120             {
1121                 VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this);
1122             }
1123             VisibilityChangedEventSignal.Emit(this, visibility);
1124         }
1125
1126         private void OnAuxiliaryMessage(IntPtr kData, IntPtr vData, IntPtr optionsArray)
1127         {
1128             if (kData == IntPtr.Zero || vData == IntPtr.Zero)
1129             {
1130                 return;
1131             }
1132
1133             using var tmp = new PropertyArray(optionsArray, false);
1134             var size = tmp.Size();
1135
1136             List<string> tmpList = new List<string>();
1137
1138             for (int i = 0; i < size; i++)
1139             {
1140                 string option = "none";
1141                 tmp.GetElementAt((uint)i).Get(out option);
1142                 tmpList.Add(option);
1143             }
1144
1145             tmp.Dispose();
1146
1147             AuxiliaryMessageEventArgs e = new AuxiliaryMessageEventArgs();
1148             e.Key = StringToVoidSignal.GetResult(kData);
1149             e.Value = StringToVoidSignal.GetResult(vData); ;
1150             e.Options = tmpList;
1151
1152             auxiliaryMessageEventHandler?.Invoke(this, e);
1153         }
1154
1155         /// <summary>
1156         /// Auxiliary message is sent by displayer server when window's auxiliary was changed then display server sent the message.
1157         /// When client application added the window's auxiliary hint and if the auxiliary is changed,
1158         /// display server send the auxiliary message.
1159         /// Auxiliary message has the key, value and options.
1160         /// </summary>
1161         [EditorBrowsable(EditorBrowsableState.Never)]
1162         public event EventHandler<AuxiliaryMessageEventArgs> AuxiliaryMessage
1163         {
1164             add
1165             {
1166                 if (auxiliaryMessageEventHandler == null)
1167                 {
1168                     auxiliaryMessageEventCallback = OnAuxiliaryMessage;
1169                     using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
1170                     signal?.Connect(auxiliaryMessageEventCallback);
1171                 }
1172                 auxiliaryMessageEventHandler += value;
1173             }
1174             remove
1175             {
1176                 auxiliaryMessageEventHandler -= value;
1177                 if (auxiliaryMessageEventHandler == null && auxiliaryMessageEventCallback != null)
1178                 {
1179                     using WindowAuxiliaryMessageSignal signal = new WindowAuxiliaryMessageSignal(Interop.WindowAuxiliaryMessageSignalType.Get(SwigCPtr), false);
1180                     signal?.Disconnect(auxiliaryMessageEventCallback);
1181                     if (signal?.Empty() == true)
1182                     {
1183                         auxiliaryMessageEventCallback = null;
1184                     }
1185                 }
1186             }
1187         }
1188
1189
1190     }
1191 }