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

   1 /*
   2  * Copyright(c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 namespace Tizen.NUI
  19 {
  20
  21     using System;
  22     using System.Collections.Generic;
  23     using System.Collections.ObjectModel;
  24     using System.ComponentModel;
  25     using System.Runtime.InteropServices;
  26     using System.Threading;
  27     using System.Threading.Tasks;
  28     using Tizen.NUI.Binding;
  29     using Tizen.NUI.Binding.Internals;
  30
  31     /**
  32       * @brief Event arguments that passed via NUIApplicationInit signal
  33       *
  34       */
  35     internal class NUIApplicationInitEventArgs : EventArgs
  36     {
  37         private Application _application;
  38
  39         /**
  40           * @brief Application - is the application that is being initialized
  41           *
  42           */
  43         public Application Application
  44         {
  45             get
  46             {
  47                 return _application;
  48             }
  49             set
  50             {
  51                 _application = value;
  52             }
  53         }
  54     }
  55
  56     /**
  57       * @brief Event arguments that passed via NUIApplicationTerminate signal
  58       *
  59       */
  60     internal class NUIApplicationTerminatingEventArgs : EventArgs
  61     {
  62         private Application _application;
  63         /**
  64           * @brief Application - is the application that is being Terminated
  65           *
  66           */
  67         public Application Application
  68         {
  69             get
  70             {
  71                 return _application;
  72             }
  73             set
  74             {
  75                 _application = value;
  76             }
  77         }
  78     }
  79
  80     /**
  81       * @brief Event arguments that passed via NUIApplicationPause signal
  82       *
  83       */
  84     internal class NUIApplicationPausedEventArgs : EventArgs
  85     {
  86         private Application _application;
  87         /**
  88           * @brief Application - is the application that is being Paused
  89           *
  90           */
  91         public Application Application
  92         {
  93             get
  94             {
  95                 return _application;
  96             }
  97             set
  98             {
  99                 _application = value;
 100             }
 101         }
 102     }
 103
 104     /**
 105       * @brief Event arguments that passed via NUIApplicationResume signal
 106       *
 107       */
 108     internal class NUIApplicationResumedEventArgs : EventArgs
 109     {
 110         private Application _application;
 111         /**
 112           * @brief Application - is the application that is being Resumed
 113           *
 114           */
 115         public Application Application
 116         {
 117             get
 118             {
 119                 return _application;
 120             }
 121             set
 122             {
 123                 _application = value;
 124             }
 125         }
 126     }
 127
 128     /**
 129       * @brief Event arguments that passed via NUIApplicationReset signal
 130       *
 131       */
 132     internal class NUIApplicationResetEventArgs : EventArgs
 133     {
 134         private Application _application;
 135         /**
 136           * @brief Application - is the application that is being Reset
 137           *
 138           */
 139         public Application Application
 140         {
 141             get
 142             {
 143                 return _application;
 144             }
 145             set
 146             {
 147                 _application = value;
 148             }
 149         }
 150     }
 151
 152     /**
 153       * @brief Event arguments that passed via NUIApplicationResize signal
 154       *
 155       */
 156     internal class NUIApplicationResizedEventArgs : EventArgs
 157     {
 158         private Application _application;
 159         /**
 160           * @brief Application - is the application that is being Resized
 161           *
 162           */
 163         public Application Application
 164         {
 165             get
 166             {
 167                 return _application;
 168             }
 169             set
 170             {
 171                 _application = value;
 172             }
 173         }
 174     }
 175
 176     /**
 177       * @brief Event arguments that passed via NUIApplicationLanguageChanged signal
 178       *
 179       */
 180     internal class NUIApplicationLanguageChangedEventArgs : EventArgs
 181     {
 182         private Application _application;
 183         /**
 184           * @brief Application - is the application that is being affected with Device's language change
 185           *
 186           */
 187         public Application Application
 188         {
 189             get
 190             {
 191                 return _application;
 192             }
 193             set
 194             {
 195                 _application = value;
 196             }
 197         }
 198     }
 199
 200     /**
 201       * @brief Event arguments that passed via NUIApplicationRegionChanged signal
 202       *
 203       */
 204     internal class NUIApplicationRegionChangedEventArgs : EventArgs
 205     {
 206         private Application _application;
 207         /**
 208           * @brief Application - is the application that is being affected with Device's region change
 209           *
 210           */
 211         public Application Application
 212         {
 213             get
 214             {
 215                 return _application;
 216             }
 217             set
 218             {
 219                 _application = value;
 220             }
 221         }
 222     }
 223
 224     /**
 225       * @brief Event arguments that passed via NUIApplicationBatteryLow signal
 226       *
 227       */
 228     internal class NUIApplicationBatteryLowEventArgs : EventArgs
 229     {
 230         private Application.BatteryStatus _status;
 231         /**
 232           * @brief Application - is the application that is being affected when the battery level of the device is low
 233           *
 234           */
 235         public Application.BatteryStatus BatteryStatus
 236         {
 237             get
 238             {
 239                 return _status;
 240             }
 241             set
 242             {
 243                 _status = value;
 244             }
 245         }
 246     }
 247
 248     /**
 249       * @brief Event arguments that passed via NUIApplicationMemoryLow signal
 250       *
 251       */
 252     internal class NUIApplicationMemoryLowEventArgs : EventArgs
 253     {
 254         private Application.MemoryStatus _status;
 255         /**
 256           * @brief Application - is the application that is being affected when the memory level of the device is low
 257           *
 258           */
 259         public Application.MemoryStatus MemoryStatus
 260         {
 261             get
 262             {
 263                 return _status;
 264             }
 265             set
 266             {
 267                 _status = value;
 268             }
 269         }
 270     }
 271
 272     /**
 273       * @brief Event arguments that passed via NUIApplicationAppControl  signal
 274       *
 275       */
 276     internal class NUIApplicationAppControlEventArgs : EventArgs
 277     {
 278         private Application _application;
 279         private IntPtr _voidp;
 280         /**
 281           * @brief Application - is the application that is receiving the launch request from another application
 282           *
 283           */
 284         public Application Application
 285         {
 286             get
 287             {
 288                 return _application;
 289             }
 290             set
 291             {
 292                 _application = value;
 293             }
 294         }
 295         /**
 296           * @brief VoidP - contains the information about why the application is launched
 297           *
 298           */
 299         public IntPtr VoidP
 300         {
 301             get
 302             {
 303                 return _voidp;
 304             }
 305             set
 306             {
 307                 _voidp = value;
 308             }
 309         }
 310     }
 311
 312     public class GetResourcesProvider
 313     {
 314         static public IResourcesProvider Get()
 315         {
 316             return Tizen.NUI.Application.Current;
 317         }
 318     }
 319
 320     internal class Application : BaseHandle, IResourcesProvider, IApplicationController, IElementConfiguration<Application>
 321     {
 322         static Application s_current;
 323         Task<IDictionary<string, object>> _propertiesTask;
 324         readonly Lazy<PlatformConfigurationRegistry<Application>> _platformConfigurationRegistry;
 325
 326         IAppIndexingProvider _appIndexProvider;
 327
 328         ReadOnlyCollection<Element> _logicalChildren;
 329
 330         Page _mainPage;
 331
 332         static SemaphoreSlim SaveSemaphore = new SemaphoreSlim(1, 1);
 333
 334         public IAppLinks AppLinks
 335         {
 336             get
 337             {
 338                 if (_appIndexProvider == null)
 339                     throw new ArgumentException("No IAppIndexingProvider was provided");
 340                 if (_appIndexProvider.AppLinks == null)
 341                     throw new ArgumentException("No AppLinks implementation was found, if in Android make sure you installed the Xamarin.Forms.AppLinks");
 342                 return _appIndexProvider.AppLinks;
 343             }
 344         }
 345
 346         [EditorBrowsable(EditorBrowsableState.Never)]
 347         public static void SetCurrentApplication(Application value) => Current = value;
 348
 349         public static Application Current
 350         {
 351             get { return s_current; }
 352             set
 353             {
 354                 if (s_current == value)
 355                     return;
 356                 if (value == null)
 357                     s_current = null; //Allow to reset current for unittesting
 358                 s_current = value;
 359             }
 360         }
 361
 362         public Page MainPage
 363         {
 364             get { return _mainPage; }
 365             set
 366             {
 367                 if (value == null)
 368                     throw new ArgumentNullException("value");
 369
 370                 if (_mainPage == value)
 371                     return;
 372
 373                 OnPropertyChanging();
 374                 if (_mainPage != null)
 375                 {
 376                     InternalChildren.Remove(_mainPage);
 377                     _mainPage.Parent = null;
 378                 }
 379
 380                 _mainPage = value;
 381
 382                 if (_mainPage != null)
 383                 {
 384                     _mainPage.Parent = this;
 385                     _mainPage.NavigationProxy.Inner = NavigationProxy;
 386                     InternalChildren.Add(_mainPage);
 387                 }
 388                 OnPropertyChanged();
 389             }
 390         }
 391
 392         public IDictionary<string, object> Properties
 393         {
 394             get
 395             {
 396                 if (_propertiesTask == null)
 397                 {
 398                     _propertiesTask = GetPropertiesAsync();
 399                 }
 400
 401                 return _propertiesTask.Result;
 402             }
 403         }
 404
 405         internal override ReadOnlyCollection<Element> LogicalChildrenInternal
 406         {
 407             get { return _logicalChildren ?? (_logicalChildren = new ReadOnlyCollection<Element>(InternalChildren)); }
 408         }
 409
 410         [EditorBrowsable(EditorBrowsableState.Never)]
 411         public NavigationProxy NavigationProxy { get; }
 412
 413         [EditorBrowsable(EditorBrowsableState.Never)]
 414         public int PanGestureId { get; set; }
 415
 416         internal IResourceDictionary SystemResources { get; }
 417
 418         ObservableCollection<Element> InternalChildren { get; } = new ObservableCollection<Element>();
 419
 420         [EditorBrowsable(EditorBrowsableState.Never)]
 421         public void SetAppIndexingProvider(IAppIndexingProvider provider)
 422         {
 423             _appIndexProvider = provider;
 424         }
 425
 426         ResourceDictionary _resources;
 427         public bool IsResourcesCreated => _resources != null;
 428
 429         public delegate void resChangeCb (object sender, ResourcesChangedEventArgs e);
 430
 431         static private Dictionary<object, Dictionary<resChangeCb, int>> resourceChangeCallbackDict = new Dictionary<object, Dictionary<resChangeCb, int>>();
 432         static public void AddResourceChangedCallback(object handle, resChangeCb cb)
 433         {
 434             Dictionary<resChangeCb, int> cbDict;
 435             resourceChangeCallbackDict.TryGetValue(handle, out cbDict);
 436
 437             if (null == cbDict)
 438             {
 439                 cbDict = new Dictionary<resChangeCb, int>();
 440                 resourceChangeCallbackDict.Add(handle, cbDict);
 441             }
 442
 443             if (false == cbDict.ContainsKey(cb))
 444             {
 445                 cbDict.Add(cb, 0);
 446             }
 447         }
 448
 449         internal override void OnResourcesChanged(object sender, ResourcesChangedEventArgs e)
 450         {
 451             base.OnResourcesChanged(sender, e);
 452
 453             foreach (KeyValuePair<object, Dictionary<resChangeCb, int>> resourcePair in resourceChangeCallbackDict)
 454             {
 455                 foreach (KeyValuePair<resChangeCb, int> cbPair in resourcePair.Value)
 456                 {
 457                     cbPair.Key(sender, e);
 458                 }
 459             }
 460         }
 461
 462         public ResourceDictionary XamlResources
 463         {
 464             get
 465             {
 466                 if (_resources != null)
 467                     return _resources;
 468
 469                 _resources = new ResourceDictionary();
 470                 int hashCode = _resources.GetHashCode();
 471                 ((IResourceDictionary)_resources).ValuesChanged += OnResourcesChanged;
 472                 return _resources;
 473             }
 474             set
 475             {
 476                 if (_resources == value)
 477                     return;
 478                 OnPropertyChanging();
 479
 480                 if (_resources != null)
 481                     ((IResourceDictionary)_resources).ValuesChanged -= OnResourcesChanged;
 482                 _resources = value;
 483                 OnResourcesChanged(value);
 484                 if (_resources != null)
 485                     ((IResourceDictionary)_resources).ValuesChanged += OnResourcesChanged;
 486
 487                 OnPropertyChanged();
 488             }
 489         }
 490
 491         public event EventHandler<ModalPoppedEventArgs> ModalPopped;
 492
 493         public event EventHandler<ModalPoppingEventArgs> ModalPopping;
 494
 495         public event EventHandler<ModalPushedEventArgs> ModalPushed;
 496
 497         public event EventHandler<ModalPushingEventArgs> ModalPushing;
 498
 499         public event EventHandler<Page> PageAppearing;
 500
 501         public event EventHandler<Page> PageDisappearing;
 502
 503
 504         async void SaveProperties()
 505         {
 506             try
 507             {
 508                 await SetPropertiesAsync();
 509             }
 510             catch (Exception exc)
 511             {
 512                 Console.WriteLine(nameof(Application), $"Exception while saving Application Properties: {exc}");
 513             }
 514         }
 515
 516         public async Task SavePropertiesAsync()
 517         {
 518             if (Device.IsInvokeRequired)
 519             {
 520                 Device.BeginInvokeOnMainThread(SaveProperties);
 521             }
 522             else
 523             {
 524                 await SetPropertiesAsync();
 525             }
 526         }
 527
 528         // Don't use this unless there really is no better option
 529         internal void SavePropertiesAsFireAndForget()
 530         {
 531             if (Device.IsInvokeRequired)
 532             {
 533                 Device.BeginInvokeOnMainThread(SaveProperties);
 534             }
 535             else
 536             {
 537                 SaveProperties();
 538             }
 539         }
 540
 541         public IPlatformElementConfiguration<T, Application> On<T>() where T : IConfigPlatform
 542         {
 543             return _platformConfigurationRegistry.Value.On<T>();
 544         }
 545
 546         protected virtual void OnAppLinkRequestReceived(Uri uri)
 547         {
 548         }
 549
 550         protected override void OnParentSet()
 551         {
 552             throw new InvalidOperationException("Setting a Parent on Application is invalid.");
 553         }
 554
 555         protected virtual void OnResume()
 556         {
 557         }
 558
 559         protected virtual void OnSleep()
 560         {
 561         }
 562
 563         protected virtual void OnStart()
 564         {
 565         }
 566
 567         [EditorBrowsable(EditorBrowsableState.Never)]
 568         public static void ClearCurrent()
 569         {
 570             s_current = null;
 571         }
 572
 573         [EditorBrowsable(EditorBrowsableState.Never)]
 574         public static bool IsApplicationOrNull(Element element)
 575         {
 576             return element == null || element is Application;
 577         }
 578
 579         internal override void OnParentResourcesChanged(IEnumerable<KeyValuePair<string, object>> values)
 580         {
 581             if (!((IResourcesProvider)this).IsResourcesCreated || XamlResources.Count == 0)
 582             {
 583                 base.OnParentResourcesChanged(values);
 584                 return;
 585             }
 586
 587             var innerKeys = new HashSet<string>();
 588             var changedResources = new List<KeyValuePair<string, object>>();
 589             foreach (KeyValuePair<string, object> c in XamlResources)
 590                 innerKeys.Add(c.Key);
 591             foreach (KeyValuePair<string, object> value in values)
 592             {
 593                 if (innerKeys.Add(value.Key))
 594                     changedResources.Add(value);
 595             }
 596             OnResourcesChanged(changedResources);
 597         }
 598
 599         internal event EventHandler PopCanceled;
 600
 601         [EditorBrowsable(EditorBrowsableState.Never)]
 602         public void SendOnAppLinkRequestReceived(Uri uri)
 603         {
 604             OnAppLinkRequestReceived(uri);
 605         }
 606
 607         [EditorBrowsable(EditorBrowsableState.Never)]
 608         public void SendResume()
 609         {
 610             s_current = this;
 611             OnResume();
 612         }
 613
 614         [EditorBrowsable(EditorBrowsableState.Never)]
 615         public void SendSleep()
 616         {
 617             OnSleep();
 618             SavePropertiesAsFireAndForget();
 619         }
 620
 621         [EditorBrowsable(EditorBrowsableState.Never)]
 622         public Task SendSleepAsync()
 623         {
 624             OnSleep();
 625             return SavePropertiesAsync();
 626         }
 627
 628         [EditorBrowsable(EditorBrowsableState.Never)]
 629         public void SendStart()
 630         {
 631             OnStart();
 632         }
 633
 634         async Task<IDictionary<string, object>> GetPropertiesAsync()
 635         {
 636             var deserializer = DependencyService.Get<IDeserializer>();
 637             if (deserializer == null)
 638             {
 639                 Console.WriteLine("Startup", "No IDeserialzier was found registered");
 640                 return new Dictionary<string, object>(4);
 641             }
 642
 643             IDictionary<string, object> properties = await deserializer.DeserializePropertiesAsync().ConfigureAwait(false);
 644             if (properties == null)
 645                 properties = new Dictionary<string, object>(4);
 646
 647             return properties;
 648         }
 649
 650         internal void OnPageAppearing(Page page)
 651             => PageAppearing?.Invoke(this, page);
 652
 653         internal void OnPageDisappearing(Page page)
 654             => PageDisappearing?.Invoke(this, page);
 655
 656         void OnModalPopped(Page modalPage)
 657             => ModalPopped?.Invoke(this, new ModalPoppedEventArgs(modalPage));
 658
 659         bool OnModalPopping(Page modalPage)
 660         {
 661             var args = new ModalPoppingEventArgs(modalPage);
 662             ModalPopping?.Invoke(this, args);
 663             return args.Cancel;
 664         }
 665
 666         void OnModalPushed(Page modalPage)
 667             => ModalPushed?.Invoke(this, new ModalPushedEventArgs(modalPage));
 668
 669         void OnModalPushing(Page modalPage)
 670             => ModalPushing?.Invoke(this, new ModalPushingEventArgs(modalPage));
 671
 672         void OnPopCanceled()
 673             => PopCanceled?.Invoke(this, EventArgs.Empty);
 674
 675         async Task SetPropertiesAsync()
 676         {
 677             await SaveSemaphore.WaitAsync();
 678             try
 679             {
 680                 await DependencyService.Get<IDeserializer>().SerializePropertiesAsync(Properties);
 681             }
 682             finally
 683             {
 684                 SaveSemaphore.Release();
 685             }
 686
 687         }
 688
 689         class NavigationImpl : NavigationProxy
 690         {
 691             readonly Application _owner;
 692
 693             public NavigationImpl(Application owner)
 694             {
 695                 _owner = owner;
 696             }
 697
 698             protected override async Task<Page> OnPopModal(bool animated)
 699             {
 700                 Page modal = ModalStack[ModalStack.Count - 1];
 701                 if (_owner.OnModalPopping(modal))
 702                 {
 703                     _owner.OnPopCanceled();
 704                     return null;
 705                 }
 706                 Page result = await base.OnPopModal(animated);
 707                 result.Parent = null;
 708                 _owner.OnModalPopped(result);
 709                 return result;
 710             }
 711
 712             protected override async Task OnPushModal(Page modal, bool animated)
 713             {
 714                 _owner.OnModalPushing(modal);
 715
 716                 modal.Parent = _owner;
 717
 718                 if (modal.NavigationProxy.ModalStack.Count == 0)
 719                 {
 720                     modal.NavigationProxy.Inner = this;
 721                     await base.OnPushModal(modal, animated);
 722                 }
 723                 else
 724                 {
 725                     await base.OnPushModal(modal, animated);
 726                     modal.NavigationProxy.Inner = this;
 727                 }
 728
 729                 _owner.OnModalPushed(modal);
 730             }
 731         }
 732
 733         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
 734
 735         internal Application(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicPINVOKE.Application_SWIGUpcast(cPtr), cMemoryOwn)
 736         {
 737             NavigationProxy = new NavigationImpl(this);
 738             SetCurrentApplication(this);
 739
 740             _platformConfigurationRegistry = new Lazy<PlatformConfigurationRegistry<Application>>(() => new PlatformConfigurationRegistry<Application>(this));
 741             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 742
 743             SendResume();
 744         }
 745
 746         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Application obj)
 747         {
 748             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 749         }
 750
 751         protected override void Dispose(DisposeTypes type)
 752         {
 753             if (disposed)
 754             {
 755                 return;
 756             }
 757
 758             if (type == DisposeTypes.Explicit)
 759             {
 760                 //Called by User
 761                 //Release your own managed resources here.
 762                 //You should release all of your own disposable objects here.
 763
 764             }
 765
 766             //Release your own unmanaged resources here.
 767             //You should not access any managed member here except static instance.
 768             //because the execution order of Finalizes is non-deterministic.
 769
 770             if (_applicationInitEventCallbackDelegate != null)
 771             {
 772                 this.InitSignal().Disconnect(_applicationInitEventCallbackDelegate);
 773             }
 774
 775             if (_applicationTerminateEventCallbackDelegate != null)
 776             {
 777                 this.TerminateSignal().Disconnect(_applicationTerminateEventCallbackDelegate);
 778             }
 779
 780             if (_applicationPauseEventCallbackDelegate != null)
 781             {
 782                 this.PauseSignal().Disconnect(_applicationPauseEventCallbackDelegate);
 783             }
 784
 785             if (_applicationResumeEventCallbackDelegate != null)
 786             {
 787                 this.ResumeSignal().Disconnect(_applicationResumeEventCallbackDelegate);
 788             }
 789
 790             if (_applicationResetEventCallbackDelegate != null)
 791             {
 792                 this.ResetSignal().Disconnect(_applicationResetEventCallbackDelegate);
 793             }
 794
 795             if (_applicationResizeEventCallbackDelegate != null)
 796             {
 797                 this.ResizeSignal().Disconnect(_applicationResizeEventCallbackDelegate);
 798             }
 799
 800             if (_applicationLanguageChangedEventCallbackDelegate != null)
 801             {
 802                 this.LanguageChangedSignal().Disconnect(_applicationLanguageChangedEventCallbackDelegate);
 803             }
 804
 805             if (_applicationRegionChangedEventCallbackDelegate != null)
 806             {
 807                 this.RegionChangedSignal().Disconnect(_applicationRegionChangedEventCallbackDelegate);
 808             }
 809
 810             if (_applicationBatteryLowEventCallbackDelegate != null)
 811             {
 812                 this.BatteryLowSignal().Disconnect(_applicationBatteryLowEventCallbackDelegate);
 813             }
 814
 815             if (_applicationMemoryLowEventCallbackDelegate != null)
 816             {
 817                 this.MemoryLowSignal().Disconnect(_applicationMemoryLowEventCallbackDelegate);
 818             }
 819
 820             if (_applicationAppControlEventCallbackDelegate != null)
 821             {
 822                 this.AppControlSignal().Disconnect(_applicationAppControlEventCallbackDelegate);
 823             }
 824
 825             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 826             {
 827                 if (swigCMemOwn)
 828                 {
 829                     swigCMemOwn = false;
 830                     NDalicPINVOKE.delete_Application(swigCPtr);
 831                 }
 832                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 833             }
 834
 835             base.Dispose(type);
 836         }
 837
 838         /// <since_tizen> 4 </since_tizen>
 839         public enum BatteryStatus
 840         {
 841             Normal,
 842             CriticallyLow,
 843             PowerOff
 844         };
 845
 846         /// <since_tizen> 4 </since_tizen>
 847         public enum MemoryStatus
 848         {
 849             Normal,
 850             Low,
 851             CriticallyLow
 852         };
 853
 854         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 855         private delegate void NUIApplicationInitEventCallbackDelegate(IntPtr application);
 856         private DaliEventHandler<object, NUIApplicationInitEventArgs> _applicationInitEventHandler;
 857         private NUIApplicationInitEventCallbackDelegate _applicationInitEventCallbackDelegate;
 858
 859
 860         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 861         private delegate void NUIApplicationTerminateEventCallbackDelegate(IntPtr application);
 862         private DaliEventHandler<object, NUIApplicationTerminatingEventArgs> _applicationTerminateEventHandler;
 863         private NUIApplicationTerminateEventCallbackDelegate _applicationTerminateEventCallbackDelegate;
 864
 865
 866         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 867         private delegate void NUIApplicationPauseEventCallbackDelegate(IntPtr application);
 868         private DaliEventHandler<object, NUIApplicationPausedEventArgs> _applicationPauseEventHandler;
 869         private NUIApplicationPauseEventCallbackDelegate _applicationPauseEventCallbackDelegate;
 870
 871         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 872         private delegate void NUIApplicationResumeEventCallbackDelegate(IntPtr application);
 873         private DaliEventHandler<object, NUIApplicationResumedEventArgs> _applicationResumeEventHandler;
 874         private NUIApplicationResumeEventCallbackDelegate _applicationResumeEventCallbackDelegate;
 875
 876         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 877         private delegate void NUIApplicationResetEventCallbackDelegate(IntPtr application);
 878         private DaliEventHandler<object, NUIApplicationResetEventArgs> _applicationResetEventHandler;
 879         private NUIApplicationResetEventCallbackDelegate _applicationResetEventCallbackDelegate;
 880
 881         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 882         private delegate void NUIApplicationResizeEventCallbackDelegate(IntPtr application);
 883         private DaliEventHandler<object, NUIApplicationResizedEventArgs> _applicationResizeEventHandler;
 884         private NUIApplicationResizeEventCallbackDelegate _applicationResizeEventCallbackDelegate;
 885
 886         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 887         private delegate void NUIApplicationLanguageChangedEventCallbackDelegate(IntPtr application);
 888         private DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> _applicationLanguageChangedEventHandler;
 889         private NUIApplicationLanguageChangedEventCallbackDelegate _applicationLanguageChangedEventCallbackDelegate;
 890
 891
 892         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 893         private delegate void NUIApplicationRegionChangedEventCallbackDelegate(IntPtr application);
 894         private DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> _applicationRegionChangedEventHandler;
 895         private NUIApplicationRegionChangedEventCallbackDelegate _applicationRegionChangedEventCallbackDelegate;
 896
 897         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 898         private delegate void NUIApplicationBatteryLowEventCallbackDelegate(BatteryStatus status);
 899         private DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> _applicationBatteryLowEventHandler;
 900         private NUIApplicationBatteryLowEventCallbackDelegate _applicationBatteryLowEventCallbackDelegate;
 901
 902         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 903         private delegate void NUIApplicationMemoryLowEventCallbackDelegate(MemoryStatus status);
 904         private DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> _applicationMemoryLowEventHandler;
 905         private NUIApplicationMemoryLowEventCallbackDelegate _applicationMemoryLowEventCallbackDelegate;
 906
 907         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 908         private delegate void NUIApplicationAppControlEventCallbackDelegate(IntPtr application, IntPtr voidp);
 909         private DaliEventHandler<object, NUIApplicationAppControlEventArgs> _applicationAppControlEventHandler;
 910         private NUIApplicationAppControlEventCallbackDelegate _applicationAppControlEventCallbackDelegate;
 911
 912         /**
 913           * @brief Event for Initialized signal which can be used to subscribe/unsubscribe the event handler
 914           *  provided by the user. Initialized signal is emitted when application is initialised
 915           */
 916         public event DaliEventHandler<object, NUIApplicationInitEventArgs> Initialized
 917         {
 918             add
 919             {
 920                 lock (this)
 921                 {
 922                     // Restricted to only one listener
 923                     if (_applicationInitEventHandler == null)
 924                     {
 925                         _applicationInitEventHandler += value;
 926
 927                         _applicationInitEventCallbackDelegate = new NUIApplicationInitEventCallbackDelegate(OnApplicationInit);
 928                         this.InitSignal().Connect(_applicationInitEventCallbackDelegate);
 929                     }
 930                 }
 931             }
 932
 933             remove
 934             {
 935                 lock (this)
 936                 {
 937                     if (_applicationInitEventHandler != null)
 938                     {
 939                         this.InitSignal().Disconnect(_applicationInitEventCallbackDelegate);
 940                     }
 941
 942                     _applicationInitEventHandler -= value;
 943                 }
 944             }
 945         }
 946
 947         // Callback for Application InitSignal
 948         private void OnApplicationInit(IntPtr data)
 949         {
 950             if (Version.DaliVersionMatchWithNUI() == false)
 951             {
 952                 Tizen.Log.Fatal("NUI", "Dali and NUI are version mismatched!");
 953             }
 954
 955             // Initialize DisposeQueue Singleton class. This is also required to create DisposeQueue on main thread.
 956             DisposeQueue.Instance.Initialize();
 957
 958             NUIApplicationInitEventArgs e = new NUIApplicationInitEventArgs();
 959             // Populate all members of "e" (NUIApplicationInitEventArgs) with real data
 960             using (e.Application = Application.GetApplicationFromPtr(data))
 961             {
 962                 if (_applicationInitEventHandler != null)
 963                 {
 964                     //here we send all data to user event handlers
 965                     _applicationInitEventHandler(this, e);
 966                 }
 967             }
 968
 969         }
 970
 971         /**
 972           * @brief Event for Terminated signal which can be used to subscribe/unsubscribe the event handler
 973           *  provided by the user. Terminated signal is emitted when application is terminating
 974           */
 975         public event DaliEventHandler<object, NUIApplicationTerminatingEventArgs> Terminating
 976         {
 977             add
 978             {
 979                 lock (this)
 980                 {
 981                     // Restricted to only one listener
 982                     if (_applicationTerminateEventHandler == null)
 983                     {
 984                         _applicationTerminateEventHandler += value;
 985
 986                         _applicationTerminateEventCallbackDelegate = new NUIApplicationTerminateEventCallbackDelegate(OnNUIApplicationTerminate);
 987                         this.TerminateSignal().Connect(_applicationTerminateEventCallbackDelegate);
 988                     }
 989                 }
 990             }
 991
 992             remove
 993             {
 994                 lock (this)
 995                 {
 996                     if (_applicationTerminateEventHandler != null)
 997                     {
 998                         this.TerminateSignal().Disconnect(_applicationTerminateEventCallbackDelegate);
 999                     }
1000
1001                     _applicationTerminateEventHandler -= value;
1002                 }
1003             }
1004         }
1005
1006         // Callback for Application TerminateSignal
1007         private void OnNUIApplicationTerminate(IntPtr data)
1008         {
1009             NUIApplicationTerminatingEventArgs e = new NUIApplicationTerminatingEventArgs();
1010
1011             // Populate all members of "e" (NUIApplicationTerminateEventArgs) with real data
1012             using (e.Application = Application.GetApplicationFromPtr(data))
1013             {
1014                 if (_applicationTerminateEventHandler != null)
1015                 {
1016                     //here we send all data to user event handlers
1017                     _applicationTerminateEventHandler(this, e);
1018                 }
1019             }
1020         }
1021
1022         /**
1023           * @brief Event for Paused signal which can be used to subscribe/unsubscribe the event handler
1024           * provided by the user. Paused signal is emitted when application is paused
1025           */
1026         public event DaliEventHandler<object, NUIApplicationPausedEventArgs> Paused
1027         {
1028             add
1029             {
1030                 lock (this)
1031                 {
1032                     // Restricted to only one listener
1033                     if (_applicationPauseEventHandler == null)
1034                     {
1035                         _applicationPauseEventHandler += value;
1036
1037                         _applicationPauseEventCallbackDelegate = new NUIApplicationPauseEventCallbackDelegate(OnNUIApplicationPause);
1038                         this.PauseSignal().Connect(_applicationPauseEventCallbackDelegate);
1039                     }
1040                 }
1041             }
1042
1043             remove
1044             {
1045                 lock (this)
1046                 {
1047                     if (_applicationPauseEventHandler != null)
1048                     {
1049                         this.PauseSignal().Disconnect(_applicationPauseEventCallbackDelegate);
1050                     }
1051
1052                     _applicationPauseEventHandler -= value;
1053                 }
1054             }
1055         }
1056
1057         // Callback for Application PauseSignal
1058         private void OnNUIApplicationPause(IntPtr data)
1059         {
1060             NUIApplicationPausedEventArgs e = new NUIApplicationPausedEventArgs();
1061
1062             // Populate all members of "e" (NUIApplicationPauseEventArgs) with real data
1063             using (e.Application = Application.GetApplicationFromPtr(data))
1064             {
1065                 if (_applicationPauseEventHandler != null)
1066                 {
1067                     //here we send all data to user event handlers
1068                     _applicationPauseEventHandler(this, e);
1069                 }
1070             }
1071         }
1072
1073         /**
1074           * @brief Event for Resumed signal which can be used to subscribe/unsubscribe the event handler
1075           *  provided by the user. Resumed signal is emitted when application is resumed
1076           */
1077         public event DaliEventHandler<object, NUIApplicationResumedEventArgs> Resumed
1078         {
1079             add
1080             {
1081                 lock (this)
1082                 {
1083                     // Restricted to only one listener
1084                     if (_applicationResumeEventHandler == null)
1085                     {
1086                         _applicationResumeEventHandler += value;
1087
1088                         _applicationResumeEventCallbackDelegate = new NUIApplicationResumeEventCallbackDelegate(OnNUIApplicationResume);
1089                         this.ResumeSignal().Connect(_applicationResumeEventCallbackDelegate);
1090                     }
1091                 }
1092             }
1093
1094             remove
1095             {
1096                 lock (this)
1097                 {
1098                     if (_applicationResumeEventHandler != null)
1099                     {
1100                         this.ResumeSignal().Disconnect(_applicationResumeEventCallbackDelegate);
1101                     }
1102
1103                     _applicationResumeEventHandler -= value;
1104                 }
1105             }
1106         }
1107
1108         // Callback for Application ResumeSignal
1109         private void OnNUIApplicationResume(IntPtr data)
1110         {
1111             NUIApplicationResumedEventArgs e = new NUIApplicationResumedEventArgs();
1112
1113             // Populate all members of "e" (NUIApplicationResumeEventArgs) with real data
1114             using (e.Application = Application.GetApplicationFromPtr(data))
1115             {
1116                 if (_applicationResumeEventHandler != null)
1117                 {
1118                     //here we send all data to user event handlers
1119                     _applicationResumeEventHandler(this, e);
1120                 }
1121             }
1122         }
1123
1124         /**
1125           * @brief Event for Reset signal which can be used to subscribe/unsubscribe the event handler
1126           *  provided by the user. Reset signal is emitted when application is reset
1127           */
1128         public new event DaliEventHandler<object, NUIApplicationResetEventArgs> Reset
1129         {
1130             add
1131             {
1132                 lock (this)
1133                 {
1134                     // Restricted to only one listener
1135                     if (_applicationResetEventHandler == null)
1136                     {
1137                         _applicationResetEventHandler += value;
1138
1139                         _applicationResetEventCallbackDelegate = new NUIApplicationResetEventCallbackDelegate(OnNUIApplicationReset);
1140                         this.ResetSignal().Connect(_applicationResetEventCallbackDelegate);
1141                     }
1142                 }
1143             }
1144
1145             remove
1146             {
1147                 lock (this)
1148                 {
1149                     if (_applicationResetEventHandler != null)
1150                     {
1151                         this.ResetSignal().Disconnect(_applicationResetEventCallbackDelegate);
1152                     }
1153
1154                     _applicationResetEventHandler -= value;
1155                 }
1156             }
1157         }
1158
1159         // Callback for Application ResetSignal
1160         private void OnNUIApplicationReset(IntPtr data)
1161         {
1162             NUIApplicationResetEventArgs e = new NUIApplicationResetEventArgs();
1163
1164             // Populate all members of "e" (NUIApplicationResetEventArgs) with real data
1165             using (e.Application = Application.GetApplicationFromPtr(data))
1166             {
1167                 if (_applicationResetEventHandler != null)
1168                 {
1169                     //here we send all data to user event handlers
1170                     _applicationResetEventHandler(this, e);
1171                 }
1172             }
1173         }
1174
1175         /**
1176           * @brief Event for Resized signal which can be used to subscribe/unsubscribe the event handler
1177           *  provided by the user. Resized signal is emitted when application is resized
1178           */
1179         public event DaliEventHandler<object, NUIApplicationResizedEventArgs> Resized
1180         {
1181             add
1182             {
1183                 lock (this)
1184                 {
1185                     // Restricted to only one listener
1186                     if (_applicationResizeEventHandler == null)
1187                     {
1188                         _applicationResizeEventHandler += value;
1189
1190                         _applicationResizeEventCallbackDelegate = new NUIApplicationResizeEventCallbackDelegate(OnNUIApplicationResize);
1191                         this.ResizeSignal().Connect(_applicationResizeEventCallbackDelegate);
1192                     }
1193                 }
1194             }
1195
1196             remove
1197             {
1198                 lock (this)
1199                 {
1200                     if (_applicationResizeEventHandler != null)
1201                     {
1202                         this.ResizeSignal().Disconnect(_applicationResizeEventCallbackDelegate);
1203                     }
1204
1205                     _applicationResizeEventHandler -= value;
1206                 }
1207             }
1208         }
1209
1210         // Callback for Application ResizeSignal
1211         private void OnNUIApplicationResize(IntPtr data)
1212         {
1213             NUIApplicationResizedEventArgs e = new NUIApplicationResizedEventArgs();
1214
1215             // Populate all members of "e" (NUIApplicationResizeEventArgs) with real data
1216             using (e.Application = Application.GetApplicationFromPtr(data))
1217             {
1218                 if (_applicationResizeEventHandler != null)
1219                 {
1220                     //here we send all data to user event handlers
1221                     _applicationResizeEventHandler(this, e);
1222                 }
1223             }
1224         }
1225
1226         /**
1227           * @brief Event for LanguageChanged signal which can be used to subscribe/unsubscribe the event handler
1228           *  provided by the user. LanguageChanged signal is emitted when the region of the device is changed.
1229           */
1230         public event DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> LanguageChanged
1231         {
1232             add
1233             {
1234                 lock (this)
1235                 {
1236                     // Restricted to only one listener
1237                     if (_applicationLanguageChangedEventHandler == null)
1238                     {
1239                         _applicationLanguageChangedEventHandler += value;
1240
1241                         _applicationLanguageChangedEventCallbackDelegate = new NUIApplicationLanguageChangedEventCallbackDelegate(OnNUIApplicationLanguageChanged);
1242                         this.LanguageChangedSignal().Connect(_applicationLanguageChangedEventCallbackDelegate);
1243                     }
1244                 }
1245             }
1246
1247             remove
1248             {
1249                 lock (this)
1250                 {
1251                     if (_applicationLanguageChangedEventHandler != null)
1252                     {
1253                         this.LanguageChangedSignal().Disconnect(_applicationLanguageChangedEventCallbackDelegate);
1254                     }
1255
1256                     _applicationLanguageChangedEventHandler -= value;
1257                 }
1258             }
1259         }
1260
1261         // Callback for Application LanguageChangedSignal
1262         private void OnNUIApplicationLanguageChanged(IntPtr data)
1263         {
1264             NUIApplicationLanguageChangedEventArgs e = new NUIApplicationLanguageChangedEventArgs();
1265
1266             // Populate all members of "e" (NUIApplicationLanguageChangedEventArgs) with real data
1267             using (e.Application = Application.GetApplicationFromPtr(data))
1268             {
1269                 if (_applicationLanguageChangedEventHandler != null)
1270                 {
1271                     //here we send all data to user event handlers
1272                     _applicationLanguageChangedEventHandler(this, e);
1273                 }
1274             }
1275         }
1276
1277         /**
1278           * @brief Event for RegionChanged signal which can be used to subscribe/unsubscribe the event handler
1279           *  provided by the user. RegionChanged signal is emitted when the region of the device is changed.
1280           */
1281         public event DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> RegionChanged
1282         {
1283             add
1284             {
1285                 lock (this)
1286                 {
1287                     // Restricted to only one listener
1288                     if (_applicationRegionChangedEventHandler == null)
1289                     {
1290                         _applicationRegionChangedEventHandler += value;
1291
1292                         _applicationRegionChangedEventCallbackDelegate = new NUIApplicationRegionChangedEventCallbackDelegate(OnNUIApplicationRegionChanged);
1293                         this.RegionChangedSignal().Connect(_applicationRegionChangedEventCallbackDelegate);
1294                     }
1295                 }
1296             }
1297
1298             remove
1299             {
1300                 lock (this)
1301                 {
1302                     if (_applicationRegionChangedEventHandler != null)
1303                     {
1304                         this.RegionChangedSignal().Disconnect(_applicationRegionChangedEventCallbackDelegate);
1305                     }
1306
1307                     _applicationRegionChangedEventHandler -= value;
1308                 }
1309             }
1310         }
1311
1312         // Callback for Application RegionChangedSignal
1313         private void OnNUIApplicationRegionChanged(IntPtr data)
1314         {
1315             NUIApplicationRegionChangedEventArgs e = new NUIApplicationRegionChangedEventArgs();
1316
1317             // Populate all members of "e" (NUIApplicationRegionChangedEventArgs) with real data
1318             using (e.Application = Application.GetApplicationFromPtr(data))
1319             {
1320                 if (_applicationRegionChangedEventHandler != null)
1321                 {
1322                     //here we send all data to user event handlers
1323                     _applicationRegionChangedEventHandler(this, e);
1324                 }
1325             }
1326         }
1327
1328         /**
1329           * @brief Event for BatteryLow signal which can be used to subscribe/unsubscribe the event handler
1330           * provided by the user. BatteryLow signal is emitted when the battery level of the device is low.
1331           */
1332         public event DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> BatteryLow
1333         {
1334             add
1335             {
1336                 lock (this)
1337                 {
1338                     // Restricted to only one listener
1339                     if (_applicationBatteryLowEventHandler == null)
1340                     {
1341                         _applicationBatteryLowEventHandler += value;
1342
1343                         _applicationBatteryLowEventCallbackDelegate = new NUIApplicationBatteryLowEventCallbackDelegate(OnNUIApplicationBatteryLow);
1344                         this.BatteryLowSignal().Connect(_applicationBatteryLowEventCallbackDelegate);
1345                     }
1346                 }
1347             }
1348
1349             remove
1350             {
1351                 lock (this)
1352                 {
1353                     if (_applicationBatteryLowEventHandler != null)
1354                     {
1355                         this.BatteryLowSignal().Disconnect(_applicationBatteryLowEventCallbackDelegate);
1356                     }
1357
1358                     _applicationBatteryLowEventHandler -= value;
1359                 }
1360             }
1361         }
1362
1363         // Callback for Application BatteryLowSignal
1364         private void OnNUIApplicationBatteryLow(BatteryStatus status)
1365         {
1366             NUIApplicationBatteryLowEventArgs e = new NUIApplicationBatteryLowEventArgs();
1367
1368             // Populate all members of "e" (NUIApplicationBatteryLowEventArgs) with real data
1369             e.BatteryStatus = status;
1370
1371             if (_applicationBatteryLowEventHandler != null)
1372             {
1373                 //here we send all data to user event handlers
1374                 _applicationBatteryLowEventHandler(this, e);
1375             }
1376         }
1377
1378         /**
1379           * @brief Event for MemoryLow signal which can be used to subscribe/unsubscribe the event handler
1380           *  provided by the user. MemoryLow signal is emitted when the memory level of the device is low.
1381           */
1382         public event DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> MemoryLow
1383         {
1384             add
1385             {
1386                 lock (this)
1387                 {
1388                     // Restricted to only one listener
1389                     if (_applicationMemoryLowEventHandler == null)
1390                     {
1391                         _applicationMemoryLowEventHandler += value;
1392
1393                         _applicationMemoryLowEventCallbackDelegate = new NUIApplicationMemoryLowEventCallbackDelegate(OnNUIApplicationMemoryLow);
1394                         this.MemoryLowSignal().Connect(_applicationMemoryLowEventCallbackDelegate);
1395                     }
1396                 }
1397             }
1398
1399             remove
1400             {
1401                 lock (this)
1402                 {
1403                     if (_applicationMemoryLowEventHandler != null)
1404                     {
1405                         this.MemoryLowSignal().Disconnect(_applicationMemoryLowEventCallbackDelegate);
1406                     }
1407
1408                     _applicationMemoryLowEventHandler -= value;
1409                 }
1410             }
1411         }
1412
1413         // Callback for Application MemoryLowSignal
1414         private void OnNUIApplicationMemoryLow(MemoryStatus status)
1415         {
1416             NUIApplicationMemoryLowEventArgs e = new NUIApplicationMemoryLowEventArgs();
1417
1418             // Populate all members of "e" (NUIApplicationMemoryLowEventArgs) with real data
1419             e.MemoryStatus = status;
1420
1421             if (_applicationMemoryLowEventHandler != null)
1422             {
1423                 //here we send all data to user event handlers
1424                 _applicationMemoryLowEventHandler(this, e);
1425             }
1426         }
1427
1428         /**
1429           * @brief Event for AppControl signal which can be used to subscribe/unsubscribe the event handler
1430           *  provided by the user. AppControl signal is emitted when another application sends a launch request to the application.
1431           */
1432         public event DaliEventHandler<object, NUIApplicationAppControlEventArgs> AppControl
1433         {
1434             add
1435             {
1436                 lock (this)
1437                 {
1438                     // Restricted to only one listener
1439                     if (_applicationAppControlEventHandler == null)
1440                     {
1441                         _applicationAppControlEventHandler += value;
1442
1443                         _applicationAppControlEventCallbackDelegate = new NUIApplicationAppControlEventCallbackDelegate(OnNUIApplicationAppControl);
1444                         this.AppControlSignal().Connect(_applicationAppControlEventCallbackDelegate);
1445                     }
1446                 }
1447             }
1448
1449             remove
1450             {
1451                 lock (this)
1452                 {
1453                     if (_applicationAppControlEventHandler != null)
1454                     {
1455                         this.AppControlSignal().Disconnect(_applicationAppControlEventCallbackDelegate);
1456                     }
1457
1458                     _applicationAppControlEventHandler -= value;
1459                 }
1460             }
1461         }
1462
1463         // Callback for Application AppControlSignal
1464         private void OnNUIApplicationAppControl(IntPtr application, IntPtr voidp)
1465         {
1466             NUIApplicationAppControlEventArgs e = new NUIApplicationAppControlEventArgs();
1467             e.VoidP = voidp;
1468
1469             // Populate all members of "e" (NUIApplicationAppControlEventArgs) with real data
1470             using (e.Application = Application.GetApplicationFromPtr(application))
1471             {
1472                 if (_applicationAppControlEventHandler != null)
1473                 {
1474                     //here we send all data to user event handlers
1475                     _applicationAppControlEventHandler(this, e);
1476                 }
1477             }
1478         }
1479
1480         private static Application _instance; // singleton
1481
1482         public static Application Instance
1483         {
1484             get
1485             {
1486                 return _instance;
1487             }
1488         }
1489
1490         public static Application GetApplicationFromPtr(global::System.IntPtr cPtr)
1491         {
1492             if (cPtr == global::System.IntPtr.Zero)
1493             {
1494                 return null;
1495             }
1496
1497             Application ret = new Application(cPtr, false);
1498             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1499             return ret;
1500         }
1501
1502         public static Application NewApplication()
1503         {
1504             return NewApplication("", Application.WindowMode.Opaque);
1505         }
1506
1507         public static Application NewApplication(string stylesheet)
1508         {
1509             return NewApplication(stylesheet, Application.WindowMode.Opaque);
1510         }
1511
1512         public static Application NewApplication(string stylesheet, Application.WindowMode windowMode)
1513         {
1514             // register all Views with the type registry, so that can be created / styled via JSON
1515             //ViewRegistryHelper.Initialize(); //moved to Application side.
1516
1517             Application ret = New(1, stylesheet, windowMode);
1518             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1519
1520             // set the singleton
1521             _instance = ret;
1522             return ret;
1523         }
1524
1525
1526         public static Application NewApplication(string[] args, string stylesheet, Application.WindowMode windowMode)
1527         {
1528             Application ret = New(args, stylesheet, (Application.WindowMode)windowMode);
1529             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1530
1531             // set the singleton
1532             _instance = ret;
1533             return _instance;
1534         }
1535
1536         /// <summary>
1537         /// Ensures that the function passed in is called from the main loop when it is idle.
1538         /// </summary>
1539         /// <param name="func">The function to call</param>
1540         /// <returns>true if added successfully, false otherwise</returns>
1541         public bool AddIdle(System.Delegate func)
1542         {
1543             System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate<System.Delegate>(func);
1544             System.IntPtr ip2 = NDalicManualPINVOKE.MakeCallback(new System.Runtime.InteropServices.HandleRef(this, ip));
1545
1546             bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip2));
1547
1548             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1549             return ret;
1550         }
1551
1552         /**
1553         * Outer::outer_method(int)
1554         */
1555         public static Application New()
1556         {
1557             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_0(), true);
1558             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1559             return ret;
1560         }
1561
1562         public static Application New(int argc)
1563         {
1564             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_1(argc), true);
1565             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1566             return ret;
1567         }
1568
1569         public static Application New(int argc, string stylesheet)
1570         {
1571             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_2(argc, stylesheet), true);
1572             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1573             return ret;
1574         }
1575
1576         public static Application New(int argc, string stylesheet, Application.WindowMode windowMode)
1577         {
1578             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_3(argc, stylesheet, (int)windowMode), true);
1579             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1580             ret.SendResume();
1581             return ret;
1582         }
1583
1584         public static Application New(string[] args, string stylesheet, Application.WindowMode windowMode)
1585         {
1586             int argc = args.Length;
1587             string argvStr = string.Join(" ", args);
1588
1589             Application ret = new Application(NDalicPINVOKE.Application_New__MANUAL_4(argc, argvStr, stylesheet, (int)windowMode), true);
1590             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1591             return ret;
1592         }
1593
1594         public static Application New(int argc, string stylesheet, Application.WindowMode windowMode, Rectangle positionSize)
1595         {
1596             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_4(argc, stylesheet, (int)windowMode, Rectangle.getCPtr(positionSize)), true);
1597             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1598             return ret;
1599         }
1600
1601         public Application() : this(NDalicPINVOKE.new_Application__SWIG_0(), true)
1602         {
1603             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1604         }
1605
1606         public Application(Application application) : this(NDalicPINVOKE.new_Application__SWIG_1(Application.getCPtr(application)), true)
1607         {
1608             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1609         }
1610
1611         public Application Assign(Application application)
1612         {
1613             Application ret = new Application(NDalicPINVOKE.Application_Assign(swigCPtr, Application.getCPtr(application)), false);
1614             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1615             return ret;
1616         }
1617
1618         public void MainLoop()
1619         {
1620             NDalicPINVOKE.Application_MainLoop__SWIG_0(swigCPtr);
1621             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1622         }
1623
1624         internal void MainLoop(SWIGTYPE_p_Configuration__ContextLoss configuration)
1625         {
1626             NDalicPINVOKE.Application_MainLoop__SWIG_1(swigCPtr, SWIGTYPE_p_Configuration__ContextLoss.getCPtr(configuration));
1627             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1628         }
1629
1630         public void Lower()
1631         {
1632             NDalicPINVOKE.Application_Lower(swigCPtr);
1633             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1634         }
1635
1636         public void Quit()
1637         {
1638             NDalicPINVOKE.Application_Quit(swigCPtr);
1639             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1640         }
1641
1642         internal bool AddIdle(SWIGTYPE_p_Dali__CallbackBase callback)
1643         {
1644             bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, SWIGTYPE_p_Dali__CallbackBase.getCPtr(callback));
1645             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1646             return ret;
1647         }
1648
1649         public Window GetWindow()
1650         {
1651             Window ret = new Window(NDalicPINVOKE.Application_GetWindow(swigCPtr), true);
1652             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1653             return ret;
1654         }
1655
1656         public void ReplaceWindow(Rectangle windowPosition, string name)
1657         {
1658             NDalicPINVOKE.Application_ReplaceWindow(swigCPtr, Rectangle.getCPtr(windowPosition), name);
1659             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1660         }
1661
1662         public static string GetResourcePath()
1663         {
1664             string ret = NDalicPINVOKE.Application_GetResourcePath();
1665             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1666             return ret;
1667         }
1668
1669         internal void SetViewMode(ViewMode viewMode)
1670         {
1671             NDalicPINVOKE.Application_SetViewMode(swigCPtr, (int)viewMode);
1672             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1673         }
1674
1675         internal ViewMode GetViewMode()
1676         {
1677             ViewMode ret = (ViewMode)NDalicPINVOKE.Application_GetViewMode(swigCPtr);
1678             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1679             return ret;
1680         }
1681
1682         public void SetStereoBase(float stereoBase)
1683         {
1684             NDalicPINVOKE.Application_SetStereoBase(swigCPtr, stereoBase);
1685             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1686         }
1687
1688         public float GetStereoBase()
1689         {
1690             float ret = NDalicPINVOKE.Application_GetStereoBase(swigCPtr);
1691             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1692             return ret;
1693         }
1694
1695         public string GetLanguage()
1696         {
1697             string ret = NDalicPINVOKE.Application_GetLanguage(swigCPtr);
1698             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1699             return ret;
1700         }
1701
1702         public string GetRegion()
1703         {
1704             string ret = NDalicPINVOKE.Application_GetRegion(swigCPtr);
1705             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1706             return ret;
1707         }
1708
1709
1710         internal ApplicationSignal InitSignal()
1711         {
1712             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_InitSignal(swigCPtr), false);
1713             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1714             return ret;
1715         }
1716
1717         internal ApplicationSignal TerminateSignal()
1718         {
1719             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_TerminateSignal(swigCPtr), false);
1720             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1721             return ret;
1722         }
1723
1724         internal ApplicationSignal PauseSignal()
1725         {
1726             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_PauseSignal(swigCPtr), false);
1727             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1728             return ret;
1729         }
1730
1731         internal ApplicationSignal ResumeSignal()
1732         {
1733             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResumeSignal(swigCPtr), false);
1734             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1735             return ret;
1736         }
1737
1738         internal ApplicationSignal ResetSignal()
1739         {
1740             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResetSignal(swigCPtr), false);
1741             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1742             return ret;
1743         }
1744
1745         internal ApplicationSignal ResizeSignal()
1746         {
1747             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResizeSignal(swigCPtr), false);
1748             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1749             return ret;
1750         }
1751
1752         internal ApplicationControlSignal AppControlSignal()
1753         {
1754             ApplicationControlSignal ret = new ApplicationControlSignal(NDalicPINVOKE.Application_AppControlSignal(swigCPtr), false);
1755             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1756             return ret;
1757         }
1758
1759         internal ApplicationSignal LanguageChangedSignal()
1760         {
1761             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_LanguageChangedSignal(swigCPtr), false);
1762             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1763             return ret;
1764         }
1765
1766         internal ApplicationSignal RegionChangedSignal()
1767         {
1768             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_RegionChangedSignal(swigCPtr), false);
1769             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1770             return ret;
1771         }
1772
1773         internal LowBatterySignalType BatteryLowSignal()
1774         {
1775             LowBatterySignalType ret = new LowBatterySignalType(NDalicPINVOKE.Application_LowBatterySignal(swigCPtr), false);
1776             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1777             return ret;
1778         }
1779
1780         internal LowMemorySignalType MemoryLowSignal()
1781         {
1782             LowMemorySignalType ret = new LowMemorySignalType(NDalicPINVOKE.Application_LowMemorySignal(swigCPtr), false);
1783             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1784             return ret;
1785         }
1786
1787         /// <since_tizen> 3 </since_tizen>
1788         public enum WindowMode
1789         {
1790             Opaque = 0,
1791             Transparent = 1
1792         }
1793
1794     }
1795
1796 }