[NUI] Add _parent in Container (#177)
[platform/core/csapi/tizenfx.git] / src / Tizen.NUI / src / public / UIComponents / Popup.cs
1 /*
2  * Copyright(c) 2017 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17 using System;
18 using System.ComponentModel;
19 using System.Runtime.InteropServices;
20 using Tizen.NUI.BaseComponents;
21
22 namespace Tizen.NUI.UIComponents
23 {
24     /// <summary>
25     /// The Popup widget provides a configurable popup dialog with a built-in layout of three main fields.
26     /// </summary>
27     /// <since_tizen> 3 </since_tizen>
28     public class Popup : View
29     {
30         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
31
32         internal Popup(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Popup_SWIGUpcast(cPtr), cMemoryOwn)
33         {
34             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
35         }
36
37         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Popup obj)
38         {
39             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
40         }
41
42         /// <summary>
43         /// Dispose.
44         /// </summary>
45         /// <param name="type">The dispose type</param>
46         /// <since_tizen> 3 </since_tizen>
47         protected override void Dispose(DisposeTypes type)
48         {
49             if (disposed)
50             {
51                 return;
52             }
53
54             if (type == DisposeTypes.Explicit)
55             {
56                 //Called by User
57                 //Release your own managed resources here.
58                 //You should release all of your own disposable objects here.
59
60             }
61
62             //Release your own unmanaged resources here.
63             //You should not access any managed member here except static instance.
64             //because the execution order of Finalizes is non-deterministic.
65             if (this != null)
66             {
67                 if (_popUpHiddenEventCallbackDelegate != null)
68                 {
69                     HiddenSignal().Disconnect(_popUpHiddenEventCallbackDelegate);
70                 }
71
72                 if (_popUpHidingEventCallbackDelegate != null)
73                 {
74                     HidingSignal().Disconnect(_popUpHidingEventCallbackDelegate);
75                 }
76             }
77
78             if (_popUpShownEventCallbackDelegate != null)
79             {
80                 ShownSignal().Disconnect(_popUpShownEventCallbackDelegate);
81             }
82
83             if (_popUpShowingEventCallbackDelegate != null)
84             {
85                 ShowingSignal().Disconnect(_popUpShowingEventCallbackDelegate);
86             }
87
88             if (_popUpOutsideTouchedEventCallbackDelegate != null)
89             {
90                 this.OutsideTouchedSignal().Disconnect(_popUpOutsideTouchedEventCallbackDelegate);
91             }
92
93             if (swigCPtr.Handle != global::System.IntPtr.Zero)
94             {
95                 if (swigCMemOwn)
96                 {
97                     swigCMemOwn = false;
98                     NDalicPINVOKE.delete_Popup(swigCPtr);
99                 }
100                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
101             }
102
103             base.Dispose(type);
104         }
105
106
107
108
109         /// <summary>
110         /// Event arguments that passed via the OutsideTouchedEvent.
111         /// </summary>
112         /// <since_tizen> 3 </since_tizen>
113         public class TouchedOutsideEventArgs : EventArgs
114         {
115         }
116
117         /// <summary>
118         /// Event arguments that passed via the ShowingEventArgs.
119         /// </summary>
120         /// <since_tizen> 3 </since_tizen>
121         public class ShowingEventArgs : EventArgs
122         {
123         }
124
125         /// <summary>
126         /// Event arguments that passed via the ShownEventArgs.
127         /// </summary>
128         /// <since_tizen> 3 </since_tizen>
129         public class ShownEventArgs : EventArgs
130         {
131         }
132
133         /// <summary>
134         /// Event arguments that passed via the HidingEventArgs.
135         /// </summary>
136         /// <since_tizen> 3 </since_tizen>
137         public class HidingEventArgs : EventArgs
138         {
139         }
140
141         /// <summary>
142         /// Event arguments that passed via the HiddenEventArgs.
143         /// </summary>
144         /// <since_tizen> 3 </since_tizen>
145         public class HiddenEventArgs : EventArgs
146         {
147         }
148
149         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
150         private delegate void OutsideTouchedEventCallbackDelegate();
151         private EventHandler<TouchedOutsideEventArgs> _popUpOutsideTouchedEventHandler;
152         private OutsideTouchedEventCallbackDelegate _popUpOutsideTouchedEventCallbackDelegate;
153
154         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
155         private delegate void ShowingEventCallbackDelegate();
156         private EventHandler<ShowingEventArgs> _popUpShowingEventHandler;
157         private ShowingEventCallbackDelegate _popUpShowingEventCallbackDelegate;
158
159         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
160         private delegate void ShownEventCallbackDelegate();
161         private EventHandler<ShownEventArgs> _popUpShownEventHandler;
162         private ShownEventCallbackDelegate _popUpShownEventCallbackDelegate;
163
164         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
165         private delegate void HidingEventCallbackDelegate();
166         private EventHandler<HidingEventArgs> _popUpHidingEventHandler;
167         private HidingEventCallbackDelegate _popUpHidingEventCallbackDelegate;
168
169         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
170         private delegate void HiddenEventCallbackDelegate();
171         private EventHandler<HiddenEventArgs> _popUpHiddenEventHandler;
172         private HiddenEventCallbackDelegate _popUpHiddenEventCallbackDelegate;
173
174         /// <summary>
175         /// An event is sent when the user has touched outside the dialog.
176         /// </summary>
177         /// <since_tizen> 3 </since_tizen>
178         public event EventHandler<TouchedOutsideEventArgs> TouchedOutside
179         {
180             add
181             {
182                 if (_popUpOutsideTouchedEventHandler == null)
183                 {
184                     _popUpOutsideTouchedEventCallbackDelegate = (OnOutsideTouched);
185                     OutsideTouchedSignal().Connect(_popUpOutsideTouchedEventCallbackDelegate);
186                 }
187                 _popUpOutsideTouchedEventHandler += value;
188             }
189             remove
190             {
191                 _popUpOutsideTouchedEventHandler -= value;
192                 if (_popUpOutsideTouchedEventHandler == null && OutsideTouchedSignal().Empty() == false)
193                 {
194                     this.OutsideTouchedSignal().Disconnect(_popUpOutsideTouchedEventCallbackDelegate);
195                 }
196             }
197         }
198
199         // Callback for Popup OutsideTouchedSignal
200         private void OnOutsideTouched()
201         {
202             TouchedOutsideEventArgs e = new TouchedOutsideEventArgs();
203
204             if (_popUpOutsideTouchedEventHandler != null)
205             {
206                 //here we send all data to user event handlers
207                 _popUpOutsideTouchedEventHandler(this, e);
208             }
209         }
210
211         /// <summary>
212         /// An event is sent when the popup starts showing.
213         /// </summary>
214         /// <since_tizen> 3 </since_tizen>
215         public event EventHandler<ShowingEventArgs> Showing
216         {
217             add
218             {
219                 if (_popUpShowingEventHandler == null)
220                 {
221                     _popUpShowingEventCallbackDelegate = (OnShowing);
222                     ShowingSignal().Connect(_popUpShowingEventCallbackDelegate);
223                 }
224                 _popUpShowingEventHandler += value;
225             }
226             remove
227             {
228                 _popUpShowingEventHandler -= value;
229                 if (_popUpShowingEventHandler == null && ShowingSignal().Empty() == false)
230                 {
231                     ShowingSignal().Disconnect(_popUpShowingEventCallbackDelegate);
232                 }
233             }
234         }
235
236         // Callback for ShowingSignal
237         private void OnShowing()
238         {
239             ShowingEventArgs e = new ShowingEventArgs();
240
241             if (_popUpShowingEventHandler != null)
242             {
243                 //here we send all data to user event handlers
244                 _popUpShowingEventHandler(this, e);
245             }
246         }
247
248
249         /// <summary>
250         /// An event is sent when the popup has been fully displayed.
251         /// </summary>
252         /// <since_tizen> 3 </since_tizen>
253         public event EventHandler<ShownEventArgs> Shown
254         {
255             add
256             {
257                 if (_popUpShownEventHandler == null)
258                 {
259                     _popUpShownEventCallbackDelegate = (OnShown);
260                     ShownSignal().Connect(_popUpShownEventCallbackDelegate);
261                 }
262                 _popUpShownEventHandler += value;
263             }
264             remove
265             {
266                 _popUpShownEventHandler -= value;
267                 if (_popUpShownEventHandler == null && ShownSignal().Empty() == false)
268                 {
269                     ShownSignal().Disconnect(_popUpShownEventCallbackDelegate);
270                 }
271             }
272         }
273
274         // Callback for ShownSignal
275         private void OnShown()
276         {
277             ShownEventArgs e = new ShownEventArgs();
278
279             if (_popUpShownEventHandler != null)
280             {
281                 //here we send all data to user event handlers
282                 _popUpShownEventHandler(this, e);
283             }
284         }
285
286         /// <summary>
287         /// An event is sent when the popup starts to hide.
288         /// </summary>
289         /// <since_tizen> 3 </since_tizen>
290         public event EventHandler<HidingEventArgs> Hiding
291         {
292             add
293             {
294                 if (_popUpHidingEventHandler == null)
295                 {
296                     _popUpHidingEventCallbackDelegate = (OnHiding);
297                     HidingSignal().Connect(_popUpHidingEventCallbackDelegate);
298                 }
299                 _popUpHidingEventHandler += value;
300             }
301             remove
302             {
303                 _popUpHidingEventHandler -= value;
304                 if (_popUpHidingEventHandler == null && HidingSignal().Empty() == false)
305                 {
306                     HidingSignal().Disconnect(_popUpHidingEventCallbackDelegate);
307                 }
308             }
309         }
310
311         // Callback for HidingSignal
312         private void OnHiding()
313         {
314             HidingEventArgs e = new HidingEventArgs();
315
316             if (_popUpHidingEventHandler != null)
317             {
318                 //here we send all data to user event handlers
319                 _popUpHidingEventHandler(this, e);
320             }
321         }
322
323         /// <summary>
324         /// An event is sent when the popup has been completely hidden.
325         /// </summary>
326         /// <since_tizen> 3 </since_tizen>
327         public event EventHandler<HiddenEventArgs> Hidden
328         {
329             add
330             {
331                 if (_popUpHiddenEventHandler == null)
332                 {
333                     _popUpHiddenEventCallbackDelegate = (OnHidden);
334                     HiddenSignal().Connect(_popUpHiddenEventCallbackDelegate);
335                 }
336                 _popUpHiddenEventHandler += value;
337             }
338             remove
339             {
340                 _popUpHiddenEventHandler -= value;
341                 if (_popUpHiddenEventHandler == null && HiddenSignal().Empty() == false)
342                 {
343                     HiddenSignal().Disconnect(_popUpHiddenEventCallbackDelegate);
344                 }
345             }
346         }
347
348         // Callback for HiddenSignal
349         private void OnHidden()
350         {
351             HiddenEventArgs e = new HiddenEventArgs();
352
353             if (_popUpHiddenEventHandler != null)
354             {
355                 //here we send all data to user event handlers
356                 _popUpHiddenEventHandler(this, e);
357             }
358         }
359
360         internal new class Property
361         {
362             internal static readonly int TITLE = NDalicPINVOKE.Popup_Property_TITLE_get();
363             internal static readonly int CONTENT = NDalicPINVOKE.Popup_Property_CONTENT_get();
364             internal static readonly int FOOTER = NDalicPINVOKE.Popup_Property_FOOTER_get();
365             internal static readonly int DISPLAY_STATE = NDalicPINVOKE.Popup_Property_DISPLAY_STATE_get();
366             internal static readonly int TOUCH_TRANSPARENT = NDalicPINVOKE.Popup_Property_TOUCH_TRANSPARENT_get();
367             internal static readonly int TAIL_VISIBILITY = NDalicPINVOKE.Popup_Property_TAIL_VISIBILITY_get();
368             internal static readonly int TAIL_POSITION = NDalicPINVOKE.Popup_Property_TAIL_POSITION_get();
369             internal static readonly int CONTEXTUAL_MODE = NDalicPINVOKE.Popup_Property_CONTEXTUAL_MODE_get();
370             internal static readonly int ANIMATION_DURATION = NDalicPINVOKE.Popup_Property_ANIMATION_DURATION_get();
371             internal static readonly int ANIMATION_MODE = NDalicPINVOKE.Popup_Property_ANIMATION_MODE_get();
372             internal static readonly int ENTRY_ANIMATION = NDalicPINVOKE.Popup_Property_ENTRY_ANIMATION_get();
373             internal static readonly int EXIT_ANIMATION = NDalicPINVOKE.Popup_Property_EXIT_ANIMATION_get();
374             internal static readonly int AUTO_HIDE_DELAY = NDalicPINVOKE.Popup_Property_AUTO_HIDE_DELAY_get();
375             internal static readonly int BACKING_ENABLED = NDalicPINVOKE.Popup_Property_BACKING_ENABLED_get();
376             internal static readonly int BACKING_COLOR = NDalicPINVOKE.Popup_Property_BACKING_COLOR_get();
377             internal static readonly int POPUP_BACKGROUND_IMAGE = NDalicPINVOKE.Popup_Property_POPUP_BACKGROUND_IMAGE_get();
378             internal static readonly int POPUP_BACKGROUND_BORDER = NDalicPINVOKE.Popup_Property_POPUP_BACKGROUND_BORDER_get();
379             internal static readonly int TAIL_UP_IMAGE = NDalicPINVOKE.Popup_Property_TAIL_UP_IMAGE_get();
380             internal static readonly int TAIL_DOWN_IMAGE = NDalicPINVOKE.Popup_Property_TAIL_DOWN_IMAGE_get();
381             internal static readonly int TAIL_LEFT_IMAGE = NDalicPINVOKE.Popup_Property_TAIL_LEFT_IMAGE_get();
382             internal static readonly int TAIL_RIGHT_IMAGE = NDalicPINVOKE.Popup_Property_TAIL_RIGHT_IMAGE_get();
383         }
384
385         /// <summary>
386         /// Creates the popup.
387         /// </summary>
388         /// <since_tizen> 3 </since_tizen>
389         public Popup() : this(NDalicPINVOKE.Popup_New(), true)
390         {
391             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
392
393         }
394
395         /// <summary>
396         /// Sets the title for this popup.
397         /// </summary>
398         /// <param name="titleView">The actor to set the title.</param>
399         /// <since_tizen> 3 </since_tizen>
400         public void SetTitle(View titleView)
401         {
402             NDalicPINVOKE.Popup_SetTitle(swigCPtr, View.getCPtr(titleView));
403             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
404         }
405
406         internal View GetTitle()
407         {
408             View view = new View(NDalicPINVOKE.Popup_GetTitle(swigCPtr), true, true);
409             View ret = Registry.GetManagedBaseHandleFromNativePtr(view) as View;
410
411             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
412             return ret;
413         }
414
415         /// <summary>
416         /// Sets the content actor.
417         /// </summary>
418         /// <param name="content">The actor to use.</param>
419         /// <since_tizen> 3 </since_tizen>
420         public void SetContent(View content)
421         {
422             NDalicPINVOKE.Popup_SetContent(swigCPtr, View.getCPtr(content));
423             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
424         }
425
426         internal View GetContent()
427         {
428             View view = new View(NDalicPINVOKE.Popup_GetContent(swigCPtr), true, true);
429             View ret = Registry.GetManagedBaseHandleFromNativePtr(view) as View;
430
431             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
432             return ret;
433         }
434
435         /// <summary>
436         /// Sets the actor to use for the footer in this popup.
437         /// </summary>
438         /// <param name="footer">The footer actor to be added to this popup.</param>
439         /// <since_tizen> 3 </since_tizen>
440         public void SetFooter(View footer)
441         {
442             NDalicPINVOKE.Popup_SetFooter(swigCPtr, View.getCPtr(footer));
443             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
444         }
445
446         internal View GetFooter()
447         {
448             View view = new View(NDalicPINVOKE.Popup_GetFooter(swigCPtr), true, true);
449             View ret = Registry.GetManagedBaseHandleFromNativePtr(view) as View;
450
451             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
452             return ret;
453         }
454
455         /// <summary>
456         /// Sets the display state of popup.<br />
457         /// There are 4 total display states.<br />
458         /// Only 2 can be set, but all four can be read for better inspection of the current popup state.<br />
459         /// <br />
460         /// The other two states are getable, but not setable, and are there for consistency.<br />
461         /// <br />
462         /// | Value    | Setting the state              | Getting the state              |<br />
463         /// |----------|--------------------------------|--------------------------------|<br />
464         /// | SHOWN    | Show the popup                 | The popup is fully shown       |<br />
465         /// | HIDDEN   | Hide the popup                 | The popup is fully hidden      |<br />
466         /// | SHOWING  |                                | The popup is transitioning in  |<br />
467         /// | HIDING   |                                | The popup is transitioning out |<br />
468         /// <br />
469         /// All 4 states changes cause notifications via 4 respective signals that can be connected to.<br />
470         /// </summary>
471         /// <param name="displayState">The desired display state to change to.</param>
472         /// <since_tizen> 3 </since_tizen>
473         public void SetDisplayState(Popup.DisplayStateType displayState)
474         {
475             NDalicPINVOKE.Popup_SetDisplayState(swigCPtr, (int)displayState);
476             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
477         }
478
479         internal Popup.DisplayStateType GetDisplayState()
480         {
481             Popup.DisplayStateType ret = (Popup.DisplayStateType)NDalicPINVOKE.Popup_GetDisplayState(swigCPtr);
482             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
483             return ret;
484         }
485
486         internal VoidSignal OutsideTouchedSignal()
487         {
488             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Popup_OutsideTouchedSignal(swigCPtr), false);
489             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
490             return ret;
491         }
492
493         internal VoidSignal ShowingSignal()
494         {
495             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Popup_ShowingSignal(swigCPtr), false);
496             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
497             return ret;
498         }
499
500         internal VoidSignal ShownSignal()
501         {
502             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Popup_ShownSignal(swigCPtr), false);
503             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
504             return ret;
505         }
506
507         internal VoidSignal HidingSignal()
508         {
509             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Popup_HidingSignal(swigCPtr), false);
510             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
511             return ret;
512         }
513
514         internal VoidSignal HiddenSignal()
515         {
516             VoidSignal ret = new VoidSignal(NDalicPINVOKE.Popup_HiddenSignal(swigCPtr), false);
517             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
518             return ret;
519         }
520
521         /// <summary>
522         /// The display states of the popup.
523         /// </summary>
524         /// <since_tizen> 3 </since_tizen>
525         public enum DisplayStateType
526         {
527             /// <summary>
528             /// The popup is transitioning in
529             /// </summary>
530             /// <since_tizen> 3 </since_tizen>
531             Showing,
532             /// <summary>
533             /// The popup is fully shown
534             /// </summary>
535             /// <since_tizen> 3 </since_tizen>
536             Shown,
537             /// <summary>
538             /// The popup is transitioning out
539             /// </summary>
540             /// <since_tizen> 3 </since_tizen>
541             Hiding,
542             /// <summary>
543             /// The popup is fully hidden
544             /// </summary>
545             /// <since_tizen> 3 </since_tizen>
546             Hidden
547         }
548
549         /// <summary>
550         /// The animation modes within the popup.<br />
551         /// Choose from a predefined mode or "CUSTOM" to use the ANIMATION_IN and ANIMATION_OUT properties.<br />
552         /// </summary>
553         /// <since_tizen> 3 </since_tizen>
554         public enum AnimationModeType
555         {
556             /// <summary>
557             /// No animation.
558             /// </summary>
559             /// <since_tizen> 3 </since_tizen>
560             None,
561             /// <summary>
562             /// Popup zooms in and out animating the scale property.
563             /// </summary>
564             /// <since_tizen> 3 </since_tizen>
565             Zoom,
566             /// <summary>
567             /// Popup fades in and out
568             /// </summary>
569             /// <since_tizen> 3 </since_tizen>
570             Fade,
571             /// <summary>
572             /// Use the EntryAnimation and ExitAnimation animation properties.
573             /// </summary>
574             /// <since_tizen> 3 </since_tizen>
575             Custom
576         }
577
578         /// <summary>
579         /// The types of the contextual layout.<br />
580         /// The popup is positioned adjacent to it's parent in the direction specified by this mode.<br />
581         /// NON_CONTEXTUAL disables any contextual positioning.<br />
582         /// </summary>
583         /// <since_tizen> 3 </since_tizen>
584         public enum ContextualModeType
585         {
586             /// <summary>
587             /// any contextual positioning
588             /// </summary>
589             /// <since_tizen> 3 </since_tizen>
590             NonContextual,
591             /// <summary>
592             /// Above
593             /// </summary>
594             /// <since_tizen> 3 </since_tizen>
595             Above,
596             /// <summary>
597             /// Rright
598             /// </summary>
599             /// <since_tizen> 3 </since_tizen>
600             Rright,
601             /// <summary>
602             /// Below
603             /// </summary>
604             /// <since_tizen> 3 </since_tizen>
605             Below,
606             /// <summary>
607             /// Left
608             /// </summary>
609             /// <since_tizen> 3 </since_tizen>
610             Left
611         }
612
613         /// <summary>
614         /// The popup title.
615         /// </summary>
616         /// <since_tizen> 3 </since_tizen>
617         public PropertyMap Title
618         {
619             get
620             {
621                 PropertyMap temp = new PropertyMap();
622                 GetProperty(Popup.Property.TITLE).Get(temp);
623                 return temp;
624             }
625             set
626             {
627                 SetProperty(Popup.Property.TITLE, new Tizen.NUI.PropertyValue(value));
628             }
629         }
630         /// <summary>
631         /// The popup content.
632         /// </summary>
633         /// <since_tizen> 3 </since_tizen>
634         public PropertyMap Content
635         {
636             get
637             {
638                 PropertyMap temp = new PropertyMap();
639                 GetProperty(Popup.Property.CONTENT).Get(temp);
640                 return temp;
641             }
642             set
643             {
644                 SetProperty(Popup.Property.CONTENT, new Tizen.NUI.PropertyValue(value));
645             }
646         }
647         /// <summary>
648         /// The popup footer.
649         /// </summary>
650         /// <since_tizen> 3 </since_tizen>
651         public PropertyMap Footer
652         {
653             get
654             {
655                 PropertyMap temp = new PropertyMap();
656                 GetProperty(Popup.Property.FOOTER).Get(temp);
657                 return temp;
658             }
659             set
660             {
661                 SetProperty(Popup.Property.FOOTER, new Tizen.NUI.PropertyValue(value));
662             }
663         }
664         /// <summary>
665         /// The popup display state.
666         /// </summary>
667         /// <since_tizen> 3 </since_tizen>
668         public DisplayStateType DisplayState
669         {
670             get
671             {
672                 string temp;
673                 if (GetProperty(Popup.Property.DISPLAY_STATE).Get(out temp) == false)
674                 {
675                     NUILog.Error("DisplayState get error!");
676                 }
677                 switch (temp)
678                 {
679                     case "SHOWING":
680                         return DisplayStateType.Showing;
681                     case "SHOWN":
682                         return DisplayStateType.Shown;
683                     case "HIDING":
684                         return DisplayStateType.Hiding;
685                     case "HIDDEN":
686                         return DisplayStateType.Hidden;
687                     default:
688                         return DisplayStateType.Hidden;
689                 }
690             }
691             set
692             {
693                 string valueToString = "";
694                 switch (value)
695                 {
696                     case DisplayStateType.Showing:
697                         {
698                             valueToString = "SHOWING";
699                             break;
700                         }
701                     case DisplayStateType.Shown:
702                         {
703                             valueToString = "SHOWN";
704                             break;
705                         }
706                     case DisplayStateType.Hiding:
707                         {
708                             valueToString = "HIDING";
709                             break;
710                         }
711                     case DisplayStateType.Hidden:
712                         {
713                             valueToString = "HIDDEN";
714                             break;
715                         }
716                     default:
717                         {
718                             valueToString = "HIDDEN";
719                             break;
720                         }
721                 }
722                 SetProperty(Popup.Property.DISPLAY_STATE, new Tizen.NUI.PropertyValue(valueToString));
723             }
724         }
725         /// <summary>
726         /// The touch transparent.
727         /// </summary>
728         /// <since_tizen> 3 </since_tizen>
729         public bool TouchTransparent
730         {
731             get
732             {
733                 bool temp = false;
734                 GetProperty(Popup.Property.TOUCH_TRANSPARENT).Get(out temp);
735                 return temp;
736             }
737             set
738             {
739                 SetProperty(Popup.Property.TOUCH_TRANSPARENT, new Tizen.NUI.PropertyValue(value));
740             }
741         }
742         /// <summary>
743         /// The popup tail visibility.
744         /// </summary>
745         /// <since_tizen> 3 </since_tizen>
746         public bool TailVisibility
747         {
748             get
749             {
750                 bool temp = false;
751                 GetProperty(Popup.Property.TAIL_VISIBILITY).Get(out temp);
752                 return temp;
753             }
754             set
755             {
756                 SetProperty(Popup.Property.TAIL_VISIBILITY, new Tizen.NUI.PropertyValue(value));
757             }
758         }
759         /// <summary>
760         /// The popup tail position.
761         /// </summary>
762         /// <since_tizen> 3 </since_tizen>
763         public Vector3 TailPosition
764         {
765             get
766             {
767                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
768                 GetProperty(Popup.Property.TAIL_POSITION).Get(temp);
769                 return temp;
770             }
771             set
772             {
773                 SetProperty(Popup.Property.TAIL_POSITION, new Tizen.NUI.PropertyValue(value));
774             }
775         }
776         /// <summary>
777         /// The contextual mode.
778         /// </summary>
779         /// <since_tizen> 3 </since_tizen>
780         public ContextualModeType ContextualMode
781         {
782             get
783             {
784                 string temp;
785                 if (GetProperty(Popup.Property.CONTEXTUAL_MODE).Get(out temp) == false)
786                 {
787                     NUILog.Error("ContextualMode get error!");
788                 }
789                 switch (temp)
790                 {
791                     case "NON_CONTEXTUAL":
792                         return ContextualModeType.NonContextual;
793                     case "ABOVE":
794                         return ContextualModeType.Above;
795                     case "RIGHT":
796                         return ContextualModeType.Rright;
797                     case "BELOW":
798                         return ContextualModeType.Below;
799                     case "LEFT":
800                         return ContextualModeType.Left;
801                     default:
802                         return ContextualModeType.Below;
803                 }
804             }
805             set
806             {
807                 string valueToString = "";
808                 switch (value)
809                 {
810                     case ContextualModeType.NonContextual:
811                         {
812                             valueToString = "NON_CONTEXTUAL";
813                             break;
814                         }
815                     case ContextualModeType.Above:
816                         {
817                             valueToString = "ABOVE";
818                             break;
819                         }
820                     case ContextualModeType.Rright:
821                         {
822                             valueToString = "RIGHT";
823                             break;
824                         }
825                     case ContextualModeType.Below:
826                         {
827                             valueToString = "BELOW";
828                             break;
829                         }
830                     case ContextualModeType.Left:
831                         {
832                             valueToString = "LEFT";
833                             break;
834                         }
835                     default:
836                         {
837                             valueToString = "BELOW";
838                             break;
839                         }
840                 }
841                 SetProperty(Popup.Property.CONTEXTUAL_MODE, new Tizen.NUI.PropertyValue(valueToString));
842             }
843         }
844         /// <summary>
845         /// The animation duration.
846         /// </summary>
847         /// <since_tizen> 3 </since_tizen>
848         public float AnimationDuration
849         {
850             get
851             {
852                 float temp = 0.0f;
853                 GetProperty(Popup.Property.ANIMATION_DURATION).Get(out temp);
854                 return temp;
855             }
856             set
857             {
858                 SetProperty(Popup.Property.ANIMATION_DURATION, new Tizen.NUI.PropertyValue(value));
859             }
860         }
861         /// <summary>
862         /// The animation mode.
863         /// </summary>
864         /// <since_tizen> 3 </since_tizen>
865         public AnimationModeType AnimationMode
866         {
867             get
868             {
869                 string temp;
870                 if (GetProperty(Popup.Property.ANIMATION_MODE).Get(out temp) == false)
871                 {
872                     NUILog.Error("AnimationMode get error!");
873                 }
874                 switch (temp)
875                 {
876                     case "NONE":
877                         return AnimationModeType.None;
878                     case "ZOOM":
879                         return AnimationModeType.Zoom;
880                     case "FADE":
881                         return AnimationModeType.Fade;
882                     case "CUSTOM":
883                         return AnimationModeType.Custom;
884                     default:
885                         return AnimationModeType.Fade;
886                 }
887             }
888             set
889             {
890                 string valueToString = "";
891                 switch (value)
892                 {
893                     case AnimationModeType.None:
894                         {
895                             valueToString = "NONE";
896                             break;
897                         }
898                     case AnimationModeType.Zoom:
899                         {
900                             valueToString = "ZOOM";
901                             break;
902                         }
903                     case AnimationModeType.Fade:
904                         {
905                             valueToString = "FADE";
906                             break;
907                         }
908                     case AnimationModeType.Custom:
909                         {
910                             valueToString = "CUSTOM";
911                             break;
912                         }
913                     default:
914                         {
915                             valueToString = "FADE";
916                             break;
917                         }
918                 }
919                 SetProperty(Popup.Property.ANIMATION_MODE, new Tizen.NUI.PropertyValue(valueToString));
920             }
921         }
922         /// <summary>
923         /// The entry animation.
924         /// </summary>
925         /// <since_tizen> 3 </since_tizen>
926         public PropertyMap EntryAnimation
927         {
928             get
929             {
930                 PropertyMap temp = new PropertyMap();
931                 GetProperty(Popup.Property.ENTRY_ANIMATION).Get(temp);
932                 return temp;
933             }
934             set
935             {
936                 SetProperty(Popup.Property.ENTRY_ANIMATION, new Tizen.NUI.PropertyValue(value));
937             }
938         }
939         /// <summary>
940         /// The exit animation.
941         /// </summary>
942         /// <since_tizen> 3 </since_tizen>
943         public PropertyMap ExitAnimation
944         {
945             get
946             {
947                 PropertyMap temp = new PropertyMap();
948                 GetProperty(Popup.Property.EXIT_ANIMATION).Get(temp);
949                 return temp;
950             }
951             set
952             {
953                 SetProperty(Popup.Property.EXIT_ANIMATION, new Tizen.NUI.PropertyValue(value));
954             }
955         }
956         /// <summary>
957         /// The auto hide delay.
958         /// </summary>
959         /// <since_tizen> 3 </since_tizen>
960         public int AutoHideDelay
961         {
962             get
963             {
964                 int temp = 0;
965                 GetProperty(Popup.Property.AUTO_HIDE_DELAY).Get(out temp);
966                 return temp;
967             }
968             set
969             {
970                 SetProperty(Popup.Property.AUTO_HIDE_DELAY, new Tizen.NUI.PropertyValue(value));
971             }
972         }
973         /// <summary>
974         /// The backing enabled.
975         /// </summary>
976         /// <since_tizen> 3 </since_tizen>
977         public bool BackingEnabled
978         {
979             get
980             {
981                 bool temp = false;
982                 GetProperty(Popup.Property.BACKING_ENABLED).Get(out temp);
983                 return temp;
984             }
985             set
986             {
987                 SetProperty(Popup.Property.BACKING_ENABLED, new Tizen.NUI.PropertyValue(value));
988             }
989         }
990         /// <summary>
991         /// The backing color.
992         /// </summary>
993         /// <since_tizen> 3 </since_tizen>
994         public Vector4 BackingColor
995         {
996             get
997             {
998                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
999                 GetProperty(Popup.Property.BACKING_COLOR).Get(temp);
1000                 return temp;
1001             }
1002             set
1003             {
1004                 SetProperty(Popup.Property.BACKING_COLOR, new Tizen.NUI.PropertyValue(value));
1005             }
1006         }
1007         /// <summary>
1008         /// The background image.
1009         /// </summary>
1010         /// <since_tizen> 3 </since_tizen>
1011         public string PopupBackgroundImage
1012         {
1013             get
1014             {
1015                 string temp;
1016                 GetProperty(Popup.Property.POPUP_BACKGROUND_IMAGE).Get(out temp);
1017                 return temp;
1018             }
1019             set
1020             {
1021                 SetProperty(Popup.Property.POPUP_BACKGROUND_IMAGE, new Tizen.NUI.PropertyValue(value));
1022             }
1023         }
1024         /// <summary>
1025         /// The background border.
1026         /// </summary>
1027         /// <since_tizen> 3 </since_tizen>
1028         public Rectangle PopupBackgroundBorder
1029         {
1030             get
1031             {
1032                 Rectangle temp = new Rectangle(0, 0, 0, 0);
1033                 GetProperty(Popup.Property.POPUP_BACKGROUND_BORDER).Get(temp);
1034                 return temp;
1035             }
1036             set
1037             {
1038                 SetProperty(Popup.Property.POPUP_BACKGROUND_BORDER, new Tizen.NUI.PropertyValue(value));
1039             }
1040         }
1041         /// <summary>
1042         /// The tail up image.
1043         /// </summary>
1044         /// <since_tizen> 3 </since_tizen>
1045         public string TailUpImage
1046         {
1047             get
1048             {
1049                 string temp;
1050                 GetProperty(Popup.Property.TAIL_UP_IMAGE).Get(out temp);
1051                 return temp;
1052             }
1053             set
1054             {
1055                 SetProperty(Popup.Property.TAIL_UP_IMAGE, new Tizen.NUI.PropertyValue(value));
1056             }
1057         }
1058         /// <summary>
1059         /// The tail down image.
1060         /// </summary>
1061         /// <since_tizen> 3 </since_tizen>
1062         public string TailDownImage
1063         {
1064             get
1065             {
1066                 string temp;
1067                 GetProperty(Popup.Property.TAIL_DOWN_IMAGE).Get(out temp);
1068                 return temp;
1069             }
1070             set
1071             {
1072                 SetProperty(Popup.Property.TAIL_DOWN_IMAGE, new Tizen.NUI.PropertyValue(value));
1073             }
1074         }
1075         /// <summary>
1076         /// The tail left image.
1077         /// </summary>
1078         /// <since_tizen> 3 </since_tizen>
1079         public string TailLeftImage
1080         {
1081             get
1082             {
1083                 string temp;
1084                 GetProperty(Popup.Property.TAIL_LEFT_IMAGE).Get(out temp);
1085                 return temp;
1086             }
1087             set
1088             {
1089                 SetProperty(Popup.Property.TAIL_LEFT_IMAGE, new Tizen.NUI.PropertyValue(value));
1090             }
1091         }
1092         /// <summary>
1093         /// The tail right image.
1094         /// </summary>
1095         /// <since_tizen> 3 </since_tizen>
1096         public string TailRightImage
1097         {
1098             get
1099             {
1100                 string temp;
1101                 GetProperty(Popup.Property.TAIL_RIGHT_IMAGE).Get(out temp);
1102                 return temp;
1103             }
1104             set
1105             {
1106                 SetProperty(Popup.Property.TAIL_RIGHT_IMAGE, new Tizen.NUI.PropertyValue(value));
1107             }
1108         }
1109
1110     }
1111
1112 }