plugins/dali-swig/SWIG/events/control-event.i

   1 /*
   2  * Copyright (c) 2016 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 %define CONTROL_EVENTHANDLER_TYPEMAP_EVENTARG(NameSpace, ClassName)
  19   %typemap(csimports) NameSpace::ClassName %{
  20     using System;
  21     using System.Runtime.InteropServices;
  22
  23     %}
  24
  25     %enddef
  26
  27 %define CONTROL_EVENTHANDLER_TYPEMAP_HELPER(NameSpace, ClassName)
  28   %typemap(cscode) NameSpace::ClassName %{
  29
  30
  31     /**
  32      * @brief Event arguments that passed via KeyInputFocusGained signal
  33      *
  34      */
  35     public class KeyInputFocusGainedEventArgs : EventArgs
  36     {
  37       private View _view;
  38
  39       /**
  40        * @brief View - is the view that gets Key Input Focus
  41        *
  42        */
  43       public View View
  44       {
  45         get
  46         {
  47           return _view;
  48         }
  49         set
  50         {
  51           _view = value;
  52         }
  53       }
  54     }
  55
  56     /**
  57      * @brief Event arguments that passed via KeyInputFocusLost signal
  58      *
  59      */
  60     public class KeyInputFocusLostEventArgs : EventArgs
  61     {
  62       private View _view;
  63
  64       /**
  65        * @brief View - is the view that loses Key Input Focus
  66        *
  67        */
  68       public View View
  69       {
  70         get
  71         {
  72           return _view;
  73         }
  74         set
  75         {
  76           _view = value;
  77         }
  78       }
  79     }
  80
  81     /**
  82      * @brief Event arguments that passed via KeyEvent signal
  83      *
  84      */
  85     public class KeyEventArgs : EventArgs
  86     {
  87       private View _view;
  88       private KeyEvent _keyEvent;
  89
  90       /**
  91        * @brief View - is the view that recieves the keyevent.
  92        *
  93        */
  94       public View View
  95       {
  96         get
  97         {
  98           return _view;
  99         }
 100         set
 101         {
 102           _view = value;
 103         }
 104       }
 105
 106       /**
 107        * @brief KeyEvent - is the keyevent sent to the View.
 108        *
 109        */
 110       public KeyEvent KeyEvent
 111       {
 112         get
 113         {
 114           return _keyEvent;
 115         }
 116         set
 117         {
 118           _keyEvent = value;
 119         }
 120       }
 121     }
 122
 123     /**
 124       * @brief Event arguments that passed via OnRelayout signal
 125       *
 126       */
 127     public class OnRelayoutEventArgs : EventArgs
 128     {
 129       private View _view;
 130
 131       /**
 132         * @brief View - is the view that is being resized upon relayout
 133         *
 134         */
 135       public View View
 136       {
 137         get
 138         {
 139           return _view;
 140         }
 141         set
 142         {
 143           _view = value;
 144         }
 145       }
 146     }
 147
 148
 149     /**
 150       * @brief Event arguments that passed via Touch signal
 151       *
 152       */
 153     public class TouchEventArgs : EventArgs
 154     {
 155        private View _view;
 156        private TouchData _touchData;
 157
 158       /**
 159         * @brief View - is the view that is being touched
 160         *
 161         */
 162       public View View
 163       {
 164         get
 165         {
 166           return _view;
 167         }
 168         set
 169         {
 170           _view = value;
 171         }
 172       }
 173
 174       /**
 175         * @brief TouchData - contains the information of touch points
 176         *
 177         */
 178       public TouchData TouchData
 179       {
 180         get
 181         {
 182           return _touchData;
 183         }
 184         set
 185         {
 186           _touchData = value;
 187         }
 188       }
 189     }
 190
 191     /**
 192       * @brief Event arguments that passed via Hover signal
 193       *
 194       */
 195     public class HoverEventArgs : EventArgs
 196     {
 197     private View _view;
 198     private HoverEvent _hoverEvent;
 199
 200       /**
 201         * @brief View - is the view that is being hovered
 202         *
 203         */
 204       public View View
 205       {
 206         get
 207         {
 208           return _view;
 209         }
 210         set
 211         {
 212           _view = value;
 213         }
 214       }
 215
 216       /**
 217         * @brief HoverEvent - contains touch points that represent the points
 218         * that are currently being hovered or the points where a hover has stopped
 219         *
 220         */
 221       public HoverEvent HoverEvent
 222       {
 223         get
 224         {
 225           return _hoverEvent;
 226         }
 227         set
 228         {
 229           _hoverEvent = value;
 230         }
 231       }
 232     }
 233
 234     /**
 235       * @brief Event arguments that passed via Wheel signal
 236       *
 237       */
 238     public class WheelEventArgs : EventArgs
 239     {
 240     private View _view;
 241     private WheelEvent _wheelEvent;
 242
 243       /**
 244         * @brief View - is the view that is being wheeled
 245         *
 246         */
 247       public View View
 248       {
 249         get
 250         {
 251           return _view;
 252         }
 253         set
 254         {
 255           _view = value;
 256         }
 257       }
 258
 259       /**
 260         * @brief WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
 261         *
 262         */
 263       public WheelEvent WheelEvent
 264       {
 265         get
 266         {
 267           return _wheelEvent;
 268         }
 269         set
 270         {
 271           _wheelEvent = value;
 272         }
 273       }
 274     }
 275
 276     /**
 277       * @brief Event arguments that passed via OnStage signal
 278       *
 279       */
 280     public class OnStageEventArgs : EventArgs
 281     {
 282     private View _view;
 283
 284       /**
 285         * @brief View - is the view that is being connected to the stage
 286         *
 287         */
 288       public View View
 289       {
 290         get
 291         {
 292           return _view;
 293         }
 294         set
 295         {
 296           _view = value;
 297         }
 298       }
 299     }
 300
 301     /**
 302       * @brief Event arguments that passed via OffStage signal
 303       *
 304       */
 305     public class OffStageEventArgs : EventArgs
 306     {
 307     private View _view;
 308
 309       /**
 310         * @brief View - is the view that is being disconnected from the stage
 311         *
 312         */
 313       public View View
 314       {
 315         get
 316         {
 317           return _view;
 318         }
 319         set
 320         {
 321           _view = value;
 322         }
 323       }
 324     }
 325
 326     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 327     private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
 328     private DaliEventHandler<object,KeyInputFocusGainedEventArgs> _KeyInputFocusGainedEventHandler;
 329     private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
 330
 331     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 332     private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
 333     private DaliEventHandler<object,KeyInputFocusLostEventArgs> _KeyInputFocusLostEventHandler;
 334     private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
 335
 336     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 337     private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr keyEvent);
 338     private DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> _KeyEventHandler;
 339     private KeyCallbackDelegate _KeyCallbackDelegate;
 340
 341     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 342     private delegate void OnRelayoutEventCallbackDelegate(IntPtr control);
 343     private DaliEventHandler<object,OnRelayoutEventArgs> _viewOnRelayoutEventHandler;
 344     private OnRelayoutEventCallbackDelegate _viewOnRelayoutEventCallbackDelegate;
 345
 346     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 347     private delegate bool TouchCallbackDelegate(IntPtr view, IntPtr touchData);
 348     private DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _viewTouchDataEventHandler;
 349     private TouchCallbackDelegate _viewTouchDataCallbackDelegate;
 350
 351     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 352     private delegate bool HoverEventCallbackDelegate(IntPtr view, IntPtr hoverEvent);
 353     private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _viewHoverEventHandler;
 354     private HoverEventCallbackDelegate _viewHoverEventCallbackDelegate;
 355
 356     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 357     private delegate bool WheelEventCallbackDelegate(IntPtr view, IntPtr wheelEvent);
 358     private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _viewWheelEventHandler;
 359     private WheelEventCallbackDelegate _viewWheelEventCallbackDelegate;
 360
 361     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 362     private delegate void OnStageEventCallbackDelegate(IntPtr control);
 363     private DaliEventHandler<object,OnStageEventArgs> _viewOnStageEventHandler;
 364     private OnStageEventCallbackDelegate _viewOnStageEventCallbackDelegate;
 365
 366     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 367     private delegate void OffStageEventCallbackDelegate(IntPtr control);
 368     private DaliEventHandler<object,OffStageEventArgs> _viewOffStageEventHandler;
 369     private OffStageEventCallbackDelegate _viewOffStageEventCallbackDelegate;
 370
 371     /**
 372      * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
 373      * (in the type of KeyInputFocusGainedEventHandler-DaliEventHandler<object,KeyInputFocusGainedEventArgs>)
 374      * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
 375      */
 376     public event DaliEventHandler<object,KeyInputFocusGainedEventArgs> KeyInputFocusGained
 377     {
 378       add
 379       {
 380         lock(this)
 381         {
 382           // Restricted to only one listener
 383           if (_KeyInputFocusGainedEventHandler == null)
 384           {
 385             _KeyInputFocusGainedEventHandler += value;
 386             Console.WriteLine("View Keyevent EVENT Locked....");
 387             _KeyInputFocusGainedCallbackDelegate = new KeyInputFocusGainedCallbackDelegate(OnKeyInputFocusGained);
 388             this.KeyInputFocusGainedSignal().Connect(_KeyInputFocusGainedCallbackDelegate);
 389           }
 390         }
 391       }
 392
 393       remove
 394       {
 395         lock(this)
 396         {
 397           if (_KeyInputFocusGainedEventHandler != null)
 398           {
 399             this.KeyInputFocusGainedSignal().Disconnect(_KeyInputFocusGainedCallbackDelegate);
 400           }
 401
 402           _KeyInputFocusGainedEventHandler -= value;
 403         }
 404       }
 405     }
 406
 407     private void OnKeyInputFocusGained(IntPtr view)
 408     {
 409       KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
 410       Console.WriteLine("View Keyevent ....");
 411       // Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
 412       e.View = Dali.View.GetViewFromPtr(view);
 413
 414       if (_KeyInputFocusGainedEventHandler != null)
 415       {
 416         //here we send all data to user event handlers
 417         _KeyInputFocusGainedEventHandler(this, e);
 418       }
 419
 420     }
 421
 422     /**
 423      * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
 424      * (in the type of KeyInputFocusLostEventHandler-DaliEventHandler<object,KeyInputFocusLostEventArgs>)
 425      * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
 426      */
 427     public event DaliEventHandler<object,KeyInputFocusLostEventArgs> KeyInputFocusLost
 428     {
 429       add
 430       {
 431         lock(this)
 432         {
 433           // Restricted to only one listener
 434           if (_KeyInputFocusLostEventHandler == null)
 435           {
 436             _KeyInputFocusLostEventHandler += value;
 437
 438             _KeyInputFocusLostCallbackDelegate = new KeyInputFocusLostCallbackDelegate(OnKeyInputFocusLost);
 439             this.KeyInputFocusLostSignal().Connect(_KeyInputFocusLostCallbackDelegate);
 440           }
 441         }
 442       }
 443
 444       remove
 445       {
 446         lock(this)
 447         {
 448           if (_KeyInputFocusLostEventHandler != null)
 449           {
 450             this.KeyInputFocusLostSignal().Disconnect(_KeyInputFocusLostCallbackDelegate);
 451           }
 452
 453           _KeyInputFocusLostEventHandler -= value;
 454         }
 455       }
 456     }
 457
 458     private void OnKeyInputFocusLost(IntPtr view)
 459     {
 460       KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
 461
 462       // Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
 463       e.View = Dali.View.GetViewFromPtr(view);
 464
 465       if (_KeyInputFocusLostEventHandler != null)
 466       {
 467         //here we send all data to user event handlers
 468         _KeyInputFocusLostEventHandler(this, e);
 469       }
 470     }
 471
 472     /**
 473      * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
 474      * (in the type of KeyEventEventHandler-DaliEventHandlerWithReturnType<object,KeyEventArgs,bool>)
 475      * provided by the user. KeyPressed signal is emitted when key event is received.
 476      */
 477     public event DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> KeyPressed
 478     {
 479       add
 480       {
 481         lock(this)
 482         {
 483           // Restricted to only one listener
 484           if (_KeyEventHandler == null)
 485           {
 486             _KeyEventHandler += value;
 487
 488             _KeyCallbackDelegate = new KeyCallbackDelegate(OnKeyEvent);
 489             this.KeyEventSignal().Connect(_KeyCallbackDelegate);
 490           }
 491         }
 492       }
 493
 494       remove
 495       {
 496         lock(this)
 497         {
 498           if (_KeyEventHandler != null)
 499           {
 500             this.KeyEventSignal().Disconnect(_KeyCallbackDelegate);
 501           }
 502
 503           _KeyEventHandler -= value;
 504         }
 505       }
 506     }
 507
 508     private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
 509     {
 510       KeyEventArgs e = new KeyEventArgs();
 511
 512       // Populate all members of "e" (KeyEventArgs) with real data
 513       e.View = Dali.View.GetViewFromPtr(view);
 514       e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr(keyEvent);
 515
 516       if (_KeyEventHandler != null)
 517       {
 518         //here we send all data to user event handlers
 519         return _KeyEventHandler(this, e);
 520       }
 521       return false;
 522
 523     }
 524
 525     /**
 526       * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
 527       * (in the type of OnRelayoutEventHandler) provided by the user.
 528       * OnRelayout signal is emitted after the size has been set on the view during relayout.
 529       */
 530     public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
 531     {
 532       add
 533       {
 534         lock(this)
 535         {
 536           // Restricted to only one listener
 537           if (_viewOnRelayoutEventHandler == null)
 538           {
 539             _viewOnRelayoutEventHandler += value;
 540             Console.WriteLine("View OnRelayoutEventArgs Locked....");
 541             _viewOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
 542             this.OnRelayoutSignal().Connect(_viewOnRelayoutEventCallbackDelegate);
 543           }
 544         }
 545       }
 546
 547       remove
 548       {
 549         lock(this)
 550         {
 551           if (_viewOnRelayoutEventHandler != null)
 552           {
 553             this.OnRelayoutSignal().Disconnect(_viewOnRelayoutEventCallbackDelegate);
 554           }
 555
 556           _viewOnRelayoutEventHandler -= value;
 557         }
 558       }
 559     }
 560
 561     // Callback for View OnRelayout signal
 562     private void OnRelayout(IntPtr data)
 563     {
 564       OnRelayoutEventArgs e = new OnRelayoutEventArgs();
 565       Console.WriteLine("View OnRelayoutEventArgs....");
 566       // Populate all members of "e" (OnRelayoutEventArgs) with real data
 567       e.View = View.GetViewFromPtr(data);
 568
 569       if (_viewOnRelayoutEventHandler != null)
 570       {
 571         //here we send all data to user event handlers
 572         _viewOnRelayoutEventHandler(this, e);
 573       }
 574     }
 575
 576     /**
 577       * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
 578       * (in the type of TouchEventHandler-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
 579       * provided by the user. Touched signal is emitted when touch input is received.
 580       */
 581     public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
 582     {
 583       add
 584       {
 585         lock(this)
 586         {
 587           // Restricted to only one listener
 588           if (_viewTouchDataEventHandler == null)
 589           {
 590             _viewTouchDataEventHandler += value;
 591             Console.WriteLine("View Touch EVENT LOCKED....");
 592             _viewTouchDataCallbackDelegate = new TouchCallbackDelegate(OnTouch);
 593             this.TouchSignal().Connect(_viewTouchDataCallbackDelegate);
 594           }
 595         }
 596       }
 597
 598       remove
 599       {
 600         lock(this)
 601         {
 602           if (_viewTouchDataEventHandler != null)
 603           {
 604             this.TouchSignal().Disconnect(_viewTouchDataCallbackDelegate);
 605           }
 606
 607           _viewTouchDataEventHandler -= value;
 608         }
 609       }
 610     }
 611
 612     // Callback for View TouchSignal
 613     private bool OnTouch(IntPtr view, IntPtr touchData)
 614     {
 615       TouchEventArgs e = new TouchEventArgs();
 616       Console.WriteLine("View Touch EVENT....");
 617       // Populate all members of "e" (TouchEventArgs) with real data
 618       e.View = View.GetViewFromPtr(view);
 619       e.TouchData = Dali.TouchData.GetTouchDataFromPtr(touchData);
 620
 621       if (_viewTouchDataEventHandler != null)
 622       {
 623         //here we send all data to user event handlers
 624         return _viewTouchDataEventHandler(this, e);
 625       }
 626
 627       return false;
 628     }
 629
 630     /**
 631       * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
 632       * (in the type of HoverEventHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
 633       * provided by the user. Hovered signal is emitted when hover input is received.
 634       */
 635     public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
 636     {
 637       add
 638       {
 639         lock(this)
 640         {
 641           // Restricted to only one listener
 642           if (_viewHoverEventHandler == null)
 643           {
 644             _viewHoverEventHandler += value;
 645
 646             _viewHoverEventCallbackDelegate = new HoverEventCallbackDelegate(OnHoverEvent);
 647             this.HoveredSignal().Connect(_viewHoverEventCallbackDelegate);
 648           }
 649         }
 650       }
 651
 652       remove
 653       {
 654         lock(this)
 655         {
 656           if (_viewHoverEventHandler != null)
 657           {
 658             this.HoveredSignal().Disconnect(_viewHoverEventCallbackDelegate);
 659           }
 660
 661           _viewHoverEventHandler -= value;
 662         }
 663       }
 664     }
 665
 666     // Callback for View Hover signal
 667     private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
 668     {
 669       HoverEventArgs e = new HoverEventArgs();
 670
 671       // Populate all members of "e" (HoverEventArgs) with real data
 672       e.View = View.GetViewFromPtr(view);
 673       e.HoverEvent = Dali.HoverEvent.GetHoverEventFromPtr(hoverEvent);
 674
 675       if (_viewHoverEventHandler != null)
 676       {
 677         //here we send all data to user event handlers
 678         return _viewHoverEventHandler(this, e);
 679       }
 680
 681       return false;
 682     }
 683
 684     /**
 685       * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
 686       * (in the type of WheelEventHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
 687       * provided by the user. WheelMoved signal is emitted when wheel event is received.
 688       */
 689     public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
 690     {
 691       add
 692       {
 693         lock(this)
 694         {
 695           // Restricted to only one listener
 696           if (_viewWheelEventHandler == null)
 697           {
 698             _viewWheelEventHandler += value;
 699             Console.WriteLine("View Wheel EVENT LOCKED....");
 700             _viewWheelEventCallbackDelegate = new WheelEventCallbackDelegate(OnWheelEvent);
 701             this.WheelEventSignal().Connect(_viewWheelEventCallbackDelegate);
 702           }
 703         }
 704       }
 705
 706       remove
 707       {
 708         lock(this)
 709         {
 710           if (_viewWheelEventHandler != null)
 711           {
 712             this.WheelEventSignal().Disconnect(_viewWheelEventCallbackDelegate);
 713           }
 714
 715           _viewWheelEventHandler -= value;
 716         }
 717       }
 718     }
 719
 720     // Callback for View Wheel signal
 721     private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
 722     {
 723       WheelEventArgs e = new WheelEventArgs();
 724       Console.WriteLine("View Wheel EVENT ....");
 725       // Populate all members of "e" (WheelEventArgs) with real data
 726       e.View = View.GetViewFromPtr(view);
 727       e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr(wheelEvent);
 728
 729       if (_viewWheelEventHandler != null)
 730       {
 731         //here we send all data to user event handlers
 732         return _viewWheelEventHandler(this, e);
 733       }
 734
 735       return false;
 736     }
 737
 738     /**
 739       * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler
 740       * (in the type of OnStageEventHandler) provided by the user.
 741       * OnStage signal is emitted after the view has been connected to the stage.
 742       */
 743     public event DaliEventHandler<object,OnStageEventArgs> OnStageEvent
 744     {
 745       add
 746       {
 747         lock(this)
 748         {
 749           // Restricted to only one listener
 750           if (_viewOnStageEventHandler == null)
 751           {
 752             _viewOnStageEventHandler += value;
 753
 754             _viewOnStageEventCallbackDelegate = new OnStageEventCallbackDelegate(OnStage);
 755             this.OnStageSignal().Connect(_viewOnStageEventCallbackDelegate);
 756           }
 757         }
 758       }
 759
 760       remove
 761       {
 762         lock(this)
 763         {
 764           if (_viewOnStageEventHandler != null)
 765           {
 766             this.OnStageSignal().Disconnect(_viewOnStageEventCallbackDelegate);
 767           }
 768
 769           _viewOnStageEventHandler -= value;
 770         }
 771       }
 772     }
 773
 774     // Callback for View OnStage signal
 775     private void OnStage(IntPtr data)
 776     {
 777       OnStageEventArgs e = new OnStageEventArgs();
 778
 779       // Populate all members of "e" (OnStageEventArgs) with real data
 780       e.View = View.GetViewFromPtr(data);
 781
 782       if (_viewOnStageEventHandler != null)
 783       {
 784         //here we send all data to user event handlers
 785         _viewOnStageEventHandler(this, e);
 786       }
 787     }
 788
 789     /**
 790       * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler
 791       * (in the type of OffStageEventHandler) provided by the user.
 792       * OffStage signal is emitted after the view has been disconnected from the stage.
 793       */
 794     public event DaliEventHandler<object,OffStageEventArgs> OffStageEvent
 795     {
 796       add
 797       {
 798         lock(this)
 799         {
 800           // Restricted to only one listener
 801           if (_viewOffStageEventHandler == null)
 802           {
 803             _viewOffStageEventHandler += value;
 804
 805             _viewOffStageEventCallbackDelegate = new OffStageEventCallbackDelegate(OffStage);
 806             this.OnStageSignal().Connect(_viewOffStageEventCallbackDelegate);
 807           }
 808         }
 809       }
 810
 811       remove
 812       {
 813         lock(this)
 814         {
 815           if (_viewOffStageEventHandler != null)
 816           {
 817             this.OnStageSignal().Disconnect(_viewOffStageEventCallbackDelegate);
 818           }
 819
 820           _viewOffStageEventHandler -= value;
 821         }
 822       }
 823     }
 824
 825     // Callback for View OffStage signal
 826     private void OffStage(IntPtr data)
 827     {
 828       OffStageEventArgs e = new OffStageEventArgs();
 829
 830       // Populate all members of "e" (OffStageEventArgs) with real data
 831       e.View = View.GetViewFromPtr(data);
 832
 833       if (_viewOffStageEventHandler != null)
 834       {
 835         //here we send all data to user event handlers
 836         _viewOffStageEventHandler(this, e);
 837       }
 838     }
 839
 840     public static View GetViewFromPtr(global::System.IntPtr cPtr) {
 841       View ret = new View(cPtr, false);
 842       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 843       return ret;
 844     }
 845
 846     %}
 847
 848     %enddef
 849
 850 %define DALI_CONTROL_EVENTHANDLER_PARAM( NameSpace, ClassName)
 851
 852   CONTROL_EVENTHANDLER_TYPEMAP_EVENTARG( NameSpace, ClassName);
 853   CONTROL_EVENTHANDLER_TYPEMAP_HELPER( NameSpace, ClassName);
 854
 855   %enddef
 856
 857   namespace Dali
 858 {
 859   DALI_CONTROL_EVENTHANDLER_PARAM( Dali::Toolkit, Control);
 860 }