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