src/Tizen.NUI/src/public/BaseComponents/ViewEvent.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.Components;
  22
  23 namespace Tizen.NUI.BaseComponents
  24 {
  25     /// <summary>
  26     /// View is the base class for all views.
  27     /// </summary>
  28     /// <since_tizen> 3 </since_tizen>
  29     public partial class View
  30     {
  31         private EventHandler _offWindowEventHandler;
  32         private OffWindowEventCallbackType _offWindowEventCallback;
  33         private EventHandlerWithReturnType<object, WheelEventArgs, bool> _wheelEventHandler;
  34         private WheelEventCallbackType _wheelEventCallback;
  35         private EventHandlerWithReturnType<object, KeyEventArgs, bool> _keyEventHandler;
  36         private KeyCallbackType _keyCallback;
  37         private EventHandlerWithReturnType<object, TouchEventArgs, bool> _touchDataEventHandler;
  38         private TouchDataCallbackType _touchDataCallback;
  39         private EventHandlerWithReturnType<object, HoverEventArgs, bool> _hoverEventHandler;
  40         private HoverEventCallbackType _hoverEventCallback;
  41         private EventHandler<VisibilityChangedEventArgs> _visibilityChangedEventHandler;
  42         private VisibilityChangedEventCallbackType _visibilityChangedEventCallback;
  43         private EventHandler _keyInputFocusGainedEventHandler;
  44         private KeyInputFocusGainedCallbackType _keyInputFocusGainedCallback;
  45         private EventHandler _keyInputFocusLostEventHandler;
  46         private KeyInputFocusLostCallbackType _keyInputFocusLostCallback;
  47         private EventHandler _onRelayoutEventHandler;
  48         private OnRelayoutEventCallbackType _onRelayoutEventCallback;
  49         private EventHandler _onWindowEventHandler;
  50         private OnWindowEventCallbackType _onWindowEventCallback;
  51         private EventHandler<LayoutDirectionChangedEventArgs> _layoutDirectionChangedEventHandler;
  52         private LayoutDirectionChangedEventCallbackType _layoutDirectionChangedEventCallback;
  53         // Resource Ready Signal
  54         private EventHandler _resourcesLoadedEventHandler;
  55         private ResourcesLoadedCallbackType _ResourcesLoadedCallback;
  56         private EventHandler<BackgroundResourceLoadedEventArgs> _backgroundResourceLoadedEventHandler;
  57         private _backgroundResourceLoadedCallbackType _backgroundResourceLoadedCallback;
  58
  59         private OnWindowEventCallbackType _onWindowSendEventCallback;
  60
  61         private void SendViewAddedEventToWindow(IntPtr data)
  62         {
  63             NUIApplication.GetDefaultWindow()?.SendViewAdded(this);
  64         }
  65
  66         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  67         private delegate void OffWindowEventCallbackType(IntPtr control);
  68         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  69         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
  70         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  71         private delegate bool KeyCallbackType(IntPtr control, IntPtr keyEvent);
  72         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  73         private delegate bool TouchDataCallbackType(IntPtr view, IntPtr touchData);
  74         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  75         private delegate bool HoverEventCallbackType(IntPtr view, IntPtr hoverEvent);
  76         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  77         private delegate void VisibilityChangedEventCallbackType(IntPtr data, bool visibility, VisibilityChangeType type);
  78         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  79         private delegate void ResourcesLoadedCallbackType(IntPtr control);
  80         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  81         private delegate void _backgroundResourceLoadedCallbackType(IntPtr view);
  82         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  83         private delegate void KeyInputFocusGainedCallbackType(IntPtr control);
  84         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  85         private delegate void KeyInputFocusLostCallbackType(IntPtr control);
  86         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  87         private delegate void OnRelayoutEventCallbackType(IntPtr control);
  88         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  89         private delegate void OnWindowEventCallbackType(IntPtr control);
  90         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  91         private delegate void LayoutDirectionChangedEventCallbackType(IntPtr data, ViewLayoutDirectionType type);
  92
  93         /// <summary>
  94         /// Event when a child is removed.
  95         /// </summary>
  96         /// <since_tizen> 5 </since_tizen>
  97         public new event EventHandler<ChildRemovedEventArgs> ChildRemoved;
  98         /// <summary>
  99         /// Event when a child is added.
 100         /// </summary>
 101         /// <since_tizen> 5 </since_tizen>
 102         public new event EventHandler<ChildAddedEventArgs> ChildAdded;
 103
 104         /// <summary>
 105         /// An event for the KeyInputFocusGained signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 106         /// The KeyInputFocusGained signal is emitted when the control gets the key input focus.<br />
 107         /// </summary>
 108         /// <since_tizen> 3 </since_tizen>
 109         public event EventHandler FocusGained
 110         {
 111             add
 112             {
 113                 if (_keyInputFocusGainedEventHandler == null)
 114                 {
 115                     _keyInputFocusGainedCallback = OnKeyInputFocusGained;
 116                     this.KeyInputFocusGainedSignal().Connect(_keyInputFocusGainedCallback);
 117                 }
 118
 119                 _keyInputFocusGainedEventHandler += value;
 120             }
 121
 122             remove
 123             {
 124                 _keyInputFocusGainedEventHandler -= value;
 125
 126                 if (_keyInputFocusGainedEventHandler == null && KeyInputFocusGainedSignal().Empty() == false)
 127                 {
 128                     this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback);
 129                 }
 130             }
 131         }
 132
 133         /// <summary>
 134         /// An event for the KeyInputFocusLost signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 135         /// The KeyInputFocusLost signal is emitted when the control loses the key input focus.<br />
 136         /// </summary>
 137         /// <since_tizen> 3 </since_tizen>
 138         public event EventHandler FocusLost
 139         {
 140             add
 141             {
 142                 if (_keyInputFocusLostEventHandler == null)
 143                 {
 144                     _keyInputFocusLostCallback = OnKeyInputFocusLost;
 145                     this.KeyInputFocusLostSignal().Connect(_keyInputFocusLostCallback);
 146                 }
 147
 148                 _keyInputFocusLostEventHandler += value;
 149             }
 150
 151             remove
 152             {
 153                 _keyInputFocusLostEventHandler -= value;
 154
 155                 if (_keyInputFocusLostEventHandler == null && KeyInputFocusLostSignal().Empty() == false)
 156                 {
 157                     this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback);
 158                 }
 159             }
 160         }
 161
 162         /// <summary>
 163         /// An event for the KeyPressed signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 164         /// The KeyPressed signal is emitted when the key event is received.<br />
 165         /// </summary>
 166         /// <since_tizen> 3 </since_tizen>
 167         public event EventHandlerWithReturnType<object, KeyEventArgs, bool> KeyEvent
 168         {
 169             add
 170             {
 171                 if (_keyEventHandler == null)
 172                 {
 173                     _keyCallback = OnKeyEvent;
 174                     this.KeyEventSignal().Connect(_keyCallback);
 175                 }
 176
 177                 _keyEventHandler += value;
 178             }
 179
 180             remove
 181             {
 182                 _keyEventHandler -= value;
 183
 184                 if (_keyEventHandler == null && KeyEventSignal().Empty() == false)
 185                 {
 186                     this.KeyEventSignal().Disconnect(_keyCallback);
 187                 }
 188             }
 189         }
 190
 191         /// <summary>
 192         /// An event for the OnRelayout signal which can be used to subscribe or unsubscribe the event handler.<br />
 193         /// The OnRelayout signal is emitted after the size has been set on the view during relayout.<br />
 194         /// </summary>
 195         /// <since_tizen> 3 </since_tizen>
 196         public event EventHandler Relayout
 197         {
 198             add
 199             {
 200                 if (_onRelayoutEventHandler == null)
 201                 {
 202                     _onRelayoutEventCallback = OnRelayout;
 203                     this.OnRelayoutSignal().Connect(_onRelayoutEventCallback);
 204                 }
 205
 206                 _onRelayoutEventHandler += value;
 207             }
 208
 209             remove
 210             {
 211                 _onRelayoutEventHandler -= value;
 212
 213                 if (_onRelayoutEventHandler == null && OnRelayoutSignal().Empty() == false)
 214                 {
 215                     this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
 216                 }
 217
 218             }
 219         }
 220
 221         /// <summary>
 222         /// An event for the touched signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 223         /// The touched signal is emitted when the touch input is received.<br />
 224         /// </summary>
 225         /// <since_tizen> 3 </since_tizen>
 226         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> TouchEvent
 227         {
 228             add
 229             {
 230                 if (_touchDataEventHandler == null)
 231                 {
 232                     _touchDataCallback = OnTouch;
 233                     this.TouchSignal().Connect(_touchDataCallback);
 234                 }
 235
 236                 _touchDataEventHandler += value;
 237             }
 238
 239             remove
 240             {
 241                 _touchDataEventHandler -= value;
 242
 243                 if (_touchDataEventHandler == null && TouchSignal().Empty() == false)
 244                 {
 245                     this.TouchSignal().Disconnect(_touchDataCallback);
 246                 }
 247
 248             }
 249         }
 250
 251         /// <summary>
 252         /// An event for the hovered signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 253         /// The hovered signal is emitted when the hover input is received.<br />
 254         /// </summary>
 255         /// <since_tizen> 3 </since_tizen>
 256         public event EventHandlerWithReturnType<object, HoverEventArgs, bool> HoverEvent
 257         {
 258             add
 259             {
 260                 if (_hoverEventHandler == null)
 261                 {
 262                     _hoverEventCallback = OnHoverEvent;
 263                     this.HoveredSignal().Connect(_hoverEventCallback);
 264                 }
 265
 266                 _hoverEventHandler += value;
 267             }
 268
 269             remove
 270             {
 271                 _hoverEventHandler -= value;
 272
 273                 if (_hoverEventHandler == null && HoveredSignal().Empty() == false)
 274                 {
 275                     this.HoveredSignal().Disconnect(_hoverEventCallback);
 276                 }
 277
 278             }
 279         }
 280
 281         /// <summary>
 282         /// An event for the WheelMoved signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 283         /// The WheelMoved signal is emitted when the wheel event is received.<br />
 284         /// </summary>
 285         /// <since_tizen> 3 </since_tizen>
 286         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelEvent
 287         {
 288             add
 289             {
 290                 if (_wheelEventHandler == null)
 291                 {
 292                     _wheelEventCallback = OnWheelEvent;
 293                     this.WheelEventSignal().Connect(_wheelEventCallback);
 294                 }
 295                 _wheelEventHandler += value;
 296
 297                 if (WindowWheelEventHandler == null)
 298                 {
 299                     NUIApplication.GetDefaultWindow().WheelEvent += OnWindowWheelEvent;
 300                 }
 301                 WindowWheelEventHandler += value;
 302             }
 303
 304             remove
 305             {
 306                 _wheelEventHandler -= value;
 307                 if (_wheelEventHandler == null && WheelEventSignal().Empty() == false)
 308                 {
 309                     this.WheelEventSignal().Disconnect(_wheelEventCallback);
 310                 }
 311
 312                 WindowWheelEventHandler -= value;
 313                 if (WindowWheelEventHandler == null)
 314                 {
 315                     NUIApplication.GetDefaultWindow().WheelEvent -= OnWindowWheelEvent;
 316                 }
 317             }
 318         }
 319
 320         /// <summary>
 321         /// An event for the OnWindow signal which can be used to subscribe or unsubscribe the event handler.<br />
 322         /// The OnWindow signal is emitted after the view has been connected to the window.<br />
 323         /// </summary>
 324         /// <since_tizen> 3 </since_tizen>
 325         public event EventHandler AddedToWindow
 326         {
 327             add
 328             {
 329                 if (_onWindowEventHandler == null)
 330                 {
 331                     _onWindowEventCallback = OnWindow;
 332                     this.OnWindowSignal().Connect(_onWindowEventCallback);
 333                 }
 334
 335                 _onWindowEventHandler += value;
 336             }
 337
 338             remove
 339             {
 340                 _onWindowEventHandler -= value;
 341
 342                 if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false)
 343                 {
 344                     this.OnWindowSignal().Disconnect(_onWindowEventCallback);
 345                 }
 346             }
 347         }
 348
 349         /// <summary>
 350         /// An event for the OffWindow signal, which can be used to subscribe or unsubscribe the event handler.<br />
 351         /// OffWindow signal is emitted after the view has been disconnected from the window.<br />
 352         /// </summary>
 353         /// <since_tizen> 3 </since_tizen>
 354         public event EventHandler RemovedFromWindow
 355         {
 356             add
 357             {
 358                 if (_offWindowEventHandler == null)
 359                 {
 360                     _offWindowEventCallback = OffWindow;
 361                     this.OffWindowSignal().Connect(_offWindowEventCallback);
 362                 }
 363
 364                 _offWindowEventHandler += value;
 365             }
 366
 367             remove
 368             {
 369                 _offWindowEventHandler -= value;
 370
 371                 if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false)
 372                 {
 373                     this.OffWindowSignal().Disconnect(_offWindowEventCallback);
 374                 }
 375             }
 376         }
 377
 378         /// <summary>
 379         /// An event for visibility change which can be used to subscribe or unsubscribe the event handler.<br />
 380         /// This signal is emitted when the visible property of this or a parent view is changed.<br />
 381         /// </summary>
 382         /// <since_tizen> 3 </since_tizen>
 383         public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
 384         {
 385             add
 386             {
 387                 if (_visibilityChangedEventHandler == null)
 388                 {
 389                     _visibilityChangedEventCallback = OnVisibilityChanged;
 390                     VisibilityChangedSignal(this).Connect(_visibilityChangedEventCallback);
 391                 }
 392
 393                 _visibilityChangedEventHandler += value;
 394             }
 395
 396             remove
 397             {
 398                 _visibilityChangedEventHandler -= value;
 399
 400                 if (_visibilityChangedEventHandler == null && VisibilityChangedSignal(this).Empty() == false)
 401                 {
 402                     VisibilityChangedSignal(this).Disconnect(_visibilityChangedEventCallback);
 403                 }
 404             }
 405         }
 406
 407         /// <summary>
 408         /// Event for layout direction change which can be used to subscribe/unsubscribe the event handler.<br />
 409         /// This signal is emitted when the layout direction property of this or a parent view is changed.<br />
 410         /// </summary>
 411         /// <since_tizen> 4 </since_tizen>
 412         public event EventHandler<LayoutDirectionChangedEventArgs> LayoutDirectionChanged
 413         {
 414             add
 415             {
 416                 if (_layoutDirectionChangedEventHandler == null)
 417                 {
 418                     _layoutDirectionChangedEventCallback = OnLayoutDirectionChanged;
 419                     LayoutDirectionChangedSignal(this).Connect(_layoutDirectionChangedEventCallback);
 420                 }
 421
 422                 _layoutDirectionChangedEventHandler += value;
 423             }
 424
 425             remove
 426             {
 427                 _layoutDirectionChangedEventHandler -= value;
 428
 429                 if (_layoutDirectionChangedEventHandler == null && LayoutDirectionChangedSignal(this).Empty() == false)
 430                 {
 431                     LayoutDirectionChangedSignal(this).Disconnect(_layoutDirectionChangedEventCallback);
 432                 }
 433             }
 434         }
 435
 436         /// <summary>
 437         /// An event for the ResourcesLoadedSignal signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 438         /// This signal is emitted after all resources required by a view are loaded and ready.<br />
 439         /// </summary>
 440         /// <since_tizen> 3 </since_tizen>
 441         public event EventHandler ResourcesLoaded
 442         {
 443             add
 444             {
 445                 if (_resourcesLoadedEventHandler == null)
 446                 {
 447                     _ResourcesLoadedCallback = OnResourcesLoaded;
 448                     this.ResourcesLoadedSignal().Connect(_ResourcesLoadedCallback);
 449                 }
 450
 451                 _resourcesLoadedEventHandler += value;
 452             }
 453
 454             remove
 455             {
 456                 _resourcesLoadedEventHandler -= value;
 457
 458                 if (_resourcesLoadedEventHandler == null && ResourcesLoadedSignal().Empty() == false)
 459                 {
 460                     this.ResourcesLoadedSignal().Disconnect(_ResourcesLoadedCallback);
 461                 }
 462             }
 463         }
 464
 465         private EventHandler _backKeyPressed;
 466
 467         /// <summary>
 468         /// An event for getting notice when physical back key is pressed.<br />
 469         /// This event is emitted BackKey is up.<br />
 470         /// </summary>
 471         [EditorBrowsable(EditorBrowsableState.Never)]
 472         public event EventHandler BackKeyPressed
 473         {
 474             add
 475             {
 476                 _backKeyPressed += value;
 477                 BackKeyManager.Instance.Subscriber.Add(this);
 478             }
 479
 480             remove
 481             {
 482                 BackKeyManager.Instance.Subscriber.Remove(this);
 483                 _backKeyPressed -= value;
 484             }
 485         }
 486
 487         /// <summary>
 488         /// Function for emitting BackKeyPressed event outside of View instance
 489         /// </summary>
 490         [EditorBrowsable(EditorBrowsableState.Never)]
 491         internal void EmitBackKeyPressed()
 492         {
 493             _backKeyPressed.Invoke(this,null);
 494         }
 495
 496
 497         internal event EventHandler<BackgroundResourceLoadedEventArgs> BackgroundResourceLoaded
 498         {
 499             add
 500             {
 501                 if (_backgroundResourceLoadedEventHandler == null)
 502                 {
 503                     _backgroundResourceLoadedCallback = OnBackgroundResourceLoaded;
 504                     this.ResourcesLoadedSignal().Connect(_backgroundResourceLoadedCallback);
 505                 }
 506
 507                 _backgroundResourceLoadedEventHandler += value;
 508             }
 509             remove
 510             {
 511                 _backgroundResourceLoadedEventHandler -= value;
 512
 513                 if (_backgroundResourceLoadedEventHandler == null && ResourcesLoadedSignal().Empty() == false)
 514                 {
 515                     this.ResourcesLoadedSignal().Disconnect(_backgroundResourceLoadedCallback);
 516                 }
 517             }
 518         }
 519
 520         internal TouchDataSignal TouchSignal()
 521         {
 522             TouchDataSignal ret = new TouchDataSignal(Interop.ActorSignal.Actor_TouchSignal(swigCPtr), false);
 523             if (NDalicPINVOKE.SWIGPendingException.Pending)
 524                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 525             return ret;
 526         }
 527
 528         internal HoverSignal HoveredSignal()
 529         {
 530             HoverSignal ret = new HoverSignal(Interop.ActorSignal.Actor_HoveredSignal(swigCPtr), false);
 531             if (NDalicPINVOKE.SWIGPendingException.Pending)
 532                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 533             return ret;
 534         }
 535
 536         internal WheelSignal WheelEventSignal()
 537         {
 538             WheelSignal ret = new WheelSignal(Interop.ActorSignal.Actor_WheelEventSignal(swigCPtr), false);
 539             if (NDalicPINVOKE.SWIGPendingException.Pending)
 540                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 541             return ret;
 542         }
 543
 544         internal ViewSignal OnWindowSignal()
 545         {
 546             ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OnStageSignal(swigCPtr), false);
 547             if (NDalicPINVOKE.SWIGPendingException.Pending)
 548                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 549             return ret;
 550         }
 551
 552         internal ViewSignal OffWindowSignal()
 553         {
 554             ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OffStageSignal(swigCPtr), false);
 555             if (NDalicPINVOKE.SWIGPendingException.Pending)
 556                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 557             return ret;
 558         }
 559
 560         internal ViewSignal OnRelayoutSignal()
 561         {
 562             ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OnRelayoutSignal(swigCPtr), false);
 563             if (NDalicPINVOKE.SWIGPendingException.Pending)
 564                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 565             return ret;
 566         }
 567
 568         internal ViewVisibilityChangedSignal VisibilityChangedSignal(View view)
 569         {
 570             ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(Interop.NDalic.VisibilityChangedSignal(View.getCPtr(view)), false);
 571             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 572             return ret;
 573         }
 574
 575         internal ViewLayoutDirectionChangedSignal LayoutDirectionChangedSignal(View view)
 576         {
 577             ViewLayoutDirectionChangedSignal ret = new ViewLayoutDirectionChangedSignal(Interop.Layout.LayoutDirectionChangedSignal(View.getCPtr(view)), false);
 578             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 579             return ret;
 580         }
 581
 582         internal ViewSignal ResourcesLoadedSignal()
 583         {
 584             ViewSignal ret = new ViewSignal(Interop.View.ResourceReadySignal(swigCPtr), false);
 585             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 586             return ret;
 587         }
 588
 589         internal ControlKeySignal KeyEventSignal()
 590         {
 591             ControlKeySignal ret = new ControlKeySignal(Interop.ViewSignal.View_KeyEventSignal(swigCPtr), false);
 592             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 593             return ret;
 594         }
 595
 596         internal KeyInputFocusSignal KeyInputFocusGainedSignal()
 597         {
 598             KeyInputFocusSignal ret = new KeyInputFocusSignal(Interop.ViewSignal.View_KeyInputFocusGainedSignal(swigCPtr), false);
 599             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 600             return ret;
 601         }
 602
 603         internal KeyInputFocusSignal KeyInputFocusLostSignal()
 604         {
 605             KeyInputFocusSignal ret = new KeyInputFocusSignal(Interop.ViewSignal.View_KeyInputFocusLostSignal(swigCPtr), false);
 606             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 607             return ret;
 608         }
 609
 610         private void OnSize2DChanged(int width, int height)
 611         {
 612             Size2D = new Size2D(width, height);
 613         }
 614
 615         private void OnMinimumSizeChanged(int width, int height)
 616         {
 617             MinimumSize = new Size2D(width, height);
 618         }
 619
 620         private void OnMaximumSizeChanged(int width, int height)
 621         {
 622             MaximumSize = new Size2D(width, height);
 623         }
 624
 625         private void OnPosition2DChanged(int x, int y)
 626         {
 627             Position2D = new Position2D(x, y);
 628         }
 629
 630         private void OnSizeChanged(float width, float height, float depth)
 631         {
 632             Size = new Size(width, height, depth);
 633         }
 634
 635         private void OnPositionChanged(float x, float y, float z)
 636         {
 637             Position = new Position(x, y, z);
 638         }
 639
 640         private void OnParentOriginChanged(float x, float y, float z)
 641         {
 642             ParentOrigin = new Position(x, y, z);
 643         }
 644
 645         private void OnPivotPointChanged(float x, float y, float z)
 646         {
 647             PivotPoint = new Position(x, y, z);
 648         }
 649
 650         private void OnImageShadowChanged(ShadowBase instance)
 651         {
 652             ImageShadow = (ImageShadow)instance;
 653         }
 654
 655         private void OnBoxShadowChanged(ShadowBase instance)
 656         {
 657             BoxShadow = (Shadow)instance;
 658         }
 659
 660         private void OnBackgroundImageBorderChanged(int left, int right, int bottom, int top)
 661         {
 662             BackgroundImageBorder = new Rectangle(left, right, bottom, top);
 663         }
 664
 665         private void OnKeyInputFocusGained(IntPtr view)
 666         {
 667             if (_keyInputFocusGainedEventHandler != null)
 668             {
 669                 _keyInputFocusGainedEventHandler(this, null);
 670             }
 671         }
 672
 673         private void OnKeyInputFocusLost(IntPtr view)
 674         {
 675             if (_keyInputFocusLostEventHandler != null)
 676             {
 677                 _keyInputFocusLostEventHandler(this, null);
 678             }
 679         }
 680
 681         private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
 682         {
 683             if (keyEvent == global::System.IntPtr.Zero)
 684             {
 685                 NUILog.Error("keyEvent should not be null!");
 686                 return true;
 687             }
 688
 689             KeyEventArgs e = new KeyEventArgs();
 690
 691             bool result = false;
 692
 693             e.Key = Tizen.NUI.Key.GetKeyFromPtr(keyEvent);
 694
 695             if (_keyEventHandler != null)
 696             {
 697                 Delegate[] delegateList = _keyEventHandler.GetInvocationList();
 698
 699                 // Oring the result of each callback.
 700                 foreach (EventHandlerWithReturnType<object, KeyEventArgs, bool> del in delegateList)
 701                 {
 702                     result |= del(this, e);
 703                 }
 704             }
 705
 706             return result;
 707         }
 708
 709         // Callback for View OnRelayout signal
 710         private void OnRelayout(IntPtr data)
 711         {
 712             if (_onRelayoutEventHandler != null)
 713             {
 714                 _onRelayoutEventHandler(this, null);
 715             }
 716         }
 717
 718         // Callback for View TouchSignal
 719         private bool OnTouch(IntPtr view, IntPtr touchData)
 720         {
 721             if (touchData == global::System.IntPtr.Zero)
 722             {
 723                 NUILog.Error("touchData should not be null!");
 724                 return true;
 725             }
 726
 727             TouchEventArgs e = new TouchEventArgs();
 728
 729             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
 730
 731             if (_touchDataEventHandler != null)
 732             {
 733                 return _touchDataEventHandler(this, e);
 734             }
 735             return false;
 736         }
 737
 738         // Callback for View Hover signal
 739         private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
 740         {
 741             if (hoverEvent == global::System.IntPtr.Zero)
 742             {
 743                 NUILog.Error("hoverEvent should not be null!");
 744                 return true;
 745             }
 746
 747             HoverEventArgs e = new HoverEventArgs();
 748
 749             e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);
 750
 751             if (_hoverEventHandler != null)
 752             {
 753                 return _hoverEventHandler(this, e);
 754             }
 755             return false;
 756         }
 757
 758         // Callback for View Wheel signal
 759         private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
 760         {
 761             if (wheelEvent == global::System.IntPtr.Zero)
 762             {
 763                 NUILog.Error("wheelEvent should not be null!");
 764                 return true;
 765             }
 766
 767             WheelEventArgs e = new WheelEventArgs();
 768
 769             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
 770
 771             if (_wheelEventHandler != null)
 772             {
 773                 return _wheelEventHandler(this, e);
 774             }
 775             return false;
 776         }
 777
 778         // Callback for View OnWindow signal
 779         private void OnWindow(IntPtr data)
 780         {
 781             if (_onWindowEventHandler != null)
 782             {
 783                 _onWindowEventHandler(this, null);
 784             }
 785         }
 786
 787         // Callback for View OffWindow signal
 788         private void OffWindow(IntPtr data)
 789         {
 790             if (_offWindowEventHandler != null)
 791             {
 792                 _offWindowEventHandler(this, null);
 793             }
 794         }
 795
 796         // Callback for View visibility change signal
 797         private void OnVisibilityChanged(IntPtr data, bool visibility, VisibilityChangeType type)
 798         {
 799             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
 800             if (data != null)
 801             {
 802                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
 803             }
 804             e.Visibility = visibility;
 805             e.Type = type;
 806
 807             if (_visibilityChangedEventHandler != null)
 808             {
 809                 _visibilityChangedEventHandler(this, e);
 810             }
 811         }
 812
 813         // Callback for View layout direction change signal
 814         private void OnLayoutDirectionChanged(IntPtr data, ViewLayoutDirectionType type)
 815         {
 816             LayoutDirectionChangedEventArgs e = new LayoutDirectionChangedEventArgs();
 817             if (data != null)
 818             {
 819                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
 820             }
 821             e.Type = type;
 822
 823             if (_layoutDirectionChangedEventHandler != null)
 824             {
 825                 _layoutDirectionChangedEventHandler(this, e);
 826             }
 827         }
 828
 829         private void OnResourcesLoaded(IntPtr view)
 830         {
 831             if (_resourcesLoadedEventHandler != null)
 832             {
 833                 _resourcesLoadedEventHandler(this, null);
 834             }
 835         }
 836
 837         private void OnBackgroundResourceLoaded(IntPtr view)
 838         {
 839             BackgroundResourceLoadedEventArgs e = new BackgroundResourceLoadedEventArgs();
 840             e.Status = (ResourceLoadingStatusType)Interop.View.View_GetVisualResourceStatus(this.swigCPtr, Property.BACKGROUND);
 841
 842             if (_backgroundResourceLoadedEventHandler != null)
 843             {
 844                 _backgroundResourceLoadedEventHandler(this, e);
 845             }
 846         }
 847
 848         /// <summary>
 849         /// Event argument passed through the ChildAdded event.
 850         /// </summary>
 851         /// <since_tizen> 5 </since_tizen>
 852         public class ChildAddedEventArgs : EventArgs
 853         {
 854             /// <summary>
 855             /// Added child view at moment.
 856             /// </summary>
 857             /// <since_tizen> 5 </since_tizen>
 858             public View Added { get; set; }
 859         }
 860
 861         /// <summary>
 862         /// Event argument passed through the ChildRemoved event.
 863         /// </summary>
 864         /// <since_tizen> 5 </since_tizen>
 865         public class ChildRemovedEventArgs : EventArgs
 866         {
 867             /// <summary>
 868             /// Removed child view at moment.
 869             /// </summary>
 870             /// <since_tizen> 5 </since_tizen>
 871             public View Removed { get; set; }
 872         }
 873
 874         /// <summary>
 875         /// Event arguments that passed via the KeyEvent signal.
 876         /// </summary>
 877         /// <since_tizen> 3 </since_tizen>
 878         public class KeyEventArgs : EventArgs
 879         {
 880             private Key _key;
 881
 882             /// <summary>
 883             /// Key - is the key sent to the view.
 884             /// </summary>
 885             /// <since_tizen> 3 </since_tizen>
 886             public Key Key
 887             {
 888                 get
 889                 {
 890                     return _key;
 891                 }
 892                 set
 893                 {
 894                     _key = value;
 895                 }
 896             }
 897         }
 898
 899         /// <summary>
 900         /// Event arguments that passed via the touch signal.
 901         /// </summary>
 902         /// <since_tizen> 3 </since_tizen>
 903         public class TouchEventArgs : EventArgs
 904         {
 905             private Touch _touch;
 906
 907             /// <summary>
 908             /// Touch - contains the information of touch points.
 909             /// </summary>
 910             /// <since_tizen> 3 </since_tizen>
 911             public Touch Touch
 912             {
 913                 get
 914                 {
 915                     return _touch;
 916                 }
 917                 set
 918                 {
 919                     _touch = value;
 920                 }
 921             }
 922         }
 923
 924         /// <summary>
 925         /// Event arguments that passed via the hover signal.
 926         /// </summary>
 927         /// <since_tizen> 3 </since_tizen>
 928         public class HoverEventArgs : EventArgs
 929         {
 930             private Hover _hover;
 931
 932             /// <summary>
 933             /// Hover - contains touch points that represent the points that are currently being hovered or the points where a hover has stopped.
 934             /// </summary>
 935             /// <since_tizen> 3 </since_tizen>
 936             public Hover Hover
 937             {
 938                 get
 939                 {
 940                     return _hover;
 941                 }
 942                 set
 943                 {
 944                     _hover = value;
 945                 }
 946             }
 947         }
 948
 949         /// <summary>
 950         /// Event arguments that passed via the wheel signal.
 951         /// </summary>
 952         /// <since_tizen> 3 </since_tizen>
 953         public class WheelEventArgs : EventArgs
 954         {
 955             private Wheel _wheel;
 956
 957             /// <summary>
 958             /// WheelEvent - store a wheel rolling type: MOUSE_WHEEL or CUSTOM_WHEEL.
 959             /// </summary>
 960             /// <since_tizen> 3 </since_tizen>
 961             public Wheel Wheel
 962             {
 963                 get
 964                 {
 965                     return _wheel;
 966                 }
 967                 set
 968                 {
 969                     _wheel = value;
 970                 }
 971             }
 972         }
 973
 974         /// <summary>
 975         /// Event arguments of visibility changed.
 976         /// </summary>
 977         /// <since_tizen> 3 </since_tizen>
 978         public class VisibilityChangedEventArgs : EventArgs
 979         {
 980             private View _view;
 981             private bool _visibility;
 982             private VisibilityChangeType _type;
 983
 984             /// <summary>
 985             /// The view, or child of view, whose visibility has changed.
 986             /// </summary>
 987             /// <since_tizen> 3 </since_tizen>
 988             public View View
 989             {
 990                 get
 991                 {
 992                     return _view;
 993                 }
 994                 set
 995                 {
 996                     _view = value;
 997                 }
 998             }
 999
1000             /// <summary>
1001             /// Whether the view is now visible or not.
1002             /// </summary>
1003             /// <since_tizen> 3 </since_tizen>
1004             public bool Visibility
1005             {
1006                 get
1007                 {
1008                     return _visibility;
1009                 }
1010                 set
1011                 {
1012                     _visibility = value;
1013                 }
1014             }
1015
1016             /// <summary>
1017             /// Whether the view's visible property has changed or a parent's.
1018             /// </summary>
1019             /// <since_tizen> 3 </since_tizen>
1020             public VisibilityChangeType Type
1021             {
1022                 get
1023                 {
1024                     return _type;
1025                 }
1026                 set
1027                 {
1028                     _type = value;
1029                 }
1030             }
1031         }
1032
1033         /// <summary>
1034         /// Event arguments of layout direction changed.
1035         /// </summary>
1036         /// <since_tizen> 4 </since_tizen>
1037         public class LayoutDirectionChangedEventArgs : EventArgs
1038         {
1039             private View _view;
1040             private ViewLayoutDirectionType _type;
1041
1042             /// <summary>
1043             /// The view, or child of view, whose layout direction has changed.
1044             /// </summary>
1045             /// <since_tizen> 4 </since_tizen>
1046             public View View
1047             {
1048                 get
1049                 {
1050                     return _view;
1051                 }
1052                 set
1053                 {
1054                     _view = value;
1055                 }
1056             }
1057
1058             /// <summary>
1059             /// Whether the view's layout direction property has changed or a parent's.
1060             /// </summary>
1061             /// <since_tizen> 4 </since_tizen>
1062             public ViewLayoutDirectionType Type
1063             {
1064                 get
1065                 {
1066                     return _type;
1067                 }
1068                 set
1069                 {
1070                     _type = value;
1071                 }
1072             }
1073         }
1074
1075         internal class BackgroundResourceLoadedEventArgs : EventArgs
1076         {
1077             private ResourceLoadingStatusType status = ResourceLoadingStatusType.Invalid;
1078             public ResourceLoadingStatusType Status
1079             {
1080                 get
1081                 {
1082                     return status;
1083                 }
1084                 set
1085                 {
1086                     status = value;
1087                 }
1088             }
1089         }
1090
1091         /// <summary>
1092         /// The class represents the information of the situation where the View's control state changes.
1093         /// </summary>
1094         [EditorBrowsable(EditorBrowsableState.Never)]
1095         public class ControlStateChangedEventArgs : EventArgs
1096         {
1097             /// <summary>
1098             /// Create an instance with mandatory fields.
1099             /// </summary>
1100             /// <param name="previousState">The previous control state.</param>
1101             /// <param name="currentState">The current control state.</param>
1102             [EditorBrowsable(EditorBrowsableState.Never)]
1103             public ControlStateChangedEventArgs(ControlState previousState, ControlState currentState)
1104             {
1105                 PreviousState = previousState;
1106                 CurrentState = currentState;
1107             }
1108
1109             /// <summary>
1110             /// The previous control state.
1111             /// </summary>
1112             [EditorBrowsable(EditorBrowsableState.Never)]
1113             public ControlState PreviousState { get; }
1114
1115             /// <summary>
1116             /// The current control state.
1117             /// </summary>
1118             [EditorBrowsable(EditorBrowsableState.Never)]
1119             public ControlState CurrentState { get; }
1120         }
1121
1122         private EventHandlerWithReturnType<object, WheelEventArgs, bool> WindowWheelEventHandler;
1123         private void OnWindowWheelEvent(object sender, Window.WheelEventArgs e)
1124         {
1125             if(e != null)
1126             {
1127                 if(e.Wheel.Type == Wheel.WheelType.CustomWheel)
1128                 {
1129                     var arg = new WheelEventArgs()
1130                     {
1131                         Wheel = e.Wheel,
1132                     };
1133                     WindowWheelEventHandler?.Invoke(this, arg);
1134                 }
1135             }
1136         }
1137
1138     }
1139 }