src/Tizen.NUI/src/internal/WidgetApplication.cs

   1 /*
   2  * Copyright(c) 2017 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System;
  18 using System.Runtime.InteropServices;
  19
  20 namespace Tizen.NUI
  21 {
  22     /// <summary>
  23     /// Widget application
  24     /// </summary>
  25     internal class WidgetApplication : BaseHandle
  26     {
  27         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  28
  29         internal WidgetApplication(global::System.IntPtr cPtr, bool cMemoryOwn) : base(NDalicManualPINVOKE.WidgetApplication_SWIGUpcast(cPtr), cMemoryOwn)
  30         {
  31             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  32         }
  33
  34         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(WidgetApplication obj)
  35         {
  36             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  37         }
  38
  39         /// <summary>
  40         /// To make Window instance be disposed.
  41         /// </summary>
  42         protected override void Dispose(DisposeTypes type)
  43         {
  44             if(disposed)
  45             {
  46                 return;
  47             }
  48
  49             if(type == DisposeTypes.Explicit)
  50             {
  51                 //Called by User
  52                 //Release your own managed resources here.
  53                 //You should release all of your own disposable objects here.
  54             }
  55
  56             //Release your own unmanaged resources here.
  57             //You should not access any managed member here except static instance.
  58             //because the execution order of Finalizes is non-deterministic.
  59
  60             if (_initCallback != null)
  61             {
  62                 this.InitSignal().Disconnect(_initCallback);
  63             }
  64             if (_terminateCallback != null)
  65             {
  66                 this.TerminateSignal().Disconnect(_terminateCallback);
  67             }
  68             if (_languageChangedCallback != null)
  69             {
  70                 this.LanguageChangedSignal().Disconnect(_languageChangedCallback);;
  71             }
  72             if (_regionChangedCallback != null)
  73             {
  74                 this.RegionChangedSignal().Disconnect(_regionChangedCallback);
  75             }
  76             if (_batteryLowCallback != null)
  77             {
  78                 this.BatteryLowSignal().Disconnect(_batteryLowCallback);
  79             }
  80             if (_memoryLowCallback != null)
  81             {
  82                 this.MemoryLowSignal().Disconnect(_memoryLowCallback);
  83             }
  84
  85             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  86             {
  87                 if (swigCMemOwn)
  88                 {
  89                     swigCMemOwn = false;
  90                     NDalicManualPINVOKE.delete_WidgetApplication(swigCPtr);
  91                 }
  92                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  93             }
  94
  95             base.Dispose(type);
  96         }
  97
  98         internal static WidgetApplication GetWidgetApplicationFromPtr(global::System.IntPtr cPtr)
  99         {
 100             WidgetApplication ret = new WidgetApplication(cPtr, false);
 101             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 102             return ret;
 103         }
 104
 105         public static WidgetApplication Instance
 106         {
 107             get
 108             {
 109                 return _instance;
 110             }
 111         }
 112
 113         public static WidgetApplication NewWidgetApplication(string[] args, string stylesheet)
 114         {
 115             WidgetApplication ret = New(args, stylesheet);
 116             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 117
 118             _instance = ret;
 119             return ret;
 120         }
 121
 122         public static WidgetApplication New(string[] args, string stylesheet)
 123         {
 124             int argc = args.Length;
 125             string argvStr = string.Join(" ", args);
 126
 127             WidgetApplication ret = new WidgetApplication(NDalicManualPINVOKE.WidgetApplication_New(argc, argvStr, stylesheet), true);
 128             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 129             return ret;
 130         }
 131
 132         internal WidgetApplication(WidgetApplication widgetApplication) : this(NDalicManualPINVOKE.new_WidgetApplication__SWIG_1(WidgetApplication.getCPtr(widgetApplication)), true)
 133         {
 134             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 135         }
 136
 137         internal WidgetApplication Assign(WidgetApplication widgetApplication)
 138         {
 139             WidgetApplication ret = new WidgetApplication(NDalicManualPINVOKE.WidgetApplication_Assign(swigCPtr, WidgetApplication.getCPtr(widgetApplication)), false);
 140             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 141             return ret;
 142         }
 143
 144         /// <summary>
 145         /// This starts the application.
 146         /// </summary>
 147         public void MainLoop()
 148         {
 149             NDalicManualPINVOKE.WidgetApplication_MainLoop(swigCPtr);
 150             if (NDalicPINVOKE.SWIGPendingException.Pending)
 151             {
 152                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 153             }
 154         }
 155
 156         /// <summary>
 157         /// This quits the application.
 158         /// Tizen applications should use Lower to improve re-start performance unless they need to Quit completely.
 159         /// </summary>
 160         public void Quit()
 161         {
 162             NDalicManualPINVOKE.WidgetApplication_Quit(swigCPtr);
 163             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 164         }
 165
 166         /// <summary>
 167         /// Get path application resources are stored at.
 168         /// </summary>
 169         /// <returns>The full path of the resources</returns>
 170         public static string GetResourcePath()
 171         {
 172             string ret = NDalicManualPINVOKE.WidgetApplication_GetResourcePath();
 173             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 174             return ret;
 175         }
 176
 177         /// <summary>
 178         /// Get region information from device.
 179         /// </summary>
 180         /// <returns>Region information</returns>
 181         public string GetRegion()
 182         {
 183             string ret = NDalicManualPINVOKE.WidgetApplication_GetRegion(swigCPtr);
 184             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 185             return ret;
 186         }
 187
 188         /// <summary>
 189         /// Get language from device.
 190         /// </summary>
 191         /// <returns>Language information</returns>
 192         public string GetLanguage()
 193         {
 194             string ret = NDalicManualPINVOKE.WidgetApplication_GetLanguage(swigCPtr);
 195             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 196             return ret;
 197         }
 198
 199         /// <summary>
 200         /// Event arguments that passed via widget app event signal.
 201         /// </summary>
 202         public class WidgetApplicationEventArgs : EventArgs
 203         {
 204             /// <summary>
 205             /// Widget application.
 206             /// </summary>
 207             public WidgetApplication WidgetApplication
 208             {
 209                 get;
 210                 set;
 211             }
 212         }
 213
 214         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 215         private delegate void InitCallbackType(IntPtr widgetApplication);
 216         private InitCallbackType _initCallback;
 217         private DaliEventHandler<object,WidgetApplicationEventArgs> _initEventHandler;
 218
 219         /// <summary>
 220         /// Init event.
 221         /// </summary>
 222         public event DaliEventHandler<object, WidgetApplicationEventArgs> Init
 223         {
 224             add
 225             {
 226                 if (_initEventHandler == null)
 227                 {
 228                     _initCallback = new InitCallbackType( OnInit);
 229                     InitSignal().Connect(_initCallback);
 230                 }
 231
 232                 _initEventHandler += value;
 233             }
 234
 235             remove
 236             {
 237                 _initEventHandler -= value;
 238
 239                 if (_initEventHandler == null && InitSignal().Empty() == false)
 240                 {
 241                    InitSignal().Disconnect(_initCallback);
 242                 }
 243             }
 244         }
 245
 246         private void OnInit(IntPtr widgetApplication)
 247         {
 248             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 249             if (widgetApplication != null)
 250             {
 251                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 252             }
 253
 254             if (_initEventHandler != null)
 255             {
 256                 _initEventHandler(this, e);
 257             }
 258         }
 259
 260         internal AppSignalType InitSignal()
 261         {
 262             AppSignalType ret = new AppSignalType(NDalicManualPINVOKE.WidgetApplication_InitSignal(swigCPtr), false);
 263             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 264             return ret;
 265         }
 266
 267         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 268         private delegate void TerminateCallbackType(IntPtr widgetApplication);
 269         private TerminateCallbackType _terminateCallback;
 270         private DaliEventHandler<object, WidgetApplicationEventArgs> _terminateEventHandler;
 271
 272         /// <summary>
 273         /// Terminate event.
 274         /// </summary>
 275         public event DaliEventHandler<object, WidgetApplicationEventArgs> Terminate
 276         {
 277             add
 278             {
 279                 if (_terminateEventHandler == null)
 280                 {
 281                     _terminateCallback = new TerminateCallbackType( OnTerminate);
 282                     TerminateSignal().Connect(_terminateCallback);
 283                 }
 284
 285                 _terminateEventHandler += value;
 286             }
 287
 288             remove
 289             {
 290                 _terminateEventHandler -= value;
 291
 292                 if (_terminateEventHandler == null && TerminateSignal().Empty() == false)
 293                 {
 294                    TerminateSignal().Disconnect(_terminateCallback);
 295                 }
 296             }
 297         }
 298
 299         private void OnTerminate(IntPtr widgetApplication)
 300         {
 301             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 302
 303             if (widgetApplication != null)
 304             {
 305                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 306             }
 307
 308             if (_terminateEventHandler != null)
 309             {
 310                 _terminateEventHandler(this, e);
 311             }
 312         }
 313
 314         internal AppSignalType TerminateSignal()
 315         {
 316             AppSignalType ret = new AppSignalType(NDalicManualPINVOKE.WidgetApplication_TerminateSignal(swigCPtr), false);
 317             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 318             return ret;
 319         }
 320
 321         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 322         private delegate void LanguageChangedCallbackType(IntPtr widgetApplication);
 323         private LanguageChangedCallbackType _languageChangedCallback;
 324         private DaliEventHandler<object, WidgetApplicationEventArgs> _languageChangedEventHandler;
 325
 326         /// <summary>
 327         /// LanguageChanged event.
 328         /// </summary>
 329         public event DaliEventHandler<object, WidgetApplicationEventArgs> LanguageChanged
 330         {
 331             add
 332             {
 333                 if (_languageChangedEventHandler == null)
 334                 {
 335                     _languageChangedCallback = new LanguageChangedCallbackType( OnLanguageChanged);
 336                     LanguageChangedSignal().Connect(_languageChangedCallback);
 337                 }
 338
 339                 _languageChangedEventHandler += value;
 340             }
 341
 342             remove
 343             {
 344                 _languageChangedEventHandler -= value;
 345
 346                 if (_languageChangedEventHandler == null && LanguageChangedSignal().Empty() == false)
 347                 {
 348                    LanguageChangedSignal().Disconnect(_languageChangedCallback);
 349                 }
 350             }
 351         }
 352
 353         private void OnLanguageChanged(IntPtr widgetApplication)
 354         {
 355             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 356
 357             if (widgetApplication != null)
 358             {
 359                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 360             }
 361
 362             if (_languageChangedEventHandler != null)
 363             {
 364                 _languageChangedEventHandler(this, e);
 365             }
 366         }
 367
 368         internal AppSignalType LanguageChangedSignal()
 369         {
 370             AppSignalType ret = new AppSignalType(NDalicManualPINVOKE.WidgetApplication_LanguageChangedSignal(swigCPtr), false);
 371             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 372             return ret;
 373         }
 374
 375         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 376         private delegate void RegionChangedCallbackType(IntPtr widgetApplication);
 377         private RegionChangedCallbackType _regionChangedCallback;
 378         private DaliEventHandler<object, WidgetApplicationEventArgs> _regionChangedEventHandler;
 379
 380         /// <summary>
 381         /// RegionChanged event.
 382         /// </summary>
 383         public event DaliEventHandler<object, WidgetApplicationEventArgs> RegionChanged
 384         {
 385             add
 386             {
 387                 if (_regionChangedEventHandler == null)
 388                 {
 389                     _regionChangedCallback = new RegionChangedCallbackType( OnRegionChanged );
 390                     RegionChangedSignal().Connect(_regionChangedCallback);
 391                 }
 392
 393                 _regionChangedEventHandler += value;
 394             }
 395
 396             remove
 397             {
 398                 _regionChangedEventHandler -= value;
 399
 400                 if (_regionChangedEventHandler == null && RegionChangedSignal().Empty() == false)
 401                 {
 402                    RegionChangedSignal().Disconnect(_regionChangedCallback);
 403                 }
 404             }
 405         }
 406
 407         private void OnRegionChanged(IntPtr widgetApplication)
 408         {
 409             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 410
 411             if (widgetApplication != null)
 412             {
 413                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 414             }
 415
 416             if (_regionChangedEventHandler != null)
 417             {
 418                 _regionChangedEventHandler(this, e);
 419             }
 420         }
 421
 422         internal AppSignalType RegionChangedSignal()
 423         {
 424             AppSignalType ret = new AppSignalType(NDalicManualPINVOKE.WidgetApplication_RegionChangedSignal(swigCPtr), false);
 425             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 426             return ret;
 427         }
 428
 429         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 430         private delegate void BatteryLowCallbackType(IntPtr widgetApplication);
 431         private BatteryLowCallbackType _batteryLowCallback;
 432         private DaliEventHandler<object, WidgetApplicationEventArgs> _batteryLowEventHandler;
 433
 434         /// <summary>
 435         /// BatteryLow event.
 436         /// </summary>
 437         public event DaliEventHandler<object, WidgetApplicationEventArgs> BatteryLow
 438         {
 439             add
 440             {
 441                 if (_batteryLowEventHandler == null)
 442                 {
 443                     _batteryLowCallback = new BatteryLowCallbackType( OnBatteryLow );
 444                     BatteryLowSignal().Connect(_batteryLowCallback);
 445                 }
 446
 447                 _batteryLowEventHandler += value;
 448             }
 449
 450             remove
 451             {
 452                 _batteryLowEventHandler -= value;
 453
 454                 if (_batteryLowEventHandler == null && BatteryLowSignal().Empty() == false)
 455                 {
 456                    BatteryLowSignal().Disconnect(_batteryLowCallback);
 457                 }
 458             }
 459         }
 460
 461         private void OnBatteryLow(IntPtr widgetApplication)
 462         {
 463             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 464
 465             if (widgetApplication != null)
 466             {
 467                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 468             }
 469
 470             if (_batteryLowEventHandler != null)
 471             {
 472                 _batteryLowEventHandler(this, e);
 473             }
 474         }
 475
 476         internal WidgetApplicationLowBatterySignalType BatteryLowSignal()
 477         {
 478             WidgetApplicationLowBatterySignalType ret = new WidgetApplicationLowBatterySignalType(NDalicManualPINVOKE.WidgetApplication_LowBatterySignal(swigCPtr), false);
 479             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 480             return ret;
 481         }
 482
 483         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 484         private delegate void MemoryLowCallbackType(IntPtr widgetApplication);
 485         private MemoryLowCallbackType _memoryLowCallback;
 486         private DaliEventHandler<object, WidgetApplicationEventArgs> _memoryLowEventHandler;
 487
 488         /// <summary>
 489         /// MemoryLow event.
 490         /// </summary>
 491         public event DaliEventHandler<object, WidgetApplicationEventArgs> MemoryLow
 492         {
 493             add
 494             {
 495                 if (_memoryLowEventHandler == null)
 496                 {
 497                     _memoryLowCallback = new MemoryLowCallbackType (OnMemoryLow);
 498                     MemoryLowSignal().Connect(_memoryLowCallback);
 499                 }
 500
 501                 _memoryLowEventHandler += value;
 502             }
 503
 504             remove
 505             {
 506                 _memoryLowEventHandler -= value;
 507
 508                 if (_memoryLowEventHandler == null && MemoryLowSignal().Empty() == false)
 509                 {
 510                    MemoryLowSignal().Disconnect(_memoryLowCallback);
 511                 }
 512             }
 513         }
 514
 515         private void OnMemoryLow(IntPtr widgetApplication)
 516         {
 517             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 518
 519             if (widgetApplication != null)
 520             {
 521                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 522             }
 523
 524             if (_memoryLowEventHandler != null)
 525             {
 526                 _memoryLowEventHandler(this, e);
 527             }
 528         }
 529
 530         internal WidgetApplicationLowMemorySignalType MemoryLowSignal()
 531         {
 532             WidgetApplicationLowMemorySignalType ret = new WidgetApplicationLowMemorySignalType(NDalicManualPINVOKE.WidgetApplication_LowMemorySignal(swigCPtr), false);
 533             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 534             return ret;
 535         }
 536
 537         private static WidgetApplication _instance; //singleton
 538
 539     }
 540
 541 }