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