Merge "C# CustomView Implementation (C++ wrappers, manual bindings, C# wrappers)...
[platform/core/uifw/dali-toolkit.git] / plugins / dali-swig / automatic / csharp / Application.cs
1 //------------------------------------------------------------------------------
2 // <auto-generated />
3 //
4 // This file was automatically generated by SWIG (http://www.swig.org).
5 // Version 3.0.9
6 //
7 // Do not make changes to this file unless you know what you are doing--modify
8 // the SWIG interface file instead.
9 //------------------------------------------------------------------------------
10
11 namespace Dali {
12
13     using System;
14     using System.Runtime.InteropServices;
15
16     /**
17       * @brief Event arguments that passed via AUIApplicationInit signal
18       *
19       */
20     public class AUIApplicationInitEventArgs : EventArgs
21     {
22     private Application _application;
23
24       /**
25         * @brief Application - is the application that is being initialized
26         *
27         */
28     public Application Application
29       {
30         get
31         {
32           return _application;
33         }
34         set
35         {
36           _application = value;
37         }
38       }
39     }
40
41     /**
42       * @brief Event arguments that passed via AUIApplicationTerminate signal
43       *
44       */
45     public class AUIApplicationTerminateEventArgs : EventArgs
46     {
47     private Application _application;
48       /**
49         * @brief Application - is the application that is being Terminated
50         *
51         */
52     public Application Application
53       {
54         get
55         {
56           return _application;
57         }
58         set
59         {
60           _application = value;
61         }
62       }
63     }
64
65     /**
66       * @brief Event arguments that passed via AUIApplicationPause signal
67       *
68       */
69     public class AUIApplicationPauseEventArgs : EventArgs
70     {
71     private Application _application;
72       /**
73         * @brief Application - is the application that is being Paused
74         *
75         */
76     public Application Application
77       {
78         get
79         {
80           return _application;
81         }
82         set
83         {
84           _application = value;
85         }
86       }
87     }
88
89     /**
90       * @brief Event arguments that passed via AUIApplicationResume signal
91       *
92       */
93     public class AUIApplicationResumeEventArgs : EventArgs
94     {
95     private Application _application;
96       /**
97         * @brief Application - is the application that is being Resumed
98         *
99         */
100     public Application Application
101       {
102         get
103         {
104           return _application;
105         }
106         set
107         {
108           _application = value;
109         }
110       }
111     }
112
113     /**
114       * @brief Event arguments that passed via AUIApplicationReset signal
115       *
116       */
117     public class AUIApplicationResetEventArgs : EventArgs
118     {
119     private Application _application;
120       /**
121         * @brief Application - is the application that is being Reset
122         *
123         */
124     public Application Application
125       {
126         get
127         {
128           return _application;
129         }
130         set
131         {
132           _application = value;
133         }
134       }
135     }
136
137     /**
138       * @brief Event arguments that passed via AUIApplicationResize signal
139       *
140       */
141     public class AUIApplicationResizeEventArgs : EventArgs
142     {
143     private Application _application;
144       /**
145         * @brief Application - is the application that is being Resized
146         *
147         */
148     public Application Application
149       {
150         get
151         {
152           return _application;
153         }
154         set
155         {
156           _application = value;
157         }
158       }
159     }
160
161     /**
162       * @brief Event arguments that passed via AUIApplicationLanguageChanged signal
163       *
164       */
165     public class AUIApplicationLanguageChangedEventArgs : EventArgs
166     {
167     private Application _application;
168       /**
169         * @brief Application - is the application that is being affected with Device's language change
170         *
171         */
172     public Application Application
173       {
174         get
175         {
176           return _application;
177         }
178         set
179         {
180           _application = value;
181         }
182       }
183     }
184
185     /**
186       * @brief Event arguments that passed via AUIApplicationRegionChanged signal
187       *
188       */
189     public class AUIApplicationRegionChangedEventArgs : EventArgs
190     {
191     private Application _application;
192       /**
193         * @brief Application - is the application that is being affected with Device's region change
194         *
195         */
196     public Application Application
197       {
198         get
199         {
200           return _application;
201         }
202         set
203         {
204           _application = value;
205         }
206       }
207     }
208
209     /**
210       * @brief Event arguments that passed via AUIApplicationBatteryLow signal
211       *
212       */
213     public class AUIApplicationBatteryLowEventArgs : EventArgs
214     {
215     private Application _application;
216       /**
217         * @brief Application - is the application that is being affected when the battery level of the device is low
218         *
219         */
220     public Application Application
221       {
222         get
223         {
224           return _application;
225         }
226         set
227         {
228           _application = value;
229         }
230       }
231     }
232
233     /**
234       * @brief Event arguments that passed via AUIApplicationMemoryLow signal
235       *
236       */
237     public class AUIApplicationMemoryLowEventArgs : EventArgs
238     {
239     private Application _application;
240       /**
241         * @brief Application - is the application that is being affected when the memory level of the device is low
242         *
243         */
244     public Application Application
245       {
246         get
247         {
248           return _application;
249         }
250         set
251         {
252           _application = value;
253         }
254       }
255     }
256
257     /**
258       * @brief Event arguments that passed via AUIApplicationAppControl  signal
259       *
260       */
261     public class AUIApplicationAppControlEventArgs : EventArgs
262     {
263     private Application _application;
264     private IntPtr _voidp;
265       /**
266         * @brief Application - is the application that is receiving the launch request from another application
267         *
268         */
269     public Application Application
270       {
271         get
272         {
273           return _application;
274         }
275         set
276         {
277           _application = value;
278         }
279       }
280       /**
281         * @brief VoidP - contains the information about why the application is launched
282         *
283         */
284     public IntPtr VoidP
285       {
286         get
287         {
288           return _voidp;
289         }
290         set
291         {
292           _voidp = value;
293         }
294       }
295     }
296
297 public class Application : BaseHandle {
298   private global::System.Runtime.InteropServices.HandleRef swigCPtr;
299
300   internal Application(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Application_SWIGUpcast(cPtr), cMemoryOwn) {
301     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
302   }
303
304   internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Application obj) {
305     return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
306   }
307
308   ~Application() {
309     Dispose();
310   }
311
312   public override void Dispose() {
313     lock(this) {
314       if (swigCPtr.Handle != global::System.IntPtr.Zero) {
315         if (swigCMemOwn) {
316           swigCMemOwn = false;
317           NDalicPINVOKE.delete_Application(swigCPtr);
318         }
319         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
320       }
321       global::System.GC.SuppressFinalize(this);
322       base.Dispose();
323     }
324   }
325
326     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
327     private delegate void AUIApplicationInitEventCallbackDelegate(IntPtr application);
328     private DaliEventHandler<object,AUIApplicationInitEventArgs> _applicationInitEventHandler;
329     private AUIApplicationInitEventCallbackDelegate _applicationInitEventCallbackDelegate;
330
331
332     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
333     private delegate void AUIApplicationTerminateEventCallbackDelegate(IntPtr application);
334     private DaliEventHandler<object,AUIApplicationTerminateEventArgs> _applicationTerminateEventHandler;
335     private AUIApplicationTerminateEventCallbackDelegate _applicationTerminateEventCallbackDelegate;
336
337
338     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
339     private delegate void AUIApplicationPauseEventCallbackDelegate(IntPtr application);
340     private DaliEventHandler<object,AUIApplicationPauseEventArgs> _applicationPauseEventHandler;
341     private AUIApplicationPauseEventCallbackDelegate _applicationPauseEventCallbackDelegate;
342
343     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
344     private delegate void AUIApplicationResumeEventCallbackDelegate(IntPtr application);
345     private DaliEventHandler<object,AUIApplicationResumeEventArgs> _applicationResumeEventHandler;
346     private AUIApplicationResumeEventCallbackDelegate _applicationResumeEventCallbackDelegate;
347
348     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
349     private delegate void AUIApplicationResetEventCallbackDelegate(IntPtr application);
350     private DaliEventHandler<object,AUIApplicationResetEventArgs> _applicationResetEventHandler;
351     private AUIApplicationResetEventCallbackDelegate _applicationResetEventCallbackDelegate;
352
353     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
354     private delegate void AUIApplicationResizeEventCallbackDelegate(IntPtr application);
355     private DaliEventHandler<object,AUIApplicationResizeEventArgs> _applicationResizeEventHandler;
356     private AUIApplicationResizeEventCallbackDelegate _applicationResizeEventCallbackDelegate;
357
358     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
359     private delegate void AUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
360     private DaliEventHandler<object,AUIApplicationLanguageChangedEventArgs> _applicationLanguageChangedEventHandler;
361     private AUIApplicationLanguageChangedEventCallbackDelegate _applicationLanguageChangedEventCallbackDelegate;
362
363
364     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
365     private delegate void AUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
366     private DaliEventHandler<object,AUIApplicationRegionChangedEventArgs> _applicationRegionChangedEventHandler;
367     private AUIApplicationRegionChangedEventCallbackDelegate _applicationRegionChangedEventCallbackDelegate;
368
369     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
370     private delegate void AUIApplicationBatteryLowEventCallbackDelegate(IntPtr application);
371     private DaliEventHandler<object,AUIApplicationBatteryLowEventArgs> _applicationBatteryLowEventHandler;
372     private AUIApplicationBatteryLowEventCallbackDelegate _applicationBatteryLowEventCallbackDelegate;
373
374     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
375     private delegate void AUIApplicationMemoryLowEventCallbackDelegate(IntPtr application);
376     private DaliEventHandler<object,AUIApplicationMemoryLowEventArgs> _applicationMemoryLowEventHandler;
377     private AUIApplicationMemoryLowEventCallbackDelegate _applicationMemoryLowEventCallbackDelegate;
378
379     [UnmanagedFunctionPointer(CallingConvention.StdCall)]
380     private delegate void AUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
381     private DaliEventHandler<object,AUIApplicationAppControlEventArgs> _applicationAppControlEventHandler;
382     private AUIApplicationAppControlEventCallbackDelegate _applicationAppControlEventCallbackDelegate;
383
384     /**
385       * @brief Event for Initialized signal which can be used to subscribe/unsubscribe the event handler
386       * (in the type of AUIApplicationInitEventHandler - DaliEventHandler<object,AUIApplicationInitEventArgs>)
387       *  provided by the user. Initialized signal is emitted when application is initialised
388       */
389     public event DaliEventHandler<object,AUIApplicationInitEventArgs> Initialized
390     {
391       add
392       {
393         lock(this)
394         {
395           // Restricted to only one listener
396           if (_applicationInitEventHandler == null)
397           {
398             _applicationInitEventHandler += value;
399
400             _applicationInitEventCallbackDelegate = new AUIApplicationInitEventCallbackDelegate(OnApplicationInit);
401             this.InitSignal().Connect(_applicationInitEventCallbackDelegate);
402           }
403         }
404       }
405
406       remove
407       {
408         lock(this)
409         {
410           if (_applicationInitEventHandler != null)
411           {
412             this.InitSignal().Disconnect(_applicationInitEventCallbackDelegate);
413           }
414
415           _applicationInitEventHandler -= value;
416         }
417       }
418     }
419
420     // Callback for Application InitSignal
421     private void OnApplicationInit(IntPtr data)
422     {
423       AUIApplicationInitEventArgs e = new AUIApplicationInitEventArgs();
424
425       // Populate all members of "e" (AUIApplicationInitEventArgs) with real data
426       e.Application = Application.GetApplicationFromPtr(data);
427
428       if (_applicationInitEventHandler != null)
429       {
430         //here we send all data to user event handlers
431         _applicationInitEventHandler(this, e);
432       }
433     }
434
435     /**
436       * @brief Event for Terminated signal which can be used to subscribe/unsubscribe the event handler
437       * (in the type of AUIApplicationTerminateEventHandler-DaliEventHandler<object,AUIApplicationTerminateEventArgs>)
438       *  provided by the user. Terminated signal is emitted when application is terminated
439       */
440     public event DaliEventHandler<object,AUIApplicationTerminateEventArgs> Terminated
441     {
442       add
443       {
444         lock(this)
445         {
446           // Restricted to only one listener
447           if (_applicationTerminateEventHandler == null)
448           {
449             _applicationTerminateEventHandler += value;
450
451             _applicationTerminateEventCallbackDelegate = new AUIApplicationTerminateEventCallbackDelegate(OnAUIApplicationTerminate);
452             this.TerminateSignal().Connect(_applicationTerminateEventCallbackDelegate);
453           }
454         }
455       }
456
457       remove
458       {
459         lock(this)
460         {
461           if (_applicationTerminateEventHandler != null)
462           {
463             this.TerminateSignal().Disconnect(_applicationTerminateEventCallbackDelegate);
464           }
465
466           _applicationTerminateEventHandler -= value;
467         }
468       }
469     }
470
471     // Callback for Application TerminateSignal
472     private void OnAUIApplicationTerminate(IntPtr data)
473     {
474       AUIApplicationTerminateEventArgs e = new AUIApplicationTerminateEventArgs();
475
476       // Populate all members of "e" (AUIApplicationTerminateEventArgs) with real data
477       e.Application = Application.GetApplicationFromPtr(data);
478
479       if (_applicationTerminateEventHandler != null)
480       {
481         //here we send all data to user event handlers
482         _applicationTerminateEventHandler(this, e);
483       }
484     }
485
486     /**
487       * @brief Event for Paused signal which can be used to subscribe/unsubscribe the event handler
488       * (in the type of AUIApplicationPauseEventHandler-DaliEventHandler<object,AUIApplicationPauseEventArgs>)
489       * provided by the user. Paused signal is emitted when application is paused
490       */
491     public event DaliEventHandler<object,AUIApplicationPauseEventArgs> Paused
492     {
493       add
494       {
495         lock(this)
496         {
497           // Restricted to only one listener
498           if (_applicationPauseEventHandler == null)
499           {
500             _applicationPauseEventHandler += value;
501
502             _applicationPauseEventCallbackDelegate = new AUIApplicationPauseEventCallbackDelegate(OnAUIApplicationPause);
503             this.PauseSignal().Connect(_applicationPauseEventCallbackDelegate);
504           }
505         }
506       }
507
508       remove
509       {
510         lock(this)
511         {
512           if (_applicationPauseEventHandler != null)
513           {
514             this.PauseSignal().Disconnect(_applicationPauseEventCallbackDelegate);
515           }
516
517           _applicationPauseEventHandler -= value;
518         }
519       }
520     }
521
522     // Callback for Application PauseSignal
523     private void OnAUIApplicationPause(IntPtr data)
524     {
525       AUIApplicationPauseEventArgs e = new AUIApplicationPauseEventArgs();
526
527       // Populate all members of "e" (AUIApplicationPauseEventArgs) with real data
528       e.Application = Application.GetApplicationFromPtr(data);
529
530       if (_applicationPauseEventHandler != null)
531       {
532         //here we send all data to user event handlers
533         _applicationPauseEventHandler(this, e);
534       }
535     }
536
537     /**
538       * @brief Event for Resumed signal which can be used to subscribe/unsubscribe the event handler
539       * (in the type of AUIApplicationResumeEventHandler-DaliEventHandler<object,AUIApplicationResumeEventArgs>)
540       *  provided by the user. Resumed signal is emitted when application is resumed
541       */
542     public event DaliEventHandler<object,AUIApplicationResumeEventArgs> Resumed
543     {
544       add
545       {
546         lock(this)
547         {
548           // Restricted to only one listener
549           if (_applicationResumeEventHandler == null)
550           {
551             _applicationResumeEventHandler += value;
552
553             _applicationResumeEventCallbackDelegate = new AUIApplicationResumeEventCallbackDelegate(OnAUIApplicationResume);
554             this.ResumeSignal().Connect(_applicationResumeEventCallbackDelegate);
555           }
556         }
557       }
558
559       remove
560       {
561         lock(this)
562         {
563           if (_applicationResumeEventHandler != null)
564           {
565             this.ResumeSignal().Disconnect(_applicationResumeEventCallbackDelegate);
566           }
567
568           _applicationResumeEventHandler -= value;
569         }
570       }
571     }
572
573     // Callback for Application ResumeSignal
574     private void OnAUIApplicationResume(IntPtr data)
575     {
576       AUIApplicationResumeEventArgs e = new AUIApplicationResumeEventArgs();
577
578       // Populate all members of "e" (AUIApplicationResumeEventArgs) with real data
579       e.Application = Application.GetApplicationFromPtr(data);
580
581       if (_applicationResumeEventHandler != null)
582       {
583         //here we send all data to user event handlers
584         _applicationResumeEventHandler(this, e);
585       }
586     }
587
588     /**
589       * @brief Event for Reset signal which can be used to subscribe/unsubscribe the event handler
590       * (in the type of AUIApplicationResetEventHandler-DaliEventHandler<object,AUIApplicationResetEventArgs>)
591       *  provided by the user. Reset signal is emitted when application is reset
592       */
593     public event DaliEventHandler<object,AUIApplicationResetEventArgs> Reset
594     {
595       add
596       {
597         lock(this)
598         {
599           // Restricted to only one listener
600           if (_applicationResetEventHandler == null)
601           {
602             _applicationResetEventHandler += value;
603
604             _applicationResetEventCallbackDelegate = new AUIApplicationResetEventCallbackDelegate(OnAUIApplicationReset);
605             this.ResetSignal().Connect(_applicationResetEventCallbackDelegate);
606           }
607         }
608       }
609
610       remove
611       {
612         lock(this)
613         {
614           if (_applicationResetEventHandler != null)
615           {
616             this.ResetSignal().Disconnect(_applicationResetEventCallbackDelegate);
617           }
618
619           _applicationResetEventHandler -= value;
620         }
621       }
622     }
623
624     // Callback for Application ResetSignal
625     private void OnAUIApplicationReset(IntPtr data)
626     {
627       AUIApplicationResetEventArgs e = new AUIApplicationResetEventArgs();
628
629       // Populate all members of "e" (AUIApplicationResetEventArgs) with real data
630       e.Application = Application.GetApplicationFromPtr(data);
631
632       if (_applicationResetEventHandler != null)
633       {
634         //here we send all data to user event handlers
635         _applicationResetEventHandler(this, e);
636       }
637     }
638
639     /**
640       * @brief Event for Resized signal which can be used to subscribe/unsubscribe the event handler
641       * (in the type of AUIApplicationResizeEventHandler-DaliEventHandler<object,AUIApplicationResizeEventArgs>)
642       *  provided by the user. Resized signal is emitted when application is resized
643       */
644     public event DaliEventHandler<object,AUIApplicationResizeEventArgs> Resized
645     {
646       add
647       {
648         lock(this)
649         {
650           // Restricted to only one listener
651           if (_applicationResizeEventHandler == null)
652           {
653             _applicationResizeEventHandler += value;
654
655             _applicationResizeEventCallbackDelegate = new AUIApplicationResizeEventCallbackDelegate(OnAUIApplicationResize);
656             this.ResizeSignal().Connect(_applicationResizeEventCallbackDelegate);
657           }
658         }
659       }
660
661       remove
662       {
663         lock(this)
664         {
665           if (_applicationResizeEventHandler != null)
666           {
667             this.ResizeSignal().Disconnect(_applicationResizeEventCallbackDelegate);
668           }
669
670           _applicationResizeEventHandler -= value;
671         }
672       }
673     }
674
675     // Callback for Application ResizeSignal
676     private void OnAUIApplicationResize(IntPtr data)
677     {
678       AUIApplicationResizeEventArgs e = new AUIApplicationResizeEventArgs();
679
680       // Populate all members of "e" (AUIApplicationResizeEventArgs) with real data
681       e.Application = Application.GetApplicationFromPtr(data);
682
683       if (_applicationResizeEventHandler != null)
684       {
685         //here we send all data to user event handlers
686         _applicationResizeEventHandler(this, e);
687       }
688     }
689
690     /**
691       * @brief Event for LanguageChanged signal which can be used to subscribe/unsubscribe the event handler
692       * (in the type of AUIApplicationLanguageChangedEventHandler-DaliEventHandler<object,AUIApplicationLanguageChangedEventArgs>)
693       *  provided by the user. LanguageChanged signal is emitted when the region of the device is changed.
694       */
695     public event DaliEventHandler<object,AUIApplicationLanguageChangedEventArgs> LanguageChanged
696     {
697       add
698       {
699         lock(this)
700         {
701           // Restricted to only one listener
702           if (_applicationLanguageChangedEventHandler == null)
703           {
704             _applicationLanguageChangedEventHandler += value;
705
706             _applicationLanguageChangedEventCallbackDelegate = new AUIApplicationLanguageChangedEventCallbackDelegate(OnAUIApplicationLanguageChanged);
707             this.LanguageChangedSignal().Connect(_applicationLanguageChangedEventCallbackDelegate);
708           }
709         }
710       }
711
712       remove
713       {
714         lock(this)
715         {
716           if (_applicationLanguageChangedEventHandler != null)
717           {
718             this.LanguageChangedSignal().Disconnect(_applicationLanguageChangedEventCallbackDelegate);
719           }
720
721           _applicationLanguageChangedEventHandler -= value;
722         }
723       }
724     }
725
726     // Callback for Application LanguageChangedSignal
727     private void OnAUIApplicationLanguageChanged(IntPtr data)
728     {
729       AUIApplicationLanguageChangedEventArgs e = new AUIApplicationLanguageChangedEventArgs();
730
731       // Populate all members of "e" (AUIApplicationLanguageChangedEventArgs) with real data
732       e.Application = Application.GetApplicationFromPtr(data);
733
734       if (_applicationLanguageChangedEventHandler != null)
735       {
736         //here we send all data to user event handlers
737         _applicationLanguageChangedEventHandler(this, e);
738       }
739     }
740
741     /**
742       * @brief Event for RegionChanged signal which can be used to subscribe/unsubscribe the event handler
743       * (in the type of AUIApplicationRegionChangedEventHandler-DaliEventHandler<object,AUIApplicationRegionChangedEventArgs>)
744       *  provided by the user. RegionChanged signal is emitted when the region of the device is changed.
745       */
746     public event DaliEventHandler<object,AUIApplicationRegionChangedEventArgs> RegionChanged
747     {
748       add
749       {
750         lock(this)
751         {
752           // Restricted to only one listener
753           if (_applicationRegionChangedEventHandler == null)
754           {
755             _applicationRegionChangedEventHandler += value;
756
757             _applicationRegionChangedEventCallbackDelegate = new AUIApplicationRegionChangedEventCallbackDelegate(OnAUIApplicationRegionChanged);
758             this.RegionChangedSignal().Connect(_applicationRegionChangedEventCallbackDelegate);
759           }
760         }
761       }
762
763       remove
764       {
765         lock(this)
766         {
767           if (_applicationRegionChangedEventHandler != null)
768           {
769             this.RegionChangedSignal().Disconnect(_applicationRegionChangedEventCallbackDelegate);
770           }
771
772           _applicationRegionChangedEventHandler -= value;
773         }
774       }
775     }
776
777     // Callback for Application RegionChangedSignal
778     private void OnAUIApplicationRegionChanged(IntPtr data)
779     {
780       AUIApplicationRegionChangedEventArgs e = new AUIApplicationRegionChangedEventArgs();
781
782       // Populate all members of "e" (AUIApplicationRegionChangedEventArgs) with real data
783       e.Application = Application.GetApplicationFromPtr(data);
784
785       if (_applicationRegionChangedEventHandler != null)
786       {
787         //here we send all data to user event handlers
788         _applicationRegionChangedEventHandler(this, e);
789       }
790     }
791
792     /**
793       * @brief Event for BatteryLow signal which can be used to subscribe/unsubscribe the event handler
794       * (in the type of AUIApplicationBatteryLowEventHandler-DaliEventHandler<object,AUIApplicationBatteryLowEventArgs>) 
795       * provided by the user. BatteryLow signal is emitted when the battery level of the device is low.
796       */
797     public event DaliEventHandler<object,AUIApplicationBatteryLowEventArgs> BatteryLow
798     {
799       add
800       {
801         lock(this)
802         {
803           // Restricted to only one listener
804           if (_applicationBatteryLowEventHandler == null)
805           {
806             _applicationBatteryLowEventHandler += value;
807
808             _applicationBatteryLowEventCallbackDelegate = new AUIApplicationBatteryLowEventCallbackDelegate(OnAUIApplicationBatteryLow);
809             this.BatteryLowSignal().Connect(_applicationBatteryLowEventCallbackDelegate);
810           }
811         }
812       }
813
814       remove
815       {
816         lock(this)
817         {
818           if (_applicationBatteryLowEventHandler != null)
819           {
820             this.BatteryLowSignal().Disconnect(_applicationBatteryLowEventCallbackDelegate);
821           }
822
823           _applicationBatteryLowEventHandler -= value;
824         }
825       }
826     }
827
828     // Callback for Application BatteryLowSignal
829     private void OnAUIApplicationBatteryLow(IntPtr data)
830     {
831       AUIApplicationBatteryLowEventArgs e = new AUIApplicationBatteryLowEventArgs();
832
833       // Populate all members of "e" (AUIApplicationBatteryLowEventArgs) with real data
834       e.Application = Application.GetApplicationFromPtr(data);
835
836       if (_applicationBatteryLowEventHandler != null)
837       {
838         //here we send all data to user event handlers
839         _applicationBatteryLowEventHandler(this, e);
840       }
841     }
842
843     /**
844       * @brief Event for MemoryLow signal which can be used to subscribe/unsubscribe the event handler
845       * (in the type of AUIApplicationMemoryLowEventHandler-DaliEventHandler<object,AUIApplicationMemoryLowEventArgs>)
846       *  provided by the user. MemoryLow signal is emitted when the memory level of the device is low.
847       */
848     public event DaliEventHandler<object,AUIApplicationMemoryLowEventArgs> MemoryLow
849     {
850       add
851       {
852         lock(this)
853         {
854           // Restricted to only one listener
855           if (_applicationMemoryLowEventHandler == null)
856           {
857             _applicationMemoryLowEventHandler += value;
858
859             _applicationMemoryLowEventCallbackDelegate = new AUIApplicationMemoryLowEventCallbackDelegate(OnAUIApplicationMemoryLow);
860             this.MemoryLowSignal().Connect(_applicationMemoryLowEventCallbackDelegate);
861           }
862         }
863       }
864
865       remove
866       {
867         lock(this)
868         {
869           if (_applicationMemoryLowEventHandler != null)
870           {
871             this.MemoryLowSignal().Disconnect(_applicationMemoryLowEventCallbackDelegate);
872           }
873
874           _applicationMemoryLowEventHandler -= value;
875         }
876       }
877     }
878
879     // Callback for Application MemoryLowSignal
880     private void OnAUIApplicationMemoryLow(IntPtr data)
881     {
882       AUIApplicationMemoryLowEventArgs e = new AUIApplicationMemoryLowEventArgs();
883
884       // Populate all members of "e" (AUIApplicationMemoryLowEventArgs) with real data
885       e.Application = Application.GetApplicationFromPtr(data);
886
887       if (_applicationMemoryLowEventHandler != null)
888       {
889         //here we send all data to user event handlers
890         _applicationMemoryLowEventHandler(this, e);
891       }
892     }
893
894     /**
895       * @brief Event for AppControl signal which can be used to subscribe/unsubscribe the event handler
896       * (in the type of AUIApplicationAppControlEventHandler-DaliEventHandler<object,AUIApplicationAppControlEventArgs>)
897       *  provided by the user. AppControl signal is emitted when another application sends a launch request to the application.
898       */
899     public event DaliEventHandler<object,AUIApplicationAppControlEventArgs> AppControl
900     {
901       add
902       {
903         lock(this)
904         {
905           // Restricted to only one listener
906           if (_applicationAppControlEventHandler == null)
907           {
908             _applicationAppControlEventHandler += value;
909
910             _applicationAppControlEventCallbackDelegate = new AUIApplicationAppControlEventCallbackDelegate(OnAUIApplicationAppControl);
911             this.AppControlSignal().Connect(_applicationAppControlEventCallbackDelegate);
912           }
913         }
914       }
915
916       remove
917       {
918         lock(this)
919         {
920           if (_applicationAppControlEventHandler != null)
921           {
922             this.AppControlSignal().Disconnect(_applicationAppControlEventCallbackDelegate);
923           }
924
925           _applicationAppControlEventHandler -= value;
926         }
927       }
928     }
929
930     // Callback for Application AppControlSignal
931     private void OnAUIApplicationAppControl(IntPtr application, IntPtr voidp)
932     {
933       AUIApplicationAppControlEventArgs e = new AUIApplicationAppControlEventArgs();
934
935       // Populate all members of "e" (AUIApplicationAppControlEventArgs) with real data
936       e.Application = Application.GetApplicationFromPtr(application);
937       e.VoidP = voidp;
938
939       if (_applicationAppControlEventHandler != null)
940       {
941         //here we send all data to user event handlers
942         _applicationAppControlEventHandler(this, e);
943       }
944     }
945
946     private static  Application instance; // singleton
947
948     public delegate void InitDelegate();
949
950     public delegate void TerminateDelegate();
951
952     public delegate void PauseDelegate();
953
954     public delegate void ResumeDelegate();
955
956     public delegate void ResizeDelegate();
957
958     public delegate void AppControlDelegate();
959
960     public delegate void LanguageChangedDelegate();
961
962     public delegate void RegionChangedDelegate();
963
964     public delegate void BatteryLowDelegate();
965
966     public delegate void MemoryLowDelegate();
967
968     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
969     internal delegate void InitDelegateInternal();
970
971     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
972     internal delegate void TerminateDelegateInternal();
973
974     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
975     internal delegate void PauseDelegateInternal();
976
977     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
978     internal delegate void ResumeDelegateInternal();
979
980     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
981     internal delegate void ResizeDelegateInternal();
982
983     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
984     internal delegate void AppControlDelegateInternal();
985
986     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
987     internal delegate void LanguageChangedDelegateInternal();
988
989     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
990     internal delegate void RegionChangedDelegateInternal();
991
992     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
993     internal delegate void BatteryLowDelegateInternal();
994
995     [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
996     internal delegate void MemoryLowDelegateInternal();
997
998     static void Initialize()
999     {
1000       //        instance.InitDelegate();
1001     }
1002
1003     public static Application GetApplicationFromPtr(global::System.IntPtr cPtr) {
1004       Application ret = new Application(cPtr, false);
1005       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1006       return ret;
1007     }
1008
1009     internal void SetupDelegates() {
1010       InitDelegateInternal initializeCallback = new InitDelegateInternal( Initialize );
1011       System.Console.WriteLine( "InitSignal connection count");
1012
1013       this.InitSignal().Connect( initializeCallback );
1014       //Console.WriteLine( "InitSignal connection count = " + app.InitSignal().GetConnectionCount() );
1015     }
1016
1017     public static Application NewApplication() {
1018       return NewApplication("",Application.WINDOW_MODE.OPAQUE);
1019     }
1020
1021     public static Application NewApplication(string stylesheet) {
1022       return NewApplication(stylesheet, Application.WINDOW_MODE.OPAQUE);
1023     }
1024
1025     public static Application NewApplication(string stylesheet, Application.WINDOW_MODE windowMode) {
1026
1027       Application ret = New(1, stylesheet, windowMode);
1028       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1029
1030       // we've got an application now connect the signals
1031       ret.SetupDelegates();
1032       // set the singleton
1033
1034       return ret;
1035     }
1036
1037
1038     
1039   
1040   /**
1041   * Outer::outer_method(int)
1042   */
1043   public static Application New() {
1044     Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_0(), true);
1045     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1046     return ret;
1047   }
1048
1049   public static Application New(int argc) {
1050     Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_1(argc), true);
1051     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1052     return ret;
1053   }
1054
1055   public static Application New(int argc, string stylesheet) {
1056     Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_2(argc, stylesheet), true);
1057     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1058     return ret;
1059   }
1060
1061   public static Application New(int argc, string stylesheet, Application.WINDOW_MODE windowMode) {
1062     Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_3(argc, stylesheet, (int)windowMode), true);
1063     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1064     return ret;
1065   }
1066
1067   public Application() : this(NDalicPINVOKE.new_Application__SWIG_0(), true) {
1068     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1069   }
1070
1071   public Application(Application application) : this(NDalicPINVOKE.new_Application__SWIG_1(Application.getCPtr(application)), true) {
1072     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1073   }
1074
1075   public Application Assign(Application application) {
1076     Application ret = new Application(NDalicPINVOKE.Application_Assign(swigCPtr, Application.getCPtr(application)), false);
1077     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1078     return ret;
1079   }
1080
1081   public void MainLoop() {
1082     NDalicPINVOKE.Application_MainLoop__SWIG_0(swigCPtr);
1083     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1084   }
1085
1086   public void MainLoop(SWIGTYPE_p_Configuration__ContextLoss configuration) {
1087     NDalicPINVOKE.Application_MainLoop__SWIG_1(swigCPtr, SWIGTYPE_p_Configuration__ContextLoss.getCPtr(configuration));
1088     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1089   }
1090
1091   public void Lower() {
1092     NDalicPINVOKE.Application_Lower(swigCPtr);
1093     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1094   }
1095
1096   public void Quit() {
1097     NDalicPINVOKE.Application_Quit(swigCPtr);
1098     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1099   }
1100
1101   public bool AddIdle(SWIGTYPE_p_Dali__CallbackBase callback) {
1102     bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, SWIGTYPE_p_Dali__CallbackBase.getCPtr(callback));
1103     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1104     return ret;
1105   }
1106
1107   public Window GetWindow() {
1108     Window ret = new Window(NDalicPINVOKE.Application_GetWindow(swigCPtr), true);
1109     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1110     return ret;
1111   }
1112
1113   public void ReplaceWindow(RectInteger windowPosition, string name) {
1114     NDalicPINVOKE.Application_ReplaceWindow(swigCPtr, RectInteger.getCPtr(windowPosition), name);
1115     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1116   }
1117
1118   public static string GetResourcePath() {
1119     string ret = NDalicPINVOKE.Application_GetResourcePath();
1120     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1121     return ret;
1122   }
1123
1124   public void SetViewMode(ViewMode viewMode) {
1125     NDalicPINVOKE.Application_SetViewMode(swigCPtr, (int)viewMode);
1126     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1127   }
1128
1129   public ViewMode GetViewMode() {
1130     ViewMode ret = (ViewMode)NDalicPINVOKE.Application_GetViewMode(swigCPtr);
1131     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1132     return ret;
1133   }
1134
1135   public void SetStereoBase(float stereoBase) {
1136     NDalicPINVOKE.Application_SetStereoBase(swigCPtr, stereoBase);
1137     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1138   }
1139
1140   public float GetStereoBase() {
1141     float ret = NDalicPINVOKE.Application_GetStereoBase(swigCPtr);
1142     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1143     return ret;
1144   }
1145
1146   public ApplicationSignal InitSignal() {
1147     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_InitSignal(swigCPtr), false);
1148     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1149     return ret;
1150   }
1151
1152   public ApplicationSignal TerminateSignal() {
1153     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_TerminateSignal(swigCPtr), false);
1154     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1155     return ret;
1156   }
1157
1158   public ApplicationSignal PauseSignal() {
1159     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_PauseSignal(swigCPtr), false);
1160     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1161     return ret;
1162   }
1163
1164   public ApplicationSignal ResumeSignal() {
1165     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResumeSignal(swigCPtr), false);
1166     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1167     return ret;
1168   }
1169
1170   public ApplicationSignal ResetSignal() {
1171     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResetSignal(swigCPtr), false);
1172     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1173     return ret;
1174   }
1175
1176   public ApplicationSignal ResizeSignal() {
1177     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResizeSignal(swigCPtr), false);
1178     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1179     return ret;
1180   }
1181
1182   public ApplicationControlSignal AppControlSignal() {
1183     ApplicationControlSignal ret = new ApplicationControlSignal(NDalicPINVOKE.Application_AppControlSignal(swigCPtr), false);
1184     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1185     return ret;
1186   }
1187
1188   public ApplicationSignal LanguageChangedSignal() {
1189     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_LanguageChangedSignal(swigCPtr), false);
1190     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1191     return ret;
1192   }
1193
1194   public ApplicationSignal RegionChangedSignal() {
1195     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_RegionChangedSignal(swigCPtr), false);
1196     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1197     return ret;
1198   }
1199
1200   public ApplicationSignal BatteryLowSignal() {
1201     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_BatteryLowSignal(swigCPtr), false);
1202     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1203     return ret;
1204   }
1205
1206   public ApplicationSignal MemoryLowSignal() {
1207     ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_MemoryLowSignal(swigCPtr), false);
1208     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1209     return ret;
1210   }
1211
1212   public enum WINDOW_MODE {
1213     OPAQUE = 0,
1214     TRANSPARENT = 1
1215   }
1216
1217 }
1218
1219 }