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

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