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

   1 /*
   2  * Copyright(c) 2019 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
  23 namespace Tizen.NUI
  24 {
  25     /// <summary>
  26     /// The window class is used internally for drawing.<br />
  27     /// The window has an orientation and indicator properties.<br />
  28     /// </summary>
  29     /// <since_tizen> 3 </since_tizen>
  30     public partial class Window
  31     {
  32         private WindowFocusChangedEventCallbackType _windowFocusChangedEventCallback;
  33         private RootLayerTouchDataCallbackType _rootLayerTouchDataCallback;
  34         private WheelEventCallbackType _wheelEventCallback;
  35         private EventCallbackDelegateType1 _stageKeyCallbackDelegate;
  36         private EventCallbackDelegateType0 _stageEventProcessingFinishedEventCallbackDelegate;
  37         private EventHandler _stageContextLostEventHandler;
  38         private EventCallbackDelegateType0 _stageContextLostEventCallbackDelegate;
  39         private EventHandler _stageContextRegainedEventHandler;
  40         private EventCallbackDelegateType0 _stageContextRegainedEventCallbackDelegate;
  41         private EventHandler _stageSceneCreatedEventHandler;
  42         private EventCallbackDelegateType0 _stageSceneCreatedEventCallbackDelegate;
  43         private WindowResizedEventCallbackType _windowResizedEventCallback;
  44         private WindowFocusChangedEventCallbackType _windowFocusChangedEventCallback2;
  45         private TransitionEffectEventCallbackType transitionEffectEventCallback;
  46         private WindowTransitionEffectSignal transitionEffectSignal;
  47
  48         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  49         private delegate void WindowFocusChangedEventCallbackType(IntPtr window, bool focusGained);
  50         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  51         private delegate bool RootLayerTouchDataCallbackType(IntPtr view, IntPtr touchData);
  52         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  53         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
  54         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  55         private delegate void WindowResizedEventCallbackType(IntPtr windowSize);
  56         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  57         private delegate void WindowFocusChangedEventCallbackType2(IntPtr window, bool focusGained);
  58         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  59         private delegate void TransitionEffectEventCallbackType(IntPtr window, int state, int type);
  60
  61         /// <summary>
  62         /// FocusChanged event.
  63         /// </summary>
  64         /// <since_tizen> 3 </since_tizen>
  65         public event EventHandler<FocusChangedEventArgs> FocusChanged
  66         {
  67             add
  68             {
  69                 if (_windowFocusChangedEventHandler == null)
  70                 {
  71                     _windowFocusChangedEventCallback = OnWindowFocusedChanged;
  72                     WindowFocusChangedSignal().Connect(_windowFocusChangedEventCallback);
  73                 }
  74
  75                 _windowFocusChangedEventHandler += value;
  76             }
  77             remove
  78             {
  79                 _windowFocusChangedEventHandler -= value;
  80
  81                 if (_windowFocusChangedEventHandler == null && WindowFocusChangedSignal().Empty() == false && _windowFocusChangedEventCallback != null)
  82                 {
  83                     WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback);
  84                 }
  85             }
  86         }
  87
  88         /// <summary>
  89         /// Emits the event when the screen is touched and when the touch ends.<br />
  90         /// If there are multiple touch points then it is emitted when the first touch occurs and
  91         /// when the last finger is lifted too.<br />
  92         /// Even though incoming events are interrupted, the event occurs.<br />
  93         /// </summary>
  94         /// <since_tizen> 3 </since_tizen>
  95         public event EventHandler<TouchEventArgs> TouchEvent
  96         {
  97             add
  98             {
  99                 if (_rootLayerTouchDataEventHandler == null)
 100                 {
 101                     _rootLayerTouchDataCallback = OnWindowTouch;
 102                     this.TouchDataSignal().Connect(_rootLayerTouchDataCallback);
 103                 }
 104                 _rootLayerTouchDataEventHandler += value;
 105             }
 106             remove
 107             {
 108                 _rootLayerTouchDataEventHandler -= value;
 109                 if (_rootLayerTouchDataEventHandler == null && TouchSignal().Empty() == false && _rootLayerTouchDataCallback != null)
 110                 {
 111                     this.TouchDataSignal().Disconnect(_rootLayerTouchDataCallback);
 112                 }
 113             }
 114         }
 115
 116         /// <summary>
 117         /// Emits the event when the wheel event is received.
 118         /// </summary>
 119         /// <since_tizen> 3 </since_tizen>
 120         public event EventHandler<WheelEventArgs> WheelEvent
 121         {
 122             add
 123             {
 124                 if (_stageWheelHandler == null)
 125                 {
 126                     _wheelEventCallback = OnStageWheel;
 127                     WheelEventSignal().Connect(_wheelEventCallback);
 128                 }
 129                 _stageWheelHandler += value;
 130
 131                 if (DetentEventHandler == null)
 132                 {
 133                     DetentEventCallback = OnDetentEvent;
 134                     StageWheelEventSignal().Connect(DetentEventCallback);
 135                 }
 136                 DetentEventHandler += value;
 137             }
 138             remove
 139             {
 140                 _stageWheelHandler -= value;
 141                 if (_stageWheelHandler == null && WheelEventSignal().Empty() == false)
 142                 {
 143                     WheelEventSignal().Disconnect(_wheelEventCallback);
 144                 }
 145
 146                 DetentEventHandler -= value;
 147                 if(DetentEventHandler ==  null && StageWheelEventSignal().Empty() == false)
 148                 {
 149                     StageWheelEventSignal().Disconnect(DetentEventCallback);
 150                 }
 151             }
 152         }
 153
 154         /// <summary>
 155         /// Emits the event when the key event is received.
 156         /// </summary>
 157         /// <since_tizen> 3 </since_tizen>
 158         public event EventHandler<KeyEventArgs> KeyEvent
 159         {
 160             add
 161             {
 162                 if (_stageKeyHandler == null)
 163                 {
 164                     _stageKeyCallbackDelegate = OnStageKey;
 165                     KeyEventSignal().Connect(_stageKeyCallbackDelegate);
 166                 }
 167                 _stageKeyHandler += value;
 168             }
 169             remove
 170             {
 171                 _stageKeyHandler -= value;
 172                 if (_stageKeyHandler == null && KeyEventSignal().Empty() == false)
 173                 {
 174                     KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
 175                 }
 176             }
 177         }
 178
 179         /// <summary>
 180         /// Emits the event when the window resized.
 181         /// </summary>
 182         /// <since_tizen> 3 </since_tizen>
 183         public event EventHandler<ResizedEventArgs> Resized
 184         {
 185             add
 186             {
 187                 if (_windowResizedEventHandler == null)
 188                 {
 189                     _windowResizedEventCallback = OnResized;
 190                     ResizedSignal().Connect(_windowResizedEventCallback);
 191                 }
 192
 193                 _windowResizedEventHandler += value;
 194             }
 195             remove
 196             {
 197                 _windowResizedEventHandler -= value;
 198
 199                 if (_windowResizedEventHandler == null && ResizedSignal().Empty() == false && _windowResizedEventCallback != null)
 200                 {
 201                     ResizedSignal().Disconnect(_windowResizedEventCallback);
 202                 }
 203             }
 204         }
 205
 206         /// <summary>
 207         /// Please do not use! this will be deprecated. Please use 'FocusChanged' event instead.
 208         /// </summary>
 209         /// <since_tizen> 3 </since_tizen>
 210         /// Please do not use! this will be deprecated!
 211         /// Instead please use FocusChanged.
 212         [Obsolete("Please do not use! This will be deprecated! Please use FocusChanged instead! " +
 213             "Like: " +
 214             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
 215             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
 216         [EditorBrowsable(EditorBrowsableState.Never)]
 217         public event EventHandler<FocusChangedEventArgs> WindowFocusChanged
 218         {
 219             add
 220             {
 221                 if (_windowFocusChangedEventHandler2 == null)
 222                 {
 223                     _windowFocusChangedEventCallback2 = OnWindowFocusedChanged2;
 224                     WindowFocusChangedSignal().Connect(_windowFocusChangedEventCallback2);
 225                 }
 226
 227                 _windowFocusChangedEventHandler2 += value;
 228             }
 229             remove
 230             {
 231                 _windowFocusChangedEventHandler2 -= value;
 232
 233                 if (_windowFocusChangedEventHandler2 == null && WindowFocusChangedSignal().Empty() == false && _windowFocusChangedEventCallback2 != null)
 234                 {
 235                     WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback2);
 236                 }
 237             }
 238         }
 239
 240         /// <summary>
 241         /// EffectStart
 242         /// </summary>
 243         [EditorBrowsable(EditorBrowsableState.Never)]
 244         public event EventHandler<TransitionEffectArgs> TransitionEffect
 245         {
 246             add
 247             {
 248                 if (transitionEffectHandler == null)
 249                 {
 250                     transitionEffectEventCallback = OnTransitionEffect;
 251                     TransitionEffectEventSignal().Connect(transitionEffectEventCallback);
 252                 }
 253                 transitionEffectHandler += value;
 254             }
 255             remove
 256             {
 257                 transitionEffectHandler -= value;
 258                 if (transitionEffectHandler == null && TransitionEffectEventSignal().Empty() == false)
 259                 {
 260                     TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback);
 261                 }
 262             }
 263         }
 264
 265         /// <summary>
 266         /// ViewAdded will be triggered when the view added on Window
 267         /// </summary>
 268         /// <since_tizen> 6 </since_tizen>
 269         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 270         [EditorBrowsable(EditorBrowsableState.Never)]
 271         public event EventHandler ViewAdded;
 272         private event EventHandler<FocusChangedEventArgs> _windowFocusChangedEventHandler;
 273         private event EventHandler<TouchEventArgs> _rootLayerTouchDataEventHandler;
 274         private event EventHandler<WheelEventArgs> _stageWheelHandler;
 275         private event EventHandler<KeyEventArgs> _stageKeyHandler;
 276         private event EventHandler _stageEventProcessingFinishedEventHandler;
 277         private event EventHandler<ResizedEventArgs> _windowResizedEventHandler;
 278         private event EventHandler<FocusChangedEventArgs> _windowFocusChangedEventHandler2;
 279         private event EventHandler<TransitionEffectArgs> transitionEffectHandler;
 280
 281         internal void SendViewAdded(View view)
 282         {
 283             ViewAdded?.Invoke(view, EventArgs.Empty);
 284         }
 285
 286         internal event EventHandler EventProcessingFinished
 287         {
 288             add
 289             {
 290                 if (_stageEventProcessingFinishedEventHandler == null)
 291                 {
 292                     _stageEventProcessingFinishedEventCallbackDelegate = OnEventProcessingFinished;
 293                     EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
 294                 }
 295                 _stageEventProcessingFinishedEventHandler += value;
 296
 297             }
 298             remove
 299             {
 300                 _stageEventProcessingFinishedEventHandler -= value;
 301                 if (_stageEventProcessingFinishedEventHandler == null && EventProcessingFinishedSignal().Empty() == false)
 302                 {
 303                     EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
 304                 }
 305             }
 306         }
 307
 308         internal event EventHandler ContextLost
 309         {
 310             add
 311             {
 312                 if (_stageContextLostEventHandler == null)
 313                 {
 314                     _stageContextLostEventCallbackDelegate = OnContextLost;
 315                     ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
 316                 }
 317                 _stageContextLostEventHandler += value;
 318             }
 319             remove
 320             {
 321                 _stageContextLostEventHandler -= value;
 322                 if (_stageContextLostEventHandler == null && ContextLostSignal().Empty() == false)
 323                 {
 324                     ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
 325                 }
 326             }
 327         }
 328
 329         internal event EventHandler ContextRegained
 330         {
 331             add
 332             {
 333                 if (_stageContextRegainedEventHandler == null)
 334                 {
 335                     _stageContextRegainedEventCallbackDelegate = OnContextRegained;
 336                     ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
 337                 }
 338                 _stageContextRegainedEventHandler += value;
 339             }
 340             remove
 341             {
 342                 _stageContextRegainedEventHandler -= value;
 343                 if (_stageContextRegainedEventHandler == null && ContextRegainedSignal().Empty() == false)
 344                 {
 345                     this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
 346                 }
 347             }
 348         }
 349
 350         internal event EventHandler SceneCreated
 351         {
 352             add
 353             {
 354                 if (_stageSceneCreatedEventHandler == null)
 355                 {
 356                     _stageSceneCreatedEventCallbackDelegate = OnSceneCreated;
 357                     SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
 358                 }
 359                 _stageSceneCreatedEventHandler += value;
 360             }
 361             remove
 362             {
 363                 _stageSceneCreatedEventHandler -= value;
 364                 if (_stageSceneCreatedEventHandler == null && SceneCreatedSignal().Empty() == false)
 365                 {
 366                     SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
 367                 }
 368             }
 369         }
 370
 371         internal WindowFocusSignalType WindowFocusChangedSignal()
 372         {
 373             WindowFocusSignalType ret = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(swigCPtr), false);
 374             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 375             return ret;
 376         }
 377
 378         internal WindowFocusSignalType FocusChangedSignal()
 379         {
 380             WindowFocusSignalType ret = new WindowFocusSignalType(Interop.Window.FocusChangedSignal(swigCPtr), false);
 381             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 382             return ret;
 383         }
 384
 385         internal KeyEventSignal KeyEventSignal()
 386         {
 387             KeyEventSignal ret = new KeyEventSignal(Interop.Window.KeyEventSignal(swigCPtr), false);
 388             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 389             return ret;
 390         }
 391
 392         internal VoidSignal EventProcessingFinishedSignal()
 393         {
 394             VoidSignal ret = new VoidSignal(Interop.StageSignal.Stage_EventProcessingFinishedSignal(stageCPtr), false);
 395             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 396             return ret;
 397         }
 398
 399         internal TouchSignal TouchSignal()
 400         {
 401             TouchSignal ret = new TouchSignal(Interop.Window.TouchSignal(swigCPtr), false);
 402             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 403             return ret;
 404         }
 405
 406         internal TouchDataSignal TouchDataSignal()
 407         {
 408             TouchDataSignal ret = new TouchDataSignal(Interop.ActorSignal.Actor_TouchSignal(Layer.getCPtr(GetRootLayer())), false);
 409             if (NDalicPINVOKE.SWIGPendingException.Pending)
 410                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 411             return ret;
 412         }
 413
 414         internal VoidSignal ContextLostSignal()
 415         {
 416             VoidSignal ret = new VoidSignal(Interop.StageSignal.Stage_ContextLostSignal(stageCPtr), false);
 417             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 418             return ret;
 419         }
 420
 421         internal VoidSignal ContextRegainedSignal()
 422         {
 423             VoidSignal ret = new VoidSignal(Interop.StageSignal.Stage_ContextRegainedSignal(stageCPtr), false);
 424             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 425             return ret;
 426         }
 427
 428         internal VoidSignal SceneCreatedSignal()
 429         {
 430             VoidSignal ret = new VoidSignal(Interop.StageSignal.Stage_SceneCreatedSignal(stageCPtr), false);
 431             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 432             return ret;
 433         }
 434
 435         internal ResizedSignal ResizedSignal()
 436         {
 437             ResizedSignal ret = new ResizedSignal(Interop.Window.Window_ResizedSignal(swigCPtr), false);
 438             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 439             return ret;
 440         }
 441
 442         internal System.IntPtr GetNativeWindowHandler()
 443         {
 444             System.IntPtr ret = Interop.Window.GetNativeWindowHandler(HandleRef.ToIntPtr(this.swigCPtr));
 445             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 446             return ret;
 447         }
 448
 449         /// <summary>
 450         /// Disconnect all native signals
 451         /// </summary>
 452         /// <since_tizen> 5 </since_tizen>
 453         internal void DisconnectNativeSignals()
 454         {
 455             if (_windowFocusChangedEventCallback != null)
 456             {
 457                 WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback);
 458             }
 459
 460             if (_rootLayerTouchDataCallback != null)
 461             {
 462                 TouchDataSignal().Disconnect(_rootLayerTouchDataCallback);
 463             }
 464
 465             if (_wheelEventCallback != null)
 466             {
 467                 WheelEventSignal().Disconnect(_wheelEventCallback);
 468             }
 469
 470             if(DetentEventCallback != null)
 471             {
 472                 StageWheelEventSignal().Disconnect(DetentEventCallback);
 473             }
 474
 475             if (_stageKeyCallbackDelegate != null)
 476             {
 477                 KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
 478             }
 479
 480             if (_stageEventProcessingFinishedEventCallbackDelegate != null)
 481             {
 482                 EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
 483             }
 484
 485             if (_stageContextLostEventCallbackDelegate != null)
 486             {
 487                 ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
 488             }
 489
 490             if (_stageContextRegainedEventCallbackDelegate != null)
 491             {
 492                 ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
 493             }
 494
 495             if (_stageSceneCreatedEventCallbackDelegate != null)
 496             {
 497                 SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
 498             }
 499
 500             if (_windowResizedEventCallback != null)
 501             {
 502                 ResizedSignal().Disconnect(_windowResizedEventCallback);
 503             }
 504
 505             if (_windowFocusChangedEventCallback2 != null)
 506             {
 507                 WindowFocusChangedSignal().Disconnect(_windowFocusChangedEventCallback2);
 508             }
 509
 510             if (transitionEffectSignal != null)
 511             {
 512                 TransitionEffectEventSignal().Disconnect(transitionEffectEventCallback);
 513             }
 514         }
 515
 516         private StageWheelSignal StageWheelEventSignal()
 517         {
 518             StageWheelSignal ret = new StageWheelSignal(Interop.StageSignal.Stage_WheelEventSignal(stageCPtr), false);
 519             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 520             return ret;
 521         }
 522
 523         private WheelSignal WheelEventSignal()
 524         {
 525             WheelSignal ret = new WheelSignal(Interop.ActorSignal.Actor_WheelEventSignal(Layer.getCPtr(this.GetRootLayer())), false);
 526             if (NDalicPINVOKE.SWIGPendingException.Pending)
 527                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 528             return ret;
 529         }
 530
 531         private WindowTransitionEffectSignal TransitionEffectEventSignal()
 532         {
 533             //Tizen.Log.Fatal("NUITEST", "TransitionEffectEventSignal()!");
 534             if (transitionEffectSignal == null)
 535             {
 536                 transitionEffectSignal = new WindowTransitionEffectSignal(this);
 537                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 538                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 539                 //Tizen.Log.Fatal("NUITEST", $"transitionEffectSignal is null, new here!");
 540             }
 541             return transitionEffectSignal;
 542         }
 543
 544         private void OnWindowFocusedChanged(IntPtr window, bool focusGained)
 545         {
 546             if (window == IntPtr.Zero)
 547             {
 548                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
 549                 return;
 550             }
 551
 552             FocusChangedEventArgs e = new FocusChangedEventArgs();
 553
 554             e.FocusGained = focusGained;
 555
 556             if (_windowFocusChangedEventHandler != null)
 557             {
 558                 _windowFocusChangedEventHandler(this, e);
 559             }
 560         }
 561
 562         private bool OnWindowTouch(IntPtr view, IntPtr touchData)
 563         {
 564             if (touchData == global::System.IntPtr.Zero)
 565             {
 566                 NUILog.Error("touchData should not be null!");
 567                 return false;
 568             }
 569
 570             TouchEventArgs e = new TouchEventArgs();
 571
 572             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 573
 574             if (_rootLayerTouchDataEventHandler != null)
 575             {
 576                 _rootLayerTouchDataEventHandler(this, e);
 577             }
 578             return false;
 579         }
 580
 581         private bool OnStageWheel(IntPtr rootLayer, IntPtr wheelEvent)
 582         {
 583             if (wheelEvent == global::System.IntPtr.Zero)
 584             {
 585                 NUILog.Error("wheelEvent should not be null!");
 586                 return true;
 587             }
 588
 589             WheelEventArgs e = new WheelEventArgs();
 590
 591             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 592
 593             if (_stageWheelHandler != null)
 594             {
 595                 _stageWheelHandler(this, e);
 596             }
 597             return true;
 598         }
 599
 600         // Callback for Stage KeyEventsignal
 601         private void OnStageKey(IntPtr data)
 602         {
 603             KeyEventArgs e = new KeyEventArgs();
 604             e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);
 605
 606
 607             if (_stageKeyHandler != null)
 608             {
 609                 //here we send all data to user event handlers
 610                 _stageKeyHandler(this, e);
 611             }
 612         }
 613
 614         // Callback for Stage EventProcessingFinishedSignal
 615         private void OnEventProcessingFinished()
 616         {
 617             if (_stageEventProcessingFinishedEventHandler != null)
 618             {
 619                 _stageEventProcessingFinishedEventHandler(this, null);
 620             }
 621         }
 622
 623         // Callback for Stage ContextLostSignal
 624         private void OnContextLost()
 625         {
 626             if (_stageContextLostEventHandler != null)
 627             {
 628                 _stageContextLostEventHandler(this, null);
 629             }
 630         }
 631
 632         // Callback for Stage ContextRegainedSignal
 633         private void OnContextRegained()
 634         {
 635             if (_stageContextRegainedEventHandler != null)
 636             {
 637                 _stageContextRegainedEventHandler(this, null);
 638             }
 639         }
 640
 641         // Callback for Stage SceneCreatedSignal
 642         private void OnSceneCreated()
 643         {
 644             if (_stageSceneCreatedEventHandler != null)
 645             {
 646                 _stageSceneCreatedEventHandler(this, null);
 647             }
 648         }
 649
 650         private void OnResized(IntPtr windowSize)
 651         {
 652             ResizedEventArgs e = new ResizedEventArgs();
 653             var val = new Uint16Pair(windowSize, false);
 654             e.WindowSize = new Size2D(val.GetWidth(), val.GetHeight());
 655             val.Dispose();
 656
 657             if (_windowResizedEventHandler != null)
 658             {
 659                 _windowResizedEventHandler(this, e);
 660             }
 661         }
 662
 663         private void OnWindowFocusedChanged2(IntPtr window, bool focusGained)
 664         {
 665             if (window == IntPtr.Zero)
 666             {
 667                 NUILog.Error("OnWindowFocusedChanged() Window is null! Do nothing!");
 668                 return;
 669             }
 670
 671             FocusChangedEventArgs e = new FocusChangedEventArgs();
 672
 673             e.FocusGained = focusGained;
 674
 675             if (_windowFocusChangedEventHandler2 != null)
 676             {
 677                 _windowFocusChangedEventHandler2(this, e);
 678             }
 679         }
 680
 681         private void OnTransitionEffect(IntPtr window, int state, int type)
 682         {
 683             //Tizen.Log.Fatal("NUITEST", $"OnTransitionEffect() called");
 684             if (window == global::System.IntPtr.Zero)
 685             {
 686                 //Tizen.Log.Error("NUI", $"OnTransitionEffect() IntPtr window is null!");
 687                 return;
 688             }
 689
 690             TransitionEffectArgs e = new TransitionEffectArgs();
 691
 692             e.State = (EffectStates)state;
 693             //Tizen.Log.Error("NUITEST", $"e.State={e.State}");
 694
 695             e.Type = (EffectTypes)type;
 696             //Tizen.Log.Error("NUITEST", $"e.Type={e.Type}");
 697
 698             if (transitionEffectHandler != null)
 699             {
 700                 //Tizen.Log.Fatal("NUITEST", $"Execute transitionEffectHandler(this, e)!!!");
 701                 transitionEffectHandler(this, e);
 702             }
 703             return;
 704         }
 705
 706         /// <summary>
 707         /// The focus changed event argument.
 708         /// </summary>
 709         /// <since_tizen> 3 </since_tizen>
 710         public class FocusChangedEventArgs : EventArgs
 711         {
 712             /// <summary>
 713             /// FocusGained flag.
 714             /// </summary>
 715             /// <since_tizen> 3 </since_tizen>
 716             public bool FocusGained
 717             {
 718                 get;
 719                 set;
 720             }
 721         }
 722
 723         /// <summary>
 724         /// The touch event argument.
 725         /// </summary>
 726         /// <since_tizen> 3 </since_tizen>
 727         public class TouchEventArgs : EventArgs
 728         {
 729             private Touch _touch;
 730
 731             /// <summary>
 732             /// Touch.
 733             /// </summary>
 734             /// <since_tizen> 3 </since_tizen>
 735             public Touch Touch
 736             {
 737                 get
 738                 {
 739                     return _touch;
 740                 }
 741                 set
 742                 {
 743                     _touch = value;
 744                 }
 745             }
 746         }
 747
 748         /// <summary>
 749         /// Wheel event arguments.
 750         /// </summary>
 751         /// <since_tizen> 3 </since_tizen>
 752         public class WheelEventArgs : EventArgs
 753         {
 754             private Wheel _wheel;
 755
 756             /// <summary>
 757             /// Wheel.
 758             /// </summary>
 759             /// <since_tizen> 3 </since_tizen>
 760             public Wheel Wheel
 761             {
 762                 get
 763                 {
 764                     return _wheel;
 765                 }
 766                 set
 767                 {
 768                     _wheel = value;
 769                 }
 770             }
 771         }
 772
 773         /// <summary>
 774         /// Key event arguments.
 775         /// </summary>
 776         /// <since_tizen> 3 </since_tizen>
 777         public class KeyEventArgs : EventArgs
 778         {
 779             private Key _key;
 780
 781             /// <summary>
 782             /// Key.
 783             /// </summary>
 784             /// <since_tizen> 3 </since_tizen>
 785             public Key Key
 786             {
 787                 get
 788                 {
 789                     return _key;
 790                 }
 791                 set
 792                 {
 793                     _key = value;
 794                 }
 795             }
 796         }
 797
 798         /// <summary>
 799         /// Feeds a key event into the window.
 800         /// This resized event arguments.
 801         /// </summary>
 802         /// <since_tizen> 3 </since_tizen>
 803         public class ResizedEventArgs : EventArgs
 804         {
 805             Size2D _windowSize;
 806
 807             /// <summary>
 808             /// This window size.
 809             /// </summary>
 810             /// <since_tizen> 4 </since_tizen>
 811             public Size2D WindowSize
 812             {
 813                 get
 814                 {
 815                     return _windowSize;
 816                 }
 817                 set
 818                 {
 819                     _windowSize = value;
 820                 }
 821             }
 822         }
 823
 824         /// <summary>
 825         /// Please do not use! this will be deprecated
 826         /// </summary>
 827         /// <since_tizen> 3 </since_tizen>
 828         [Obsolete("Please do not use! This will be deprecated! Please use FocusChangedEventArgs instead! " +
 829             "Like: " +
 830             "NUIApplication.GetDefaultWindow().FocusChanged = OnFocusChanged; " +
 831             "private void OnFocusChanged(object source, Window.FocusChangedEventArgs args) {...}")]
 832         [EditorBrowsable(EditorBrowsableState.Never)]
 833         public class WindowFocusChangedEventArgs : EventArgs
 834         {
 835             /// <summary>
 836             /// Please do not use! this will be deprecated
 837             /// </summary>
 838             /// <since_tizen> 3 </since_tizen>
 839             public bool FocusGained
 840             {
 841                 get;
 842                 set;
 843             }
 844         }
 845
 846         /// <summary>
 847         /// Contains and encapsulates Native Window handle.
 848         /// </summary>
 849         /// <since_tizen> 4 </since_tizen>
 850         public class SafeNativeWindowHandle : SafeHandle
 851         {
 852             /// <summary>
 853             /// Contructor, Native window handle is set to handle.
 854             /// </summary>
 855             /// <since_tizen> 4 </since_tizen>
 856             public SafeNativeWindowHandle() : base(IntPtr.Zero, false)
 857             {
 858                 SetHandle(NUIApplication.GetDefaultWindow().GetNativeWindowHandler());
 859             }
 860             /// <summary>
 861             /// Null check if the handle is valid or not.
 862             /// </summary>
 863             /// <since_tizen> 4 </since_tizen>
 864             public override bool IsInvalid
 865             {
 866                 get
 867                 {
 868                     return this.handle == IntPtr.Zero;
 869                 }
 870             }
 871             /// <summary>
 872             /// Release handle itself.
 873             /// </summary>
 874             /// <returns>true when released successfully.</returns>
 875             /// <since_tizen> 4 </since_tizen>
 876             protected override bool ReleaseHandle()
 877             {
 878                 return true;
 879             }
 880         }
 881
 882         /// <summary>
 883         /// TransitionEffectArgs
 884         /// </summary>
 885         [EditorBrowsable(EditorBrowsableState.Never)]
 886         public class TransitionEffectArgs : EventArgs
 887         {
 888             private EffectStates state;
 889             private EffectTypes type;
 890
 891             /// <summary>
 892             /// State
 893             /// </summary>
 894             [EditorBrowsable(EditorBrowsableState.Never)]
 895             public EffectStates State
 896             {
 897                 get
 898                 {
 899                     return state;
 900                 }
 901                 set
 902                 {
 903                     state = value;
 904                 }
 905             }
 906             /// <summary>
 907             /// Type
 908             /// </summary>
 909             [EditorBrowsable(EditorBrowsableState.Never)]
 910             public EffectTypes Type
 911             {
 912                 get
 913                 {
 914                     return type;
 915                 }
 916                 set
 917                 {
 918                     type = value;
 919                 }
 920             }
 921         }
 922
 923         private EventHandler<WheelEventArgs> DetentEventHandler;
 924
 925         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 926         private delegate void DetentEventCallbackType(IntPtr arg1);
 927
 928         private DetentEventCallbackType DetentEventCallback;
 929
 930         private void OnDetentEvent(IntPtr wheelEvent)
 931         {
 932             WheelEventArgs e = new WheelEventArgs();
 933
 934             if (wheelEvent != global::System.IntPtr.Zero)
 935             {
 936                 e.Wheel = Wheel.GetWheelFromPtr(wheelEvent);
 937             }
 938
 939             DetentEventHandler?.Invoke(this, e);
 940         }
 941
 942         /// <summary>
 943         /// VisibilityChangedArgs
 944         /// </summary>
 945         [EditorBrowsable(EditorBrowsableState.Never)]
 946         public class VisibilityChangedArgs : EventArgs
 947         {
 948             private bool visibility;
 949             /// <summary>
 950             /// Visibility
 951             /// </summary>
 952             [EditorBrowsable(EditorBrowsableState.Never)]
 953             public bool Visibility
 954             {
 955                 get => visibility;
 956                 set {
 957                     visibility = value;
 958                 }
 959             }
 960         }
 961
 962         private void OnVisibilityChanged(IntPtr window, bool visibility)
 963         {
 964             if (window == global::System.IntPtr.Zero)
 965             {
 966                 NUILog.Error("[ERR] OnVisibilityChanged() window is null");
 967                 return;
 968             }
 969
 970             VisibilityChangedArgs e = new VisibilityChangedArgs();
 971             e.Visibility = visibility;
 972             if (VisibilityChangedEventHandler != null)
 973             {
 974                 VisibilityChangedEventHandler.Invoke(this, e);
 975             }
 976         }
 977
 978         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 979         private delegate void VisibilityChangedEventCallbackType(IntPtr window, bool visibility);
 980         private VisibilityChangedEventCallbackType VisibilityChangedEventCallback;
 981         private event EventHandler<VisibilityChangedArgs> VisibilityChangedEventHandler;
 982         private WindowVisibilityChangedEvent VisibilityChangedEventSignal;
 983
 984         /// <summary>
 985         /// EffectStart
 986         /// </summary>
 987         [EditorBrowsable(EditorBrowsableState.Never)]
 988         public event EventHandler<VisibilityChangedArgs> VisibilityChanged
 989         {
 990             add
 991             {
 992                 if (VisibilityChangedEventHandler == null)
 993                 {
 994                     VisibilityChangedEventCallback = OnVisibilityChanged;
 995                     VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this);
 996                     VisibilityChangedEventSignal.Connect(VisibilityChangedEventCallback);
 997                 }
 998                 VisibilityChangedEventHandler += value;
 999             }
1000             remove
1001             {
1002                 VisibilityChangedEventHandler -= value;
1003                 if (VisibilityChangedEventHandler == null)
1004                 {
1005                     if(VisibilityChangedEventSignal != null)
1006                     {
1007                         if(VisibilityChangedEventSignal.Empty() == false)
1008                         {
1009                             VisibilityChangedEventSignal.Disconnect(VisibilityChangedEventCallback);
1010                         }
1011                     }
1012                 }
1013             }
1014         }
1015
1016         /// <summary>
1017         /// VisibiltyChangedSignalEmit
1018         /// </summary>
1019         [EditorBrowsable(EditorBrowsableState.Never)]
1020         public void VisibiltyChangedSignalEmit(bool visibility)
1021         {
1022             if(VisibilityChangedEventSignal == null)
1023             {
1024                 VisibilityChangedEventSignal = new WindowVisibilityChangedEvent(this);
1025             }
1026             VisibilityChangedEventSignal.Emit(this, visibility);
1027         }
1028
1029
1030
1031     }
1032 }