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