Tizen.NUI/src/public/Actor.cs

   1 // Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved\r
   2 // PROPRIETARY/CONFIDENTIAL \r
   3 // This software is the confidential and proprietary\r
   4 // information of SAMSUNG ELECTRONICS ("Confidential Information"). You shall\r
   5 // not disclose such Confidential Information and shall use it only in\r
   6 // accordance with the terms of the license agreement you entered into with\r
   7 // SAMSUNG ELECTRONICS. SAMSUNG make no representations or warranties about the\r
   8 // suitability of the software, either express or implied, including but not\r
   9 // limited to the implied warranties of merchantability, fitness for a\r
  10 // particular purpose, or non-infringement. SAMSUNG shall not be liable for any\r
  11 // damages suffered by licensee as a result of using, modifying or distributing\r
  12 // this software or its derivatives.\r
  13 \r
  14 // Copyright (c) 2017 Samsung Electronics Co., Ltd.\r
  15 //\r
  16 // Licensed under the Apache License, Version 2.0 (the "License");\r
  17 // you may not use this file except in compliance with the License.\r
  18 // You may obtain a copy of the License at\r
  19 //\r
  20 // http://www.apache.org/licenses/LICENSE-2.0\r
  21 //
  22 // Unless required by applicable law or agreed to in writing, software\r
  23 // distributed under the License is distributed on an "AS IS" BASIS,\r
  24 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r
  25 // See the License for the specific language governing permissions and\r
  26 // limitations under the License.\r
  27 //
  28 \r
  29 // This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts\r
  30 // Some have been manually changed\r
  31
  32 namespace Tizen.NUI\r
  33 {
  34
  35     using System;
  36     using System.Runtime.InteropServices;\r
  37 \r
  38     public class Actor : Handle\r
  39     {\r
  40         private global::System.Runtime.InteropServices.HandleRef swigCPtr;\r
  41 \r
  42         internal Actor(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Actor_SWIGUpcast(cPtr), cMemoryOwn)\r
  43         {\r
  44             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);\r
  45         }\r
  46 \r
  47         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Actor obj)\r
  48         {\r
  49             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;\r
  50         }\r
  51 \r
  52         ~Actor()\r
  53         {\r
  54             DisposeQueue.Instance.Add(this);\r
  55         }\r
  56 \r
  57         public override void Dispose()\r
  58         {\r
  59             if (!Stage.IsInstalled())\r
  60             {\r
  61                 DisposeQueue.Instance.Add(this);\r
  62                 return;\r
  63             }\r
  64 \r
  65             lock (this)\r
  66             {\r
  67                 if (swigCPtr.Handle != global::System.IntPtr.Zero)\r
  68                 {\r
  69                     if (swigCMemOwn)\r
  70                     {\r
  71                         swigCMemOwn = false;\r
  72                         NDalicPINVOKE.delete_Actor(swigCPtr);\r
  73                     }\r
  74                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);\r
  75                 }\r
  76                 global::System.GC.SuppressFinalize(this);\r
  77                 base.Dispose();\r
  78             }\r
  79         }\r
  80 \r
  81 \r
  82 \r
  83         internal static Actor GetActorFromPtr(global::System.IntPtr cPtr)\r
  84         {\r
  85             Actor ret = new Actor(cPtr, false);\r
  86             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
  87             return ret;\r
  88         }\r
  89 \r
  90         internal IntPtr GetPtrfromActor()\r
  91         {\r
  92             return (IntPtr)swigCPtr;\r
  93         }\r
  94 \r
  95         public Actor Parent\r
  96         {\r
  97             get\r
  98             {\r
  99                 return GetParent();\r
 100             }\r
 101         }\r
 102 \r
 103         public float Opacity\r
 104         {\r
 105             get\r
 106             {\r
 107                 float temp = 0.0f;\r
 108                 GetProperty(Actor.Property.COLOR_ALPHA).Get(ref temp);\r
 109                 return temp;\r
 110             }\r
 111             set\r
 112             {\r
 113                 SetProperty(Actor.Property.COLOR_ALPHA, new Tizen.NUI.PropertyValue(value));\r
 114             }\r
 115         }\r
 116 \r
 117         public bool IsOnStage\r
 118         {\r
 119             get\r
 120             {\r
 121                 return OnStage();\r
 122             }\r
 123         }\r
 124 \r
 125         public int HierarchyDepth\r
 126         {\r
 127             get\r
 128             {\r
 129                 return GetHierarchyDepth();\r
 130             }\r
 131         }\r
 132 \r
 133         public int SiblingOrder\r
 134         {\r
 135             get\r
 136             {\r
 137                 int temp = 0;\r
 138                 GetProperty(Actor.Property.SIBLING_ORDER).Get(ref temp);\r
 139                 return temp;\r
 140             }\r
 141             set\r
 142             {\r
 143                 SetProperty(Actor.Property.SIBLING_ORDER, new Tizen.NUI.PropertyValue(value));\r
 144             }\r
 145         }\r
 146 \r
 147         public void Show()\r
 148         {\r
 149             SetVisible(true);\r
 150         }\r
 151 \r
 152         public void Hide()\r
 153         {\r
 154             SetVisible(false);\r
 155         }\r
 156 \r
 157         internal class Property : global::System.IDisposable\r
 158         {\r
 159             private global::System.Runtime.InteropServices.HandleRef swigCPtr;\r
 160             protected bool swigCMemOwn;\r
 161 \r
 162             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)\r
 163             {\r
 164                 swigCMemOwn = cMemoryOwn;\r
 165                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);\r
 166             }\r
 167 \r
 168             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)\r
 169             {\r
 170                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;\r
 171             }\r
 172 \r
 173             ~Property()\r
 174             {\r
 175                 Dispose();\r
 176             }\r
 177 \r
 178             public virtual void Dispose()\r
 179             {\r
 180                 lock (this)\r
 181                 {\r
 182                     if (swigCPtr.Handle != global::System.IntPtr.Zero)\r
 183                     {\r
 184                         if (swigCMemOwn)\r
 185                         {\r
 186                             swigCMemOwn = false;\r
 187                             NDalicPINVOKE.delete_Actor_Property(swigCPtr);\r
 188                         }\r
 189                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);\r
 190                     }\r
 191                     global::System.GC.SuppressFinalize(this);\r
 192                 }\r
 193             }\r
 194 \r
 195             internal static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();\r
 196             internal static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();\r
 197 \r
 198             internal Property() : this(NDalicPINVOKE.new_Actor_Property(), true)\r
 199             {\r
 200                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 201             }\r
 202 \r
 203             internal static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();\r
 204             internal static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();\r
 205             internal static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();\r
 206             internal static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();\r
 207             internal static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();\r
 208             internal static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();\r
 209             internal static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();\r
 210             internal static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();\r
 211             internal static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();\r
 212             internal static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();\r
 213             internal static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();\r
 214             internal static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();\r
 215             internal static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();\r
 216             internal static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();\r
 217             internal static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();\r
 218             internal static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();\r
 219             internal static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();\r
 220             internal static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();\r
 221             internal static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();\r
 222             internal static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();\r
 223             internal static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();\r
 224             internal static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();\r
 225             internal static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();\r
 226             internal static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();\r
 227             internal static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();\r
 228             internal static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();\r
 229             internal static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();\r
 230             internal static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();\r
 231             internal static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();\r
 232             internal static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();\r
 233             internal static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();\r
 234             internal static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();\r
 235             internal static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();\r
 236             internal static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();\r
 237             internal static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();\r
 238             internal static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();\r
 239             internal static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();\r
 240             internal static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();\r
 241             internal static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();\r
 242             internal static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();\r
 243             internal static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();\r
 244             internal static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();\r
 245             internal static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();\r
 246             internal static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();\r
 247             internal static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();\r
 248             internal static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();\r
 249             internal static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();\r
 250             internal static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();\r
 251             internal static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();\r
 252             internal static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();\r
 253             internal static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();\r
 254             internal static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();\r
 255             internal static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();\r
 256             internal static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();\r
 257 \r
 258         }\r
 259 \r
 260         public Actor() : this(NDalicPINVOKE.Actor_New(), true)\r
 261         {\r
 262             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 263 \r
 264         }\r
 265         public new static Actor DownCast(BaseHandle handle)\r
 266         {\r
 267             Actor ret = new Actor(NDalicPINVOKE.Actor_DownCast(BaseHandle.getCPtr(handle)), true);\r
 268             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 269             return ret;\r
 270         }\r
 271 \r
 272         internal Actor(Actor copy) : this(NDalicPINVOKE.new_Actor__SWIG_1(Actor.getCPtr(copy)), true)\r
 273         {\r
 274             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 275         }\r
 276 \r
 277         internal Actor Assign(Actor rhs)\r
 278         {\r
 279             Actor ret = new Actor(NDalicPINVOKE.Actor_Assign(swigCPtr, Actor.getCPtr(rhs)), false);\r
 280             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 281             return ret;\r
 282         }\r
 283 \r
 284         internal string GetName()\r
 285         {\r
 286             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);\r
 287             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 288             return ret;\r
 289         }\r
 290 \r
 291         internal void SetName(string name)\r
 292         {\r
 293             NDalicPINVOKE.Actor_SetName(swigCPtr, name);\r
 294             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 295         }\r
 296 \r
 297         internal uint GetId()\r
 298         {\r
 299             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);\r
 300             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 301             return ret;\r
 302         }\r
 303 \r
 304         internal bool IsRoot()\r
 305         {\r
 306             bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);\r
 307             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 308             return ret;\r
 309         }\r
 310 \r
 311         internal bool OnStage()\r
 312         {\r
 313             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);\r
 314             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 315             return ret;\r
 316         }\r
 317 \r
 318         internal bool IsLayer()\r
 319         {\r
 320             bool ret = NDalicPINVOKE.Actor_IsLayer(swigCPtr);\r
 321             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 322             return ret;\r
 323         }\r
 324 \r
 325         internal Layer GetLayer()\r
 326         {\r
 327             Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);\r
 328             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 329             return ret;\r
 330         }\r
 331 \r
 332         public void Add(Actor child)\r
 333         {\r
 334             NDalicPINVOKE.Actor_Add(swigCPtr, Actor.getCPtr(child));\r
 335             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 336         }\r
 337 \r
 338         public void Remove(Actor child)\r
 339         {\r
 340             NDalicPINVOKE.Actor_Remove(swigCPtr, Actor.getCPtr(child));\r
 341             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 342         }\r
 343 \r
 344         internal void Unparent()\r
 345         {\r
 346             NDalicPINVOKE.Actor_Unparent(swigCPtr);\r
 347             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 348         }\r
 349 \r
 350         public uint GetChildCount()\r
 351         {\r
 352             uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);\r
 353             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 354             return ret;\r
 355         }\r
 356 \r
 357         public Actor GetChildAt(uint index)\r
 358         {\r
 359             Actor ret = new Actor(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);\r
 360             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 361             return ret;\r
 362         }\r
 363 \r
 364         public Actor FindChildByName(string actorName)\r
 365         {\r
 366             Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);\r
 367             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 368             return ret;\r
 369         }\r
 370 \r
 371         internal Actor FindChildById(uint id)\r
 372         {\r
 373             Actor ret = new Actor(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);\r
 374             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 375             return ret;\r
 376         }\r
 377 \r
 378         internal Actor GetParent()\r
 379         {\r
 380             Actor ret = new Actor(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);\r
 381             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 382             return ret;\r
 383         }\r
 384 \r
 385         internal void SetParentOrigin(Vector3 origin)\r
 386         {\r
 387             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));\r
 388             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 389         }\r
 390 \r
 391         internal Vector3 GetCurrentParentOrigin()\r
 392         {\r
 393             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);\r
 394             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 395             return ret;\r
 396         }\r
 397 \r
 398         internal void SetAnchorPoint(Vector3 anchorPoint)\r
 399         {\r
 400             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));\r
 401             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 402         }\r
 403 \r
 404         internal Vector3 GetCurrentAnchorPoint()\r
 405         {\r
 406             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);\r
 407             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 408             return ret;\r
 409         }\r
 410 \r
 411         internal void SetSize(float width, float height)\r
 412         {\r
 413             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);\r
 414             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 415         }\r
 416 \r
 417         internal void SetSize(float width, float height, float depth)\r
 418         {\r
 419             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);\r
 420             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 421         }\r
 422 \r
 423         internal void SetSize(Vector2 size)\r
 424         {\r
 425             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));\r
 426             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 427         }\r
 428 \r
 429         internal void SetSize(Vector3 size)\r
 430         {\r
 431             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));\r
 432             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 433         }\r
 434 \r
 435         internal Vector3 GetTargetSize()\r
 436         {\r
 437             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);\r
 438             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 439             return ret;\r
 440         }\r
 441 \r
 442         internal Size GetCurrentSize()\r
 443         {\r
 444             Size ret = new Size(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);\r
 445             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 446             return ret;\r
 447         }\r
 448 \r
 449         public Vector3 GetNaturalSize()\r
 450         {\r
 451             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);\r
 452             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 453             return ret;\r
 454         }\r
 455 \r
 456         internal void SetPosition(float x, float y)\r
 457         {\r
 458             NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);\r
 459             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 460         }\r
 461 \r
 462         internal void SetPosition(float x, float y, float z)\r
 463         {\r
 464             NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);\r
 465             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 466         }\r
 467 \r
 468         internal void SetPosition(Vector3 position)\r
 469         {\r
 470             NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));\r
 471             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 472         }\r
 473 \r
 474         internal void SetX(float x)\r
 475         {\r
 476             NDalicPINVOKE.Actor_SetX(swigCPtr, x);\r
 477             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 478         }\r
 479 \r
 480         internal void SetY(float y)\r
 481         {\r
 482             NDalicPINVOKE.Actor_SetY(swigCPtr, y);\r
 483             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 484         }\r
 485 \r
 486         internal void SetZ(float z)\r
 487         {\r
 488             NDalicPINVOKE.Actor_SetZ(swigCPtr, z);\r
 489             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 490         }\r
 491 \r
 492         internal void TranslateBy(Vector3 distance)\r
 493         {\r
 494             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));\r
 495             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 496         }\r
 497 \r
 498         internal Position GetCurrentPosition()\r
 499         {\r
 500             Position ret = new Position(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);\r
 501             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 502             return ret;\r
 503         }\r
 504 \r
 505         internal Vector3 GetCurrentWorldPosition()\r
 506         {\r
 507             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);\r
 508             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 509             return ret;\r
 510         }\r
 511 \r
 512         internal void SetInheritPosition(bool inherit)\r
 513         {\r
 514             NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);\r
 515             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 516         }\r
 517 \r
 518         internal PositionInheritanceMode GetPositionInheritanceMode()\r
 519         {\r
 520             PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);\r
 521             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 522             return ret;\r
 523         }\r
 524 \r
 525         internal bool IsPositionInherited()\r
 526         {\r
 527             bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);\r
 528             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 529             return ret;\r
 530         }\r
 531 \r
 532         internal void SetOrientation(Degree angle, Vector3 axis)\r
 533         {\r
 534             NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));\r
 535             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 536         }\r
 537 \r
 538         internal void SetOrientation(Radian angle, Vector3 axis)\r
 539         {\r
 540             NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));\r
 541             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 542         }\r
 543 \r
 544         internal void SetOrientation(Rotation orientation)\r
 545         {\r
 546             NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));\r
 547             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 548         }\r
 549 \r
 550         internal void RotateBy(Degree angle, Vector3 axis)\r
 551         {\r
 552             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));\r
 553             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 554         }\r
 555 \r
 556         internal void RotateBy(Radian angle, Vector3 axis)\r
 557         {\r
 558             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));\r
 559             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 560         }\r
 561 \r
 562         internal void RotateBy(Rotation relativeRotation)\r
 563         {\r
 564             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));\r
 565             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 566         }\r
 567 \r
 568         internal Rotation GetCurrentOrientation()\r
 569         {\r
 570             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);\r
 571             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 572             return ret;\r
 573         }\r
 574 \r
 575         internal void SetInheritOrientation(bool inherit)\r
 576         {\r
 577             NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);\r
 578             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 579         }\r
 580 \r
 581         internal bool IsOrientationInherited()\r
 582         {\r
 583             bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);\r
 584             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 585             return ret;\r
 586         }\r
 587 \r
 588         internal Rotation GetCurrentWorldOrientation()\r
 589         {\r
 590             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);\r
 591             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 592             return ret;\r
 593         }\r
 594 \r
 595         internal void SetScale(float scale)\r
 596         {\r
 597             NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);\r
 598             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 599         }\r
 600 \r
 601         internal void SetScale(float scaleX, float scaleY, float scaleZ)\r
 602         {\r
 603             NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);\r
 604             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 605         }\r
 606 \r
 607         internal void SetScale(Vector3 scale)\r
 608         {\r
 609             NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));\r
 610             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 611         }\r
 612 \r
 613         internal void ScaleBy(Vector3 relativeScale)\r
 614         {\r
 615             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));\r
 616             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 617         }\r
 618 \r
 619         internal Vector3 GetCurrentScale()\r
 620         {\r
 621             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);\r
 622             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 623             return ret;\r
 624         }\r
 625 \r
 626         internal Vector3 GetCurrentWorldScale()\r
 627         {\r
 628             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);\r
 629             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 630             return ret;\r
 631         }\r
 632 \r
 633         internal void SetInheritScale(bool inherit)\r
 634         {\r
 635             NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);\r
 636             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 637         }\r
 638 \r
 639         internal bool IsScaleInherited()\r
 640         {\r
 641             bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);\r
 642             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 643             return ret;\r
 644         }\r
 645 \r
 646         internal Matrix GetCurrentWorldMatrix()\r
 647         {\r
 648             Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);\r
 649             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 650             return ret;\r
 651         }\r
 652 \r
 653         internal void SetVisible(bool visible)\r
 654         {\r
 655             NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);\r
 656             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 657         }\r
 658 \r
 659         internal bool IsVisible()\r
 660         {\r
 661             bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);\r
 662             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 663             return ret;\r
 664         }\r
 665 \r
 666         internal void SetOpacity(float opacity)\r
 667         {\r
 668             NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);\r
 669             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 670         }\r
 671 \r
 672         internal float GetCurrentOpacity()\r
 673         {\r
 674             float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);\r
 675             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 676             return ret;\r
 677         }\r
 678 \r
 679         internal void SetColor(Vector4 color)\r
 680         {\r
 681             NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));\r
 682             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 683         }\r
 684 \r
 685         internal Vector4 GetCurrentColor()\r
 686         {\r
 687             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);\r
 688             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 689             return ret;\r
 690         }\r
 691 \r
 692         internal void SetColorMode(ColorMode colorMode)\r
 693         {\r
 694             NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);\r
 695             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 696         }\r
 697 \r
 698         internal ColorMode GetColorMode()\r
 699         {\r
 700             ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);\r
 701             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 702             return ret;\r
 703         }\r
 704 \r
 705         internal Vector4 GetCurrentWorldColor()\r
 706         {\r
 707             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);\r
 708             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 709             return ret;\r
 710         }\r
 711 \r
 712         internal void SetDrawMode(DrawModeType drawMode)\r
 713         {\r
 714             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);\r
 715             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 716         }\r
 717 \r
 718         internal DrawModeType GetDrawMode()\r
 719         {\r
 720             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);\r
 721             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 722             return ret;\r
 723         }\r
 724 \r
 725         internal void SetSensitive(bool sensitive)\r
 726         {\r
 727             NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);\r
 728             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 729         }\r
 730 \r
 731         internal bool IsSensitive()\r
 732         {\r
 733             bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);\r
 734             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 735             return ret;\r
 736         }\r
 737 \r
 738         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)\r
 739         {\r
 740             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);\r
 741             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 742             return ret;\r
 743         }\r
 744 \r
 745         internal void SetLeaveRequired(bool required)\r
 746         {\r
 747             NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);\r
 748             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 749         }\r
 750 \r
 751         internal bool GetLeaveRequired()\r
 752         {\r
 753             bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);\r
 754             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 755             return ret;\r
 756         }\r
 757 \r
 758         internal void SetKeyboardFocusable(bool focusable)\r
 759         {\r
 760             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);\r
 761             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 762         }\r
 763 \r
 764         internal bool IsKeyboardFocusable()\r
 765         {\r
 766             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);\r
 767             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 768             return ret;\r
 769         }\r
 770 \r
 771         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)\r
 772         {\r
 773             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);\r
 774             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 775         }\r
 776 \r
 777         internal ResizePolicyType GetResizePolicy(DimensionType dimension)\r
 778         {\r
 779             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);\r
 780             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 781             return ret;\r
 782         }\r
 783 \r
 784         internal void SetSizeScalePolicy(SizeScalePolicyType policy)\r
 785         {\r
 786             NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);\r
 787             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 788         }\r
 789 \r
 790         internal SizeScalePolicyType GetSizeScalePolicy()\r
 791         {\r
 792             SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);\r
 793             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 794             return ret;\r
 795         }\r
 796 \r
 797         internal void SetSizeModeFactor(Vector3 factor)\r
 798         {\r
 799             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));\r
 800             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 801         }\r
 802 \r
 803         internal Vector3 GetSizeModeFactor()\r
 804         {\r
 805             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);\r
 806             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 807             return ret;\r
 808         }\r
 809 \r
 810         public float GetHeightForWidth(float width)\r
 811         {\r
 812             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);\r
 813             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 814             return ret;\r
 815         }\r
 816 \r
 817         public float GetWidthForHeight(float height)\r
 818         {\r
 819             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);\r
 820             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 821             return ret;\r
 822         }\r
 823 \r
 824         internal float GetRelayoutSize(DimensionType dimension)\r
 825         {\r
 826             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);\r
 827             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 828             return ret;\r
 829         }\r
 830 \r
 831         public void SetPadding(PaddingType padding)\r
 832         {\r
 833             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));\r
 834             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 835         }\r
 836 \r
 837         public void GetPadding(PaddingType paddingOut)\r
 838         {\r
 839             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));\r
 840             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 841         }\r
 842 \r
 843         internal void SetMinimumSize(Vector2 size)\r
 844         {\r
 845             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));\r
 846             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 847         }\r
 848 \r
 849         internal Vector2 GetMinimumSize()\r
 850         {\r
 851             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);\r
 852             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 853             return ret;\r
 854         }\r
 855 \r
 856         internal void SetMaximumSize(Vector2 size)\r
 857         {\r
 858             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));\r
 859             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 860         }\r
 861 \r
 862         internal Vector2 GetMaximumSize()\r
 863         {\r
 864             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);\r
 865             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 866             return ret;\r
 867         }\r
 868 \r
 869         internal int GetHierarchyDepth()\r
 870         {\r
 871             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);\r
 872             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 873             return ret;\r
 874         }\r
 875 \r
 876         internal uint AddRenderer(Renderer renderer)\r
 877         {\r
 878             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));\r
 879             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 880             return ret;\r
 881         }\r
 882 \r
 883         internal uint GetRendererCount()\r
 884         {\r
 885             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);\r
 886             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 887             return ret;\r
 888         }\r
 889 \r
 890         internal Renderer GetRendererAt(uint index)\r
 891         {\r
 892             Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);\r
 893             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 894             return ret;\r
 895         }\r
 896 \r
 897         internal void RemoveRenderer(Renderer renderer)\r
 898         {\r
 899             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));\r
 900             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 901         }\r
 902 \r
 903         internal void RemoveRenderer(uint index)\r
 904         {\r
 905             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);\r
 906             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 907         }\r
 908 \r
 909         internal SWIGTYPE_p_Dali__SignalT_bool_fDali__Actor_Dali__TouchEvent_const_RF_t TouchedSignal()\r
 910         {\r
 911             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);\r
 912             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 913             return ret;\r
 914         }\r
 915 \r
 916         internal ActorTouchDataSignal TouchSignal()\r
 917         {\r
 918             ActorTouchDataSignal ret = new ActorTouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);\r
 919             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 920             return ret;\r
 921         }\r
 922 \r
 923         internal ActorHoverSignal HoveredSignal()\r
 924         {\r
 925             ActorHoverSignal ret = new ActorHoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);\r
 926             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 927             return ret;\r
 928         }\r
 929 \r
 930         internal ActorWheelSignal WheelEventSignal()\r
 931         {\r
 932             ActorWheelSignal ret = new ActorWheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);\r
 933             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 934             return ret;\r
 935         }\r
 936 \r
 937         internal ActorSignal OnStageSignal()\r
 938         {\r
 939             ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);\r
 940             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 941             return ret;\r
 942         }\r
 943 \r
 944         internal ActorSignal OffStageSignal()\r
 945         {\r
 946             ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);\r
 947             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 948             return ret;\r
 949         }\r
 950 \r
 951         internal ActorSignal OnRelayoutSignal()\r
 952         {\r
 953             ActorSignal ret = new ActorSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);\r
 954             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();\r
 955             return ret;\r
 956         }\r
 957 \r
 958         public Position ParentOrigin\r
 959         {\r
 960             get\r
 961             {\r
 962                 Position temp = new Position(0.0f, 0.0f, 0.0f);\r
 963                 GetProperty(Actor.Property.PARENT_ORIGIN).Get(temp);\r
 964                 return temp;\r
 965             }\r
 966             set\r
 967             {\r
 968                 SetProperty(Actor.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue(value));\r
 969             }\r
 970         }\r
 971 \r
 972         public Position AnchorPoint\r
 973         {\r
 974             get\r
 975             {\r
 976                 Position temp = new Position(0.0f, 0.0f, 0.0f);\r
 977                 GetProperty(Actor.Property.ANCHOR_POINT).Get(temp);\r
 978                 return temp;\r
 979             }\r
 980             set\r
 981             {\r
 982                 SetProperty(Actor.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));\r
 983             }\r
 984         }\r
 985 \r
 986         public Size Size\r
 987         {\r
 988             get\r
 989             {\r
 990                 Size temp = GetCurrentSize();\r
 991                 return temp;\r
 992             }\r
 993             set\r
 994             {\r
 995                 SetProperty(Actor.Property.SIZE, new Tizen.NUI.PropertyValue(value));\r
 996             }\r
 997         }\r
 998         public float SizeWidth\r
 999         {\r
1000             get\r
1001             {\r
1002                 Size temp = GetCurrentSize();\r
1003                 return temp.Width;\r
1004             }\r
1005             set\r
1006             {\r
1007                 SetProperty(Actor.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));\r
1008             }\r
1009         }\r
1010         public float SizeHeight\r
1011         {\r
1012             get\r
1013             {\r
1014                 Size temp = GetCurrentSize();\r
1015                 return temp.Height;\r
1016             }\r
1017             set\r
1018             {\r
1019                 SetProperty(Actor.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));\r
1020             }\r
1021         }\r
1022         public float SizeDepth\r
1023         {\r
1024             get\r
1025             {\r
1026                 Size temp = GetCurrentSize();\r
1027                 return temp.Depth;\r
1028             }\r
1029             set\r
1030             {\r
1031                 SetProperty(Actor.Property.SIZE_DEPTH, new Tizen.NUI.PropertyValue(value));\r
1032             }\r
1033         }\r
1034         public Position Position\r
1035         {\r
1036             get\r
1037             {\r
1038                 Position temp = GetCurrentPosition();\r
1039                 return temp;\r
1040             }\r
1041             set\r
1042             {\r
1043                 SetProperty(Actor.Property.POSITION, new Tizen.NUI.PropertyValue(value));\r
1044             }\r
1045         }\r
1046         public float PositionX\r
1047         {\r
1048             get\r
1049             {\r
1050                 Position temp = GetCurrentPosition();\r
1051                 return temp.X;\r
1052             }\r
1053             set\r
1054             {\r
1055                 SetProperty(Actor.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));\r
1056             }\r
1057         }\r
1058         public float PositionY\r
1059         {\r
1060             get\r
1061             {\r
1062                 Position temp = GetCurrentPosition();\r
1063                 return temp.Y;\r
1064             }\r
1065             set\r
1066             {\r
1067                 SetProperty(Actor.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));\r
1068             }\r
1069         }\r
1070         public float PositionZ\r
1071         {\r
1072             get\r
1073             {\r
1074                 Position temp = GetCurrentPosition();\r
1075                 return temp.Z;\r
1076             }\r
1077             set\r
1078             {\r
1079                 SetProperty(Actor.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));\r
1080             }\r
1081         }\r
1082         public Vector3 WorldPosition\r
1083         {\r
1084             get\r
1085             {\r
1086                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);\r
1087                 GetProperty(Actor.Property.WORLD_POSITION).Get(temp);\r
1088                 return temp;\r
1089             }\r
1090         }\r
1091 \r
1092         public Rotation Orientation\r
1093         {\r
1094             get\r
1095             {\r
1096                 Rotation temp = new Rotation();\r
1097                 GetProperty(Actor.Property.ORIENTATION).Get(temp);\r
1098                 return temp;\r
1099             }\r
1100             set\r
1101             {\r
1102                 SetProperty(Actor.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));\r
1103             }\r
1104         }\r
1105         public Rotation WorldOrientation\r
1106         {\r
1107             get\r
1108             {\r
1109                 Rotation temp = new Rotation();\r
1110                 GetProperty(Actor.Property.WORLD_ORIENTATION).Get(temp);\r
1111                 return temp;\r
1112             }\r
1113         }\r
1114         public Vector3 Scale\r
1115         {\r
1116             get\r
1117             {\r
1118                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);\r
1119                 GetProperty(Actor.Property.SCALE).Get(temp);\r
1120                 return temp;\r
1121             }\r
1122             set\r
1123             {\r
1124                 SetProperty(Actor.Property.SCALE, new Tizen.NUI.PropertyValue(value));\r
1125             }\r
1126         }\r
1127         public float ScaleX\r
1128         {\r
1129             get\r
1130             {\r
1131                 float temp = 0.0f;\r
1132                 GetProperty(Actor.Property.SCALE_X).Get(ref temp);\r
1133                 return temp;\r
1134             }\r
1135             set\r
1136             {\r
1137                 SetProperty(Actor.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));\r
1138             }\r
1139         }\r
1140         public float ScaleY\r
1141         {\r
1142             get\r
1143             {\r
1144                 float temp = 0.0f;\r
1145                 GetProperty(Actor.Property.SCALE_Y).Get(ref temp);\r
1146                 return temp;\r
1147             }\r
1148             set\r
1149             {\r
1150                 SetProperty(Actor.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));\r
1151             }\r
1152         }\r
1153         public float ScaleZ\r
1154         {\r
1155             get\r
1156             {\r
1157                 float temp = 0.0f;\r
1158                 GetProperty(Actor.Property.SCALE_Z).Get(ref temp);\r
1159                 return temp;\r
1160             }\r
1161             set\r
1162             {\r
1163                 SetProperty(Actor.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));\r
1164             }\r
1165         }\r
1166         public Vector3 WorldScale\r
1167         {\r
1168             get\r
1169             {\r
1170                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);\r
1171                 GetProperty(Actor.Property.WORLD_SCALE).Get(temp);\r
1172                 return temp;\r
1173             }\r
1174         }\r
1175         public bool Visible\r
1176         {\r
1177             get\r
1178             {\r
1179                 bool temp = false;\r
1180                 GetProperty(Actor.Property.VISIBLE).Get(ref temp);\r
1181                 return temp;\r
1182             }\r
1183             set\r
1184             {\r
1185                 SetProperty(Actor.Property.VISIBLE, new Tizen.NUI.PropertyValue(value));\r
1186             }\r
1187         }\r
1188         public Color MixColor\r
1189         {\r
1190             get\r
1191             {\r
1192                 Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);\r
1193                 GetProperty(Actor.Property.COLOR).Get(temp);\r
1194                 return temp;\r
1195             }\r
1196             set\r
1197             {\r
1198                 SetProperty(Actor.Property.COLOR, new Tizen.NUI.PropertyValue(value));\r
1199             }\r
1200         }\r
1201         public float ColorRed\r
1202         {\r
1203             get\r
1204             {\r
1205                 float temp = 0.0f;\r
1206                 GetProperty(Actor.Property.COLOR_RED).Get(ref temp);\r
1207                 return temp;\r
1208             }\r
1209             set\r
1210             {\r
1211                 SetProperty(Actor.Property.COLOR_RED, new Tizen.NUI.PropertyValue(value));\r
1212             }\r
1213         }\r
1214         public float ColorGreen\r
1215         {\r
1216             get\r
1217             {\r
1218                 float temp = 0.0f;\r
1219                 GetProperty(Actor.Property.COLOR_GREEN).Get(ref temp);\r
1220                 return temp;\r
1221             }\r
1222             set\r
1223             {\r
1224                 SetProperty(Actor.Property.COLOR_GREEN, new Tizen.NUI.PropertyValue(value));\r
1225             }\r
1226         }\r
1227         public float ColorBlue\r
1228         {\r
1229             get\r
1230             {\r
1231                 float temp = 0.0f;\r
1232                 GetProperty(Actor.Property.COLOR_BLUE).Get(ref temp);\r
1233                 return temp;\r
1234             }\r
1235             set\r
1236             {\r
1237                 SetProperty(Actor.Property.COLOR_BLUE, new Tizen.NUI.PropertyValue(value));\r
1238             }\r
1239         }\r
1240         public float ColorAlpha\r
1241         {\r
1242             get\r
1243             {\r
1244                 float temp = 0.0f;\r
1245                 GetProperty(Actor.Property.COLOR_ALPHA).Get(ref temp);\r
1246                 return temp;\r
1247             }\r
1248             set\r
1249             {\r
1250                 SetProperty(Actor.Property.COLOR_ALPHA, new Tizen.NUI.PropertyValue(value));\r
1251             }\r
1252         }\r
1253         public Color WorldColor\r
1254         {\r
1255             get\r
1256             {\r
1257                 Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);\r
1258                 GetProperty(Actor.Property.WORLD_COLOR).Get(temp);\r
1259                 return temp;\r
1260             }\r
1261         }\r
1262 \r
1263         public string Name\r
1264         {\r
1265             get\r
1266             {\r
1267                 string temp;\r
1268                 GetProperty(Actor.Property.NAME).Get(out temp);\r
1269                 return temp;\r
1270             }\r
1271             set\r
1272             {\r
1273                 SetProperty(Actor.Property.NAME, new Tizen.NUI.PropertyValue(value));\r
1274             }\r
1275         }\r
1276         public bool Sensitive\r
1277         {\r
1278             get\r
1279             {\r
1280                 bool temp = false;\r
1281                 GetProperty(Actor.Property.SENSITIVE).Get(ref temp);\r
1282                 return temp;\r
1283             }\r
1284             set\r
1285             {\r
1286                 SetProperty(Actor.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));\r
1287             }\r
1288         }\r
1289         public bool LeaveRequired\r
1290         {\r
1291             get\r
1292             {\r
1293                 bool temp = false;\r
1294                 GetProperty(Actor.Property.LEAVE_REQUIRED).Get(ref temp);\r
1295                 return temp;\r
1296             }\r
1297             set\r
1298             {\r
1299                 SetProperty(Actor.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));\r
1300             }\r
1301         }\r
1302         public bool InheritOrientation\r
1303         {\r
1304             get\r
1305             {\r
1306                 bool temp = false;\r
1307                 GetProperty(Actor.Property.INHERIT_ORIENTATION).Get(ref temp);\r
1308                 return temp;\r
1309             }\r
1310             set\r
1311             {\r
1312                 SetProperty(Actor.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));\r
1313             }\r
1314         }\r
1315         public bool InheritScale\r
1316         {\r
1317             get\r
1318             {\r
1319                 bool temp = false;\r
1320                 GetProperty(Actor.Property.INHERIT_SCALE).Get(ref temp);\r
1321                 return temp;\r
1322             }\r
1323             set\r
1324             {\r
1325                 SetProperty(Actor.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));\r
1326             }\r
1327         }\r
1328 \r
1329         public ColorMode ColorMode\r
1330         {\r
1331             get\r
1332             {\r
1333                 string temp;\r
1334                 if (GetProperty(Actor.Property.COLOR_MODE).Get(out temp) == false)\r
1335                 {\r
1336                     //Tizen.Log.Error("NUI", "ColorMode get error!");\r
1337                 }\r
1338                 switch (temp)\r
1339                 {\r
1340                     case "USE_OWN_COLOR":\r
1341                         return ColorMode.UseOwnColor;\r
1342                     case "USE_PARENT_COLOR":\r
1343                         return ColorMode.UseParentColor;\r
1344                     case "USE_OWN_MULTIPLY_PARENT_COLOR":\r
1345                         return ColorMode.UseOwnMultiplyParentColor;\r
1346                     case "USE_OWN_MULTIPLY_PARENT_ALPHA":\r
1347                         return ColorMode.UseOwnMultiplyParentAlpha;\r
1348                     default:\r
1349                         return ColorMode.UseOwnColor;\r
1350                 }\r
1351             }\r
1352             set\r
1353             {\r
1354                 SetProperty(Actor.Property.COLOR_MODE, new Tizen.NUI.PropertyValue((int)value));\r
1355             }\r
1356         }\r
1357 \r
1358         public DrawModeType DrawMode\r
1359         {\r
1360             get\r
1361             {\r
1362                 string temp;\r
1363                 if (GetProperty(Actor.Property.DRAW_MODE).Get(out temp) == false)\r
1364                 {\r
1365                     //Tizen.Log.Error("NUI", "DrawMode get error!");\r
1366                 }\r
1367                 switch (temp)\r
1368                 {\r
1369                     case "NORMAL":\r
1370                         return DrawModeType.Normal;\r
1371                     case "OVERLAY_2D":\r
1372                         return DrawModeType.Overlay2D;\r
1373                     case "STENCIL":\r
1374                         return DrawModeType.Stencil;\r
1375                     default:\r
1376                         return DrawModeType.Normal;\r
1377                 }\r
1378             }\r
1379             set\r
1380             {\r
1381                 SetProperty(Actor.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));\r
1382             }\r
1383         }\r
1384         public Vector3 SizeModeFactor\r
1385         {\r
1386             get\r
1387             {\r
1388                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);\r
1389                 GetProperty(Actor.Property.SIZE_MODE_FACTOR).Get(temp);\r
1390                 return temp;\r
1391             }\r
1392             set\r
1393             {\r
1394                 SetProperty(Actor.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));\r
1395             }\r
1396         }\r
1397 \r
1398         public ResizePolicyType WidthResizePolicy\r
1399         {\r
1400             get\r
1401             {\r
1402                 string temp;\r
1403                 if (GetProperty(Actor.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)\r
1404                 {\r
1405                     //Tizen.Log.Error("NUI", "WidthResizePolicy get error!");\r
1406                 }\r
1407                 switch (temp)\r
1408                 {\r
1409                     case "FIXED":\r
1410                         return ResizePolicyType.Fixed;\r
1411                     case "USE_NATURAL_SIZE":\r
1412                         return ResizePolicyType.UseNaturalSize;\r
1413                     case "FILL_TO_PARENT":\r
1414                         return ResizePolicyType.FillToParent;\r
1415                     case "SIZE_RELATIVE_TO_PARENT":\r
1416                         return ResizePolicyType.SizeRelativeToParent;\r
1417                     case "SIZE_FIXED_OFFSET_FROM_PARENT":\r
1418                         return ResizePolicyType.SizeFixedOffsetFromParent;\r
1419                     case "FIT_TO_CHILDREN":\r
1420                         return ResizePolicyType.FitToChildren;\r
1421                     case "DIMENSION_DEPENDENCY":\r
1422                         return ResizePolicyType.DimensionDependency;\r
1423                     case "USE_ASSIGNED_SIZE":\r
1424                         return ResizePolicyType.UseAssignedSize;\r
1425                     default:\r
1426                         return ResizePolicyType.Fixed;\r
1427                 }\r
1428             }\r
1429             set\r
1430             {\r
1431                 SetProperty(Actor.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));\r
1432             }\r
1433         }\r
1434 \r
1435         public ResizePolicyType HeightResizePolicy\r
1436         {\r
1437             get\r
1438             {\r
1439                 string temp;\r
1440                 if (GetProperty(Actor.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)\r
1441                 {\r
1442                     //Tizen.Log.Error("NUI", "HeightResizePolicy get error!");\r
1443                 }\r
1444                 switch (temp)\r
1445                 {\r
1446                     case "FIXED":\r
1447                         return ResizePolicyType.Fixed;\r
1448                     case "USE_NATURAL_SIZE":\r
1449                         return ResizePolicyType.UseNaturalSize;\r
1450                     case "FILL_TO_PARENT":\r
1451                         return ResizePolicyType.FillToParent;\r
1452                     case "SIZE_RELATIVE_TO_PARENT":\r
1453                         return ResizePolicyType.SizeRelativeToParent;\r
1454                     case "SIZE_FIXED_OFFSET_FROM_PARENT":\r
1455                         return ResizePolicyType.SizeFixedOffsetFromParent;\r
1456                     case "FIT_TO_CHILDREN":\r
1457                         return ResizePolicyType.FitToChildren;\r
1458                     case "DIMENSION_DEPENDENCY":\r
1459                         return ResizePolicyType.DimensionDependency;\r
1460                     case "USE_ASSIGNED_SIZE":\r
1461                         return ResizePolicyType.UseAssignedSize;\r
1462                     default:\r
1463                         return ResizePolicyType.Fixed;\r
1464                 }\r
1465             }\r
1466             set\r
1467             {\r
1468                 SetProperty(Actor.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));\r
1469             }\r
1470         }\r
1471 \r
1472         public SizeScalePolicyType SizeScalePolicy\r
1473         {\r
1474             get\r
1475             {\r
1476                 string temp;\r
1477                 if (GetProperty(Actor.Property.SIZE_SCALE_POLICY).Get(out temp) == false)\r
1478                 {\r
1479                     //Tizen.Log.Error("NUI", "SizeScalePolicy get error!");\r
1480                 }\r
1481                 switch (temp)\r
1482                 {\r
1483                     case "USE_SIZE_SET":\r
1484                         return SizeScalePolicyType.UseSizeSet;\r
1485                     case "FIT_WITH_ASPECT_RATIO":\r
1486                         return SizeScalePolicyType.FitWithAspectRatio;\r
1487                     case "FILL_WITH_ASPECT_RATIO":\r
1488                         return SizeScalePolicyType.FillWithAspectRatio;\r
1489                     default:\r
1490                         return SizeScalePolicyType.UseSizeSet;\r
1491                 }\r
1492             }\r
1493             set\r
1494             {\r
1495                 SetProperty(Actor.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue((int)value));\r
1496             }\r
1497         }\r
1498 \r
1499         public bool WidthDependentOnHeight\r
1500         {\r
1501             get\r
1502             {\r
1503                 bool temp = false;\r
1504                 GetProperty(Actor.Property.WIDTH_FOR_HEIGHT).Get(ref temp);\r
1505                 return temp;\r
1506             }\r
1507             set\r
1508             {\r
1509                 SetProperty(Actor.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));\r
1510             }\r
1511         }\r
1512         public bool HeightDependentOnWidth\r
1513         {\r
1514             get\r
1515             {\r
1516                 bool temp = false;\r
1517                 GetProperty(Actor.Property.HEIGHT_FOR_WIDTH).Get(ref temp);\r
1518                 return temp;\r
1519             }\r
1520             set\r
1521             {\r
1522                 SetProperty(Actor.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));\r
1523             }\r
1524         }\r
1525         public Vector4 Padding\r
1526         {\r
1527             get\r
1528             {\r
1529                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);\r
1530                 GetProperty(Actor.Property.PADDING).Get(temp);\r
1531                 return temp;\r
1532             }\r
1533             set\r
1534             {\r
1535                 SetProperty(Actor.Property.PADDING, new Tizen.NUI.PropertyValue(value));\r
1536             }\r
1537         }\r
1538 \r
1539         public Size2D MinimumSize\r
1540         {\r
1541             get\r
1542             {\r
1543                 Size2D temp = new Size2D(0.0f, 0.0f);\r
1544                 GetProperty(Actor.Property.MINIMUM_SIZE).Get(temp);\r
1545                 return temp;\r
1546             }\r
1547             set\r
1548             {\r
1549                 SetProperty(Actor.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));\r
1550             }\r
1551         }\r
1552 \r
1553         public Size2D MaximumSize\r
1554         {\r
1555             get\r
1556             {\r
1557                 Size2D temp = new Size2D(0.0f, 0.0f);\r
1558                 GetProperty(Actor.Property.MAXIMUM_SIZE).Get(temp);\r
1559                 return temp;\r
1560             }\r
1561             set\r
1562             {\r
1563                 SetProperty(Actor.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));\r
1564             }\r
1565         }\r
1566         public bool InheritPosition\r
1567         {\r
1568             get\r
1569             {\r
1570                 bool temp = false;\r
1571                 GetProperty(Actor.Property.INHERIT_POSITION).Get(ref temp);\r
1572                 return temp;\r
1573             }\r
1574             set\r
1575             {\r
1576                 SetProperty(Actor.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));\r
1577             }\r
1578         }\r
1579 \r
1580         public ClippingModeType ClippingMode\r
1581         {\r
1582             get\r
1583             {\r
1584                 string temp;\r
1585                 if (GetProperty(Actor.Property.CLIPPING_MODE).Get(out temp) == false)\r
1586                 {\r
1587                     //Tizen.Log.Error("NUI", "ClippingMode get error!");\r
1588                 }\r
1589                 switch (temp)\r
1590                 {\r
1591                     case "DISABLED":\r
1592                         return ClippingModeType.Disabled;\r
1593                     case "CLIP_CHILDREN":\r
1594                         return ClippingModeType.ClipChildren;\r
1595                     default:\r
1596                         return ClippingModeType.Disabled;\r
1597                 }\r
1598             }\r
1599             set\r
1600             {\r
1601                 SetProperty(Actor.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));\r
1602             }\r
1603         }\r
1604 \r
1605     }\r
1606     //changed\r
1607     public enum ColorMode\r
1608     {\r
1609         UseOwnColor,\r
1610         UseParentColor,\r
1611         UseOwnMultiplyParentColor,\r
1612         UseOwnMultiplyParentAlpha\r
1613             }\r
1614 \r
1615     public enum DimensionType\r
1616     {\r
1617         Width = 0x1,\r
1618         Height = 0x2,\r
1619         AllDimensions = 0x3\r
1620         }\r
1621 \r
1622     public enum DrawModeType\r
1623     {\r
1624         Normal = 0,\r
1625         Overlay2D = 1,\r
1626         Stencil = 3\r
1627     }\r
1628     public enum ResizePolicyType\r
1629     {\r
1630         Fixed,\r
1631         UseNaturalSize,\r
1632         FillToParent,\r
1633         SizeRelativeToParent,\r
1634         SizeFixedOffsetFromParent,\r
1635         FitToChildren,\r
1636         DimensionDependency,\r
1637         UseAssignedSize\r
1638     }\r
1639     public enum SizeScalePolicyType\r
1640     {\r
1641         UseSizeSet,\r
1642         FitWithAspectRatio,\r
1643         FillWithAspectRatio\r
1644     }\r
1645     public enum ClippingModeType\r
1646     {\r
1647         Disabled,\r
1648         ClipChildren\r
1649     }
1650
1651 }