Tizen.NUI/src/public/Actor.cs

   1 // Copyright (c) 2017 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 // Some have been manually changed
  18
  19
  20 namespace Tizen.NUI
  21 {
  22
  23     using System;
  24     using System.Runtime.InteropServices;
  25
  26     /// <summary>
  27     /// Actor is the primary object with which Dali applications interact.
  28     /// UI controls can be built by combining multiple actors.
  29     /// </summary>
  30     public class Actor : Handle
  31     {
  32         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  33
  34         internal Actor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Actor_SWIGUpcast(cPtr), cMemoryOwn)
  35         {
  36             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  37         }
  38
  39         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Actor obj)
  40         {
  41             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  42         }
  43
  44         ~Actor()
  45         {
  46             DisposeQueue.Instance.Add(this);
  47         }
  48
  49         /// <summary>
  50         /// To make Actor instance be disposed.
  51         /// </summary>
  52         public override void Dispose()
  53         {
  54             if (!Stage.IsInstalled())
  55             {
  56                 DisposeQueue.Instance.Add(this);
  57                 return;
  58             }
  59
  60             lock (this)
  61             {
  62                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
  63                 {
  64                     if (swigCMemOwn)
  65                     {
  66                         swigCMemOwn = false;
  67                         NDalicPINVOKE.delete_Actor(swigCPtr);
  68                     }
  69                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  70                 }
  71                 global::System.GC.SuppressFinalize(this);
  72                 base.Dispose();
  73             }
  74         }
  75
  76         internal static Actor GetActorFromPtr(global::System.IntPtr cPtr)
  77         {
  78             Actor ret = new Actor(cPtr, false);
  79             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  80             return ret;
  81         }
  82
  83         internal IntPtr GetPtrfromActor()
  84         {
  85             return (IntPtr)swigCPtr;
  86         }
  87
  88         /// <summary>
  89         ///  Retrieve the position of the Actor.
  90         ///  The coordinates are relative to the Actor's parent.
  91         /// </summary>
  92         public Position CurrentPosition
  93         {
  94             get
  95             {
  96                 return GetCurrentPosition();
  97             }
  98         }
  99
 100         /// <summary>
 101         ///  Retrieve the size of the Actor.
 102         ///  The coordinates are relative to the Actor's parent.
 103         /// </summary>
 104         public Size CurrentSize
 105         {
 106             get
 107             {
 108                 return GetCurrentSize();
 109             }
 110         }
 111
 112         /// <summary>
 113         /// Retrieves the actor's parent.
 114         /// </summary>
 115         public Actor Parent
 116         {
 117             get
 118             {
 119                 return GetParent();
 120             }
 121         }
 122
 123         /// <summary>
 124         /// Retrieves and sets the actor's opacity.
 125         /// </summary>
 126         public float Opacity
 127         {
 128             get
 129             {
 130                 float temp = 0.0f;
 131                 GetProperty(Actor.Property.COLOR_ALPHA).Get(ref temp);
 132                 return temp;
 133             }
 134             set
 135             {
 136                 SetProperty(Actor.Property.COLOR_ALPHA, new Tizen.NUI.PropertyValue(value));
 137             }
 138         }
 139
 140         /// <summary>
 141         /// Retrieves screen postion of actor's
 142         /// </summary>
 143         public Vector2 ScreenPosition
 144         {
 145             get
 146             {
 147                 Vector2 temp = new Vector2(0.0f, 0.0f);
 148                 GetProperty(Actor.Property.SCREEN_POSITION).Get(temp);
 149                 return temp;
 150             }
 151         }
 152
 153         /// <summary>
 154         /// Determines whether the anchor point should be used to determine the position of the actor.
 155         /// This is true by default.
 156         /// Note: If false, then the top-left of the actor is used for the position.
 157         /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the actor's position.
 158         /// </summary>
 159         public bool PositionUsesAnchorPoint
 160         {
 161             get
 162             {
 163                 bool temp = false;
 164                 GetProperty(Actor.Property.POSITION_USES_ANCHOR_POINT).Get(ref temp);
 165                 return temp;
 166             }
 167             set
 168             {
 169                 SetProperty(Actor.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
 170             }
 171         }
 172
 173         /// <summary>
 174         /// Queries whether the actor is connected to the Stage.
 175         /// When an actor is connected, it will be directly or indirectly parented to the root Actor.
 176         /// </summary>
 177         public bool IsOnStage
 178         {
 179             get
 180             {
 181                 return OnStage();
 182             }
 183         }
 184
 185         /// <summary>
 186         /// Gets depth in the hierarchy for the actor.
 187         /// </summary>
 188         public int HierarchyDepth
 189         {
 190             get
 191             {
 192                 return GetHierarchyDepth();
 193             }
 194         }
 195
 196         /// <summary>
 197         ///  Sets the sibling order of the actor so depth position can be defined within the same parent.
 198         ///  Note The initial value is 0.
 199         ///  Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove and LowerBelow will override the sibling order.
 200         ///  The values set by this Property will likely change.
 201         /// </summary>
 202         public int SiblingOrder
 203         {
 204             get
 205             {
 206                 int temp = 0;
 207                 GetProperty(Actor.Property.SIBLING_ORDER).Get(ref temp);
 208                 return temp;
 209             }
 210             set
 211             {
 212                 SetProperty(Actor.Property.SIBLING_ORDER, new Tizen.NUI.PropertyValue(value));
 213             }
 214         }
 215
 216         /// <summary>
 217         /// Sets the size of an actor for Width and Height.
 218         /// Geometry can be scaled to fit within this area.
 219         /// This does not interfere with the actors scale factor.
 220         /// The actors default depth is the minimum of Width & Height.
 221         /// </summary>
 222         public Size2D Size2D
 223         {
 224             get
 225             {
 226                 Size temp = new Size(0.0f, 0.0f, 0.0f);
 227                 GetProperty(Actor.Property.SIZE).Get(temp);
 228                 return new Size2D(temp);
 229             }
 230             set
 231             {
 232                 SetProperty(Actor.Property.SIZE, new PropertyValue(new Size(value)));
 233             }
 234         }
 235
 236         /// <summary>
 237         /// Sets the position of the Actor for X and Y.
 238         /// By default, sets the position vector between the parent origin and anchor point(default).
 239         /// If Position inheritance if disabled, sets the world position.
 240         /// </summary>
 241         public Position2D Position2D
 242         {
 243             get
 244             {
 245                 Position temp = new Position(0.0f, 0.0f, 0.0f);
 246                 GetProperty(Actor.Property.POSITION).Get(temp);
 247                 return new Position2D(temp);
 248             }
 249             set
 250             {
 251                 SetProperty(Actor.Property.POSITION, new PropertyValue(new Position(value)));
 252             }
 253         }
 254
 255         /// <summary>
 256         /// Sets the visibility flag of an actor as true to be shown.
 257         /// Note This is an asynchronous method; the value written may not match a value subsequently read with Visible.
 258         /// If an actor's visibility flag is set to false, then the actor and its children will not be rendered.
 259         /// This is regardless of the individual visibility values of the children i.e.an actor will only be rendered if all of its parents have visibility set to true.
 260         /// </summary>
 261         public void Show()
 262         {
 263             SetVisible(true);
 264         }
 265
 266         /// <summary>
 267         /// Sets the visibility flag of an actor as false to be hidden.
 268         /// </summary>
 269         public void Hide()
 270         {
 271             SetVisible(false);
 272         }
 273
 274         /// <summary>
 275         /// Raise actor above the next highest level of actor(s).
 276         /// Note Sibling order of actors within the parent will be updated automatically.
 277         /// Initially actors added to a parent will have the same sibling order and shown in relation to insertion order.
 278         /// Raising this actor above actors with the same sibling order as each other will raise this actor above them.
 279         /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
 280         /// </summary>
 281         public void Raise()
 282         {
 283             NDalicPINVOKE.Raise(swigCPtr);
 284             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 285         }
 286
 287         /// <summary>
 288         /// Lower the actor to underneath the level below actor(s).
 289         /// Note Sibling order of actors within the parent will be updated automatically.
 290         /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.
 291         /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
 292         /// </summary>
 293         public void Lower()
 294         {
 295             NDalicPINVOKE.Lower(swigCPtr);
 296             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 297         }
 298
 299         /// <summary>
 300         /// Raise actor above all other actors.
 301         /// Note Sibling order of actors within the parent will be updated automatically.
 302         /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
 303         /// </summary>
 304         public void RaiseToTop()
 305         {
 306             NDalicPINVOKE.RaiseToTop(swigCPtr);
 307             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 308         }
 309
 310         /// <summary>
 311         /// Lower actor to the bottom of all actors.
 312         /// Note Sibling order of actors within the parent will be updated automatically.
 313         /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
 314         /// </summary>
 315         public void LowerToBottom()
 316         {
 317             NDalicPINVOKE.LowerToBottom(swigCPtr);
 318             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 319         }
 320
 321         /// <summary>
 322         ///  Raise the actor to above the target actor.
 323         ///  Note Sibling order of actors within the parent will be updated automatically.
 324         ///  Actors on the level above the target actor will still be shown above this actor.
 325         ///  Raising this actor above actors with the same sibling order as each other will raise this actor above them.
 326         ///  Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
 327         /// </summary>
 328         /// <param name="target">Will be raised above this actor</param>
 329         public void RaiseAbove(Actor target)
 330         {
 331             NDalicPINVOKE.RaiseAbove(swigCPtr, Actor.getCPtr(target));
 332             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 333         }
 334
 335         /// <summary>
 336         /// Lower the actor to below the target actor.
 337         /// Note Sibling order of actors within the parent will be updated automatically.
 338         /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.
 339         /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
 340         /// </summary>
 341         /// <param name="target">Will be lowered below this actor</param>
 342         public void LowerBelow(Actor target)
 343         {
 344             NDalicPINVOKE.RaiseAbove(swigCPtr, Actor.getCPtr(target));
 345             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 346         }
 347
 348
 349         internal class Property : global::System.IDisposable
 350         {
 351             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 352             protected bool swigCMemOwn;
 353
 354             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
 355             {
 356                 swigCMemOwn = cMemoryOwn;
 357                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 358             }
 359
 360             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
 361             {
 362                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 363             }
 364
 365             ~Property()
 366             {
 367                 Dispose();
 368             }
 369
 370             public virtual void Dispose()
 371             {
 372                 lock (this)
 373                 {
 374                     if (swigCPtr.Handle != global::System.IntPtr.Zero)
 375                     {
 376                         if (swigCMemOwn)
 377                         {
 378                             swigCMemOwn = false;
 379                             NDalicPINVOKE.delete_Actor_Property(swigCPtr);
 380                         }
 381                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 382                     }
 383                     global::System.GC.SuppressFinalize(this);
 384                 }
 385             }
 386
 387             internal static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
 388             internal static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
 389             internal static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
 390             internal static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
 391
 392             internal Property() : this(NDalicPINVOKE.new_Actor_Property(), true)
 393             {
 394                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 395             }
 396
 397             internal static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
 398             internal static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
 399             internal static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
 400             internal static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
 401             internal static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
 402             internal static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
 403             internal static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
 404             internal static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
 405             internal static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
 406             internal static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
 407             internal static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
 408             internal static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
 409             internal static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
 410             internal static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
 411             internal static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
 412             internal static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
 413             internal static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
 414             internal static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
 415             internal static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
 416             internal static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
 417             internal static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
 418             internal static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
 419             internal static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
 420             internal static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
 421             internal static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
 422             internal static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
 423             internal static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
 424             internal static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
 425             internal static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
 426             internal static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
 427             internal static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
 428             internal static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
 429             internal static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
 430             internal static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
 431             internal static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
 432             internal static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
 433             internal static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
 434             internal static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
 435             internal static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
 436             internal static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
 437             internal static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
 438             internal static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
 439             internal static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
 440             internal static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
 441             internal static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
 442             internal static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
 443             internal static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
 444             internal static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
 445             internal static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
 446             internal static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
 447             internal static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
 448             internal static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
 449             internal static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
 450             internal static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
 451
 452         }
 453
 454         /// <summary>
 455         /// Creates an initialized Actor.
 456         /// </summary>
 457         public Actor() : this(NDalicPINVOKE.Actor_New(), true)
 458         {
 459             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 460
 461         }
 462
 463         /// <summary>
 464         /// Downcasts a handle to Actor handle.
 465         /// If handle points to an Actor object, the downcast produces valid handle.
 466         /// If not, the returned handle is left uninitialized.   *
 467         /// </summary>
 468         /// <param name="handle">handle to An object</param>
 469         /// <returns>handle to a Actor object or an uninitialized handle</returns>
 470         public new static Actor DownCast(BaseHandle handle)
 471         {
 472             Actor ret = new Actor(NDalicPINVOKE.Actor_DownCast(BaseHandle.getCPtr(handle)), true);
 473             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 474             return ret;
 475         }
 476
 477         internal Actor(Actor copy) : this(NDalicPINVOKE.new_Actor__SWIG_1(Actor.getCPtr(copy)), true)
 478         {
 479             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 480         }
 481
 482         internal Actor Assign(Actor rhs)
 483         {
 484             Actor ret = new Actor(NDalicPINVOKE.Actor_Assign(swigCPtr, Actor.getCPtr(rhs)), false);
 485             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 486             return ret;
 487         }
 488
 489         internal string GetName()
 490         {
 491             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
 492             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 493             return ret;
 494         }
 495
 496         internal void SetName(string name)
 497         {
 498             NDalicPINVOKE.Actor_SetName(swigCPtr, name);
 499             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 500         }
 501
 502         internal uint GetId()
 503         {
 504             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
 505             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 506             return ret;
 507         }
 508
 509         internal bool IsRoot()
 510         {
 511             bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
 512             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 513             return ret;
 514         }
 515
 516         internal bool OnStage()
 517         {
 518             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
 519             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 520             return ret;
 521         }
 522
 523         internal bool IsLayer()
 524         {
 525             bool ret = NDalicPINVOKE.Actor_IsLayer(swigCPtr);
 526             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 527             return ret;
 528         }
 529
 530         internal Layer GetLayer()
 531         {
 532             Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
 533             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 534             return ret;
 535         }
 536
 537         /// <summary>
 538         /// Adds a child Actor to this Actor.
 539         /// Precondition : This Actor(the parent) has been initialized. The child actor has been initialized. The child actor is not the same as the parent actor.
 540         /// PostCondition : The child will be referenced by its parent. This means that the child will be kept alive, even if the handle passed into this method is reset or destroyed.
 541         /// Note : If the child already has a parent, it will be removed from old parent and reparented to this actor. This may change child's position, color, scale etc as it now inherits them from this actor.
 542         /// </summary>
 543         /// <param name="child">The child</param>
 544         public void Add(Actor child)
 545         {
 546             NDalicPINVOKE.Actor_Add(swigCPtr, Actor.getCPtr(child));
 547             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 548         }
 549
 550         /// <summary>
 551         /// Removes a child Actor from this Actor. If the actor was not a child of this actor, this is a no-op.
 552         /// Precondition : This Actor(the parent) has been initialized. The child actor is not the same as the parent actor.
 553         /// </summary>
 554         /// <param name="child">The child</param>
 555         public void Remove(Actor child)
 556         {
 557             NDalicPINVOKE.Actor_Remove(swigCPtr, Actor.getCPtr(child));
 558             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 559         }
 560
 561         internal void Unparent()
 562         {
 563             NDalicPINVOKE.Actor_Unparent(swigCPtr);
 564             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 565         }
 566
 567         /// <summary>
 568         /// Retrieves the number of children held by the actor.
 569         /// Precondition :  The Actor has been initialized.
 570         /// </summary>
 571         /// <returns>The number of children</returns>
 572         public uint GetChildCount()
 573         {
 574             uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
 575             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 576             return ret;
 577         }
 578
 579         /// <summary>
 580         /// Retrieve and child actor by index.
 581         /// Precondition : The Actor has been initialized.
 582         /// </summary>
 583         /// <param name="index">The index of the child to retrieve</param>
 584         /// <returns>The actor for the given index or empty handle if children not initialized</returns>
 585         public Actor GetChildAt(uint index)
 586         {
 587             Actor ret = new Actor(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
 588             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 589             return ret;
 590         }
 591
 592         /// <summary>
 593         /// Search through this actor's hierarchy for an actor with the given name.
 594         /// The actor itself is also considered in the search.
 595         ///Precondition :  The Actor has been initialized.
 596         /// </summary>
 597         /// <param name="actorName">The name of the actor to find</param>
 598         /// <returns>A handle to the actor if found, or an empty handle if not</returns>
 599         public Actor FindChildByName(string actorName)
 600         {
 601             Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);
 602             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 603             return ret;
 604         }
 605
 606         internal Actor FindChildById(uint id)
 607         {
 608             Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
 609             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 610             return ret;
 611         }
 612
 613         internal Actor GetParent()
 614         {
 615             Actor ret = new Actor(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
 616             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 617             return ret;
 618         }
 619
 620         internal void SetParentOrigin(Vector3 origin)
 621         {
 622             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
 623             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 624         }
 625
 626         internal Vector3 GetCurrentParentOrigin()
 627         {
 628             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
 629             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 630             return ret;
 631         }
 632
 633         internal void SetAnchorPoint(Vector3 anchorPoint)
 634         {
 635             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
 636             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 637         }
 638
 639         internal Vector3 GetCurrentAnchorPoint()
 640         {
 641             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
 642             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 643             return ret;
 644         }
 645
 646         internal void SetSize(float width, float height)
 647         {
 648             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
 649             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 650         }
 651
 652         internal void SetSize(float width, float height, float depth)
 653         {
 654             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
 655             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 656         }
 657
 658         internal void SetSize(Vector2 size)
 659         {
 660             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
 661             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 662         }
 663
 664         internal void SetSize(Vector3 size)
 665         {
 666             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
 667             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 668         }
 669
 670         internal Vector3 GetTargetSize()
 671         {
 672             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
 673             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 674             return ret;
 675         }
 676
 677         internal Size GetCurrentSize()
 678         {
 679             Size ret = new Size(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
 680             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 681             return ret;
 682         }
 683
 684         /// <summary>
 685         /// Returns the natural size of the actor.
 686         /// Deriving classes stipulate the natural size and by default an actor has a ZERO natural size.
 687         /// </summary>
 688         /// <returns>The actor's natural size</returns>
 689         public Vector3 GetNaturalSize()
 690         {
 691             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
 692             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 693             return ret;
 694         }
 695
 696         internal void SetPosition(float x, float y)
 697         {
 698             NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
 699             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 700         }
 701
 702         internal void SetPosition(float x, float y, float z)
 703         {
 704             NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
 705             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 706         }
 707
 708         internal void SetPosition(Vector3 position)
 709         {
 710             NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
 711             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 712         }
 713
 714         internal void SetX(float x)
 715         {
 716             NDalicPINVOKE.Actor_SetX(swigCPtr, x);
 717             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 718         }
 719
 720         internal void SetY(float y)
 721         {
 722             NDalicPINVOKE.Actor_SetY(swigCPtr, y);
 723             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 724         }
 725
 726         internal void SetZ(float z)
 727         {
 728             NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
 729             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 730         }
 731
 732         internal void TranslateBy(Vector3 distance)
 733         {
 734             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
 735             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 736         }
 737
 738         internal Position GetCurrentPosition()
 739         {
 740             Position ret = new Position(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
 741             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 742             return ret;
 743         }
 744
 745         internal Vector3 GetCurrentWorldPosition()
 746         {
 747             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
 748             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 749             return ret;
 750         }
 751
 752         internal void SetInheritPosition(bool inherit)
 753         {
 754             NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
 755             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 756         }
 757
 758         internal PositionInheritanceMode GetPositionInheritanceMode()
 759         {
 760             PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);
 761             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 762             return ret;
 763         }
 764
 765         internal bool IsPositionInherited()
 766         {
 767             bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
 768             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 769             return ret;
 770         }
 771
 772         internal void SetOrientation(Degree angle, Vector3 axis)
 773         {
 774             NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
 775             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 776         }
 777
 778         internal void SetOrientation(Radian angle, Vector3 axis)
 779         {
 780             NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
 781             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 782         }
 783
 784         internal void SetOrientation(Rotation orientation)
 785         {
 786             NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
 787             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 788         }
 789
 790         internal void RotateBy(Degree angle, Vector3 axis)
 791         {
 792             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
 793             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 794         }
 795
 796         internal void RotateBy(Radian angle, Vector3 axis)
 797         {
 798             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
 799             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 800         }
 801
 802         internal void RotateBy(Rotation relativeRotation)
 803         {
 804             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
 805             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 806         }
 807
 808         internal Rotation GetCurrentOrientation()
 809         {
 810             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
 811             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 812             return ret;
 813         }
 814
 815         internal void SetInheritOrientation(bool inherit)
 816         {
 817             NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
 818             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 819         }
 820
 821         internal bool IsOrientationInherited()
 822         {
 823             bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
 824             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 825             return ret;
 826         }
 827
 828         internal Rotation GetCurrentWorldOrientation()
 829         {
 830             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
 831             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 832             return ret;
 833         }
 834
 835         internal void SetScale(float scale)
 836         {
 837             NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
 838             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 839         }
 840
 841         internal void SetScale(float scaleX, float scaleY, float scaleZ)
 842         {
 843             NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
 844             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 845         }
 846
 847         internal void SetScale(Vector3 scale)
 848         {
 849             NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
 850             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 851         }
 852
 853         internal void ScaleBy(Vector3 relativeScale)
 854         {
 855             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
 856             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 857         }
 858
 859         internal Vector3 GetCurrentScale()
 860         {
 861             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
 862             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 863             return ret;
 864         }
 865
 866         internal Vector3 GetCurrentWorldScale()
 867         {
 868             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
 869             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 870             return ret;
 871         }
 872
 873         internal void SetInheritScale(bool inherit)
 874         {
 875             NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
 876             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 877         }
 878
 879         internal bool IsScaleInherited()
 880         {
 881             bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
 882             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 883             return ret;
 884         }
 885
 886         internal Matrix GetCurrentWorldMatrix()
 887         {
 888             Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
 889             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 890             return ret;
 891         }
 892
 893         internal void SetVisible(bool visible)
 894         {
 895             NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
 896             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 897         }
 898
 899         internal bool IsVisible()
 900         {
 901             bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
 902             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 903             return ret;
 904         }
 905
 906         internal void SetOpacity(float opacity)
 907         {
 908             NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
 909             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 910         }
 911
 912         internal float GetCurrentOpacity()
 913         {
 914             float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
 915             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 916             return ret;
 917         }
 918
 919         internal void SetColor(Vector4 color)
 920         {
 921             NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
 922             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 923         }
 924
 925         internal Vector4 GetCurrentColor()
 926         {
 927             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
 928             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 929             return ret;
 930         }
 931
 932         internal void SetColorMode(ColorMode colorMode)
 933         {
 934             NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
 935             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 936         }
 937
 938         internal ColorMode GetColorMode()
 939         {
 940             ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
 941             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 942             return ret;
 943         }
 944
 945         internal Vector4 GetCurrentWorldColor()
 946         {
 947             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
 948             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 949             return ret;
 950         }
 951
 952         internal void SetDrawMode(DrawModeType drawMode)
 953         {
 954             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
 955             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 956         }
 957
 958         internal DrawModeType GetDrawMode()
 959         {
 960             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
 961             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 962             return ret;
 963         }
 964
 965         internal void SetSensitive(bool sensitive)
 966         {
 967             NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);
 968             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 969         }
 970
 971         internal bool IsSensitive()
 972         {
 973             bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);
 974             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 975             return ret;
 976         }
 977
 978         /// <summary>
 979         /// Converts screen coordinates into the actor's coordinate system using the default camera.
 980         /// Precondition : The Actor has been initialized.
 981         /// Note : The actor coordinates are relative to the top-left(0.0, 0.0, 0.5)
 982         /// </summary>
 983         /// <param name="localX">On return, the X-coordinate relative to the actor</param>
 984         /// <param name="localY">On return, the Y-coordinate relative to the actor</param>
 985         /// <param name="screenX">The screen X-coordinate</param>
 986         /// <param name="screenY">The screen Y-coordinate</param>
 987         /// <returns>True if the conversion succeeded</returns>
 988         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
 989         {
 990             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
 991             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 992             return ret;
 993         }
 994
 995         internal void SetLeaveRequired(bool required)
 996         {
 997             NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);
 998             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 999         }
1000
1001         internal bool GetLeaveRequired()
1002         {
1003             bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);
1004             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1005             return ret;
1006         }
1007
1008         internal void SetKeyboardFocusable(bool focusable)
1009         {
1010             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
1011             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1012         }
1013
1014         internal bool IsKeyboardFocusable()
1015         {
1016             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
1017             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1018             return ret;
1019         }
1020
1021         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
1022         {
1023             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
1024             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1025         }
1026
1027         internal ResizePolicyType GetResizePolicy(DimensionType dimension)
1028         {
1029             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
1030             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1031             return ret;
1032         }
1033
1034         internal void SetSizeScalePolicy(SizeScalePolicyType policy)
1035         {
1036             NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);
1037             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1038         }
1039
1040         internal SizeScalePolicyType GetSizeScalePolicy()
1041         {
1042             SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);
1043             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1044             return ret;
1045         }
1046
1047         /// <summary>
1048         /// Sets the relative to parent size factor of the actor.
1049         /// This factor is only used when ResizePolicy is set to either
1050         /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicy
1051         /// Precondition : The Actor has been initialized.
1052         /// </summary>
1053         /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis</param>
1054         public void SetSizeModeFactor(Vector3 factor)
1055         {
1056             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
1057             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1058         }
1059
1060         internal Vector3 GetSizeModeFactor()
1061         {
1062             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
1063             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1064             return ret;
1065         }
1066
1067         /// <summary>
1068         /// Calculates the height of the actor given a width.
1069         /// The natural size is used for default calculation.
1070         /// size 0 is treated as aspect ratio 1:1.
1071         /// </summary>
1072         /// <param name="width">Width to use</param>
1073         /// <returns>the height based on the width</returns>
1074         public float GetHeightForWidth(float width)
1075         {
1076             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
1077             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1078             return ret;
1079         }
1080
1081         /// <summary>
1082         /// Calculates the width of the actor given a height.
1083         /// The natural size is used for default calculation.
1084         /// size 0 is treated as aspect ratio 1:1.
1085         /// </summary>
1086         /// <param name="height">Height to use</param>
1087         /// <returns>the width based on the height</returns>
1088         public float GetWidthForHeight(float height)
1089         {
1090             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
1091             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1092             return ret;
1093         }
1094
1095         public float GetRelayoutSize(DimensionType dimension)
1096         {
1097             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
1098             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1099             return ret;
1100         }
1101
1102         /// <summary>
1103         /// Sets the padding for use in layout.
1104         /// </summary>
1105         /// <param name="padding">padding Padding for the actor</param>
1106         public void SetPadding(PaddingType padding)
1107         {
1108             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
1109             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1110         }
1111
1112         /// <summary>
1113         /// Returns the value of the padding.
1114         /// </summary>
1115         /// <param name="paddingOut">The returned padding data</param>
1116         public void GetPadding(PaddingType paddingOut)
1117         {
1118             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
1119             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1120         }
1121
1122         internal void SetMinimumSize(Vector2 size)
1123         {
1124             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
1125             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1126         }
1127
1128         internal Vector2 GetMinimumSize()
1129         {
1130             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
1131             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1132             return ret;
1133         }
1134
1135         internal void SetMaximumSize(Vector2 size)
1136         {
1137             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
1138             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1139         }
1140
1141         internal Vector2 GetMaximumSize()
1142         {
1143             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
1144             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1145             return ret;
1146         }
1147
1148         internal int GetHierarchyDepth()
1149         {
1150             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
1151             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1152             return ret;
1153         }
1154
1155         internal uint AddRenderer(Renderer renderer)
1156         {
1157             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
1158             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1159             return ret;
1160         }
1161
1162         internal uint GetRendererCount()
1163         {
1164             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
1165             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1166             return ret;
1167         }
1168
1169         internal Renderer GetRendererAt(uint index)
1170         {
1171             Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
1172             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1173             return ret;
1174         }
1175
1176         internal void RemoveRenderer(Renderer renderer)
1177         {
1178             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
1179             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1180         }
1181
1182         internal void RemoveRenderer(uint index)
1183         {
1184             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
1185             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1186         }
1187
1188         internal SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t TouchedSignal()
1189         {
1190             SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t ret = new SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t(NDalicPINVOKE.Actor_TouchedSignal(swigCPtr), false);
1191             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1192             return ret;
1193         }
1194
1195         internal ActorTouchDataSignal TouchSignal()
1196         {
1197             ActorTouchDataSignal ret = new ActorTouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
1198             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1199             return ret;
1200         }
1201
1202         internal ActorHoverSignal HoveredSignal()
1203         {
1204             ActorHoverSignal ret = new ActorHoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
1205             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1206             return ret;
1207         }
1208
1209         internal ActorWheelSignal WheelEventSignal()
1210         {
1211             ActorWheelSignal ret = new ActorWheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
1212             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1213             return ret;
1214         }
1215
1216         internal ActorSignal OnStageSignal()
1217         {
1218             ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
1219             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1220             return ret;
1221         }
1222
1223         internal ActorSignal OffStageSignal()
1224         {
1225             ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
1226             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1227             return ret;
1228         }
1229
1230         internal ActorSignal OnRelayoutSignal()
1231         {
1232             ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
1233             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1234             return ret;
1235         }
1236
1237         /// <summary>
1238         /// Gets/Sets the origin of an actor, within its parent's area.
1239         /// This is expressed in unit coordinates, such that(0.0, 0.0, 0.5) is the top-left corner of the parent, and(1.0, 1.0, 0.5) is the bottom-right corner.
1240         /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).
1241         /// An actor's position is the distance between this origin, and the actor's anchor-point.
1242         /// Precondition : The Actor has been initialized.
1243         /// </summary>
1244         public Position ParentOrigin
1245         {
1246             get
1247             {
1248                 Position temp = new Position(0.0f, 0.0f, 0.0f);
1249                 GetProperty(Actor.Property.PARENT_ORIGIN).Get(temp);
1250                 return temp;
1251             }
1252             set
1253             {
1254                 SetProperty(Actor.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue(value));
1255             }
1256         }
1257
1258         /// <summary>
1259         /// Gets/Sets the anchor-point of an actor.
1260         /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the actor, and(1.0, 1.0, 0.5) is the bottom-right corner.
1261         /// The default anchor point is AnchorPoint.Center (0.5, 0.5, 0.5).
1262         /// An actor position is the distance between its parent-origin and this anchor-point.
1263         /// An actor's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.
1264         /// Precondition : The Actor has been initialized.
1265         /// </summary>
1266         public Position AnchorPoint
1267         {
1268             get
1269             {
1270                 Position temp = new Position(0.0f, 0.0f, 0.0f);
1271                 GetProperty(Actor.Property.ANCHOR_POINT).Get(temp);
1272                 return temp;
1273             }
1274             set
1275             {
1276                 SetProperty(Actor.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
1277             }
1278         }
1279
1280
1281         /// <summary>
1282         /// Gets/Sets the size of an actor.
1283         /// Geometry can be scaled to fit within this area.
1284         /// This does not interfere with the actors scale factor.
1285         /// </summary>
1286         public Size Size
1287         {
1288             get
1289             {
1290                 Size temp = new Size(0.0f, 0.0f, 0.0f);
1291                 GetProperty(Actor.Property.SIZE).Get(temp);
1292                 return temp;
1293             }
1294             set
1295             {
1296                 SetProperty(Actor.Property.SIZE, new Tizen.NUI.PropertyValue(value));
1297             }
1298         }
1299
1300         /// <summary>
1301         /// Gets/Sets the size width of an actor.
1302         /// </summary>
1303         public float SizeWidth
1304         {
1305             get
1306             {
1307                 float temp = 0.0f;
1308                 GetProperty(Actor.Property.SIZE_WIDTH).Get(ref temp);
1309                 return temp;
1310             }
1311             set
1312             {
1313                 SetProperty(Actor.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
1314             }
1315         }
1316
1317         /// <summary>
1318         /// Gets/Sets the size height of an actor.
1319         /// </summary>
1320         public float SizeHeight
1321         {
1322             get
1323             {
1324                 float temp = 0.0f;
1325                 GetProperty(Actor.Property.SIZE_HEIGHT).Get(ref temp);
1326                 return temp;
1327             }
1328             set
1329             {
1330                 SetProperty(Actor.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
1331             }
1332         }
1333
1334         /// <summary>
1335         /// Gets/Sets the size depth of an actor.
1336         /// </summary>
1337         public float SizeDepth
1338         {
1339             get
1340             {
1341                 float temp = 0.0f;
1342                 GetProperty(Actor.Property.SIZE_DEPTH).Get(ref temp);
1343                 return temp;
1344             }
1345             set
1346             {
1347                 SetProperty(Actor.Property.SIZE_DEPTH, new Tizen.NUI.PropertyValue(value));
1348             }
1349         }
1350
1351         /// <summary>
1352         /// Gets/Sets the position of the Actor.
1353         /// By default, sets the position vector between the parent origin and anchor point(default).
1354         /// If Position inheritance if disabled, sets the world position.
1355         /// </summary>
1356         public Position Position
1357         {
1358             get
1359             {
1360                 Position temp = new Position(0.0f, 0.0f, 0.0f);
1361                 GetProperty(Actor.Property.POSITION).Get(temp);
1362                 return temp;
1363             }
1364             set
1365             {
1366                 SetProperty(Actor.Property.POSITION, new Tizen.NUI.PropertyValue(value));
1367             }
1368         }
1369
1370
1371         /// <summary>
1372         /// Gets/Sets the position x of the Actor.
1373         /// </summary>
1374         public float PositionX
1375         {
1376             get
1377             {
1378                 float temp = 0.0f;
1379                 GetProperty(Actor.Property.POSITION_X).Get(ref temp);
1380                 return temp;
1381             }
1382             set
1383             {
1384                 SetProperty(Actor.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));
1385             }
1386         }
1387
1388         /// <summary>
1389         /// Gets/Sets the position y of the Actor.
1390         /// </summary>
1391         public float PositionY
1392         {
1393             get
1394             {
1395                 float temp = 0.0f;
1396                 GetProperty(Actor.Property.POSITION_Y).Get(ref temp);
1397                 return temp;
1398             }
1399             set
1400             {
1401                 SetProperty(Actor.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));
1402             }
1403         }
1404
1405         /// <summary>
1406         /// Gets/Sets the position z of the Actor.
1407         /// </summary>
1408         public float PositionZ
1409         {
1410             get
1411             {
1412                 float temp = 0.0f;
1413                 GetProperty(Actor.Property.POSITION_Z).Get(ref temp);
1414                 return temp;
1415             }
1416             set
1417             {
1418                 SetProperty(Actor.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));
1419             }
1420         }
1421
1422         /// <summary>
1423         /// Gets/Sets the world position of the Actor.
1424         /// </summary>
1425         public Vector3 WorldPosition
1426         {
1427             get
1428             {
1429                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
1430                 GetProperty(Actor.Property.WORLD_POSITION).Get(temp);
1431                 return temp;
1432             }
1433         }
1434
1435         /// <summary>
1436         /// Gets/Sets the orientation of the Actor.
1437         /// An actor's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.
1438         /// Note: This is an asynchronous method.
1439         /// </summary>
1440         public Rotation Orientation
1441         {
1442             get
1443             {
1444                 Rotation temp = new Rotation();
1445                 GetProperty(Actor.Property.ORIENTATION).Get(temp);
1446                 return temp;
1447             }
1448             set
1449             {
1450                 SetProperty(Actor.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));
1451             }
1452         }
1453
1454         /// <summary>
1455         /// Gets/Sets the world orientation of the Actor.
1456         /// </summary>
1457         public Rotation WorldOrientation
1458         {
1459             get
1460             {
1461                 Rotation temp = new Rotation();
1462                 GetProperty(Actor.Property.WORLD_ORIENTATION).Get(temp);
1463                 return temp;
1464             }
1465         }
1466
1467         /// <summary>
1468         /// Gets/Sets the scale factor applied to an actor.
1469         /// Note : This is an asynchronous method.
1470         /// </summary>
1471         public Vector3 Scale
1472         {
1473             get
1474             {
1475                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
1476                 GetProperty(Actor.Property.SCALE).Get(temp);
1477                 return temp;
1478             }
1479             set
1480             {
1481                 SetProperty(Actor.Property.SCALE, new Tizen.NUI.PropertyValue(value));
1482             }
1483         }
1484
1485         /// <summary>
1486         /// Gets/Sets the scale x factor applied to an actor.
1487         /// </summary>
1488         public float ScaleX
1489         {
1490             get
1491             {
1492                 float temp = 0.0f;
1493                 GetProperty(Actor.Property.SCALE_X).Get(ref temp);
1494                 return temp;
1495             }
1496             set
1497             {
1498                 SetProperty(Actor.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));
1499             }
1500         }
1501
1502         /// <summary>
1503         /// Gets/Sets the scale y factor applied to an actor.
1504         /// </summary>
1505         public float ScaleY
1506         {
1507             get
1508             {
1509                 float temp = 0.0f;
1510                 GetProperty(Actor.Property.SCALE_Y).Get(ref temp);
1511                 return temp;
1512             }
1513             set
1514             {
1515                 SetProperty(Actor.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));
1516             }
1517         }
1518
1519         /// <summary>
1520         /// Gets/Sets the scale z factor applied to an actor.
1521         /// </summary>
1522         public float ScaleZ
1523         {
1524             get
1525             {
1526                 float temp = 0.0f;
1527                 GetProperty(Actor.Property.SCALE_Z).Get(ref temp);
1528                 return temp;
1529             }
1530             set
1531             {
1532                 SetProperty(Actor.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));
1533             }
1534         }
1535
1536         /// <summary>
1537         /// Gets the world scale of Actor.
1538         /// </summary>
1539         public Vector3 WorldScale
1540         {
1541             get
1542             {
1543                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
1544                 GetProperty(Actor.Property.WORLD_SCALE).Get(temp);
1545                 return temp;
1546             }
1547         }
1548
1549         /// <summary>
1550         /// Retrieves the visibility flag of an actor.
1551         /// Note : If an actor is not visible, then the actor and its children will not be rendered.
1552         /// This is regardless of the individual visibility values of the children i.e.an actor will only be rendered if all of its parents have visibility set to true.
1553         /// </summary>
1554         public bool Visible
1555         {
1556             get
1557             {
1558                 bool temp = false;
1559                 GetProperty(Actor.Property.VISIBLE).Get(ref temp);
1560                 return temp;
1561             }
1562             /* only get is required : removed
1563             set
1564             {
1565                 SetProperty(Actor.Property.VISIBLE, new Tizen.NUI.PropertyValue(value));
1566             }
1567             */
1568         }
1569
1570         /// <summary>
1571         /// Gets/Sets the actor's mix color; this is an RGBA value.
1572         /// The final color of the actor depends on its color mode.
1573         /// Note : This is an asynchronous method.
1574         /// </summary>
1575         public Color MixColor
1576         {
1577             get
1578             {
1579                 Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);
1580                 GetProperty(Actor.Property.COLOR).Get(temp);
1581                 return temp;
1582             }
1583             set
1584             {
1585                 SetProperty(Actor.Property.COLOR, new Tizen.NUI.PropertyValue(value));
1586             }
1587         }
1588
1589         /// <summary>
1590         /// Gets/Sets the actor's mix color red.
1591         /// </summary>
1592         public float ColorRed
1593         {
1594             get
1595             {
1596                 float temp = 0.0f;
1597                 GetProperty(Actor.Property.COLOR_RED).Get(ref temp);
1598                 return temp;
1599             }
1600             set
1601             {
1602                 SetProperty(Actor.Property.COLOR_RED, new Tizen.NUI.PropertyValue(value));
1603             }
1604         }
1605
1606         /// <summary>
1607         /// Gets/Sets the actor's mix color green.
1608         /// </summary>
1609         public float ColorGreen
1610         {
1611             get
1612             {
1613                 float temp = 0.0f;
1614                 GetProperty(Actor.Property.COLOR_GREEN).Get(ref temp);
1615                 return temp;
1616             }
1617             set
1618             {
1619                 SetProperty(Actor.Property.COLOR_GREEN, new Tizen.NUI.PropertyValue(value));
1620             }
1621         }
1622
1623         /// <summary>
1624         /// Gets/Sets the actor's mix color blue
1625         /// </summary>
1626         public float ColorBlue
1627         {
1628             get
1629             {
1630                 float temp = 0.0f;
1631                 GetProperty(Actor.Property.COLOR_BLUE).Get(ref temp);
1632                 return temp;
1633             }
1634             set
1635             {
1636                 SetProperty(Actor.Property.COLOR_BLUE, new Tizen.NUI.PropertyValue(value));
1637             }
1638         }
1639
1640         /// <summary>
1641         /// Gets/Sets the actor's mix color alpha.
1642         /// </summary>
1643         public float ColorAlpha
1644         {
1645             get
1646             {
1647                 float temp = 0.0f;
1648                 GetProperty(Actor.Property.COLOR_ALPHA).Get(ref temp);
1649                 return temp;
1650             }
1651             set
1652             {
1653                 SetProperty(Actor.Property.COLOR_ALPHA, new Tizen.NUI.PropertyValue(value));
1654             }
1655         }
1656
1657         /// <summary>
1658         /// Gets the actor's world color.
1659         /// </summary>
1660         public Color WorldColor
1661         {
1662             get
1663             {
1664                 Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);
1665                 GetProperty(Actor.Property.WORLD_COLOR).Get(temp);
1666                 return temp;
1667             }
1668         }
1669
1670         /// <summary>
1671         /// Gets/Sets the Actor's name.
1672         /// </summary>
1673         public string Name
1674         {
1675             get
1676             {
1677                 string temp;
1678                 GetProperty(Actor.Property.NAME).Get(out temp);
1679                 return temp;
1680             }
1681             set
1682             {
1683                 SetProperty(Actor.Property.NAME, new Tizen.NUI.PropertyValue(value));
1684             }
1685         }
1686
1687         /// <summary>
1688         /// Gets/Sets the status of whether an actor should emit touch or hover signals.
1689         /// </summary>
1690         public bool Sensitive
1691         {
1692             get
1693             {
1694                 bool temp = false;
1695                 GetProperty(Actor.Property.SENSITIVE).Get(ref temp);
1696                 return temp;
1697             }
1698             set
1699             {
1700                 SetProperty(Actor.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));
1701             }
1702         }
1703
1704         /// <summary>
1705         /// Gets/Sets the status of whether the actor should receive a notification when touch or hover motion events leave the boundary of the actor.
1706         /// </summary>
1707         public bool LeaveRequired
1708         {
1709             get
1710             {
1711                 bool temp = false;
1712                 GetProperty(Actor.Property.LEAVE_REQUIRED).Get(ref temp);
1713                 return temp;
1714             }
1715             set
1716             {
1717                 SetProperty(Actor.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));
1718             }
1719         }
1720
1721         /// <summary>
1722         /// Gets/Sets the status of whether a child actor inherits it's parent's orientation.
1723         /// </summary>
1724         public bool InheritOrientation
1725         {
1726             get
1727             {
1728                 bool temp = false;
1729                 GetProperty(Actor.Property.INHERIT_ORIENTATION).Get(ref temp);
1730                 return temp;
1731             }
1732             set
1733             {
1734                 SetProperty(Actor.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));
1735             }
1736         }
1737
1738         /// <summary>
1739         /// Gets/Sets the status of whether a child actor inherits it's parent's scale.
1740         /// </summary>
1741         public bool InheritScale
1742         {
1743             get
1744             {
1745                 bool temp = false;
1746                 GetProperty(Actor.Property.INHERIT_SCALE).Get(ref temp);
1747                 return temp;
1748             }
1749             set
1750             {
1751                 SetProperty(Actor.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));
1752             }
1753         }
1754
1755         /// <summary>
1756         /// Gets/Sets the actor's color mode.
1757         /// This specifies whether the Actor uses its own color, or inherits its parent color.
1758         /// The default is UseOwnMultiplyParentAlpha.
1759         /// </summary>
1760         public ColorMode ColorMode
1761         {
1762             get
1763             {
1764                 string temp;
1765                 if (GetProperty(Actor.Property.COLOR_MODE).Get(out temp) == false)
1766                 {
1767                     //Tizen.Log.Error("NUI", "ColorMode get error!");
1768                 }
1769                 switch (temp)
1770                 {
1771                     case "USE_OWN_COLOR":
1772                     return ColorMode.UseOwnColor;
1773                     case "USE_PARENT_COLOR":
1774                     return ColorMode.UseParentColor;
1775                     case "USE_OWN_MULTIPLY_PARENT_COLOR":
1776                     return ColorMode.UseOwnMultiplyParentColor;
1777                     case "USE_OWN_MULTIPLY_PARENT_ALPHA":
1778                     return ColorMode.UseOwnMultiplyParentAlpha;
1779                     default:
1780                     return ColorMode.UseOwnMultiplyParentAlpha;
1781                 }
1782             }
1783             set
1784             {
1785                 SetProperty(Actor.Property.COLOR_MODE, new Tizen.NUI.PropertyValue((int)value));
1786             }
1787         }
1788
1789
1790         /// <summary>
1791         /// Gets/Sets the status of how the actor and its children should be drawn.
1792         /// Not all actors are renderable, but DrawMode can be inherited from any actor.
1793         /// If an object is in a 3D layer, it will be depth-tested against other objects in the world i.e. it may be obscured if other objects are in front.
1794         /// If DrawMode.Overlay2D is used, the actor and its children will be drawn as a 2D overlay.
1795         /// Overlay actors are drawn in a separate pass, after all non-overlay actors within the Layer.
1796         /// For overlay actors, the drawing order is with respect to tree levels of Actors, and depth-testing will not be used.
1797         /// </summary>
1798         public DrawModeType DrawMode
1799         {
1800             get
1801             {
1802                 string temp;
1803                 if (GetProperty(Actor.Property.DRAW_MODE).Get(out temp) == false)
1804                 {
1805                     //Tizen.Log.Error("NUI", "DrawMode get error!");
1806                 }
1807                 switch (temp)
1808                 {
1809                     case "NORMAL":
1810                     return DrawModeType.Normal;
1811                     case "OVERLAY_2D":
1812                     return DrawModeType.Overlay2D;
1813                     case "STENCIL":
1814                     return DrawModeType.Stencil;
1815                     default:
1816                     return DrawModeType.Normal;
1817                 }
1818             }
1819             set
1820             {
1821                 SetProperty(Actor.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));
1822             }
1823         }
1824
1825         /// <summary>
1826         /// Gets/Sets the relative to parent size factor of the actor.
1827         /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.
1828         /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicyType.
1829         /// </summary>
1830         public Vector3 SizeModeFactor
1831         {
1832             get
1833             {
1834                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
1835                 GetProperty(Actor.Property.SIZE_MODE_FACTOR).Get(temp);
1836                 return temp;
1837             }
1838             set
1839             {
1840                 SetProperty(Actor.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));
1841             }
1842         }
1843
1844         /// <summary>
1845         /// Gets/Sets the width resize policy to be used for the given dimension(s).
1846         /// </summary>
1847         public ResizePolicyType WidthResizePolicy
1848         {
1849             get
1850             {
1851                 string temp;
1852                 if (GetProperty(Actor.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
1853                 {
1854                     //Tizen.Log.Error("NUI", "WidthResizePolicy get error!");
1855                 }
1856                 switch (temp)
1857                 {
1858                     case "FIXED":
1859                     return ResizePolicyType.Fixed;
1860                     case "USE_NATURAL_SIZE":
1861                     return ResizePolicyType.UseNaturalSize;
1862                     case "FILL_TO_PARENT":
1863                     return ResizePolicyType.FillToParent;
1864                     case "SIZE_RELATIVE_TO_PARENT":
1865                     return ResizePolicyType.SizeRelativeToParent;
1866                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
1867                     return ResizePolicyType.SizeFixedOffsetFromParent;
1868                     case "FIT_TO_CHILDREN":
1869                     return ResizePolicyType.FitToChildren;
1870                     case "DIMENSION_DEPENDENCY":
1871                     return ResizePolicyType.DimensionDependency;
1872                     case "USE_ASSIGNED_SIZE":
1873                     return ResizePolicyType.UseAssignedSize;
1874                     default:
1875                     return ResizePolicyType.Fixed;
1876                 }
1877             }
1878             set
1879             {
1880                 SetProperty(Actor.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
1881             }
1882         }
1883
1884         /// <summary>
1885         /// Gets/Sets the height resize policy to be used for the given dimension(s).
1886         /// </summary>
1887         public ResizePolicyType HeightResizePolicy
1888         {
1889             get
1890             {
1891                 string temp;
1892                 if (GetProperty(Actor.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
1893                 {
1894                     //Tizen.Log.Error("NUI", "HeightResizePolicy get error!");
1895                 }
1896                 switch (temp)
1897                 {
1898                     case "FIXED":
1899                     return ResizePolicyType.Fixed;
1900                     case "USE_NATURAL_SIZE":
1901                     return ResizePolicyType.UseNaturalSize;
1902                     case "FILL_TO_PARENT":
1903                     return ResizePolicyType.FillToParent;
1904                     case "SIZE_RELATIVE_TO_PARENT":
1905                     return ResizePolicyType.SizeRelativeToParent;
1906                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
1907                     return ResizePolicyType.SizeFixedOffsetFromParent;
1908                     case "FIT_TO_CHILDREN":
1909                     return ResizePolicyType.FitToChildren;
1910                     case "DIMENSION_DEPENDENCY":
1911                     return ResizePolicyType.DimensionDependency;
1912                     case "USE_ASSIGNED_SIZE":
1913                     return ResizePolicyType.UseAssignedSize;
1914                     default:
1915                     return ResizePolicyType.Fixed;
1916                 }
1917             }
1918             set
1919             {
1920                 SetProperty(Actor.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
1921             }
1922         }
1923
1924         /// <summary>
1925         /// Gets/Sets the policy to use when setting size with size negotiation.
1926         /// Defaults to  SizeScalePolicyType.UseSizeSet.
1927         /// </summary>
1928         public SizeScalePolicyType SizeScalePolicy
1929         {
1930             get
1931             {
1932                 string temp;
1933                 if (GetProperty(Actor.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
1934                 {
1935                     //Tizen.Log.Error("NUI", "SizeScalePolicy get error!");
1936                 }
1937                 switch (temp)
1938                 {
1939                     case "USE_SIZE_SET":
1940                     return SizeScalePolicyType.UseSizeSet;
1941                     case "FIT_WITH_ASPECT_RATIO":
1942                     return SizeScalePolicyType.FitWithAspectRatio;
1943                     case "FILL_WITH_ASPECT_RATIO":
1944                     return SizeScalePolicyType.FillWithAspectRatio;
1945                     default:
1946                     return SizeScalePolicyType.UseSizeSet;
1947                 }
1948             }
1949             set
1950             {
1951                 string valueToString = "";
1952                 switch (value)
1953                 {
1954                     case SizeScalePolicyType.UseSizeSet:
1955                     {
1956                         valueToString = "USE_SIZE_SET";
1957                         break;
1958                     }
1959                     case SizeScalePolicyType.FitWithAspectRatio:
1960                     {
1961                         valueToString = "FIT_WITH_ASPECT_RATIO";
1962                         break;
1963                     }
1964                     case SizeScalePolicyType.FillWithAspectRatio:
1965                     {
1966                         valueToString = "FILL_WITH_ASPECT_RATIO";
1967                         break;
1968                     }
1969                     default:
1970                     {
1971                         valueToString = "USE_SIZE_SET";
1972                         break;
1973                     }
1974                 }
1975                 SetProperty(Actor.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
1976             }
1977         }
1978
1979         /// <summary>
1980         ///  Gets/Sets the status of whether the width size is dependent on height size.
1981         /// </summary>
1982         public bool WidthDependentOnHeight
1983         {
1984             get
1985             {
1986                 bool temp = false;
1987                 GetProperty(Actor.Property.WIDTH_FOR_HEIGHT).Get(ref temp);
1988                 return temp;
1989             }
1990             set
1991             {
1992                 SetProperty(Actor.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));
1993             }
1994         }
1995
1996         /// <summary>
1997         ///  Gets/Sets the status of whether the height size is dependent on width size.
1998         /// </summary>
1999         public bool HeightDependentOnWidth
2000         {
2001             get
2002             {
2003                 bool temp = false;
2004                 GetProperty(Actor.Property.HEIGHT_FOR_WIDTH).Get(ref temp);
2005                 return temp;
2006             }
2007             set
2008             {
2009                 SetProperty(Actor.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));
2010             }
2011         }
2012
2013         /// <summary>
2014         /// Gets/Sets the padding for use in layout.
2015         /// </summary>
2016         public Vector4 Padding
2017         {
2018             get
2019             {
2020                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
2021                 GetProperty(Actor.Property.PADDING).Get(temp);
2022                 return temp;
2023             }
2024             set
2025             {
2026                 SetProperty(Actor.Property.PADDING, new Tizen.NUI.PropertyValue(value));
2027             }
2028         }
2029
2030
2031         /// <summary>
2032         /// Gets/Sets the minimum size an actor can be assigned in size negotiation.
2033         /// </summary>
2034         public Size2D MinimumSize
2035         {
2036             get
2037             {
2038                 Size2D temp = new Size2D(0, 0);
2039                 GetProperty(Actor.Property.MINIMUM_SIZE).Get(temp);
2040                 return temp;
2041             }
2042             set
2043             {
2044                 SetProperty(Actor.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
2045             }
2046         }
2047
2048
2049         /// <summary>
2050         /// Gets/Sets the maximum size an actor can be assigned in size negotiation.
2051         /// </summary>
2052         public Size2D MaximumSize
2053         {
2054             get
2055             {
2056                 Size2D temp = new Size2D(0, 0);
2057                 GetProperty(Actor.Property.MAXIMUM_SIZE).Get(temp);
2058                 return temp;
2059             }
2060             set
2061             {
2062                 SetProperty(Actor.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
2063             }
2064         }
2065
2066         /// <summary>
2067         /// Gets/Sets whether a child actor inherits it's parent's position.
2068         /// Default is to inherit.
2069         /// Switching this off means that using Position sets the actor's world position, i.e. translates from the world origin(0,0,0) to the anchor point of the actor.
2070         /// </summary>
2071         public bool InheritPosition
2072         {
2073             get
2074             {
2075                 bool temp = false;
2076                 GetProperty(Actor.Property.INHERIT_POSITION).Get(ref temp);
2077                 return temp;
2078             }
2079             set
2080             {
2081                 SetProperty(Actor.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));
2082             }
2083         }
2084
2085         /// <summary>
2086         /// Gets/Sets clipping behavior(mode) of it's children
2087         /// </summary>
2088         public ClippingModeType ClippingMode
2089         {
2090             get
2091             {
2092                 string temp;
2093                 if (GetProperty(Actor.Property.CLIPPING_MODE).Get(out temp) == false)
2094                 {
2095                     //Tizen.Log.Error("NUI", "ClippingMode get error!");
2096                 }
2097                 switch (temp)
2098                 {
2099                     case "DISABLED":
2100                     return ClippingModeType.Disabled;
2101                     case "CLIP_CHILDREN":
2102                     return ClippingModeType.ClipChildren;
2103                     default:
2104                     return ClippingModeType.Disabled;
2105                 }
2106             }
2107             set
2108             {
2109                 SetProperty(Actor.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));
2110             }
2111         }
2112
2113     }
2114
2115     /// <summary>
2116     /// This specifies whether the Actor uses its own color, or inherits
2117     /// ColorMode.UseOwnColor : Actor will use its own color
2118     /// ColorMode.UseParentColor : Actor will use its parent color
2119     /// ColorMode.UseOwnMultiplyParentColor : Actor will blend its color with its parents color.
2120     /// ColorMode.UseOwnMultiplyParentAlpha : Actor will blend its alpha with its parents alpha. This means when parent fades in or out child does as well. This is the default.
2121     /// </summary>
2122     public enum ColorMode
2123     {
2124         UseOwnColor,
2125         UseParentColor,
2126         UseOwnMultiplyParentColor,
2127         UseOwnMultiplyParentAlpha
2128     }
2129
2130     /// <summary>
2131     /// This specifies the dimesion of width or heigh for size negotiation.
2132     /// </summary>
2133     public enum DimensionType
2134     {
2135         Width = 0x1,
2136         Height = 0x2,
2137         AllDimensions = 0x3
2138     }
2139
2140     /// <summary>
2141     /// This specifies draw mode types
2142     /// </summary>
2143     public enum DrawModeType
2144     {
2145         Normal = 0,
2146         Overlay2D = 1,
2147         Stencil = 3
2148     }
2149
2150     /// <summary>
2151     /// This specifies resize policy types
2152     /// </summary>
2153     public enum ResizePolicyType
2154     {
2155         Fixed,
2156         UseNaturalSize,
2157         FillToParent,
2158         SizeRelativeToParent,
2159         SizeFixedOffsetFromParent,
2160         FitToChildren,
2161         DimensionDependency,
2162         UseAssignedSize
2163     }
2164
2165     /// <summary>
2166     /// This specifies size scale policy types
2167     /// </summary>
2168     public enum SizeScalePolicyType
2169     {
2170         UseSizeSet,
2171         FitWithAspectRatio,
2172         FillWithAspectRatio
2173     }
2174
2175     /// <summary>
2176     /// This specifies clipping mode types
2177     /// </summary>
2178     public enum ClippingModeType
2179     {
2180         Disabled,
2181         ClipChildren
2182     }
2183
2184 }