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           * @brief Event for Paused signal which can be used to subscribe/unsubscribe the event handler
1020           * provided by the user. Paused signal is emitted when application is paused
1021           */
1022         public event DaliEventHandler<object, NUIApplicationPausedEventArgs> Paused
1023         {
1024             add
1025             {
1026                 lock (this)
1027                 {
1028                     // Restricted to only one listener
1029                     if (_applicationPauseEventHandler == null)
1030                     {
1031                         _applicationPauseEventHandler += value;
1032
1033                         _applicationPauseEventCallbackDelegate = new NUIApplicationPauseEventCallbackDelegate(OnNUIApplicationPause);
1034                         this.PauseSignal().Connect(_applicationPauseEventCallbackDelegate);
1035                     }
1036                 }
1037             }
1038
1039             remove
1040             {
1041                 lock (this)
1042                 {
1043                     if (_applicationPauseEventHandler != null)
1044                     {
1045                         this.PauseSignal().Disconnect(_applicationPauseEventCallbackDelegate);
1046                     }
1047
1048                     _applicationPauseEventHandler -= value;
1049                 }
1050             }
1051         }
1052
1053         // Callback for Application PauseSignal
1054         private void OnNUIApplicationPause(IntPtr data)
1055         {
1056             if (_applicationPauseEventHandler != null)
1057             {
1058                 NUIApplicationPausedEventArgs e = new NUIApplicationPausedEventArgs();
1059                 e.Application = this;
1060                 _applicationPauseEventHandler.Invoke(this, e);
1061             }
1062         }
1063
1064         /**
1065           * @brief Event for Resumed signal which can be used to subscribe/unsubscribe the event handler
1066           *  provided by the user. Resumed signal is emitted when application is resumed
1067           */
1068         public event DaliEventHandler<object, NUIApplicationResumedEventArgs> Resumed
1069         {
1070             add
1071             {
1072                 lock (this)
1073                 {
1074                     // Restricted to only one listener
1075                     if (_applicationResumeEventHandler == null)
1076                     {
1077                         _applicationResumeEventHandler += value;
1078
1079                         _applicationResumeEventCallbackDelegate = new NUIApplicationResumeEventCallbackDelegate(OnNUIApplicationResume);
1080                         this.ResumeSignal().Connect(_applicationResumeEventCallbackDelegate);
1081                     }
1082                 }
1083             }
1084
1085             remove
1086             {
1087                 lock (this)
1088                 {
1089                     if (_applicationResumeEventHandler != null)
1090                     {
1091                         this.ResumeSignal().Disconnect(_applicationResumeEventCallbackDelegate);
1092                     }
1093
1094                     _applicationResumeEventHandler -= value;
1095                 }
1096             }
1097         }
1098
1099         // Callback for Application ResumeSignal
1100         private void OnNUIApplicationResume(IntPtr data)
1101         {
1102             if (_applicationResumeEventHandler != null)
1103             {
1104                 NUIApplicationResumedEventArgs e = new NUIApplicationResumedEventArgs();
1105                 e.Application = this;
1106                 _applicationResumeEventHandler.Invoke(this, e);
1107             }
1108         }
1109
1110         /**
1111           * @brief Event for Reset signal which can be used to subscribe/unsubscribe the event handler
1112           *  provided by the user. Reset signal is emitted when application is reset
1113           */
1114         public new event DaliEventHandler<object, NUIApplicationResetEventArgs> Reset
1115         {
1116             add
1117             {
1118                 lock (this)
1119                 {
1120                     // Restricted to only one listener
1121                     if (_applicationResetEventHandler == null)
1122                     {
1123                         _applicationResetEventHandler += value;
1124
1125                         _applicationResetEventCallbackDelegate = new NUIApplicationResetEventCallbackDelegate(OnNUIApplicationReset);
1126                         this.ResetSignal().Connect(_applicationResetEventCallbackDelegate);
1127                     }
1128                 }
1129             }
1130
1131             remove
1132             {
1133                 lock (this)
1134                 {
1135                     if (_applicationResetEventHandler != null)
1136                     {
1137                         this.ResetSignal().Disconnect(_applicationResetEventCallbackDelegate);
1138                     }
1139
1140                     _applicationResetEventHandler -= value;
1141                 }
1142             }
1143         }
1144
1145         // Callback for Application ResetSignal
1146         private void OnNUIApplicationReset(IntPtr data)
1147         {
1148             if (_applicationResetEventHandler != null)
1149             {
1150                 NUIApplicationResetEventArgs e = new NUIApplicationResetEventArgs();
1151                 e.Application = this;
1152                 _applicationResetEventHandler.Invoke(this, e);
1153             }
1154         }
1155
1156         /**
1157           * @brief Event for Resized signal which can be used to subscribe/unsubscribe the event handler
1158           *  provided by the user. Resized signal is emitted when application is resized
1159           */
1160         public event DaliEventHandler<object, NUIApplicationResizedEventArgs> Resized
1161         {
1162             add
1163             {
1164                 lock (this)
1165                 {
1166                     // Restricted to only one listener
1167                     if (_applicationResizeEventHandler == null)
1168                     {
1169                         _applicationResizeEventHandler += value;
1170
1171                         _applicationResizeEventCallbackDelegate = new NUIApplicationResizeEventCallbackDelegate(OnNUIApplicationResize);
1172                         this.ResizeSignal().Connect(_applicationResizeEventCallbackDelegate);
1173                     }
1174                 }
1175             }
1176
1177             remove
1178             {
1179                 lock (this)
1180                 {
1181                     if (_applicationResizeEventHandler != null)
1182                     {
1183                         this.ResizeSignal().Disconnect(_applicationResizeEventCallbackDelegate);
1184                     }
1185
1186                     _applicationResizeEventHandler -= value;
1187                 }
1188             }
1189         }
1190
1191         // Callback for Application ResizeSignal
1192         private void OnNUIApplicationResize(IntPtr data)
1193         {
1194             if (_applicationResizeEventHandler != null)
1195             {
1196                 NUIApplicationResizedEventArgs e = new NUIApplicationResizedEventArgs();
1197                 e.Application = this;
1198                 _applicationResizeEventHandler.Invoke(this, e);
1199             }
1200         }
1201
1202         /**
1203           * @brief Event for LanguageChanged signal which can be used to subscribe/unsubscribe the event handler
1204           *  provided by the user. LanguageChanged signal is emitted when the region of the device is changed.
1205           */
1206         public event DaliEventHandler<object, NUIApplicationLanguageChangedEventArgs> LanguageChanged
1207         {
1208             add
1209             {
1210                 lock (this)
1211                 {
1212                     // Restricted to only one listener
1213                     if (_applicationLanguageChangedEventHandler == null)
1214                     {
1215                         _applicationLanguageChangedEventHandler += value;
1216
1217                         _applicationLanguageChangedEventCallbackDelegate = new NUIApplicationLanguageChangedEventCallbackDelegate(OnNUIApplicationLanguageChanged);
1218                         this.LanguageChangedSignal().Connect(_applicationLanguageChangedEventCallbackDelegate);
1219                     }
1220                 }
1221             }
1222
1223             remove
1224             {
1225                 lock (this)
1226                 {
1227                     if (_applicationLanguageChangedEventHandler != null)
1228                     {
1229                         this.LanguageChangedSignal().Disconnect(_applicationLanguageChangedEventCallbackDelegate);
1230                     }
1231
1232                     _applicationLanguageChangedEventHandler -= value;
1233                 }
1234             }
1235         }
1236
1237         // Callback for Application LanguageChangedSignal
1238         private void OnNUIApplicationLanguageChanged(IntPtr data)
1239         {
1240             if (_applicationLanguageChangedEventHandler != null)
1241             {
1242                 NUIApplicationLanguageChangedEventArgs e = new NUIApplicationLanguageChangedEventArgs();
1243                 e.Application = this;
1244                 _applicationLanguageChangedEventHandler.Invoke(this, e);
1245             }
1246         }
1247
1248         /**
1249           * @brief Event for RegionChanged signal which can be used to subscribe/unsubscribe the event handler
1250           *  provided by the user. RegionChanged signal is emitted when the region of the device is changed.
1251           */
1252         public event DaliEventHandler<object, NUIApplicationRegionChangedEventArgs> RegionChanged
1253         {
1254             add
1255             {
1256                 lock (this)
1257                 {
1258                     // Restricted to only one listener
1259                     if (_applicationRegionChangedEventHandler == null)
1260                     {
1261                         _applicationRegionChangedEventHandler += value;
1262
1263                         _applicationRegionChangedEventCallbackDelegate = new NUIApplicationRegionChangedEventCallbackDelegate(OnNUIApplicationRegionChanged);
1264                         this.RegionChangedSignal().Connect(_applicationRegionChangedEventCallbackDelegate);
1265                     }
1266                 }
1267             }
1268
1269             remove
1270             {
1271                 lock (this)
1272                 {
1273                     if (_applicationRegionChangedEventHandler != null)
1274                     {
1275                         this.RegionChangedSignal().Disconnect(_applicationRegionChangedEventCallbackDelegate);
1276                     }
1277
1278                     _applicationRegionChangedEventHandler -= value;
1279                 }
1280             }
1281         }
1282
1283         // Callback for Application RegionChangedSignal
1284         private void OnNUIApplicationRegionChanged(IntPtr data)
1285         {
1286             if (_applicationRegionChangedEventHandler != null)
1287             {
1288                 NUIApplicationRegionChangedEventArgs e = new NUIApplicationRegionChangedEventArgs();
1289                 e.Application = this;
1290                 _applicationRegionChangedEventHandler.Invoke(this, e);
1291             }
1292         }
1293
1294         /**
1295           * @brief Event for BatteryLow signal which can be used to subscribe/unsubscribe the event handler
1296           * provided by the user. BatteryLow signal is emitted when the battery level of the device is low.
1297           */
1298         public event DaliEventHandler<object, NUIApplicationBatteryLowEventArgs> BatteryLow
1299         {
1300             add
1301             {
1302                 lock (this)
1303                 {
1304                     // Restricted to only one listener
1305                     if (_applicationBatteryLowEventHandler == null)
1306                     {
1307                         _applicationBatteryLowEventHandler += value;
1308
1309                         _applicationBatteryLowEventCallbackDelegate = new NUIApplicationBatteryLowEventCallbackDelegate(OnNUIApplicationBatteryLow);
1310                         this.BatteryLowSignal().Connect(_applicationBatteryLowEventCallbackDelegate);
1311                     }
1312                 }
1313             }
1314
1315             remove
1316             {
1317                 lock (this)
1318                 {
1319                     if (_applicationBatteryLowEventHandler != null)
1320                     {
1321                         this.BatteryLowSignal().Disconnect(_applicationBatteryLowEventCallbackDelegate);
1322                     }
1323
1324                     _applicationBatteryLowEventHandler -= value;
1325                 }
1326             }
1327         }
1328
1329         // Callback for Application BatteryLowSignal
1330         private void OnNUIApplicationBatteryLow(BatteryStatus status)
1331         {
1332             lock (this)
1333             {
1334                 NUIApplicationBatteryLowEventArgs e = new NUIApplicationBatteryLowEventArgs();
1335
1336                 // Populate all members of "e" (NUIApplicationBatteryLowEventArgs) with real data
1337                 e.BatteryStatus = status;
1338                 _applicationBatteryLowEventHandler?.Invoke(this, e);
1339             }
1340         }
1341
1342         /**
1343           * @brief Event for MemoryLow signal which can be used to subscribe/unsubscribe the event handler
1344           *  provided by the user. MemoryLow signal is emitted when the memory level of the device is low.
1345           */
1346         public event DaliEventHandler<object, NUIApplicationMemoryLowEventArgs> MemoryLow
1347         {
1348             add
1349             {
1350                 lock (this)
1351                 {
1352                     // Restricted to only one listener
1353                     if (_applicationMemoryLowEventHandler == null)
1354                     {
1355                         _applicationMemoryLowEventHandler += value;
1356
1357                         _applicationMemoryLowEventCallbackDelegate = new NUIApplicationMemoryLowEventCallbackDelegate(OnNUIApplicationMemoryLow);
1358                         this.MemoryLowSignal().Connect(_applicationMemoryLowEventCallbackDelegate);
1359                     }
1360                 }
1361             }
1362
1363             remove
1364             {
1365                 lock (this)
1366                 {
1367                     if (_applicationMemoryLowEventHandler != null)
1368                     {
1369                         this.MemoryLowSignal().Disconnect(_applicationMemoryLowEventCallbackDelegate);
1370                     }
1371
1372                     _applicationMemoryLowEventHandler -= value;
1373                 }
1374             }
1375         }
1376
1377         // Callback for Application MemoryLowSignal
1378         private void OnNUIApplicationMemoryLow(MemoryStatus status)
1379         {
1380             lock (this)
1381             {
1382                 NUIApplicationMemoryLowEventArgs e = new NUIApplicationMemoryLowEventArgs();
1383
1384                 // Populate all members of "e" (NUIApplicationMemoryLowEventArgs) with real data
1385                 e.MemoryStatus = status;
1386                 _applicationMemoryLowEventHandler?.Invoke(this, e);
1387             }
1388         }
1389
1390         /**
1391           * @brief Event for AppControl signal which can be used to subscribe/unsubscribe the event handler
1392           *  provided by the user. AppControl signal is emitted when another application sends a launch request to the application.
1393           */
1394         public event DaliEventHandler<object, NUIApplicationAppControlEventArgs> AppControl
1395         {
1396             add
1397             {
1398                 lock (this)
1399                 {
1400                     // Restricted to only one listener
1401                     if (_applicationAppControlEventHandler == null)
1402                     {
1403                         _applicationAppControlEventHandler += value;
1404
1405                         _applicationAppControlEventCallbackDelegate = new NUIApplicationAppControlEventCallbackDelegate(OnNUIApplicationAppControl);
1406                         this.AppControlSignal().Connect(_applicationAppControlEventCallbackDelegate);
1407                     }
1408                 }
1409             }
1410
1411             remove
1412             {
1413                 lock (this)
1414                 {
1415                     if (_applicationAppControlEventHandler != null)
1416                     {
1417                         this.AppControlSignal().Disconnect(_applicationAppControlEventCallbackDelegate);
1418                     }
1419
1420                     _applicationAppControlEventHandler -= value;
1421                 }
1422             }
1423         }
1424
1425         // Callback for Application AppControlSignal
1426         private void OnNUIApplicationAppControl(IntPtr application, IntPtr voidp)
1427         {
1428             if (_applicationAppControlEventHandler != null)
1429             {
1430                 NUIApplicationAppControlEventArgs e = new NUIApplicationAppControlEventArgs();
1431                 e.VoidP = voidp;
1432                 e.Application = this;
1433                 _applicationAppControlEventHandler.Invoke(this, e);
1434             }
1435         }
1436
1437         private static Application _instance; // singleton
1438
1439         public static Application Instance
1440         {
1441             get
1442             {
1443                 return _instance;
1444             }
1445         }
1446
1447         public static Application GetApplicationFromPtr(global::System.IntPtr cPtr)
1448         {
1449             if (cPtr == global::System.IntPtr.Zero)
1450             {
1451                 return null;
1452             }
1453
1454             Application ret = Registry.GetManagedBaseHandleFromNativePtr(cPtr) as Application;
1455             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1456             return ret;
1457         }
1458
1459         public static Application NewApplication()
1460         {
1461             return NewApplication("", Application.WindowMode.Opaque);
1462         }
1463
1464         public static Application NewApplication(string stylesheet)
1465         {
1466             return NewApplication(stylesheet, Application.WindowMode.Opaque);
1467         }
1468
1469         public static Application NewApplication(string stylesheet, Application.WindowMode windowMode)
1470         {
1471             // register all Views with the type registry, so that can be created / styled via JSON
1472             //ViewRegistryHelper.Initialize(); //moved to Application side.
1473
1474             Application ret = New(1, stylesheet, windowMode);
1475             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1476
1477             // set the singleton
1478             _instance = ret;
1479             return ret;
1480         }
1481
1482
1483         public static Application NewApplication(string[] args, string stylesheet, Application.WindowMode windowMode)
1484         {
1485             Application ret = New(args, stylesheet, (Application.WindowMode)windowMode);
1486             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1487
1488             // set the singleton
1489             _instance = ret;
1490             return _instance;
1491         }
1492
1493         /// <summary>
1494         /// Ensures that the function passed in is called from the main loop when it is idle.
1495         /// </summary>
1496         /// <param name="func">The function to call</param>
1497         /// <returns>true if added successfully, false otherwise</returns>
1498         public bool AddIdle(System.Delegate func)
1499         {
1500             System.IntPtr ip = System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate<System.Delegate>(func);
1501             System.IntPtr ip2 = NDalicManualPINVOKE.MakeCallback(new System.Runtime.InteropServices.HandleRef(this, ip));
1502
1503             bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, new System.Runtime.InteropServices.HandleRef(this, ip2));
1504
1505             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1506             return ret;
1507         }
1508
1509         /**
1510         * Outer::outer_method(int)
1511         */
1512         public static Application New()
1513         {
1514             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_0(), true);
1515             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1516             return ret;
1517         }
1518
1519         public static Application New(int argc)
1520         {
1521             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_1(argc), true);
1522             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1523             return ret;
1524         }
1525
1526         public static Application New(int argc, string stylesheet)
1527         {
1528             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_2(argc, stylesheet), true);
1529             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1530             return ret;
1531         }
1532
1533         public static Application New(int argc, string stylesheet, Application.WindowMode windowMode)
1534         {
1535             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_3(argc, stylesheet, (int)windowMode), true);
1536             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1537             ret.SendResume();
1538             return ret;
1539         }
1540
1541         public static Application New(string[] args, string stylesheet, Application.WindowMode windowMode)
1542         {
1543             int argc = args.Length;
1544             string argvStr = string.Join(" ", args);
1545
1546             Application ret = new Application(NDalicPINVOKE.Application_New__MANUAL_4(argc, argvStr, stylesheet, (int)windowMode), true);
1547             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1548             return ret;
1549         }
1550
1551         public static Application New(int argc, string stylesheet, Application.WindowMode windowMode, Rectangle positionSize)
1552         {
1553             Application ret = new Application(NDalicPINVOKE.Application_New__SWIG_4(argc, stylesheet, (int)windowMode, Rectangle.getCPtr(positionSize)), true);
1554             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1555             return ret;
1556         }
1557
1558         public Application() : this(NDalicPINVOKE.new_Application__SWIG_0(), true)
1559         {
1560             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1561         }
1562
1563         public Application(Application application) : this(NDalicPINVOKE.new_Application__SWIG_1(Application.getCPtr(application)), true)
1564         {
1565             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1566         }
1567
1568         public Application Assign(Application application)
1569         {
1570             Application ret = new Application(NDalicPINVOKE.Application_Assign(swigCPtr, Application.getCPtr(application)), false);
1571             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1572             return ret;
1573         }
1574
1575         public void MainLoop()
1576         {
1577             NDalicPINVOKE.Application_MainLoop__SWIG_0(swigCPtr);
1578             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1579         }
1580
1581         internal void MainLoop(SWIGTYPE_p_Configuration__ContextLoss configuration)
1582         {
1583             NDalicPINVOKE.Application_MainLoop__SWIG_1(swigCPtr, SWIGTYPE_p_Configuration__ContextLoss.getCPtr(configuration));
1584             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1585         }
1586
1587         public void Lower()
1588         {
1589             NDalicPINVOKE.Application_Lower(swigCPtr);
1590             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1591         }
1592
1593         public void Quit()
1594         {
1595             NDalicPINVOKE.Application_Quit(swigCPtr);
1596             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1597         }
1598
1599         internal bool AddIdle(SWIGTYPE_p_Dali__CallbackBase callback)
1600         {
1601             bool ret = NDalicPINVOKE.Application_AddIdle(swigCPtr, SWIGTYPE_p_Dali__CallbackBase.getCPtr(callback));
1602             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1603             return ret;
1604         }
1605
1606         public Window GetWindow()
1607         {
1608             Window ret = new Window(NDalicPINVOKE.Application_GetWindow(swigCPtr), true);
1609             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1610             return ret;
1611         }
1612
1613         public void ReplaceWindow(Rectangle windowPosition, string name)
1614         {
1615             NDalicPINVOKE.Application_ReplaceWindow(swigCPtr, Rectangle.getCPtr(windowPosition), name);
1616             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1617         }
1618
1619         public static string GetResourcePath()
1620         {
1621             string ret = NDalicPINVOKE.Application_GetResourcePath();
1622             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1623             return ret;
1624         }
1625
1626         public string GetLanguage()
1627         {
1628             string ret = NDalicPINVOKE.Application_GetLanguage(swigCPtr);
1629             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1630             return ret;
1631         }
1632
1633         public string GetRegion()
1634         {
1635             string ret = NDalicPINVOKE.Application_GetRegion(swigCPtr);
1636             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1637             return ret;
1638         }
1639
1640
1641         internal ApplicationSignal InitSignal()
1642         {
1643             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_InitSignal(swigCPtr), false);
1644             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1645             return ret;
1646         }
1647
1648         internal ApplicationSignal TerminateSignal()
1649         {
1650             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_TerminateSignal(swigCPtr), false);
1651             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1652             return ret;
1653         }
1654
1655         internal ApplicationSignal PauseSignal()
1656         {
1657             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_PauseSignal(swigCPtr), false);
1658             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1659             return ret;
1660         }
1661
1662         internal ApplicationSignal ResumeSignal()
1663         {
1664             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResumeSignal(swigCPtr), false);
1665             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1666             return ret;
1667         }
1668
1669         internal ApplicationSignal ResetSignal()
1670         {
1671             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResetSignal(swigCPtr), false);
1672             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1673             return ret;
1674         }
1675
1676         internal ApplicationSignal ResizeSignal()
1677         {
1678             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_ResizeSignal(swigCPtr), false);
1679             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1680             return ret;
1681         }
1682
1683         internal ApplicationControlSignal AppControlSignal()
1684         {
1685             ApplicationControlSignal ret = new ApplicationControlSignal(NDalicPINVOKE.Application_AppControlSignal(swigCPtr), false);
1686             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1687             return ret;
1688         }
1689
1690         internal ApplicationSignal LanguageChangedSignal()
1691         {
1692             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_LanguageChangedSignal(swigCPtr), false);
1693             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1694             return ret;
1695         }
1696
1697         internal ApplicationSignal RegionChangedSignal()
1698         {
1699             ApplicationSignal ret = new ApplicationSignal(NDalicPINVOKE.Application_RegionChangedSignal(swigCPtr), false);
1700             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1701             return ret;
1702         }
1703
1704         internal LowBatterySignalType BatteryLowSignal()
1705         {
1706             LowBatterySignalType ret = new LowBatterySignalType(NDalicPINVOKE.Application_LowBatterySignal(swigCPtr), false);
1707             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1708             return ret;
1709         }
1710
1711         internal LowMemorySignalType MemoryLowSignal()
1712         {
1713             LowMemorySignalType ret = new LowMemorySignalType(NDalicPINVOKE.Application_LowMemorySignal(swigCPtr), false);
1714             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1715             return ret;
1716         }
1717
1718         /// <since_tizen> 3 </since_tizen>
1719         public enum WindowMode
1720         {
1721             Opaque = 0,
1722             Transparent = 1
1723         }
1724
1725     }
1726
1727 }