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