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