Combined Stage and Window class, and removed Stage class
[platform/core/uifw/dali-toolkit.git] / plugins / dali-sharp / sharp / internal / 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 Dali
18 {
19     using System;
20     using System.Runtime.InteropServices;
21
22     public class View : Animatable
23     {
24         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
25
26         internal View(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.View_SWIGUpcast(cPtr), cMemoryOwn)
27         {
28             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
29
30             // Register this instance of view in the view registry.
31             ViewRegistry.RegisterView(this);
32
33             // By default, we do not want the position to use the anchor point
34             this.PositionUsesAnchorPoint = false;
35         }
36
37         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj)
38         {
39             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
40         }
41
42         ~View()
43         {
44             DisposeQueue.Instance.Add(this);
45
46             // Unregister this instance of view from the view registry.
47             ViewRegistry.UnregisterView(this);
48         }
49
50         public virtual void Dispose()
51         {
52             if (!Window.IsInstalled())
53             {
54                 DisposeQueue.Instance.Add(this);
55                 return;
56             }
57
58             lock (this)
59             {
60                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
61                 {
62                     if (swigCMemOwn)
63                     {
64                         swigCMemOwn = false;
65                         NDalicPINVOKE.delete_View(swigCPtr);
66                     }
67                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
68                 }
69                 global::System.GC.SuppressFinalize(this);
70             }
71         }
72
73         /**
74          * @brief Event arguments that passed via KeyInputFocusGained signal
75          *
76          */
77         public class KeyInputFocusGainedEventArgs : EventArgs
78         {
79             private View _view;
80
81             /**
82              * @brief View - is the view that gets Key Input Focus
83              *
84              */
85             public View View
86             {
87                 get
88                 {
89                     return _view;
90                 }
91                 set
92                 {
93                     _view = value;
94                 }
95             }
96         }
97
98         /**
99          * @brief Event arguments that passed via KeyInputFocusLost signal
100          *
101          */
102         public class KeyInputFocusLostEventArgs : EventArgs
103         {
104             private View _view;
105
106             /**
107              * @brief View - is the view that loses Key Input Focus
108              *
109              */
110             public View View
111             {
112                 get
113                 {
114                     return _view;
115                 }
116                 set
117                 {
118                     _view = value;
119                 }
120             }
121         }
122
123         /**
124          * @brief Event arguments that passed via Key signal
125          *
126          */
127         public class KeyEventArgs : EventArgs
128         {
129             private View _view;
130             private Key _key;
131
132             /**
133              * @brief View - is the view that recieves the key.
134              *
135              */
136             public View View
137             {
138                 get
139                 {
140                     return _view;
141                 }
142                 set
143                 {
144                     _view = value;
145                 }
146             }
147
148             /**
149              * @brief Key - is the key sent to the View.
150              *
151              */
152             public Key Key
153             {
154                 get
155                 {
156                     return _key;
157                 }
158                 set
159                 {
160                     _key = value;
161                 }
162             }
163         }
164
165         /**
166          * @brief Event arguments that passed via OnRelayout signal
167          *
168          */
169         public class OnRelayoutEventArgs : EventArgs
170         {
171             private View _view;
172
173             /**
174              * @brief View - is the view that is being resized upon relayout
175              *
176              */
177             public View View
178             {
179                 get
180                 {
181                     return _view;
182                 }
183                 set
184                 {
185                     _view = value;
186                 }
187             }
188         }
189
190
191         /**
192          * @brief Event arguments that passed via Touch signal
193          *
194          */
195         public class TouchEventArgs : EventArgs
196         {
197             private View _view;
198             private Touch _touch;
199
200             /**
201              * @brief View - is the view that is being touched
202              *
203              */
204             public View View
205             {
206                 get
207                 {
208                     return _view;
209                 }
210                 set
211                 {
212                     _view = value;
213                 }
214             }
215
216             /**
217              * @brief Touch - contains the information of touch points
218              *
219              */
220             public Touch Touch
221             {
222                 get
223                 {
224                     return _touch;
225                 }
226                 set
227                 {
228                     _touch = value;
229                 }
230             }
231         }
232
233         /**
234          * @brief Event arguments that passed via Hover signal
235          *
236          */
237         public class HoverEventArgs : EventArgs
238         {
239             private View _view;
240             private Hover _hover;
241
242             /**
243              * @brief View - is the view that is being hovered
244              *
245              */
246             public View View
247             {
248                 get
249                 {
250                     return _view;
251                 }
252                 set
253                 {
254                     _view = value;
255                 }
256             }
257
258             /**
259              * @brief Hover - contains touch points that represent the points
260              * that are currently being hovered or the points where a hover has stopped
261              *
262              */
263             public Hover Hover
264             {
265                 get
266                 {
267                     return _hover;
268                 }
269                 set
270                 {
271                     _hover = value;
272                 }
273             }
274         }
275
276         /**
277          * @brief Event arguments that passed via Wheel signal
278          *
279          */
280         public class WheelEventArgs : EventArgs
281         {
282             private View _view;
283             private Wheel _wheel;
284
285             /**
286              * @brief View - is the view that is being wheeled
287              *
288              */
289             public View View
290             {
291                 get
292                 {
293                     return _view;
294                 }
295                 set
296                 {
297                     _view = value;
298                 }
299             }
300
301             /**
302              * @brief Wheel - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
303              *
304              */
305             public Wheel Wheel
306             {
307                 get
308                 {
309                     return _wheel;
310                 }
311                 set
312                 {
313                     _wheel = value;
314                 }
315             }
316         }
317
318         /**
319          * @brief Event arguments that passed via OnWindow signal
320          *
321          */
322         public class OnWindowEventArgs : EventArgs
323         {
324             private View _view;
325
326             /**
327              * @brief View - is the view that is being connected to the window
328              *
329              */
330             public View View
331             {
332                 get
333                 {
334                     return _view;
335                 }
336                 set
337                 {
338                     _view = value;
339                 }
340             }
341         }
342
343         /**
344          * @brief Event arguments that passed via OffWindow signal
345          *
346          */
347         public class OffWindowEventArgs : EventArgs
348         {
349             private View _view;
350
351             /**
352              * @brief View - is the view that is being disconnected from the window
353              *
354              */
355             public View View
356             {
357                 get
358                 {
359                     return _view;
360                 }
361                 set
362                 {
363                     _view = value;
364                 }
365             }
366         }
367
368         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
369         private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
370
371         private DaliEventHandler<object,KeyInputFocusGainedEventArgs> _KeyInputFocusGainedEventHandler;
372         private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
373
374         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
375         private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
376
377         private DaliEventHandler<object,KeyInputFocusLostEventArgs> _KeyInputFocusLostEventHandler;
378         private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
379
380         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
381         private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr key);
382
383         private DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> _KeyHandler;
384         private KeyCallbackDelegate _KeyCallbackDelegate;
385
386         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
387         private delegate void OnRelayoutEventCallbackDelegate(IntPtr control);
388
389         private DaliEventHandler<object,OnRelayoutEventArgs> _viewOnRelayoutEventHandler;
390         private OnRelayoutEventCallbackDelegate _viewOnRelayoutEventCallbackDelegate;
391
392         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
393         private delegate bool TouchCallbackDelegate(IntPtr view, IntPtr touch);
394
395         private DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _viewTouchHandler;
396         private TouchCallbackDelegate _viewTouchCallbackDelegate;
397
398         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
399         private delegate bool HoverCallbackDelegate(IntPtr view, IntPtr hover);
400
401         private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _viewHoverHandler;
402         private HoverCallbackDelegate _viewHoverCallbackDelegate;
403
404         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
405         private delegate bool WheelCallbackDelegate(IntPtr view, IntPtr wheel);
406
407         private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _viewWheelHandler;
408         private WheelCallbackDelegate _viewWheelCallbackDelegate;
409
410         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
411         private delegate void OnWindowEventCallbackDelegate(IntPtr control);
412
413         private DaliEventHandler<object,OnWindowEventArgs> _viewOnWindowEventHandler;
414         private OnWindowEventCallbackDelegate _viewOnWindowEventCallbackDelegate;
415
416         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
417         private delegate void OffWindowEventCallbackDelegate(IntPtr control);
418
419         private DaliEventHandler<object,OffWindowEventArgs> _viewOffWindowEventHandler;
420         private OffWindowEventCallbackDelegate _viewOffWindowEventCallbackDelegate;
421
422         /**
423          * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
424          * (in the type of KeyInputFocusGainedEventHandler-DaliEventHandler<object,KeyInputFocusGainedEventArgs>)
425          * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
426          */
427         public event DaliEventHandler<object,KeyInputFocusGainedEventArgs> KeyInputFocusGained
428         {
429             add
430             {
431                 lock (this)
432                 {
433                     // Restricted to only one listener
434                     if (_KeyInputFocusGainedEventHandler == null)
435                     {
436                         _KeyInputFocusGainedEventHandler += value;
437                         Console.WriteLine("View Key EVENT Locked....");
438                         _KeyInputFocusGainedCallbackDelegate = new KeyInputFocusGainedCallbackDelegate(OnKeyInputFocusGained);
439                         this.KeyInputFocusGainedSignal().Connect(_KeyInputFocusGainedCallbackDelegate);
440                     }
441                 }
442             }
443
444             remove
445             {
446                 lock (this)
447                 {
448                     if (_KeyInputFocusGainedEventHandler != null)
449                     {
450                         this.KeyInputFocusGainedSignal().Disconnect(_KeyInputFocusGainedCallbackDelegate);
451                     }
452
453                     _KeyInputFocusGainedEventHandler -= value;
454                 }
455             }
456         }
457
458         private void OnKeyInputFocusGained(IntPtr view)
459         {
460             KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
461             Console.WriteLine("View Key ....");
462             // Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
463             e.View = Dali.View.GetViewFromPtr(view);
464
465             if (_KeyInputFocusGainedEventHandler != null)
466             {
467                 //here we send all data to user event handlers
468                 _KeyInputFocusGainedEventHandler(this, e);
469             }
470
471         }
472
473         /**
474          * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
475          * (in the type of KeyInputFocusLostEventHandler-DaliEventHandler<object,KeyInputFocusLostEventArgs>)
476          * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
477          */
478         public event DaliEventHandler<object,KeyInputFocusLostEventArgs> KeyInputFocusLost
479         {
480             add
481             {
482                 lock (this)
483                 {
484                     // Restricted to only one listener
485                     if (_KeyInputFocusLostEventHandler == null)
486                     {
487                         _KeyInputFocusLostEventHandler += value;
488
489                         _KeyInputFocusLostCallbackDelegate = new KeyInputFocusLostCallbackDelegate(OnKeyInputFocusLost);
490                         this.KeyInputFocusLostSignal().Connect(_KeyInputFocusLostCallbackDelegate);
491                     }
492                 }
493             }
494
495             remove
496             {
497                 lock (this)
498                 {
499                     if (_KeyInputFocusLostEventHandler != null)
500                     {
501                         this.KeyInputFocusLostSignal().Disconnect(_KeyInputFocusLostCallbackDelegate);
502                     }
503
504                     _KeyInputFocusLostEventHandler -= value;
505                 }
506             }
507         }
508
509         private void OnKeyInputFocusLost(IntPtr view)
510         {
511             KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
512
513             // Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
514             e.View = Dali.View.GetViewFromPtr(view);
515
516             if (_KeyInputFocusLostEventHandler != null)
517             {
518                 //here we send all data to user event handlers
519                 _KeyInputFocusLostEventHandler(this, e);
520             }
521         }
522
523         /**
524          * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
525          * (in the type of KeyHandler-DaliEventHandlerWithReturnType<object,KeyEventArgs,bool>)
526          * provided by the user. KeyPressed signal is emitted when key event is received.
527          */
528         public event DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> KeyPressed
529         {
530             add
531             {
532                 lock (this)
533                 {
534                     // Restricted to only one listener
535                     if (_KeyHandler == null)
536                     {
537                         _KeyHandler += value;
538
539                         _KeyCallbackDelegate = new KeyCallbackDelegate(OnKey);
540                         this.KeyEventSignal().Connect(_KeyCallbackDelegate);
541                     }
542                 }
543             }
544
545             remove
546             {
547                 lock (this)
548                 {
549                     if (_KeyHandler != null)
550                     {
551                         this.KeyEventSignal().Disconnect(_KeyCallbackDelegate);
552                     }
553
554                     _KeyHandler -= value;
555                 }
556             }
557         }
558
559         private bool OnKey(IntPtr view, IntPtr key)
560         {
561             KeyEventArgs e = new KeyEventArgs();
562
563             // Populate all members of "e" (KeyEventArgs) with real data
564             e.View = Dali.View.GetViewFromPtr(view);
565             e.Key = Dali.Key.GetKeyFromPtr(key);
566
567             if (_KeyHandler != null)
568             {
569                 //here we send all data to user event handlers
570                 return _KeyHandler(this, e);
571             }
572             return false;
573
574         }
575
576         /**
577          * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
578          * (in the type of OnRelayoutEventHandler) provided by the user.
579          * OnRelayout signal is emitted after the size has been set on the view during relayout.
580          */
581         public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
582         {
583             add
584             {
585                 lock (this)
586                 {
587                     // Restricted to only one listener
588                     if (_viewOnRelayoutEventHandler == null)
589                     {
590                         _viewOnRelayoutEventHandler += value;
591                         Console.WriteLine("View OnRelayoutEventArgs Locked....");
592                         _viewOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
593                         this.OnRelayoutSignal().Connect(_viewOnRelayoutEventCallbackDelegate);
594                     }
595                 }
596             }
597
598             remove
599             {
600                 lock (this)
601                 {
602                     if (_viewOnRelayoutEventHandler != null)
603                     {
604                         this.OnRelayoutSignal().Disconnect(_viewOnRelayoutEventCallbackDelegate);
605                     }
606
607                     _viewOnRelayoutEventHandler -= value;
608                 }
609             }
610         }
611
612         // Callback for View OnRelayout signal
613         private void OnRelayout(IntPtr data)
614         {
615             OnRelayoutEventArgs e = new OnRelayoutEventArgs();
616             Console.WriteLine("View OnRelayoutEventArgs....");
617             // Populate all members of "e" (OnRelayoutEventArgs) with real data
618             e.View = View.GetViewFromPtr(data);
619
620             if (_viewOnRelayoutEventHandler != null)
621             {
622                 //here we send all data to user event handlers
623                 _viewOnRelayoutEventHandler(this, e);
624             }
625         }
626
627         /**
628          * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
629          * (in the type of TouchHandler-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
630          * provided by the user. Touched signal is emitted when touch input is received.
631          */
632         public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
633         {
634             add
635             {
636                 lock (this)
637                 {
638                     // Restricted to only one listener
639                     if (_viewTouchHandler == null)
640                     {
641                         _viewTouchHandler += value;
642                         Console.WriteLine("View Touch EVENT LOCKED....");
643                         _viewTouchCallbackDelegate = new TouchCallbackDelegate(OnTouch);
644                         this.TouchSignal().Connect(_viewTouchCallbackDelegate);
645                     }
646                 }
647             }
648
649             remove
650             {
651                 lock (this)
652                 {
653                     if (_viewTouchHandler != null)
654                     {
655                         this.TouchSignal().Disconnect(_viewTouchCallbackDelegate);
656                     }
657
658                     _viewTouchHandler -= value;
659                 }
660             }
661         }
662
663         // Callback for View TouchSignal
664         private bool OnTouch(IntPtr view, IntPtr touch)
665         {
666             TouchEventArgs e = new TouchEventArgs();
667             Console.WriteLine("View Touch EVENT....");
668             // Populate all members of "e" (TouchEventArgs) with real data
669             e.View = View.GetViewFromPtr(view);
670             e.Touch = Dali.Touch.GetTouchFromPtr(touch);
671
672             if (_viewTouchHandler != null)
673             {
674                 //here we send all data to user event handlers
675                 return _viewTouchHandler(this, e);
676             }
677
678             return false;
679         }
680
681         /**
682          * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
683          * (in the type of HoverHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
684          * provided by the user. Hovered signal is emitted when hover input is received.
685          */
686         public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
687         {
688             add
689             {
690                 lock (this)
691                 {
692                     // Restricted to only one listener
693                     if (_viewHoverHandler == null)
694                     {
695                         _viewHoverHandler += value;
696
697                         _viewHoverCallbackDelegate = new HoverCallbackDelegate(OnHover);
698                         this.HoveredSignal().Connect(_viewHoverCallbackDelegate);
699                     }
700                 }
701             }
702
703             remove
704             {
705                 lock (this)
706                 {
707                     if (_viewHoverHandler != null)
708                     {
709                         this.HoveredSignal().Disconnect(_viewHoverCallbackDelegate);
710                     }
711
712                     _viewHoverHandler -= value;
713                 }
714             }
715         }
716
717         // Callback for View Hover signal
718         private bool OnHover(IntPtr view, IntPtr hover)
719         {
720             HoverEventArgs e = new HoverEventArgs();
721
722             // Populate all members of "e" (HoverEventArgs) with real data
723             e.View = View.GetViewFromPtr(view);
724             e.Hover = Dali.Hover.GetHoverFromPtr(hover);
725
726             if (_viewHoverHandler != null)
727             {
728                 //here we send all data to user event handlers
729                 return _viewHoverHandler(this, e);
730             }
731
732             return false;
733         }
734
735         /**
736          * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
737          * (in the type of WheelHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
738          * provided by the user. WheelMoved signal is emitted when wheel event is received.
739          */
740         public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
741         {
742             add
743             {
744                 lock (this)
745                 {
746                     // Restricted to only one listener
747                     if (_viewWheelHandler == null)
748                     {
749                         _viewWheelHandler += value;
750                         Console.WriteLine("View Wheel EVENT LOCKED....");
751                         _viewWheelCallbackDelegate = new WheelCallbackDelegate(OnWheel);
752                         this.WheelEventSignal().Connect(_viewWheelCallbackDelegate);
753                     }
754                 }
755             }
756
757             remove
758             {
759                 lock (this)
760                 {
761                     if (_viewWheelHandler != null)
762                     {
763                         this.WheelEventSignal().Disconnect(_viewWheelCallbackDelegate);
764                     }
765
766                     _viewWheelHandler -= value;
767                 }
768             }
769         }
770
771         // Callback for View Wheel signal
772         private bool OnWheel(IntPtr view, IntPtr wheel)
773         {
774             WheelEventArgs e = new WheelEventArgs();
775             Console.WriteLine("View Wheel EVENT ....");
776             // Populate all members of "e" (WheelEventArgs) with real data
777             e.View = View.GetViewFromPtr(view);
778             e.Wheel = Dali.Wheel.GetWheelFromPtr(wheel);
779
780             if (_viewWheelHandler != null)
781             {
782                 //here we send all data to user event handlers
783                 return _viewWheelHandler(this, e);
784             }
785
786             return false;
787         }
788
789         /**
790          * @brief Event for OnWindow signal which can be used to subscribe/unsubscribe the event handler
791          * (in the type of OnWindowEventHandler) provided by the user.
792          * OnWindow signal is emitted after the view has been connected to the window.
793          */
794         public event DaliEventHandler<object,OnWindowEventArgs> OnWindowEvent
795         {
796             add
797             {
798                 lock (this)
799                 {
800                     // Restricted to only one listener
801                     if (_viewOnWindowEventHandler == null)
802                     {
803                         _viewOnWindowEventHandler += value;
804
805                         _viewOnWindowEventCallbackDelegate = new OnWindowEventCallbackDelegate(OnWindow);
806                         this.OnWindowSignal().Connect(_viewOnWindowEventCallbackDelegate);
807                     }
808                 }
809             }
810
811             remove
812             {
813                 lock (this)
814                 {
815                     if (_viewOnWindowEventHandler != null)
816                     {
817                         this.OnWindowSignal().Disconnect(_viewOnWindowEventCallbackDelegate);
818                     }
819
820                     _viewOnWindowEventHandler -= value;
821                 }
822             }
823         }
824
825         // Callback for View OnWindow signal
826         private void OnWindow(IntPtr data)
827         {
828             OnWindowEventArgs e = new OnWindowEventArgs();
829
830             // Populate all members of "e" (OnWindowEventArgs) with real data
831             e.View = View.GetViewFromPtr(data);
832
833             //Console.WriteLine("############# OnWindow()! e.View.Name=" + e.View.Name);
834
835             if (_viewOnWindowEventHandler != null)
836             {
837                 //here we send all data to user event handlers
838                 _viewOnWindowEventHandler(this, e);
839             }
840         }
841
842         /**
843          * @brief Event for OffWindow signal which can be used to subscribe/unsubscribe the event handler
844          * (in the type of OffWindowEventHandler) provided by the user.
845          * OffWindow signal is emitted after the view has been disconnected from the window.
846          */
847         public event DaliEventHandler<object,OffWindowEventArgs> OffWindowEvent
848         {
849             add
850             {
851                 lock (this)
852                 {
853                     // Restricted to only one listener
854                     if (_viewOffWindowEventHandler == null)
855                     {
856                         _viewOffWindowEventHandler += value;
857
858                         _viewOffWindowEventCallbackDelegate = new OffWindowEventCallbackDelegate(OffWindow);
859                         this.OnWindowSignal().Connect(_viewOffWindowEventCallbackDelegate);
860                     }
861                 }
862             }
863
864             remove
865             {
866                 lock (this)
867                 {
868                     if (_viewOffWindowEventHandler != null)
869                     {
870                         this.OnWindowSignal().Disconnect(_viewOffWindowEventCallbackDelegate);
871                     }
872
873                     _viewOffWindowEventHandler -= value;
874                 }
875             }
876         }
877
878         // Callback for View OffWindow signal
879         private void OffWindow(IntPtr data)
880         {
881             OffWindowEventArgs e = new OffWindowEventArgs();
882
883             // Populate all members of "e" (OffWindowEventArgs) with real data
884             e.View = View.GetViewFromPtr(data);
885
886             if (_viewOffWindowEventHandler != null)
887             {
888                 //here we send all data to user event handlers
889                 _viewOffWindowEventHandler(this, e);
890             }
891         }
892
893         public static View GetViewFromPtr(global::System.IntPtr cPtr)
894         {
895             View ret = new View(cPtr, false);
896             if (NDalicPINVOKE.SWIGPendingException.Pending)
897                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
898             return ret;
899         }
900
901         public IntPtr GetPtrfromView()
902         {
903             return (IntPtr)swigCPtr;
904         }
905
906         public class Property : global::System.IDisposable
907         {
908             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
909             protected bool swigCMemOwn;
910
911             internal Property(global::System.IntPtr cPtr, bool cMemoryOwn)
912             {
913                 swigCMemOwn = cMemoryOwn;
914                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
915             }
916
917             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj)
918             {
919                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
920             }
921
922             ~Property()
923             {
924                 Dispose();
925             }
926
927             public virtual void Dispose()
928             {
929                 lock (this)
930                 {
931                     if (swigCPtr.Handle != global::System.IntPtr.Zero)
932                     {
933                         if (swigCMemOwn)
934                         {
935                             swigCMemOwn = false;
936                             NDalicPINVOKE.delete_View_Property(swigCPtr);
937                         }
938                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
939                     }
940                     global::System.GC.SuppressFinalize(this);
941                 }
942             }
943
944             public static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
945             public static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
946             public static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
947             public static readonly int LEFT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
948             public static readonly int RIGHT_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
949             public static readonly int UP_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
950             public static readonly int DOWN_FOCUSABLE_VIEW_ID = NDalicManualPINVOKE.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
951
952             public Property() : this(NDalicPINVOKE.new_View_Property(), true)
953             {
954                 if (NDalicPINVOKE.SWIGPendingException.Pending)
955                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
956             }
957
958             public static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();
959             public static readonly int BACKGROUND_COLOR = NDalicPINVOKE.View_Property_BACKGROUND_COLOR_get();
960             public static readonly int BACKGROUND_IMAGE = NDalicPINVOKE.View_Property_BACKGROUND_IMAGE_get();
961             public static readonly int KEY_INPUT_FOCUS = NDalicPINVOKE.View_Property_KEY_INPUT_FOCUS_get();
962             public static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();
963
964
965             public static readonly int SIBLING_ORDER = NDalicManualPINVOKE.Actor_Property_SIBLING_ORDER_get();
966             public static readonly int OPACITY = NDalicManualPINVOKE.Actor_Property_OPACITY_get();
967             public static readonly int SCREEN_POSITION = NDalicManualPINVOKE.Actor_Property_SCREEN_POSITION_get();
968             public static readonly int POSITION_USES_ANCHOR_POINT = NDalicManualPINVOKE.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
969             public static readonly int PARENT_ORIGIN = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_get();
970             public static readonly int PARENT_ORIGIN_X = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_X_get();
971             public static readonly int PARENT_ORIGIN_Y = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Y_get();
972             public static readonly int PARENT_ORIGIN_Z = NDalicPINVOKE.Actor_Property_PARENT_ORIGIN_Z_get();
973             public static readonly int ANCHOR_POINT = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_get();
974             public static readonly int ANCHOR_POINT_X = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_X_get();
975             public static readonly int ANCHOR_POINT_Y = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Y_get();
976             public static readonly int ANCHOR_POINT_Z = NDalicPINVOKE.Actor_Property_ANCHOR_POINT_Z_get();
977             public static readonly int SIZE = NDalicPINVOKE.Actor_Property_SIZE_get();
978             public static readonly int SIZE_WIDTH = NDalicPINVOKE.Actor_Property_SIZE_WIDTH_get();
979             public static readonly int SIZE_HEIGHT = NDalicPINVOKE.Actor_Property_SIZE_HEIGHT_get();
980             public static readonly int SIZE_DEPTH = NDalicPINVOKE.Actor_Property_SIZE_DEPTH_get();
981             public static readonly int POSITION = NDalicPINVOKE.Actor_Property_POSITION_get();
982             public static readonly int POSITION_X = NDalicPINVOKE.Actor_Property_POSITION_X_get();
983             public static readonly int POSITION_Y = NDalicPINVOKE.Actor_Property_POSITION_Y_get();
984             public static readonly int POSITION_Z = NDalicPINVOKE.Actor_Property_POSITION_Z_get();
985             public static readonly int WORLD_POSITION = NDalicPINVOKE.Actor_Property_WORLD_POSITION_get();
986             public static readonly int WORLD_POSITION_X = NDalicPINVOKE.Actor_Property_WORLD_POSITION_X_get();
987             public static readonly int WORLD_POSITION_Y = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Y_get();
988             public static readonly int WORLD_POSITION_Z = NDalicPINVOKE.Actor_Property_WORLD_POSITION_Z_get();
989             public static readonly int ORIENTATION = NDalicPINVOKE.Actor_Property_ORIENTATION_get();
990             public static readonly int WORLD_ORIENTATION = NDalicPINVOKE.Actor_Property_WORLD_ORIENTATION_get();
991             public static readonly int SCALE = NDalicPINVOKE.Actor_Property_SCALE_get();
992             public static readonly int SCALE_X = NDalicPINVOKE.Actor_Property_SCALE_X_get();
993             public static readonly int SCALE_Y = NDalicPINVOKE.Actor_Property_SCALE_Y_get();
994             public static readonly int SCALE_Z = NDalicPINVOKE.Actor_Property_SCALE_Z_get();
995             public static readonly int WORLD_SCALE = NDalicPINVOKE.Actor_Property_WORLD_SCALE_get();
996             public static readonly int VISIBLE = NDalicPINVOKE.Actor_Property_VISIBLE_get();
997             public static readonly int COLOR = NDalicPINVOKE.Actor_Property_COLOR_get();
998             public static readonly int COLOR_RED = NDalicPINVOKE.Actor_Property_COLOR_RED_get();
999             public static readonly int COLOR_GREEN = NDalicPINVOKE.Actor_Property_COLOR_GREEN_get();
1000             public static readonly int COLOR_BLUE = NDalicPINVOKE.Actor_Property_COLOR_BLUE_get();
1001             public static readonly int COLOR_ALPHA = NDalicPINVOKE.Actor_Property_COLOR_ALPHA_get();
1002             public static readonly int WORLD_COLOR = NDalicPINVOKE.Actor_Property_WORLD_COLOR_get();
1003             public static readonly int WORLD_MATRIX = NDalicPINVOKE.Actor_Property_WORLD_MATRIX_get();
1004             public static readonly int NAME = NDalicPINVOKE.Actor_Property_NAME_get();
1005             public static readonly int SENSITIVE = NDalicPINVOKE.Actor_Property_SENSITIVE_get();
1006             public static readonly int LEAVE_REQUIRED = NDalicPINVOKE.Actor_Property_LEAVE_REQUIRED_get();
1007             public static readonly int INHERIT_ORIENTATION = NDalicPINVOKE.Actor_Property_INHERIT_ORIENTATION_get();
1008             public static readonly int INHERIT_SCALE = NDalicPINVOKE.Actor_Property_INHERIT_SCALE_get();
1009             public static readonly int COLOR_MODE = NDalicPINVOKE.Actor_Property_COLOR_MODE_get();
1010             public static readonly int POSITION_INHERITANCE = NDalicPINVOKE.Actor_Property_POSITION_INHERITANCE_get();
1011             public static readonly int DRAW_MODE = NDalicPINVOKE.Actor_Property_DRAW_MODE_get();
1012             public static readonly int SIZE_MODE_FACTOR = NDalicPINVOKE.Actor_Property_SIZE_MODE_FACTOR_get();
1013             public static readonly int WIDTH_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_WIDTH_RESIZE_POLICY_get();
1014             public static readonly int HEIGHT_RESIZE_POLICY = NDalicPINVOKE.Actor_Property_HEIGHT_RESIZE_POLICY_get();
1015             public static readonly int SIZE_SCALE_POLICY = NDalicPINVOKE.Actor_Property_SIZE_SCALE_POLICY_get();
1016             public static readonly int WIDTH_FOR_HEIGHT = NDalicPINVOKE.Actor_Property_WIDTH_FOR_HEIGHT_get();
1017             public static readonly int HEIGHT_FOR_WIDTH = NDalicPINVOKE.Actor_Property_HEIGHT_FOR_WIDTH_get();
1018             public static readonly int PADDING = NDalicPINVOKE.Actor_Property_PADDING_get();
1019             public static readonly int MINIMUM_SIZE = NDalicPINVOKE.Actor_Property_MINIMUM_SIZE_get();
1020             public static readonly int MAXIMUM_SIZE = NDalicPINVOKE.Actor_Property_MAXIMUM_SIZE_get();
1021             public static readonly int INHERIT_POSITION = NDalicPINVOKE.Actor_Property_INHERIT_POSITION_get();
1022             public static readonly int CLIPPING_MODE = NDalicPINVOKE.Actor_Property_CLIPPING_MODE_get();
1023
1024         }
1025
1026         public class KeyboardFocus : global::System.IDisposable
1027         {
1028             private global::System.Runtime.InteropServices.HandleRef swigCPtr;
1029             protected bool swigCMemOwn;
1030
1031             internal KeyboardFocus(global::System.IntPtr cPtr, bool cMemoryOwn)
1032             {
1033                 swigCMemOwn = cMemoryOwn;
1034                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
1035             }
1036
1037             internal static global::System.Runtime.InteropServices.HandleRef getCPtr(KeyboardFocus obj)
1038             {
1039                 return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
1040             }
1041
1042             ~KeyboardFocus()
1043             {
1044                 Dispose();
1045             }
1046
1047             public virtual void Dispose()
1048             {
1049                 lock (this)
1050                 {
1051                     if (swigCPtr.Handle != global::System.IntPtr.Zero)
1052                     {
1053                         if (swigCMemOwn)
1054                         {
1055                             swigCMemOwn = false;
1056                             NDalicPINVOKE.delete_View_KeyboardFocus(swigCPtr);
1057                         }
1058                         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
1059                     }
1060                     global::System.GC.SuppressFinalize(this);
1061                 }
1062             }
1063
1064             public KeyboardFocus() : this(NDalicPINVOKE.new_View_KeyboardFocus(), true)
1065             {
1066                 if (NDalicPINVOKE.SWIGPendingException.Pending)
1067                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1068             }
1069
1070             public enum Direction
1071             {
1072                 LEFT,
1073                 RIGHT,
1074                 UP,
1075                 DOWN,
1076                 PAGE_UP,
1077                 PAGE_DOWN
1078             }
1079         }
1080
1081         public View() : this(NDalicPINVOKE.View_New(), true)
1082         {
1083             if (NDalicPINVOKE.SWIGPendingException.Pending)
1084                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1085
1086         }
1087
1088         public View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true)
1089         {
1090             if (NDalicPINVOKE.SWIGPendingException.Pending)
1091                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1092         }
1093
1094         public View Assign(View handle)
1095         {
1096             View ret = new View(NDalicPINVOKE.View_Assign(swigCPtr, View.getCPtr(handle)), false);
1097             if (NDalicPINVOKE.SWIGPendingException.Pending)
1098                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1099             return ret;
1100         }
1101
1102         private new static View DownCast(BaseHandle handle)
1103         {
1104             View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);
1105             if (NDalicPINVOKE.SWIGPendingException.Pending)
1106                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1107             return ret;
1108         }
1109
1110         public static T DownCast<T>(View view) where T : View
1111         {
1112             return (T)(ViewRegistry.GetViewFromActor(view));
1113         }
1114
1115         private View ConvertIdToView(uint id)
1116         {
1117             View view = null;
1118
1119             if (Parent)
1120             {
1121                 view = Parent.FindChildById(id);
1122             }
1123
1124             if (!view)
1125             {
1126                 view = Window.Instance.GetRootLayer().FindChildById(id);
1127             }
1128
1129             return view;
1130         }
1131
1132         public void SetKeyInputFocus()
1133         {
1134             NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
1135             if (NDalicPINVOKE.SWIGPendingException.Pending)
1136                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1137         }
1138
1139         public bool HasKeyInputFocus()
1140         {
1141             bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
1142             if (NDalicPINVOKE.SWIGPendingException.Pending)
1143                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1144             return ret;
1145         }
1146
1147         public void ClearKeyInputFocus()
1148         {
1149             NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
1150             if (NDalicPINVOKE.SWIGPendingException.Pending)
1151                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1152         }
1153
1154         public PinchGestureDetector GetPinchGestureDetector()
1155         {
1156             PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
1157             if (NDalicPINVOKE.SWIGPendingException.Pending)
1158                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1159             return ret;
1160         }
1161
1162         public PanGestureDetector GetPanGestureDetector()
1163         {
1164             PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
1165             if (NDalicPINVOKE.SWIGPendingException.Pending)
1166                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1167             return ret;
1168         }
1169
1170         public TapGestureDetector GetTapGestureDetector()
1171         {
1172             TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
1173             if (NDalicPINVOKE.SWIGPendingException.Pending)
1174                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1175             return ret;
1176         }
1177
1178         public LongPressGestureDetector GetLongPressGestureDetector()
1179         {
1180             LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
1181             if (NDalicPINVOKE.SWIGPendingException.Pending)
1182                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1183             return ret;
1184         }
1185
1186         public void SetStyleName(string styleName)
1187         {
1188             NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
1189             if (NDalicPINVOKE.SWIGPendingException.Pending)
1190                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1191         }
1192
1193         public string GetStyleName()
1194         {
1195             string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
1196             if (NDalicPINVOKE.SWIGPendingException.Pending)
1197                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1198             return ret;
1199         }
1200
1201         public void SetBackgroundColor(Vector4 color)
1202         {
1203             NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
1204             if (NDalicPINVOKE.SWIGPendingException.Pending)
1205                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1206         }
1207
1208         public Vector4 GetBackgroundColor()
1209         {
1210             Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);
1211             if (NDalicPINVOKE.SWIGPendingException.Pending)
1212                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1213             return ret;
1214         }
1215
1216         public void SetBackgroundImage(Image image)
1217         {
1218             NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));
1219             if (NDalicPINVOKE.SWIGPendingException.Pending)
1220                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1221         }
1222
1223         public void ClearBackground()
1224         {
1225             NDalicPINVOKE.View_ClearBackground(swigCPtr);
1226             if (NDalicPINVOKE.SWIGPendingException.Pending)
1227                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1228         }
1229
1230         public ControlKeySignal KeyEventSignal()
1231         {
1232             ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
1233             if (NDalicPINVOKE.SWIGPendingException.Pending)
1234                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1235             return ret;
1236         }
1237
1238         public KeyInputFocusSignal KeyInputFocusGainedSignal()
1239         {
1240             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
1241             if (NDalicPINVOKE.SWIGPendingException.Pending)
1242                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1243             return ret;
1244         }
1245
1246         public KeyInputFocusSignal KeyInputFocusLostSignal()
1247         {
1248             KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
1249             if (NDalicPINVOKE.SWIGPendingException.Pending)
1250                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1251             return ret;
1252         }
1253
1254         public View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)
1255         {
1256             if (NDalicPINVOKE.SWIGPendingException.Pending)
1257                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1258         }
1259
1260         public enum PropertyRange
1261         {
1262             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
1263             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
1264             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
1265         }
1266
1267         public string StyleName
1268         {
1269             get
1270             {
1271                 string temp;
1272                 GetProperty(View.Property.STYLE_NAME).Get(out temp);
1273                 return temp;
1274             }
1275             set
1276             {
1277                 SetProperty(View.Property.STYLE_NAME, new Dali.Property.Value(value));
1278             }
1279         }
1280
1281         public Vector4 BackgroundColor
1282         {
1283             get
1284             {
1285                 Vector4 backgroundColor = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1286
1287                 Dali.Property.Map background = Background;
1288                 int visualType = 0;
1289                 background.Find(Dali.Constants.Visual.Property.Type).Get(ref visualType);
1290                 if (visualType == (int)Dali.Constants.Visual.Type.Color)
1291                 {
1292                     background.Find(Dali.Constants.ColorVisualProperty.MixColor).Get(backgroundColor);
1293                 }
1294
1295                 return backgroundColor;
1296             }
1297             set
1298             {
1299                 SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
1300             }
1301         }
1302
1303         public string BackgroundImage
1304         {
1305             get
1306             {
1307                 string backgroundImage = "";
1308
1309                 Dali.Property.Map background = Background;
1310                 int visualType = 0;
1311                 background.Find(Dali.Constants.Visual.Property.Type).Get(ref visualType);
1312                 if (visualType == (int)Dali.Constants.Visual.Type.Image)
1313                 {
1314                     background.Find(Dali.Constants.ImageVisualProperty.URL).Get(out backgroundImage);
1315                 }
1316
1317                 return backgroundImage;
1318             }
1319             set
1320             {
1321                 SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
1322             }
1323         }
1324
1325         public bool KeyInputFocus
1326         {
1327             get
1328             {
1329                 bool temp = false;
1330                 GetProperty(View.Property.KEY_INPUT_FOCUS).Get(ref temp);
1331                 return temp;
1332             }
1333             set
1334             {
1335                 SetProperty(View.Property.KEY_INPUT_FOCUS, new Dali.Property.Value(value));
1336             }
1337         }
1338
1339         public Dali.Property.Map Background
1340         {
1341             get
1342             {
1343                 Dali.Property.Map temp = new Dali.Property.Map();
1344                 GetProperty(View.Property.BACKGROUND).Get(temp);
1345                 return temp;
1346             }
1347             set
1348             {
1349                 SetProperty(View.Property.BACKGROUND, new Dali.Property.Value(value));
1350             }
1351         }
1352
1353         public string State
1354         {
1355             get
1356             {
1357                 string temp;
1358                 GetProperty(View.Property.STATE).Get(out temp);
1359                 return temp;
1360             }
1361             set
1362             {
1363                 SetProperty(View.Property.STATE, new Dali.Property.Value(value));
1364             }
1365         }
1366
1367         public string SubState
1368         {
1369             get
1370             {
1371                 string temp;
1372                 GetProperty(View.Property.SUB_STATE).Get(out temp);
1373                 return temp;
1374             }
1375             set
1376             {
1377                 SetProperty(View.Property.SUB_STATE, new Dali.Property.Value(value));
1378             }
1379         }
1380
1381         public Dali.Property.Map Tooltip
1382         {
1383             get
1384             {
1385                 Dali.Property.Map temp = new Dali.Property.Map();
1386                 GetProperty(View.Property.TOOLTIP).Get(temp);
1387                 return temp;
1388             }
1389             set
1390             {
1391                 SetProperty(View.Property.TOOLTIP, new Dali.Property.Value(value));
1392             }
1393         }
1394
1395         public string TooltipText
1396         {
1397             set
1398             {
1399                 SetProperty(View.Property.TOOLTIP, new Dali.Property.Value(value));
1400             }
1401         }
1402
1403         private int LeftFocusableViewId
1404         {
1405             get
1406             {
1407                 int temp = 0;
1408                 GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(ref temp);
1409                 return temp;
1410             }
1411             set
1412             {
1413                 SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1414             }
1415         }
1416
1417         private int RightFocusableViewId
1418         {
1419             get
1420             {
1421                 int temp = 0;
1422                 GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(ref temp);
1423                 return temp;
1424             }
1425             set
1426             {
1427                 SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1428             }
1429         }
1430
1431         private int UpFocusableViewId
1432         {
1433             get
1434             {
1435                 int temp = 0;
1436                 GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(ref temp);
1437                 return temp;
1438             }
1439             set
1440             {
1441                 SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1442             }
1443         }
1444
1445         private int DownFocusableViewId
1446         {
1447             get
1448             {
1449                 int temp = 0;
1450                 GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(ref temp);
1451                 return temp;
1452             }
1453             set
1454             {
1455                 SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Dali.Property.Value(value));
1456             }
1457         }
1458
1459         public float Flex
1460         {
1461             get
1462             {
1463                 float temp = 0.0f;
1464                 GetProperty(FlexContainer.ChildProperty.FLEX).Get(ref temp);
1465                 return temp;
1466             }
1467             set
1468             {
1469                 SetProperty(FlexContainer.ChildProperty.FLEX, new Dali.Property.Value(value));
1470             }
1471         }
1472
1473         public int AlignSelf
1474         {
1475             get
1476             {
1477                 int temp = 0;
1478                 GetProperty(FlexContainer.ChildProperty.ALIGN_SELF).Get(ref temp);
1479                 return temp;
1480             }
1481             set
1482             {
1483                 SetProperty(FlexContainer.ChildProperty.ALIGN_SELF, new Dali.Property.Value(value));
1484             }
1485         }
1486
1487         public Vector4 FlexMargin
1488         {
1489             get
1490             {
1491                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
1492                 GetProperty(FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
1493                 return temp;
1494             }
1495             set
1496             {
1497                 SetProperty(FlexContainer.ChildProperty.FLEX_MARGIN, new Dali.Property.Value(value));
1498             }
1499         }
1500
1501         public Vector2 CellIndex
1502         {
1503             get
1504             {
1505                 Vector2 temp = new Vector2(0.0f, 0.0f);
1506                 GetProperty(TableView.ChildProperty.CELL_INDEX).Get(temp);
1507                 return temp;
1508             }
1509             set
1510             {
1511                 SetProperty(TableView.ChildProperty.CELL_INDEX, new Dali.Property.Value(value));
1512             }
1513         }
1514
1515         public float RowSpan
1516         {
1517             get
1518             {
1519                 float temp = 0.0f;
1520                 GetProperty(TableView.ChildProperty.ROW_SPAN).Get(ref temp);
1521                 return temp;
1522             }
1523             set
1524             {
1525                 SetProperty(TableView.ChildProperty.ROW_SPAN, new Dali.Property.Value(value));
1526             }
1527         }
1528
1529         public float ColumnSpan
1530         {
1531             get
1532             {
1533                 float temp = 0.0f;
1534                 GetProperty(TableView.ChildProperty.COLUMN_SPAN).Get(ref temp);
1535                 return temp;
1536             }
1537             set
1538             {
1539                 SetProperty(TableView.ChildProperty.COLUMN_SPAN, new Dali.Property.Value(value));
1540             }
1541         }
1542
1543         public string CellHorizontalAlignment
1544         {
1545             get
1546             {
1547                 string temp;
1548                 GetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp);
1549                 return temp;
1550             }
1551             set
1552             {
1553                 SetProperty(TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Dali.Property.Value(value));
1554             }
1555         }
1556
1557         public string CellVerticalAlignment
1558         {
1559             get
1560             {
1561                 string temp;
1562                 GetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
1563                 return temp;
1564             }
1565             set
1566             {
1567                 SetProperty(TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Dali.Property.Value(value));
1568             }
1569         }
1570
1571         /**
1572          * @brief The left focusable view.
1573          * @note This will return NULL if not set.
1574          * This will also return NULL if the specified left focusable view is not on window.
1575          *
1576          */
1577         public View LeftFocusableView
1578         {
1579             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1580             get
1581             {
1582                 if (LeftFocusableViewId >= 0)
1583                 {
1584                     return ConvertIdToView((uint)LeftFocusableViewId);
1585                 }
1586                 return null;
1587             }
1588             set
1589             {
1590                 LeftFocusableViewId = (int)value.GetId();
1591             }
1592         }
1593
1594         /**
1595          * @brief The right focusable view.
1596          * @note This will return NULL if not set.
1597          * This will also return NULL if the specified right focusable view is not on window.
1598          *
1599          */
1600         public View RightFocusableView
1601         {
1602             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1603             get
1604             {
1605                 if (RightFocusableViewId >= 0)
1606                 {
1607                     return ConvertIdToView((uint)RightFocusableViewId);
1608                 }
1609                 return null;
1610             }
1611             set
1612             {
1613                 RightFocusableViewId = (int)value.GetId();
1614             }
1615         }
1616
1617         /**
1618          * @brief The up focusable view.
1619          * @note This will return NULL if not set.
1620          * This will also return NULL if the specified up focusable view is not on window.
1621          *
1622          */
1623         public View UpFocusableView
1624         {
1625             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1626             get
1627             {
1628                 if (UpFocusableViewId >= 0)
1629                 {
1630                     return ConvertIdToView((uint)UpFocusableViewId);
1631                 }
1632                 return null;
1633             }
1634             set
1635             {
1636                 UpFocusableViewId = (int)value.GetId();
1637             }
1638         }
1639
1640         /**
1641          * @brief The down focusable view.
1642          * @note This will return NULL if not set.
1643          * This will also return NULL if the specified down focusable view is not on window.
1644          *
1645          */
1646         public View DownFocusableView
1647         {
1648             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
1649             get
1650             {
1651                 if (DownFocusableViewId >= 0)
1652                 {
1653                     return ConvertIdToView((uint)DownFocusableViewId);
1654                 }
1655                 return null;
1656             }
1657             set
1658             {
1659                 DownFocusableViewId = (int)value.GetId();
1660             }
1661         }
1662
1663         public Position CurrentPosition
1664         {
1665             get
1666             {
1667                 return GetCurrentPosition();
1668             }
1669         }
1670
1671         public Size2D Size2D
1672         {
1673             get
1674             {
1675                 Size temp = new Size(0.0f, 0.0f, 0.0f);
1676                 GetProperty(View.Property.SIZE).Get(temp);
1677                 return new Size2D(temp);
1678             }
1679             set
1680             {
1681                 SetProperty(View.Property.SIZE, new Dali.Property.Value(new Size(value)));
1682             }
1683         }
1684
1685         public Size CurrentSize
1686         {
1687             get
1688             {
1689                 return GetCurrentSize();
1690             }
1691         }
1692
1693         public View Parent
1694         {
1695             get
1696             {
1697                 return GetParent();
1698             }
1699         }
1700
1701         public bool Visibility
1702         {
1703             get
1704             {
1705                 return IsVisible();
1706             }
1707         }
1708
1709         public float Opacity
1710         {
1711             get
1712             {
1713                 float temp = 0;
1714                 GetProperty(View.Property.OPACITY).Get(ref temp);
1715                 return temp;
1716             }
1717             set
1718             {
1719                 SetProperty(View.Property.OPACITY, new Dali.Property.Value(value));
1720             }
1721         }
1722
1723         public Position2D Position2D
1724         {
1725             get
1726             {
1727                 Position temp = new Position(0.0f, 0.0f, 0.0f);
1728                 GetProperty(View.Property.POSITION).Get(temp);
1729                 return new Position2D(temp);
1730             }
1731             set
1732             {
1733                 SetProperty(View.Property.POSITION, new Dali.Property.Value(new Position(value)));
1734             }
1735         }
1736
1737         public Vector2 ScreenPosition
1738         {
1739             get
1740             {
1741                 Vector2 temp = new Vector2(0.0f, 0.0f);
1742                 GetProperty(View.Property.SCREEN_POSITION).Get(temp);
1743                 return temp;
1744             }
1745         }
1746
1747         protected bool PositionUsesAnchorPoint
1748         {
1749             get
1750             {
1751                 bool temp = false;
1752                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(ref temp);
1753                 return temp;
1754             }
1755             set
1756             {
1757                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Dali.Property.Value(value));
1758             }
1759         }
1760
1761         public bool StateFocusEnable
1762         {
1763             get
1764             {
1765                 return IsKeyboardFocusable();
1766             }
1767             set
1768             {
1769                 SetKeyboardFocusable(value);
1770             }
1771         }
1772
1773         public bool IsOnWindow
1774         {
1775             get
1776             {
1777                 return OnWindow();
1778             }
1779         }
1780
1781         public int SiblingOrder
1782         {
1783             get
1784             {
1785                 int temp = 0;
1786                 GetProperty(View.Property.SIBLING_ORDER).Get(ref temp);
1787                 return temp;
1788             }
1789             set
1790             {
1791                 SetProperty(View.Property.SIBLING_ORDER, new Dali.Property.Value(value));
1792             }
1793         }
1794
1795         public void Show()
1796         {
1797             SetVisible(true);
1798         }
1799
1800         public void Hide()
1801         {
1802             SetVisible(false);
1803         }
1804
1805         public void Raise()
1806         {
1807             NDalicPINVOKE.Raise(swigCPtr);
1808             if (NDalicPINVOKE.SWIGPendingException.Pending)
1809                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1810         }
1811
1812         public void Lower()
1813         {
1814             NDalicPINVOKE.Lower(swigCPtr);
1815             if (NDalicPINVOKE.SWIGPendingException.Pending)
1816                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1817         }
1818
1819         public void RaiseToTop()
1820         {
1821             NDalicPINVOKE.RaiseToTop(swigCPtr);
1822             if (NDalicPINVOKE.SWIGPendingException.Pending)
1823                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1824         }
1825
1826         public void LowerToBottom()
1827         {
1828             NDalicPINVOKE.LowerToBottom(swigCPtr);
1829             if (NDalicPINVOKE.SWIGPendingException.Pending)
1830                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1831         }
1832
1833         public void RaiseAbove(View target)
1834         {
1835             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
1836             if (NDalicPINVOKE.SWIGPendingException.Pending)
1837                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1838         }
1839
1840         public void LowerBelow(View target)
1841         {
1842             NDalicPINVOKE.RaiseAbove(swigCPtr, View.getCPtr(target));
1843             if (NDalicPINVOKE.SWIGPendingException.Pending)
1844                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1845         }
1846
1847         public string GetName()
1848         {
1849             string ret = NDalicPINVOKE.Actor_GetName(swigCPtr);
1850             if (NDalicPINVOKE.SWIGPendingException.Pending)
1851                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1852             return ret;
1853         }
1854
1855         public void SetName(string name)
1856         {
1857             NDalicPINVOKE.Actor_SetName(swigCPtr, name);
1858             if (NDalicPINVOKE.SWIGPendingException.Pending)
1859                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1860         }
1861
1862         public uint GetId()
1863         {
1864             uint ret = NDalicPINVOKE.Actor_GetId(swigCPtr);
1865             if (NDalicPINVOKE.SWIGPendingException.Pending)
1866                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1867             return ret;
1868         }
1869
1870         public bool OnWindow()
1871         {
1872             bool ret = NDalicPINVOKE.Actor_OnStage(swigCPtr);
1873             if (NDalicPINVOKE.SWIGPendingException.Pending)
1874                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1875             return ret;
1876         }
1877
1878         public Layer GetLayer()
1879         {
1880             Layer ret = new Layer(NDalicPINVOKE.Actor_GetLayer(swigCPtr), true);
1881             if (NDalicPINVOKE.SWIGPendingException.Pending)
1882                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1883             return ret;
1884         }
1885
1886         public void Add(View child)
1887         {
1888             NDalicPINVOKE.Actor_Add(swigCPtr, View.getCPtr(child));
1889             if (NDalicPINVOKE.SWIGPendingException.Pending)
1890                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1891         }
1892
1893         public void Remove(View child)
1894         {
1895             NDalicPINVOKE.Actor_Remove(swigCPtr, View.getCPtr(child));
1896             if (NDalicPINVOKE.SWIGPendingException.Pending)
1897                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1898         }
1899
1900         public void Unparent()
1901         {
1902             NDalicPINVOKE.Actor_Unparent(swigCPtr);
1903             if (NDalicPINVOKE.SWIGPendingException.Pending)
1904                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1905         }
1906
1907         public uint GetChildCount()
1908         {
1909             uint ret = NDalicPINVOKE.Actor_GetChildCount(swigCPtr);
1910             if (NDalicPINVOKE.SWIGPendingException.Pending)
1911                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1912             return ret;
1913         }
1914
1915         public View GetChildAt(uint index)
1916         {
1917             View ret = new View(NDalicPINVOKE.Actor_GetChildAt(swigCPtr, index), true);
1918             if (NDalicPINVOKE.SWIGPendingException.Pending)
1919                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1920             return ret;
1921         }
1922
1923         public View FindChildByName(string actorName)
1924         {
1925             View ret = new View(NDalicPINVOKE.Actor_FindChildByName(swigCPtr, actorName), true);
1926             if (NDalicPINVOKE.SWIGPendingException.Pending)
1927                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1928             return ret;
1929         }
1930
1931         public View FindChildById(uint id)
1932         {
1933             View ret = new View(NDalicPINVOKE.Actor_FindChildById(swigCPtr, id), true);
1934             if (NDalicPINVOKE.SWIGPendingException.Pending)
1935                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1936             return ret;
1937         }
1938
1939         public View GetParent()
1940         {
1941             View ret = new View(NDalicPINVOKE.Actor_GetParent(swigCPtr), true);
1942             if (NDalicPINVOKE.SWIGPendingException.Pending)
1943                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1944             return ret;
1945         }
1946
1947         public void SetParentOrigin(Vector3 origin)
1948         {
1949             NDalicPINVOKE.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
1950             if (NDalicPINVOKE.SWIGPendingException.Pending)
1951                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1952         }
1953
1954         public Vector3 GetCurrentParentOrigin()
1955         {
1956             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentParentOrigin(swigCPtr), true);
1957             if (NDalicPINVOKE.SWIGPendingException.Pending)
1958                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1959             return ret;
1960         }
1961
1962         public void SetAnchorPoint(Vector3 anchorPoint)
1963         {
1964             NDalicPINVOKE.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
1965             if (NDalicPINVOKE.SWIGPendingException.Pending)
1966                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1967         }
1968
1969         public Vector3 GetCurrentAnchorPoint()
1970         {
1971             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentAnchorPoint(swigCPtr), true);
1972             if (NDalicPINVOKE.SWIGPendingException.Pending)
1973                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1974             return ret;
1975         }
1976
1977         public void SetSize(float width, float height)
1978         {
1979             NDalicPINVOKE.Actor_SetSize__SWIG_0(swigCPtr, width, height);
1980             if (NDalicPINVOKE.SWIGPendingException.Pending)
1981                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1982         }
1983
1984         public void SetSize(float width, float height, float depth)
1985         {
1986             NDalicPINVOKE.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
1987             if (NDalicPINVOKE.SWIGPendingException.Pending)
1988                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1989         }
1990
1991         public void SetSize(Vector2 size)
1992         {
1993             NDalicPINVOKE.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
1994             if (NDalicPINVOKE.SWIGPendingException.Pending)
1995                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1996         }
1997
1998         public void SetSize(Vector3 size)
1999         {
2000             NDalicPINVOKE.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
2001             if (NDalicPINVOKE.SWIGPendingException.Pending)
2002                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2003         }
2004
2005         public Vector3 GetTargetSize()
2006         {
2007             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetTargetSize(swigCPtr), true);
2008             if (NDalicPINVOKE.SWIGPendingException.Pending)
2009                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2010             return ret;
2011         }
2012
2013         public Vector3 GetCurrentSize()
2014         {
2015             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentSize(swigCPtr), true);
2016             if (NDalicPINVOKE.SWIGPendingException.Pending)
2017                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2018             return ret;
2019         }
2020
2021         public Vector3 GetNaturalSize()
2022         {
2023             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetNaturalSize(swigCPtr), true);
2024             if (NDalicPINVOKE.SWIGPendingException.Pending)
2025                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2026             return ret;
2027         }
2028
2029         public void SetPosition(float x, float y)
2030         {
2031             NDalicPINVOKE.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
2032             if (NDalicPINVOKE.SWIGPendingException.Pending)
2033                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2034         }
2035
2036         public void SetPosition(float x, float y, float z)
2037         {
2038             NDalicPINVOKE.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
2039             if (NDalicPINVOKE.SWIGPendingException.Pending)
2040                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2041         }
2042
2043         public void SetPosition(Vector3 position)
2044         {
2045             NDalicPINVOKE.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
2046             if (NDalicPINVOKE.SWIGPendingException.Pending)
2047                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2048         }
2049
2050         public void SetX(float x)
2051         {
2052             NDalicPINVOKE.Actor_SetX(swigCPtr, x);
2053             if (NDalicPINVOKE.SWIGPendingException.Pending)
2054                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2055         }
2056
2057         public void SetY(float y)
2058         {
2059             NDalicPINVOKE.Actor_SetY(swigCPtr, y);
2060             if (NDalicPINVOKE.SWIGPendingException.Pending)
2061                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2062         }
2063
2064         public void SetZ(float z)
2065         {
2066             NDalicPINVOKE.Actor_SetZ(swigCPtr, z);
2067             if (NDalicPINVOKE.SWIGPendingException.Pending)
2068                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2069         }
2070
2071         public void TranslateBy(Vector3 distance)
2072         {
2073             NDalicPINVOKE.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
2074             if (NDalicPINVOKE.SWIGPendingException.Pending)
2075                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2076         }
2077
2078         public Vector3 GetCurrentPosition()
2079         {
2080             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentPosition(swigCPtr), true);
2081             if (NDalicPINVOKE.SWIGPendingException.Pending)
2082                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2083             return ret;
2084         }
2085
2086         public Vector3 GetCurrentWorldPosition()
2087         {
2088             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldPosition(swigCPtr), true);
2089             if (NDalicPINVOKE.SWIGPendingException.Pending)
2090                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2091             return ret;
2092         }
2093
2094         public void SetInheritPosition(bool inherit)
2095         {
2096             NDalicPINVOKE.Actor_SetInheritPosition(swigCPtr, inherit);
2097             if (NDalicPINVOKE.SWIGPendingException.Pending)
2098                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2099         }
2100
2101         public PositionInheritanceMode GetPositionInheritanceMode()
2102         {
2103             PositionInheritanceMode ret = (PositionInheritanceMode)NDalicPINVOKE.Actor_GetPositionInheritanceMode(swigCPtr);
2104             if (NDalicPINVOKE.SWIGPendingException.Pending)
2105                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2106             return ret;
2107         }
2108
2109         public bool IsPositionInherited()
2110         {
2111             bool ret = NDalicPINVOKE.Actor_IsPositionInherited(swigCPtr);
2112             if (NDalicPINVOKE.SWIGPendingException.Pending)
2113                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2114             return ret;
2115         }
2116
2117         public void SetOrientation(Degree angle, Vector3 axis)
2118         {
2119             NDalicPINVOKE.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2120             if (NDalicPINVOKE.SWIGPendingException.Pending)
2121                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2122         }
2123
2124         public void SetOrientation(Radian angle, Vector3 axis)
2125         {
2126             NDalicPINVOKE.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2127             if (NDalicPINVOKE.SWIGPendingException.Pending)
2128                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2129         }
2130
2131         public void SetOrientation(Rotation orientation)
2132         {
2133             NDalicPINVOKE.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
2134             if (NDalicPINVOKE.SWIGPendingException.Pending)
2135                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2136         }
2137
2138         public void RotateBy(Degree angle, Vector3 axis)
2139         {
2140             NDalicPINVOKE.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
2141             if (NDalicPINVOKE.SWIGPendingException.Pending)
2142                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2143         }
2144
2145         public void RotateBy(Radian angle, Vector3 axis)
2146         {
2147             NDalicPINVOKE.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
2148             if (NDalicPINVOKE.SWIGPendingException.Pending)
2149                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2150         }
2151
2152         public void RotateBy(Rotation relativeRotation)
2153         {
2154             NDalicPINVOKE.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
2155             if (NDalicPINVOKE.SWIGPendingException.Pending)
2156                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2157         }
2158
2159         public Rotation GetCurrentOrientation()
2160         {
2161             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentOrientation(swigCPtr), true);
2162             if (NDalicPINVOKE.SWIGPendingException.Pending)
2163                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2164             return ret;
2165         }
2166
2167         public void SetInheritOrientation(bool inherit)
2168         {
2169             NDalicPINVOKE.Actor_SetInheritOrientation(swigCPtr, inherit);
2170             if (NDalicPINVOKE.SWIGPendingException.Pending)
2171                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2172         }
2173
2174         public bool IsOrientationInherited()
2175         {
2176             bool ret = NDalicPINVOKE.Actor_IsOrientationInherited(swigCPtr);
2177             if (NDalicPINVOKE.SWIGPendingException.Pending)
2178                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2179             return ret;
2180         }
2181
2182         public Rotation GetCurrentWorldOrientation()
2183         {
2184             Rotation ret = new Rotation(NDalicPINVOKE.Actor_GetCurrentWorldOrientation(swigCPtr), true);
2185             if (NDalicPINVOKE.SWIGPendingException.Pending)
2186                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2187             return ret;
2188         }
2189
2190         public void SetScale(float scale)
2191         {
2192             NDalicPINVOKE.Actor_SetScale__SWIG_0(swigCPtr, scale);
2193             if (NDalicPINVOKE.SWIGPendingException.Pending)
2194                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2195         }
2196
2197         public void SetScale(float scaleX, float scaleY, float scaleZ)
2198         {
2199             NDalicPINVOKE.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
2200             if (NDalicPINVOKE.SWIGPendingException.Pending)
2201                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2202         }
2203
2204         public void SetScale(Vector3 scale)
2205         {
2206             NDalicPINVOKE.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
2207             if (NDalicPINVOKE.SWIGPendingException.Pending)
2208                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2209         }
2210
2211         public void ScaleBy(Vector3 relativeScale)
2212         {
2213             NDalicPINVOKE.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
2214             if (NDalicPINVOKE.SWIGPendingException.Pending)
2215                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2216         }
2217
2218         public Vector3 GetCurrentScale()
2219         {
2220             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentScale(swigCPtr), true);
2221             if (NDalicPINVOKE.SWIGPendingException.Pending)
2222                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2223             return ret;
2224         }
2225
2226         public Vector3 GetCurrentWorldScale()
2227         {
2228             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetCurrentWorldScale(swigCPtr), true);
2229             if (NDalicPINVOKE.SWIGPendingException.Pending)
2230                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2231             return ret;
2232         }
2233
2234         public void SetInheritScale(bool inherit)
2235         {
2236             NDalicPINVOKE.Actor_SetInheritScale(swigCPtr, inherit);
2237             if (NDalicPINVOKE.SWIGPendingException.Pending)
2238                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2239         }
2240
2241         public bool IsScaleInherited()
2242         {
2243             bool ret = NDalicPINVOKE.Actor_IsScaleInherited(swigCPtr);
2244             if (NDalicPINVOKE.SWIGPendingException.Pending)
2245                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2246             return ret;
2247         }
2248
2249         public Matrix GetCurrentWorldMatrix()
2250         {
2251             Matrix ret = new Matrix(NDalicPINVOKE.Actor_GetCurrentWorldMatrix(swigCPtr), true);
2252             if (NDalicPINVOKE.SWIGPendingException.Pending)
2253                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2254             return ret;
2255         }
2256
2257         public void SetVisible(bool visible)
2258         {
2259             NDalicPINVOKE.Actor_SetVisible(swigCPtr, visible);
2260             if (NDalicPINVOKE.SWIGPendingException.Pending)
2261                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2262         }
2263
2264         public bool IsVisible()
2265         {
2266             bool ret = NDalicPINVOKE.Actor_IsVisible(swigCPtr);
2267             if (NDalicPINVOKE.SWIGPendingException.Pending)
2268                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2269             return ret;
2270         }
2271
2272         public void SetOpacity(float opacity)
2273         {
2274             NDalicPINVOKE.Actor_SetOpacity(swigCPtr, opacity);
2275             if (NDalicPINVOKE.SWIGPendingException.Pending)
2276                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2277         }
2278
2279         public float GetCurrentOpacity()
2280         {
2281             float ret = NDalicPINVOKE.Actor_GetCurrentOpacity(swigCPtr);
2282             if (NDalicPINVOKE.SWIGPendingException.Pending)
2283                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2284             return ret;
2285         }
2286
2287         public void SetColor(Vector4 color)
2288         {
2289             NDalicPINVOKE.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
2290             if (NDalicPINVOKE.SWIGPendingException.Pending)
2291                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2292         }
2293
2294         public Vector4 GetCurrentColor()
2295         {
2296             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentColor(swigCPtr), true);
2297             if (NDalicPINVOKE.SWIGPendingException.Pending)
2298                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2299             return ret;
2300         }
2301
2302         public void SetColorMode(ColorMode colorMode)
2303         {
2304             NDalicPINVOKE.Actor_SetColorMode(swigCPtr, (int)colorMode);
2305             if (NDalicPINVOKE.SWIGPendingException.Pending)
2306                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2307         }
2308
2309         public ColorMode GetColorMode()
2310         {
2311             ColorMode ret = (ColorMode)NDalicPINVOKE.Actor_GetColorMode(swigCPtr);
2312             if (NDalicPINVOKE.SWIGPendingException.Pending)
2313                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2314             return ret;
2315         }
2316
2317         public Vector4 GetCurrentWorldColor()
2318         {
2319             Vector4 ret = new Vector4(NDalicPINVOKE.Actor_GetCurrentWorldColor(swigCPtr), true);
2320             if (NDalicPINVOKE.SWIGPendingException.Pending)
2321                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2322             return ret;
2323         }
2324
2325         public void SetDrawMode(DrawModeType drawMode)
2326         {
2327             NDalicPINVOKE.Actor_SetDrawMode(swigCPtr, (int)drawMode);
2328             if (NDalicPINVOKE.SWIGPendingException.Pending)
2329                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2330         }
2331
2332         public DrawModeType GetDrawMode()
2333         {
2334             DrawModeType ret = (DrawModeType)NDalicPINVOKE.Actor_GetDrawMode(swigCPtr);
2335             if (NDalicPINVOKE.SWIGPendingException.Pending)
2336                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2337             return ret;
2338         }
2339
2340         public void SetSensitive(bool sensitive)
2341         {
2342             NDalicPINVOKE.Actor_SetSensitive(swigCPtr, sensitive);
2343             if (NDalicPINVOKE.SWIGPendingException.Pending)
2344                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2345         }
2346
2347         public bool IsSensitive()
2348         {
2349             bool ret = NDalicPINVOKE.Actor_IsSensitive(swigCPtr);
2350             if (NDalicPINVOKE.SWIGPendingException.Pending)
2351                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2352             return ret;
2353         }
2354
2355         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
2356         {
2357             bool ret = NDalicPINVOKE.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
2358             if (NDalicPINVOKE.SWIGPendingException.Pending)
2359                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2360             return ret;
2361         }
2362
2363         public void SetLeaveRequired(bool required)
2364         {
2365             NDalicPINVOKE.Actor_SetLeaveRequired(swigCPtr, required);
2366             if (NDalicPINVOKE.SWIGPendingException.Pending)
2367                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2368         }
2369
2370         public bool GetLeaveRequired()
2371         {
2372             bool ret = NDalicPINVOKE.Actor_GetLeaveRequired(swigCPtr);
2373             if (NDalicPINVOKE.SWIGPendingException.Pending)
2374                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2375             return ret;
2376         }
2377
2378         public void SetKeyboardFocusable(bool focusable)
2379         {
2380             NDalicPINVOKE.Actor_SetKeyboardFocusable(swigCPtr, focusable);
2381             if (NDalicPINVOKE.SWIGPendingException.Pending)
2382                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2383         }
2384
2385         public bool IsKeyboardFocusable()
2386         {
2387             bool ret = NDalicPINVOKE.Actor_IsKeyboardFocusable(swigCPtr);
2388             if (NDalicPINVOKE.SWIGPendingException.Pending)
2389                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2390             return ret;
2391         }
2392
2393         public void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
2394         {
2395             NDalicPINVOKE.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
2396             if (NDalicPINVOKE.SWIGPendingException.Pending)
2397                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2398         }
2399
2400         public ResizePolicyType GetResizePolicy(DimensionType dimension)
2401         {
2402             ResizePolicyType ret = (ResizePolicyType)NDalicPINVOKE.Actor_GetResizePolicy(swigCPtr, (int)dimension);
2403             if (NDalicPINVOKE.SWIGPendingException.Pending)
2404                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2405             return ret;
2406         }
2407
2408         public void SetSizeScalePolicy(SizeScalePolicyType policy)
2409         {
2410             NDalicPINVOKE.Actor_SetSizeScalePolicy(swigCPtr, (int)policy);
2411             if (NDalicPINVOKE.SWIGPendingException.Pending)
2412                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2413         }
2414
2415         public SizeScalePolicyType GetSizeScalePolicy()
2416         {
2417             SizeScalePolicyType ret = (SizeScalePolicyType)NDalicPINVOKE.Actor_GetSizeScalePolicy(swigCPtr);
2418             if (NDalicPINVOKE.SWIGPendingException.Pending)
2419                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2420             return ret;
2421         }
2422
2423         public void SetSizeModeFactor(Vector3 factor)
2424         {
2425             NDalicPINVOKE.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
2426             if (NDalicPINVOKE.SWIGPendingException.Pending)
2427                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2428         }
2429
2430         public Vector3 GetSizeModeFactor()
2431         {
2432             Vector3 ret = new Vector3(NDalicPINVOKE.Actor_GetSizeModeFactor(swigCPtr), true);
2433             if (NDalicPINVOKE.SWIGPendingException.Pending)
2434                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2435             return ret;
2436         }
2437
2438         public float GetHeightForWidth(float width)
2439         {
2440             float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
2441             if (NDalicPINVOKE.SWIGPendingException.Pending)
2442                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2443             return ret;
2444         }
2445
2446         public float GetWidthForHeight(float height)
2447         {
2448             float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
2449             if (NDalicPINVOKE.SWIGPendingException.Pending)
2450                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2451             return ret;
2452         }
2453
2454         public float GetRelayoutSize(DimensionType dimension)
2455         {
2456             float ret = NDalicPINVOKE.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
2457             if (NDalicPINVOKE.SWIGPendingException.Pending)
2458                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2459             return ret;
2460         }
2461
2462         public void SetPadding(PaddingType padding)
2463         {
2464             NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
2465             if (NDalicPINVOKE.SWIGPendingException.Pending)
2466                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2467         }
2468
2469         public void GetPadding(PaddingType paddingOut)
2470         {
2471             NDalicPINVOKE.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
2472             if (NDalicPINVOKE.SWIGPendingException.Pending)
2473                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2474         }
2475
2476         public void SetMinimumSize(Vector2 size)
2477         {
2478             NDalicPINVOKE.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
2479             if (NDalicPINVOKE.SWIGPendingException.Pending)
2480                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2481         }
2482
2483         public Vector2 GetMinimumSize()
2484         {
2485             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMinimumSize(swigCPtr), true);
2486             if (NDalicPINVOKE.SWIGPendingException.Pending)
2487                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2488             return ret;
2489         }
2490
2491         public void SetMaximumSize(Vector2 size)
2492         {
2493             NDalicPINVOKE.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
2494             if (NDalicPINVOKE.SWIGPendingException.Pending)
2495                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2496         }
2497
2498         public Vector2 GetMaximumSize()
2499         {
2500             Vector2 ret = new Vector2(NDalicPINVOKE.Actor_GetMaximumSize(swigCPtr), true);
2501             if (NDalicPINVOKE.SWIGPendingException.Pending)
2502                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2503             return ret;
2504         }
2505
2506         public int GetHierarchyDepth()
2507         {
2508             int ret = NDalicPINVOKE.Actor_GetHierarchyDepth(swigCPtr);
2509             if (NDalicPINVOKE.SWIGPendingException.Pending)
2510                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2511             return ret;
2512         }
2513
2514         public uint AddRenderer(Renderer renderer)
2515         {
2516             uint ret = NDalicPINVOKE.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
2517             if (NDalicPINVOKE.SWIGPendingException.Pending)
2518                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2519             return ret;
2520         }
2521
2522         public uint GetRendererCount()
2523         {
2524             uint ret = NDalicPINVOKE.Actor_GetRendererCount(swigCPtr);
2525             if (NDalicPINVOKE.SWIGPendingException.Pending)
2526                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2527             return ret;
2528         }
2529
2530         public Renderer GetRendererAt(uint index)
2531         {
2532             Renderer ret = new Renderer(NDalicPINVOKE.Actor_GetRendererAt(swigCPtr, index), true);
2533             if (NDalicPINVOKE.SWIGPendingException.Pending)
2534                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2535             return ret;
2536         }
2537
2538         public void RemoveRenderer(Renderer renderer)
2539         {
2540             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
2541             if (NDalicPINVOKE.SWIGPendingException.Pending)
2542                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2543         }
2544
2545         public void RemoveRenderer(uint index)
2546         {
2547             NDalicPINVOKE.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
2548             if (NDalicPINVOKE.SWIGPendingException.Pending)
2549                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2550         }
2551
2552         internal TouchDataSignal TouchSignal()
2553         {
2554             TouchDataSignal ret = new TouchDataSignal(NDalicPINVOKE.Actor_TouchSignal(swigCPtr), false);
2555             if (NDalicPINVOKE.SWIGPendingException.Pending)
2556                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2557             return ret;
2558         }
2559
2560         internal HoverSignal HoveredSignal()
2561         {
2562             HoverSignal ret = new HoverSignal(NDalicPINVOKE.Actor_HoveredSignal(swigCPtr), false);
2563             if (NDalicPINVOKE.SWIGPendingException.Pending)
2564                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2565             return ret;
2566         }
2567
2568         internal WheelSignal WheelEventSignal()
2569         {
2570             WheelSignal ret = new WheelSignal(NDalicPINVOKE.Actor_WheelEventSignal(swigCPtr), false);
2571             if (NDalicPINVOKE.SWIGPendingException.Pending)
2572                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2573             return ret;
2574         }
2575
2576         public ViewSignal OnWindowSignal()
2577         {
2578             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnStageSignal(swigCPtr), false);
2579             if (NDalicPINVOKE.SWIGPendingException.Pending)
2580                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2581             return ret;
2582         }
2583
2584         public ViewSignal OffStageSignal()
2585         {
2586             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OffStageSignal(swigCPtr), false);
2587             if (NDalicPINVOKE.SWIGPendingException.Pending)
2588                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2589             return ret;
2590         }
2591
2592         public ViewSignal OnRelayoutSignal()
2593         {
2594             ViewSignal ret = new ViewSignal(NDalicPINVOKE.Actor_OnRelayoutSignal(swigCPtr), false);
2595             if (NDalicPINVOKE.SWIGPendingException.Pending)
2596                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2597             return ret;
2598         }
2599
2600         public Vector3 ParentOrigin
2601         {
2602             get
2603             {
2604                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2605                 GetProperty(View.Property.PARENT_ORIGIN).Get(temp);
2606                 return temp;
2607             }
2608             set
2609             {
2610                 SetProperty(View.Property.PARENT_ORIGIN, new Dali.Property.Value(value));
2611             }
2612         }
2613
2614         public float ParentOriginX
2615         {
2616             get
2617             {
2618                 float temp = 0.0f;
2619                 GetProperty(View.Property.PARENT_ORIGIN_X).Get(ref temp);
2620                 return temp;
2621             }
2622             set
2623             {
2624                 SetProperty(View.Property.PARENT_ORIGIN_X, new Dali.Property.Value(value));
2625             }
2626         }
2627
2628         public float ParentOriginY
2629         {
2630             get
2631             {
2632                 float temp = 0.0f;
2633                 GetProperty(View.Property.PARENT_ORIGIN_Y).Get(ref temp);
2634                 return temp;
2635             }
2636             set
2637             {
2638                 SetProperty(View.Property.PARENT_ORIGIN_Y, new Dali.Property.Value(value));
2639             }
2640         }
2641
2642         public float ParentOriginZ
2643         {
2644             get
2645             {
2646                 float temp = 0.0f;
2647                 GetProperty(View.Property.PARENT_ORIGIN_Z).Get(ref temp);
2648                 return temp;
2649             }
2650             set
2651             {
2652                 SetProperty(View.Property.PARENT_ORIGIN_Z, new Dali.Property.Value(value));
2653             }
2654         }
2655
2656         public Vector3 AnchorPoint
2657         {
2658             get
2659             {
2660                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2661                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
2662                 return temp;
2663             }
2664             set
2665             {
2666                 SetProperty(View.Property.ANCHOR_POINT, new Dali.Property.Value(value));
2667             }
2668         }
2669
2670         public float AnchorPointX
2671         {
2672             get
2673             {
2674                 float temp = 0.0f;
2675                 GetProperty(View.Property.ANCHOR_POINT_X).Get(ref temp);
2676                 return temp;
2677             }
2678             set
2679             {
2680                 SetProperty(View.Property.ANCHOR_POINT_X, new Dali.Property.Value(value));
2681             }
2682         }
2683
2684         public float AnchorPointY
2685         {
2686             get
2687             {
2688                 float temp = 0.0f;
2689                 GetProperty(View.Property.ANCHOR_POINT_Y).Get(ref temp);
2690                 return temp;
2691             }
2692             set
2693             {
2694                 SetProperty(View.Property.ANCHOR_POINT_Y, new Dali.Property.Value(value));
2695             }
2696         }
2697
2698         public float AnchorPointZ
2699         {
2700             get
2701             {
2702                 float temp = 0.0f;
2703                 GetProperty(View.Property.ANCHOR_POINT_Z).Get(ref temp);
2704                 return temp;
2705             }
2706             set
2707             {
2708                 SetProperty(View.Property.ANCHOR_POINT_Z, new Dali.Property.Value(value));
2709             }
2710         }
2711
2712         public Vector3 Size
2713         {
2714             get
2715             {
2716                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2717                 GetProperty(View.Property.SIZE).Get(temp);
2718                 return temp;
2719             }
2720             set
2721             {
2722                 SetProperty(View.Property.SIZE, new Dali.Property.Value(value));
2723             }
2724         }
2725
2726         public float SizeWidth
2727         {
2728             get
2729             {
2730                 float temp = 0.0f;
2731                 GetProperty(View.Property.SIZE_WIDTH).Get(ref temp);
2732                 return temp;
2733             }
2734             set
2735             {
2736                 SetProperty(View.Property.SIZE_WIDTH, new Dali.Property.Value(value));
2737             }
2738         }
2739
2740         public float SizeHeight
2741         {
2742             get
2743             {
2744                 float temp = 0.0f;
2745                 GetProperty(View.Property.SIZE_HEIGHT).Get(ref temp);
2746                 return temp;
2747             }
2748             set
2749             {
2750                 SetProperty(View.Property.SIZE_HEIGHT, new Dali.Property.Value(value));
2751             }
2752         }
2753
2754         public float SizeDepth
2755         {
2756             get
2757             {
2758                 float temp = 0.0f;
2759                 GetProperty(View.Property.SIZE_DEPTH).Get(ref temp);
2760                 return temp;
2761             }
2762             set
2763             {
2764                 SetProperty(View.Property.SIZE_DEPTH, new Dali.Property.Value(value));
2765             }
2766         }
2767
2768         public Vector3 Position
2769         {
2770             get
2771             {
2772                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2773                 GetProperty(View.Property.POSITION).Get(temp);
2774                 return temp;
2775             }
2776             set
2777             {
2778                 SetProperty(View.Property.POSITION, new Dali.Property.Value(value));
2779             }
2780         }
2781
2782         public float PositionX
2783         {
2784             get
2785             {
2786                 float temp = 0.0f;
2787                 GetProperty(View.Property.POSITION_X).Get(ref temp);
2788                 return temp;
2789             }
2790             set
2791             {
2792                 SetProperty(View.Property.POSITION_X, new Dali.Property.Value(value));
2793             }
2794         }
2795
2796         public float PositionY
2797         {
2798             get
2799             {
2800                 float temp = 0.0f;
2801                 GetProperty(View.Property.POSITION_Y).Get(ref temp);
2802                 return temp;
2803             }
2804             set
2805             {
2806                 SetProperty(View.Property.POSITION_Y, new Dali.Property.Value(value));
2807             }
2808         }
2809
2810         public float PositionZ
2811         {
2812             get
2813             {
2814                 float temp = 0.0f;
2815                 GetProperty(View.Property.POSITION_Z).Get(ref temp);
2816                 return temp;
2817             }
2818             set
2819             {
2820                 SetProperty(View.Property.POSITION_Z, new Dali.Property.Value(value));
2821             }
2822         }
2823
2824         public Vector3 WorldPosition
2825         {
2826             get
2827             {
2828                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2829                 GetProperty(View.Property.WORLD_POSITION).Get(temp);
2830                 return temp;
2831             }
2832         }
2833
2834         public float WorldPositionX
2835         {
2836             get
2837             {
2838                 float temp = 0.0f;
2839                 GetProperty(View.Property.WORLD_POSITION_X).Get(ref temp);
2840                 return temp;
2841             }
2842         }
2843
2844         public float WorldPositionY
2845         {
2846             get
2847             {
2848                 float temp = 0.0f;
2849                 GetProperty(View.Property.WORLD_POSITION_Y).Get(ref temp);
2850                 return temp;
2851             }
2852         }
2853
2854         public float WorldPositionZ
2855         {
2856             get
2857             {
2858                 float temp = 0.0f;
2859                 GetProperty(View.Property.WORLD_POSITION_Z).Get(ref temp);
2860                 return temp;
2861             }
2862         }
2863
2864         public Rotation Orientation
2865         {
2866             get
2867             {
2868                 Rotation temp = new Rotation();
2869                 GetProperty(View.Property.ORIENTATION).Get(temp);
2870                 return temp;
2871             }
2872             set
2873             {
2874                 SetProperty(View.Property.ORIENTATION, new Dali.Property.Value(value));
2875             }
2876         }
2877
2878         public Rotation WorldOrientation
2879         {
2880             get
2881             {
2882                 Rotation temp = new Rotation();
2883                 GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
2884                 return temp;
2885             }
2886         }
2887
2888         public Vector3 Scale
2889         {
2890             get
2891             {
2892                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2893                 GetProperty(View.Property.SCALE).Get(temp);
2894                 return temp;
2895             }
2896             set
2897             {
2898                 SetProperty(View.Property.SCALE, new Dali.Property.Value(value));
2899             }
2900         }
2901
2902         public float ScaleX
2903         {
2904             get
2905             {
2906                 float temp = 0.0f;
2907                 GetProperty(View.Property.SCALE_X).Get(ref temp);
2908                 return temp;
2909             }
2910             set
2911             {
2912                 SetProperty(View.Property.SCALE_X, new Dali.Property.Value(value));
2913             }
2914         }
2915
2916         public float ScaleY
2917         {
2918             get
2919             {
2920                 float temp = 0.0f;
2921                 GetProperty(View.Property.SCALE_Y).Get(ref temp);
2922                 return temp;
2923             }
2924             set
2925             {
2926                 SetProperty(View.Property.SCALE_Y, new Dali.Property.Value(value));
2927             }
2928         }
2929
2930         public float ScaleZ
2931         {
2932             get
2933             {
2934                 float temp = 0.0f;
2935                 GetProperty(View.Property.SCALE_Z).Get(ref temp);
2936                 return temp;
2937             }
2938             set
2939             {
2940                 SetProperty(View.Property.SCALE_Z, new Dali.Property.Value(value));
2941             }
2942         }
2943
2944         public Vector3 WorldScale
2945         {
2946             get
2947             {
2948                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2949                 GetProperty(View.Property.WORLD_SCALE).Get(temp);
2950                 return temp;
2951             }
2952         }
2953
2954         public bool Visible
2955         {
2956             get
2957             {
2958                 bool temp = false;
2959                 GetProperty(View.Property.VISIBLE).Get(ref temp);
2960                 return temp;
2961             }
2962             set
2963             {
2964                 SetProperty(View.Property.VISIBLE, new Dali.Property.Value(value));
2965             }
2966         }
2967
2968         public float ColorRed
2969         {
2970             get
2971             {
2972                 float temp = 0.0f;
2973                 GetProperty(View.Property.COLOR_RED).Get(ref temp);
2974                 return temp;
2975             }
2976             set
2977             {
2978                 SetProperty(View.Property.COLOR_RED, new Dali.Property.Value(value));