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