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

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