1b4fbec5cae1a92a968bf7c2bbf8be0ea6cc5e2d
[platform/core/uifw/dali-toolkit.git] / plugins / dali-swig / manual / csharp / 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
23 public class View : CustomActor {
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     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
28
29     // Register this instance of view in the view registry.
30     ViewRegistry.RegisterView(this);
31   }
32
33   internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj) {
34     return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
35   }
36
37   ~View() {
38     DisposeQueue.Instance.Add(this);
39
40     // Unregister this instance of view from the view registry.
41     ViewRegistry.UnregisterView(this);
42   }
43
44   public override void Dispose() {
45     if (!Stage.IsInstalled()) {
46       DisposeQueue.Instance.Add(this);
47       return;
48     }
49
50     lock(this) {
51       if (swigCPtr.Handle != global::System.IntPtr.Zero) {
52         if (swigCMemOwn) {
53           swigCMemOwn = false;
54           NDalicPINVOKE.delete_View(swigCPtr);
55         }
56         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
57       }
58       global::System.GC.SuppressFinalize(this);
59       base.Dispose();
60     }
61   }
62
63   /**
64    * @brief Event arguments that passed via KeyInputFocusGained signal
65    *
66    */
67   public class KeyInputFocusGainedEventArgs : EventArgs
68   {
69     private View _view;
70
71     /**
72      * @brief View - is the view that gets Key Input Focus
73      *
74      */
75     public View View
76     {
77       get
78       {
79         return _view;
80       }
81       set
82       {
83         _view = value;
84       }
85     }
86   }
87
88   /**
89    * @brief Event arguments that passed via KeyInputFocusLost signal
90    *
91    */
92   public class KeyInputFocusLostEventArgs : EventArgs
93   {
94     private View _view;
95
96     /**
97      * @brief View - is the view that loses Key Input Focus
98      *
99      */
100     public View View
101     {
102       get
103       {
104         return _view;
105       }
106       set
107       {
108         _view = value;
109       }
110     }
111   }
112
113   /**
114    * @brief Event arguments that passed via Key signal
115    *
116    */
117   public class KeyEventArgs : EventArgs
118   {
119     private View _view;
120     private Key _key;
121
122     /**
123      * @brief View - is the view that recieves the key.
124      *
125      */
126     public View View
127     {
128       get
129       {
130         return _view;
131       }
132       set
133       {
134         _view = value;
135       }
136     }
137
138     /**
139      * @brief Key - is the key sent to the View.
140      *
141      */
142     public Key Key
143     {
144       get
145       {
146         return _key;
147       }
148       set
149       {
150         _key = value;
151       }
152     }
153   }
154
155   /**
156    * @brief Event arguments that passed via OnRelayout signal
157    *
158    */
159   public class OnRelayoutEventArgs : EventArgs
160   {
161     private View _view;
162
163     /**
164      * @brief View - is the view that is being resized upon relayout
165      *
166      */
167     public View View
168     {
169       get
170       {
171         return _view;
172       }
173       set
174       {
175         _view = value;
176       }
177     }
178   }
179
180
181   /**
182    * @brief Event arguments that passed via Touch signal
183    *
184    */
185   public class TouchEventArgs : EventArgs
186   {
187      private View _view;
188      private Touch _touch;
189
190     /**
191      * @brief View - is the view that is being touched
192      *
193      */
194     public View View
195     {
196       get
197       {
198         return _view;
199       }
200       set
201       {
202         _view = value;
203       }
204     }
205
206     /**
207      * @brief Touch - contains the information of touch points
208      *
209      */
210     public Touch Touch
211     {
212       get
213       {
214         return _touch;
215       }
216       set
217       {
218         _touch = value;
219       }
220     }
221   }
222
223   /**
224    * @brief Event arguments that passed via Hover signal
225    *
226    */
227   public class HoverEventArgs : EventArgs
228   {
229      private View _view;
230      private Hover _hover;
231
232     /**
233      * @brief View - is the view that is being hovered
234      *
235      */
236     public View View
237     {
238       get
239       {
240         return _view;
241       }
242       set
243       {
244         _view = value;
245       }
246     }
247
248     /**
249      * @brief Hover - contains touch points that represent the points
250      * that are currently being hovered or the points where a hover has stopped
251      *
252      */
253     public Hover Hover
254     {
255       get
256       {
257         return _hover;
258       }
259       set
260       {
261         _hover = value;
262       }
263     }
264   }
265
266   /**
267    * @brief Event arguments that passed via Wheel signal
268    *
269    */
270   public class WheelEventArgs : EventArgs
271   {
272     private View _view;
273     private Wheel _wheel;
274
275     /**
276      * @brief View - is the view that is being wheeled
277      *
278      */
279     public View View
280     {
281       get
282       {
283         return _view;
284       }
285       set
286       {
287         _view = value;
288       }
289     }
290
291     /**
292      * @brief Wheel - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
293      *
294      */
295     public Wheel Wheel
296     {
297       get
298       {
299         return _wheel;
300       }
301       set
302       {
303         _wheel = value;
304       }
305     }
306   }
307
308   /**
309    * @brief Event arguments that passed via OnStage signal
310    *
311    */
312   public class OnStageEventArgs : EventArgs
313   {
314   private View _view;
315
316     /**
317      * @brief View - is the view that is being connected to the stage
318      *
319      */
320     public View View
321     {
322       get
323       {
324         return _view;
325       }
326       set
327       {
328         _view = value;
329       }
330     }
331   }
332
333   /**
334    * @brief Event arguments that passed via OffStage signal
335    *
336    */
337   public class OffStageEventArgs : EventArgs
338   {
339   private View _view;
340
341     /**
342      * @brief View - is the view that is being disconnected from the stage
343      *
344      */
345     public View View
346     {
347       get
348       {
349         return _view;
350       }
351       set
352       {
353         _view = value;
354       }
355     }
356   }
357
358   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
359   private delegate void KeyInputFocusGainedCallbackDelegate(IntPtr control);
360   private DaliEventHandler<object,KeyInputFocusGainedEventArgs> _KeyInputFocusGainedEventHandler;
361   private KeyInputFocusGainedCallbackDelegate _KeyInputFocusGainedCallbackDelegate;
362
363   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
364   private delegate void KeyInputFocusLostCallbackDelegate(IntPtr control);
365   private DaliEventHandler<object,KeyInputFocusLostEventArgs> _KeyInputFocusLostEventHandler;
366   private KeyInputFocusLostCallbackDelegate _KeyInputFocusLostCallbackDelegate;
367
368   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
369   private delegate bool KeyCallbackDelegate(IntPtr control, IntPtr key);
370   private DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> _KeyHandler;
371   private KeyCallbackDelegate _KeyCallbackDelegate;
372
373   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
374   private delegate void OnRelayoutEventCallbackDelegate(IntPtr control);
375   private DaliEventHandler<object,OnRelayoutEventArgs> _viewOnRelayoutEventHandler;
376   private OnRelayoutEventCallbackDelegate _viewOnRelayoutEventCallbackDelegate;
377
378   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
379   private delegate bool TouchCallbackDelegate(IntPtr view, IntPtr touch);
380   private DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> _viewTouchHandler;
381   private TouchCallbackDelegate _viewTouchCallbackDelegate;
382
383   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
384   private delegate bool HoverCallbackDelegate(IntPtr view, IntPtr hover);
385   private DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> _viewHoverHandler;
386   private HoverCallbackDelegate _viewHoverCallbackDelegate;
387
388   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
389   private delegate bool WheelCallbackDelegate(IntPtr view, IntPtr wheel);
390   private DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> _viewWheelHandler;
391   private WheelCallbackDelegate _viewWheelCallbackDelegate;
392
393   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
394   private delegate void OnStageEventCallbackDelegate(IntPtr control);
395   private DaliEventHandler<object,OnStageEventArgs> _viewOnStageEventHandler;
396   private OnStageEventCallbackDelegate _viewOnStageEventCallbackDelegate;
397
398   [UnmanagedFunctionPointer(CallingConvention.StdCall)]
399   private delegate void OffStageEventCallbackDelegate(IntPtr control);
400   private DaliEventHandler<object,OffStageEventArgs> _viewOffStageEventHandler;
401   private OffStageEventCallbackDelegate _viewOffStageEventCallbackDelegate;
402
403   /**
404    * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
405    * (in the type of KeyInputFocusGainedEventHandler-DaliEventHandler<object,KeyInputFocusGainedEventArgs>)
406    * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
407    */
408   public event DaliEventHandler<object,KeyInputFocusGainedEventArgs> KeyInputFocusGained
409   {
410     add
411     {
412       lock(this)
413       {
414         // Restricted to only one listener
415         if (_KeyInputFocusGainedEventHandler == null)
416         {
417           _KeyInputFocusGainedEventHandler += value;
418           Console.WriteLine("View Key EVENT Locked....");
419           _KeyInputFocusGainedCallbackDelegate = new KeyInputFocusGainedCallbackDelegate(OnKeyInputFocusGained);
420           this.KeyInputFocusGainedSignal().Connect(_KeyInputFocusGainedCallbackDelegate);
421         }
422       }
423     }
424
425     remove
426     {
427       lock(this)
428       {
429         if (_KeyInputFocusGainedEventHandler != null)
430         {
431           this.KeyInputFocusGainedSignal().Disconnect(_KeyInputFocusGainedCallbackDelegate);
432         }
433
434         _KeyInputFocusGainedEventHandler -= value;
435       }
436     }
437   }
438
439   private void OnKeyInputFocusGained(IntPtr view)
440   {
441     KeyInputFocusGainedEventArgs e = new KeyInputFocusGainedEventArgs();
442     Console.WriteLine("View Key ....");
443     // Populate all members of "e" (KeyInputFocusGainedEventArgs) with real data
444     e.View = Dali.View.GetViewFromPtr(view);
445
446     if (_KeyInputFocusGainedEventHandler != null)
447     {
448       //here we send all data to user event handlers
449       _KeyInputFocusGainedEventHandler(this, e);
450     }
451
452   }
453
454   /**
455    * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
456    * (in the type of KeyInputFocusLostEventHandler-DaliEventHandler<object,KeyInputFocusLostEventArgs>)
457    * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
458    */
459   public event DaliEventHandler<object,KeyInputFocusLostEventArgs> KeyInputFocusLost
460   {
461     add
462     {
463       lock(this)
464       {
465         // Restricted to only one listener
466         if (_KeyInputFocusLostEventHandler == null)
467         {
468           _KeyInputFocusLostEventHandler += value;
469
470           _KeyInputFocusLostCallbackDelegate = new KeyInputFocusLostCallbackDelegate(OnKeyInputFocusLost);
471           this.KeyInputFocusLostSignal().Connect(_KeyInputFocusLostCallbackDelegate);
472         }
473       }
474     }
475
476     remove
477     {
478       lock(this)
479       {
480         if (_KeyInputFocusLostEventHandler != null)
481         {
482           this.KeyInputFocusLostSignal().Disconnect(_KeyInputFocusLostCallbackDelegate);
483         }
484
485         _KeyInputFocusLostEventHandler -= value;
486       }
487     }
488   }
489
490   private void OnKeyInputFocusLost(IntPtr view)
491   {
492     KeyInputFocusLostEventArgs e = new KeyInputFocusLostEventArgs();
493
494     // Populate all members of "e" (KeyInputFocusLostEventArgs) with real data
495     e.View = Dali.View.GetViewFromPtr(view);
496
497     if (_KeyInputFocusLostEventHandler != null)
498     {
499       //here we send all data to user event handlers
500       _KeyInputFocusLostEventHandler(this, e);
501     }
502   }
503
504   /**
505    * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
506    * (in the type of KeyHandler-DaliEventHandlerWithReturnType<object,KeyEventArgs,bool>)
507    * provided by the user. KeyPressed signal is emitted when key event is received.
508    */
509   public event DaliEventHandlerWithReturnType<object,KeyEventArgs,bool> KeyPressed
510   {
511     add
512     {
513       lock(this)
514       {
515         // Restricted to only one listener
516         if (_KeyHandler == null)
517         {
518           _KeyHandler += value;
519
520           _KeyCallbackDelegate = new KeyCallbackDelegate(OnKey);
521           this.KeyEventSignal().Connect(_KeyCallbackDelegate);
522         }
523       }
524     }
525
526     remove
527     {
528       lock(this)
529       {
530         if (_KeyHandler != null)
531         {
532           this.KeyEventSignal().Disconnect(_KeyCallbackDelegate);
533         }
534
535         _KeyHandler -= value;
536       }
537     }
538   }
539
540   private bool OnKey(IntPtr view, IntPtr key)
541   {
542     KeyEventArgs e = new KeyEventArgs();
543
544     // Populate all members of "e" (KeyEventArgs) with real data
545     e.View = Dali.View.GetViewFromPtr(view);
546     e.Key = Dali.Key.GetKeyFromPtr(key);
547
548     if (_KeyHandler != null)
549     {
550       //here we send all data to user event handlers
551       return _KeyHandler(this, e);
552     }
553     return false;
554
555   }
556
557   /**
558    * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
559    * (in the type of OnRelayoutEventHandler) provided by the user.
560    * OnRelayout signal is emitted after the size has been set on the view during relayout.
561    */
562   public event DaliEventHandler<object,OnRelayoutEventArgs> OnRelayoutEvent
563   {
564     add
565     {
566       lock(this)
567       {
568         // Restricted to only one listener
569         if (_viewOnRelayoutEventHandler == null)
570         {
571           _viewOnRelayoutEventHandler += value;
572           Console.WriteLine("View OnRelayoutEventArgs Locked....");
573           _viewOnRelayoutEventCallbackDelegate = new OnRelayoutEventCallbackDelegate(OnRelayout);
574           this.OnRelayoutSignal().Connect(_viewOnRelayoutEventCallbackDelegate);
575         }
576       }
577     }
578
579     remove
580     {
581       lock(this)
582       {
583         if (_viewOnRelayoutEventHandler != null)
584         {
585           this.OnRelayoutSignal().Disconnect(_viewOnRelayoutEventCallbackDelegate);
586         }
587
588         _viewOnRelayoutEventHandler -= value;
589       }
590     }
591   }
592
593   // Callback for View OnRelayout signal
594   private void OnRelayout(IntPtr data)
595   {
596     OnRelayoutEventArgs e = new OnRelayoutEventArgs();
597     Console.WriteLine("View OnRelayoutEventArgs....");
598     // Populate all members of "e" (OnRelayoutEventArgs) with real data
599     e.View = View.GetViewFromPtr(data);
600
601     if (_viewOnRelayoutEventHandler != null)
602     {
603       //here we send all data to user event handlers
604       _viewOnRelayoutEventHandler(this, e);
605     }
606   }
607
608   /**
609    * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
610    * (in the type of TouchHandler-DaliEventHandlerWithReturnType<object,TouchEventArgs,bool>)
611    * provided by the user. Touched signal is emitted when touch input is received.
612    */
613   public event DaliEventHandlerWithReturnType<object,TouchEventArgs,bool> Touched
614   {
615     add
616     {
617       lock(this)
618       {
619         // Restricted to only one listener
620         if (_viewTouchHandler == null)
621         {
622           _viewTouchHandler += value;
623           Console.WriteLine("View Touch EVENT LOCKED....");
624           _viewTouchCallbackDelegate = new TouchCallbackDelegate(OnTouch);
625           this.TouchSignal().Connect(_viewTouchCallbackDelegate);
626         }
627       }
628     }
629
630     remove
631     {
632       lock(this)
633       {
634         if (_viewTouchHandler != null)
635         {
636           this.TouchSignal().Disconnect(_viewTouchCallbackDelegate);
637         }
638
639         _viewTouchHandler -= value;
640       }
641     }
642   }
643
644   // Callback for View TouchSignal
645   private bool OnTouch(IntPtr view, IntPtr touch)
646   {
647     TouchEventArgs e = new TouchEventArgs();
648     Console.WriteLine("View Touch EVENT....");
649     // Populate all members of "e" (TouchEventArgs) with real data
650     e.View = View.GetViewFromPtr(view);
651     e.Touch = Dali.Touch.GetTouchFromPtr(touch);
652
653     if (_viewTouchHandler != null)
654     {
655       //here we send all data to user event handlers
656       return _viewTouchHandler(this, e);
657     }
658
659     return false;
660   }
661
662   /**
663    * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
664    * (in the type of HoverHandler-DaliEventHandlerWithReturnType<object,HoverEventArgs,bool>)
665    * provided by the user. Hovered signal is emitted when hover input is received.
666    */
667   public event DaliEventHandlerWithReturnType<object,HoverEventArgs,bool> Hovered
668   {
669     add
670     {
671       lock(this)
672       {
673         // Restricted to only one listener
674         if (_viewHoverHandler == null)
675         {
676           _viewHoverHandler += value;
677
678           _viewHoverCallbackDelegate = new HoverCallbackDelegate(OnHover);
679           this.HoveredSignal().Connect(_viewHoverCallbackDelegate);
680         }
681       }
682     }
683
684     remove
685     {
686       lock(this)
687       {
688         if (_viewHoverHandler != null)
689         {
690           this.HoveredSignal().Disconnect(_viewHoverCallbackDelegate);
691         }
692
693         _viewHoverHandler -= value;
694       }
695     }
696   }
697
698   // Callback for View Hover signal
699   private bool OnHover(IntPtr view, IntPtr hover)
700   {
701     HoverEventArgs e = new HoverEventArgs();
702
703     // Populate all members of "e" (HoverEventArgs) with real data
704     e.View = View.GetViewFromPtr(view);
705     e.Hover = Dali.Hover.GetHoverFromPtr(hover);
706
707     if (_viewHoverHandler != null)
708     {
709       //here we send all data to user event handlers
710       return _viewHoverHandler(this, e);
711     }
712
713     return false;
714   }
715
716   /**
717    * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
718    * (in the type of WheelHandler-DaliEventHandlerWithReturnType<object,WheelEventArgs,bool>)
719    * provided by the user. WheelMoved signal is emitted when wheel event is received.
720    */
721   public event DaliEventHandlerWithReturnType<object,WheelEventArgs,bool> WheelMoved
722   {
723     add
724     {
725       lock(this)
726       {
727         // Restricted to only one listener
728         if (_viewWheelHandler == null)
729         {
730           _viewWheelHandler += value;
731           Console.WriteLine("View Wheel EVENT LOCKED....");
732           _viewWheelCallbackDelegate = new WheelCallbackDelegate(OnWheel);
733           this.WheelEventSignal().Connect(_viewWheelCallbackDelegate);
734         }
735       }
736     }
737
738     remove
739     {
740       lock(this)
741       {
742         if (_viewWheelHandler != null)
743         {
744           this.WheelEventSignal().Disconnect(_viewWheelCallbackDelegate);
745         }
746
747         _viewWheelHandler -= value;
748       }
749     }
750   }
751
752   // Callback for View Wheel signal
753   private bool OnWheel(IntPtr view, IntPtr wheel)
754   {
755     WheelEventArgs e = new WheelEventArgs();
756     Console.WriteLine("View Wheel EVENT ....");
757     // Populate all members of "e" (WheelEventArgs) with real data
758     e.View = View.GetViewFromPtr(view);
759     e.Wheel = Dali.Wheel.GetWheelFromPtr(wheel);
760
761     if (_viewWheelHandler != null)
762     {
763       //here we send all data to user event handlers
764       return _viewWheelHandler(this, e);
765     }
766
767     return false;
768   }
769
770   /**
771    * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler
772    * (in the type of OnStageEventHandler) provided by the user.
773    * OnStage signal is emitted after the view has been connected to the stage.
774    */
775   public event DaliEventHandler<object,OnStageEventArgs> OnStageEvent
776   {
777     add
778     {
779       lock(this)
780       {
781         // Restricted to only one listener
782         if (_viewOnStageEventHandler == null)
783         {
784           _viewOnStageEventHandler += value;
785
786           _viewOnStageEventCallbackDelegate = new OnStageEventCallbackDelegate(OnStage);
787           this.OnStageSignal().Connect(_viewOnStageEventCallbackDelegate);
788         }
789       }
790     }
791
792     remove
793     {
794       lock(this)
795       {
796         if (_viewOnStageEventHandler != null)
797         {
798           this.OnStageSignal().Disconnect(_viewOnStageEventCallbackDelegate);
799         }
800
801         _viewOnStageEventHandler -= value;
802       }
803     }
804   }
805
806   // Callback for View OnStage signal
807   private void OnStage(IntPtr data)
808   {
809     OnStageEventArgs e = new OnStageEventArgs();
810
811     // Populate all members of "e" (OnStageEventArgs) with real data
812     e.View = View.GetViewFromPtr(data);
813
814     //Console.WriteLine("############# OnStage()! e.View.Name=" + e.View.Name);
815
816     if (_viewOnStageEventHandler != null)
817     {
818       //here we send all data to user event handlers
819       _viewOnStageEventHandler(this, e);
820     }
821   }
822
823   /**
824    * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler
825    * (in the type of OffStageEventHandler) provided by the user.
826    * OffStage signal is emitted after the view has been disconnected from the stage.
827    */
828   public event DaliEventHandler<object,OffStageEventArgs> OffStageEvent
829   {
830     add
831     {
832       lock(this)
833       {
834         // Restricted to only one listener
835         if (_viewOffStageEventHandler == null)
836         {
837           _viewOffStageEventHandler += value;
838
839           _viewOffStageEventCallbackDelegate = new OffStageEventCallbackDelegate(OffStage);
840           this.OnStageSignal().Connect(_viewOffStageEventCallbackDelegate);
841         }
842       }
843     }
844
845     remove
846     {
847       lock(this)
848       {
849         if (_viewOffStageEventHandler != null)
850         {
851           this.OnStageSignal().Disconnect(_viewOffStageEventCallbackDelegate);
852         }
853
854         _viewOffStageEventHandler -= value;
855       }
856     }
857   }
858
859   // Callback for View OffStage signal
860   private void OffStage(IntPtr data)
861   {
862     OffStageEventArgs e = new OffStageEventArgs();
863
864     // Populate all members of "e" (OffStageEventArgs) with real data
865     e.View = View.GetViewFromPtr(data);
866
867     if (_viewOffStageEventHandler != null)
868     {
869       //here we send all data to user event handlers
870       _viewOffStageEventHandler(this, e);
871     }
872   }
873
874   public static View GetViewFromPtr(global::System.IntPtr cPtr) {
875     View ret = new View(cPtr, false);
876     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
877     return ret;
878   }
879
880   public class Property : global::System.IDisposable {
881     private global::System.Runtime.InteropServices.HandleRef swigCPtr;
882     protected bool swigCMemOwn;
883
884     internal Property(global::System.IntPtr cPtr, bool cMemoryOwn) {
885       swigCMemOwn = cMemoryOwn;
886       swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
887     }
888
889     internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Property obj) {
890       return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
891     }
892
893     ~Property() {
894       Dispose();
895     }
896
897     public virtual void Dispose() {
898       lock(this) {
899         if (swigCPtr.Handle != global::System.IntPtr.Zero) {
900           if (swigCMemOwn) {
901             swigCMemOwn = false;
902             NDalicPINVOKE.delete_View_Property(swigCPtr);
903           }
904           swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
905         }
906         global::System.GC.SuppressFinalize(this);
907       }
908     }
909
910     public static readonly int TOOLTIP = NDalicManualPINVOKE.View_Property_TOOLTIP_get();
911     public static readonly int STATE = NDalicManualPINVOKE.View_Property_STATE_get();
912     public static readonly int SUB_STATE = NDalicManualPINVOKE.View_Property_SUB_STATE_get();
913
914     public Property() : this(NDalicPINVOKE.new_View_Property(), true) {
915       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
916     }
917
918     public static readonly int STYLE_NAME = NDalicPINVOKE.View_Property_STYLE_NAME_get();
919     public static readonly int BACKGROUND_COLOR = NDalicPINVOKE.View_Property_BACKGROUND_COLOR_get();
920     public static readonly int BACKGROUND_IMAGE = NDalicPINVOKE.View_Property_BACKGROUND_IMAGE_get();
921     public static readonly int KEY_INPUT_FOCUS = NDalicPINVOKE.View_Property_KEY_INPUT_FOCUS_get();
922     public static readonly int BACKGROUND = NDalicPINVOKE.View_Property_BACKGROUND_get();
923
924   }
925
926   public class KeyboardFocus : global::System.IDisposable {
927     private global::System.Runtime.InteropServices.HandleRef swigCPtr;
928     protected bool swigCMemOwn;
929
930     internal KeyboardFocus(global::System.IntPtr cPtr, bool cMemoryOwn) {
931       swigCMemOwn = cMemoryOwn;
932       swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
933     }
934
935     internal static global::System.Runtime.InteropServices.HandleRef getCPtr(KeyboardFocus obj) {
936       return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
937     }
938
939     ~KeyboardFocus() {
940       Dispose();
941     }
942
943     public virtual void Dispose() {
944       lock(this) {
945         if (swigCPtr.Handle != global::System.IntPtr.Zero) {
946           if (swigCMemOwn) {
947             swigCMemOwn = false;
948             NDalicPINVOKE.delete_View_KeyboardFocus(swigCPtr);
949           }
950           swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
951         }
952         global::System.GC.SuppressFinalize(this);
953       }
954     }
955
956     public KeyboardFocus() : this(NDalicPINVOKE.new_View_KeyboardFocus(), true) {
957       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
958     }
959
960     public enum Direction {
961       LEFT,
962       RIGHT,
963       UP,
964       DOWN,
965       PAGE_UP,
966       PAGE_DOWN
967     }
968   }
969
970   public View () : this (NDalicPINVOKE.View_New(), true) {
971       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
972
973   }
974   public View(View uiControl) : this(NDalicPINVOKE.new_View__SWIG_1(View.getCPtr(uiControl)), true) {
975     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
976   }
977
978   public View Assign(View handle) {
979     View ret = new View(NDalicPINVOKE.View_Assign(swigCPtr, View.getCPtr(handle)), false);
980     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
981     return ret;
982   }
983
984   private new static View DownCast(BaseHandle handle) {
985     View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);
986     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
987     return ret;
988   }
989
990   public static T DownCast<T>(Actor actor) where T : View
991   {
992       return (T)( ViewRegistry.GetViewFromActor( actor ) );
993   }
994
995   public void SetKeyInputFocus() {
996     NDalicPINVOKE.View_SetKeyInputFocus(swigCPtr);
997     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
998   }
999
1000   public bool HasKeyInputFocus() {
1001     bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
1002     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1003     return ret;
1004   }
1005
1006   public void ClearKeyInputFocus() {
1007     NDalicPINVOKE.View_ClearKeyInputFocus(swigCPtr);
1008     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1009   }
1010
1011   public PinchGestureDetector GetPinchGestureDetector() {
1012     PinchGestureDetector ret = new PinchGestureDetector(NDalicPINVOKE.View_GetPinchGestureDetector(swigCPtr), true);
1013     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1014     return ret;
1015   }
1016
1017   public PanGestureDetector GetPanGestureDetector() {
1018     PanGestureDetector ret = new PanGestureDetector(NDalicPINVOKE.View_GetPanGestureDetector(swigCPtr), true);
1019     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1020     return ret;
1021   }
1022
1023   public TapGestureDetector GetTapGestureDetector() {
1024     TapGestureDetector ret = new TapGestureDetector(NDalicPINVOKE.View_GetTapGestureDetector(swigCPtr), true);
1025     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1026     return ret;
1027   }
1028
1029   public LongPressGestureDetector GetLongPressGestureDetector() {
1030     LongPressGestureDetector ret = new LongPressGestureDetector(NDalicPINVOKE.View_GetLongPressGestureDetector(swigCPtr), true);
1031     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1032     return ret;
1033   }
1034
1035   public void SetStyleName(string styleName) {
1036     NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
1037     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1038   }
1039
1040   public string GetStyleName() {
1041     string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
1042     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1043     return ret;
1044   }
1045
1046   public void SetBackgroundColor(Vector4 color) {
1047     NDalicPINVOKE.View_SetBackgroundColor(swigCPtr, Vector4.getCPtr(color));
1048     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1049   }
1050
1051   public Vector4 GetBackgroundColor() {
1052     Vector4 ret = new Vector4(NDalicPINVOKE.View_GetBackgroundColor(swigCPtr), true);
1053     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1054     return ret;
1055   }
1056
1057   public void SetBackgroundImage(Image image) {
1058     NDalicPINVOKE.View_SetBackgroundImage(swigCPtr, Image.getCPtr(image));
1059     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1060   }
1061
1062   public void ClearBackground() {
1063     NDalicPINVOKE.View_ClearBackground(swigCPtr);
1064     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1065   }
1066
1067   public ControlKeySignal KeyEventSignal() {
1068     ControlKeySignal ret = new ControlKeySignal(NDalicPINVOKE.View_KeyEventSignal(swigCPtr), false);
1069     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1070     return ret;
1071   }
1072
1073   public KeyInputFocusSignal KeyInputFocusGainedSignal() {
1074     KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusGainedSignal(swigCPtr), false);
1075     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1076     return ret;
1077   }
1078
1079   public KeyInputFocusSignal KeyInputFocusLostSignal() {
1080     KeyInputFocusSignal ret = new KeyInputFocusSignal(NDalicPINVOKE.View_KeyInputFocusLostSignal(swigCPtr), false);
1081     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1082     return ret;
1083   }
1084
1085   public View(ViewImpl implementation) : this(NDalicPINVOKE.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true) {
1086     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1087   }
1088
1089   public enum PropertyRange {
1090     PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
1091     CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
1092     CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX+1000
1093   }
1094
1095   public string StyleName
1096   {
1097     get
1098     {
1099       string temp;
1100       GetProperty( View.Property.STYLE_NAME).Get( out temp );
1101       return temp;
1102     }
1103     set
1104     {
1105       SetProperty( View.Property.STYLE_NAME, new Dali.Property.Value( value ) );
1106     }
1107   }
1108
1109   public Vector4 BackgroundColor
1110   {
1111     get
1112     {
1113       Vector4 backgroundColor = new Vector4(0.0f,0.0f,0.0f,0.0f);
1114
1115       Dali.Property.Map background = Background;
1116       int visualType = 0;
1117       background.Find( Dali.Constants.Visual.Property.Type ).Get( ref visualType );
1118       if(visualType == (int)Dali.Constants.Visual.Type.Color)
1119       {
1120         background.Find( Dali.Constants.ColorVisualProperty.MixColor ).Get( backgroundColor );
1121       }
1122
1123       return backgroundColor;
1124     }
1125     set
1126     {
1127       SetProperty( View.Property.BACKGROUND, new Dali.Property.Value( value ) );
1128     }
1129   }
1130
1131   public string BackgroundImage
1132   {
1133     get
1134     {
1135       string backgroundImage = "";
1136
1137       Dali.Property.Map background = Background;
1138       int visualType = 0;
1139       background.Find( Dali.Constants.Visual.Property.Type ).Get( ref visualType );
1140       if(visualType == (int)Dali.Constants.Visual.Type.Image)
1141       {
1142         background.Find( Dali.Constants.ImageVisualProperty.URL ).Get( out backgroundImage );
1143       }
1144
1145       return backgroundImage;
1146     }
1147     set
1148     {
1149       SetProperty( View.Property.BACKGROUND, new Dali.Property.Value( value ) );
1150     }
1151   }
1152
1153   public bool KeyInputFocus
1154   {
1155     get
1156     {
1157       bool temp = false;
1158       GetProperty( View.Property.KEY_INPUT_FOCUS).Get( ref temp );
1159       return temp;
1160     }
1161     set
1162     {
1163       SetProperty( View.Property.KEY_INPUT_FOCUS, new Dali.Property.Value( value ) );
1164     }
1165   }
1166
1167   public Dali.Property.Map Background
1168   {
1169     get
1170     {
1171       Dali.Property.Map temp = new Dali.Property.Map();
1172       GetProperty( View.Property.BACKGROUND).Get(  temp );
1173       return temp;
1174     }
1175     set
1176     {
1177       SetProperty( View.Property.BACKGROUND, new Dali.Property.Value( value ) );
1178     }
1179   }
1180
1181   public string State
1182   {
1183     get
1184     {
1185       string temp;
1186       GetProperty( View.Property.STATE).Get( out temp );
1187       return temp;
1188     }
1189     set
1190     {
1191       SetProperty( View.Property.STATE, new Dali.Property.Value( value ) );
1192     }
1193   }
1194
1195   public string SubState
1196   {
1197     get
1198     {
1199       string temp;
1200       GetProperty( View.Property.SUB_STATE).Get( out temp );
1201       return temp;
1202     }
1203     set
1204     {
1205       SetProperty( View.Property.SUB_STATE, new Dali.Property.Value( value ) );
1206     }
1207   }
1208
1209   public Dali.Property.Map Tooltip
1210   {
1211     get
1212     {
1213       Dali.Property.Map temp = new Dali.Property.Map();
1214       GetProperty( View.Property.TOOLTIP).Get(  temp );
1215       return temp;
1216     }
1217     set
1218     {
1219       SetProperty( View.Property.TOOLTIP, new Dali.Property.Value( value ) );
1220     }
1221   }
1222
1223   public string TooltipText
1224   {
1225     set
1226     {
1227       SetProperty( View.Property.TOOLTIP, new Dali.Property.Value( value ) );
1228     }
1229   }
1230
1231   public float Flex
1232   {
1233     get
1234     {
1235       float temp = 0.0f;
1236       GetProperty( FlexContainer.ChildProperty.FLEX).Get( ref temp );
1237       return temp;
1238     }
1239     set
1240     {
1241       SetProperty( FlexContainer.ChildProperty.FLEX, new Dali.Property.Value( value ) );
1242     }
1243   }
1244
1245   public int AlignSelf
1246   {
1247     get
1248     {
1249       int temp = 0;
1250       GetProperty( FlexContainer.ChildProperty.ALIGN_SELF).Get( ref temp );
1251       return temp;
1252     }
1253     set
1254     {
1255       SetProperty( FlexContainer.ChildProperty.ALIGN_SELF, new Dali.Property.Value( value ) );
1256     }
1257   }
1258
1259   public Vector4 FlexMargin
1260   {
1261     get
1262     {
1263       Vector4 temp = new Vector4(0.0f,0.0f,0.0f,0.0f);
1264       GetProperty( FlexContainer.ChildProperty.FLEX_MARGIN).Get(  temp );
1265       return temp;
1266     }
1267     set
1268     {
1269       SetProperty( FlexContainer.ChildProperty.FLEX_MARGIN, new Dali.Property.Value( value ) );
1270     }
1271   }
1272
1273   public Vector2 CellIndex
1274   {
1275     get
1276     {
1277       Vector2 temp = new Vector2(0.0f,0.0f);
1278       GetProperty( TableView.ChildProperty.CELL_INDEX).Get(  temp );
1279       return temp;
1280     }
1281     set
1282     {
1283       SetProperty( TableView.ChildProperty.CELL_INDEX, new Dali.Property.Value( value ) );
1284     }
1285   }
1286
1287   public float RowSpan
1288   {
1289     get
1290     {
1291       float temp = 0.0f;
1292       GetProperty( TableView.ChildProperty.ROW_SPAN).Get( ref temp );
1293       return temp;
1294     }
1295     set
1296     {
1297       SetProperty( TableView.ChildProperty.ROW_SPAN, new Dali.Property.Value( value ) );
1298     }
1299   }
1300
1301   public float ColumnSpan
1302   {
1303     get
1304     {
1305       float temp = 0.0f;
1306       GetProperty( TableView.ChildProperty.COLUMN_SPAN).Get( ref temp );
1307       return temp;
1308     }
1309     set
1310     {
1311       SetProperty( TableView.ChildProperty.COLUMN_SPAN, new Dali.Property.Value( value ) );
1312     }
1313   }
1314
1315   public string CellHorizontalAlignment
1316   {
1317     get
1318     {
1319       string temp;
1320       GetProperty( TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get( out temp );
1321       return temp;
1322     }
1323     set
1324     {
1325       SetProperty( TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Dali.Property.Value( value ) );
1326     }
1327   }
1328
1329   public string CellVerticalAlignment
1330   {
1331     get
1332     {
1333       string temp;
1334       GetProperty( TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get( out temp );
1335       return temp;
1336     }
1337     set
1338     {
1339       SetProperty( TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Dali.Property.Value( value ) );
1340     }
1341   }
1342 }
1343
1344 }