src/Tizen.NUI/src/internal/WatchApplication.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
  18 using System;
  19 using System.Runtime.InteropServices;
  20 namespace Tizen.NUI
  21 {
  22     internal class WatchApplication : Application
  23     {
  24         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  25
  26         internal WatchApplication(global::System.IntPtr cPtr, bool cMemoryOwn) : base(cPtr, cMemoryOwn)
  27         {
  28             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  29         }
  30
  31         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(WatchApplication obj)
  32         {
  33             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  34         }
  35
  36         protected override void Dispose(DisposeTypes type)
  37         {
  38             if (disposed)
  39             {
  40                 return;
  41             }
  42
  43             if (type == DisposeTypes.Explicit)
  44             {
  45                 //Called by User
  46                 //Release your own managed resources here.
  47                 //You should release all of your own disposable objects here.
  48
  49             }
  50
  51             //Release your own unmanaged resources here.
  52             //You should not access any managed member here except static instance.
  53             //because the execution order of Finalizes is non-deterministic.
  54             DisConnectFromSignals();
  55
  56             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  57             {
  58                 if (swigCMemOwn)
  59                 {
  60                     swigCMemOwn = false;
  61                     Interop.Watch.delete_WatchApplication(swigCPtr);
  62                 }
  63                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  64             }
  65
  66             base.Dispose(type);
  67         }
  68
  69         private void DisConnectFromSignals()
  70         {
  71             if (_timeTickCallback != null)
  72             {
  73                 this.TimeTickSignal().Disconnect(_timeTickCallback);
  74             }
  75             if (_ambientTickCallback != null)
  76             {
  77                 this.AmbientTickSignal().Disconnect(_ambientTickCallback);
  78             }
  79             if (_ambientChangedCallback != null)
  80             {
  81                 this.AmbientChangedSignal().Disconnect(_ambientChangedCallback);
  82             }
  83         }
  84
  85         public new static WatchApplication Instance
  86         {
  87             get
  88             {
  89                 return _instance;
  90             }
  91         }
  92
  93         public static WatchApplication NewWatchApplication()
  94         {
  95             WatchApplication ret = New();
  96             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  97             // we've got an application now connect the signals
  98             _instance = ret;
  99             return ret;
 100         }
 101
 102         public static WatchApplication NewWatchApplication(string[] args)
 103         {
 104             WatchApplication ret = New(args);
 105             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 106             _instance = ret;
 107             return ret;
 108         }
 109
 110         public static WatchApplication NewWatchApplication(string[] args, string stylesheet)
 111         {
 112             WatchApplication ret = New(args, stylesheet);
 113             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 114             _instance = ret;
 115             return ret;
 116         }
 117
 118         public new static WatchApplication New()
 119         {
 120             WatchApplication ret = new WatchApplication(Interop.Watch.WatchApplication_New__SWIG_0(), true);
 121             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 122             return ret;
 123         }
 124
 125         public static WatchApplication New(string[] args)
 126         {
 127             int argc = args.Length;
 128             string argvStr = string.Join(" ", args);
 129
 130             WatchApplication ret = new WatchApplication(Interop.Watch.WatchApplication_New__SWIG_1(argc, argvStr), true);
 131             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 132             return ret;
 133         }
 134
 135         public static WatchApplication New(string[] args, string stylesheet)
 136         {
 137             int argc = args.Length;
 138             string argvStr = string.Join(" ", args);
 139
 140             WatchApplication ret = new WatchApplication(Interop.Watch.WatchApplication_New__SWIG_2(argc, argvStr, stylesheet), true);
 141             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 142             return ret;
 143         }
 144
 145         internal WatchApplication(WatchApplication implementation) : this(Interop.Watch.new_WatchApplication__SWIG_1(WatchApplication.getCPtr(implementation)), true)
 146         {
 147             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 148         }
 149
 150         /// <summary>
 151         /// Event arguments that passed via time tick event signal.
 152         /// </summary>
 153         /// <since_tizen> 4 </since_tizen>
 154         public class TimeTickEventArgs : EventArgs
 155         {
 156             /// <summary>
 157             /// Application.
 158             /// </summary>
 159             /// <since_tizen> 4 </since_tizen>
 160             public Application Application
 161             {
 162                 get;
 163                 set;
 164             }
 165
 166             /// <summary>
 167             /// WatchTime.
 168             /// </summary>
 169             /// <since_tizen> 4 </since_tizen>
 170             public WatchTime WatchTime
 171             {
 172                 get;
 173                 set;
 174             }
 175         }
 176
 177         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 178         private delegate void TimeTickCallbackType(IntPtr application, IntPtr watchTime);
 179         private TimeTickCallbackType _timeTickCallback;
 180         private DaliEventHandler<object,TimeTickEventArgs> _timeTickEventHandler;
 181
 182         /// <summary>
 183         /// TimeTick event.
 184         /// </summary>
 185         public event DaliEventHandler<object, TimeTickEventArgs> TimeTick
 186         {
 187             add
 188             {
 189                 if (_timeTickEventHandler == null)
 190                 {
 191                     _timeTickCallback = new TimeTickCallbackType( OnTimeTick);
 192                     TimeTickSignal().Connect(_timeTickCallback);
 193                 }
 194
 195                 _timeTickEventHandler += value;
 196             }
 197
 198             remove
 199             {
 200                 _timeTickEventHandler -= value;
 201
 202                 if (_timeTickEventHandler == null && TimeTickSignal().Empty() == false)
 203                 {
 204                    TimeTickSignal().Disconnect(_timeTickCallback);
 205                 }
 206             }
 207         }
 208
 209         private void OnTimeTick(IntPtr application, IntPtr watchTime)
 210         {
 211             TimeTickEventArgs e = new TimeTickEventArgs();
 212             e.Application = this;
 213             e.WatchTime = WatchTime.GetWatchTimeFromPtr(watchTime);
 214
 215             _timeTickEventHandler?.Invoke(this, e);
 216
 217         }
 218
 219         internal WatchTimeSignal TimeTickSignal()
 220         {
 221             WatchTimeSignal ret = new WatchTimeSignal(Interop.Watch.WatchApplication_TimeTickSignal(swigCPtr), false);
 222             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 223             return ret;
 224         }
 225
 226         /// <summary>
 227         /// Event arguments that passed via ambient tick event signal.
 228         /// </summary>
 229         /// <since_tizen> 4 </since_tizen>
 230         public class AmbientTickEventArgs : EventArgs
 231         {
 232             /// <summary>
 233             /// Application.
 234             /// </summary>
 235             /// <since_tizen> 4 </since_tizen>
 236             public Application Application
 237             {
 238                 get;
 239                 set;
 240             }
 241
 242             /// <summary>
 243             /// WatchTime.
 244             /// </summary>
 245             /// <since_tizen> 4 </since_tizen>
 246             public WatchTime WatchTime
 247             {
 248                 get;
 249                 set;
 250             }
 251         }
 252
 253         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 254         private delegate void AmbientTickCallbackType(IntPtr application, IntPtr watchTime);
 255         private AmbientTickCallbackType _ambientTickCallback;
 256         private DaliEventHandler<object,AmbientTickEventArgs> _ambientTickEventHandler;
 257
 258         /// <summary>
 259         /// AmbientTick event.
 260         /// </summary>
 261         public event DaliEventHandler<object, AmbientTickEventArgs> AmbientTick
 262         {
 263             add
 264             {
 265                 if (_ambientTickEventHandler == null)
 266                 {
 267                     _ambientTickCallback = new AmbientTickCallbackType( OnAmbientTick);
 268                     AmbientTickSignal().Connect(_ambientTickCallback);
 269                 }
 270
 271                 _ambientTickEventHandler += value;
 272             }
 273
 274             remove
 275             {
 276                 _ambientTickEventHandler -= value;
 277
 278                 if (_ambientTickEventHandler == null && AmbientTickSignal().Empty() == false)
 279                 {
 280                    AmbientTickSignal().Disconnect(_ambientTickCallback);
 281                 }
 282             }
 283         }
 284
 285         private void OnAmbientTick(IntPtr application, IntPtr watchTime)
 286         {
 287             AmbientTickEventArgs e = new AmbientTickEventArgs();
 288
 289             e.Application = this;
 290             e.WatchTime = WatchTime.GetWatchTimeFromPtr(watchTime);
 291             _ambientTickEventHandler?.Invoke(this, e);
 292         }
 293
 294         internal WatchTimeSignal AmbientTickSignal()
 295         {
 296             WatchTimeSignal ret = new WatchTimeSignal(Interop.Watch.WatchApplication_AmbientTickSignal(swigCPtr), false);
 297             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 298             return ret;
 299         }
 300
 301         /// <summary>
 302         /// Event arguments that passed via ambient tick event signal.
 303         /// </summary>
 304         /// <since_tizen> 4 </since_tizen>
 305         public class AmbientChangedEventArgs : EventArgs
 306         {
 307             /// <summary>
 308             /// Application.
 309             /// </summary>
 310             /// <since_tizen> 4 </since_tizen>
 311             public Application Application
 312             {
 313                 get;
 314                 set;
 315             }
 316
 317             /// <summary>
 318             /// Changed.
 319             /// </summary>
 320             /// <since_tizen> 4 </since_tizen>
 321             public bool Changed
 322             {
 323                 get;
 324                 set;
 325             }
 326         }
 327
 328         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
 329         private delegate void AmbientChangedCallbackType(IntPtr application, bool changed);
 330         private AmbientChangedCallbackType _ambientChangedCallback;
 331         private DaliEventHandler<object,AmbientChangedEventArgs> _ambientChangedEventHandler;
 332
 333         /// <summary>
 334         /// AmbientChanged event.
 335         /// </summary>
 336         public event DaliEventHandler<object, AmbientChangedEventArgs> AmbientChanged
 337         {
 338             add
 339             {
 340                 if (_ambientChangedEventHandler == null)
 341                 {
 342                     _ambientChangedCallback = new AmbientChangedCallbackType( OnAmbientChanged);
 343                     AmbientChangedSignal().Connect(_ambientChangedCallback);
 344                 }
 345
 346                 _ambientChangedEventHandler += value;
 347             }
 348
 349             remove
 350             {
 351                 _ambientChangedEventHandler -= value;
 352
 353                 if (_ambientChangedEventHandler == null && AmbientChangedSignal().Empty() == false)
 354                 {
 355                    AmbientChangedSignal().Disconnect(_ambientChangedCallback);
 356                 }
 357             }
 358         }
 359
 360         private void OnAmbientChanged(IntPtr application, bool changed)
 361         {
 362             AmbientChangedEventArgs e = new AmbientChangedEventArgs();
 363             e.Application = this;
 364             e.Changed = changed;
 365             _ambientChangedEventHandler?.Invoke(this, e);
 366         }
 367
 368         internal WatchBoolSignal AmbientChangedSignal()
 369         {
 370             WatchBoolSignal ret = new WatchBoolSignal(Interop.Watch.WatchApplication_AmbientChangedSignal(swigCPtr), false);
 371             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 372             return ret;
 373         }
 374
 375         private static WatchApplication _instance; //singleton
 376
 377     }
 378
 379 }