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