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 }