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

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