Tizen.NUI/src/public/Stage.cs

   1 // Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved\r
   2 // PROPRIETARY/CONFIDENTIAL \r
   3 // This software is the confidential and proprietary\r
   4 // information of SAMSUNG ELECTRONICS ("Confidential Information"). You shall\r
   5 // not disclose such Confidential Information and shall use it only in\r
   6 // accordance with the terms of the license agreement you entered into with\r
   7 // SAMSUNG ELECTRONICS. SAMSUNG make no representations or warranties about the\r
   8 // suitability of the software, either express or implied, including but not\r
   9 // limited to the implied warranties of merchantability, fitness for a\r
  10 // particular purpose, or non-infringement. SAMSUNG shall not be liable for any\r
  11 // damages suffered by licensee as a result of using, modifying or distributing\r
  12 // this software or its derivatives.\r
  13 \r
  14 // Copyright (c) 2017 Samsung Electronics Co., Ltd.\r
  15 //\r
  16 // Licensed under the Apache License, Version 2.0 (the "License");\r
  17 // you may not use this file except in compliance with the License.\r
  18 // You may obtain a copy of the License at\r
  19 //\r
  20 // http://www.apache.org/licenses/LICENSE-2.0\r
  21 //\r
  22 // Unless required by applicable law or agreed to in writing, software\r
  23 // distributed under the License is distributed on an "AS IS" BASIS,\r
  24 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  25 // See the License for the specific language governing permissions and\r
  26 // limitations under the License.\r
  27 //\r
  28 \r
  29 // This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts\r
  30 // Some have been manually changed\r
  31 \r
  32 \r
  33 namespace Tizen.NUI\r
  34 {\r
  35 \r
  36     using System;\r
  37     using System.Runtime.InteropServices;\r
  38 \r
  39 \r
  40     public class Stage : BaseHandle\r
  41     {\r
  42         private global::System.Runtime.InteropServices.HandleRef swigCPtr;\r
  43 \r
  44         internal Stage(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Stage_SWIGUpcast(cPtr), cMemoryOwn)\r
  45         {\r
  46             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);\r
  47         }\r
  48 \r
  49         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Stage obj)\r
  50         {\r
  51             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;\r
  52         }\r
  53 \r
  54         ~Stage()\r
  55         {\r
  56             DisposeQueue.Instance.Add(this);\r
  57         }\r
  58 \r
  59         public override void Dispose()\r
  60         {\r
  61             if (!Stage.IsInstalled())\r
  62             {\r
  63                 DisposeQueue.Instance.Add(this);\r
  64                 return;\r
  65             }\r
  66 \r
  67             lock (this)\r
  68             {\r
  69                 if (swigCPtr.Handle != global::System.IntPtr.Zero)\r
  70                 {\r
  71                     if (swigCMemOwn)\r
  72                     {\r
  73                         swigCMemOwn = false;\r
  74                         NDalicPINVOKE.delete_Stage(swigCPtr);\r
  75                     }\r
  76                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);\r
  77                 }\r
  78                 global::System.GC.SuppressFinalize(this);\r
  79                 base.Dispose();\r
  80             }\r
  81         }\r
  82 \r
  83 \r
  84         /**\r
  85           * @brief Event arguments that passed via Touch signal\r
  86           *\r
  87           */\r
  88         public class TouchEventArgs : EventArgs\r
  89         {\r
  90             private Touch _touch;\r
  91 \r
  92             /**\r
  93               * @brief Touch - contains the information of touch points\r
  94               *\r
  95               */\r
  96             public Touch Touch\r
  97             {\r
  98                 get\r
  99                 {\r
 100                     return _touch;\r
 101                 }\r
 102                 set\r
 103                 {\r
 104                     _touch = value;\r
 105                 }\r
 106             }\r
 107         }\r
 108 \r
 109         private event EventHandler<TouchEventArgs> _stageTouchEventHandler;\r
 110         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 111         private delegate void StageTouchCallbackType(IntPtr data);\r
 112         private StageTouchCallbackType _stageTouchCallback;\r
 113 \r
 114         /**\r
 115           * @brief Event for TouchEvent signal which can be used to subscribe/unsubscribe the event handler\r
 116           * TouchEvent signal is emitted when the screen is touched and when the touch ends\r
 117           * (i.e. the down & up touch events only).\r
 118           *\r
 119           */\r
 120         public event EventHandler<TouchEventArgs> Touch\r
 121         {\r
 122             add\r
 123             {\r
 124                 if (_stageTouchEventHandler == null)\r
 125                 {\r
 126                     _stageTouchCallback = OnStageTouch;\r
 127                     TouchSignal().Connect(_stageTouchCallback);\r
 128                 }\r
 129 \r
 130                 _stageTouchEventHandler += value;\r
 131             }\r
 132             remove\r
 133             {\r
 134                 _stageTouchEventHandler -= value;\r
 135 \r
 136                 if (_stageTouchEventHandler == null && _stageTouchCallback != null)\r
 137                 {\r
 138                     TouchSignal().Disconnect(_stageTouchCallback);\r
 139                 }\r
 140             }\r
 141         }\r
 142 \r
 143         private void OnStageTouch(IntPtr data)\r
 144         {\r
 145             TouchEventArgs e = new TouchEventArgs();\r
 146 \r
 147             if (data != null)\r
 148             {\r
 149                 e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(data);\r
 150             }\r
 151 \r
 152             if (_stageTouchEventHandler != null)\r
 153             {\r
 154                 _stageTouchEventHandler(this, e);\r
 155             }\r
 156         }\r
 157 \r
 158         /**\r
 159           * @brief Wheel arguments that passed via Wheel signal\r
 160           *\r
 161           */\r
 162         public class WheelEventArgs : EventArgs\r
 163         {\r
 164             private Wheel _wheel;\r
 165 \r
 166             public Wheel Wheel\r
 167             {\r
 168                 get\r
 169                 {\r
 170                     return _wheel;\r
 171                 }\r
 172                 set\r
 173                 {\r
 174                     _wheel = value;\r
 175                 }\r
 176             }\r
 177         }\r
 178 \r
 179         private event EventHandler<WheelEventArgs> _stageWheelEventHandler;\r
 180         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 181         private delegate void StageWheelCallbackType(IntPtr data);\r
 182         private StageWheelCallbackType _stageWheelCallback;\r
 183 \r
 184         /**\r
 185           * @brief Event for Wheel signal which can be used to subscribe/unsubscribe the event handler\r
 186           * Wheel signal is emitted is emitted when wheel event is received.\r
 187           *\r
 188           */\r
 189         public event EventHandler<WheelEventArgs> Wheel\r
 190         {\r
 191             add\r
 192             {\r
 193                 if (_stageWheelEventHandler == null)\r
 194                 {\r
 195                     _stageWheelCallback = OnStageWheel;\r
 196                     WheelEventSignal().Connect(_stageWheelCallback);\r
 197                 }\r
 198 \r
 199                 _stageWheelEventHandler += value;\r
 200             }\r
 201             remove\r
 202             {\r
 203                 _stageWheelEventHandler -= value;\r
 204 \r
 205                 if (_stageWheelEventHandler == null && _stageWheelCallback != null)\r
 206                 {\r
 207                     WheelEventSignal().Disconnect(_stageWheelCallback);\r
 208                 }\r
 209 \r
 210             }\r
 211         }\r
 212 \r
 213         private void OnStageWheel(IntPtr data)\r
 214         {\r
 215             WheelEventArgs e = new WheelEventArgs();\r
 216 \r
 217             if (data != null)\r
 218             {\r
 219                 e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(data);\r
 220             }\r
 221 \r
 222             if (_stageWheelEventHandler != null)\r
 223             {\r
 224                 _stageWheelEventHandler(this, e);\r
 225             }\r
 226         }\r
 227 \r
 228         /**\r
 229           * @brief Event arguments that passed via Key signal\r
 230           *\r
 231           */\r
 232         public class KeyEventArgs : EventArgs\r
 233         {\r
 234             private Key _key;\r
 235 \r
 236             public Key Key\r
 237             {\r
 238                 get\r
 239                 {\r
 240                     return _key;\r
 241                 }\r
 242                 set\r
 243                 {\r
 244                     _key = value;\r
 245                 }\r
 246             }\r
 247         }\r
 248 \r
 249         private event EventHandler<KeyEventArgs> _stageKeyEventHandler;\r
 250         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 251         private delegate void StageKeyCallbackType(IntPtr data);\r
 252         private StageKeyCallbackType _stageKeyCallback;\r
 253 \r
 254         /**\r
 255           * @brief Event for Key signal which can be used to subscribe/unsubscribe the event handler\r
 256           * Key signal is emitted is emitted when key event is received.\r
 257           *\r
 258           */\r
 259         public event EventHandler<KeyEventArgs> Key\r
 260         {\r
 261             add\r
 262             {\r
 263                 if (_stageKeyEventHandler == null)\r
 264                 {\r
 265                     _stageKeyCallback = OnStageKey;\r
 266                     KeyEventSignal().Connect(_stageKeyCallback);\r
 267                 }\r
 268 \r
 269                 _stageKeyEventHandler += value;\r
 270             }\r
 271             remove\r
 272             {\r
 273                 _stageKeyEventHandler -= value;\r
 274 \r
 275                 if (_stageKeyEventHandler == null && _stageKeyCallback != null)\r
 276                 {\r
 277                     KeyEventSignal().Disconnect(_stageKeyCallback);\r
 278                 }\r
 279             }\r
 280         }\r
 281 \r
 282         // Callback for Stage KeyEventsignal\r
 283         private void OnStageKey(IntPtr data)\r
 284         {\r
 285             KeyEventArgs e = new KeyEventArgs();\r
 286 \r
 287             if (data != null)\r
 288             {\r
 289                 e.Key = Tizen.NUI.Key.GetKeyFromPtr(data);\r
 290             }\r
 291 \r
 292             if (_stageKeyEventHandler != null)\r
 293             {\r
 294                 _stageKeyEventHandler(this, e);\r
 295             }\r
 296         }\r
 297 \r
 298         private event EventHandler _stageEventProcessingFinishedEventHandler;\r
 299         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 300         private delegate void StageEventProcessingFinishedEventCallbackType();\r
 301         private StageEventProcessingFinishedEventCallbackType _stageEventProcessingFinishedEventCallback;\r
 302 \r
 303         /**\r
 304           * @brief Event for EventProcessingFinished signal which can be used to subscribe/unsubscribe the event handler\r
 305           * provided by the user. EventProcessingFinished signal is emitted just after the event processing is finished.\r
 306           *\r
 307           */\r
 308         internal event EventHandler EventProcessingFinished\r
 309         {\r
 310             add\r
 311             {\r
 312                 if (_stageEventProcessingFinishedEventHandler == null)\r
 313                 {\r
 314                     _stageEventProcessingFinishedEventCallback = OnEventProcessingFinished;\r
 315                     EventProcessingFinishedSignal().Connect(_stageEventProcessingFinishedEventCallback);\r
 316                 }\r
 317 \r
 318                 _stageEventProcessingFinishedEventHandler += value;\r
 319             }\r
 320             remove\r
 321             {\r
 322                 _stageEventProcessingFinishedEventHandler -= value;\r
 323 \r
 324                 if (_stageEventProcessingFinishedEventHandler == null && _stageEventProcessingFinishedEventCallback != null)\r
 325                 {\r
 326                     EventProcessingFinishedSignal().Disconnect(_stageEventProcessingFinishedEventCallback);\r
 327                 }\r
 328             }\r
 329         }\r
 330 \r
 331         private void OnEventProcessingFinished()\r
 332         {\r
 333             if (_stageEventProcessingFinishedEventHandler != null)\r
 334             {\r
 335                 _stageEventProcessingFinishedEventHandler(this, null);\r
 336             }\r
 337         }\r
 338 \r
 339         private event EventHandler _stageContextLostEventHandler;\r
 340         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 341         private delegate void StageContextLostEventCallbackType();\r
 342         private StageContextLostEventCallbackType _stageContextLostEventCallback;\r
 343 \r
 344         /**\r
 345           * @brief Event for ContextLost signal which can be used to subscribe/unsubscribe the event handler\r
 346           * ContextLost signal is emitted when the GL context is lost (Platform specific behaviour).\r
 347           *\r
 348           */\r
 349         internal event EventHandler ContextLost\r
 350         {\r
 351             add\r
 352             {\r
 353                 if (_stageContextLostEventHandler == null)\r
 354                 {\r
 355                     _stageContextLostEventCallback = OnContextLost;\r
 356                     ContextLostSignal().Connect(_stageContextLostEventCallback);\r
 357                 }\r
 358 \r
 359                 _stageContextLostEventHandler += value;\r
 360             }\r
 361             remove\r
 362             {\r
 363                 _stageContextLostEventHandler -= value;\r
 364 \r
 365                 if (_stageContextLostEventHandler == null && _stageContextLostEventCallback != null)\r
 366                 {\r
 367                     ContextLostSignal().Disconnect(_stageContextLostEventCallback);\r
 368                 }\r
 369             }\r
 370         }\r
 371 \r
 372         private void OnContextLost()\r
 373         {\r
 374             if (_stageContextLostEventHandler != null)\r
 375             {\r
 376                 _stageContextLostEventHandler(this, null);\r
 377             }\r
 378         }\r
 379 \r
 380         private event EventHandler _stageContextRegainedEventHandler;\r
 381         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 382         private delegate void StageContextRegainedEventCallbackType();\r
 383         private StageContextRegainedEventCallbackType _stageContextRegainedEventCallback;\r
 384 \r
 385         /**\r
 386           * @brief Event for ContextRegained signal which can be used to subscribe/unsubscribe the event handler\r
 387           * provided by the user. ContextRegained signal is emitted when the GL context is regained (Platform specific\r
 388           * behaviour).\r
 389           *\r
 390           */\r
 391         internal event EventHandler ContextRegained\r
 392         {\r
 393             add\r
 394             {\r
 395                 if (_stageContextRegainedEventHandler == null)\r
 396                 {\r
 397                     _stageContextRegainedEventCallback = OnContextRegained;\r
 398                     ContextRegainedSignal().Connect(_stageContextRegainedEventCallback);\r
 399                 }\r
 400 \r
 401                 _stageContextRegainedEventHandler += value;\r
 402             }\r
 403             remove\r
 404             {\r
 405                 _stageContextRegainedEventHandler -= value;\r
 406 \r
 407                 if (_stageContextRegainedEventHandler == null && _stageContextRegainedEventCallback != null)\r
 408                 {\r
 409                     ContextRegainedSignal().Disconnect(_stageContextRegainedEventCallback);\r
 410                 }\r
 411             }\r
 412         }\r
 413 \r
 414         private void OnContextRegained()\r
 415         {\r
 416             if (_stageContextRegainedEventHandler != null)\r
 417             {\r
 418                 _stageContextRegainedEventHandler(this, null);\r
 419             }\r
 420         }\r
 421 \r
 422         private event EventHandler _stageSceneCreatedEventHandler;\r
 423         [UnmanagedFunctionPointer(CallingConvention.StdCall)]\r
 424         private delegate void StageSceneCreatedEventCallbackType();\r
 425         private StageSceneCreatedEventCallbackType _stageSceneCreatedEventCallback;\r
 426 \r
 427         /**\r
 428           * @brief Event for SceneCreated signal which can be used to subscribe/unsubscribe the event handler\r
 429           * SceneCreated signal is emitted after the initial scene is created.\r
 430           *\r
 431           */\r
 432         internal event EventHandler SceneCreated\r
 433         {\r
 434             add\r
 435             {\r
 436                 if (_stageSceneCreatedEventHandler == null)\r
 437                 {\r
 438                     _stageSceneCreatedEventCallback = OnSceneCreated;\r
 439                     SceneCreatedSignal().Connect(_stageSceneCreatedEventCallback);\r
 440                 }\r
 441 \r
 442                 _stageSceneCreatedEventHandler += value;\r
 443             }\r
 444             remove\r
 445             {\r
 446                 _stageSceneCreatedEventHandler -= value;\r
 447 \r
 448                 if (_stageSceneCreatedEventHandler == null && _stageSceneCreatedEventCallback != null)\r
 449                 {\r
 450                     SceneCreatedSignal().Disconnect(_stageSceneCreatedEventCallback);\r
 451                 }\r
 452 \r
 453             }\r
 454         }\r
 455 \r
 456         private void OnSceneCreated()\r
 457         {\r
 458             if (_stageSceneCreatedEventHandler != null)\r
 459             {\r
 460                 _stageSceneCreatedEventHandler(this, null);\r
 461             }\r
 462         }\r
 463 \r
 464 \r
 465         public Size2D Size\r
 466         {\r
 467             get\r
 468             {\r
 469                 Size2D ret = GetSize();\r
 470                 return ret;\r
 471             }\r
 472         }\r
 473 \r
 474         public Color BackgroundColor\r
 475         {\r
 476             set\r
 477             {\r
 478                 SetBackgroundColor(value);\r
 479             }\r
 480             get\r
 481             {\r
 482                 Color ret = GetBackgroundColor();\r
 483                 return ret;\r
 484             }\r
 485         }\r
 486 \r
 487         public Vector2 Dpi\r
 488         {\r
 489             get\r
 490             {\r
 491                 return GetDpi();\r
 492             }\r
 493         }\r
 494 \r
 495         public uint LayerCount\r
 496         {\r
 497             get\r
 498             {\r
 499                 return GetLayerCount();\r
 500             }\r
 501         }\r
 502 \r
 503         private static readonly Stage instance = Stage.GetCurrent();\r
 504 \r
 505         public static Stage Instance\r
 506         {\r
 507             get\r
 508             {\r
 509                 return instance;\r
 510             }\r
 511         }\r
 512 \r
 513         public Layer GetDefaultLayer()\r
 514         {\r
 515             return this.GetRootLayer();\r
 516         }\r
 517 \r
 518         public void AddLayer(Layer layer)\r
 519         {\r
 520             this.Add((Actor)layer);\r
 521         }\r
 522 \r
 523         public void RemoveLayer(Layer layer)\r
 524         {\r
 525             this.Remove((Actor)layer);\r
 526         }\r
 527 \r
 528         internal static Vector4 DEFAULT_BACKGROUND_COLOR\r
 529         {\r
 530             get\r
 531             {\r
 532                 global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEFAULT_BACKGROUND_COLOR_get();\r
 533                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);\r
 534                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 535                 return ret;\r
 536             }\r
 537         }\r
 538 \r
 539         internal static Vector4 DEBUG_BACKGROUND_COLOR\r
 540         {\r
 541             get\r
 542             {\r
 543                 global::System.IntPtr cPtr = NDalicPINVOKE.Stage_DEBUG_BACKGROUND_COLOR_get();\r
 544                 Vector4 ret = (cPtr == global::System.IntPtr.Zero) ? null : new Vector4(cPtr, false);\r
 545                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 546                 return ret;\r
 547             }\r
 548         }\r
 549 \r
 550         internal Stage() : this(NDalicPINVOKE.new_Stage__SWIG_0(), true)\r
 551         {\r
 552             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 553         }\r
 554 \r
 555         internal static Stage GetCurrent()\r
 556         {\r
 557             Stage ret = new Stage(NDalicPINVOKE.Stage_GetCurrent(), true);\r
 558             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 559             return ret;\r
 560         }\r
 561 \r
 562         internal static bool IsInstalled()\r
 563         {\r
 564             bool ret = NDalicPINVOKE.Stage_IsInstalled();\r
 565             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 566             return ret;\r
 567         }\r
 568 \r
 569         internal Stage(Stage handle) : this(NDalicPINVOKE.new_Stage__SWIG_1(Stage.getCPtr(handle)), true)\r
 570         {\r
 571             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 572         }\r
 573 \r
 574         internal Stage Assign(Stage rhs)\r
 575         {\r
 576             Stage ret = new Stage(NDalicPINVOKE.Stage_Assign(swigCPtr, Stage.getCPtr(rhs)), false);\r
 577             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 578             return ret;\r
 579         }\r
 580 \r
 581         internal void Add(Actor actor)\r
 582         {\r
 583             NDalicPINVOKE.Stage_Add(swigCPtr, Actor.getCPtr(actor));\r
 584             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 585         }\r
 586 \r
 587         internal void Remove(Actor actor)\r
 588         {\r
 589             NDalicPINVOKE.Stage_Remove(swigCPtr, Actor.getCPtr(actor));\r
 590             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 591         }\r
 592 \r
 593         internal Size2D GetSize()\r
 594         {\r
 595             Size2D ret = new Size2D(NDalicPINVOKE.Stage_GetSize(swigCPtr), true);\r
 596             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 597             return ret;\r
 598         }\r
 599 \r
 600         internal RenderTaskList GetRenderTaskList()\r
 601         {\r
 602             RenderTaskList ret = new RenderTaskList(NDalicPINVOKE.Stage_GetRenderTaskList(swigCPtr), true);\r
 603             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 604             return ret;\r
 605         }\r
 606 \r
 607         internal uint GetLayerCount()\r
 608         {\r
 609             uint ret = NDalicPINVOKE.Stage_GetLayerCount(swigCPtr);\r
 610             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 611             return ret;\r
 612         }\r
 613 \r
 614         public Layer GetLayer(uint depth)\r
 615         {\r
 616             Layer ret = new Layer(NDalicPINVOKE.Stage_GetLayer(swigCPtr, depth), true);\r
 617             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 618             return ret;\r
 619         }\r
 620 \r
 621         internal Layer GetRootLayer()\r
 622         {\r
 623             Layer ret = new Layer(NDalicPINVOKE.Stage_GetRootLayer(swigCPtr), true);\r
 624             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 625             return ret;\r
 626         }\r
 627 \r
 628 \r
 629         internal void SetBackgroundColor(Color color)\r
 630         {\r
 631             NDalicPINVOKE.Stage_SetBackgroundColor(swigCPtr, Color.getCPtr(color));\r
 632             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 633         }\r
 634 \r
 635         internal Color GetBackgroundColor()\r
 636         {\r
 637             Color ret = new Color(NDalicPINVOKE.Stage_GetBackgroundColor(swigCPtr), true);\r
 638             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 639             return ret;\r
 640         }\r
 641         internal Vector2 GetDpi()\r
 642         {\r
 643             Vector2 ret = new Vector2(NDalicPINVOKE.Stage_GetDpi(swigCPtr), true);\r
 644             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 645             return ret;\r
 646         }\r
 647 \r
 648         internal ObjectRegistry GetObjectRegistry()\r
 649         {\r
 650             ObjectRegistry ret = new ObjectRegistry(NDalicPINVOKE.Stage_GetObjectRegistry(swigCPtr), true);\r
 651             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 652             return ret;\r
 653         }\r
 654 \r
 655         public void KeepRendering(float durationSeconds)\r
 656         {\r
 657             NDalicPINVOKE.Stage_KeepRendering(swigCPtr, durationSeconds);\r
 658             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 659         }\r
 660 \r
 661         internal KeyEventSignal KeyEventSignal()\r
 662         {\r
 663             KeyEventSignal ret = new KeyEventSignal(NDalicPINVOKE.Stage_KeyEventSignal(swigCPtr), false);\r
 664             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 665             return ret;\r
 666         }\r
 667 \r
 668         internal VoidSignal EventProcessingFinishedSignal()\r
 669         {\r
 670             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_EventProcessingFinishedSignal(swigCPtr), false);\r
 671             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 672             return ret;\r
 673         }\r
 674 \r
 675         internal TouchSignal TouchSignal()\r
 676         {\r
 677             TouchSignal ret = new TouchSignal(NDalicPINVOKE.Stage_TouchSignal(swigCPtr), false);\r
 678             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 679             return ret;\r
 680         }\r
 681 \r
 682         internal StageWheelSignal WheelEventSignal()\r
 683         {\r
 684             StageWheelSignal ret = new StageWheelSignal(NDalicPINVOKE.Stage_WheelEventSignal(swigCPtr), false);\r
 685             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 686             return ret;\r
 687         }\r
 688 \r
 689         internal VoidSignal ContextLostSignal()\r
 690         {\r
 691             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextLostSignal(swigCPtr), false);\r
 692             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 693             return ret;\r
 694         }\r
 695 \r
 696         internal VoidSignal ContextRegainedSignal()\r
 697         {\r
 698             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_ContextRegainedSignal(swigCPtr), false);\r
 699             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 700             return ret;\r
 701         }\r
 702 \r
 703         internal VoidSignal SceneCreatedSignal()\r
 704         {\r
 705             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Stage_SceneCreatedSignal(swigCPtr), false);\r
 706             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 707             return ret;\r
 708         }\r
 709 \r
 710     }\r
 711 \r
 712 }\r