6d0ab26a500ae4be9a7bf3c1d831636f3b9d60e9
[platform/core/csapi/nui.git] / 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                 float temp = 0.0f;\r
1011                 GetProperty(Actor.Property.SIZE_WIDTH).Get(ref temp);\r
1012                 return temp;\r
1013             }\r
1014             set\r
1015             {\r
1016                 SetProperty(Actor.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));\r
1017             }\r
1018         }\r
1019         public float SizeHeight\r
1020         {\r
1021             get\r
1022             {\r
1023                 float temp = 0.0f;\r
1024                 GetProperty(Actor.Property.SIZE_HEIGHT).Get(ref temp);\r
1025                 return temp;\r
1026             }\r
1027             set\r
1028             {\r
1029                 SetProperty(Actor.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));\r
1030             }\r
1031         }\r
1032         public float SizeDepth\r
1033         {\r
1034             get\r
1035             {\r
1036                 float temp = 0.0f;\r
1037                 GetProperty(Actor.Property.SIZE_DEPTH).Get(ref temp);\r
1038                 return temp;\r
1039             }\r
1040             set\r
1041             {\r
1042                 SetProperty(Actor.Property.SIZE_DEPTH, new Tizen.NUI.PropertyValue(value));\r
1043             }\r
1044         }\r
1045         public Position Position\r
1046         {\r
1047             get\r
1048             {\r
1049                 Position temp = GetCurrentPosition();\r
1050                 return temp;\r
1051             }\r
1052             set\r
1053             {\r
1054                 SetProperty(Actor.Property.POSITION, new Tizen.NUI.PropertyValue(value));\r
1055             }\r
1056         }\r
1057         public float PositionX\r
1058         {\r
1059             get\r
1060             {\r
1061                 float temp = 0.0f;\r
1062                 GetProperty(Actor.Property.POSITION_X).Get(ref temp);\r
1063                 return temp;\r
1064             }\r
1065             set\r
1066             {\r
1067                 SetProperty(Actor.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));\r
1068             }\r
1069         }\r
1070         public float PositionY\r
1071         {\r
1072             get\r
1073             {\r
1074                 float temp = 0.0f;\r
1075                 GetProperty(Actor.Property.POSITION_Y).Get(ref temp);\r
1076                 return temp;\r
1077             }\r
1078             set\r
1079             {\r
1080                 SetProperty(Actor.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));\r
1081             }\r
1082         }\r
1083         public float PositionZ\r
1084         {\r
1085             get\r
1086             {\r
1087                 float temp = 0.0f;\r
1088                 GetProperty(Actor.Property.POSITION_Z).Get(ref temp);\r
1089                 return temp;\r
1090             }\r
1091             set\r
1092             {\r
1093                 SetProperty(Actor.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));\r
1094             }\r
1095         }\r
1096         public Vector3 WorldPosition\r
1097         {\r
1098             get\r
1099             {\r
1100                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);\r
1101                 GetProperty(Actor.Property.WORLD_POSITION).Get(temp);\r
1102                 return temp;\r
1103             }\r
1104         }\r
1105 \r
1106         public Rotation Orientation\r
1107         {\r
1108             get\r
1109             {\r
1110                 Rotation temp = new Rotation();\r
1111                 GetProperty(Actor.Property.ORIENTATION).Get(temp);\r
1112                 return temp;\r
1113             }\r
1114             set\r
1115             {\r
1116                 SetProperty(Actor.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));\r
1117             }\r
1118         }\r
1119         public Rotation WorldOrientation\r
1120         {\r
1121             get\r
1122             {\r
1123                 Rotation temp = new Rotation();\r
1124                 GetProperty(Actor.Property.WORLD_ORIENTATION).Get(temp);\r
1125                 return temp;\r
1126             }\r
1127         }\r
1128         public Vector3 Scale\r
1129         {\r
1130             get\r
1131             {\r
1132                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);\r
1133                 GetProperty(Actor.Property.SCALE).Get(temp);\r
1134                 return temp;\r
1135             }\r
1136             set\r
1137             {\r
1138                 SetProperty(Actor.Property.SCALE, new Tizen.NUI.PropertyValue(value));\r
1139             }\r
1140         }\r
1141         public float ScaleX\r
1142         {\r
1143             get\r
1144             {\r
1145                 float temp = 0.0f;\r
1146                 GetProperty(Actor.Property.SCALE_X).Get(ref temp);\r
1147                 return temp;\r
1148             }\r
1149             set\r
1150             {\r
1151                 SetProperty(Actor.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));\r
1152             }\r
1153         }\r
1154         public float ScaleY\r
1155         {\r
1156             get\r
1157             {\r
1158                 float temp = 0.0f;\r
1159                 GetProperty(Actor.Property.SCALE_Y).Get(ref temp);\r
1160                 return temp;\r
1161             }\r
1162             set\r
1163             {\r
1164                 SetProperty(Actor.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));\r
1165             }\r
1166         }\r
1167         public float ScaleZ\r
1168         {\r
1169             get\r
1170             {\r
1171                 float temp = 0.0f;\r
1172                 GetProperty(Actor.Property.SCALE_Z).Get(ref temp);\r
1173                 return temp;\r
1174             }\r
1175             set\r
1176             {\r
1177                 SetProperty(Actor.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));\r
1178             }\r
1179         }\r
1180         public Vector3 WorldScale\r
1181         {\r
1182             get\r
1183             {\r
1184                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);\r
1185                 GetProperty(Actor.Property.WORLD_SCALE).Get(temp);\r
1186                 return temp;\r
1187             }\r
1188         }\r
1189         public bool Visible\r
1190         {\r
1191             get\r
1192             {\r
1193                 bool temp = false;\r
1194                 GetProperty(Actor.Property.VISIBLE).Get(ref temp);\r
1195                 return temp;\r
1196             }\r
1197             set\r
1198             {\r
1199                 SetProperty(Actor.Property.VISIBLE, new Tizen.NUI.PropertyValue(value));\r
1200             }\r
1201         }\r
1202         public Color MixColor\r
1203         {\r
1204             get\r
1205             {\r
1206                 Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);\r
1207                 GetProperty(Actor.Property.COLOR).Get(temp);\r
1208                 return temp;\r
1209             }\r
1210             set\r
1211             {\r
1212                 SetProperty(Actor.Property.COLOR, new Tizen.NUI.PropertyValue(value));\r
1213             }\r
1214         }\r
1215         public float ColorRed\r
1216         {\r
1217             get\r
1218             {\r
1219                 float temp = 0.0f;\r
1220                 GetProperty(Actor.Property.COLOR_RED).Get(ref temp);\r
1221                 return temp;\r
1222             }\r
1223             set\r
1224             {\r
1225                 SetProperty(Actor.Property.COLOR_RED, new Tizen.NUI.PropertyValue(value));\r
1226             }\r
1227         }\r
1228         public float ColorGreen\r
1229         {\r
1230             get\r
1231             {\r
1232                 float temp = 0.0f;\r
1233                 GetProperty(Actor.Property.COLOR_GREEN).Get(ref temp);\r
1234                 return temp;\r
1235             }\r
1236             set\r
1237             {\r
1238                 SetProperty(Actor.Property.COLOR_GREEN, new Tizen.NUI.PropertyValue(value));\r
1239             }\r
1240         }\r
1241         public float ColorBlue\r
1242         {\r
1243             get\r
1244             {\r
1245                 float temp = 0.0f;\r
1246                 GetProperty(Actor.Property.COLOR_BLUE).Get(ref temp);\r
1247                 return temp;\r
1248             }\r
1249             set\r
1250             {\r
1251                 SetProperty(Actor.Property.COLOR_BLUE, new Tizen.NUI.PropertyValue(value));\r
1252             }\r
1253         }\r
1254         public float ColorAlpha\r
1255         {\r
1256             get\r
1257             {\r
1258                 float temp = 0.0f;\r
1259                 GetProperty(Actor.Property.COLOR_ALPHA).Get(ref temp);\r
1260                 return temp;\r
1261             }\r
1262             set\r
1263             {\r
1264                 SetProperty(Actor.Property.COLOR_ALPHA, new Tizen.NUI.PropertyValue(value));\r
1265             }\r
1266         }\r
1267         public Color WorldColor\r
1268         {\r
1269             get\r
1270             {\r
1271                 Color temp = new Color(0.0f, 0.0f, 0.0f, 0.0f);\r
1272                 GetProperty(Actor.Property.WORLD_COLOR).Get(temp);\r
1273                 return temp;\r
1274             }\r
1275         }\r
1276 \r
1277         public string Name\r
1278         {\r
1279             get\r
1280             {\r
1281                 string temp;\r
1282                 GetProperty(Actor.Property.NAME).Get(out temp);\r
1283                 return temp;\r
1284             }\r
1285             set\r
1286             {\r
1287                 SetProperty(Actor.Property.NAME, new Tizen.NUI.PropertyValue(value));\r
1288             }\r
1289         }\r
1290         public bool Sensitive\r
1291         {\r
1292             get\r
1293             {\r
1294                 bool temp = false;\r
1295                 GetProperty(Actor.Property.SENSITIVE).Get(ref temp);\r
1296                 return temp;\r
1297             }\r
1298             set\r
1299             {\r
1300                 SetProperty(Actor.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));\r
1301             }\r
1302         }\r
1303         public bool LeaveRequired\r
1304         {\r
1305             get\r
1306             {\r
1307                 bool temp = false;\r
1308                 GetProperty(Actor.Property.LEAVE_REQUIRED).Get(ref temp);\r
1309                 return temp;\r
1310             }\r
1311             set\r
1312             {\r
1313                 SetProperty(Actor.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));\r
1314             }\r
1315         }\r
1316         public bool InheritOrientation\r
1317         {\r
1318             get\r
1319             {\r
1320                 bool temp = false;\r
1321                 GetProperty(Actor.Property.INHERIT_ORIENTATION).Get(ref temp);\r
1322                 return temp;\r
1323             }\r
1324             set\r
1325             {\r
1326                 SetProperty(Actor.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));\r
1327             }\r
1328         }\r
1329         public bool InheritScale\r
1330         {\r
1331             get\r
1332             {\r
1333                 bool temp = false;\r
1334                 GetProperty(Actor.Property.INHERIT_SCALE).Get(ref temp);\r
1335                 return temp;\r
1336             }\r
1337             set\r
1338             {\r
1339                 SetProperty(Actor.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));\r
1340             }\r
1341         }\r
1342 \r
1343         public ColorMode ColorMode\r
1344         {\r
1345             get\r
1346             {\r
1347                 string temp;\r
1348                 if (GetProperty(Actor.Property.COLOR_MODE).Get(out temp) == false)\r
1349                 {\r
1350                     //Tizen.Log.Error("NUI", "ColorMode get error!");\r
1351                 }\r
1352                 switch (temp)\r
1353                 {\r
1354                     case "USE_OWN_COLOR":\r
1355                         return ColorMode.UseOwnColor;\r
1356                     case "USE_PARENT_COLOR":\r
1357                         return ColorMode.UseParentColor;\r
1358                     case "USE_OWN_MULTIPLY_PARENT_COLOR":\r
1359                         return ColorMode.UseOwnMultiplyParentColor;\r
1360                     case "USE_OWN_MULTIPLY_PARENT_ALPHA":\r
1361                         return ColorMode.UseOwnMultiplyParentAlpha;\r
1362                     default:\r
1363                         return ColorMode.UseOwnColor;\r
1364                 }\r
1365             }\r
1366             set\r
1367             {\r
1368                 SetProperty(Actor.Property.COLOR_MODE, new Tizen.NUI.PropertyValue((int)value));\r
1369             }\r
1370         }\r
1371 \r
1372         public DrawModeType DrawMode\r
1373         {\r
1374             get\r
1375             {\r
1376                 string temp;\r
1377                 if (GetProperty(Actor.Property.DRAW_MODE).Get(out temp) == false)\r
1378                 {\r
1379                     //Tizen.Log.Error("NUI", "DrawMode get error!");\r
1380                 }\r
1381                 switch (temp)\r
1382                 {\r
1383                     case "NORMAL":\r
1384                         return DrawModeType.Normal;\r
1385                     case "OVERLAY_2D":\r
1386                         return DrawModeType.Overlay2D;\r
1387                     case "STENCIL":\r
1388                         return DrawModeType.Stencil;\r
1389                     default:\r
1390                         return DrawModeType.Normal;\r
1391                 }\r
1392             }\r
1393             set\r
1394             {\r
1395                 SetProperty(Actor.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));\r
1396             }\r
1397         }\r
1398         public Vector3 SizeModeFactor\r
1399         {\r
1400             get\r
1401             {\r
1402                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);\r
1403                 GetProperty(Actor.Property.SIZE_MODE_FACTOR).Get(temp);\r
1404                 return temp;\r
1405             }\r
1406             set\r
1407             {\r
1408                 SetProperty(Actor.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));\r
1409             }\r
1410         }\r
1411 \r
1412         public ResizePolicyType WidthResizePolicy\r
1413         {\r
1414             get\r
1415             {\r
1416                 string temp;\r
1417                 if (GetProperty(Actor.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)\r
1418                 {\r
1419                     //Tizen.Log.Error("NUI", "WidthResizePolicy get error!");\r
1420                 }\r
1421                 switch (temp)\r
1422                 {\r
1423                     case "FIXED":\r
1424                         return ResizePolicyType.Fixed;\r
1425                     case "USE_NATURAL_SIZE":\r
1426                         return ResizePolicyType.UseNaturalSize;\r
1427                     case "FILL_TO_PARENT":\r
1428                         return ResizePolicyType.FillToParent;\r
1429                     case "SIZE_RELATIVE_TO_PARENT":\r
1430                         return ResizePolicyType.SizeRelativeToParent;\r
1431                     case "SIZE_FIXED_OFFSET_FROM_PARENT":\r
1432                         return ResizePolicyType.SizeFixedOffsetFromParent;\r
1433                     case "FIT_TO_CHILDREN":\r
1434                         return ResizePolicyType.FitToChildren;\r
1435                     case "DIMENSION_DEPENDENCY":\r
1436                         return ResizePolicyType.DimensionDependency;\r
1437                     case "USE_ASSIGNED_SIZE":\r
1438                         return ResizePolicyType.UseAssignedSize;\r
1439                     default:\r
1440                         return ResizePolicyType.Fixed;\r
1441                 }\r
1442             }\r
1443             set\r
1444             {\r
1445                 SetProperty(Actor.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));\r
1446             }\r
1447         }\r
1448 \r
1449         public ResizePolicyType HeightResizePolicy\r
1450         {\r
1451             get\r
1452             {\r
1453                 string temp;\r
1454                 if (GetProperty(Actor.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)\r
1455                 {\r
1456                     //Tizen.Log.Error("NUI", "HeightResizePolicy get error!");\r
1457                 }\r
1458                 switch (temp)\r
1459                 {\r
1460                     case "FIXED":\r
1461                         return ResizePolicyType.Fixed;\r
1462                     case "USE_NATURAL_SIZE":\r
1463                         return ResizePolicyType.UseNaturalSize;\r
1464                     case "FILL_TO_PARENT":\r
1465                         return ResizePolicyType.FillToParent;\r
1466                     case "SIZE_RELATIVE_TO_PARENT":\r
1467                         return ResizePolicyType.SizeRelativeToParent;\r
1468                     case "SIZE_FIXED_OFFSET_FROM_PARENT":\r
1469                         return ResizePolicyType.SizeFixedOffsetFromParent;\r
1470                     case "FIT_TO_CHILDREN":\r
1471                         return ResizePolicyType.FitToChildren;\r
1472                     case "DIMENSION_DEPENDENCY":\r
1473                         return ResizePolicyType.DimensionDependency;\r
1474                     case "USE_ASSIGNED_SIZE":\r
1475                         return ResizePolicyType.UseAssignedSize;\r
1476                     default:\r
1477                         return ResizePolicyType.Fixed;\r
1478                 }\r
1479             }\r
1480             set\r
1481             {\r
1482                 SetProperty(Actor.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));\r
1483             }\r
1484         }\r
1485 \r
1486         public SizeScalePolicyType SizeScalePolicy\r
1487         {\r
1488             get\r
1489             {\r
1490                 string temp;\r
1491                 if (GetProperty(Actor.Property.SIZE_SCALE_POLICY).Get(out temp) == false)\r
1492                 {\r
1493                     //Tizen.Log.Error("NUI", "SizeScalePolicy get error!");\r
1494                 }\r
1495                 switch (temp)\r
1496                 {\r
1497                     case "USE_SIZE_SET":\r
1498                         return SizeScalePolicyType.UseSizeSet;\r
1499                     case "FIT_WITH_ASPECT_RATIO":\r
1500                         return SizeScalePolicyType.FitWithAspectRatio;\r
1501                     case "FILL_WITH_ASPECT_RATIO":\r
1502                         return SizeScalePolicyType.FillWithAspectRatio;\r
1503                     default:\r
1504                         return SizeScalePolicyType.UseSizeSet;\r
1505                 }\r
1506             }\r
1507             set\r
1508             {\r
1509                 SetProperty(Actor.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue((int)value));\r
1510             }\r
1511         }\r
1512 \r
1513         public bool WidthDependentOnHeight\r
1514         {\r
1515             get\r
1516             {\r
1517                 bool temp = false;\r
1518                 GetProperty(Actor.Property.WIDTH_FOR_HEIGHT).Get(ref temp);\r
1519                 return temp;\r
1520             }\r
1521             set\r
1522             {\r
1523                 SetProperty(Actor.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));\r
1524             }\r
1525         }\r
1526         public bool HeightDependentOnWidth\r
1527         {\r
1528             get\r
1529             {\r
1530                 bool temp = false;\r
1531                 GetProperty(Actor.Property.HEIGHT_FOR_WIDTH).Get(ref temp);\r
1532                 return temp;\r
1533             }\r
1534             set\r
1535             {\r
1536                 SetProperty(Actor.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));\r
1537             }\r
1538         }\r
1539         public Vector4 Padding\r
1540         {\r
1541             get\r
1542             {\r
1543                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);\r
1544                 GetProperty(Actor.Property.PADDING).Get(temp);\r
1545                 return temp;\r
1546             }\r
1547             set\r
1548             {\r
1549                 SetProperty(Actor.Property.PADDING, new Tizen.NUI.PropertyValue(value));\r
1550             }\r
1551         }\r
1552 \r
1553         public Size2D MinimumSize\r
1554         {\r
1555             get\r
1556             {\r
1557                 Size2D temp = new Size2D(0.0f, 0.0f);\r
1558                 GetProperty(Actor.Property.MINIMUM_SIZE).Get(temp);\r
1559                 return temp;\r
1560             }\r
1561             set\r
1562             {\r
1563                 SetProperty(Actor.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));\r
1564             }\r
1565         }\r
1566 \r
1567         public Size2D MaximumSize\r
1568         {\r
1569             get\r
1570             {\r
1571                 Size2D temp = new Size2D(0.0f, 0.0f);\r
1572                 GetProperty(Actor.Property.MAXIMUM_SIZE).Get(temp);\r
1573                 return temp;\r
1574             }\r
1575             set\r
1576             {\r
1577                 SetProperty(Actor.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));\r
1578             }\r
1579         }\r
1580         public bool InheritPosition\r
1581         {\r
1582             get\r
1583             {\r
1584                 bool temp = false;\r
1585                 GetProperty(Actor.Property.INHERIT_POSITION).Get(ref temp);\r
1586                 return temp;\r
1587             }\r
1588             set\r
1589             {\r
1590                 SetProperty(Actor.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));\r
1591             }\r
1592         }\r
1593 \r
1594         public ClippingModeType ClippingMode\r
1595         {\r
1596             get\r
1597             {\r
1598                 string temp;\r
1599                 if (GetProperty(Actor.Property.CLIPPING_MODE).Get(out temp) == false)\r
1600                 {\r
1601                     //Tizen.Log.Error("NUI", "ClippingMode get error!");\r
1602                 }\r
1603                 switch (temp)\r
1604                 {\r
1605                     case "DISABLED":\r
1606                         return ClippingModeType.Disabled;\r
1607                     case "CLIP_CHILDREN":\r
1608                         return ClippingModeType.ClipChildren;\r
1609                     default:\r
1610                         return ClippingModeType.Disabled;\r
1611                 }\r
1612             }\r
1613             set\r
1614             {\r
1615                 SetProperty(Actor.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));\r
1616             }\r
1617         }\r
1618 \r
1619     }\r
1620     //changed\r
1621     public enum ColorMode\r
1622     {\r
1623         UseOwnColor,\r
1624         UseParentColor,\r
1625         UseOwnMultiplyParentColor,\r
1626         UseOwnMultiplyParentAlpha\r
1627             }\r
1628 \r
1629     public enum DimensionType\r
1630     {\r
1631         Width = 0x1,\r
1632         Height = 0x2,\r
1633         AllDimensions = 0x3\r
1634         }\r
1635 \r
1636     public enum DrawModeType\r
1637     {\r
1638         Normal = 0,\r
1639         Overlay2D = 1,\r
1640         Stencil = 3\r
1641     }\r
1642     public enum ResizePolicyType\r
1643     {\r
1644         Fixed,\r
1645         UseNaturalSize,\r
1646         FillToParent,\r
1647         SizeRelativeToParent,\r
1648         SizeFixedOffsetFromParent,\r
1649         FitToChildren,\r
1650         DimensionDependency,\r
1651         UseAssignedSize\r
1652     }\r
1653     public enum SizeScalePolicyType\r
1654     {\r
1655         UseSizeSet,\r
1656         FitWithAspectRatio,\r
1657         FillWithAspectRatio\r
1658     }\r
1659     public enum ClippingModeType\r
1660     {\r
1661         Disabled,\r
1662         ClipChildren\r
1663     }
1664
1665 }