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