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 = 34;
  23         public const int nuiVer1 = 0;
  24         public const int nuiVer2 = 2;
  25         public const int nuiVer3 = 34;
  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         ~Application()
 325         {
 326             DisposeQueue.Instance.Add(this);
 327         }
 328
 329         public override void Dispose()
 330         {
 331             if (!Stage.IsInstalled())
 332             {
 333                 DisposeQueue.Instance.Add(this);
 334                 return;
 335             }
 336
 337             lock (this)
 338             {
 339                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
 340                 {
 341                     if (swigCMemOwn)
 342                     {
 343                         swigCMemOwn = false;
 344                         NDalicPINVOKE.delete_Application(swigCPtr);
 345                     }
 346                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 347                 }
 348                 global::System.GC.SuppressFinalize(this);
 349                 base.Dispose();
 350             }
 351         }
 352
 353         private static void LOG(string str)
 354         {
 355             //Tizen.Log.Debug("NUI", str);
 356         }
 357
 358         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 359         private delegate void NUIApplicationInitEventCallbackDelegate(IntPtr application);
 360         private DaliEventHandler<object, NUIApplicationInitEventArgs> _applicationInitEventHandler;
 361         private NUIApplicationInitEventCallbackDelegate _applicationInitEventCallbackDelegate;
 362
 363
 364         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 365         private delegate void NUIApplicationTerminateEventCallbackDelegate(IntPtr application);
 366         private DaliEventHandler<object, NUIApplicationTerminateEventArgs> _applicationTerminateEventHandler;
 367         private NUIApplicationTerminateEventCallbackDelegate _applicationTerminateEventCallbackDelegate;
 368
 369
 370         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 371         private delegate void NUIApplicationPauseEventCallbackDelegate(IntPtr application);
 372         private DaliEventHandler<object, NUIApplicationPauseEventArgs> _applicationPauseEventHandler;
 373         private NUIApplicationPauseEventCallbackDelegate _applicationPauseEventCallbackDelegate;
 374
 375         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 376         private delegate void NUIApplicationResumeEventCallbackDelegate(IntPtr application);
 377         private DaliEventHandler<object, NUIApplicationResumeEventArgs> _applicationResumeEventHandler;
 378         private NUIApplicationResumeEventCallbackDelegate _applicationResumeEventCallbackDelegate;
 379
 380         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 381         private delegate void NUIApplicationResetEventCallbackDelegate(IntPtr application);
 382         private DaliEventHandler<object, NUIApplicationResetEventArgs> _applicationResetEventHandler;
 383         private NUIApplicationResetEventCallbackDelegate _applicationResetEventCallbackDelegate;
 384
 385         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 386         private delegate void NUIApplicationResizeEventCallbackDelegate(IntPtr application);
 387         private DaliEventHandler<object, NUIApplicationResizeEventArgs> _applicationResizeEventHandler;
 388         private NUIApplicationResizeEventCallbackDelegate _applicationResizeEventCallbackDelegate;
 389
 390         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 391         private delegate void NUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
 392         private DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> _applicationLanguageChangedEventHandler;
 393         private NUIApplicationLanguageChangedEventCallbackDelegate _applicationLanguageChangedEventCallbackDelegate;
 394
 395
 396         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 397         private delegate void NUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
 398         private DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> _applicationRegionChangedEventHandler;
 399         private NUIApplicationRegionChangedEventCallbackDelegate _applicationRegionChangedEventCallbackDelegate;
 400
 401         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 402         private delegate void NUIApplicationBatteryLowEventCallbackDelegate(IntPtr application);
 403         private DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> _applicationBatteryLowEventHandler;
 404         private NUIApplicationBatteryLowEventCallbackDelegate _applicationBatteryLowEventCallbackDelegate;
 405
 406         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 407         private delegate void NUIApplicationMemoryLowEventCallbackDelegate(IntPtr application);
 408         private DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> _applicationMemoryLowEventHandler;
 409         private NUIApplicationMemoryLowEventCallbackDelegate _applicationMemoryLowEventCallbackDelegate;
 410
 411         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 412         private delegate void NUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
 413         private DaliEventHandler<object, NUIApplicationAppControlEventArgs> _applicationAppControlEventHandler;
 414         private NUIApplicationAppControlEventCallbackDelegate _applicationAppControlEventCallbackDelegate;
 415
 416         /**
 417           * @brief Event for Initialized signal which can be used to subscribe/unsubscribe the event handler
 418           * (in the type of NUIApplicationInitEventHandler - DaliEventHandler<object,NUIApplicationInitEventArgs>)
 419           *  provided by the user. Initialized signal is emitted when application is initialised
 420           */
 421         public event DaliEventHandler<object, NUIApplicationInitEventArgs> Initialized
 422         {
 423             add
 424             {
 425                 lock (this)
 426                 {
 427                     // Restricted to only one listener
 428                     if (_applicationInitEventHandler == null)
 429                     {
 430                         _applicationInitEventHandler += value;
 431
 432                         _applicationInitEventCallbackDelegate = new NUIApplicationInitEventCallbackDelegate(OnApplicationInit);
 433                         this.InitSignal().Connect(_applicationInitEventCallbackDelegate);
 434                     }
 435                 }
 436             }
 437
 438             remove
 439             {
 440                 lock (this)
 441                 {
 442                     if (_applicationInitEventHandler != null)
 443                     {
 444                         this.InitSignal().Disconnect(_applicationInitEventCallbackDelegate);
 445                     }
 446
 447                     _applicationInitEventHandler -= value;
 448                 }
 449             }
 450         }
 451
 452         // Callback for Application InitSignal
 453         private void OnApplicationInit(IntPtr data)
 454         {
 455             // Initialize DisposeQueue Singleton class. This is also required to create DisposeQueue on main thread.
 456             DisposeQueue.Instance.Initialize();
 457             NUIApplicationInitEventArgs e = new NUIApplicationInitEventArgs();
 458
 459             // Populate all members of "e" (NUIApplicationInitEventArgs) with real data
 460             e.Application = Application.GetApplicationFromPtr(data);
 461
 462             if (_applicationInitEventHandler != null)
 463             {
 464                 //here we send all data to user event handlers
 465                 _applicationInitEventHandler(this, e);
 466             }
 467         }
 468
 469         /**
 470           * @brief Event for Terminated signal which can be used to subscribe/unsubscribe the event handler
 471           * (in the type of NUIApplicationTerminateEventHandler-DaliEventHandler<object,NUIApplicationTerminateEventArgs>)
 472           *  provided by the user. Terminated signal is emitted when application is terminated
 473           */
 474         public event DaliEventHandler<object, NUIApplicationTerminateEventArgs> Terminated
 475         {
 476             add
 477             {
 478                 lock (this)
 479                 {
 480                     // Restricted to only one listener
 481                     if (_applicationTerminateEventHandler == null)
 482                     {
 483                         _applicationTerminateEventHandler += value;
 484
 485                         _applicationTerminateEventCallbackDelegate = new NUIApplicationTerminateEventCallbackDelegate(OnNUIApplicationTerminate);
 486                         this.TerminateSignal().Connect(_applicationTerminateEventCallbackDelegate);
 487                     }
 488                 }
 489             }
 490
 491             remove
 492             {
 493                 lock (this)
 494                 {
 495                     if (_applicationTerminateEventHandler != null)
 496                     {
 497                         this.TerminateSignal().Disconnect(_applicationTerminateEventCallbackDelegate);
 498                     }
 499
 500                     _applicationTerminateEventHandler -= value;
 501                 }
 502             }
 503         }
 504
 505         // Callback for Application TerminateSignal
 506         private void OnNUIApplicationTerminate(IntPtr data)
 507         {
 508             NUIApplicationTerminateEventArgs e = new NUIApplicationTerminateEventArgs();
 509
 510             // Populate all members of "e" (NUIApplicationTerminateEventArgs) with real data
 511             e.Application = Application.GetApplicationFromPtr(data);
 512
 513             if (_applicationTerminateEventHandler != null)
 514             {
 515                 //here we send all data to user event handlers
 516                 _applicationTerminateEventHandler(this, e);
 517             }
 518         }
 519
 520         /**
 521           * @brief Event for Paused signal which can be used to subscribe/unsubscribe the event handler
 522           * (in the type of NUIApplicationPauseEventHandler-DaliEventHandler<object,NUIApplicationPauseEventArgs>)
 523           * provided by the user. Paused signal is emitted when application is paused
 524           */
 525         public event DaliEventHandler<object, NUIApplicationPauseEventArgs> Paused
 526         {
 527             add
 528             {
 529                 lock (this)
 530                 {
 531                     // Restricted to only one listener
 532                     if (_applicationPauseEventHandler == null)
 533                     {
 534                         _applicationPauseEventHandler += value;
 535
 536                         _applicationPauseEventCallbackDelegate = new NUIApplicationPauseEventCallbackDelegate(OnNUIApplicationPause);
 537                         this.PauseSignal().Connect(_applicationPauseEventCallbackDelegate);
 538                     }
 539                 }
 540             }
 541
 542             remove
 543             {
 544                 lock (this)
 545                 {
 546                     if (_applicationPauseEventHandler != null)
 547                     {
 548                         this.PauseSignal().Disconnect(_applicationPauseEventCallbackDelegate);
 549                     }
 550
 551                     _applicationPauseEventHandler -= value;
 552                 }
 553             }
 554         }
 555
 556         // Callback for Application PauseSignal
 557         private void OnNUIApplicationPause(IntPtr data)
 558         {
 559             NUIApplicationPauseEventArgs e = new NUIApplicationPauseEventArgs();
 560
 561             // Populate all members of "e" (NUIApplicationPauseEventArgs) with real data
 562             e.Application = Application.GetApplicationFromPtr(data);
 563
 564             if (_applicationPauseEventHandler != null)
 565             {
 566                 //here we send all data to user event handlers
 567                 _applicationPauseEventHandler(this, e);
 568             }
 569         }
 570
 571         /**
 572           * @brief Event for Resumed signal which can be used to subscribe/unsubscribe the event handler
 573           * (in the type of NUIApplicationResumeEventHandler-DaliEventHandler<object,NUIApplicationResumeEventArgs>)
 574           *  provided by the user. Resumed signal is emitted when application is resumed
 575           */
 576         public event DaliEventHandler<object, NUIApplicationResumeEventArgs> Resumed
 577         {
 578             add
 579             {
 580                 lock (this)
 581                 {
 582                     // Restricted to only one listener
 583                     if (_applicationResumeEventHandler == null)
 584                     {
 585                         _applicationResumeEventHandler += value;
 586
 587                         _applicationResumeEventCallbackDelegate = new NUIApplicationResumeEventCallbackDelegate(OnNUIApplicationResume);
 588                         this.ResumeSignal().Connect(_applicationResumeEventCallbackDelegate);
 589                     }
 590                 }
 591             }
 592
 593             remove
 594             {
 595                 lock (this)
 596                 {
 597                     if (_applicationResumeEventHandler != null)
 598                     {
 599                         this.ResumeSignal().Disconnect(_applicationResumeEventCallbackDelegate);
 600                     }
 601
 602                     _applicationResumeEventHandler -= value;
 603                 }
 604             }
 605         }
 606
 607         // Callback for Application ResumeSignal
 608         private void OnNUIApplicationResume(IntPtr data)
 609         {
 610             NUIApplicationResumeEventArgs e = new NUIApplicationResumeEventArgs();
 611
 612             // Populate all members of "e" (NUIApplicationResumeEventArgs) with real data
 613             e.Application = Application.GetApplicationFromPtr(data);
 614
 615             if (_applicationResumeEventHandler != null)
 616             {
 617                 //here we send all data to user event handlers
 618                 _applicationResumeEventHandler(this, e);
 619             }
 620         }
 621
 622         /**
 623           * @brief Event for Reset signal which can be used to subscribe/unsubscribe the event handler
 624           * (in the type of NUIApplicationResetEventHandler-DaliEventHandler<object,NUIApplicationResetEventArgs>)
 625           *  provided by the user. Reset signal is emitted when application is reset
 626           */
 627         public event DaliEventHandler<object, NUIApplicationResetEventArgs> Reset
 628         {
 629             add
 630             {
 631                 lock (this)
 632                 {
 633                     // Restricted to only one listener
 634                     if (_applicationResetEventHandler == null)
 635                     {
 636                         _applicationResetEventHandler += value;
 637
 638                         _applicationResetEventCallbackDelegate = new NUIApplicationResetEventCallbackDelegate(OnNUIApplicationReset);
 639                         this.ResetSignal().Connect(_applicationResetEventCallbackDelegate);
 640                     }
 641                 }
 642             }
 643
 644             remove
 645             {
 646                 lock (this)
 647                 {
 648                     if (_applicationResetEventHandler != null)
 649                     {
 650                         this.ResetSignal().Disconnect(_applicationResetEventCallbackDelegate);
 651                     }
 652
 653                     _applicationResetEventHandler -= value;
 654                 }
 655             }
 656         }
 657
 658         // Callback for Application ResetSignal
 659         private void OnNUIApplicationReset(IntPtr data)
 660         {
 661             NUIApplicationResetEventArgs e = new NUIApplicationResetEventArgs();
 662
 663             // Populate all members of "e" (NUIApplicationResetEventArgs) with real data
 664             e.Application = Application.GetApplicationFromPtr(data);
 665
 666             if (_applicationResetEventHandler != null)
 667             {
 668                 //here we send all data to user event handlers
 669                 _applicationResetEventHandler(this, e);
 670             }
 671         }
 672
 673         /**
 674           * @brief Event for Resized signal which can be used to subscribe/unsubscribe the event handler
 675           * (in the type of NUIApplicationResizeEventHandler-DaliEventHandler<object,NUIApplicationResizeEventArgs>)
 676           *  provided by the user. Resized signal is emitted when application is resized
 677           */
 678         public event DaliEventHandler<object, NUIApplicationResizeEventArgs> Resized
 679         {
 680             add
 681             {
 682                 lock (this)
 683                 {
 684                     // Restricted to only one listener
 685                     if (_applicationResizeEventHandler == null)
 686                     {
 687                         _applicationResizeEventHandler += value;
 688
 689                         _applicationResizeEventCallbackDelegate = new NUIApplicationResizeEventCallbackDelegate(OnNUIApplicationResize);
 690                         this.ResizeSignal().Connect(_applicationResizeEventCallbackDelegate);
 691                     }
 692                 }
 693             }
 694
 695             remove
 696             {
 697                 lock (this)
 698                 {
 699                     if (_applicationResizeEventHandler != null)
 700                     {
 701                         this.ResizeSignal().Disconnect(_applicationResizeEventCallbackDelegate);
 702                     }
 703
 704                     _applicationResizeEventHandler -= value;
 705                 }
 706             }
 707         }
 708
 709         // Callback for Application ResizeSignal
 710         private void OnNUIApplicationResize(IntPtr data)
 711         {
 712             NUIApplicationResizeEventArgs e = new NUIApplicationResizeEventArgs();
 713
 714             // Populate all members of "e" (NUIApplicationResizeEventArgs) with real data
 715             e.Application = Application.GetApplicationFromPtr(data);
 716
 717             if (_applicationResizeEventHandler != null)
 718             {
 719                 //here we send all data to user event handlers
 720                 _applicationResizeEventHandler(this, e);
 721             }
 722         }
 723
 724         /**
 725           * @brief Event for LanguageChanged signal which can be used to subscribe/unsubscribe the event handler
 726           * (in the type of NUIApplicationLanguageChangedEventHandler-DaliEventHandler<object,NUIApplicationLanguageChangedEventArgs>)
 727           *  provided by the user. LanguageChanged signal is emitted when the region of the device is changed.
 728           */
 729         public event DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> LanguageChanged
 730         {
 731             add
 732             {
 733                 lock (this)
 734                 {
 735                     // Restricted to only one listener
 736                     if (_applicationLanguageChangedEventHandler == null)
 737                     {
 738                         _applicationLanguageChangedEventHandler += value;
 739
 740                         _applicationLanguageChangedEventCallbackDelegate = new NUIApplicationLanguageChangedEventCallbackDelegate(OnNUIApplicationLanguageChanged);
 741                         this.LanguageChangedSignal().Connect(_applicationLanguageChangedEventCallbackDelegate);
 742                     }
 743                 }
 744             }
 745
 746             remove
 747             {
 748                 lock (this)
 749                 {
 750                     if (_applicationLanguageChangedEventHandler != null)
 751                     {
 752                         this.LanguageChangedSignal().Disconnect(_applicationLanguageChangedEventCallbackDelegate);
 753                     }
 754
 755                     _applicationLanguageChangedEventHandler -= value;
 756                 }
 757             }
 758         }
 759
 760         // Callback for Application LanguageChangedSignal
 761         private void OnNUIApplicationLanguageChanged(IntPtr data)
 762         {
 763             NUIApplicationLanguageChangedEventArgs e = new NUIApplicationLanguageChangedEventArgs();
 764
 765             // Populate all members of "e" (NUIApplicationLanguageChangedEventArgs) with real data
 766             e.Application = Application.GetApplicationFromPtr(data);
 767
 768             if (_applicationLanguageChangedEventHandler != null)
 769             {
 770                 //here we send all data to user event handlers
 771                 _applicationLanguageChangedEventHandler(this, e);
 772             }
 773         }
 774
 775         /**
 776           * @brief Event for RegionChanged signal which can be used to subscribe/unsubscribe the event handler
 777           * (in the type of NUIApplicationRegionChangedEventHandler-DaliEventHandler<object,NUIApplicationRegionChangedEventArgs>)
 778           *  provided by the user. RegionChanged signal is emitted when the region of the device is changed.
 779           */
 780         public event DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> RegionChanged
 781         {
 782             add
 783             {
 784                 lock (this)
 785                 {
 786                     // Restricted to only one listener
 787                     if (_applicationRegionChangedEventHandler == null)
 788                     {
 789                         _applicationRegionChangedEventHandler += value;
 790
 791                         _applicationRegionChangedEventCallbackDelegate = new NUIApplicationRegionChangedEventCallbackDelegate(OnNUIApplicationRegionChanged);
 792                         this.RegionChangedSignal().Connect(_applicationRegionChangedEventCallbackDelegate);
 793                     }
 794                 }
 795             }
 796
 797             remove
 798             {
 799                 lock (this)
 800                 {
 801                     if (_applicationRegionChangedEventHandler != null)
 802                     {
 803                         this.RegionChangedSignal().Disconnect(_applicationRegionChangedEventCallbackDelegate);
 804                     }
 805
 806                     _applicationRegionChangedEventHandler -= value;
 807                 }
 808             }
 809         }
 810
 811         // Callback for Application RegionChangedSignal
 812         private void OnNUIApplicationRegionChanged(IntPtr data)
 813         {
 814             NUIApplicationRegionChangedEventArgs e = new NUIApplicationRegionChangedEventArgs();
 815
 816             // Populate all members of "e" (NUIApplicationRegionChangedEventArgs) with real data
 817             e.Application = Application.GetApplicationFromPtr(data);
 818
 819             if (_applicationRegionChangedEventHandler != null)
 820             {
 821                 //here we send all data to user event handlers
 822                 _applicationRegionChangedEventHandler(this, e);
 823             }
 824         }
 825
 826         /**
 827           * @brief Event for BatteryLow signal which can be used to subscribe/unsubscribe the event handler
 828           * (in the type of NUIApplicationBatteryLowEventHandler-DaliEventHandler<object,NUIApplicationBatteryLowEventArgs>)
 829           * provided by the user. BatteryLow signal is emitted when the battery level of the device is low.
 830           */
 831         public event DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> BatteryLow
 832         {
 833             add
 834             {
 835                 lock (this)
 836                 {
 837                     // Restricted to only one listener
 838                     if (_applicationBatteryLowEventHandler == null)
 839                     {
 840                         _applicationBatteryLowEventHandler += value;
 841
 842                         _applicationBatteryLowEventCallbackDelegate = new NUIApplicationBatteryLowEventCallbackDelegate(OnNUIApplicationBatteryLow);
 843                         this.BatteryLowSignal().Connect(_applicationBatteryLowEventCallbackDelegate);
 844                     }
 845                 }
 846             }
 847
 848             remove
 849             {
 850                 lock (this)
 851                 {
 852                     if (_applicationBatteryLowEventHandler != null)
 853                     {
 854                         this.BatteryLowSignal().Disconnect(_applicationBatteryLowEventCallbackDelegate);
 855                     }
 856
 857                     _applicationBatteryLowEventHandler -= value;
 858                 }
 859             }
 860         }
 861
 862         // Callback for Application BatteryLowSignal
 863         private void OnNUIApplicationBatteryLow(IntPtr data)
 864         {
 865             NUIApplicationBatteryLowEventArgs e = new NUIApplicationBatteryLowEventArgs();
 866
 867             // Populate all members of "e" (NUIApplicationBatteryLowEventArgs) with real data
 868             e.Application = Application.GetApplicationFromPtr(data);
 869
 870             if (_applicationBatteryLowEventHandler != null)
 871             {
 872                 //here we send all data to user event handlers
 873                 _applicationBatteryLowEventHandler(this, e);
 874             }
 875         }
 876
 877         /**
 878           * @brief Event for MemoryLow signal which can be used to subscribe/unsubscribe the event handler
 879           * (in the type of NUIApplicationMemoryLowEventHandler-DaliEventHandler<object,NUIApplicationMemoryLowEventArgs>)
 880           *  provided by the user. MemoryLow signal is emitted when the memory level of the device is low.
 881           */
 882         public event DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> MemoryLow
 883         {
 884             add
 885             {
 886                 lock (this)
 887                 {
 888                     // Restricted to only one listener
 889                     if (_applicationMemoryLowEventHandler == null)
 890                     {
 891                         _applicationMemoryLowEventHandler += value;
 892
 893                         _applicationMemoryLowEventCallbackDelegate = new NUIApplicationMemoryLowEventCallbackDelegate(OnNUIApplicationMemoryLow);
 894                         this.MemoryLowSignal().Connect(_applicationMemoryLowEventCallbackDelegate);
 895                     }
 896                 }
 897             }
 898
 899             remove
 900             {
 901                 lock (this)
 902                 {
 903                     if (_applicationMemoryLowEventHandler != null)
 904                     {
 905                         this.MemoryLowSignal().Disconnect(_applicationMemoryLowEventCallbackDelegate);
 906                     }
 907
 908                     _applicationMemoryLowEventHandler -= value;
 909                 }
 910             }
 911         }
 912
 913         // Callback for Application MemoryLowSignal
 914         private void OnNUIApplicationMemoryLow(IntPtr data)
 915         {
 916             NUIApplicationMemoryLowEventArgs e = new NUIApplicationMemoryLowEventArgs();
 917
 918             // Populate all members of "e" (NUIApplicationMemoryLowEventArgs) with real data
 919             e.Application = Application.GetApplicationFromPtr(data);
 920
 921             if (_applicationMemoryLowEventHandler != null)
 922             {
 923                 //here we send all data to user event handlers
 924                 _applicationMemoryLowEventHandler(this, e);
 925             }
 926         }
 927
 928         /**
 929           * @brief Event for AppControl signal which can be used to subscribe/unsubscribe the event handler
 930           * (in the type of NUIApplicationAppControlEventHandler-DaliEventHandler<object,NUIApplicationAppControlEventArgs>)
 931           *  provided by the user. AppControl signal is emitted when another application sends a launch request to the application.
 932           */
 933         public event DaliEventHandler<object, NUIApplicationAppControlEventArgs> AppControl
 934         {
 935             add
 936             {
 937                 lock (this)
 938                 {
 939                     // Restricted to only one listener
 940                     if (_applicationAppControlEventHandler == null)
 941                     {
 942                         _applicationAppControlEventHandler += value;
 943
 944                         _applicationAppControlEventCallbackDelegate = new NUIApplicationAppControlEventCallbackDelegate(OnNUIApplicationAppControl);
 945                         this.AppControlSignal().Connect(_applicationAppControlEventCallbackDelegate);
 946                     }
 947                 }
 948             }
 949
 950             remove
 951             {
 952                 lock (this)
 953                 {
 954                     if (_applicationAppControlEventHandler != null)
 955                     {
 956                         this.AppControlSignal().Disconnect(_applicationAppControlEventCallbackDelegate);
 957                     }
 958
 959                     _applicationAppControlEventHandler -= value;
 960                 }
 961             }
 962         }
 963
 964         // Callback for Application AppControlSignal
 965         private void OnNUIApplicationAppControl(IntPtr application, IntPtr voidp)
 966         {
 967             NUIApplicationAppControlEventArgs e = new NUIApplicationAppControlEventArgs();
 968
 969             // Populate all members of "e" (NUIApplicationAppControlEventArgs) with real data
 970             e.Application = Application.GetApplicationFromPtr(application);
 971             e.VoidP = voidp;
 972
 973             if (_applicationAppControlEventHandler != null)
 974             {
 975                 //here we send all data to user event handlers
 976                 _applicationAppControlEventHandler(this, e);
 977             }
 978         }
 979
 980         private static Application _instance; // singleton
 981
 982         public delegate void InitDelegate();
 983
 984         public delegate void TerminateDelegate();
 985
 986         public delegate void PauseDelegate();
 987
 988         public delegate void ResumeDelegate();
 989
 990         public delegate void ResizeDelegate();
 991
 992         public delegate void AppControlDelegate();
 993
 994         public delegate void LanguageChangedDelegate();
 995
 996         public delegate void RegionChangedDelegate();
 997
 998         public delegate void BatteryLowDelegate();
 999
1000         public delegate void MemoryLowDelegate();
1001
1002         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1003         internal delegate void InitDelegateInternal();
1004
1005         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1006         internal delegate void TerminateDelegateInternal();
1007
1008         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1009         internal delegate void PauseDelegateInternal();
1010
1011         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1012         internal delegate void ResumeDelegateInternal();
1013
1014         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1015         internal delegate void ResizeDelegateInternal();
1016
1017         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1018         internal delegate void AppControlDelegateInternal();
1019
1020         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1021         internal delegate void LanguageChangedDelegateInternal();
1022
1023         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1024         internal delegate void RegionChangedDelegateInternal();
1025
1026         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1027         internal delegate void BatteryLowDelegateInternal();
1028
1029         [System.Runtime.InteropServices.UnmanagedFunctionPointer(System.Runtime.InteropServices.CallingConvention.StdCall)]
1030         internal delegate void MemoryLowDelegateInternal();
1031
1032         static void Initialize()
1033         {
1034             //  instance.InitDelegate();
1035         }
1036
1037         public static Application Instance
1038         {
1039             get
1040             {
1041                 return _instance;
1042             }
1043         }
1044
1045         public static Application GetApplicationFromPtr(global::System.IntPtr cPtr)
1046         {
1047             Application ret = new Application(cPtr, false);
1048             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1049             return ret;
1050         }
1051
1052         internal void SetupDelegates()
1053         {
1054             InitDelegateInternal initializeCallback = new InitDelegateInternal(Initialize);
1055             System.Console.WriteLine("InitSignal connection count");
1056
1057             this.InitSignal().Connect(initializeCallback);
1058             //Console.WriteLine( "InitSignal connection count = " + app.InitSignal().GetConnectionCount() );
1059         }
1060
1061         public static Application NewApplication()
1062         {
1063             _instance = NewApplication("", Application.WindowMode.Opaque);
1064             return _instance;
1065         }
1066
1067         public static Application NewApplication(string stylesheet)
1068         {
1069             _instance = NewApplication(stylesheet, Application.WindowMode.Opaque);
1070             return _instance;
1071         }
1072
1073         public static Application NewApplication(string stylesheet, Application.WindowMode windowMode)
1074         {
1075             {
1076                 int ver1 = -1;
1077                 int ver2 = -1;
1078                 int ver3 = -1;
1079
1080                 try
1081                 {
1082                 if (NDalicManualPINVOKE.NativeVersionCheck(ref ver1, ref ver2, ref ver3))
1083                 {
1084                     if (ver1 != Version.ver1 || ver2 != Version.ver2 || ver3 != Version.ver3)
1085                     {
1086                             //throw new System.InvalidOperationException("Dali native version mismatch error! nui=" + Version.ver1 + "." + Version.ver2 + "." + Version.ver3 + " but dali=" + ver1 + "." + ver2 + "." + ver3);
1087                             Tizen.Log.Fatal("NUI", "Dali native version mismatch error! nui=" + Version.nuiVer1 + "." + Version.nuiVer2 + "." + Version.nuiVer3 + Version.nuiRelease + " but native dali=" + ver1 + "." + ver2 + "." + ver3);
1088                     }
1089                 }
1090                 else
1091                 {
1092                         //throw new System.InvalidOperationException("Dali native version mismatch error! nui=" + Version.ver1 + "." + Version.ver2 + "." + Version.ver3 + " but dali=" + ver1 + "." + ver2 + "." + ver3);
1093                         Tizen.Log.Fatal("NUI", "Dali native version mismatch error! nui=" + Version.nuiVer1 + "." + Version.nuiVer2 + "." + Version.nuiVer3 + Version.nuiRelease + " but native dali=" + ver1 + "." + ver2 + "." + ver3);
1094                     }
1095                 }
1096                 catch (Exception e)
1097                 {
1098                     //throw new System.InvalidOperationException("Dali native version is very old! nui=" + Version.ver1 + "." + Version.ver2 + "." + Version.ver3);
1099                     Tizen.Log.Fatal("NUI", "Dali native version is very old! nui=" + Version.nuiVer1 + "." + Version.nuiVer2 + "." + Version.nuiVer3 + Version.nuiRelease);
1100                 }
1101             }
1102
1103             LOG(" NewApplication(string stylesheet, Application.WindowMode windowMode) is called! ");
1104
1105             // register all Views with the type registry, so that can be created / styled via JSON
1106             ViewRegistryHelper.Initialize();
1107
1108             Application ret = New(1, stylesheet, windowMode);
1109             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1110
1111             // we've got an application now connect the signals
1112             ret.SetupDelegates();
1113             // set the singleton
1114             _instance = ret;
1115             return ret;
1116         }
1117
1118         //Removed from v0.2.33
1119         /*public bool AddIdle(System.Delegate func)
1120         {
1121             System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func);
1122             System.IntPtr ip2 = NDalicManualPINVOKE.MakeCallback(new System.Runtime.InteropServices.HandleRef(this, ip));
1123
1124             bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip2));
1125
1126             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1127             return ret;
1128         }*/
1129
1130
1131
1132         /**
1133         * Outer::outer_method(int)
1134         */
1135         public static Application New()
1136         {
1137             LOG("New() is called!");
1138
1139             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_0(), true);
1140             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1141             return ret;
1142         }
1143
1144         public static Application New(int argc)
1145         {
1146             LOG("New(int argc) is called!");
1147
1148             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_1(argc), true);
1149             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1150             return ret;
1151         }
1152
1153         public static Application New(int argc, string stylesheet)
1154         {
1155             LOG("New(int argc, string stylesheet) is called!");
1156
1157             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_2(argc, stylesheet), true);
1158             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1159             return ret;
1160         }
1161
1162         public static Application New(int argc, string stylesheet, Application.WindowMode windowMode)
1163         {
1164             LOG("New(int argc, string stylesheet, Application.WindowMode windowMode) is called!");
1165
1166             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_3(argc, stylesheet, (int)windowMode), true);
1167             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1168             return ret;
1169         }
1170
1171         public Application() : this(NDalicPINVOKE.new_Application__SWIG_0(), true)
1172         {
1173             LOG("Application() is called!");
1174
1175             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1176         }
1177
1178         public Application(Application application) : this(NDalicPINVOKE.new_Application__SWIG_1(Application.getCPtr(application)), true)
1179         {
1180             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1181         }
1182
1183         public Application Assign(Application application)
1184         {
1185             Application ret = new Application(NDalicPINVOKE.Application_Assign(swigCPtr, Application.getCPtr(application)), false);
1186             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1187             return ret;
1188         }
1189
1190         public void MainLoop()
1191         {
1192             NDalicPINVOKE.Application_MainLoop__SWIG_0(swigCPtr);
1193             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1194         }
1195
1196         internal void MainLoop(SWIGTYPE_p_Configuration__ContextLoss configuration)
1197         {
1198             NDalicPINVOKE.Application_MainLoop__SWIG_1(swigCPtr, SWIGTYPE_p_Configuration__ContextLoss.getCPtr(configuration));
1199             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1200         }
1201
1202         public void Lower()
1203         {
1204             NDalicPINVOKE.Application_Lower(swigCPtr);
1205             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1206         }
1207
1208         public void Quit()
1209         {
1210             NDalicPINVOKE.Application_Quit(swigCPtr);
1211             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1212         }
1213
1214         internal bool AddIdle(SWIGTYPE_p_Dali__CallbackBase callback)
1215         {
1216             bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, SWIGTYPE_p_Dali__CallbackBase.getCPtr(callback));
1217             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1218             return ret;
1219         }
1220
1221         public Window GetWindow()
1222         {
1223             Window ret = new Window(NDalicPINVOKE.Application_GetWindow(swigCPtr), true);
1224             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1225             return ret;
1226         }
1227
1228         public void ReplaceWindow(Rectangle windowPosition, string name)
1229         {
1230             NDalicPINVOKE.Application_ReplaceWindow(swigCPtr, Rectangle.getCPtr(windowPosition), name);
1231             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1232         }
1233
1234         public static string GetResourcePath()
1235         {
1236             string ret = NDalicPINVOKE.Application_GetResourcePath();
1237             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1238             return ret;
1239         }
1240
1241         internal void SetViewMode(ViewMode viewMode)
1242         {
1243             NDalicPINVOKE.Application_SetViewMode(swigCPtr, (int)viewMode);
1244             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1245         }
1246
1247         internal ViewMode GetViewMode()
1248         {
1249             ViewMode ret = (ViewMode)NDalicPINVOKE.Application_GetViewMode(swigCPtr);
1250             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1251             return ret;
1252         }
1253
1254         public void SetStereoBase(float stereoBase)
1255         {
1256             NDalicPINVOKE.Application_SetStereoBase(swigCPtr, stereoBase);
1257             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1258         }
1259
1260         public float GetStereoBase()
1261         {
1262             float ret = NDalicPINVOKE.Application_GetStereoBase(swigCPtr);
1263             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1264             return ret;
1265         }
1266
1267         internal ApplicationSignal InitSignal()
1268         {
1269             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_InitSignal(swigCPtr), false);
1270             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1271             return ret;
1272         }
1273
1274         internal ApplicationSignal TerminateSignal()
1275         {
1276             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_TerminateSignal(swigCPtr), false);
1277             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1278             return ret;
1279         }
1280
1281         internal ApplicationSignal PauseSignal()
1282         {
1283             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_PauseSignal(swigCPtr), false);
1284             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1285             return ret;
1286         }
1287
1288         internal ApplicationSignal ResumeSignal()
1289         {
1290             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResumeSignal(swigCPtr), false);
1291             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1292             return ret;
1293         }
1294
1295         internal ApplicationSignal ResetSignal()
1296         {
1297             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResetSignal(swigCPtr), false);
1298             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1299             return ret;
1300         }
1301
1302         internal ApplicationSignal ResizeSignal()
1303         {
1304             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResizeSignal(swigCPtr), false);
1305             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1306             return ret;
1307         }
1308
1309         internal ApplicationControlSignal AppControlSignal()
1310         {
1311             ApplicationControlSignal ret = new ApplicationControlSignal(NDalicPINVOKE.Application_AppControlSignal(swigCPtr), false);
1312             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1313             return ret;
1314         }
1315
1316         internal ApplicationSignal LanguageChangedSignal()
1317         {
1318             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_LanguageChangedSignal(swigCPtr), false);
1319             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1320             return ret;
1321         }
1322
1323         internal ApplicationSignal RegionChangedSignal()
1324         {
1325             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_RegionChangedSignal(swigCPtr), false);
1326             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1327             return ret;
1328         }
1329
1330         internal ApplicationSignal BatteryLowSignal()
1331         {
1332             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_BatteryLowSignal(swigCPtr), false);
1333             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1334             return ret;
1335         }
1336
1337         internal ApplicationSignal MemoryLowSignal()
1338         {
1339             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_MemoryLowSignal(swigCPtr), false);
1340             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1341             return ret;
1342         }
1343
1344         public enum WindowMode
1345         {
1346             Opaque = 0,
1347             Transparent = 1
1348         }
1349
1350     }
1351
1352 }