manual binding for TextEditor and ApplicationExtension
[platform/core/csapi/tizenfx.git] / src / Tizen.NUI / src / public / BaseComponents / View.cs
1 /** Copyright (c) 2017 Samsung Electronics Co., Ltd.
2 *
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 *
15 */
16
17 namespace Tizen.NUI.BaseComponents
18 {
19
20     using System;
21     using System.Runtime.InteropServices;
22
23     /// <summary>
24     /// View is the base class for all views.
25     /// </summary>
26     public class View : Animatable //CustomActor => Animatable
27     {
28         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
29
30         internal View(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.View_SWIGUpcast(cPtr), cMemoryOwn)
31         {
32             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
33
34             // Register this instance of view in the view registry.
35             ViewRegistry.RegisterView(this);
36         }
37
38         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj)
39         {
40             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
41         }
42
43         //you can override it to clean-up your own resources.
44         protected override void Dispose(DisposeTypes type)
45         {
46             if(disposed)
47             {
48                 return;
49             }
50
51             if(type == DisposeTypes.Explicit)
52             {
53                 //Called by User
54                 //Release your own managed resources here.
55                 //You should release all of your own disposable objects here.
56             }
57
58             //Release your own unmanaged resources here.
59             //You should not access any managed member here except static instance.
60             //because the execution order of Finalizes is non-deterministic.
61
62             //Unreference this from if a static instance refer to this.
63             ViewRegistry.UnregisterView(this);
64
65             if (swigCPtr.Handle != global::System.IntPtr.Zero)
66             {
67                 if (swigCMemOwn)
68                 {
69                     swigCMemOwn = false;
70                     NDalicPINVOKE.delete_View(swigCPtr);
71                 }
72                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
73             }
74
75             base.Dispose(type);
76         }
77
78         private EventHandler _keyInputFocusGainedEventHandler;
79         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
80         private delegate void KeyInputFocusGainedCallbackType(IntPtr control);
81         private KeyInputFocusGainedCallbackType _keyInputFocusGainedCallback;
82
83         /// <summary>
84         /// Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
85         /// KeyInputFocusGained signal is emitted when the control gets Key Input Focus.<br>
86         /// </summary>
87         public event EventHandler FocusGained
88         {
89             add
90             {
91                 if (_keyInputFocusGainedEventHandler == null)
92                 {
93                     _keyInputFocusGainedCallback = OnKeyInputFocusGained;
94                     this.KeyInputFocusGainedSignal().Connect(_keyInputFocusGainedCallback);
95                 }
96
97                 _keyInputFocusGainedEventHandler += value;
98             }
99
100             remove
101             {
102                 _keyInputFocusGainedEventHandler -= value;
103
104                 if (_keyInputFocusGainedEventHandler == null && KeyInputFocusGainedSignal().Empty() == false)
105                 {
106                     this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback);
107                 }
108             }
109         }
110
111         private void OnKeyInputFocusGained(IntPtr view)
112         {
113             if (_keyInputFocusGainedEventHandler != null)
114             {
115                 _keyInputFocusGainedEventHandler(this, null);
116             }
117         }
118
119
120         private EventHandler _keyInputFocusLostEventHandler;
121         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
122         private delegate void KeyInputFocusLostCallbackType(IntPtr control);
123         private KeyInputFocusLostCallbackType _keyInputFocusLostCallback;
124
125         /// <summary>
126         /// Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
127         /// KeyInputFocusLost signal is emitted when the control loses Key Input Focus.<br>
128         /// </summary>
129         public event EventHandler FocusLost
130         {
131             add
132             {
133                 if (_keyInputFocusLostEventHandler == null)
134                 {
135                     _keyInputFocusLostCallback = OnKeyInputFocusLost;
136                     this.KeyInputFocusLostSignal().Connect(_keyInputFocusLostCallback);
137                 }
138
139                 _keyInputFocusLostEventHandler += value;
140             }
141
142             remove
143             {
144                 _keyInputFocusLostEventHandler -= value;
145
146                 if (_keyInputFocusLostEventHandler == null && KeyInputFocusLostSignal().Empty() == false)
147                 {
148                     this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback);
149                 }
150             }
151         }
152
153         private void OnKeyInputFocusLost(IntPtr view)
154         {
155             if (_keyInputFocusLostEventHandler != null)
156             {
157                 _keyInputFocusLostEventHandler(this, null);
158             }
159         }
160
161         /// <summary>
162         /// Event arguments that passed via KeyEvent signal.
163         /// </summary>
164         public class KeyEventArgs : EventArgs
165         {
166             private Key _key;
167
168             /// <summary>
169             /// Key - is the key sent to the View.
170             /// </summary>
171             public Key Key
172             {
173                 get
174                 {
175                     return _key;
176                 }
177                 set
178                 {
179                     _key = value;
180                 }
181             }
182         }
183
184         private EventHandlerWithReturnType<object, KeyEventArgs, bool> _keyEventHandler;
185         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
186         private delegate bool KeyCallbackType(IntPtr control, IntPtr keyEvent);
187         private KeyCallbackType _keyCallback;
188
189         /// <summary>
190         /// Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
191         /// KeyPressed signal is emitted when key event is received.<br>
192         /// </summary>
193         public event EventHandlerWithReturnType<object, KeyEventArgs, bool> Key
194         {
195             add
196             {
197                 if (_keyEventHandler == null)
198                 {
199                     _keyCallback = OnKeyEvent;
200                     this.KeyEventSignal().Connect(_keyCallback);
201                 }
202
203                 _keyEventHandler += value;
204             }
205
206             remove
207             {
208                 _keyEventHandler -= value;
209
210                 if (_keyEventHandler == null && KeyEventSignal().Empty() == false)
211                 {
212                     this.KeyEventSignal().Disconnect(_keyCallback);
213                 }
214             }
215         }
216
217         private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
218         {
219             KeyEventArgs e = new KeyEventArgs();
220
221             e.Key = Tizen.NUI.Key.GetKeyFromPtr(keyEvent);
222
223             if (_keyEventHandler != null)
224             {
225                 return _keyEventHandler(this, e);
226             }
227             return false;
228         }
229
230
231         private EventHandler _onRelayoutEventHandler;
232         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
233         private delegate void OnRelayoutEventCallbackType(IntPtr control);
234         private OnRelayoutEventCallbackType _onRelayoutEventCallback;
235
236         /// <summary>
237         /// Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler.<br>
238         /// OnRelayout signal is emitted after the size has been set on the view during relayout.<br>
239         /// </summary>
240         public event EventHandler Relayout
241         {
242             add
243             {
244                 if (_onRelayoutEventHandler == null)
245                 {
246                     _onRelayoutEventCallback = OnRelayout;
247                     this.OnRelayoutSignal().Connect(_onRelayoutEventCallback);
248                 }
249
250                 _onRelayoutEventHandler += value;
251             }
252
253             remove
254             {
255                 _onRelayoutEventHandler -= value;
256
257                 if (_onRelayoutEventHandler == null && OnRelayoutSignal().Empty() == false)
258                 {
259                     this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
260                 }
261
262             }
263         }
264
265         // Callback for View OnRelayout signal
266         private void OnRelayout(IntPtr data)
267         {
268             if (_onRelayoutEventHandler != null)
269             {
270                 _onRelayoutEventHandler(this, null);
271             }
272         }
273
274         /// <summary>
275         /// Event arguments that passed via Touch signal.
276         /// </summary>
277         public class TouchEventArgs : EventArgs
278         {
279             private Touch _touch;
280
281             /// <summary>
282             /// Touch - contains the information of touch points
283             /// </summary>
284             public Touch Touch
285             {
286                 get
287                 {
288                     return _touch;
289                 }
290                 set
291                 {
292                     _touch = value;
293                 }
294             }
295         }
296
297         private EventHandlerWithReturnType<object, TouchEventArgs, bool> _touchDataEventHandler;
298         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
299         private delegate bool TouchDataCallbackType(IntPtr view, IntPtr touchData);
300         private TouchDataCallbackType _touchDataCallback;
301
302         /// <summary>
303         /// Event for Touched signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
304         /// Touched signal is emitted when touch input is received.<br>
305         /// </summary>
306         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> Touched
307         {
308             add
309             {
310                 if (_touchDataEventHandler == null)
311                 {
312                     _touchDataCallback = OnTouch;
313                     this.TouchSignal().Connect(_touchDataCallback);
314                 }
315
316                 _touchDataEventHandler += value;
317             }
318
319             remove
320             {
321                 _touchDataEventHandler -= value;
322
323                 if (_touchDataEventHandler == null && TouchSignal().Empty() == false)
324                 {
325                     this.TouchSignal().Disconnect(_touchDataCallback);
326                 }
327
328             }
329         }
330
331         // Callback for View TouchSignal
332         private bool OnTouch(IntPtr view, IntPtr touchData)
333         {
334             TouchEventArgs e = new TouchEventArgs();
335
336             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
337
338             if (_touchDataEventHandler != null)
339             {
340                 return _touchDataEventHandler(this, e);
341             }
342             return false;
343         }
344
345
346         /// <summary>
347         /// Event arguments that passed via Hover signal.
348         /// </summary>
349         public class HoverEventArgs : EventArgs
350         {
351             private Hover _hover;
352
353             /// <summary>
354             /// Hover - contains touch points that represent the points that are currently being hovered or the points where a hover has stopped.
355             /// </summary>
356             public Hover Hover
357             {
358                 get
359                 {
360                     return _hover;
361                 }
362                 set
363                 {
364                     _hover = value;
365                 }
366             }
367         }
368
369         private EventHandlerWithReturnType<object, HoverEventArgs, bool> _hoverEventHandler;
370         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
371         private delegate bool HoverEventCallbackType(IntPtr view, IntPtr hoverEvent);
372         private HoverEventCallbackType _hoverEventCallback;
373
374         /// <summary>
375         /// Event for Hovered signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
376         /// Hovered signal is emitted when hover input is received.<br>
377         /// </summary>
378         public event EventHandlerWithReturnType<object, HoverEventArgs, bool> Hovered
379         {
380             add
381             {
382                 if (_hoverEventHandler == null)
383                 {
384                     _hoverEventCallback = OnHoverEvent;
385                     this.HoveredSignal().Connect(_hoverEventCallback);
386                 }
387
388                 _hoverEventHandler += value;
389             }
390
391             remove
392             {
393                 _hoverEventHandler -= value;
394
395                 if (_hoverEventHandler == null && HoveredSignal().Empty() == false)
396                 {
397                     this.HoveredSignal().Disconnect(_hoverEventCallback);
398                 }
399
400             }
401         }
402
403         // Callback for View Hover signal
404         private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
405         {
406             HoverEventArgs e = new HoverEventArgs();
407
408             e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);
409
410             if (_hoverEventHandler != null)
411             {
412                 return _hoverEventHandler(this, e);
413             }
414             return false;
415         }
416
417
418         /// <summary>
419         /// Event arguments that passed via Wheel signal.
420         /// </summary>
421         public class WheelEventArgs : EventArgs
422         {
423             private Wheel _wheel;
424
425             /// <summary>
426             /// WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
427             /// </summary>
428             public Wheel Wheel
429             {
430                 get
431                 {
432                     return _wheel;
433                 }
434                 set
435                 {
436                     _wheel = value;
437                 }
438             }
439         }
440
441         private EventHandlerWithReturnType<object, WheelEventArgs, bool> _wheelEventHandler;
442         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
443         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
444         private WheelEventCallbackType _wheelEventCallback;
445
446         /// <summary>
447         /// Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
448         /// WheelMoved signal is emitted when wheel event is received.<br>
449         /// </summary>
450         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelRolled
451         {
452             add
453             {
454                 if (_wheelEventHandler == null)
455                 {
456                     _wheelEventCallback = OnWheelEvent;
457                     this.WheelEventSignal().Connect(_wheelEventCallback);
458                 }
459
460                 _wheelEventHandler += value;
461             }
462
463             remove
464             {
465                 _wheelEventHandler -= value;
466
467                 if (_wheelEventHandler == null && WheelEventSignal().Empty() == false)
468                 {
469                     this.WheelEventSignal().Disconnect(_wheelEventCallback);
470                 }
471
472             }
473         }
474
475         // Callback for View Wheel signal
476         private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
477         {
478             WheelEventArgs e = new WheelEventArgs();
479
480             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
481
482             if (_wheelEventHandler != null)
483             {
484                 return _wheelEventHandler(this, e);
485             }
486             return false;
487         }
488
489
490         private EventHandler _onWindowEventHandler;
491         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
492         private delegate void OnWindowEventCallbackType(IntPtr control);
493         private OnWindowEventCallbackType _onWindowEventCallback;
494
495         /// <summary>
496         /// Event for OnWindow signal which can be used to subscribe/unsubscribe the event handler.<br>
497         /// OnWindow signal is emitted after the view has been connected to the Window.<br>
498         /// </summary>
499         public event EventHandler AddedToWindow
500         {
501             add
502             {
503                 if (_onWindowEventHandler == null)
504                 {
505                     _onWindowEventCallback = OnWindow;
506                     this.OnWindowSignal().Connect(_onWindowEventCallback);
507                 }
508
509                 _onWindowEventHandler += value;
510             }
511
512             remove
513             {
514                 _onWindowEventHandler -= value;
515
516                 if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false)
517                 {
518                     this.OnWindowSignal().Disconnect(_onWindowEventCallback);
519                 }
520             }
521         }
522
523         // Callback for View OnWindow signal
524         private void OnWindow(IntPtr data)
525         {
526             if (_onWindowEventHandler != null)
527             {
528                 _onWindowEventHandler(this, null);
529             }
530         }
531
532
533         private EventHandler _offWindowEventHandler;
534         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
535         private delegate void OffWindowEventCallbackType(IntPtr control);
536         private OffWindowEventCallbackType _offWindowEventCallback;
537
538         /// <summary>
539         /// Event for OffWindow signal which can be used to subscribe/unsubscribe the event handler.<br>
540         /// OffWindow signal is emitted after the view has been disconnected from the Window.<br>
541         /// </summary>
542         public event EventHandler RemovedFromWindow
543         {
544             add
545             {
546                 if (_offWindowEventHandler == null)
547                 {
548                     _offWindowEventCallback = OffWindow;
549                     this.OffWindowSignal().Connect(_offWindowEventCallback);
550                 }
551
552                 _offWindowEventHandler += value;
553             }
554
555             remove
556             {
557                 _offWindowEventHandler -= value;
558
559                 if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false)
560                 {
561                     this.OffWindowSignal().Disconnect(_offWindowEventCallback);
562                 }
563             }
564         }
565
566         // Callback for View OffWindow signal
567         private void OffWindow(IntPtr data)
568         {
569             if (_offWindowEventHandler != null)
570             {
571                 _offWindowEventHandler(this, null);
572             }
573         }
574
575         /// <summary>
576         /// Event arguments of visibility changed.
577         /// </summary>
578         public class VisibilityChangedEventArgs : EventArgs
579         {
580             private View _view;
581             private bool _visibility;
582             private VisibilityChangeType _type;
583
584             /// <summary>
585             /// The view, or child of view, whose visibility has changed.
586             /// </summary>
587             public View View
588             {
589                 get
590                 {
591                     return _view;
592                 }
593                 set
594                 {
595                     _view = value;
596                 }
597             }
598
599             /// <summary>
600             /// Whether the view is now visible or not.
601             /// </summary>
602             public bool Visibility
603             {
604                 get
605                 {
606                     return _visibility;
607                 }
608                 set
609                 {
610                     _visibility = value;
611                 }
612             }
613
614             /// <summary>
615             /// Whether the view's visible property has changed or a parent's.
616             /// </summary>
617             public VisibilityChangeType Type
618             {
619                 get
620                 {
621                     return _type;
622                 }
623                 set
624                 {
625                     _type = value;
626                 }
627             }
628         }
629
630         private EventHandler<VisibilityChangedEventArgs> _visibilityChangedEventHandler;
631         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
632         private delegate void VisibilityChangedEventCallbackType(IntPtr data, bool visibility, VisibilityChangeType type);
633         private VisibilityChangedEventCallbackType _visibilityChangedEventCallback;
634
635         /// <summary>
636         /// Event for visibility change which can be used to subscribe/unsubscribe the event handler.<br>
637         /// This signal is emitted when the visible property of this or a parent view is changed.<br>
638         /// </summary>
639         public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
640         {
641             add
642             {
643                 if (_visibilityChangedEventHandler == null)
644                 {
645                     _visibilityChangedEventCallback = OnVisibilityChanged;
646                     VisibilityChangedSignal(this).Connect(_visibilityChangedEventCallback);
647                 }
648
649                 _visibilityChangedEventHandler += value;
650             }
651
652             remove
653             {
654                 _visibilityChangedEventHandler -= value;
655
656                 if (_visibilityChangedEventHandler == null && VisibilityChangedSignal(this).Empty() == false)
657                 {
658                     VisibilityChangedSignal(this).Disconnect(_visibilityChangedEventCallback);
659                 }
660             }
661         }
662
663         // Callback for View visibility change signal
664         private void OnVisibilityChanged(IntPtr data, bool visibility, VisibilityChangeType type)
665         {
666             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
667             if (data != null)
668             {
669                 e.View = View.GetViewFromPtr(data);
670             }
671             e.Visibility = visibility;
672             e.Type = type;
673
674             if (_visibilityChangedEventHandler != null)
675             {
676                 _visibilityChangedEventHandler(this, e);
677             }
678         }
679
680         internal static View GetViewFromPtr(global::System.IntPtr cPtr)
681         {
682             View ret = new View(cPtr, false);
683             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
684             return ret;
685         }
686
687         internal IntPtr GetPtrfromView()
688         {
689             return (IntPtr)swigCPtr;
690         }
691
692         internal class Property
693         {
694             internal static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
695             internal static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
696             internal static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
697             internal static readonly int LEFT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
698             internal static readonly int RIGHT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
699             internal static readonly int UP_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
700             internal static readonly int DOWN_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
701             internal static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();
702             internal static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();
703             internal static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
704             internal static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
705             internal static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
706             internal static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
707             internal static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
708             internal static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
709             internal static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
710             internal static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
711             internal static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
712             internal static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
713             internal static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
714             internal static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
715             internal static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
716             internal static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
717             internal static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
718             internal static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
719             internal static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
720             internal static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
721             internal static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
722             internal static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
723             internal static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
724             internal static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
725             internal static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
726             internal static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
727             internal static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
728             internal static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
729             internal static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
730             internal static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
731             internal static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
732             internal static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
733             internal static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
734             internal static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
735             internal static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
736             internal static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
737             internal static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
738             internal static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
739             internal static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
740             internal static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
741             internal static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
742             internal static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
743             internal static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
744             internal static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
745             internal static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
746             internal static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
747             internal static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
748             internal static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
749             internal static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
750             internal static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
751             internal static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
752             internal static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
753             internal static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
754         }
755
756
757         /// <summary>
758         /// Describes the direction to move the focus towards.
759         /// </summary>
760         public enum FocusDirection
761         {
762             Left,
763             Right,
764             Up,
765             Down,
766             PageUp,
767             PageDown
768         }
769
770         /// <summary>
771         /// Creates a new instance of a View.
772         /// </summary>
773         public View() : this(NDalicPINVOKE.View_New(), true)
774         {
775             PositionUsesAnchorPoint = false;
776             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
777
778         }
779         internal View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true)
780         {
781             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
782         }
783
784         /// <summary>
785         /// Downcasts a handle to View handle.<br>
786         /// If handle points to a View, the downcast produces valid handle.<br>
787         /// If not, the returned handle is left uninitialized.<br>
788         /// </summary>
789         /// <param name="handle">Handle to an object</param>
790         /// <returns>A handle to a View or an uninitialized handle</returns>
791         public new static View DownCast(BaseHandle handle)
792         {
793             View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);
794             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
795             return ret;
796         }
797
798         /// <summary>
799         /// Downcasts a handle to class which inherit View handle.
800         /// </summary>
801         /// <typeparam name="T">Class which inherit View</typeparam>
802         /// <param name="view">View to an object</param>
803         /// <returns>A object which inherit View</returns>
804         public static T DownCast<T>(View view) where T : View
805         {
806             View ret = ViewRegistry.GetViewFromBaseHandle(view);
807             if (ret != null)
808             {
809                 return (T)ret;
810             }
811             return null;
812         }
813
814         private View ConvertIdToView(uint id)
815         {
816             View view = null;
817
818             if (Parent)
819             {
820                 view = Parent.FindChildById(id);
821             }
822
823             if (!view)
824             {
825                 view = Window.Instance.GetRootLayer().FindChildById(id);
826             }
827
828             return view;
829         }
830
831         internal void SetKeyInputFocus()
832         {
833             NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
834             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
835         }
836
837         /// <summary>
838         /// Quries whether the view has focus.
839         /// </summary>
840         /// <returns>true if this view has focus</returns>
841         public bool HasFocus()
842         {
843             bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
844             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
845             return ret;
846         }
847
848         internal void ClearKeyInputFocus()
849         {
850             NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
851             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
852         }
853
854         internal PinchGestureDetector GetPinchGestureDetector()
855         {
856             PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
857             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
858             return ret;
859         }
860
861         internal PanGestureDetector GetPanGestureDetector()
862         {
863             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
864             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
865             return ret;
866         }
867
868         internal TapGestureDetector GetTapGestureDetector()
869         {
870             TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
871             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
872             return ret;
873         }
874
875         internal LongPressGestureDetector GetLongPressGestureDetector()
876         {
877             LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
878             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
879             return ret;
880         }
881
882         /// <summary>
883         /// Sets the name of the style to be applied to the view.
884         /// </summary>
885         /// <param name="styleName">A string matching a style described in a stylesheet</param>
886         public void SetStyleName(string styleName)
887         {
888             NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
889             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
890         }
891
892         /// <summary>
893         /// Retrieves the name of the style to be applied to the view (if any).
894         /// </summary>
895         /// <returns>A string matching a style, or an empty string</returns>
896         public string GetStyleName()
897         {
898             string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
899             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
900             return ret;
901         }
902
903         internal void SetBackgroundColor(Vector4 color)
904         {
905             NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
906             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
907         }
908
909         internal Vector4 GetBackgroundColor()
910         {
911             Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);
912             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
913             return ret;
914         }
915
916         internal void SetBackgroundImage(Image image)
917         {
918             NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));
919             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
920         }
921
922         /// <summary>
923         /// Clears the background.
924         /// </summary>
925         public void ClearBackground()
926         {
927             NDalicPINVOKE.View_ClearBackground(swigCPtr);
928             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
929         }
930
931         internal ControlKeySignal KeyEventSignal()
932         {
933             ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
934             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
935             return ret;
936         }
937
938         internal KeyInputFocusSignal KeyInputFocusGainedSignal()
939         {
940             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
941             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
942             return ret;
943         }
944
945         internal KeyInputFocusSignal KeyInputFocusLostSignal()
946         {
947             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
948             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
949             return ret;
950         }
951
952         internal View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)
953         {
954             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
955         }
956
957         internal enum PropertyRange
958         {
959             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
960             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
961             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
962         }
963
964         /// <summary>
965         /// styleName, type string.
966         /// </summary>
967         public string StyleName
968         {
969             get
970             {
971                 string temp;
972                 GetProperty(View.Property.STYLE_NAME).Get(out temp);
973                 return temp;
974             }
975             set
976             {
977                 SetProperty(View.Property.STYLE_NAME, new Tizen.NUI.PropertyValue(value));
978             }
979         }
980
981         /// <summary>
982         /// mutually exclusive with BACKGROUND_IMAGE & BACKGROUND,  type Vector4.
983         /// </summary>
984         public Color BackgroundColor
985         {
986             get
987             {
988                 Color backgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
989
990                 Tizen.NUI.PropertyMap background = Background;
991                 int visualType = 0;
992                 background.Find(Visual.Property.Type)?.Get(out visualType);
993                 if (visualType == (int)Visual.Type.Color)
994                 {
995                     background.Find(ColorVisualProperty.MixColor)?.Get(backgroundColor);
996                 }
997
998                 return backgroundColor;
999             }
1000             set
1001             {
1002                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1003             }
1004         }
1005
1006         /// <summary>
1007         /// mutually exclusive with BACKGROUND_COLOR & BACKGROUND,  type Map.
1008         /// </summary>
1009         public string BackgroundImage
1010         {
1011             get
1012             {
1013                 string backgroundImage = "";
1014
1015                 Tizen.NUI.PropertyMap background = Background;
1016                 int visualType = 0;
1017                 background.Find(Visual.Property.Type)?.Get(out visualType);
1018                 if (visualType == (int)Visual.Type.Image)
1019                 {
1020                     background.Find(ImageVisualProperty.URL)?.Get(out backgroundImage);
1021                 }
1022
1023                 return backgroundImage;
1024             }
1025             set
1026             {
1027                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1028             }
1029         }
1030
1031         /// <summary>
1032         /// mutually exclusive with BACKGROUND_COLOR & BACKGROUND_IMAGE, type Map or string for URL.
1033         /// </summary>
1034         public Tizen.NUI.PropertyMap Background
1035         {
1036             get
1037             {
1038                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
1039                 GetProperty(View.Property.BACKGROUND).Get(temp);
1040                 return temp;
1041             }
1042             set
1043             {
1044                 SetProperty(View.Property.BACKGROUND, new Tizen.NUI.PropertyValue(value));
1045             }
1046         }
1047
1048         /// <summary>
1049         /// The current state of the view.
1050         /// </summary>
1051         public States State
1052         {
1053             get
1054             {
1055                 int temp = 0;
1056                 if (GetProperty(View.Property.STATE).Get(out temp) == false)
1057                 {
1058 #if DEBUG_ON
1059                     Tizen.Log.Error("NUI", "State get error!");
1060 #endif
1061                 }
1062                 switch (temp)
1063                 {
1064                     case 0:
1065                     {
1066                         return States.Normal;
1067                     }
1068                     case 1:
1069                     {
1070                         return States.Focused;
1071                     }
1072                     case 2:
1073                     {
1074                         return States.Disabled;
1075                     }
1076                     default:
1077                     {
1078                         return States.Normal;
1079                     }
1080                 }
1081             }
1082             set
1083             {
1084                 SetProperty(View.Property.STATE, new Tizen.NUI.PropertyValue((int)value));
1085             }
1086         }
1087
1088         /// <summary>
1089         /// The current sub state of the view.
1090         /// </summary>
1091         public States SubState
1092         {
1093             get
1094             {
1095                 string temp;
1096                 if (GetProperty(View.Property.SUB_STATE).Get(out temp) == false)
1097                 {
1098 #if DEBUG_ON
1099                     Tizen.Log.Error("NUI", "subState get error!");
1100 #endif
1101                 }
1102                 switch (temp)
1103                 {
1104                     case "NORMAL":
1105                         return States.Normal;
1106                     case "FOCUSED":
1107                         return States.Focused;
1108                     case "DISABLED":
1109                         return States.Disabled;
1110                     default:
1111                         return States.Normal;
1112                 }
1113             }
1114             set
1115             {
1116                 string valueToString = "";
1117                 switch (value)
1118                 {
1119                     case States.Normal:
1120                     {
1121                         valueToString = "NORMAL";
1122                         break;
1123                     }
1124                     case States.Focused:
1125                     {
1126                         valueToString = "FOCUSED";
1127                         break;
1128                     }
1129                     case States.Disabled:
1130                     {
1131                         valueToString = "DISABLED";
1132                         break;
1133                     }
1134                     default:
1135                     {
1136                         valueToString = "NORMAL";
1137                         break;
1138                     }
1139                 }
1140                 SetProperty(View.Property.SUB_STATE, new Tizen.NUI.PropertyValue(valueToString));
1141             }
1142         }
1143
1144         /// <summary>
1145         /// Displays a tooltip
1146         /// </summary>
1147         public Tizen.NUI.PropertyMap Tooltip
1148         {
1149             get
1150             {
1151                 Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
1152                 GetProperty(View.Property.TOOLTIP).Get(temp);
1153                 return temp;
1154             }
1155             set
1156             {
1157                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));
1158             }
1159         }
1160
1161         /// <summary>
1162         /// Displays a tooltip as Text
1163         /// </summary>
1164         public string TooltipText
1165         {
1166             set
1167             {
1168                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));
1169             }
1170         }
1171
1172         private int LeftFocusableViewId
1173         {
1174             get
1175             {
1176                 int temp = 0;
1177                 GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(out temp);
1178                 return temp;
1179             }
1180             set
1181             {
1182                 SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1183             }
1184         }
1185
1186         private int RightFocusableViewId
1187         {
1188             get
1189             {
1190                 int temp = 0;
1191                 GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(out temp);
1192                 return temp;
1193             }
1194             set
1195             {
1196                 SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1197             }
1198         }
1199
1200         private int UpFocusableViewId
1201         {
1202             get
1203             {
1204                 int temp = 0;
1205                 GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(out temp);
1206                 return temp;
1207             }
1208             set
1209             {
1210                 SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1211             }
1212         }
1213
1214         private int DownFocusableViewId
1215         {
1216             get
1217             {
1218                 int temp = 0;
1219                 GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(out temp);
1220                 return temp;
1221             }
1222             set
1223             {
1224                 SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
1225             }
1226         }
1227
1228         /// <summary>
1229         /// Child Property of FlexContainer.<br>
1230         /// The proportion of the free space in the container the flex item will receive.<br>
1231         /// If all items in the container set this property, their sizes will be proportional to the specified flex factor.<br>
1232         /// </summary>
1233         public float Flex
1234         {
1235             get
1236             {
1237                 float temp = 0.0f;
1238                 GetProperty(FlexContainer.ChildProperty.FLEX).Get(out temp);
1239                 return temp;
1240             }
1241             set
1242             {
1243                 SetProperty(FlexContainer.ChildProperty.FLEX, new Tizen.NUI.PropertyValue(value));
1244             }
1245         }
1246
1247         /// <summary>
1248         /// Child Property of FlexContainer.<br>
1249         /// The alignment of the flex item along the cross axis, which, if set, overides the default alignment for all items in the container.<br>
1250         /// </summary>
1251         public int AlignSelf
1252         {
1253             get
1254             {
1255                 int temp = 0;
1256                 GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(out temp);
1257                 return temp;
1258             }
1259             set
1260             {
1261                 SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Tizen.NUI.PropertyValue(value));
1262             }
1263         }
1264
1265         /// <summary>
1266         /// Child Property of FlexContainer.<br>
1267         /// The space around the flex item.<br>
1268         /// </summary>
1269         public Vector4 FlexMargin
1270         {
1271             get
1272             {
1273                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1274                 GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
1275                 return temp;
1276             }
1277             set
1278             {
1279                 SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Tizen.NUI.PropertyValue(value));
1280             }
1281         }
1282
1283         /// <summary>
1284         /// The top-left cell this child occupies, if not set, the first available cell is used
1285         /// </summary>
1286         public Vector2 CellIndex
1287         {
1288             get
1289             {
1290                 Vector2 temp = new Vector2(0.0f, 0.0f);
1291                 GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);
1292                 return temp;
1293             }
1294             set
1295             {
1296                 SetProperty(TableView.ChildProperty.CELL_INDEX, new Tizen.NUI.PropertyValue(value));
1297             }
1298         }
1299
1300         /// <summary>
1301         /// The number of rows this child occupies, if not set, default value is 1
1302         /// </summary>
1303         public float RowSpan
1304         {
1305             get
1306             {
1307                 float temp = 0.0f;
1308                 GetProperty(TableView.ChildProperty.ROW_SPAN).Get(out temp);
1309                 return temp;
1310             }
1311             set
1312             {
1313                 SetProperty(TableView.ChildProperty.ROW_SPAN, new Tizen.NUI.PropertyValue(value));
1314             }
1315         }
1316
1317         /// <summary>
1318         /// The number of columns this child occupies, if not set, default value is 1
1319         /// </summary>
1320         public float ColumnSpan
1321         {
1322             get
1323             {
1324                 float temp = 0.0f;
1325                 GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(out temp);
1326                 return temp;
1327             }
1328             set
1329             {
1330                 SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Tizen.NUI.PropertyValue(value));
1331             }
1332         }
1333
1334         /// <summary>
1335         /// The horizontal alignment of this child inside the cells, if not set, default value is 'left'
1336         /// </summary>
1337         public Tizen.NUI.HorizontalAlignmentType CellHorizontalAlignment
1338         {
1339             get
1340             {
1341                 string temp;
1342                 if (GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp) == false)
1343                 {
1344 #if DEBUG_ON
1345                     Tizen.Log.Error("NUI", "CellHorizontalAlignment get error!");
1346 #endif
1347                 }
1348
1349                 switch (temp)
1350                 {
1351                     case "left":
1352                         return Tizen.NUI.HorizontalAlignmentType.Left;
1353                     case "center":
1354                         return Tizen.NUI.HorizontalAlignmentType.Center;
1355                     case "right":
1356                         return Tizen.NUI.HorizontalAlignmentType.Right;
1357                     default:
1358                         return Tizen.NUI.HorizontalAlignmentType.Left;
1359                 }
1360             }
1361             set
1362             {
1363                 string valueToString = "";
1364                 switch (value)
1365                 {
1366                     case Tizen.NUI.HorizontalAlignmentType.Left:
1367                     {
1368                         valueToString = "left";
1369                         break;
1370                     }
1371                     case Tizen.NUI.HorizontalAlignmentType.Center:
1372                     {
1373                         valueToString = "center";
1374                         break;
1375                     }
1376                     case Tizen.NUI.HorizontalAlignmentType.Right:
1377                     {
1378                         valueToString = "right";
1379                         break;
1380                     }
1381                     default:
1382                     {
1383                         valueToString = "left";
1384                         break;
1385                     }
1386                 }
1387                 SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
1388             }
1389         }
1390
1391         /// <summary>
1392         /// The vertical alignment of this child inside the cells, if not set, default value is 'top'
1393         /// </summary>
1394         public Tizen.NUI.VerticalAlignmentType CellVerticalAlignment
1395         {
1396             get
1397             {
1398                 string temp;
1399                 GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
1400                 {
1401 #if DEBUG_ON
1402                     Tizen.Log.Error("NUI", "CellVerticalAlignment get error!");
1403 #endif
1404                 }
1405
1406                 switch (temp)
1407                 {
1408                     case "top":
1409                         return Tizen.NUI.VerticalAlignmentType.Top;
1410                     case "center":
1411                         return Tizen.NUI.VerticalAlignmentType.Center;
1412                     case "bottom":
1413                         return Tizen.NUI.VerticalAlignmentType.Bottom;
1414                     default:
1415                         return Tizen.NUI.VerticalAlignmentType.Top;
1416                 }
1417             }
1418             set
1419             {
1420                 string valueToString = "";
1421                 switch (value)
1422                 {
1423                     case Tizen.NUI.VerticalAlignmentType.Top:
1424                     {
1425                         valueToString = "top";
1426                         break;
1427                     }
1428                     case Tizen.NUI.VerticalAlignmentType.Center:
1429                     {
1430                         valueToString = "center";
1431                         break;
1432                     }
1433                     case Tizen.NUI.VerticalAlignmentType.Bottom:
1434                     {
1435                         valueToString = "bottom";
1436                         break;
1437                     }
1438                     default:
1439                     {
1440                         valueToString = "top";
1441                         break;
1442                     }
1443                 }
1444                 SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
1445             }
1446         }
1447
1448         /// <summary>
1449         /// The left focusable view.<br>
1450         /// This will return NULL if not set.<br>
1451         /// This will also return NULL if the specified left focusable view is not on Window.<br>
1452         /// </summary>
1453         public View LeftFocusableView
1454         {
1455             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1456             get
1457             {
1458                 if (LeftFocusableViewId >= 0)
1459                 {
1460                     return ConvertIdToView((uint)LeftFocusableViewId);
1461                 }
1462                 return null;
1463             }
1464             set
1465             {
1466                 LeftFocusableViewId = (int)value.GetId();
1467             }
1468         }
1469
1470         /// <summary>
1471         /// The right focusable view.<br>
1472         /// This will return NULL if not set.<br>
1473         /// This will also return NULL if the specified right focusable view is not on Window.<br>
1474         /// </summary>
1475         public View RightFocusableView
1476         {
1477             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1478             get
1479             {
1480                 if (RightFocusableViewId >= 0)
1481                 {
1482                     return ConvertIdToView((uint)RightFocusableViewId);
1483                 }
1484                 return null;
1485             }
1486             set
1487             {
1488                 RightFocusableViewId = (int)value.GetId();
1489             }
1490         }
1491
1492         /// <summary>
1493         /// The up focusable view.<br>
1494         /// This will return NULL if not set.<br>
1495         /// This will also return NULL if the specified up focusable view is not on Window.<br>
1496         /// </summary>
1497         public View UpFocusableView
1498         {
1499             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1500             get
1501             {
1502                 if (UpFocusableViewId >= 0)
1503                 {
1504                     return ConvertIdToView((uint)UpFocusableViewId);
1505                 }
1506                 return null;
1507             }
1508             set
1509             {
1510                 UpFocusableViewId = (int)value.GetId();
1511             }
1512         }
1513
1514         /// <summary>
1515         /// The down focusable view.<br>
1516         /// This will return NULL if not set.<br>
1517         /// This will also return NULL if the specified down focusable view is not on Window.<br>
1518         /// </summary>
1519         public View DownFocusableView
1520         {
1521             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1522             get
1523             {
1524                 if (DownFocusableViewId >= 0)
1525                 {
1526                     return ConvertIdToView((uint)DownFocusableViewId);
1527                 }
1528                 return null;
1529             }
1530             set
1531             {
1532                 DownFocusableViewId = (int)value.GetId();
1533             }
1534         }
1535
1536         /// <summary>
1537         /// whether the view should be focusable by keyboard navigation.
1538         /// </summary>
1539         public bool Focusable
1540         {
1541             set
1542             {
1543                 SetKeyboardFocusable(value);
1544             }
1545             get
1546             {
1547                 return IsKeyboardFocusable();
1548             }
1549         }
1550
1551         /// <summary>
1552         /// Enumeration for describing the states of view.
1553         /// </summary>
1554         public enum States
1555         {
1556             /// <summary>
1557             /// Normal state
1558             /// </summary>
1559             Normal,
1560             /// <summary>
1561             /// Focused state
1562             /// </summary>
1563             Focused,
1564             /// <summary>
1565             /// Disabled state
1566             /// </summary>
1567             Disabled
1568         }
1569
1570         /// <summary>
1571         ///  Retrieves the position of the View.<br>
1572         ///  The coordinates are relative to the View's parent.<br>
1573         /// </summary>
1574         public Position CurrentPosition
1575         {
1576             get
1577             {
1578                 return GetCurrentPosition();
1579             }
1580         }
1581
1582         /// <summary>
1583         /// Sets the size of an view for width and height.<br>
1584         /// Geometry can be scaled to fit within this area.<br>
1585         /// This does not interfere with the views scale factor.<br>
1586         /// The views default depth is the minimum of width & height.<br>
1587         /// </summary>
1588         public Size2D Size2D
1589         {
1590             get
1591             {
1592                 Size temp = new Size(0.0f, 0.0f, 0.0f);
1593                 GetProperty(View.Property.SIZE).Get(temp);
1594                 Size2D size = new Size2D((int)temp.Width, (int)temp.Height);
1595                 return size;
1596             }
1597             set
1598             {
1599                 SetProperty(View.Property.SIZE, new Tizen.NUI.PropertyValue(new Size(value)));
1600             }
1601         }
1602
1603         /// <summary>
1604         ///  Retrieves the size of the View.<br>
1605         ///  The coordinates are relative to the View's parent.<br>
1606         /// </summary>
1607         public Size2D CurrentSize
1608         {
1609             get
1610             {
1611                 return GetCurrentSize();
1612             }
1613         }
1614
1615         /// <summary>
1616         /// Retrieves the view's parent.<br>
1617         /// </summary>
1618         public View Parent
1619         {
1620             get
1621             {
1622                 return GetParent();
1623             }
1624         }
1625
1626         public bool Visibility
1627         {
1628             get
1629             {
1630                 return IsVisible();
1631             }
1632         }
1633
1634         /// <summary>
1635         /// Retrieves and sets the view's opacity.<br>
1636         /// </summary>
1637         public float Opacity
1638         {
1639             get
1640             {
1641                 float temp = 0.0f;
1642                 GetProperty(View.Property.OPACITY).Get(out temp);
1643                 return temp;
1644             }
1645             set
1646             {
1647                 SetProperty(View.Property.OPACITY, new Tizen.NUI.PropertyValue(value));
1648             }
1649         }
1650
1651         /// <summary>
1652         /// Sets the position of the View for X and Y.<br>
1653         /// By default, sets the position vector between the parent origin and anchor point(default).<br>
1654         /// If Position inheritance if disabled, sets the world position.<br>
1655         /// </summary>
1656         public Position2D Position2D
1657         {
1658             get
1659             {
1660                 Position temp = new Position(0.0f, 0.0f, 0.0f);
1661                 GetProperty(View.Property.POSITION).Get(temp);
1662                 return new Position2D(temp);
1663             }
1664             set
1665             {
1666                 SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(new Position(value)));
1667             }
1668         }
1669
1670         /// <summary>
1671         /// Retrieves screen postion of view's.<br>
1672         /// </summary>
1673         public Vector2 ScreenPosition
1674         {
1675             get
1676             {
1677                 Vector2 temp = new Vector2(0.0f, 0.0f);
1678                 GetProperty(View.Property.SCREEN_POSITION).Get(temp);
1679                 return temp;
1680             }
1681         }
1682
1683         /// <summary>
1684         /// Determines whether the anchor point should be used to determine the position of the view.
1685         /// This is true by default.
1686         /// </summary>
1687         /// <remarks>If false, then the top-left of the view is used for the position.
1688         /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the view's position.
1689         /// </remarks>
1690         public bool PositionUsesAnchorPoint
1691         {
1692             get
1693             {
1694                 bool temp = false;
1695                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
1696                 return temp;
1697             }
1698             set
1699             {
1700                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
1701             }
1702         }
1703
1704         internal bool FocusState
1705         {
1706             get
1707             {
1708                 return IsKeyboardFocusable();
1709             }
1710             set
1711             {
1712                 SetKeyboardFocusable(value);
1713             }
1714         }
1715
1716         /// <summary>
1717         /// Queries whether the view is connected to the Stage.<br>
1718         /// When an view is connected, it will be directly or indirectly parented to the root View.<br>
1719         /// </summary>
1720         public bool IsOnWindow
1721         {
1722             get
1723             {
1724                 return OnWindow();
1725             }
1726         }
1727
1728         /// <summary>
1729         /// Gets depth in the hierarchy for the view.
1730         /// </summary>
1731         public int HierarchyDepth
1732         {
1733             get
1734             {
1735                 return GetHierarchyDepth();
1736             }
1737         }
1738
1739         /// <summary>
1740         /// Sets the sibling order of the view so depth position can be defined within the same parent.
1741         /// </summary>
1742         /// <remarks>
1743         /// Note The initial value is 0.
1744         /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove and LowerBelow will override the sibling order.
1745         /// The values set by this Property will likely change.
1746         /// </remarks>
1747         public int SiblingOrder
1748         {
1749             get
1750             {
1751                 int temp = 0;
1752                 GetProperty(View.Property.SIBLING_ORDER).Get(out temp);
1753                 return temp;
1754             }
1755             set
1756             {
1757                 SetProperty(View.Property.SIBLING_ORDER, new Tizen.NUI.PropertyValue(value));
1758             }
1759         }
1760
1761         /// <summary>
1762         /// Gets the natural size of the view.<br>
1763         /// </summary>
1764         /// <remarks>
1765         /// Readonly.
1766         /// </remarks>
1767         internal Vector3 NaturalSize
1768         {
1769             get
1770             {
1771                 Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
1772                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1773                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1774                 return ret;
1775             }
1776         }
1777
1778         /// <summary>
1779         /// Shows the View.
1780         /// </summary>
1781         /// <remarks>
1782         /// This is an asynchronous method.
1783         /// </remarks>
1784         public void Show()
1785         {
1786             SetVisible(true);
1787         }
1788
1789         /// <summary>
1790         /// Hides the View.
1791         /// </summary>
1792         /// <remarks>
1793         /// This is an asynchronous method.
1794         /// If an view is hidden, then the view and its children will not be rendered.
1795         /// This is regardless of the individual visibility of the children i.e.an view will only be rendered if all of its parents are shown.
1796         /// </remarks>
1797         public void Hide()
1798         {
1799             SetVisible(false);
1800         }
1801
1802         internal void Raise()
1803         {
1804             NDalicPINVOKE.Raise(swigCPtr);
1805             if (NDalicPINVOKE.SWIGPendingException.Pending)
1806                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1807         }
1808
1809         internal void Lower()
1810         {
1811             NDalicPINVOKE.Lower(swigCPtr);
1812             if (NDalicPINVOKE.SWIGPendingException.Pending)
1813                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1814         }
1815
1816         /// <summary>
1817         /// Raise view above all other views.
1818         /// </summary>
1819         /// <remarks>
1820         /// Sibling order of views within the parent will be updated automatically.
1821         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
1822         /// </remarks>
1823         public void RaiseToTop()
1824         {
1825             NDalicPINVOKE.RaiseToTop(swigCPtr);
1826             if (NDalicPINVOKE.SWIGPendingException.Pending)
1827                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1828         }
1829
1830         /// <summary>
1831         /// Lower view to the bottom of all views.
1832         /// </summary>
1833         /// <remarks>
1834         /// Sibling order of views within the parent will be updated automatically.
1835         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
1836         /// </remarks>
1837         public void LowerToBottom()
1838         {
1839             NDalicPINVOKE.LowerToBottom(swigCPtr);
1840             if (NDalicPINVOKE.SWIGPendingException.Pending)
1841                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1842         }
1843
1844         /// <summary>
1845         /// Raise the view to above the target view.
1846         /// </summary>
1847         /// <remarks>Sibling order of views within the parent will be updated automatically.
1848         /// Views on the level above the target view will still be shown above this view.
1849         /// Raising this view above views with the same sibling order as each other will raise this view above them.
1850         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
1851         /// </remarks>
1852         /// <param name="target">Will be raised above this view</param>
1853         internal void RaiseAbove(View target)
1854         {
1855             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
1856             if (NDalicPINVOKE.SWIGPendingException.Pending)
1857                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1858         }
1859
1860         /// <summary>
1861         /// Lower the view to below the target view.
1862         /// </summary>
1863         /// <remarks>Sibling order of views within the parent will be updated automatically.
1864         /// Lowering this view below views with the same sibling order as each other will lower this view above them.
1865         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
1866         /// </remarks>
1867         /// <param name="target">Will be lowered below this view</param>
1868         internal void LowerBelow(View target)
1869         {
1870             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
1871             if (NDalicPINVOKE.SWIGPendingException.Pending)
1872                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1873         }
1874
1875         internal string GetName()
1876         {
1877             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
1878             if (NDalicPINVOKE.SWIGPendingException.Pending)
1879                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1880             return ret;
1881         }
1882
1883         internal void SetName(string name)
1884         {
1885             NDalicPINVOKE.Actor_SetName(swigCPtr, name);
1886             if (NDalicPINVOKE.SWIGPendingException.Pending)
1887                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1888         }
1889
1890         internal uint GetId()
1891         {
1892             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
1893             if (NDalicPINVOKE.SWIGPendingException.Pending)
1894                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1895             return ret;
1896         }
1897
1898         internal bool IsRoot()
1899         {
1900             bool ret = NDalicPINVOKE.Actor_IsRoot(swigCPtr);
1901             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1902             return ret;
1903         }
1904
1905         internal bool OnWindow()
1906         {
1907             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
1908             if (NDalicPINVOKE.SWIGPendingException.Pending)
1909                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1910             return ret;
1911         }
1912
1913         internal Layer GetLayer()
1914         {
1915             Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
1916             if (NDalicPINVOKE.SWIGPendingException.Pending)
1917                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1918             return ret;
1919         }
1920
1921         /// <summary>
1922         /// Adds a child view to this View.
1923         /// </summary>
1924         /// <pre>This View(the parent) has been initialized. The child view has been initialized. The child view is not the same as the parent view.</pre>
1925         /// <post>The child will be referenced by its parent. This means that the child will be kept alive, even if the handle passed into this method is reset or destroyed.</post>
1926         /// <remarks>If the child already has a parent, it will be removed from old parent and reparented to this view. This may change child's position, color, scale etc as it now inherits them from this view.</remarks>
1927         /// <param name="child">The child</param>
1928         public void Add(View child)
1929         {
1930             NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
1931             if (NDalicPINVOKE.SWIGPendingException.Pending)
1932                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1933         }
1934
1935         /// <summary>
1936         /// Removes a child View from this View. If the view was not a child of this view, this is a no-op.
1937         /// </summary>
1938         /// <pre>This View(the parent) has been initialized. The child view is not the same as the parent view.</pre>
1939         /// <param name="child">The child</param>
1940         public void Remove(View child)
1941         {
1942             NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
1943             if (NDalicPINVOKE.SWIGPendingException.Pending)
1944                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1945         }
1946
1947         internal void Unparent()
1948         {
1949             NDalicPINVOKE.Actor_Unparent(swigCPtr);
1950             if (NDalicPINVOKE.SWIGPendingException.Pending)
1951                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1952         }
1953
1954         /// <summary>
1955         /// Retrieves the number of children held by the view.
1956         /// </summary>
1957         /// <pre>The View has been initialized.</pre>
1958         /// <returns>The number of children</returns>
1959         internal uint GetChildCount()
1960         {
1961             uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
1962             if (NDalicPINVOKE.SWIGPendingException.Pending)
1963                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1964             return ret;
1965         }
1966
1967         /// <summary>
1968         /// Retrieves child view by index.
1969         /// </summary>
1970         /// <pre>The View has been initialized.</pre>
1971         /// <param name="index">The index of the child to retrieve</param>
1972         /// <returns>The view for the given index or empty handle if children not initialized</returns>
1973         public View GetChildAt(uint index)
1974         {
1975             IntPtr cPtr = NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index);
1976             cPtr = NDalicPINVOKE.View_SWIGUpcast(cPtr);
1977             cPtr = NDalicPINVOKE.Handle_SWIGUpcast(cPtr);
1978
1979             BaseHandle ret = new BaseHandle(cPtr, false);
1980
1981             View temp = ViewRegistry.GetViewFromBaseHandle(ret);
1982
1983             if (NDalicPINVOKE.SWIGPendingException.Pending)
1984                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1985
1986             return temp ?? null;
1987         }
1988
1989         /// <summary>
1990         /// Search through this view's hierarchy for an view with the given name.
1991         /// The view itself is also considered in the search.
1992         /// </summary>
1993         /// <pre>The View has been initialized.</pre>
1994         /// <param name="viewName">The name of the view to find</param>
1995         /// <returns>A handle to the view if found, or an empty handle if not</returns>
1996         public View FindChildByName(string viewName)
1997         {
1998             View ret = new View(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, viewName), true);
1999             if (NDalicPINVOKE.SWIGPendingException.Pending)
2000                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2001             return ret;
2002         }
2003
2004         internal View FindChildById(uint id)
2005         {
2006             View ret = new View(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
2007             if (NDalicPINVOKE.SWIGPendingException.Pending)
2008                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2009             return ret;
2010         }
2011
2012         internal View GetParent()
2013         {
2014             View ret = new View(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
2015             if (NDalicPINVOKE.SWIGPendingException.Pending)
2016                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2017             return ret;
2018         }
2019
2020         internal void SetParentOrigin(Vector3 origin)
2021         {
2022             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
2023             if (NDalicPINVOKE.SWIGPendingException.Pending)
2024                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2025         }
2026
2027         internal Vector3 GetCurrentParentOrigin()
2028         {
2029             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
2030             if (NDalicPINVOKE.SWIGPendingException.Pending)
2031                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2032             return ret;
2033         }
2034
2035         internal void SetAnchorPoint(Vector3 anchorPoint)
2036         {
2037             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
2038             if (NDalicPINVOKE.SWIGPendingException.Pending)
2039                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2040         }
2041
2042         internal Vector3 GetCurrentAnchorPoint()
2043         {
2044             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
2045             if (NDalicPINVOKE.SWIGPendingException.Pending)
2046                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2047             return ret;
2048         }
2049
2050         internal void SetSize(float width, float height)
2051         {
2052             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
2053             if (NDalicPINVOKE.SWIGPendingException.Pending)
2054                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2055         }
2056
2057         internal void SetSize(float width, float height, float depth)
2058         {
2059             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
2060             if (NDalicPINVOKE.SWIGPendingException.Pending)
2061                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2062         }
2063
2064         internal void SetSize(Vector2 size)
2065         {
2066             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
2067             if (NDalicPINVOKE.SWIGPendingException.Pending)
2068                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2069         }
2070
2071         internal void SetSize(Vector3 size)
2072         {
2073             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
2074             if (NDalicPINVOKE.SWIGPendingException.Pending)
2075                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2076         }
2077
2078         internal Vector3 GetTargetSize()
2079         {
2080             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
2081             if (NDalicPINVOKE.SWIGPendingException.Pending)
2082                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2083             return ret;
2084         }
2085
2086         internal Size2D GetCurrentSize()
2087         {
2088             Size ret = new Size(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
2089             if (NDalicPINVOKE.SWIGPendingException.Pending)
2090                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2091             Size2D size = new Size2D((int)ret.Width, (int)ret.Height);
2092             return size;
2093         }
2094
2095         internal Vector3 GetNaturalSize()
2096         {
2097             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2098             if (NDalicPINVOKE.SWIGPendingException.Pending)
2099                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2100             return ret;
2101         }
2102
2103         internal void SetPosition(float x, float y)
2104         {
2105             NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
2106             if (NDalicPINVOKE.SWIGPendingException.Pending)
2107                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2108         }
2109
2110         internal void SetPosition(float x, float y, float z)
2111         {
2112             NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
2113             if (NDalicPINVOKE.SWIGPendingException.Pending)
2114                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2115         }
2116
2117         internal void SetPosition(Vector3 position)
2118         {
2119             NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
2120             if (NDalicPINVOKE.SWIGPendingException.Pending)
2121                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2122         }
2123
2124         internal void SetX(float x)
2125         {
2126             NDalicPINVOKE.Actor_SetX(swigCPtr, x);
2127             if (NDalicPINVOKE.SWIGPendingException.Pending)
2128                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2129         }
2130
2131         internal void SetY(float y)
2132         {
2133             NDalicPINVOKE.Actor_SetY(swigCPtr, y);
2134             if (NDalicPINVOKE.SWIGPendingException.Pending)
2135                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2136         }
2137
2138         internal void SetZ(float z)
2139         {
2140             NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
2141             if (NDalicPINVOKE.SWIGPendingException.Pending)
2142                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2143         }
2144
2145         internal void TranslateBy(Vector3 distance)
2146         {
2147             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
2148             if (NDalicPINVOKE.SWIGPendingException.Pending)
2149                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2150         }
2151
2152         internal Position GetCurrentPosition()
2153         {
2154             Position ret = new Position(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
2155             if (NDalicPINVOKE.SWIGPendingException.Pending)
2156                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2157             return ret;
2158         }
2159
2160         internal Vector3 GetCurrentWorldPosition()
2161         {
2162             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
2163             if (NDalicPINVOKE.SWIGPendingException.Pending)
2164                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2165             return ret;
2166         }
2167
2168         internal void SetInheritPosition(bool inherit)
2169         {
2170             NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
2171             if (NDalicPINVOKE.SWIGPendingException.Pending)
2172                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2173         }
2174
2175         internal bool IsPositionInherited()
2176         {
2177             bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
2178             if (NDalicPINVOKE.SWIGPendingException.Pending)
2179                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2180             return ret;
2181         }
2182
2183         internal void SetOrientation(Degree angle, Vector3 axis)
2184         {
2185             NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2186             if (NDalicPINVOKE.SWIGPendingException.Pending)
2187                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2188         }
2189
2190         internal void SetOrientation(Radian angle, Vector3 axis)
2191         {
2192             NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2193             if (NDalicPINVOKE.SWIGPendingException.Pending)
2194                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2195         }
2196
2197         internal void SetOrientation(Rotation orientation)
2198         {
2199             NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
2200             if (NDalicPINVOKE.SWIGPendingException.Pending)
2201                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2202         }
2203
2204         internal void RotateBy(Degree angle, Vector3 axis)
2205         {
2206             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2207             if (NDalicPINVOKE.SWIGPendingException.Pending)
2208                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2209         }
2210
2211         internal void RotateBy(Radian angle, Vector3 axis)
2212         {
2213             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2214             if (NDalicPINVOKE.SWIGPendingException.Pending)
2215                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2216         }
2217
2218         internal void RotateBy(Rotation relativeRotation)
2219         {
2220             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
2221             if (NDalicPINVOKE.SWIGPendingException.Pending)
2222                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2223         }
2224
2225         internal Rotation GetCurrentOrientation()
2226         {
2227             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
2228             if (NDalicPINVOKE.SWIGPendingException.Pending)
2229                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2230             return ret;
2231         }
2232
2233         internal void SetInheritOrientation(bool inherit)
2234         {
2235             NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
2236             if (NDalicPINVOKE.SWIGPendingException.Pending)
2237                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2238         }
2239
2240         internal bool IsOrientationInherited()
2241         {
2242             bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
2243             if (NDalicPINVOKE.SWIGPendingException.Pending)
2244                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2245             return ret;
2246         }
2247
2248         internal Rotation GetCurrentWorldOrientation()
2249         {
2250             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
2251             if (NDalicPINVOKE.SWIGPendingException.Pending)
2252                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2253             return ret;
2254         }
2255
2256         internal void SetScale(float scale)
2257         {
2258             NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
2259             if (NDalicPINVOKE.SWIGPendingException.Pending)
2260                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2261         }
2262
2263         internal void SetScale(float scaleX, float scaleY, float scaleZ)
2264         {
2265             NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
2266             if (NDalicPINVOKE.SWIGPendingException.Pending)
2267                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2268         }
2269
2270         internal void SetScale(Vector3 scale)
2271         {
2272             NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
2273             if (NDalicPINVOKE.SWIGPendingException.Pending)
2274                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2275         }
2276
2277         internal void ScaleBy(Vector3 relativeScale)
2278         {
2279             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
2280             if (NDalicPINVOKE.SWIGPendingException.Pending)
2281                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2282         }
2283
2284         internal Vector3 GetCurrentScale()
2285         {
2286             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
2287             if (NDalicPINVOKE.SWIGPendingException.Pending)
2288                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2289             return ret;
2290         }
2291
2292         internal Vector3 GetCurrentWorldScale()
2293         {
2294             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
2295             if (NDalicPINVOKE.SWIGPendingException.Pending)
2296                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2297             return ret;
2298         }
2299
2300         internal void SetInheritScale(bool inherit)
2301         {
2302             NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
2303             if (NDalicPINVOKE.SWIGPendingException.Pending)
2304                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2305         }
2306
2307         internal bool IsScaleInherited()
2308         {
2309             bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
2310             if (NDalicPINVOKE.SWIGPendingException.Pending)
2311                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2312             return ret;
2313         }
2314
2315         internal Matrix GetCurrentWorldMatrix()
2316         {
2317             Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
2318             if (NDalicPINVOKE.SWIGPendingException.Pending)
2319                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2320             return ret;
2321         }
2322
2323         internal void SetVisible(bool visible)
2324         {
2325             NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
2326             if (NDalicPINVOKE.SWIGPendingException.Pending)
2327                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2328         }
2329
2330         internal bool IsVisible()
2331         {
2332             bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
2333             if (NDalicPINVOKE.SWIGPendingException.Pending)
2334                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2335             return ret;
2336         }
2337
2338         internal void SetOpacity(float opacity)
2339         {
2340             NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
2341             if (NDalicPINVOKE.SWIGPendingException.Pending)
2342                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2343         }
2344
2345         internal float GetCurrentOpacity()
2346         {
2347             float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
2348             if (NDalicPINVOKE.SWIGPendingException.Pending)
2349                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2350             return ret;
2351         }
2352
2353         internal void SetColor(Vector4 color)
2354         {
2355             NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
2356             if (NDalicPINVOKE.SWIGPendingException.Pending)
2357                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2358         }
2359
2360         internal Vector4 GetCurrentColor()
2361         {
2362             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
2363             if (NDalicPINVOKE.SWIGPendingException.Pending)
2364                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2365             return ret;
2366         }
2367
2368         internal void SetColorMode(ColorMode colorMode)
2369         {
2370             NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
2371             if (NDalicPINVOKE.SWIGPendingException.Pending)
2372                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2373         }
2374
2375         internal ColorMode GetColorMode()
2376         {
2377             ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
2378             if (NDalicPINVOKE.SWIGPendingException.Pending)
2379                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2380             return ret;
2381         }
2382
2383         internal Vector4 GetCurrentWorldColor()
2384         {
2385             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
2386             if (NDalicPINVOKE.SWIGPendingException.Pending)
2387                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2388             return ret;
2389         }
2390
2391         internal void SetDrawMode(DrawModeType drawMode)
2392         {
2393             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
2394             if (NDalicPINVOKE.SWIGPendingException.Pending)
2395                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2396         }
2397
2398         internal DrawModeType GetDrawMode()
2399         {
2400             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
2401             if (NDalicPINVOKE.SWIGPendingException.Pending)
2402                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2403             return ret;
2404         }
2405
2406         /// <summary>
2407         /// Converts screen coordinates into the view's coordinate system using the default camera.
2408         /// </summary>
2409         /// <pre>The View has been initialized.</pre>
2410         /// <remarks>The view coordinates are relative to the top-left(0.0, 0.0, 0.5)</remarks>
2411         /// <param name="localX">On return, the X-coordinate relative to the view</param>
2412         /// <param name="localY">On return, the Y-coordinate relative to the view</param>
2413         /// <param name="screenX">The screen X-coordinate</param>
2414         /// <param name="screenY">The screen Y-coordinate</param>
2415         /// <returns>True if the conversion succeeded</returns>
2416         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
2417         {
2418             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
2419             if (NDalicPINVOKE.SWIGPendingException.Pending)
2420                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2421             return ret;
2422         }
2423
2424         internal void SetKeyboardFocusable(bool focusable)
2425         {
2426             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
2427             if (NDalicPINVOKE.SWIGPendingException.Pending)
2428                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2429         }
2430
2431         internal bool IsKeyboardFocusable()
2432         {
2433             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
2434             if (NDalicPINVOKE.SWIGPendingException.Pending)
2435                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2436             return ret;
2437         }
2438
2439         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
2440         {
2441             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
2442             if (NDalicPINVOKE.SWIGPendingException.Pending)
2443                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2444         }
2445
2446         internal ResizePolicyType GetResizePolicy(DimensionType dimension)
2447         {
2448             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
2449             if (NDalicPINVOKE.SWIGPendingException.Pending)
2450                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2451             return ret;
2452         }
2453
2454         /// <summary>
2455         /// Sets the relative to parent size factor of the view.<br>
2456         /// This factor is only used when ResizePolicy is set to either:
2457         /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<br>
2458         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicy.<br>
2459         /// </summary>
2460         /// <pre>The View has been initialized.</pre>
2461         /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis</param>
2462         public void SetSizeModeFactor(Vector3 factor)
2463         {
2464             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
2465             if (NDalicPINVOKE.SWIGPendingException.Pending)
2466                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2467         }
2468
2469         internal Vector3 GetSizeModeFactor()
2470         {
2471             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
2472             if (NDalicPINVOKE.SWIGPendingException.Pending)
2473                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2474             return ret;
2475         }
2476
2477         /// <summary>
2478         /// Calculates the height of the view given a width.<br>
2479         /// The natural size is used for default calculation. <br>
2480         /// size 0 is treated as aspect ratio 1:1.<br>
2481         /// </summary>
2482         /// <param name="width">Width to use</param>
2483         /// <returns>The height based on the width</returns>
2484         public float GetHeightForWidth(float width)
2485         {
2486             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
2487             if (NDalicPINVOKE.SWIGPendingException.Pending)
2488                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2489             return ret;
2490         }
2491
2492         /// <summary>
2493         /// Calculates the width of the view given a height.<br>
2494         /// The natural size is used for default calculation.<br>
2495         /// size 0 is treated as aspect ratio 1:1.<br>
2496         /// </summary>
2497         /// <param name="height">Height to use</param>
2498         /// <returns>The width based on the height</returns>
2499         public float GetWidthForHeight(float height)
2500         {
2501             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
2502             if (NDalicPINVOKE.SWIGPendingException.Pending)
2503                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2504             return ret;
2505         }
2506
2507         public float GetRelayoutSize(DimensionType dimension)
2508         {
2509             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
2510             if (NDalicPINVOKE.SWIGPendingException.Pending)
2511                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2512             return ret;
2513         }
2514
2515         public void SetPadding(PaddingType padding)
2516         {
2517             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
2518             if (NDalicPINVOKE.SWIGPendingException.Pending)
2519                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2520         }
2521
2522         public void GetPadding(PaddingType paddingOut)
2523         {
2524             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
2525             if (NDalicPINVOKE.SWIGPendingException.Pending)
2526                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2527         }
2528
2529         internal void SetMinimumSize(Vector2 size)
2530         {
2531             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
2532             if (NDalicPINVOKE.SWIGPendingException.Pending)
2533                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2534         }
2535
2536         internal Vector2 GetMinimumSize()
2537         {
2538             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
2539             if (NDalicPINVOKE.SWIGPendingException.Pending)
2540                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2541             return ret;
2542         }
2543
2544         internal void SetMaximumSize(Vector2 size)
2545         {
2546             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
2547             if (NDalicPINVOKE.SWIGPendingException.Pending)
2548                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2549         }
2550
2551         internal Vector2 GetMaximumSize()
2552         {
2553             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
2554             if (NDalicPINVOKE.SWIGPendingException.Pending)
2555                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2556             return ret;
2557         }
2558
2559         internal int GetHierarchyDepth()
2560         {
2561             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
2562             if (NDalicPINVOKE.SWIGPendingException.Pending)
2563                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2564             return ret;
2565         }
2566
2567         internal uint AddRenderer(Renderer renderer)
2568         {
2569             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
2570             if (NDalicPINVOKE.SWIGPendingException.Pending)
2571                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2572             return ret;
2573         }
2574
2575         internal uint GetRendererCount()
2576         {
2577             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
2578             if (NDalicPINVOKE.SWIGPendingException.Pending)
2579                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2580             return ret;
2581         }
2582
2583         internal Renderer GetRendererAt(uint index)
2584         {
2585             Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
2586             if (NDalicPINVOKE.SWIGPendingException.Pending)
2587                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2588             return ret;
2589         }
2590
2591         internal void RemoveRenderer(Renderer renderer)
2592         {
2593             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
2594             if (NDalicPINVOKE.SWIGPendingException.Pending)
2595                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2596         }
2597
2598         internal void RemoveRenderer(uint index)
2599         {
2600             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
2601             if (NDalicPINVOKE.SWIGPendingException.Pending)
2602                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2603         }
2604
2605         internal TouchDataSignal TouchSignal()
2606         {
2607             TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
2608             if (NDalicPINVOKE.SWIGPendingException.Pending)
2609                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2610             return ret;
2611         }
2612
2613         internal HoverSignal HoveredSignal()
2614         {
2615             HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
2616             if (NDalicPINVOKE.SWIGPendingException.Pending)
2617                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2618             return ret;
2619         }
2620
2621         internal WheelSignal WheelEventSignal()
2622         {
2623             WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
2624             if (NDalicPINVOKE.SWIGPendingException.Pending)
2625                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2626             return ret;
2627         }
2628
2629         internal ViewSignal OnWindowSignal()
2630         {
2631             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
2632             if (NDalicPINVOKE.SWIGPendingException.Pending)
2633                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2634             return ret;
2635         }
2636
2637         internal ViewSignal OffWindowSignal()
2638         {
2639             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
2640             if (NDalicPINVOKE.SWIGPendingException.Pending)
2641                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2642             return ret;
2643         }
2644
2645         internal ViewSignal OnRelayoutSignal()
2646         {
2647             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
2648             if (NDalicPINVOKE.SWIGPendingException.Pending)
2649                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2650             return ret;
2651         }
2652
2653         internal ViewVisibilityChangedSignal VisibilityChangedSignal(View view) {
2654             ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(NDalicPINVOKE.VisibilityChangedSignal(View.getCPtr(view)), false);
2655             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2656             return ret;
2657         }
2658
2659         /// <summary>
2660         /// Gets/Sets the origin of an view, within its parent's area.<br>
2661         /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the parent, and(1.0, 1.0, 0.5) is the bottom-right corner.<br>
2662         /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).<br>
2663         /// An view's position is the distance between this origin, and the view's anchor-point.<br>
2664         /// </summary>
2665         /// <pre>The View has been initialized.</pre>
2666         public Position ParentOrigin
2667         {
2668             get
2669             {
2670                 Position temp = new Position(0.0f, 0.0f, 0.0f);
2671                 GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
2672                 return temp;
2673             }
2674             set
2675             {
2676                 SetProperty(View.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue(value));
2677             }
2678         }
2679
2680         internal float ParentOriginX
2681         {
2682             get
2683             {
2684                 float temp = 0.0f;
2685                 GetProperty(View.Property.PARENT_ORIGIN_X).Get(out temp);
2686                 return temp;
2687             }
2688             set
2689             {
2690                 SetProperty(View.Property.PARENT_ORIGIN_X, new Tizen.NUI.PropertyValue(value));
2691             }
2692         }
2693
2694         internal float ParentOriginY
2695         {
2696             get
2697             {
2698                 float temp = 0.0f;
2699                 GetProperty(View.Property.PARENT_ORIGIN_Y).Get(out temp);
2700                 return temp;
2701             }
2702             set
2703             {
2704                 SetProperty(View.Property.PARENT_ORIGIN_Y, new Tizen.NUI.PropertyValue(value));
2705             }
2706         }
2707
2708         internal float ParentOriginZ
2709         {
2710             get
2711             {
2712                 float temp = 0.0f;
2713                 GetProperty(View.Property.PARENT_ORIGIN_Z).Get(out temp);
2714                 return temp;
2715             }
2716             set
2717             {
2718                 SetProperty(View.Property.PARENT_ORIGIN_Z, new Tizen.NUI.PropertyValue(value));
2719             }
2720         }
2721
2722         /// <summary>
2723         /// Gets/Sets the anchor-point of an view.<br>
2724         /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the view, and (1.0, 1.0, 0.5) is the bottom-right corner.<br>
2725         /// The default anchor point is AnchorPoint.Center (0.5, 0.5, 0.5).<br>
2726         /// An view position is the distance between its parent-origin and this anchor-point.<br>
2727         /// An view's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.<br>
2728         /// <pre>The View has been initialized.</pre>
2729         /// </summary>
2730         public Position PivotPoint
2731         {
2732             get
2733             {
2734                 Position temp = new Position(0.0f, 0.0f, 0.0f);
2735                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
2736                 return temp;
2737             }
2738             set
2739             {
2740                 SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
2741             }
2742         }
2743
2744         internal float PivotPointX
2745         {
2746             get
2747             {
2748                 float temp = 0.0f;
2749                 GetProperty(View.Property.ANCHOR_POINT_X).Get(out temp);
2750                 return temp;
2751             }
2752             set
2753             {
2754                 SetProperty(View.Property.ANCHOR_POINT_X, new Tizen.NUI.PropertyValue(value));
2755             }
2756         }
2757
2758         internal float PivotPointY
2759         {
2760             get
2761             {
2762                 float temp = 0.0f;
2763                 GetProperty(View.Property.ANCHOR_POINT_Y).Get(out temp);
2764                 return temp;
2765             }
2766             set
2767             {
2768                 SetProperty(View.Property.ANCHOR_POINT_Y, new Tizen.NUI.PropertyValue(value));
2769             }
2770         }
2771
2772         internal float PivotPointZ
2773         {
2774             get
2775             {
2776                 float temp = 0.0f;
2777                 GetProperty(View.Property.ANCHOR_POINT_Z).Get(out temp);
2778                 return temp;
2779             }
2780             set
2781             {
2782                 SetProperty(View.Property.ANCHOR_POINT_Z, new Tizen.NUI.PropertyValue(value));
2783             }
2784         }
2785
2786         /// <summary>
2787         /// Gets/Sets the size width of an view.
2788         /// </summary>
2789         public float SizeWidth
2790         {
2791             get
2792             {
2793                 float temp = 0.0f;
2794                 GetProperty(View.Property.SIZE_WIDTH).Get(out temp);
2795                 return temp;
2796             }
2797             set
2798             {
2799                 SetProperty(View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
2800             }
2801         }
2802
2803         /// <summary>
2804         /// Gets/Sets the size height of an view.
2805         /// </summary>
2806         public float SizeHeight
2807         {
2808             get
2809             {
2810                 float temp = 0.0f;
2811                 GetProperty(View.Property.SIZE_HEIGHT).Get(out temp);
2812                 return temp;
2813             }
2814             set
2815             {
2816                 SetProperty(View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
2817             }
2818         }
2819
2820         /// <summary>
2821         /// Gets/Sets the position of the View.<br>
2822         /// By default, sets the position vector between the parent origin and anchor point(default).<br>
2823         /// If Position inheritance if disabled, sets the world position.<br>
2824         /// </summary>
2825         public Position Position
2826         {
2827             get
2828             {
2829                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2830                 GetProperty(View.Property.POSITION).Get(temp);
2831                 return temp;
2832             }
2833             set
2834             {
2835                 SetProperty(View.Property.POSITION, new Tizen.NUI.PropertyValue(value));
2836             }
2837         }
2838
2839         /// <summary>
2840         /// Gets/Sets the position x of the View.
2841         /// </summary>
2842         public float PositionX
2843         {
2844             get
2845             {
2846                 float temp = 0.0f;
2847                 GetProperty(View.Property.POSITION_X).Get(out temp);
2848                 return temp;
2849             }
2850             set
2851             {
2852                 SetProperty(View.Property.POSITION_X, new Tizen.NUI.PropertyValue(value));
2853             }
2854         }
2855
2856         /// <summary>
2857         /// Gets/Sets the position y of the View.
2858         /// </summary>
2859         public float PositionY
2860         {
2861             get
2862             {
2863                 float temp = 0.0f;
2864                 GetProperty(View.Property.POSITION_Y).Get(out temp);
2865                 return temp;
2866             }
2867             set
2868             {
2869                 SetProperty(View.Property.POSITION_Y, new Tizen.NUI.PropertyValue(value));
2870             }
2871         }
2872
2873         /// <summary>
2874         /// Gets/Sets the position z of the View.
2875         /// </summary>
2876         public float PositionZ
2877         {
2878             get
2879             {
2880                 float temp = 0.0f;
2881                 GetProperty(View.Property.POSITION_Z).Get(out temp);
2882                 return temp;
2883             }
2884             set
2885             {
2886                 SetProperty(View.Property.POSITION_Z, new Tizen.NUI.PropertyValue(value));
2887             }
2888         }
2889
2890         /// <summary>
2891         /// Gets/Sets the world position of the View.
2892         /// </summary>
2893         public Vector3 WorldPosition
2894         {
2895             get
2896             {
2897                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2898                 GetProperty(View.Property.WORLD_POSITION).Get(temp);
2899                 return temp;
2900             }
2901         }
2902
2903         internal float WorldPositionX
2904         {
2905             get
2906             {
2907                 float temp = 0.0f;
2908                 GetProperty(View.Property.WORLD_POSITION_X).Get(out temp);
2909                 return temp;
2910             }
2911         }
2912
2913         internal float WorldPositionY
2914         {
2915             get
2916             {
2917                 float temp = 0.0f;
2918                 GetProperty(View.Property.WORLD_POSITION_Y).Get(out temp);
2919                 return temp;
2920             }
2921         }
2922
2923         internal float WorldPositionZ
2924         {
2925             get
2926             {
2927                 float temp = 0.0f;
2928                 GetProperty(View.Property.WORLD_POSITION_Z).Get(out temp);
2929                 return temp;
2930             }
2931         }
2932
2933         /// <summary>
2934         /// Gets/Sets the orientation of the View.<br>
2935         /// An view's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.<br>
2936         /// </summary>
2937         /// <remarks>This is an asynchronous method.</remarks>
2938         public Rotation Orientation
2939         {
2940             get
2941             {
2942                 Rotation temp = new Rotation();
2943                 GetProperty(View.Property.ORIENTATION).Get(temp);
2944                 return temp;
2945             }
2946             set
2947             {
2948                 SetProperty(View.Property.ORIENTATION, new Tizen.NUI.PropertyValue(value));
2949             }
2950         }
2951
2952         /// <summary>
2953         /// Gets/Sets the world orientation of the View.<br>
2954         /// </summary>
2955         public Rotation WorldOrientation
2956         {
2957             get
2958             {
2959                 Rotation temp = new Rotation();
2960                 GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
2961                 return temp;
2962             }
2963         }
2964
2965         /// <summary>
2966         /// Gets/Sets the scale factor applied to an view.<br>
2967         /// </summary>
2968         public Vector3 Scale
2969         {
2970             get
2971             {
2972                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2973                 GetProperty(View.Property.SCALE).Get(temp);
2974                 return temp;
2975             }
2976             set
2977             {
2978                 SetProperty(View.Property.SCALE, new Tizen.NUI.PropertyValue(value));
2979             }
2980         }
2981
2982         /// <summary>
2983         /// Gets/Sets the scale x factor applied to an view.
2984         /// </summary>
2985         public float ScaleX
2986         {
2987             get
2988             {
2989                 float temp = 0.0f;
2990                 GetProperty(View.Property.SCALE_X).Get(out temp);
2991                 return temp;
2992             }
2993             set
2994             {
2995                 SetProperty(View.Property.SCALE_X, new Tizen.NUI.PropertyValue(value));
2996             }
2997         }
2998
2999         /// <summary>
3000         /// Gets/Sets the scale y factor applied to an view.
3001         /// </summary>
3002         public float ScaleY
3003         {
3004             get
3005             {
3006                 float temp = 0.0f;
3007                 GetProperty(View.Property.SCALE_Y).Get(out temp);
3008                 return temp;
3009             }
3010             set
3011             {
3012                 SetProperty(View.Property.SCALE_Y, new Tizen.NUI.PropertyValue(value));
3013             }
3014         }
3015
3016         /// <summary>
3017         /// Gets/Sets the scale z factor applied to an view.
3018         /// </summary>
3019         public float ScaleZ
3020         {
3021             get
3022             {
3023                 float temp = 0.0f;
3024                 GetProperty(View.Property.SCALE_Z).Get(out temp);
3025                 return temp;
3026             }
3027             set
3028             {
3029                 SetProperty(View.Property.SCALE_Z, new Tizen.NUI.PropertyValue(value));
3030             }
3031         }
3032
3033         /// <summary>
3034         /// Gets the world scale of View.
3035         /// </summary>
3036         public Vector3 WorldScale
3037         {
3038             get
3039             {
3040                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3041                 GetProperty(View.Property.WORLD_SCALE).Get(temp);
3042                 return temp;
3043             }
3044         }
3045
3046         /// <summary>
3047         /// Retrieves the visibility flag of an view.
3048         /// </summary>
3049         /// <remarks>
3050         /// If an view is not visible, then the view and its children will not be rendered.
3051         /// This is regardless of the individual visibility values of the children i.e.an view will only be rendered if all of its parents have visibility set to true.
3052         /// </remarks>
3053         public bool Visible
3054         {
3055             get
3056             {
3057                 bool temp = false;
3058                 GetProperty(View.Property.VISIBLE).Get(out temp);
3059                 return temp;
3060             }/* only get is required : removed
3061             set
3062             {
3063                 SetProperty(View.Property.VISIBLE, new Tizen.NUI.PropertyValue(value));
3064             }*/
3065         }
3066
3067         /// <summary>
3068         /// Gets the view's world color.
3069         /// </summary>
3070         public Vector4 WorldColor
3071         {
3072             get
3073             {
3074                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3075                 GetProperty(View.Property.WORLD_COLOR).Get(temp);
3076                 return temp;
3077             }
3078         }
3079
3080         internal Matrix WorldMatrix
3081         {
3082             get
3083             {
3084                 Matrix temp = new Matrix();
3085                 GetProperty(View.Property.WORLD_MATRIX).Get(temp);
3086                 return temp;
3087             }
3088         }
3089
3090         /// <summary>
3091         /// Gets/Sets the View's name.
3092         /// </summary>
3093         public string Name
3094         {
3095             get
3096             {
3097                 string temp;
3098                 GetProperty(View.Property.NAME).Get(out temp);
3099                 return temp;
3100             }
3101             set
3102             {
3103                 SetProperty(View.Property.NAME, new Tizen.NUI.PropertyValue(value));
3104             }
3105         }
3106
3107         /// <summary>
3108         /// Get the number of children held by the view.
3109         /// </summary>
3110         public uint ChildCount
3111         {
3112             get
3113             {
3114                 return GetChildCount();
3115             }
3116         }
3117
3118         /// <summary>
3119         /// Gets the View's ID.
3120         /// Readonly
3121         /// </summary>
3122         public uint ID
3123         {
3124             get
3125             {
3126                 return GetId();
3127             }
3128         }
3129
3130         /// <summary>
3131         /// Gets/Sets the status of whether an view should emit touch or hover signals.
3132         /// </summary>
3133         public bool Sensitive
3134         {
3135             get
3136             {
3137                 bool temp = false;
3138                 GetProperty(View.Property.SENSITIVE).Get(out temp);
3139                 return temp;
3140             }
3141             set
3142             {
3143                 SetProperty(View.Property.SENSITIVE, new Tizen.NUI.PropertyValue(value));
3144             }
3145         }
3146
3147         /// <summary>
3148         /// Gets/Sets the status of whether the view should receive a notification when touch or hover motion events leave the boundary of the view.
3149         /// </summary>
3150         public bool LeaveRequired
3151         {
3152             get
3153             {
3154                 bool temp = false;
3155                 GetProperty(View.Property.LEAVE_REQUIRED).Get(out temp);
3156                 return temp;
3157             }
3158             set
3159             {
3160                 SetProperty(View.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue(value));
3161             }
3162         }
3163
3164         /// <summary>
3165         /// Gets/Sets the status of whether a child view inherits it's parent's orientation.
3166         /// </summary>
3167         public bool InheritOrientation
3168         {
3169             get
3170             {
3171                 bool temp = false;
3172                 GetProperty(View.Property.INHERIT_ORIENTATION).Get(out temp);
3173                 return temp;
3174             }
3175             set
3176             {
3177                 SetProperty(View.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue(value));
3178             }
3179         }
3180
3181         /// <summary>
3182         /// Gets/Sets the status of whether a child view inherits it's parent's scale.
3183         /// </summary>
3184         public bool InheritScale
3185         {
3186             get
3187             {
3188                 bool temp = false;
3189                 GetProperty(View.Property.INHERIT_SCALE).Get(out temp);
3190                 return temp;
3191             }
3192             set
3193             {
3194                 SetProperty(View.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue(value));
3195             }
3196         }
3197
3198         /// <summary>
3199         /// Gets/Sets the status of how the view and its children should be drawn.<br>
3200         /// Not all views are renderable, but DrawMode can be inherited from any view.<br>
3201         /// If an object is in a 3D layer, it will be depth-tested against other objects in the world i.e. it may be obscured if other objects are in front.<br>
3202         /// If DrawMode.Overlay2D is used, the view and its children will be drawn as a 2D overlay.<br>
3203         /// Overlay views are drawn in a separate pass, after all non-overlay views within the Layer.<br>
3204         /// For overlay views, the drawing order is with respect to tree levels of Views, and depth-testing will not be used.<br>
3205         /// </summary>
3206         public DrawModeType DrawMode
3207         {
3208             get
3209             {
3210                 string temp;
3211                 if (GetProperty(View.Property.DRAW_MODE).Get(out temp) == false)
3212                 {
3213 #if DEBUG_ON
3214                     Tizen.Log.Error("NUI", "DrawMode get error!");
3215 #endif
3216                 }
3217                 switch (temp)
3218                 {
3219                     case "NORMAL":
3220                     return DrawModeType.Normal;
3221                     case "OVERLAY_2D":
3222                     return DrawModeType.Overlay2D;
3223                     case "STENCIL":
3224                     return DrawModeType.Stencil;
3225                     default:
3226                     return DrawModeType.Normal;
3227                 }
3228             }
3229             set
3230             {
3231                 SetProperty(View.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)value));
3232             }
3233         }
3234
3235         /// <summary>
3236         /// Gets/Sets the relative to parent size factor of the view.<br>
3237         /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.<br>
3238         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicyType.<br>
3239         /// </summary>
3240         public Vector3 SizeModeFactor
3241         {
3242             get
3243             {
3244                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
3245                 GetProperty(View.Property.SIZE_MODE_FACTOR).Get(temp);
3246                 return temp;
3247             }
3248             set
3249             {
3250                 SetProperty(View.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue(value));
3251             }
3252         }
3253
3254         /// <summary>
3255         /// Gets/Sets the width resize policy to be used.
3256         /// </summary>
3257         public ResizePolicyType WidthResizePolicy
3258         {
3259             get
3260             {
3261                 string temp;
3262                 if (GetProperty(View.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
3263                 {
3264 #if DEBUG_ON
3265                     Tizen.Log.Error("NUI", "WidthResizePolicy get error!");
3266 #endif
3267                 }
3268                 switch (temp)
3269                 {
3270                     case "FIXED":
3271                         return ResizePolicyType.Fixed;
3272                     case "USE_NATURAL_SIZE":
3273                         return ResizePolicyType.UseNaturalSize;
3274                     case "FILL_TO_PARENT":
3275                         return ResizePolicyType.FillToParent;
3276                     case "SIZE_RELATIVE_TO_PARENT":
3277                         return ResizePolicyType.SizeRelativeToParent;
3278                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3279                         return ResizePolicyType.SizeFixedOffsetFromParent;
3280                     case "FIT_TO_CHILDREN":
3281                         return ResizePolicyType.FitToChildren;
3282                     case "DIMENSION_DEPENDENCY":
3283                         return ResizePolicyType.DimensionDependency;
3284                     case "USE_ASSIGNED_SIZE":
3285                         return ResizePolicyType.UseAssignedSize;
3286                     default:
3287                         return ResizePolicyType.Fixed;
3288                 }
3289             }
3290             set
3291             {
3292                 SetProperty(View.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
3293             }
3294         }
3295
3296         /// <summary>
3297         /// Gets/Sets the height resize policy to be used.
3298         /// </summary>
3299         public ResizePolicyType HeightResizePolicy
3300         {
3301             get
3302             {
3303                 string temp;
3304                 if (GetProperty(View.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
3305                 {
3306 #if DEBUG_ON
3307                     Tizen.Log.Error("NUI", "HeightResizePolicy get error!");
3308 #endif
3309                 }
3310                 switch (temp)
3311                 {
3312                     case "FIXED":
3313                         return ResizePolicyType.Fixed;
3314                     case "USE_NATURAL_SIZE":
3315                         return ResizePolicyType.UseNaturalSize;
3316                     case "FILL_TO_PARENT":
3317                         return ResizePolicyType.FillToParent;
3318                     case "SIZE_RELATIVE_TO_PARENT":
3319                         return ResizePolicyType.SizeRelativeToParent;
3320                     case "SIZE_FIXED_OFFSET_FROM_PARENT":
3321                         return ResizePolicyType.SizeFixedOffsetFromParent;
3322                     case "FIT_TO_CHILDREN":
3323                         return ResizePolicyType.FitToChildren;
3324                     case "DIMENSION_DEPENDENCY":
3325                         return ResizePolicyType.DimensionDependency;
3326                     case "USE_ASSIGNED_SIZE":
3327                         return ResizePolicyType.UseAssignedSize;
3328                     default:
3329                         return ResizePolicyType.Fixed;
3330                 }
3331             }
3332             set
3333             {
3334                 SetProperty(View.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)value));
3335             }
3336         }
3337
3338         /// <summary>
3339         /// Gets/Sets the policy to use when setting size with size negotiation.<br>
3340         /// Defaults to  SizeScalePolicyType.UseSizeSet.<br>
3341         /// </summary>
3342         public SizeScalePolicyType SizeScalePolicy
3343         {
3344             get
3345             {
3346                 string temp;
3347                 if (GetProperty(View.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
3348                 {
3349 #if DEBUG_ON
3350                     Tizen.Log.Error("NUI", "SizeScalePolicy get error!");
3351 #endif
3352                 }
3353                 switch (temp)
3354                 {
3355                     case "USE_SIZE_SET":
3356                         return SizeScalePolicyType.UseSizeSet;
3357                     case "FIT_WITH_ASPECT_RATIO":
3358                         return SizeScalePolicyType.FitWithAspectRatio;
3359                     case "FILL_WITH_ASPECT_RATIO":
3360                         return SizeScalePolicyType.FillWithAspectRatio;
3361                     default:
3362                         return SizeScalePolicyType.UseSizeSet;
3363                 }
3364             }
3365             set
3366             {
3367                 string valueToString = "";
3368                 switch (value)
3369                 {
3370                     case SizeScalePolicyType.UseSizeSet:
3371                         {
3372                             valueToString = "USE_SIZE_SET";
3373                             break;
3374                         }
3375                     case SizeScalePolicyType.FitWithAspectRatio:
3376                         {
3377                             valueToString = "FIT_WITH_ASPECT_RATIO";
3378                             break;
3379                         }
3380                     case SizeScalePolicyType.FillWithAspectRatio:
3381                         {
3382                             valueToString = "FILL_WITH_ASPECT_RATIO";
3383                             break;
3384                         }
3385                     default:
3386                         {
3387                             valueToString = "USE_SIZE_SET";
3388                             break;
3389                         }
3390                 }
3391                 SetProperty(View.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
3392             }
3393         }
3394
3395         /// <summary>
3396         ///  Gets/Sets the status of whether the width size is dependent on height size.
3397         /// </summary>
3398         public bool WidthForHeight
3399         {
3400             get
3401             {
3402                 bool temp = false;
3403                 GetProperty(View.Property.WIDTH_FOR_HEIGHT).Get(out temp);
3404                 return temp;
3405             }
3406             set
3407             {
3408                 SetProperty(View.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue(value));
3409             }
3410         }
3411
3412         /// <summary>
3413         ///  Gets/Sets the status of whether the height size is dependent on width size.
3414         /// </summary>
3415         public bool HeightForWidth
3416         {
3417             get
3418             {
3419                 bool temp = false;
3420                 GetProperty(View.Property.HEIGHT_FOR_WIDTH).Get(out temp);
3421                 return temp;
3422             }
3423             set
3424             {
3425                 SetProperty(View.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue(value));
3426             }
3427         }
3428
3429         /// <summary>
3430         /// Gets/Sets the padding for use in layout.
3431         /// </summary>
3432         public Vector4 Padding
3433         {
3434             get
3435             {
3436                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
3437                 GetProperty(View.Property.PADDING).Get(temp);
3438                 return temp;
3439             }
3440             set
3441             {
3442                 SetProperty(View.Property.PADDING, new Tizen.NUI.PropertyValue(value));
3443             }
3444         }
3445
3446         /// <summary>
3447         /// Gets/Sets the minimum size an view can be assigned in size negotiation.
3448         /// </summary>
3449         public Size2D MinimumSize
3450         {
3451             get
3452             {
3453                 Size2D temp = new Size2D(0, 0);
3454                 GetProperty(View.Property.MINIMUM_SIZE).Get(temp);
3455                 return temp;
3456             }
3457             set
3458             {
3459                 SetProperty(View.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
3460             }
3461         }
3462
3463         /// <summary>
3464         /// Gets/Sets the maximum size an view can be assigned in size negotiation.
3465         /// </summary>
3466         public Size2D MaximumSize
3467         {
3468             get
3469             {
3470                 Size2D temp = new Size2D(0, 0);
3471                 GetProperty(View.Property.MAXIMUM_SIZE).Get(temp);
3472                 return temp;
3473             }
3474             set
3475             {
3476                 SetProperty(View.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(value));
3477             }
3478         }
3479
3480         /// <summary>
3481         /// Gets/Sets whether a child view inherits it's parent's position.<br>
3482         /// Default is to inherit.<br>
3483         /// Switching this off means that using Position sets the view's world position, i.e. translates from the world origin(0,0,0) to the anchor point of the view.<br>
3484         /// </summary>
3485         public bool InheritPosition
3486         {
3487             get
3488             {
3489                 bool temp = false;
3490                 GetProperty(View.Property.INHERIT_POSITION).Get(out temp);
3491                 return temp;
3492             }
3493             set
3494             {
3495                 SetProperty(View.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue(value));
3496             }
3497         }
3498
3499         /// <summary>
3500         /// Gets/Sets clipping behavior(mode) of it's children.
3501         /// </summary>
3502         public ClippingModeType ClippingMode
3503         {
3504             get
3505             {
3506                 string temp;
3507                 if (GetProperty(View.Property.CLIPPING_MODE).Get(out temp) == false)
3508                 {
3509 #if DEBUG_ON
3510                     Tizen.Log.Error("NUI", "ClippingMode get error!");
3511 #endif
3512                 }
3513                 switch (temp)
3514                 {
3515                     case "DISABLED":
3516                     return ClippingModeType.Disabled;
3517                     case "CLIP_CHILDREN":
3518                     return ClippingModeType.ClipChildren;
3519                     default:
3520                     return ClippingModeType.Disabled;
3521                 }
3522             }
3523             set
3524             {
3525                 SetProperty(View.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)value));
3526             }
3527         }
3528     }
3529
3530 }