plugins/dali-swig/automatic/csharp/Stage.cs

   1 //------------------------------------------------------------------------------
   2 // <auto-generated />
   3 //
   4 // This file was automatically generated by SWIG (http://www.swig.org).
   5 // Version 3.0.9
   6 //
   7 // Do not make changes to this file unless you know what you are doing--modify
   8 // the SWIG interface file instead.
   9 //------------------------------------------------------------------------------
  10
  11 namespace Dali {
  12
  13 using System;
  14 using System.Runtime.InteropServices;
  15
  16
  17 public class Stage : BaseHandle {
  18   private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  19
  20   internal Stage(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Stage_SWIGUpcast(cPtr), cMemoryOwn) {
  21     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  22   }
  23
  24   internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Stage obj) {
  25     return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  26   }
  27
  28   ~Stage() {
  29     Dispose();
  30   }
  31
  32   public override void Dispose() {
  33     lock(this) {
  34       if (swigCPtr.Handle != global::System.IntPtr.Zero) {
  35         if (swigCMemOwn) {
  36           swigCMemOwn = false;
  37           NDalicPINVOKE.delete_Stage(swigCPtr);
  38         }
  39         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  40       }
  41       global::System.GC.SuppressFinalize(this);
  42       base.Dispose();
  43     }
  44   }
  45
  46
  47 /**
  48   * @brief Event arguments that passed via Touch signal
  49   *
  50   */
  51 public class TouchEventArgs : EventArgs
  52 {
  53    private TouchData _touchData;
  54
  55    /**
  56      * @brief TouchData - contains the information of touch points
  57      *
  58      */
  59    public TouchData TouchData
  60    {
  61       get
  62       {
  63          return _touchData;
  64       }
  65       set
  66       {
  67          _touchData = value;
  68       }
  69    }
  70 }
  71
  72
  73 /**
  74   * @brief Event arguments that passed via Wheel signal
  75   *
  76   */
  77 public class WheelEventArgs : EventArgs
  78 {
  79    private WheelEvent _wheelEvent;
  80
  81    /**
  82      * @brief WheelEvent - store a wheel rolling type MOUSE_WHEEL or CUSTOM_WHEEL
  83      *
  84      */
  85    public WheelEvent WheelEvent
  86    {
  87       get
  88       {
  89          return _wheelEvent;
  90       }
  91       set
  92       {
  93          _wheelEvent = value;
  94       }
  95    }
  96 }
  97
  98 /**
  99   * @brief Event arguments that passed via KeyEvent signal
 100   *
 101   */
 102 public class KeyEventArgs : EventArgs
 103 {
 104    private KeyEvent _keyEvent;
 105
 106    /**
 107      * @brief KeyEvent - is the keyevent sent to Stage.
 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 EventProcessingFinished signal
 125   *
 126   */
 127 public class EventProcessingFinishedEventArgs : EventArgs
 128 {
 129 }
 130
 131 /**
 132   * @brief Event arguments that passed via ContextLost signal
 133   *
 134   */
 135 public class ContextLostEventArgs : EventArgs
 136 {
 137 }
 138
 139 /**
 140   * @brief Event arguments that passed via ContextRegained signal
 141   *
 142   */
 143 public class ContextRegainedEventArgs : EventArgs
 144 {
 145 }
 146
 147 /**
 148   * @brief Event arguments that passed via SceneCreated signal
 149   *
 150   */
 151 public class SceneCreatedEventArgs : EventArgs
 152 {
 153 }
 154
 155
 156   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 157   private delegate void StageTouchCallbackDelegate(IntPtr data);
 158   private DaliEventHandler<object,TouchEventArgs> _stageTouchEventHandler;
 159   private StageTouchCallbackDelegate _stageTouchCallbackDelegate;
 160
 161   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 162   private delegate void WheelCallbackDelegate(IntPtr data);
 163   private DaliEventHandler<object,WheelEventArgs> _stageWheelEventHandler;
 164   private WheelCallbackDelegate _stageWheelCallbackDelegate;
 165
 166   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 167   private delegate void KeyCallbackDelegate(IntPtr data);
 168   private DaliEventHandler<object,KeyEventArgs> _stageKeyEventHandler;
 169   private KeyCallbackDelegate _stageKeyCallbackDelegate;
 170
 171   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 172   private delegate void EventProcessingFinishedEventCallbackDelegate();
 173   private DaliEventHandler<object,EventProcessingFinishedEventArgs> _stageEventProcessingFinishedEventHandler;
 174   private EventProcessingFinishedEventCallbackDelegate _stageEventProcessingFinishedEventCallbackDelegate;
 175
 176   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 177   private delegate void ContextLostEventCallbackDelegate();
 178   private DaliEventHandler<object,ContextLostEventArgs> _stageContextLostEventHandler;
 179   private ContextLostEventCallbackDelegate _stageContextLostEventCallbackDelegate;
 180
 181   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 182   private delegate void ContextRegainedEventCallbackDelegate();
 183   private DaliEventHandler<object,ContextRegainedEventArgs> _stageContextRegainedEventHandler;
 184   private ContextRegainedEventCallbackDelegate _stageContextRegainedEventCallbackDelegate;
 185
 186   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 187   private delegate void SceneCreatedEventCallbackDelegate();
 188   private DaliEventHandler<object,SceneCreatedEventArgs> _stageSceneCreatedEventHandler;
 189   private SceneCreatedEventCallbackDelegate _stageSceneCreatedEventCallbackDelegate;
 190
 191   /**
 192     * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
 193     * (in the type of TouchEventHandler-DaliEventHandler<object,TouchEventArgs>) provided by the user.
 194     * Touched signal is emitted when the screen is touched and when the touch ends
 195     * (i.e. the down & up touch events only).
 196     *
 197     */
 198   public event DaliEventHandler<object,TouchEventArgs> Touched
 199   {
 200      add
 201      {
 202         lock(this)
 203         {
 204            // Restricted to only one listener
 205            if (_stageTouchEventHandler == null)
 206            {
 207               _stageTouchEventHandler += value;
 208
 209               _stageTouchCallbackDelegate = new StageTouchCallbackDelegate(OnStageTouch);
 210               this.TouchSignal().Connect(_stageTouchCallbackDelegate);
 211            }
 212         }
 213      }
 214
 215      remove
 216      {
 217         lock(this)
 218         {
 219            if (_stageTouchEventHandler != null)
 220            {
 221               this.TouchSignal().Disconnect(_stageTouchCallbackDelegate);
 222            }
 223
 224            _stageTouchEventHandler -= value;
 225         }
 226      }
 227   }
 228
 229   // Callback for Stage Touch signal
 230   private void OnStageTouch(IntPtr data)
 231   {
 232      TouchEventArgs e = new TouchEventArgs();
 233
 234      // Populate all members of "e" (TouchEventArgs) with real data
 235      e.TouchData = TouchData.GetTouchDataFromPtr( data );
 236
 237      if (_stageTouchEventHandler != null)
 238      {
 239         //here we send all data to user event handlers
 240         _stageTouchEventHandler(this, e);
 241      }
 242   }
 243
 244   /**
 245     * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
 246     * (in the type of WheelEventHandler-DaliEventHandler<object,WheelEventArgs>) provided by the user.
 247     * WheelMoved signal is emitted is emitted when wheel event is received.
 248     *
 249     */
 250   public event DaliEventHandler<object,WheelEventArgs> WheelMoved
 251   {
 252      add
 253      {
 254         lock(this)
 255         {
 256            // Restricted to only one listener
 257            if (_stageWheelEventHandler == null)
 258            {
 259               _stageWheelEventHandler += value;
 260
 261               _stageWheelCallbackDelegate = new WheelCallbackDelegate(OnStageWheel);
 262               this.WheelEventSignal().Connect(_stageWheelCallbackDelegate);
 263            }
 264         }
 265      }
 266
 267      remove
 268      {
 269         lock(this)
 270         {
 271            if (_stageWheelEventHandler != null)
 272            {
 273               this.WheelEventSignal().Disconnect(_stageWheelCallbackDelegate);
 274            }
 275
 276            _stageWheelEventHandler -= value;
 277         }
 278      }
 279   }
 280
 281   // Callback for Stage WheelEventsignal
 282   private void OnStageWheel(IntPtr data)
 283   {
 284      WheelEventArgs e = new WheelEventArgs();
 285
 286      // Populate all members of "e" (WheelEventArgs) with real data
 287      e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr( data );
 288
 289      if (_stageWheelEventHandler != null)
 290      {
 291         //here we send all data to user event handlers
 292         _stageWheelEventHandler(this, e);
 293      }
 294   }
 295
 296   /**
 297     * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
 298     * (in the type of KeyEventHandler-DaliEventHandler<object,KeyEventArgs>) provided by the user.
 299     * KeyPressed signal is emitted is emitted when key event is received.
 300     *
 301     */
 302   public event DaliEventHandler<object,KeyEventArgs> KeyPressed
 303   {
 304      add
 305      {
 306         lock(this)
 307         {
 308            // Restricted to only one listener
 309            if (_stageKeyEventHandler == null)
 310            {
 311               _stageKeyEventHandler += value;
 312
 313               _stageKeyCallbackDelegate = new KeyCallbackDelegate(OnStageKey);
 314               this.KeyEventSignal().Connect(_stageKeyCallbackDelegate);
 315            }
 316         }
 317      }
 318
 319      remove
 320      {
 321         lock(this)
 322         {
 323            if (_stageKeyEventHandler != null)
 324            {
 325               this.KeyEventSignal().Disconnect(_stageKeyCallbackDelegate);
 326            }
 327
 328            _stageKeyEventHandler -= value;
 329         }
 330      }
 331   }
 332
 333   // Callback for Stage KeyEventsignal
 334   private void OnStageKey(IntPtr keyEvent)
 335   {
 336      KeyEventArgs e = new KeyEventArgs();
 337
 338      // Populate all members of "e" (KeyEventArgs) with real data
 339      e.KeyEvent = Dali.KeyEvent.GetKeyEventFromPtr( keyEvent );
 340
 341      if (_stageKeyEventHandler != null)
 342      {
 343         //here we send all data to user event handlers
 344         _stageKeyEventHandler(this, e);
 345      }
 346   }
 347
 348   /**
 349     * @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler
 350     * (in the type of EventProcessingFinishedEventHandler-DaliEventHandler<object,EventProcessingFinishedEventArgs>)
 351     * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.
 352     *
 353     */
 354   public event DaliEventHandler<object,EventProcessingFinishedEventArgs> EventProcessingFinished
 355   {
 356      add
 357      {
 358         lock(this)
 359         {
 360            // Restricted to only one listener
 361            if (_stageEventProcessingFinishedEventHandler == null)
 362            {
 363               _stageEventProcessingFinishedEventHandler += value;
 364
 365               _stageEventProcessingFinishedEventCallbackDelegate = new EventProcessingFinishedEventCallbackDelegate(OnEventProcessingFinished);
 366               this.EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallbackDelegate);
 367            }
 368         }
 369      }
 370
 371      remove
 372      {
 373         lock(this)
 374         {
 375            if (_stageEventProcessingFinishedEventHandler != null)
 376            {
 377               this.EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallbackDelegate);
 378            }
 379
 380            _stageEventProcessingFinishedEventHandler -= value;
 381         }
 382      }
 383   }
 384
 385   // Callback for Stage EventProcessingFinishedSignal
 386   private void OnEventProcessingFinished()
 387   {
 388      EventProcessingFinishedEventArgs e = new EventProcessingFinishedEventArgs();
 389
 390      if (_stageEventProcessingFinishedEventHandler != null)
 391      {
 392         //here we send all data to user event handlers
 393         _stageEventProcessingFinishedEventHandler(this, e);
 394      }
 395   }
 396
 397   /**
 398     * @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler
 399     * (in the type of ContextLostEventHandler-DaliEventHandler<object,ContextLostEventArgs>) provided by the user.
 400     * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).
 401     *
 402     */
 403   public event DaliEventHandler<object,ContextLostEventArgs> ContextLost
 404   {
 405      add
 406      {
 407         lock(this)
 408         {
 409            // Restricted to only one listener
 410            if (_stageContextLostEventHandler == null)
 411            {
 412               _stageContextLostEventHandler += value;
 413
 414               _stageContextLostEventCallbackDelegate = new ContextLostEventCallbackDelegate(OnContextLost);
 415               this.ContextLostSignal().Connect(_stageContextLostEventCallbackDelegate);
 416            }
 417         }
 418      }
 419
 420      remove
 421      {
 422         lock(this)
 423         {
 424            if (_stageContextLostEventHandler != null)
 425            {
 426               this.ContextLostSignal().Disconnect(_stageContextLostEventCallbackDelegate);
 427            }
 428
 429            _stageContextLostEventHandler -= value;
 430         }
 431      }
 432   }
 433
 434   // Callback for Stage ContextLostSignal
 435   private void OnContextLost()
 436   {
 437      ContextLostEventArgs e = new ContextLostEventArgs();
 438
 439      if (_stageContextLostEventHandler != null)
 440      {
 441         //here we send all data to user event handlers
 442         _stageContextLostEventHandler(this, e);
 443      }
 444   }
 445
 446   /**
 447     * @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler
 448     * (in the type of ContextRegainedEventHandler-DaliEventHandler<object,ContextRegainedEventArgs>)
 449     * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific
 450     * behaviour).
 451     *
 452     */
 453   public event DaliEventHandler<object,ContextRegainedEventArgs> ContextRegained
 454   {
 455      add
 456      {
 457         lock(this)
 458         {
 459            // Restricted to only one listener
 460            if (_stageContextRegainedEventHandler == null)
 461            {
 462               _stageContextRegainedEventHandler += value;
 463
 464               _stageContextRegainedEventCallbackDelegate = new ContextRegainedEventCallbackDelegate(OnContextRegained);
 465               this.ContextRegainedSignal().Connect(_stageContextRegainedEventCallbackDelegate);
 466            }
 467         }
 468      }
 469
 470      remove
 471      {
 472         lock(this)
 473         {
 474            if (_stageContextRegainedEventHandler != null)
 475            {
 476               this.ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallbackDelegate);
 477            }
 478
 479            _stageContextRegainedEventHandler -= value;
 480         }
 481      }
 482   }
 483
 484   // Callback for Stage ContextRegainedSignal
 485   private void OnContextRegained()
 486   {
 487      ContextRegainedEventArgs e = new ContextRegainedEventArgs();
 488
 489      if (_stageContextRegainedEventHandler != null)
 490      {
 491         //here we send all data to user event handlers
 492         _stageContextRegainedEventHandler(this, e);
 493      }
 494   }
 495
 496   /**
 497     * @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler
 498     * (in the type of SceneCreatedEventHandler-DaliEventHandler<object,SceneCreatedEventArgs>) provided by the user.
 499     * SceneCreated signal is emitted after the initial scene is created.
 500     *
 501     */
 502   public event DaliEventHandler<object,SceneCreatedEventArgs> SceneCreated
 503   {
 504      add
 505      {
 506         lock(this)
 507         {
 508            // Restricted to only one listener
 509            if (_stageSceneCreatedEventHandler == null)
 510            {
 511               _stageSceneCreatedEventHandler += value;
 512
 513               _stageSceneCreatedEventCallbackDelegate = new SceneCreatedEventCallbackDelegate(OnSceneCreated);
 514               this.SceneCreatedSignal().Connect(_stageSceneCreatedEventCallbackDelegate);
 515            }
 516         }
 517      }
 518
 519      remove
 520      {
 521         lock(this)
 522         {
 523            if (_stageSceneCreatedEventHandler != null)
 524            {
 525               this.SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallbackDelegate);
 526            }
 527
 528            _stageSceneCreatedEventHandler -= value;
 529         }
 530      }
 531   }
 532
 533   // Callback for Stage SceneCreatedSignal
 534   private void OnSceneCreated()
 535   {
 536      SceneCreatedEventArgs e = new SceneCreatedEventArgs();
 537
 538      if (_stageSceneCreatedEventHandler != null)
 539      {
 540         //here we send all data to user event handlers
 541         _stageSceneCreatedEventHandler(this, e);
 542      }
 543   }
 544
 545   public Vector2 Size
 546   {
 547      get
 548      {
 549         Vector2 ret = GetSize();
 550         return ret;
 551      }
 552   }
 553
 554   public Vector4 BackgroundColor
 555   {
 556      set
 557      {
 558         SetBackgroundColor(value);
 559      }
 560      get
 561      {
 562         Vector4 ret = GetBackgroundColor();
 563         return ret;
 564      }
 565    }
 566
 567
 568   public static Vector4 DEFAULT_BACKGROUND_COLOR {
 569     get {
 570       global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEFAULT_BACKGROUND_COLOR_get();
 571       Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 572       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 573       return ret;
 574     }
 575   }
 576
 577   public static Vector4 DEBUG_BACKGROUND_COLOR {
 578     get {
 579       global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEBUG_BACKGROUND_COLOR_get();
 580       Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);
 581       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 582       return ret;
 583     }
 584   }
 585
 586   public Stage() : this(NDalicPINVOKE.new_Stage__SWIG_0(), true) {
 587     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 588   }
 589
 590   public static Stage GetCurrent() {
 591     Stage ret = new Stage(NDalicPINVOKE.Stage_GetCurrent(), true);
 592     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 593     return ret;
 594   }
 595
 596   public static bool IsInstalled() {
 597     bool ret = NDalicPINVOKE.Stage_IsInstalled();
 598     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 599     return ret;
 600   }
 601
 602   public Stage(Stage handle) : this(NDalicPINVOKE.new_Stage__SWIG_1(Stage.getCPtr(handle)), true) {
 603     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 604   }
 605
 606   public Stage Assign(Stage rhs) {
 607     Stage ret = new Stage(NDalicPINVOKE.Stage_Assign(swigCPtr, Stage.getCPtr(rhs)), false);
 608     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 609     return ret;
 610   }
 611
 612   public void Add(Actor actor) {
 613     NDalicPINVOKE.Stage_Add(swigCPtr, Actor.getCPtr(actor));
 614     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 615   }
 616
 617   public void Remove(Actor actor) {
 618     NDalicPINVOKE.Stage_Remove(swigCPtr, Actor.getCPtr(actor));
 619     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 620   }
 621
 622   public Vector2 GetSize() {
 623     Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetSize(swigCPtr), true);
 624     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 625     return ret;
 626   }
 627
 628   public RenderTaskList GetRenderTaskList() {
 629     RenderTaskList ret = new RenderTaskList(NDalicPINVOKE.Stage_GetRenderTaskList(swigCPtr), true);
 630     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 631     return ret;
 632   }
 633
 634   public uint GetLayerCount() {
 635     uint ret = NDalicPINVOKE.Stage_GetLayerCount(swigCPtr);
 636     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 637     return ret;
 638   }
 639
 640   public Layer GetLayer(uint depth) {
 641     Layer ret = new Layer(NDalicPINVOKE.Stage_GetLayer(swigCPtr, depth), true);
 642     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 643     return ret;
 644   }
 645
 646   public Layer GetRootLayer() {
 647     Layer ret = new Layer(NDalicPINVOKE.Stage_GetRootLayer(swigCPtr), true);
 648     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 649     return ret;
 650   }
 651
 652   public void SetBackgroundColor(Vector4 color) {
 653     NDalicPINVOKE.Stage_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
 654     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 655   }
 656
 657   public Vector4 GetBackgroundColor() {
 658     Vector4 ret = new Vector4(NDalicPINVOKE.Stage_GetBackgroundColor(swigCPtr), true);
 659     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 660     return ret;
 661   }
 662
 663   public Vector2 GetDpi() {
 664     Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetDpi(swigCPtr), true);
 665     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 666     return ret;
 667   }
 668
 669   public ObjectRegistry GetObjectRegistry() {
 670     ObjectRegistry ret = new ObjectRegistry(NDalicPINVOKE.Stage_GetObjectRegistry(swigCPtr), true);
 671     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 672     return ret;
 673   }
 674
 675   public void KeepRendering(float durationSeconds) {
 676     NDalicPINVOKE.Stage_KeepRendering(swigCPtr, durationSeconds);
 677     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 678   }
 679
 680   public KeyEventSignal KeyEventSignal() {
 681     KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.Stage_KeyEventSignal(swigCPtr), false);
 682     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 683     return ret;
 684   }
 685
 686   public VoidSignal EventProcessingFinishedSignal() {
 687     VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_EventProcessingFinishedSignal(swigCPtr), false);
 688     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 689     return ret;
 690   }
 691
 692   public TouchEventSignal TouchedSignal() {
 693     TouchEventSignal ret = new TouchEventSignal(NDalicPINVOKE.Stage_TouchedSignal(swigCPtr), false);
 694     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 695     return ret;
 696   }
 697
 698   public TouchSignal TouchSignal() {
 699     TouchSignal ret = new TouchSignal(NDalicPINVOKE.Stage_TouchSignal(swigCPtr), false);
 700     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 701     return ret;
 702   }
 703
 704   public StageWheelEventSignal WheelEventSignal() {
 705     StageWheelEventSignal ret = new StageWheelEventSignal(NDalicPINVOKE.Stage_WheelEventSignal(swigCPtr), false);
 706     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 707     return ret;
 708   }
 709
 710   public VoidSignal ContextLostSignal() {
 711     VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextLostSignal(swigCPtr), false);
 712     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 713     return ret;
 714   }
 715
 716   public VoidSignal ContextRegainedSignal() {
 717     VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextRegainedSignal(swigCPtr), false);
 718     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 719     return ret;
 720   }
 721
 722   public VoidSignal SceneCreatedSignal() {
 723     VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_SceneCreatedSignal(swigCPtr), false);
 724     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 725     return ret;
 726   }
 727
 728 }
 729
 730 }