src/Tizen.NUI/src/public/Gesture.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
  17 namespace Tizen.NUI
  18 {
  19
  20     /// <summary>
  21     /// Base structure for different gestures that an application can receive.<br>
  22     /// A Gesture is an event that is produced from a combination of several touch events
  23     /// in a particular order or within a certain time frame (for example, pinch).<br>
  24     /// </summary>
  25     public class Gesture : global::System.IDisposable
  26     {
  27         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  28         protected bool swigCMemOwn;
  29
  30         internal Gesture(global::System.IntPtr cPtr, bool cMemoryOwn)
  31         {
  32             swigCMemOwn = cMemoryOwn;
  33             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  34         }
  35
  36         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Gesture obj)
  37         {
  38             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  39         }
  40
  41         //A Flag to check who called Dispose(). (By User or DisposeQueue)
  42         private bool isDisposeQueued = false;
  43         //A Flat to check if it is already disposed.
  44         protected bool disposed = false;
  45
  46         ~Gesture()
  47         {
  48             if(!isDisposeQueued)
  49             {
  50                 isDisposeQueued = true;
  51                 DisposeQueue.Instance.Add(this);
  52             }
  53         }
  54
  55         public void Dispose()
  56         {
  57             //Throw excpetion if Dispose() is called in separate thread.
  58             if (!Window.IsInstalled())
  59             {
  60                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
  61             }
  62
  63             if (isDisposeQueued)
  64             {
  65                 Dispose(DisposeTypes.Implicit);
  66             }
  67             else
  68             {
  69                 Dispose(DisposeTypes.Explicit);
  70                 System.GC.SuppressFinalize(this);
  71             }
  72         }
  73
  74         protected virtual void Dispose(DisposeTypes type)
  75         {
  76             if (disposed)
  77             {
  78                 return;
  79             }
  80
  81             if(type == DisposeTypes.Explicit)
  82             {
  83                 //Called by User
  84                 //Release your own managed resources here.
  85                 //You should release all of your own disposable objects here.
  86             }
  87
  88             //Release your own unmanaged resources here.
  89             //You should not access any managed member here except static instance.
  90             //because the execution order of Finalizes is non-deterministic.
  91
  92             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  93             {
  94                 if (swigCMemOwn)
  95                 {
  96                     swigCMemOwn = false;
  97                     NDalicPINVOKE.delete_Gesture(swigCPtr);
  98                 }
  99                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 100             }
 101             disposed = true;
 102         }
 103
 104
 105         /// <summary>
 106         /// The gesture type.
 107         /// </summary>
 108         public Gesture.GestureType Type
 109         {
 110             get
 111             {
 112                 return type;
 113             }
 114         }
 115
 116         /// <summary>
 117         /// The gesture state.
 118         /// </summary>
 119         public Gesture.StateType State
 120         {
 121             get
 122             {
 123                 return state;
 124             }
 125         }
 126
 127         /// <summary>
 128         /// The time the gesture took place.
 129         /// </summary>
 130         public uint Time
 131         {
 132             get
 133             {
 134                 return time;
 135             }
 136         }
 137
 138         /// <summary>
 139         /// The Copy constructor.
 140         /// </summary>
 141         /// <param name="rhs">A reference to the copied handle</param>
 142         public Gesture(Gesture rhs) : this(NDalicPINVOKE.new_Gesture(Gesture.getCPtr(rhs)), true)
 143         {
 144             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 145         }
 146
 147         private Gesture.GestureType type
 148         {
 149             set
 150             {
 151                 NDalicPINVOKE.Gesture_type_set(swigCPtr, (int)value);
 152                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 153             }
 154             get
 155             {
 156                 Gesture.GestureType ret = (Gesture.GestureType)NDalicPINVOKE.Gesture_type_get(swigCPtr);
 157                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 158                 return ret;
 159             }
 160         }
 161
 162         private Gesture.StateType state
 163         {
 164             set
 165             {
 166                 NDalicPINVOKE.Gesture_state_set(swigCPtr, (int)value);
 167                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 168             }
 169             get
 170             {
 171                 Gesture.StateType ret = (Gesture.StateType)NDalicPINVOKE.Gesture_state_get(swigCPtr);
 172                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 173                 return ret;
 174             }
 175         }
 176
 177         private uint time
 178         {
 179             set
 180             {
 181                 NDalicPINVOKE.Gesture_time_set(swigCPtr, value);
 182                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 183             }
 184             get
 185             {
 186                 uint ret = NDalicPINVOKE.Gesture_time_get(swigCPtr);
 187                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 188                 return ret;
 189             }
 190         }
 191
 192         /// <summary>
 193         /// Enumeration for type of gesture.
 194         /// </summary>
 195         public enum GestureType
 196         {
 197             Pinch = 1 << 0,
 198             Pan = 1 << 1,
 199             Tap = 1 << 2,
 200             LongPress = 1 << 3
 201         }
 202
 203         /// <summary>
 204         /// Enumeration for state of the gesture.
 205         /// </summary>
 206         public enum StateType
 207         {
 208             Clear,
 209             Started,
 210             Continuing,
 211             Finished,
 212             Cancelled,
 213             Possible
 214         }
 215
 216     }
 217
 218 }