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         /// <since_tizen> 4 </since_tizen>
 203         public class WidgetApplicationEventArgs : EventArgs
 204         {
 205             /// <summary>
 206             /// Widget application.
 207             /// </summary>
 208             /// <since_tizen> 4 </since_tizen>
 209             public WidgetApplication WidgetApplication
 210             {
 211                 get;
 212                 set;
 213             }
 214         }
 215
 216         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 217         private delegate void InitCallbackType(IntPtr widgetApplication);
 218         private InitCallbackType _initCallback;
 219         private DaliEventHandler<object,WidgetApplicationEventArgs> _initEventHandler;
 220
 221         /// <summary>
 222         /// Init event.
 223         /// </summary>
 224         public event DaliEventHandler<object, WidgetApplicationEventArgs> Init
 225         {
 226             add
 227             {
 228                 if (_initEventHandler == null)
 229                 {
 230                     _initCallback = new InitCallbackType( OnInit);
 231                     InitSignal().Connect(_initCallback);
 232                 }
 233
 234                 _initEventHandler += value;
 235             }
 236
 237             remove
 238             {
 239                 _initEventHandler -= value;
 240
 241                 if (_initEventHandler == null && InitSignal().Empty() == false)
 242                 {
 243                    InitSignal().Disconnect(_initCallback);
 244                 }
 245             }
 246         }
 247
 248         private void OnInit(IntPtr widgetApplication)
 249         {
 250             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 251             if (widgetApplication != null)
 252             {
 253                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 254             }
 255
 256             if (_initEventHandler != null)
 257             {
 258                 _initEventHandler(this, e);
 259             }
 260         }
 261
 262         internal AppSignalType InitSignal()
 263         {
 264             AppSignalType ret = new AppSignalType(NDalicManualPINVOKE.WidgetApplication_InitSignal(swigCPtr), false);
 265             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 266             return ret;
 267         }
 268
 269         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 270         private delegate void TerminateCallbackType(IntPtr widgetApplication);
 271         private TerminateCallbackType _terminateCallback;
 272         private DaliEventHandler<object, WidgetApplicationEventArgs> _terminateEventHandler;
 273
 274         /// <summary>
 275         /// Terminate event.
 276         /// </summary>
 277         public event DaliEventHandler<object, WidgetApplicationEventArgs> Terminate
 278         {
 279             add
 280             {
 281                 if (_terminateEventHandler == null)
 282                 {
 283                     _terminateCallback = new TerminateCallbackType( OnTerminate);
 284                     TerminateSignal().Connect(_terminateCallback);
 285                 }
 286
 287                 _terminateEventHandler += value;
 288             }
 289
 290             remove
 291             {
 292                 _terminateEventHandler -= value;
 293
 294                 if (_terminateEventHandler == null && TerminateSignal().Empty() == false)
 295                 {
 296                    TerminateSignal().Disconnect(_terminateCallback);
 297                 }
 298             }
 299         }
 300
 301         private void OnTerminate(IntPtr widgetApplication)
 302         {
 303             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 304
 305             if (widgetApplication != null)
 306             {
 307                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 308             }
 309
 310             if (_terminateEventHandler != null)
 311             {
 312                 _terminateEventHandler(this, e);
 313             }
 314         }
 315
 316         internal AppSignalType TerminateSignal()
 317         {
 318             AppSignalType ret = new AppSignalType(NDalicManualPINVOKE.WidgetApplication_TerminateSignal(swigCPtr), false);
 319             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 320             return ret;
 321         }
 322
 323         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 324         private delegate void LanguageChangedCallbackType(IntPtr widgetApplication);
 325         private LanguageChangedCallbackType _languageChangedCallback;
 326         private DaliEventHandler<object, WidgetApplicationEventArgs> _languageChangedEventHandler;
 327
 328         /// <summary>
 329         /// LanguageChanged event.
 330         /// </summary>
 331         public event DaliEventHandler<object, WidgetApplicationEventArgs> LanguageChanged
 332         {
 333             add
 334             {
 335                 if (_languageChangedEventHandler == null)
 336                 {
 337                     _languageChangedCallback = new LanguageChangedCallbackType( OnLanguageChanged);
 338                     LanguageChangedSignal().Connect(_languageChangedCallback);
 339                 }
 340
 341                 _languageChangedEventHandler += value;
 342             }
 343
 344             remove
 345             {
 346                 _languageChangedEventHandler -= value;
 347
 348                 if (_languageChangedEventHandler == null && LanguageChangedSignal().Empty() == false)
 349                 {
 350                    LanguageChangedSignal().Disconnect(_languageChangedCallback);
 351                 }
 352             }
 353         }
 354
 355         private void OnLanguageChanged(IntPtr widgetApplication)
 356         {
 357             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 358
 359             if (widgetApplication != null)
 360             {
 361                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 362             }
 363
 364             if (_languageChangedEventHandler != null)
 365             {
 366                 _languageChangedEventHandler(this, e);
 367             }
 368         }
 369
 370         internal AppSignalType LanguageChangedSignal()
 371         {
 372             AppSignalType ret = new AppSignalType(NDalicManualPINVOKE.WidgetApplication_LanguageChangedSignal(swigCPtr), false);
 373             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 374             return ret;
 375         }
 376
 377         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 378         private delegate void RegionChangedCallbackType(IntPtr widgetApplication);
 379         private RegionChangedCallbackType _regionChangedCallback;
 380         private DaliEventHandler<object, WidgetApplicationEventArgs> _regionChangedEventHandler;
 381
 382         /// <summary>
 383         /// RegionChanged event.
 384         /// </summary>
 385         public event DaliEventHandler<object, WidgetApplicationEventArgs> RegionChanged
 386         {
 387             add
 388             {
 389                 if (_regionChangedEventHandler == null)
 390                 {
 391                     _regionChangedCallback = new RegionChangedCallbackType( OnRegionChanged );
 392                     RegionChangedSignal().Connect(_regionChangedCallback);
 393                 }
 394
 395                 _regionChangedEventHandler += value;
 396             }
 397
 398             remove
 399             {
 400                 _regionChangedEventHandler -= value;
 401
 402                 if (_regionChangedEventHandler == null && RegionChangedSignal().Empty() == false)
 403                 {
 404                    RegionChangedSignal().Disconnect(_regionChangedCallback);
 405                 }
 406             }
 407         }
 408
 409         private void OnRegionChanged(IntPtr widgetApplication)
 410         {
 411             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 412
 413             if (widgetApplication != null)
 414             {
 415                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 416             }
 417
 418             if (_regionChangedEventHandler != null)
 419             {
 420                 _regionChangedEventHandler(this, e);
 421             }
 422         }
 423
 424         internal AppSignalType RegionChangedSignal()
 425         {
 426             AppSignalType ret = new AppSignalType(NDalicManualPINVOKE.WidgetApplication_RegionChangedSignal(swigCPtr), false);
 427             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 428             return ret;
 429         }
 430
 431         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 432         private delegate void BatteryLowCallbackType(IntPtr widgetApplication);
 433         private BatteryLowCallbackType _batteryLowCallback;
 434         private DaliEventHandler<object, WidgetApplicationEventArgs> _batteryLowEventHandler;
 435
 436         /// <summary>
 437         /// BatteryLow event.
 438         /// </summary>
 439         public event DaliEventHandler<object, WidgetApplicationEventArgs> BatteryLow
 440         {
 441             add
 442             {
 443                 if (_batteryLowEventHandler == null)
 444                 {
 445                     _batteryLowCallback = new BatteryLowCallbackType( OnBatteryLow );
 446                     BatteryLowSignal().Connect(_batteryLowCallback);
 447                 }
 448
 449                 _batteryLowEventHandler += value;
 450             }
 451
 452             remove
 453             {
 454                 _batteryLowEventHandler -= value;
 455
 456                 if (_batteryLowEventHandler == null && BatteryLowSignal().Empty() == false)
 457                 {
 458                    BatteryLowSignal().Disconnect(_batteryLowCallback);
 459                 }
 460             }
 461         }
 462
 463         private void OnBatteryLow(IntPtr widgetApplication)
 464         {
 465             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 466
 467             if (widgetApplication != null)
 468             {
 469                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 470             }
 471
 472             if (_batteryLowEventHandler != null)
 473             {
 474                 _batteryLowEventHandler(this, e);
 475             }
 476         }
 477
 478         internal WidgetApplicationLowBatterySignalType BatteryLowSignal()
 479         {
 480             WidgetApplicationLowBatterySignalType ret = new WidgetApplicationLowBatterySignalType(NDalicManualPINVOKE.WidgetApplication_LowBatterySignal(swigCPtr), false);
 481             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 482             return ret;
 483         }
 484
 485         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 486         private delegate void MemoryLowCallbackType(IntPtr widgetApplication);
 487         private MemoryLowCallbackType _memoryLowCallback;
 488         private DaliEventHandler<object, WidgetApplicationEventArgs> _memoryLowEventHandler;
 489
 490         /// <summary>
 491         /// MemoryLow event.
 492         /// </summary>
 493         public event DaliEventHandler<object, WidgetApplicationEventArgs> MemoryLow
 494         {
 495             add
 496             {
 497                 if (_memoryLowEventHandler == null)
 498                 {
 499                     _memoryLowCallback = new MemoryLowCallbackType (OnMemoryLow);
 500                     MemoryLowSignal().Connect(_memoryLowCallback);
 501                 }
 502
 503                 _memoryLowEventHandler += value;
 504             }
 505
 506             remove
 507             {
 508                 _memoryLowEventHandler -= value;
 509
 510                 if (_memoryLowEventHandler == null && MemoryLowSignal().Empty() == false)
 511                 {
 512                    MemoryLowSignal().Disconnect(_memoryLowCallback);
 513                 }
 514             }
 515         }
 516
 517         private void OnMemoryLow(IntPtr widgetApplication)
 518         {
 519             WidgetApplicationEventArgs e = new WidgetApplicationEventArgs();
 520
 521             if (widgetApplication != null)
 522             {
 523                 e.WidgetApplication = WidgetApplication.GetWidgetApplicationFromPtr(widgetApplication);
 524             }
 525
 526             if (_memoryLowEventHandler != null)
 527             {
 528                 _memoryLowEventHandler(this, e);
 529             }
 530         }
 531
 532         internal WidgetApplicationLowMemorySignalType MemoryLowSignal()
 533         {
 534             WidgetApplicationLowMemorySignalType ret = new WidgetApplicationLowMemorySignalType(NDalicManualPINVOKE.WidgetApplication_LowMemorySignal(swigCPtr), false);
 535             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 536             return ret;
 537         }
 538
 539         private static WidgetApplication _instance; //singleton
 540
 541     }
 542
 543 }