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

   1 /** Copyright (c) 2016 Samsung Electronics Co., Ltd.
   2 *
   3 * Licensed under the Apache License, Version 2.0 (the "License");
   4 * you may not use this file except in compliance with the License.
   5 * You may obtain a copy of the License at
   6 *
   7 * http://www.apache.org/licenses/LICENSE-2.0
   8 *
   9 * Unless required by applicable law or agreed to in writing, software
  10 * distributed under the License is distributed on an "AS IS" BASIS,
  11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 * See the License for the specific language governing permissions and
  13 * limitations under the License.
  14 *
  15 */
  16 // This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
  17 //------------------------------------------------------------------------------
  18 // <auto-generated />
  19 //
  20 // This file was automatically generated by SWIG (http://www.swig.org).
  21 // Version 3.0.9
  22 //
  23 // Do not make changes to this file unless you know what you are doing--modify
  24 // the SWIG interface file instead.
  25 //------------------------------------------------------------------------------
  26
  27 namespace Dali {
  28
  29     using System;
  30     using System.Runtime.InteropServices;
  31
  32 public class Actor : Handle {
  33   private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  34
  35   internal Actor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Actor_SWIGUpcast(cPtr), cMemoryOwn) {
  36     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  37   }
  38
  39   internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Actor obj) {
  40     return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  41   }
  42
  43   ~Actor() {
  44     Dispose();
  45   }
  46
  47   public override void Dispose() {
  48     lock(this) {
  49       if (swigCPtr.Handle != global::System.IntPtr.Zero) {
  50         if (swigCMemOwn) {
  51           swigCMemOwn = false;
  52           NDalicPINVOKE.delete_Actor(swigCPtr);
  53         }
  54         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  55       }
  56       global::System.GC.SuppressFinalize(this);
  57       base.Dispose();
  58     }
  59   }
  60
  61
  62
  63     /**
  64       * @brief Event arguments that passed via Touch signal
  65       *
  66       */
  67     public class TouchEventArgs : EventArgs
  68     {
  69        private Actor _actor;
  70        private TouchData _touchData;
  71
  72       /**
  73         * @brief Actor - is the actor that is being touched
  74         *
  75         */
  76       public Actor Actor
  77       {
  78         get
  79         {
  80           return _actor;
  81         }
  82         set
  83         {
  84           _actor = value;
  85         }
  86       }
  87
  88       /**
  89         * @brief TouchData - contains the information of touch points
  90         *
  91         */
  92       public TouchData TouchData
  93       {
  94         get
  95         {
  96           return _touchData;
  97         }
  98         set
  99         {
 100           _touchData = value;
 101         }
 102       }
 103     }
 104
 105     /**
 106       * @brief Event arguments that passed via Hover signal
 107       *
 108       */
 109     public class HoverEventArgs : EventArgs
 110     {
 111     private Actor _actor;
 112     private HoverEvent _hoverEvent;
 113
 114       /**
 115         * @brief Actor - is the actor that is being hovered
 116         *
 117         */
 118       public Actor Actor
 119       {
 120         get
 121         {
 122           return _actor;
 123         }
 124         set
 125         {
 126           _actor = value;
 127         }
 128       }
 129
 130       /**
 131         * @brief HoverEvent - contains touch points that represent the points
 132         * that are currently being hovered or the points where a hover has stopped
 133         *
 134         */
 135       public HoverEvent HoverEvent
 136       {
 137         get
 138         {
 139           return _hoverEvent;
 140         }
 141         set
 142         {
 143           _hoverEvent = value;
 144         }
 145       }
 146     }
 147
 148     /**
 149       * @brief Event arguments that passed via Wheel signal
 150       *
 151       */
 152     public class WheelEventArgs : EventArgs
 153     {
 154     private Actor _actor;
 155     private WheelEvent _wheelEvent;
 156
 157       /**
 158         * @brief Actor - is the actor that is being wheeled
 159         *
 160         */
 161       public Actor Actor
 162       {
 163         get
 164         {
 165           return _actor;
 166         }
 167         set
 168         {
 169           _actor = value;
 170         }
 171       }
 172
 173       /**
 174         * @brief WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
 175         *
 176         */
 177       public WheelEvent WheelEvent
 178       {
 179         get
 180         {
 181           return _wheelEvent;
 182         }
 183         set
 184         {
 185           _wheelEvent = value;
 186         }
 187       }
 188     }
 189
 190     /**
 191       * @brief Event arguments that passed via OnStage signal
 192       *
 193       */
 194     public class OnStageEventArgs : EventArgs
 195     {
 196     private Actor _actor;
 197
 198       /**
 199         * @brief Actor - is the actor that is being connected to the stage
 200         *
 201         */
 202       public Actor Actor
 203       {
 204         get
 205         {
 206           return _actor;
 207         }
 208         set
 209         {
 210           _actor = value;
 211         }
 212       }
 213     }
 214
 215     /**
 216       * @brief Event arguments that passed via OffStage signal
 217       *
 218       */
 219     public class OffStageEventArgs : EventArgs
 220     {
 221     private Actor _actor;
 222
 223       /**
 224         * @brief Actor - is the actor that is being disconnected from the stage
 225         *
 226         */
 227       public Actor Actor
 228       {
 229         get
 230         {
 231           return _actor;
 232         }
 233         set
 234         {
 235           _actor = value;
 236         }
 237       }
 238     }
 239
 240     /**
 241       * @brief Event arguments that passed via OnRelayout signal
 242       *
 243       */
 244     public class OnRelayoutEventArgs : EventArgs
 245     {
 246       private Actor _actor;
 247
 248       /**
 249         * @brief Actor - is the actor that is being resized upon relayout
 250         *
 251         */
 252       public Actor Actor
 253       {
 254         get
 255         {
 256           return _actor;
 257         }
 258         set
 259         {
 260           _actor = value;
 261         }
 262       }
 263     }
 264
 265
 266     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 267     private delegate bool TouchCallbackDelegate(IntPtr actor, IntPtr touchData);
 268     private DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _actorTouchDataEventHandler;
 269     private TouchCallbackDelegate _actorTouchDataCallbackDelegate;
 270
 271     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 272     private delegate bool HoverEventCallbackDelegate(IntPtr actor, IntPtr hoverEvent);
 273     private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _actorHoverEventHandler;
 274     private HoverEventCallbackDelegate _actorHoverEventCallbackDelegate;
 275
 276     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 277     private delegate bool WheelEventCallbackDelegate(IntPtr actor, IntPtr wheelEvent);
 278     private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _actorWheelEventHandler;
 279     private WheelEventCallbackDelegate _actorWheelEventCallbackDelegate;
 280
 281     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 282     private delegate void OnStageEventCallbackDelegate(IntPtr actor);
 283     private DaliEventHandler<object,OnStageEventArgs> _actorOnStageEventHandler;
 284     private OnStageEventCallbackDelegate _actorOnStageEventCallbackDelegate;
 285
 286     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 287     private delegate void OffStageEventCallbackDelegate(IntPtr actor);
 288     private DaliEventHandler<object,OffStageEventArgs> _actorOffStageEventHandler;
 289     private OffStageEventCallbackDelegate _actorOffStageEventCallbackDelegate;
 290
 291     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 292     private delegate void OnRelayoutEventCallbackDelegate(IntPtr actor);
 293     private DaliEventHandler<object,OnRelayoutEventArgs> _actorOnRelayoutEventHandler;
 294     private OnRelayoutEventCallbackDelegate _actorOnRelayoutEventCallbackDelegate;
 295
 296     /**
 297       * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
 298       * (in the type of TouchEventHandler-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
 299       * provided by the user. Touched signal is emitted when touch input is received.
 300       */
 301     public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
 302     {
 303       add
 304       {
 305         lock(this)
 306         {
 307           // Restricted to only one listener
 308           if (_actorTouchDataEventHandler == null)
 309           {
 310             _actorTouchDataEventHandler += value;
 311
 312             _actorTouchDataCallbackDelegate = new TouchCallbackDelegate(OnTouch);
 313             this.TouchSignal().Connect(_actorTouchDataCallbackDelegate);
 314           }
 315         }
 316       }
 317
 318       remove
 319       {
 320         lock(this)
 321         {
 322           if (_actorTouchDataEventHandler != null)
 323           {
 324             this.TouchSignal().Disconnect(_actorTouchDataCallbackDelegate);
 325           }
 326
 327           _actorTouchDataEventHandler -= value;
 328         }
 329       }
 330     }
 331
 332     // Callback for Actor TouchSignal
 333     private bool OnTouch(IntPtr actor, IntPtr touchData)
 334     {
 335       TouchEventArgs e = new TouchEventArgs();
 336
 337       // Populate all members of "e" (TouchEventArgs) with real data
 338       e.Actor = Actor.GetActorFromPtr(actor);
 339       e.TouchData = Dali.TouchData.GetTouchDataFromPtr(touchData);
 340
 341       if (_actorTouchDataEventHandler != null)
 342       {
 343         //here we send all data to user event handlers
 344         return _actorTouchDataEventHandler(this, e, true);
 345       }
 346
 347       return false;
 348     }
 349
 350     /**
 351       * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
 352       * (in the type of HoverEventHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
 353       * provided by the user. Hovered signal is emitted when hover input is received.
 354       */
 355     public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
 356     {
 357       add
 358       {
 359         lock(this)
 360         {
 361           // Restricted to only one listener
 362           if (_actorHoverEventHandler == null)
 363           {
 364             _actorHoverEventHandler += value;
 365
 366             _actorHoverEventCallbackDelegate = new HoverEventCallbackDelegate(OnHoverEvent);
 367             this.HoveredSignal().Connect(_actorHoverEventCallbackDelegate);
 368           }
 369         }
 370       }
 371
 372       remove
 373       {
 374         lock(this)
 375         {
 376           if (_actorHoverEventHandler != null)
 377           {
 378             this.HoveredSignal().Disconnect(_actorHoverEventCallbackDelegate);
 379           }
 380
 381           _actorHoverEventHandler -= value;
 382         }
 383       }
 384     }
 385
 386     // Callback for Actor Hover signal
 387     private bool OnHoverEvent(IntPtr actor, IntPtr hoverEvent)
 388     {
 389       HoverEventArgs e = new HoverEventArgs();
 390
 391       // Populate all members of "e" (HoverEventArgs) with real data
 392       e.Actor = Actor.GetActorFromPtr(actor);
 393       e.HoverEvent = Dali.HoverEvent.GetHoverEventFromPtr(hoverEvent);
 394
 395       if (_actorHoverEventHandler != null)
 396       {
 397         //here we send all data to user event handlers
 398         return _actorHoverEventHandler(this, e, true);
 399       }
 400
 401       return false;
 402     }
 403
 404     /**
 405       * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
 406       * (in the type of WheelEventHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
 407       * provided by the user. WheelMoved signal is emitted when wheel event is received.
 408       */
 409     public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
 410     {
 411       add
 412       {
 413         lock(this)
 414         {
 415           // Restricted to only one listener
 416           if (_actorWheelEventHandler == null)
 417           {
 418             _actorWheelEventHandler += value;
 419
 420             _actorWheelEventCallbackDelegate = new WheelEventCallbackDelegate(OnWheelEvent);
 421             this.WheelEventSignal().Connect(_actorWheelEventCallbackDelegate);
 422           }
 423         }
 424       }
 425
 426       remove
 427       {
 428         lock(this)
 429         {
 430           if (_actorWheelEventHandler != null)
 431           {
 432             this.WheelEventSignal().Disconnect(_actorWheelEventCallbackDelegate);
 433           }
 434
 435           _actorWheelEventHandler -= value;
 436         }
 437       }
 438     }
 439
 440     // Callback for Actor Wheel signal
 441     private bool OnWheelEvent(IntPtr actor, IntPtr wheelEvent)
 442     {
 443       WheelEventArgs e = new WheelEventArgs();
 444
 445       // Populate all members of "e" (WheelEventArgs) with real data
 446       e.Actor = Actor.GetActorFromPtr(actor);
 447       e.WheelEvent = Dali.WheelEvent.GetWheelEventFromPtr(wheelEvent);
 448
 449       if (_actorWheelEventHandler != null)
 450       {
 451         //here we send all data to user event handlers
 452         return _actorWheelEventHandler(this, e, true);
 453       }
 454
 455       return false;
 456     }
 457
 458     /**
 459       * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler
 460       * (in the type of OnStageEventHandler) provided by the user.
 461       * OnStage signal is emitted after the actor has been connected to the stage.
 462       */
 463     public event DaliEventHandler<object,OnStageEventArgs> OnStageEvent
 464     {
 465       add
 466       {
 467         lock(this)
 468         {
 469           // Restricted to only one listener
 470           if (_actorOnStageEventHandler == null)
 471           {
 472             _actorOnStageEventHandler += value;
 473
 474             _actorOnStageEventCallbackDelegate = new OnStageEventCallbackDelegate(OnStage);
 475             this.OnStageSignal().Connect(_actorOnStageEventCallbackDelegate);
 476           }
 477         }
 478       }
 479
 480       remove
 481       {
 482         lock(this)
 483         {
 484           if (_actorOnStageEventHandler != null)
 485           {
 486             this.OnStageSignal().Disconnect(_actorOnStageEventCallbackDelegate);
 487           }
 488
 489           _actorOnStageEventHandler -= value;
 490         }
 491       }
 492     }
 493
 494     // Callback for Actor OnStage signal
 495     private void OnStage(IntPtr data)
 496     {
 497       OnStageEventArgs e = new OnStageEventArgs();
 498
 499       // Populate all members of "e" (OnStageEventArgs) with real data
 500       e.Actor = Actor.GetActorFromPtr(data);
 501
 502       if (_actorOnStageEventHandler != null)
 503       {
 504         //here we send all data to user event handlers
 505         _actorOnStageEventHandler(this, e);
 506       }
 507     }
 508
 509     /**
 510       * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler
 511       * (in the type of OffStageEventHandler) provided by the user.
 512       * OffStage signal is emitted after the actor has been disconnected from the stage.
 513       */
 514     public event DaliEventHandler<object,OffStageEventArgs> OffStageEvent
 515     {
 516       add
 517       {
 518         lock(this)
 519         {
 520           // Restricted to only one listener
 521           if (_actorOffStageEventHandler == null)
 522           {
 523             _actorOffStageEventHandler += value;
 524
 525             _actorOffStageEventCallbackDelegate = new OffStageEventCallbackDelegate(OffStage);
 526             this.OnStageSignal().Connect(_actorOffStageEventCallbackDelegate);
 527           }
 528         }
 529       }
 530
 531       remove
 532       {
 533         lock(this)
 534         {
 535           if (_actorOffStageEventHandler != null)
 536           {
 537             this.OnStageSignal().Disconnect(_actorOffStageEventCallbackDelegate);
 538           }
 539
 540           _actorOffStageEventHandler -= value;
 541         }
 542       }
 543     }
 544
 545     // Callback for Actor OffStage signal
 546     private void OffStage(IntPtr data)
 547     {
 548       OffStageEventArgs e = new OffStageEventArgs();
 549
 550       // Populate all members of "e" (OffStageEventArgs) with real data
 551       e.Actor = Actor.GetActorFromPtr(data);
 552
 553       if (_actorOffStageEventHandler != null)
 554       {
 555         //here we send all data to user event handlers
 556         _actorOffStageEventHandler(this, e);
 557       }
 558     }
 559
 560     /**
 561       * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
 562       * (in the type of OnRelayoutEventHandler) provided by the user.
 563       * OnRelayout signal is emitted after the size has been set on the actor during relayout.
 564       */
 565     public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
 566     {
 567       add
 568       {
 569         lock(this)
 570         {
 571           // Restricted to only one listener
 572           if (_actorOnRelayoutEventHandler == null)
 573           {
 574             _actorOnRelayoutEventHandler += value;
 575
 576             _actorOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
 577             this.OnRelayoutSignal().Connect(_actorOnRelayoutEventCallbackDelegate);
 578           }
 579         }
 580       }
 581
 582       remove
 583       {
 584         lock(this)
 585         {
 586           if (_actorOnRelayoutEventHandler != null)
 587           {
 588             this.OnRelayoutSignal().Disconnect(_actorOnRelayoutEventCallbackDelegate);
 589           }
 590
 591           _actorOnRelayoutEventHandler -= value;
 592         }
 593       }
 594     }
 595
 596     // Callback for Actor OnRelayout signal
 597     private void OnRelayout(IntPtr data)
 598     {
 599       OnRelayoutEventArgs e = new OnRelayoutEventArgs();
 600
 601       // Populate all members of "e" (OnRelayoutEventArgs) with real data
 602       e.Actor = Actor.GetActorFromPtr(data);
 603
 604       if (_actorOnRelayoutEventHandler != null)
 605       {
 606         //here we send all data to user event handlers
 607         _actorOnRelayoutEventHandler(this, e);
 608       }
 609     }
 610
 611     public static Actor GetActorFromPtr(global::System.IntPtr cPtr) {
 612       Actor ret = new Actor(cPtr, false);
 613       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 614       return ret;
 615     }
 616
 617     public IntPtr GetPtrfromActor ()
 618     {
 619        return (IntPtr)swigCPtr;
 620     }
 621
 622     public Actor Parent
 623     {
 624       get
 625       {
 626         Actor parent = GetParent();
 627         return parent;
 628       }
 629     }
 630
 631    public bool Vibility
 632    {
 633       get
 634       {
 635         bool visibility = IsVisible();
 636         return visibility;
 637       }
 638     }
 639
 640    public float Opacity
 641    {
 642       set
 643       {
 644         SetOpacity(value);
 645       }
 646     }
 647
 648    public float CurrentOpacity
 649    {
 650       get
 651       {
 652         float ret = GetCurrentOpacity();
 653         return ret;
 654       }
 655     }
 656
 657     public bool StateFocusEnable
 658     {
 659       set
 660       {
 661         SetKeyboardFocusable(value);
 662       }
 663       get
 664       {
 665         bool focusable = IsKeyboardFocusable();
 666         return focusable;
 667       }
 668     }
 669
 670
 671   public class Property : global::System.IDisposable {
 672     private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 673     protected bool swigCMemOwn;
 674
 675     internal Property(global::System.IntPtr cPtr, bool cMemoryOwn) {
 676       swigCMemOwn = cMemoryOwn;
 677       swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 678     }
 679
 680     internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj) {
 681       return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 682     }
 683
 684     ~Property() {
 685       Dispose();
 686     }
 687
 688     public virtual void Dispose() {
 689       lock(this) {
 690         if (swigCPtr.Handle != global::System.IntPtr.Zero) {
 691           if (swigCMemOwn) {
 692             swigCMemOwn = false;
 693             NDalicPINVOKE.delete_Actor_Property(swigCPtr);
 694           }
 695           swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 696         }
 697         global::System.GC.SuppressFinalize(this);
 698       }
 699     }
 700
 701     public Property() : this(NDalicPINVOKE.new_Actor_Property(), true) {
 702       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 703     }
 704
 705     public static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
 706     public static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
 707     public static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
 708     public static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
 709     public static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
 710     public static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
 711     public static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
 712     public static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
 713     public static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
 714     public static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
 715     public static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
 716     public static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
 717     public static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
 718     public static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
 719     public static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
 720     public static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
 721     public static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
 722     public static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
 723     public static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
 724     public static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
 725     public static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
 726     public static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
 727     public static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
 728     public static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
 729     public static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
 730     public static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
 731     public static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
 732     public static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
 733     public static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
 734     public static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
 735     public static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
 736     public static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
 737     public static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
 738     public static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
 739     public static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
 740     public static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
 741     public static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
 742     public static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
 743     public static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
 744     public static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
 745     public static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
 746     public static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
 747     public static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
 748     public static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
 749     public static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
 750     public static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
 751     public static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
 752     public static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
 753     public static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
 754     public static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
 755     public static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
 756     public static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
 757     public static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
 758     public static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
 759     public static readonly int BATCH_PARENT = NDalicPINVOKE.Actor_Property_BATCH_PARENT_get();
 760
 761   }
 762
 763   public Actor () : this (NDalicPINVOKE.Actor_New(), true) {
 764       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 765
 766   }
 767   public new static Actor DownCast(BaseHandle handle) {
 768     Actor ret = new Actor(NDalicPINVOKE.Actor_DownCast(BaseHandle.getCPtr(handle)), true);
 769     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 770     return ret;
 771   }
 772
 773   public Actor(Actor copy) : this(NDalicPINVOKE.new_Actor__SWIG_1(Actor.getCPtr(copy)), true) {
 774     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 775   }
 776
 777   public Actor Assign(Actor rhs) {
 778     Actor ret = new Actor(NDalicPINVOKE.Actor_Assign(swigCPtr, Actor.getCPtr(rhs)), false);
 779     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 780     return ret;
 781   }
 782
 783   public string GetName() {
 784     string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
 785     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 786     return ret;
 787   }
 788
 789   public void SetName(string name) {
 790     NDalicPINVOKE.Actor_SetName(swigCPtr, name);
 791     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 792   }
 793
 794   public uint GetId() {
 795     uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
 796     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 797     return ret;
 798   }
 799
 800   public bool IsRoot() {
 801     bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
 802     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 803     return ret;
 804   }
 805
 806   public bool OnStage() {
 807     bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
 808     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 809     return ret;
 810   }
 811
 812   public bool IsLayer() {
 813     bool ret = NDalicPINVOKE.Actor_IsLayer(swigCPtr);
 814     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 815     return ret;
 816   }
 817
 818   public Layer GetLayer() {
 819     Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
 820     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 821     return ret;
 822   }
 823
 824   public void Add(Actor child) {
 825     NDalicPINVOKE.Actor_Add(swigCPtr, Actor.getCPtr(child));
 826     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 827   }
 828
 829   public void Remove(Actor child) {
 830     NDalicPINVOKE.Actor_Remove(swigCPtr, Actor.getCPtr(child));
 831     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 832   }
 833
 834   public void Unparent() {
 835     NDalicPINVOKE.Actor_Unparent(swigCPtr);
 836     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 837   }
 838
 839   public uint GetChildCount() {
 840     uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
 841     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 842     return ret;
 843   }
 844
 845   public Actor GetChildAt(uint index) {
 846     Actor ret = new Actor(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
 847     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 848     return ret;
 849   }
 850
 851   public Actor FindChildByName(string actorName) {
 852     Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);
 853     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 854     return ret;
 855   }
 856
 857   public Actor FindChildById(uint id) {
 858     Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
 859     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 860     return ret;
 861   }
 862
 863   public Actor GetParent() {
 864     Actor ret = new Actor(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
 865     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 866     return ret;
 867   }
 868
 869   public void SetParentOrigin(Vector3 origin) {
 870     NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
 871     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 872   }
 873
 874   public Vector3 GetCurrentParentOrigin() {
 875     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
 876     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 877     return ret;
 878   }
 879
 880   public void SetAnchorPoint(Vector3 anchorPoint) {
 881     NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
 882     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 883   }
 884
 885   public Vector3 GetCurrentAnchorPoint() {
 886     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
 887     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 888     return ret;
 889   }
 890
 891   public void SetSize(float width, float height) {
 892     NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
 893     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 894   }
 895
 896   public void SetSize(float width, float height, float depth) {
 897     NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
 898     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 899   }
 900
 901   public void SetSize(Vector2 size) {
 902     NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
 903     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 904   }
 905
 906   public void SetSize(Vector3 size) {
 907     NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
 908     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 909   }
 910
 911   public Vector3 GetTargetSize() {
 912     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
 913     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 914     return ret;
 915   }
 916
 917   public Vector3 GetCurrentSize() {
 918     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
 919     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 920     return ret;
 921   }
 922
 923   public Vector3 GetNaturalSize() {
 924     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
 925     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 926     return ret;
 927   }
 928
 929   public void SetPosition(float x, float y) {
 930     NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
 931     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 932   }
 933
 934   public void SetPosition(float x, float y, float z) {
 935     NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
 936     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 937   }
 938
 939   public void SetPosition(Vector3 position) {
 940     NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
 941     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 942   }
 943
 944   public void SetX(float x) {
 945     NDalicPINVOKE.Actor_SetX(swigCPtr, x);
 946     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 947   }
 948
 949   public void SetY(float y) {
 950     NDalicPINVOKE.Actor_SetY(swigCPtr, y);
 951     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 952   }
 953
 954   public void SetZ(float z) {
 955     NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
 956     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 957   }
 958
 959   public void TranslateBy(Vector3 distance) {
 960     NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
 961     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 962   }
 963
 964   public Vector3 GetCurrentPosition() {
 965     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
 966     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 967     return ret;
 968   }
 969
 970   public Vector3 GetCurrentWorldPosition() {
 971     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
 972     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 973     return ret;
 974   }
 975
 976   public void SetInheritPosition(bool inherit) {
 977     NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
 978     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 979   }
 980
 981   public PositionInheritanceMode GetPositionInheritanceMode() {
 982     PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);
 983     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 984     return ret;
 985   }
 986
 987   public bool IsPositionInherited() {
 988     bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
 989     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 990     return ret;
 991   }
 992
 993   public void SetOrientation(Degree angle, Vector3 axis) {
 994     NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
 995     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 996   }
 997
 998   public void SetOrientation(Radian angle, Vector3 axis) {
 999     NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
1000     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1001   }
1002
1003   public void SetOrientation(Quaternion orientation) {
1004     NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Quaternion.getCPtr(orientation));
1005     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1006   }
1007
1008   public void RotateBy(Degree angle, Vector3 axis) {
1009     NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
1010     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1011   }
1012
1013   public void RotateBy(Radian angle, Vector3 axis) {
1014     NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
1015     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1016   }
1017
1018   public void RotateBy(Quaternion relativeRotation) {
1019     NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Quaternion.getCPtr(relativeRotation));
1020     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1021   }
1022
1023   public Quaternion GetCurrentOrientation() {
1024     Quaternion ret = new Quaternion(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
1025     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1026     return ret;
1027   }
1028
1029   public void SetInheritOrientation(bool inherit) {
1030     NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
1031     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1032   }
1033
1034   public bool IsOrientationInherited() {
1035     bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
1036     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1037     return ret;
1038   }
1039
1040   public Quaternion GetCurrentWorldOrientation() {
1041     Quaternion ret = new Quaternion(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
1042     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1043     return ret;
1044   }
1045
1046   public void SetScale(float scale) {
1047     NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
1048     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1049   }
1050
1051   public void SetScale(float scaleX, float scaleY, float scaleZ) {
1052     NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
1053     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1054   }
1055
1056   public void SetScale(Vector3 scale) {
1057     NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
1058     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1059   }
1060
1061   public void ScaleBy(Vector3 relativeScale) {
1062     NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
1063     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1064   }
1065
1066   public Vector3 GetCurrentScale() {
1067     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
1068     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1069     return ret;
1070   }
1071
1072   public Vector3 GetCurrentWorldScale() {
1073     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
1074     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1075     return ret;
1076   }
1077
1078   public void SetInheritScale(bool inherit) {
1079     NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
1080     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1081   }
1082
1083   public bool IsScaleInherited() {
1084     bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
1085     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1086     return ret;
1087   }
1088
1089   public Matrix GetCurrentWorldMatrix() {
1090     Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
1091     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1092     return ret;
1093   }
1094
1095   public void SetVisible(bool visible) {
1096     NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
1097     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1098   }
1099
1100   public bool IsVisible() {
1101     bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
1102     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1103     return ret;
1104   }
1105
1106   public void SetOpacity(float opacity) {
1107     NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
1108     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1109   }
1110
1111   public float GetCurrentOpacity() {
1112     float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
1113     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1114     return ret;
1115   }
1116
1117   public void SetColor(Vector4 color) {
1118     NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
1119     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1120   }
1121
1122   public Vector4 GetCurrentColor() {
1123     Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
1124     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1125     return ret;
1126   }
1127
1128   public void SetColorMode(ColorMode colorMode) {
1129     NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
1130     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1131   }
1132
1133   public ColorMode GetColorMode() {
1134     ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
1135     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1136     return ret;
1137   }
1138
1139   public Vector4 GetCurrentWorldColor() {
1140     Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
1141     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1142     return ret;
1143   }
1144
1145   public void SetDrawMode(DrawModeType drawMode) {
1146     NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
1147     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1148   }
1149
1150   public DrawModeType GetDrawMode() {
1151     DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
1152     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1153     return ret;
1154   }
1155
1156   public void SetSensitive(bool sensitive) {
1157     NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);
1158     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1159   }
1160
1161   public bool IsSensitive() {
1162     bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);
1163     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1164     return ret;
1165   }
1166
1167   public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY) {
1168     bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
1169     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1170     return ret;
1171   }
1172
1173   public void SetLeaveRequired(bool required) {
1174     NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);
1175     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1176   }
1177
1178   public bool GetLeaveRequired() {
1179     bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);
1180     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1181     return ret;
1182   }
1183
1184   public void SetKeyboardFocusable(bool focusable) {
1185     NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
1186     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1187   }
1188
1189   public bool IsKeyboardFocusable() {
1190     bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
1191     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1192     return ret;
1193   }
1194
1195   public void SetResizePolicy(ResizePolicyType policy, DimensionType dimension) {
1196     NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
1197     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1198   }
1199
1200   public ResizePolicyType GetResizePolicy(DimensionType dimension) {
1201     ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
1202     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1203     return ret;
1204   }
1205
1206   public void SetSizeScalePolicy(SizeScalePolicyType policy) {
1207     NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);
1208     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1209   }
1210
1211   public SizeScalePolicyType GetSizeScalePolicy() {
1212     SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);
1213     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1214     return ret;
1215   }
1216
1217   public void SetSizeModeFactor(Vector3 factor) {
1218     NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
1219     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1220   }
1221
1222   public Vector3 GetSizeModeFactor() {
1223     Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
1224     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1225     return ret;
1226   }
1227
1228   public float GetHeightForWidth(float width) {
1229     float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
1230     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1231     return ret;
1232   }
1233
1234   public float GetWidthForHeight(float height) {
1235     float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
1236     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1237     return ret;
1238   }
1239
1240   public float GetRelayoutSize(DimensionType dimension) {
1241     float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
1242     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1243     return ret;
1244   }
1245
1246   public void SetPadding(RectFloat padding) {
1247     NDalicPINVOKE.Actor_SetPadding(swigCPtr, RectFloat.getCPtr(padding));
1248     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1249   }
1250
1251   public void GetPadding(RectFloat paddingOut) {
1252     NDalicPINVOKE.Actor_GetPadding(swigCPtr, RectFloat.getCPtr(paddingOut));
1253     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1254   }
1255
1256   public void SetMinimumSize(Vector2 size) {
1257     NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
1258     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1259   }
1260
1261   public Vector2 GetMinimumSize() {
1262     Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
1263     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1264     return ret;
1265   }
1266
1267   public void SetMaximumSize(Vector2 size) {
1268     NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
1269     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1270   }
1271
1272   public Vector2 GetMaximumSize() {
1273     Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
1274     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1275     return ret;
1276   }
1277
1278   public int GetHierarchyDepth() {
1279     int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
1280     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1281     return ret;
1282   }
1283
1284   public uint AddRenderer(Renderer renderer) {
1285     uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
1286     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1287     return ret;
1288   }
1289
1290   public uint GetRendererCount() {
1291     uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
1292     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1293     return ret;
1294   }
1295
1296   public Renderer GetRendererAt(uint index) {
1297     Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
1298     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1299     return ret;
1300   }
1301
1302   public void RemoveRenderer(Renderer renderer) {
1303     NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
1304     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1305   }
1306
1307   public void RemoveRenderer(uint index) {
1308     NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
1309     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1310   }
1311
1312   public ActorTouchEventSignal TouchedSignal() {
1313     ActorTouchEventSignal ret = new ActorTouchEventSignal(NDalicPINVOKE.Actor_TouchedSignal(swigCPtr), false);
1314     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1315     return ret;
1316   }
1317
1318   public ActorTouchDataSignal TouchSignal() {
1319     ActorTouchDataSignal ret = new ActorTouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
1320     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1321     return ret;
1322   }
1323
1324   public ActorHoverEventSignal HoveredSignal() {
1325     ActorHoverEventSignal ret = new ActorHoverEventSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
1326     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1327     return ret;
1328   }
1329
1330   public ActorWheelEventSignal WheelEventSignal() {
1331     ActorWheelEventSignal ret = new ActorWheelEventSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
1332     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1333     return ret;
1334   }
1335
1336   public ActorSignal OnStageSignal() {
1337     ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
1338     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1339     return ret;
1340   }
1341
1342   public ActorSignal OffStageSignal() {
1343     ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
1344     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1345     return ret;
1346   }
1347
1348   public ActorSignal OnRelayoutSignal() {
1349     ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
1350     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1351     return ret;
1352   }
1353
1354   public Vector3 ParentOrigin
1355   {
1356     get
1357     {
1358       Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
1359       GetProperty( Actor.Property.PARENT_ORIGIN).Get(  temp );
1360       return temp;
1361     }
1362     set
1363     {
1364       SetProperty( Actor.Property.PARENT_ORIGIN, new Dali.Property.Value( value ) );
1365     }
1366   }
1367   public float ParentOriginX
1368   {
1369     get
1370     {
1371       float temp = 0.0f;
1372       GetProperty( Actor.Property.PARENT_ORIGIN_X).Get( ref temp );
1373       return temp;
1374     }
1375     set
1376     {
1377       SetProperty( Actor.Property.PARENT_ORIGIN_X, new Dali.Property.Value( value ) );
1378     }
1379   }
1380   public float ParentOriginY
1381   {
1382     get
1383     {
1384       float temp = 0.0f;
1385       GetProperty( Actor.Property.PARENT_ORIGIN_Y).Get( ref temp );
1386       return temp;
1387     }
1388     set
1389     {
1390       SetProperty( Actor.Property.PARENT_ORIGIN_Y, new Dali.Property.Value( value ) );
1391     }
1392   }
1393   public float ParentOriginZ
1394   {
1395     get
1396     {
1397       float temp = 0.0f;
1398       GetProperty( Actor.Property.PARENT_ORIGIN_Z).Get( ref temp );
1399       return temp;
1400     }
1401     set
1402     {
1403       SetProperty( Actor.Property.PARENT_ORIGIN_Z, new Dali.Property.Value( value ) );
1404     }
1405   }
1406   public Vector3 AnchorPoint
1407   {
1408     get
1409     {
1410       Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
1411       GetProperty( Actor.Property.ANCHOR_POINT).Get(  temp );
1412       return temp;
1413     }
1414     set
1415     {
1416       SetProperty( Actor.Property.ANCHOR_POINT, new Dali.Property.Value( value ) );
1417     }
1418   }
1419   public float AnchorPointX
1420   {
1421     get
1422     {
1423       float temp = 0.0f;
1424       GetProperty( Actor.Property.ANCHOR_POINT_X).Get( ref temp );
1425       return temp;
1426     }
1427     set
1428     {
1429       SetProperty( Actor.Property.ANCHOR_POINT_X, new Dali.Property.Value( value ) );
1430     }
1431   }
1432   public float AnchorPointY
1433   {
1434     get
1435     {
1436       float temp = 0.0f;
1437       GetProperty( Actor.Property.ANCHOR_POINT_Y).Get( ref temp );
1438       return temp;
1439     }
1440     set
1441     {
1442       SetProperty( Actor.Property.ANCHOR_POINT_Y, new Dali.Property.Value( value ) );
1443     }
1444   }
1445   public float AnchorPointZ
1446   {
1447     get
1448     {
1449       float temp = 0.0f;
1450       GetProperty( Actor.Property.ANCHOR_POINT_Z).Get( ref temp );
1451       return temp;
1452     }
1453     set
1454     {
1455       SetProperty( Actor.Property.ANCHOR_POINT_Z, new Dali.Property.Value( value ) );
1456     }
1457   }
1458   public Vector3 Size
1459   {
1460     get
1461     {
1462       Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
1463       GetProperty( Actor.Property.SIZE).Get(  temp );
1464       return temp;
1465     }
1466     set
1467     {
1468       SetProperty( Actor.Property.SIZE, new Dali.Property.Value( value ) );
1469     }
1470   }
1471   public float SizeWidth
1472   {
1473     get
1474     {
1475       float temp = 0.0f;
1476       GetProperty( Actor.Property.SIZE_WIDTH).Get( ref temp );
1477       return temp;
1478     }
1479     set
1480     {
1481       SetProperty( Actor.Property.SIZE_WIDTH, new Dali.Property.Value( value ) );
1482     }
1483   }
1484   public float SizeHeight
1485   {
1486     get
1487     {
1488       float temp = 0.0f;
1489       GetProperty( Actor.Property.SIZE_HEIGHT).Get( ref temp );
1490       return temp;
1491     }
1492     set
1493     {
1494       SetProperty( Actor.Property.SIZE_HEIGHT, new Dali.Property.Value( value ) );
1495     }
1496   }
1497   public float SizeDepth
1498   {
1499     get
1500     {
1501       float temp = 0.0f;
1502       GetProperty( Actor.Property.SIZE_DEPTH).Get( ref temp );
1503       return temp;
1504     }
1505     set
1506     {
1507       SetProperty( Actor.Property.SIZE_DEPTH, new Dali.Property.Value( value ) );
1508     }
1509   }
1510   public Vector3 Position
1511   {
1512     get
1513     {
1514       Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
1515       GetProperty( Actor.Property.POSITION).Get(  temp );
1516       return temp;
1517     }
1518     set
1519     {
1520       SetProperty( Actor.Property.POSITION, new Dali.Property.Value( value ) );
1521     }
1522   }
1523   public float PositionX
1524   {
1525     get
1526     {
1527       float temp = 0.0f;
1528       GetProperty( Actor.Property.POSITION_X).Get( ref temp );
1529       return temp;
1530     }
1531     set
1532     {
1533       SetProperty( Actor.Property.POSITION_X, new Dali.Property.Value( value ) );
1534     }
1535   }
1536   public float PositionY
1537   {
1538     get
1539     {
1540       float temp = 0.0f;
1541       GetProperty( Actor.Property.POSITION_Y).Get( ref temp );
1542       return temp;
1543     }
1544     set
1545     {
1546       SetProperty( Actor.Property.POSITION_Y, new Dali.Property.Value( value ) );
1547     }
1548   }
1549   public float PositionZ
1550   {
1551     get
1552     {
1553       float temp = 0.0f;
1554       GetProperty( Actor.Property.POSITION_Z).Get( ref temp );
1555       return temp;
1556     }
1557     set
1558     {
1559       SetProperty( Actor.Property.POSITION_Z, new Dali.Property.Value( value ) );
1560     }
1561   }
1562   public Vector3 WorldPosition
1563   {
1564     get
1565     {
1566       Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
1567       GetProperty( Actor.Property.WORLD_POSITION).Get(  temp );
1568       return temp;
1569     }
1570 }  public float WorldPositionX
1571   {
1572     get
1573     {
1574       float temp = 0.0f;
1575       GetProperty( Actor.Property.WORLD_POSITION_X).Get( ref temp );
1576       return temp;
1577     }
1578 }  public float WorldPositionY
1579   {
1580     get
1581     {
1582       float temp = 0.0f;
1583       GetProperty( Actor.Property.WORLD_POSITION_Y).Get( ref temp );
1584       return temp;
1585     }
1586 }  public float WorldPositionZ
1587   {
1588     get
1589     {
1590       float temp = 0.0f;
1591       GetProperty( Actor.Property.WORLD_POSITION_Z).Get( ref temp );
1592       return temp;
1593     }
1594 }  public Quaternion Orientation
1595   {
1596     get
1597     {
1598       Quaternion temp = new Quaternion();
1599       GetProperty( Actor.Property.ORIENTATION).Get(  temp );
1600       return temp;
1601     }
1602     set
1603     {
1604       SetProperty( Actor.Property.ORIENTATION, new Dali.Property.Value( value ) );
1605     }
1606   }
1607   public Quaternion WorldOrientation
1608   {
1609     get
1610     {
1611       Quaternion temp = new Quaternion();
1612       GetProperty( Actor.Property.WORLD_ORIENTATION).Get(  temp );
1613       return temp;
1614     }
1615 }  public Vector3 Scale
1616   {
1617     get
1618     {
1619       Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
1620       GetProperty( Actor.Property.SCALE).Get(  temp );
1621       return temp;
1622     }
1623     set
1624     {
1625       SetProperty( Actor.Property.SCALE, new Dali.Property.Value( value ) );
1626     }
1627   }
1628   public float ScaleX
1629   {
1630     get
1631     {
1632       float temp = 0.0f;
1633       GetProperty( Actor.Property.SCALE_X).Get( ref temp );
1634       return temp;
1635     }
1636     set
1637     {
1638       SetProperty( Actor.Property.SCALE_X, new Dali.Property.Value( value ) );
1639     }
1640   }
1641   public float ScaleY
1642   {
1643     get
1644     {
1645       float temp = 0.0f;
1646       GetProperty( Actor.Property.SCALE_Y).Get( ref temp );
1647       return temp;
1648     }
1649     set
1650     {
1651       SetProperty( Actor.Property.SCALE_Y, new Dali.Property.Value( value ) );
1652     }
1653   }
1654   public float ScaleZ
1655   {
1656     get
1657     {
1658       float temp = 0.0f;
1659       GetProperty( Actor.Property.SCALE_Z).Get( ref temp );
1660       return temp;
1661     }
1662     set
1663     {
1664       SetProperty( Actor.Property.SCALE_Z, new Dali.Property.Value( value ) );
1665     }
1666   }
1667   public Vector3 WorldScale
1668   {
1669     get
1670     {
1671       Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
1672       GetProperty( Actor.Property.WORLD_SCALE).Get(  temp );
1673       return temp;
1674     }
1675 }  public bool Visible
1676   {
1677     get
1678     {
1679       bool temp = false;
1680       GetProperty( Actor.Property.VISIBLE).Get( ref temp );
1681       return temp;
1682     }
1683     set
1684     {
1685       SetProperty( Actor.Property.VISIBLE, new Dali.Property.Value( value ) );
1686     }
1687   }
1688   public Vector4 Color
1689   {
1690     get
1691     {
1692       Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
1693       GetProperty( Actor.Property.COLOR).Get(  temp );
1694       return temp;
1695     }
1696     set
1697     {
1698       SetProperty( Actor.Property.COLOR, new Dali.Property.Value( value ) );
1699     }
1700   }
1701   public float ColorRed
1702   {
1703     get
1704     {
1705       float temp = 0.0f;
1706       GetProperty( Actor.Property.COLOR_RED).Get( ref temp );
1707       return temp;
1708     }
1709     set
1710     {
1711       SetProperty( Actor.Property.COLOR_RED, new Dali.Property.Value( value ) );
1712     }
1713   }
1714   public float ColorGreen
1715   {
1716     get
1717     {
1718       float temp = 0.0f;
1719       GetProperty( Actor.Property.COLOR_GREEN).Get( ref temp );
1720       return temp;
1721     }
1722     set
1723     {
1724       SetProperty( Actor.Property.COLOR_GREEN, new Dali.Property.Value( value ) );
1725     }
1726   }
1727   public float ColorBlue
1728   {
1729     get
1730     {
1731       float temp = 0.0f;
1732       GetProperty( Actor.Property.COLOR_BLUE).Get( ref temp );
1733       return temp;
1734     }
1735     set
1736     {
1737       SetProperty( Actor.Property.COLOR_BLUE, new Dali.Property.Value( value ) );
1738     }
1739   }
1740   public float ColorAlpha
1741   {
1742     get
1743     {
1744       float temp = 0.0f;
1745       GetProperty( Actor.Property.COLOR_ALPHA).Get( ref temp );
1746       return temp;
1747     }
1748     set
1749     {
1750       SetProperty( Actor.Property.COLOR_ALPHA, new Dali.Property.Value( value ) );
1751     }
1752   }
1753   public Vector4 WorldColor
1754   {
1755     get
1756     {
1757       Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
1758       GetProperty( Actor.Property.WORLD_COLOR).Get(  temp );
1759       return temp;
1760     }
1761 }  public Matrix WorldMatrix
1762   {
1763     get
1764     {
1765       Matrix temp = new Matrix();
1766       GetProperty( Actor.Property.WORLD_MATRIX).Get(  temp );
1767       return temp;
1768     }
1769 }  public string Name
1770   {
1771     get
1772     {
1773       string temp;
1774       GetProperty( Actor.Property.NAME).Get( out temp );
1775       return temp;
1776     }
1777     set
1778     {
1779       SetProperty( Actor.Property.NAME, new Dali.Property.Value( value ) );
1780     }
1781   }
1782   public bool Sensitive
1783   {
1784     get
1785     {
1786       bool temp = false;
1787       GetProperty( Actor.Property.SENSITIVE).Get( ref temp );
1788       return temp;
1789     }
1790     set
1791     {
1792       SetProperty( Actor.Property.SENSITIVE, new Dali.Property.Value( value ) );
1793     }
1794   }
1795   public bool LeaveRequired
1796   {
1797     get
1798     {
1799       bool temp = false;
1800       GetProperty( Actor.Property.LEAVE_REQUIRED).Get( ref temp );
1801       return temp;
1802     }
1803     set
1804     {
1805       SetProperty( Actor.Property.LEAVE_REQUIRED, new Dali.Property.Value( value ) );
1806     }
1807   }
1808   public bool InheritOrientation
1809   {
1810     get
1811     {
1812       bool temp = false;
1813       GetProperty( Actor.Property.INHERIT_ORIENTATION).Get( ref temp );
1814       return temp;
1815     }
1816     set
1817     {
1818       SetProperty( Actor.Property.INHERIT_ORIENTATION, new Dali.Property.Value( value ) );
1819     }
1820   }
1821   public bool InheritScale
1822   {
1823     get
1824     {
1825       bool temp = false;
1826       GetProperty( Actor.Property.INHERIT_SCALE).Get( ref temp );
1827       return temp;
1828     }
1829     set
1830     {
1831       SetProperty( Actor.Property.INHERIT_SCALE, new Dali.Property.Value( value ) );
1832     }
1833   }
1834   public string ColorMode
1835   {
1836     get
1837     {
1838       string temp;
1839       GetProperty( Actor.Property.COLOR_MODE).Get( out temp );
1840       return temp;
1841     }
1842     set
1843     {
1844       SetProperty( Actor.Property.COLOR_MODE, new Dali.Property.Value( value ) );
1845     }
1846   }
1847   public string PositionInheritance
1848   {
1849     get
1850     {
1851       string temp;
1852       GetProperty( Actor.Property.POSITION_INHERITANCE).Get( out temp );
1853       return temp;
1854     }
1855     set
1856     {
1857       SetProperty( Actor.Property.POSITION_INHERITANCE, new Dali.Property.Value( value ) );
1858     }
1859   }
1860   public string DrawMode
1861   {
1862     get
1863     {
1864       string temp;
1865       GetProperty( Actor.Property.DRAW_MODE).Get( out temp );
1866       return temp;
1867     }
1868     set
1869     {
1870       SetProperty( Actor.Property.DRAW_MODE, new Dali.Property.Value( value ) );
1871     }
1872   }
1873   public Vector3 SizeModeFactor
1874   {
1875     get
1876     {
1877       Vector3 temp = new Vector3(0.0f,0.0f,0.0f);
1878       GetProperty( Actor.Property.SIZE_MODE_FACTOR).Get(  temp );
1879       return temp;
1880     }
1881     set
1882     {
1883       SetProperty( Actor.Property.SIZE_MODE_FACTOR, new Dali.Property.Value( value ) );
1884     }
1885   }
1886   public string WidthResizePolicy
1887   {
1888     get
1889     {
1890       string temp;
1891       GetProperty( Actor.Property.WIDTH_RESIZE_POLICY).Get( out temp );
1892       return temp;
1893     }
1894     set
1895     {
1896       SetProperty( Actor.Property.WIDTH_RESIZE_POLICY, new Dali.Property.Value( value ) );
1897     }
1898   }
1899   public string HeightResizePolicy
1900   {
1901     get
1902     {
1903       string temp;
1904       GetProperty( Actor.Property.HEIGHT_RESIZE_POLICY).Get( out temp );
1905       return temp;
1906     }
1907     set
1908     {
1909       SetProperty( Actor.Property.HEIGHT_RESIZE_POLICY, new Dali.Property.Value( value ) );
1910     }
1911   }
1912   public string SizeScalePolicy
1913   {
1914     get
1915     {
1916       string temp;
1917       GetProperty( Actor.Property.SIZE_SCALE_POLICY).Get( out temp );
1918       return temp;
1919     }
1920     set
1921     {
1922       SetProperty( Actor.Property.SIZE_SCALE_POLICY, new Dali.Property.Value( value ) );
1923     }
1924   }
1925   public bool WidthForHeight
1926   {
1927     get
1928     {
1929       bool temp = false;
1930       GetProperty( Actor.Property.WIDTH_FOR_HEIGHT).Get( ref temp );
1931       return temp;
1932     }
1933     set
1934     {
1935       SetProperty( Actor.Property.WIDTH_FOR_HEIGHT, new Dali.Property.Value( value ) );
1936     }
1937   }
1938   public bool HeightForWidth
1939   {
1940     get
1941     {
1942       bool temp = false;
1943       GetProperty( Actor.Property.HEIGHT_FOR_WIDTH).Get( ref temp );
1944       return temp;
1945     }
1946     set
1947     {
1948       SetProperty( Actor.Property.HEIGHT_FOR_WIDTH, new Dali.Property.Value( value ) );
1949     }
1950   }
1951   public Vector4 Padding
1952   {
1953     get
1954     {
1955       Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
1956       GetProperty( Actor.Property.PADDING).Get(  temp );
1957       return temp;
1958     }
1959     set
1960     {
1961       SetProperty( Actor.Property.PADDING, new Dali.Property.Value( value ) );
1962     }
1963   }
1964   public Vector2 MinimumSize
1965   {
1966     get
1967     {
1968       Vector2 temp = new Vector2(0.0f,0.0f);
1969       GetProperty( Actor.Property.MINIMUM_SIZE).Get(  temp );
1970       return temp;
1971     }
1972     set
1973     {
1974       SetProperty( Actor.Property.MINIMUM_SIZE, new Dali.Property.Value( value ) );
1975     }
1976   }
1977   public Vector2 MaximumSize
1978   {
1979     get
1980     {
1981       Vector2 temp = new Vector2(0.0f,0.0f);
1982       GetProperty( Actor.Property.MAXIMUM_SIZE).Get(  temp );
1983       return temp;
1984     }
1985     set
1986     {
1987       SetProperty( Actor.Property.MAXIMUM_SIZE, new Dali.Property.Value( value ) );
1988     }
1989   }
1990   public bool InheritPosition
1991   {
1992     get
1993     {
1994       bool temp = false;
1995       GetProperty( Actor.Property.INHERIT_POSITION).Get( ref temp );
1996       return temp;
1997     }
1998     set
1999     {
2000       SetProperty( Actor.Property.INHERIT_POSITION, new Dali.Property.Value( value ) );
2001     }
2002   }
2003   public string ClippingMode
2004   {
2005     get
2006     {
2007       string temp;
2008       GetProperty( Actor.Property.CLIPPING_MODE).Get( out temp );
2009       return temp;
2010     }
2011     set
2012     {
2013       SetProperty( Actor.Property.CLIPPING_MODE, new Dali.Property.Value( value ) );
2014     }
2015   }
2016   public bool BatchParent
2017   {
2018     get
2019     {
2020       bool temp = false;
2021       GetProperty( Actor.Property.BATCH_PARENT).Get( ref temp );
2022       return temp;
2023     }
2024     set
2025     {
2026       SetProperty( Actor.Property.BATCH_PARENT, new Dali.Property.Value( value ) );
2027     }
2028   }
2029
2030 }
2031
2032 }