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