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