src/Tizen.NUI/src/internal/Application.cs

   1 /*
   2  * Copyright(c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 namespace Tizen.NUI
  19 {
  20
  21     using System;
  22     using System.Runtime.InteropServices;
  23
  24     /**
  25       * @brief Event arguments that passed via NUIApplicationInit signal
  26       *
  27       */
  28     internal class NUIApplicationInitEventArgs : EventArgs
  29     {
  30         private Application _application;
  31
  32         /**
  33           * @brief Application - is the application that is being initialized
  34           *
  35           */
  36         public Application Application
  37         {
  38             get
  39             {
  40                 return _application;
  41             }
  42             set
  43             {
  44                 _application = value;
  45             }
  46         }
  47     }
  48
  49     /**
  50       * @brief Event arguments that passed via NUIApplicationTerminate signal
  51       *
  52       */
  53     internal class NUIApplicationTerminatingEventArgs : EventArgs
  54     {
  55         private Application _application;
  56         /**
  57           * @brief Application - is the application that is being Terminated
  58           *
  59           */
  60         public Application Application
  61         {
  62             get
  63             {
  64                 return _application;
  65             }
  66             set
  67             {
  68                 _application = value;
  69             }
  70         }
  71     }
  72
  73     /**
  74       * @brief Event arguments that passed via NUIApplicationPause signal
  75       *
  76       */
  77     internal class NUIApplicationPausedEventArgs : EventArgs
  78     {
  79         private Application _application;
  80         /**
  81           * @brief Application - is the application that is being Paused
  82           *
  83           */
  84         public Application Application
  85         {
  86             get
  87             {
  88                 return _application;
  89             }
  90             set
  91             {
  92                 _application = value;
  93             }
  94         }
  95     }
  96
  97     /**
  98       * @brief Event arguments that passed via NUIApplicationResume signal
  99       *
 100       */
 101     internal class NUIApplicationResumedEventArgs : EventArgs
 102     {
 103         private Application _application;
 104         /**
 105           * @brief Application - is the application that is being Resumed
 106           *
 107           */
 108         public Application Application
 109         {
 110             get
 111             {
 112                 return _application;
 113             }
 114             set
 115             {
 116                 _application = value;
 117             }
 118         }
 119     }
 120
 121     /**
 122       * @brief Event arguments that passed via NUIApplicationReset signal
 123       *
 124       */
 125     internal class NUIApplicationResetEventArgs : EventArgs
 126     {
 127         private Application _application;
 128         /**
 129           * @brief Application - is the application that is being Reset
 130           *
 131           */
 132         public Application Application
 133         {
 134             get
 135             {
 136                 return _application;
 137             }
 138             set
 139             {
 140                 _application = value;
 141             }
 142         }
 143     }
 144
 145     /**
 146       * @brief Event arguments that passed via NUIApplicationResize signal
 147       *
 148       */
 149     internal class NUIApplicationResizedEventArgs : EventArgs
 150     {
 151         private Application _application;
 152         /**
 153           * @brief Application - is the application that is being Resized
 154           *
 155           */
 156         public Application Application
 157         {
 158             get
 159             {
 160                 return _application;
 161             }
 162             set
 163             {
 164                 _application = value;
 165             }
 166         }
 167     }
 168
 169     /**
 170       * @brief Event arguments that passed via NUIApplicationLanguageChanged signal
 171       *
 172       */
 173     internal class NUIApplicationLanguageChangedEventArgs : EventArgs
 174     {
 175         private Application _application;
 176         /**
 177           * @brief Application - is the application that is being affected with Device's language change
 178           *
 179           */
 180         public Application Application
 181         {
 182             get
 183             {
 184                 return _application;
 185             }
 186             set
 187             {
 188                 _application = value;
 189             }
 190         }
 191     }
 192
 193     /**
 194       * @brief Event arguments that passed via NUIApplicationRegionChanged signal
 195       *
 196       */
 197     internal class NUIApplicationRegionChangedEventArgs : EventArgs
 198     {
 199         private Application _application;
 200         /**
 201           * @brief Application - is the application that is being affected with Device's region change
 202           *
 203           */
 204         public Application Application
 205         {
 206             get
 207             {
 208                 return _application;
 209             }
 210             set
 211             {
 212                 _application = value;
 213             }
 214         }
 215     }
 216
 217     /**
 218       * @brief Event arguments that passed via NUIApplicationBatteryLow signal
 219       *
 220       */
 221     internal class NUIApplicationBatteryLowEventArgs : EventArgs
 222     {
 223         private Application.BatteryStatus _status;
 224         /**
 225           * @brief Application - is the application that is being affected when the battery level of the device is low
 226           *
 227           */
 228         public Application.BatteryStatus BatteryStatus
 229         {
 230             get
 231             {
 232                 return _status;
 233             }
 234             set
 235             {
 236                 _status = value;
 237             }
 238         }
 239     }
 240
 241     /**
 242       * @brief Event arguments that passed via NUIApplicationMemoryLow signal
 243       *
 244       */
 245     internal class NUIApplicationMemoryLowEventArgs : EventArgs
 246     {
 247         private Application.MemoryStatus _status;
 248         /**
 249           * @brief Application - is the application that is being affected when the memory level of the device is low
 250           *
 251           */
 252         public Application.MemoryStatus MemoryStatus
 253         {
 254             get
 255             {
 256                 return _status;
 257             }
 258             set
 259             {
 260                 _status = value;
 261             }
 262         }
 263     }
 264
 265     /**
 266       * @brief Event arguments that passed via NUIApplicationAppControl  signal
 267       *
 268       */
 269     internal class NUIApplicationAppControlEventArgs : EventArgs
 270     {
 271         private Application _application;
 272         private IntPtr _voidp;
 273         /**
 274           * @brief Application - is the application that is receiving the launch request from another application
 275           *
 276           */
 277         public Application Application
 278         {
 279             get
 280             {
 281                 return _application;
 282             }
 283             set
 284             {
 285                 _application = value;
 286             }
 287         }
 288         /**
 289           * @brief VoidP - contains the information about why the application is launched
 290           *
 291           */
 292         public IntPtr VoidP
 293         {
 294             get
 295             {
 296                 return _voidp;
 297             }
 298             set
 299             {
 300                 _voidp = value;
 301             }
 302         }
 303     }
 304
 305     internal class Application : BaseHandle
 306     {
 307         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 308
 309         internal Application(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Application_SWIGUpcast(cPtr), cMemoryOwn)
 310         {
 311             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 312         }
 313
 314         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Application obj)
 315         {
 316             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 317         }
 318
 319         protected override void Dispose(DisposeTypes type)
 320         {
 321             if (disposed)
 322             {
 323                 return;
 324             }
 325
 326             if (type == DisposeTypes.Explicit)
 327             {
 328                 //Called by User
 329                 //Release your own managed resources here.
 330                 //You should release all of your own disposable objects here.
 331
 332             }
 333
 334             //Release your own unmanaged resources here.
 335             //You should not access any managed member here except static instance.
 336             //because the execution order of Finalizes is non-deterministic.
 337
 338             if (_applicationInitEventCallbackDelegate != null)
 339             {
 340                 this.InitSignal().Disconnect(_applicationInitEventCallbackDelegate);
 341             }
 342
 343             if (_applicationTerminateEventCallbackDelegate != null)
 344             {
 345                 this.TerminateSignal().Disconnect(_applicationTerminateEventCallbackDelegate);
 346             }
 347
 348             if (_applicationPauseEventCallbackDelegate != null)
 349             {
 350                 this.PauseSignal().Disconnect(_applicationPauseEventCallbackDelegate);
 351             }
 352
 353             if (_applicationResumeEventCallbackDelegate != null)
 354             {
 355                 this.ResumeSignal().Disconnect(_applicationResumeEventCallbackDelegate);
 356             }
 357
 358             if (_applicationResetEventCallbackDelegate != null)
 359             {
 360                 this.ResetSignal().Disconnect(_applicationResetEventCallbackDelegate);
 361             }
 362
 363             if (_applicationResizeEventCallbackDelegate != null)
 364             {
 365                 this.ResizeSignal().Disconnect(_applicationResizeEventCallbackDelegate);
 366             }
 367
 368             if (_applicationLanguageChangedEventCallbackDelegate != null)
 369             {
 370                 this.LanguageChangedSignal().Disconnect(_applicationLanguageChangedEventCallbackDelegate);
 371             }
 372
 373             if (_applicationRegionChangedEventCallbackDelegate != null)
 374             {
 375                 this.RegionChangedSignal().Disconnect(_applicationRegionChangedEventCallbackDelegate);
 376             }
 377
 378             if (_applicationBatteryLowEventCallbackDelegate != null)
 379             {
 380                 this.BatteryLowSignal().Disconnect(_applicationBatteryLowEventCallbackDelegate);
 381             }
 382
 383             if (_applicationMemoryLowEventCallbackDelegate != null)
 384             {
 385                 this.MemoryLowSignal().Disconnect(_applicationMemoryLowEventCallbackDelegate);
 386             }
 387
 388             if (_applicationAppControlEventCallbackDelegate != null)
 389             {
 390                 this.AppControlSignal().Disconnect(_applicationAppControlEventCallbackDelegate);
 391             }
 392
 393             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 394             {
 395                 if (swigCMemOwn)
 396                 {
 397                     swigCMemOwn = false;
 398                     NDalicPINVOKE.delete_Application(swigCPtr);
 399                 }
 400                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 401             }
 402
 403             base.Dispose(type);
 404         }
 405
 406         /// <since_tizen> 4 </since_tizen>
 407         public enum BatteryStatus
 408         {
 409             Normal,
 410             CriticallyLow,
 411             PowerOff
 412         };
 413
 414         /// <since_tizen> 4 </since_tizen>
 415         public enum MemoryStatus
 416         {
 417             Normal,
 418             Low,
 419             CriticallyLow
 420         };
 421
 422         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 423         private delegate void NUIApplicationInitEventCallbackDelegate(IntPtr application);
 424         private DaliEventHandler<object, NUIApplicationInitEventArgs> _applicationInitEventHandler;
 425         private NUIApplicationInitEventCallbackDelegate _applicationInitEventCallbackDelegate;
 426
 427
 428         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 429         private delegate void NUIApplicationTerminateEventCallbackDelegate(IntPtr application);
 430         private DaliEventHandler<object, NUIApplicationTerminatingEventArgs> _applicationTerminateEventHandler;
 431         private NUIApplicationTerminateEventCallbackDelegate _applicationTerminateEventCallbackDelegate;
 432
 433
 434         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 435         private delegate void NUIApplicationPauseEventCallbackDelegate(IntPtr application);
 436         private DaliEventHandler<object, NUIApplicationPausedEventArgs> _applicationPauseEventHandler;
 437         private NUIApplicationPauseEventCallbackDelegate _applicationPauseEventCallbackDelegate;
 438
 439         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 440         private delegate void NUIApplicationResumeEventCallbackDelegate(IntPtr application);
 441         private DaliEventHandler<object, NUIApplicationResumedEventArgs> _applicationResumeEventHandler;
 442         private NUIApplicationResumeEventCallbackDelegate _applicationResumeEventCallbackDelegate;
 443
 444         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 445         private delegate void NUIApplicationResetEventCallbackDelegate(IntPtr application);
 446         private DaliEventHandler<object, NUIApplicationResetEventArgs> _applicationResetEventHandler;
 447         private NUIApplicationResetEventCallbackDelegate _applicationResetEventCallbackDelegate;
 448
 449         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 450         private delegate void NUIApplicationResizeEventCallbackDelegate(IntPtr application);
 451         private DaliEventHandler<object, NUIApplicationResizedEventArgs> _applicationResizeEventHandler;
 452         private NUIApplicationResizeEventCallbackDelegate _applicationResizeEventCallbackDelegate;
 453
 454         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 455         private delegate void NUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
 456         private DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> _applicationLanguageChangedEventHandler;
 457         private NUIApplicationLanguageChangedEventCallbackDelegate _applicationLanguageChangedEventCallbackDelegate;
 458
 459
 460         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 461         private delegate void NUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
 462         private DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> _applicationRegionChangedEventHandler;
 463         private NUIApplicationRegionChangedEventCallbackDelegate _applicationRegionChangedEventCallbackDelegate;
 464
 465         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 466         private delegate void NUIApplicationBatteryLowEventCallbackDelegate(BatteryStatus status);
 467         private DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> _applicationBatteryLowEventHandler;
 468         private NUIApplicationBatteryLowEventCallbackDelegate _applicationBatteryLowEventCallbackDelegate;
 469
 470         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 471         private delegate void NUIApplicationMemoryLowEventCallbackDelegate(MemoryStatus status);
 472         private DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> _applicationMemoryLowEventHandler;
 473         private NUIApplicationMemoryLowEventCallbackDelegate _applicationMemoryLowEventCallbackDelegate;
 474
 475         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 476         private delegate void NUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
 477         private DaliEventHandler<object, NUIApplicationAppControlEventArgs> _applicationAppControlEventHandler;
 478         private NUIApplicationAppControlEventCallbackDelegate _applicationAppControlEventCallbackDelegate;
 479
 480         /**
 481           * @brief Event for Initialized signal which can be used to subscribe/unsubscribe the event handler
 482           *  provided by the user. Initialized signal is emitted when application is initialised
 483           */
 484         public event DaliEventHandler<object, NUIApplicationInitEventArgs> Initialized
 485         {
 486             add
 487             {
 488                 lock (this)
 489                 {
 490                     // Restricted to only one listener
 491                     if (_applicationInitEventHandler == null)
 492                     {
 493                         _applicationInitEventHandler += value;
 494
 495                         _applicationInitEventCallbackDelegate = new NUIApplicationInitEventCallbackDelegate(OnApplicationInit);
 496                         this.InitSignal().Connect(_applicationInitEventCallbackDelegate);
 497                     }
 498                 }
 499             }
 500
 501             remove
 502             {
 503                 lock (this)
 504                 {
 505                     if (_applicationInitEventHandler != null)
 506                     {
 507                         this.InitSignal().Disconnect(_applicationInitEventCallbackDelegate);
 508                     }
 509
 510                     _applicationInitEventHandler -= value;
 511                 }
 512             }
 513         }
 514
 515         // Callback for Application InitSignal
 516         private void OnApplicationInit(IntPtr data)
 517         {
 518             // Initialize DisposeQueue Singleton class. This is also required to create DisposeQueue on main thread.
 519             DisposeQueue.Instance.Initialize();
 520             NUIApplicationInitEventArgs e = new NUIApplicationInitEventArgs();
 521
 522             // Populate all members of "e" (NUIApplicationInitEventArgs) with real data
 523             e.Application = Application.GetApplicationFromPtr(data);
 524
 525             if (_applicationInitEventHandler != null)
 526             {
 527                 //here we send all data to user event handlers
 528                 _applicationInitEventHandler(this, e);
 529             }
 530         }
 531
 532         /**
 533           * @brief Event for Terminated signal which can be used to subscribe/unsubscribe the event handler
 534           *  provided by the user. Terminated signal is emitted when application is terminating
 535           */
 536         public event DaliEventHandler<object, NUIApplicationTerminatingEventArgs> Terminating
 537         {
 538             add
 539             {
 540                 lock (this)
 541                 {
 542                     // Restricted to only one listener
 543                     if (_applicationTerminateEventHandler == null)
 544                     {
 545                         _applicationTerminateEventHandler += value;
 546
 547                         _applicationTerminateEventCallbackDelegate = new NUIApplicationTerminateEventCallbackDelegate(OnNUIApplicationTerminate);
 548                         this.TerminateSignal().Connect(_applicationTerminateEventCallbackDelegate);
 549                     }
 550                 }
 551             }
 552
 553             remove
 554             {
 555                 lock (this)
 556                 {
 557                     if (_applicationTerminateEventHandler != null)
 558                     {
 559                         this.TerminateSignal().Disconnect(_applicationTerminateEventCallbackDelegate);
 560                     }
 561
 562                     _applicationTerminateEventHandler -= value;
 563                 }
 564             }
 565         }
 566
 567         // Callback for Application TerminateSignal
 568         private void OnNUIApplicationTerminate(IntPtr data)
 569         {
 570             NUIApplicationTerminatingEventArgs e = new NUIApplicationTerminatingEventArgs();
 571
 572             // Populate all members of "e" (NUIApplicationTerminateEventArgs) with real data
 573             e.Application = Application.GetApplicationFromPtr(data);
 574
 575             if (_applicationTerminateEventHandler != null)
 576             {
 577                 //here we send all data to user event handlers
 578                 _applicationTerminateEventHandler(this, e);
 579             }
 580         }
 581
 582         /**
 583           * @brief Event for Paused signal which can be used to subscribe/unsubscribe the event handler
 584           * provided by the user. Paused signal is emitted when application is paused
 585           */
 586         public event DaliEventHandler<object, NUIApplicationPausedEventArgs> Paused
 587         {
 588             add
 589             {
 590                 lock (this)
 591                 {
 592                     // Restricted to only one listener
 593                     if (_applicationPauseEventHandler == null)
 594                     {
 595                         _applicationPauseEventHandler += value;
 596
 597                         _applicationPauseEventCallbackDelegate = new NUIApplicationPauseEventCallbackDelegate(OnNUIApplicationPause);
 598                         this.PauseSignal().Connect(_applicationPauseEventCallbackDelegate);
 599                     }
 600                 }
 601             }
 602
 603             remove
 604             {
 605                 lock (this)
 606                 {
 607                     if (_applicationPauseEventHandler != null)
 608                     {
 609                         this.PauseSignal().Disconnect(_applicationPauseEventCallbackDelegate);
 610                     }
 611
 612                     _applicationPauseEventHandler -= value;
 613                 }
 614             }
 615         }
 616
 617         // Callback for Application PauseSignal
 618         private void OnNUIApplicationPause(IntPtr data)
 619         {
 620             NUIApplicationPausedEventArgs e = new NUIApplicationPausedEventArgs();
 621
 622             // Populate all members of "e" (NUIApplicationPauseEventArgs) with real data
 623             e.Application = Application.GetApplicationFromPtr(data);
 624
 625             if (_applicationPauseEventHandler != null)
 626             {
 627                 //here we send all data to user event handlers
 628                 _applicationPauseEventHandler(this, e);
 629             }
 630         }
 631
 632         /**
 633           * @brief Event for Resumed signal which can be used to subscribe/unsubscribe the event handler
 634           *  provided by the user. Resumed signal is emitted when application is resumed
 635           */
 636         public event DaliEventHandler<object, NUIApplicationResumedEventArgs> Resumed
 637         {
 638             add
 639             {
 640                 lock (this)
 641                 {
 642                     // Restricted to only one listener
 643                     if (_applicationResumeEventHandler == null)
 644                     {
 645                         _applicationResumeEventHandler += value;
 646
 647                         _applicationResumeEventCallbackDelegate = new NUIApplicationResumeEventCallbackDelegate(OnNUIApplicationResume);
 648                         this.ResumeSignal().Connect(_applicationResumeEventCallbackDelegate);
 649                     }
 650                 }
 651             }
 652
 653             remove
 654             {
 655                 lock (this)
 656                 {
 657                     if (_applicationResumeEventHandler != null)
 658                     {
 659                         this.ResumeSignal().Disconnect(_applicationResumeEventCallbackDelegate);
 660                     }
 661
 662                     _applicationResumeEventHandler -= value;
 663                 }
 664             }
 665         }
 666
 667         // Callback for Application ResumeSignal
 668         private void OnNUIApplicationResume(IntPtr data)
 669         {
 670             NUIApplicationResumedEventArgs e = new NUIApplicationResumedEventArgs();
 671
 672             // Populate all members of "e" (NUIApplicationResumeEventArgs) with real data
 673             e.Application = Application.GetApplicationFromPtr(data);
 674
 675             if (_applicationResumeEventHandler != null)
 676             {
 677                 //here we send all data to user event handlers
 678                 _applicationResumeEventHandler(this, e);
 679             }
 680         }
 681
 682         /**
 683           * @brief Event for Reset signal which can be used to subscribe/unsubscribe the event handler
 684           *  provided by the user. Reset signal is emitted when application is reset
 685           */
 686         public new event DaliEventHandler<object, NUIApplicationResetEventArgs> Reset
 687         {
 688             add
 689             {
 690                 lock (this)
 691                 {
 692                     // Restricted to only one listener
 693                     if (_applicationResetEventHandler == null)
 694                     {
 695                         _applicationResetEventHandler += value;
 696
 697                         _applicationResetEventCallbackDelegate = new NUIApplicationResetEventCallbackDelegate(OnNUIApplicationReset);
 698                         this.ResetSignal().Connect(_applicationResetEventCallbackDelegate);
 699                     }
 700                 }
 701             }
 702
 703             remove
 704             {
 705                 lock (this)
 706                 {
 707                     if (_applicationResetEventHandler != null)
 708                     {
 709                         this.ResetSignal().Disconnect(_applicationResetEventCallbackDelegate);
 710                     }
 711
 712                     _applicationResetEventHandler -= value;
 713                 }
 714             }
 715         }
 716
 717         // Callback for Application ResetSignal
 718         private void OnNUIApplicationReset(IntPtr data)
 719         {
 720             NUIApplicationResetEventArgs e = new NUIApplicationResetEventArgs();
 721
 722             // Populate all members of "e" (NUIApplicationResetEventArgs) with real data
 723             e.Application = Application.GetApplicationFromPtr(data);
 724
 725             if (_applicationResetEventHandler != null)
 726             {
 727                 //here we send all data to user event handlers
 728                 _applicationResetEventHandler(this, e);
 729             }
 730         }
 731
 732         /**
 733           * @brief Event for Resized signal which can be used to subscribe/unsubscribe the event handler
 734           *  provided by the user. Resized signal is emitted when application is resized
 735           */
 736         public event DaliEventHandler<object, NUIApplicationResizedEventArgs> Resized
 737         {
 738             add
 739             {
 740                 lock (this)
 741                 {
 742                     // Restricted to only one listener
 743                     if (_applicationResizeEventHandler == null)
 744                     {
 745                         _applicationResizeEventHandler += value;
 746
 747                         _applicationResizeEventCallbackDelegate = new NUIApplicationResizeEventCallbackDelegate(OnNUIApplicationResize);
 748                         this.ResizeSignal().Connect(_applicationResizeEventCallbackDelegate);
 749                     }
 750                 }
 751             }
 752
 753             remove
 754             {
 755                 lock (this)
 756                 {
 757                     if (_applicationResizeEventHandler != null)
 758                     {
 759                         this.ResizeSignal().Disconnect(_applicationResizeEventCallbackDelegate);
 760                     }
 761
 762                     _applicationResizeEventHandler -= value;
 763                 }
 764             }
 765         }
 766
 767         // Callback for Application ResizeSignal
 768         private void OnNUIApplicationResize(IntPtr data)
 769         {
 770             NUIApplicationResizedEventArgs e = new NUIApplicationResizedEventArgs();
 771
 772             // Populate all members of "e" (NUIApplicationResizeEventArgs) with real data
 773             e.Application = Application.GetApplicationFromPtr(data);
 774
 775             if (_applicationResizeEventHandler != null)
 776             {
 777                 //here we send all data to user event handlers
 778                 _applicationResizeEventHandler(this, e);
 779             }
 780         }
 781
 782         /**
 783           * @brief Event for LanguageChanged signal which can be used to subscribe/unsubscribe the event handler
 784           *  provided by the user. LanguageChanged signal is emitted when the region of the device is changed.
 785           */
 786         public event DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> LanguageChanged
 787         {
 788             add
 789             {
 790                 lock (this)
 791                 {
 792                     // Restricted to only one listener
 793                     if (_applicationLanguageChangedEventHandler == null)
 794                     {
 795                         _applicationLanguageChangedEventHandler += value;
 796
 797                         _applicationLanguageChangedEventCallbackDelegate = new NUIApplicationLanguageChangedEventCallbackDelegate(OnNUIApplicationLanguageChanged);
 798                         this.LanguageChangedSignal().Connect(_applicationLanguageChangedEventCallbackDelegate);
 799                     }
 800                 }
 801             }
 802
 803             remove
 804             {
 805                 lock (this)
 806                 {
 807                     if (_applicationLanguageChangedEventHandler != null)
 808                     {
 809                         this.LanguageChangedSignal().Disconnect(_applicationLanguageChangedEventCallbackDelegate);
 810                     }
 811
 812                     _applicationLanguageChangedEventHandler -= value;
 813                 }
 814             }
 815         }
 816
 817         // Callback for Application LanguageChangedSignal
 818         private void OnNUIApplicationLanguageChanged(IntPtr data)
 819         {
 820             NUIApplicationLanguageChangedEventArgs e = new NUIApplicationLanguageChangedEventArgs();
 821
 822             // Populate all members of "e" (NUIApplicationLanguageChangedEventArgs) with real data
 823             e.Application = Application.GetApplicationFromPtr(data);
 824
 825             if (_applicationLanguageChangedEventHandler != null)
 826             {
 827                 //here we send all data to user event handlers
 828                 _applicationLanguageChangedEventHandler(this, e);
 829             }
 830         }
 831
 832         /**
 833           * @brief Event for RegionChanged signal which can be used to subscribe/unsubscribe the event handler
 834           *  provided by the user. RegionChanged signal is emitted when the region of the device is changed.
 835           */
 836         public event DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> RegionChanged
 837         {
 838             add
 839             {
 840                 lock (this)
 841                 {
 842                     // Restricted to only one listener
 843                     if (_applicationRegionChangedEventHandler == null)
 844                     {
 845                         _applicationRegionChangedEventHandler += value;
 846
 847                         _applicationRegionChangedEventCallbackDelegate = new NUIApplicationRegionChangedEventCallbackDelegate(OnNUIApplicationRegionChanged);
 848                         this.RegionChangedSignal().Connect(_applicationRegionChangedEventCallbackDelegate);
 849                     }
 850                 }
 851             }
 852
 853             remove
 854             {
 855                 lock (this)
 856                 {
 857                     if (_applicationRegionChangedEventHandler != null)
 858                     {
 859                         this.RegionChangedSignal().Disconnect(_applicationRegionChangedEventCallbackDelegate);
 860                     }
 861
 862                     _applicationRegionChangedEventHandler -= value;
 863                 }
 864             }
 865         }
 866
 867         // Callback for Application RegionChangedSignal
 868         private void OnNUIApplicationRegionChanged(IntPtr data)
 869         {
 870             NUIApplicationRegionChangedEventArgs e = new NUIApplicationRegionChangedEventArgs();
 871
 872             // Populate all members of "e" (NUIApplicationRegionChangedEventArgs) with real data
 873             e.Application = Application.GetApplicationFromPtr(data);
 874
 875             if (_applicationRegionChangedEventHandler != null)
 876             {
 877                 //here we send all data to user event handlers
 878                 _applicationRegionChangedEventHandler(this, e);
 879             }
 880         }
 881
 882         /**
 883           * @brief Event for BatteryLow signal which can be used to subscribe/unsubscribe the event handler
 884           * provided by the user. BatteryLow signal is emitted when the battery level of the device is low.
 885           */
 886         public event DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> BatteryLow
 887         {
 888             add
 889             {
 890                 lock (this)
 891                 {
 892                     // Restricted to only one listener
 893                     if (_applicationBatteryLowEventHandler == null)
 894                     {
 895                         _applicationBatteryLowEventHandler += value;
 896
 897                         _applicationBatteryLowEventCallbackDelegate = new NUIApplicationBatteryLowEventCallbackDelegate(OnNUIApplicationBatteryLow);
 898                         this.BatteryLowSignal().Connect(_applicationBatteryLowEventCallbackDelegate);
 899                     }
 900                 }
 901             }
 902
 903             remove
 904             {
 905                 lock (this)
 906                 {
 907                     if (_applicationBatteryLowEventHandler != null)
 908                     {
 909                         this.BatteryLowSignal().Disconnect(_applicationBatteryLowEventCallbackDelegate);
 910                     }
 911
 912                     _applicationBatteryLowEventHandler -= value;
 913                 }
 914             }
 915         }
 916
 917         // Callback for Application BatteryLowSignal
 918         private void OnNUIApplicationBatteryLow(BatteryStatus status)
 919         {
 920             NUIApplicationBatteryLowEventArgs e = new NUIApplicationBatteryLowEventArgs();
 921
 922             // Populate all members of "e" (NUIApplicationBatteryLowEventArgs) with real data
 923             e.BatteryStatus = status;
 924
 925             if (_applicationBatteryLowEventHandler != null)
 926             {
 927                 //here we send all data to user event handlers
 928                 _applicationBatteryLowEventHandler(this, e);
 929             }
 930         }
 931
 932         /**
 933           * @brief Event for MemoryLow signal which can be used to subscribe/unsubscribe the event handler
 934           *  provided by the user. MemoryLow signal is emitted when the memory level of the device is low.
 935           */
 936         public event DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> MemoryLow
 937         {
 938             add
 939             {
 940                 lock (this)
 941                 {
 942                     // Restricted to only one listener
 943                     if (_applicationMemoryLowEventHandler == null)
 944                     {
 945                         _applicationMemoryLowEventHandler += value;
 946
 947                         _applicationMemoryLowEventCallbackDelegate = new NUIApplicationMemoryLowEventCallbackDelegate(OnNUIApplicationMemoryLow);
 948                         this.MemoryLowSignal().Connect(_applicationMemoryLowEventCallbackDelegate);
 949                     }
 950                 }
 951             }
 952
 953             remove
 954             {
 955                 lock (this)
 956                 {
 957                     if (_applicationMemoryLowEventHandler != null)
 958                     {
 959                         this.MemoryLowSignal().Disconnect(_applicationMemoryLowEventCallbackDelegate);
 960                     }
 961
 962                     _applicationMemoryLowEventHandler -= value;
 963                 }
 964             }
 965         }
 966
 967         // Callback for Application MemoryLowSignal
 968         private void OnNUIApplicationMemoryLow(MemoryStatus status)
 969         {
 970             NUIApplicationMemoryLowEventArgs e = new NUIApplicationMemoryLowEventArgs();
 971
 972             // Populate all members of "e" (NUIApplicationMemoryLowEventArgs) with real data
 973             e.MemoryStatus = status;
 974
 975             if (_applicationMemoryLowEventHandler != null)
 976             {
 977                 //here we send all data to user event handlers
 978                 _applicationMemoryLowEventHandler(this, e);
 979             }
 980         }
 981
 982         /**
 983           * @brief Event for AppControl signal which can be used to subscribe/unsubscribe the event handler
 984           *  provided by the user. AppControl signal is emitted when another application sends a launch request to the application.
 985           */
 986         public event DaliEventHandler<object, NUIApplicationAppControlEventArgs> AppControl
 987         {
 988             add
 989             {
 990                 lock (this)
 991                 {
 992                     // Restricted to only one listener
 993                     if (_applicationAppControlEventHandler == null)
 994                     {
 995                         _applicationAppControlEventHandler += value;
 996
 997                         _applicationAppControlEventCallbackDelegate = new NUIApplicationAppControlEventCallbackDelegate(OnNUIApplicationAppControl);
 998                         this.AppControlSignal().Connect(_applicationAppControlEventCallbackDelegate);
 999                     }
1000                 }
1001             }
1002
1003             remove
1004             {
1005                 lock (this)
1006                 {
1007                     if (_applicationAppControlEventHandler != null)
1008                     {
1009                         this.AppControlSignal().Disconnect(_applicationAppControlEventCallbackDelegate);
1010                     }
1011
1012                     _applicationAppControlEventHandler -= value;
1013                 }
1014             }
1015         }
1016
1017         // Callback for Application AppControlSignal
1018         private void OnNUIApplicationAppControl(IntPtr application, IntPtr voidp)
1019         {
1020             NUIApplicationAppControlEventArgs e = new NUIApplicationAppControlEventArgs();
1021
1022             // Populate all members of "e" (NUIApplicationAppControlEventArgs) with real data
1023             e.Application = Application.GetApplicationFromPtr(application);
1024             e.VoidP = voidp;
1025
1026             if (_applicationAppControlEventHandler != null)
1027             {
1028                 //here we send all data to user event handlers
1029                 _applicationAppControlEventHandler(this, e);
1030             }
1031         }
1032
1033         private static Application _instance; // singleton
1034
1035         public static Application Instance
1036         {
1037             get
1038             {
1039                 return _instance;
1040             }
1041         }
1042
1043         public static Application GetApplicationFromPtr(global::System.IntPtr cPtr)
1044         {
1045             Application ret = new Application(cPtr, false);
1046             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1047             return ret;
1048         }
1049
1050         public static Application NewApplication()
1051         {
1052             return NewApplication("", Application.WindowMode.Opaque);
1053         }
1054
1055         public static Application NewApplication(string stylesheet)
1056         {
1057             return NewApplication(stylesheet, Application.WindowMode.Opaque);
1058         }
1059
1060         public static Application NewApplication(string stylesheet, Application.WindowMode windowMode)
1061         {
1062             // register all Views with the type registry, so that can be created / styled via JSON
1063             //ViewRegistryHelper.Initialize(); //moved to Application side.
1064
1065             Application ret = New(1, stylesheet, windowMode);
1066             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1067
1068             // set the singleton
1069             _instance = ret;
1070             return ret;
1071         }
1072
1073
1074         public static Application NewApplication(string[] args, string stylesheet, Application.WindowMode windowMode)
1075         {
1076             NUILog.Debug(" NewApplication(string[] args, string stylesheet, Application.WindowMode windowMode) is called! ");
1077
1078             Application ret = New(args, stylesheet, (Application.WindowMode)windowMode);
1079             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1080
1081             // set the singleton
1082             _instance = ret;
1083             return _instance;
1084         }
1085
1086         /// <summary>
1087         /// Ensures that the function passed in is called from the main loop when it is idle.
1088         /// </summary>
1089         /// <param name="func">The function to call</param>
1090         /// <returns>true if added successfully, false otherwise</returns>
1091         public bool AddIdle(System.Delegate func)
1092         {
1093             System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate<System.Delegate>(func);
1094             System.IntPtr ip2 = NDalicManualPINVOKE.MakeCallback(new System.Runtime.InteropServices.HandleRef(this, ip));
1095
1096             bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip2));
1097
1098             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1099             return ret;
1100         }
1101
1102         /**
1103         * Outer::outer_method(int)
1104         */
1105         public static Application New()
1106         {
1107             NUILog.Debug("New() is called!");
1108
1109             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_0(), true);
1110             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1111             return ret;
1112         }
1113
1114         public static Application New(int argc)
1115         {
1116             NUILog.Debug("New(int argc) is called!");
1117
1118             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_1(argc), true);
1119             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1120             return ret;
1121         }
1122
1123         public static Application New(int argc, string stylesheet)
1124         {
1125             NUILog.Debug("New(int argc, string stylesheet) is called!");
1126
1127             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_2(argc, stylesheet), true);
1128             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1129             return ret;
1130         }
1131
1132         public static Application New(int argc, string stylesheet, Application.WindowMode windowMode)
1133         {
1134             NUILog.Debug("New(int argc, string stylesheet, Application.WindowMode windowMode) is called!");
1135
1136             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_3(argc, stylesheet, (int)windowMode), true);
1137             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1138             return ret;
1139         }
1140
1141         public static Application New(string[] args, string stylesheet, Application.WindowMode windowMode)
1142         {
1143             NUILog.Debug("New(string[] args) is called!");
1144             int argc = args.Length;
1145             string argvStr = string.Join(" ", args);
1146
1147             Application ret = new Application(NDalicPINVOKE.Application_New__MANUAL_4(argc, argvStr, stylesheet, (int)windowMode), true);
1148             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1149             return ret;
1150         }
1151
1152         public static Application New(int argc, string stylesheet, Application.WindowMode windowMode, Rectangle positionSize)
1153         {
1154             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_4(argc, stylesheet, (int)windowMode, Rectangle.getCPtr(positionSize)), true);
1155             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1156             return ret;
1157         }
1158
1159         public Application() : this(NDalicPINVOKE.new_Application__SWIG_0(), true)
1160         {
1161             NUILog.Debug("Application() is called!");
1162
1163             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1164         }
1165
1166         public Application(Application application) : this(NDalicPINVOKE.new_Application__SWIG_1(Application.getCPtr(application)), true)
1167         {
1168             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1169         }
1170
1171         public Application Assign(Application application)
1172         {
1173             Application ret = new Application(NDalicPINVOKE.Application_Assign(swigCPtr, Application.getCPtr(application)), false);
1174             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1175             return ret;
1176         }
1177
1178         public void MainLoop()
1179         {
1180             NDalicPINVOKE.Application_MainLoop__SWIG_0(swigCPtr);
1181             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1182         }
1183
1184         internal void MainLoop(SWIGTYPE_p_Configuration__ContextLoss configuration)
1185         {
1186             NDalicPINVOKE.Application_MainLoop__SWIG_1(swigCPtr, SWIGTYPE_p_Configuration__ContextLoss.getCPtr(configuration));
1187             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1188         }
1189
1190         public void Lower()
1191         {
1192             NDalicPINVOKE.Application_Lower(swigCPtr);
1193             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1194         }
1195
1196         public void Quit()
1197         {
1198             NDalicPINVOKE.Application_Quit(swigCPtr);
1199             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1200         }
1201
1202         internal bool AddIdle(SWIGTYPE_p_Dali__CallbackBase callback)
1203         {
1204             bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, SWIGTYPE_p_Dali__CallbackBase.getCPtr(callback));
1205             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1206             return ret;
1207         }
1208
1209         public Window GetWindow()
1210         {
1211             Window ret = new Window(NDalicPINVOKE.Application_GetWindow(swigCPtr), true);
1212             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1213             return ret;
1214         }
1215
1216         public void ReplaceWindow(Rectangle windowPosition, string name)
1217         {
1218             NDalicPINVOKE.Application_ReplaceWindow(swigCPtr, Rectangle.getCPtr(windowPosition), name);
1219             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1220         }
1221
1222         public static string GetResourcePath()
1223         {
1224             string ret = NDalicPINVOKE.Application_GetResourcePath();
1225             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1226             return ret;
1227         }
1228
1229         internal void SetViewMode(ViewMode viewMode)
1230         {
1231             NDalicPINVOKE.Application_SetViewMode(swigCPtr, (int)viewMode);
1232             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1233         }
1234
1235         internal ViewMode GetViewMode()
1236         {
1237             ViewMode ret = (ViewMode)NDalicPINVOKE.Application_GetViewMode(swigCPtr);
1238             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1239             return ret;
1240         }
1241
1242         public void SetStereoBase(float stereoBase)
1243         {
1244             NDalicPINVOKE.Application_SetStereoBase(swigCPtr, stereoBase);
1245             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1246         }
1247
1248         public float GetStereoBase()
1249         {
1250             float ret = NDalicPINVOKE.Application_GetStereoBase(swigCPtr);
1251             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1252             return ret;
1253         }
1254
1255         public string GetLanguage()
1256         {
1257             string ret = NDalicPINVOKE.Application_GetLanguage(swigCPtr);
1258             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1259             return ret;
1260         }
1261
1262         public string GetRegion()
1263         {
1264             string ret = NDalicPINVOKE.Application_GetRegion(swigCPtr);
1265             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1266             return ret;
1267         }
1268
1269
1270         internal ApplicationSignal InitSignal()
1271         {
1272             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_InitSignal(swigCPtr), false);
1273             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1274             return ret;
1275         }
1276
1277         internal ApplicationSignal TerminateSignal()
1278         {
1279             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_TerminateSignal(swigCPtr), false);
1280             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1281             return ret;
1282         }
1283
1284         internal ApplicationSignal PauseSignal()
1285         {
1286             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_PauseSignal(swigCPtr), false);
1287             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1288             return ret;
1289         }
1290
1291         internal ApplicationSignal ResumeSignal()
1292         {
1293             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResumeSignal(swigCPtr), false);
1294             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1295             return ret;
1296         }
1297
1298         internal ApplicationSignal ResetSignal()
1299         {
1300             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResetSignal(swigCPtr), false);
1301             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1302             return ret;
1303         }
1304
1305         internal ApplicationSignal ResizeSignal()
1306         {
1307             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResizeSignal(swigCPtr), false);
1308             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1309             return ret;
1310         }
1311
1312         internal ApplicationControlSignal AppControlSignal()
1313         {
1314             ApplicationControlSignal ret = new ApplicationControlSignal(NDalicPINVOKE.Application_AppControlSignal(swigCPtr), false);
1315             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1316             return ret;
1317         }
1318
1319         internal ApplicationSignal LanguageChangedSignal()
1320         {
1321             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_LanguageChangedSignal(swigCPtr), false);
1322             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1323             return ret;
1324         }
1325
1326         internal ApplicationSignal RegionChangedSignal()
1327         {
1328             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_RegionChangedSignal(swigCPtr), false);
1329             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1330             return ret;
1331         }
1332
1333         internal LowBatterySignalType BatteryLowSignal()
1334         {
1335             LowBatterySignalType ret = new LowBatterySignalType(NDalicPINVOKE.Application_LowBatterySignal(swigCPtr), false);
1336             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1337             return ret;
1338         }
1339
1340         internal LowMemorySignalType MemoryLowSignal()
1341         {
1342             LowMemorySignalType ret = new LowMemorySignalType(NDalicPINVOKE.Application_LowMemorySignal(swigCPtr), false);
1343             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1344             return ret;
1345         }
1346
1347         /// <since_tizen> 3 </since_tizen>
1348         public enum WindowMode
1349         {
1350             Opaque = 0,
1351             Transparent = 1
1352         }
1353
1354     }
1355
1356 }