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