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