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