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

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