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