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