src/Tizen.NUI/src/internal/RulerPtr.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 namespace Tizen.NUI
  19 {
  20
  21     internal class RulerPtr : global::System.IDisposable
  22     {
  23         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  24         protected bool swigCMemOwn;
  25
  26         internal RulerPtr(global::System.IntPtr cPtr, bool cMemoryOwn)
  27         {
  28             swigCMemOwn = cMemoryOwn;
  29             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  30         }
  31
  32         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(RulerPtr obj)
  33         {
  34             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  35         }
  36
  37         //A Flag to check who called Dispose(). (By User or DisposeQueue)
  38         private bool isDisposeQueued = false;
  39         //A Flat to check if it is already disposed.
  40         protected bool disposed = false;
  41
  42
  43         ~RulerPtr()
  44         {
  45             if (!isDisposeQueued)
  46             {
  47                 isDisposeQueued = true;
  48                 DisposeQueue.Instance.Add(this);
  49             }
  50         }
  51
  52         public void Dispose()
  53         {
  54             //Throw excpetion if Dispose() is called in separate thread.
  55             if (!Window.IsInstalled())
  56             {
  57                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
  58             }
  59
  60             if (isDisposeQueued)
  61             {
  62                 Dispose(DisposeTypes.Implicit);
  63             }
  64             else
  65             {
  66                 Dispose(DisposeTypes.Explicit);
  67                 System.GC.SuppressFinalize(this);
  68             }
  69         }
  70
  71         protected virtual void Dispose(DisposeTypes type)
  72         {
  73             if (disposed)
  74             {
  75                 return;
  76             }
  77
  78             if (type == DisposeTypes.Explicit)
  79             {
  80                 //Called by User
  81                 //Release your own managed resources here.
  82                 //You should release all of your own disposable objects here.
  83
  84             }
  85
  86             //Release your own unmanaged resources here.
  87             //You should not access any managed member here except static instance.
  88             //because the execution order of Finalizes is non-deterministic.
  89
  90             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  91             {
  92                 if (swigCMemOwn)
  93                 {
  94                     swigCMemOwn = false;
  95                     NDalicPINVOKE.delete_RulerPtr(swigCPtr);
  96                 }
  97                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  98             }
  99
 100             disposed = true;
 101         }
 102
 103
 104         public RulerPtr() : this(NDalicPINVOKE.new_RulerPtr__SWIG_0(), true)
 105         {
 106             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 107         }
 108
 109         public RulerPtr(Ruler p) : this(NDalicPINVOKE.new_RulerPtr__SWIG_1(Ruler.getCPtr(p)), true)
 110         {
 111             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 112         }
 113
 114         public RulerPtr(RulerPtr rhs) : this(NDalicPINVOKE.new_RulerPtr__SWIG_2(RulerPtr.getCPtr(rhs)), true)
 115         {
 116             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 117         }
 118
 119         public Ruler Get()
 120         {
 121             global::System.IntPtr cPtr = NDalicPINVOKE.RulerPtr_Get(swigCPtr);
 122             Ruler ret = (cPtr == global::System.IntPtr.Zero) ? null : new Ruler(cPtr, false);
 123             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 124             return ret;
 125         }
 126
 127         public Ruler __deref__()
 128         {
 129             global::System.IntPtr cPtr = NDalicPINVOKE.RulerPtr___deref__(swigCPtr);
 130             Ruler ret = (cPtr == global::System.IntPtr.Zero) ? null : new Ruler(cPtr, false);
 131             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 132             return ret;
 133         }
 134
 135         public Ruler __ref__()
 136         {
 137             Ruler ret = new Ruler(NDalicPINVOKE.RulerPtr___ref__(swigCPtr), false);
 138             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 139             return ret;
 140         }
 141
 142         public RulerPtr Assign(RulerPtr rhs)
 143         {
 144             RulerPtr ret = new RulerPtr(NDalicPINVOKE.RulerPtr_Assign__SWIG_0(swigCPtr, RulerPtr.getCPtr(rhs)), false);
 145             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 146             return ret;
 147         }
 148
 149         public RulerPtr Assign(Ruler rhs)
 150         {
 151             RulerPtr ret = new RulerPtr(NDalicPINVOKE.RulerPtr_Assign__SWIG_1(swigCPtr, Ruler.getCPtr(rhs)), false);
 152             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 153             return ret;
 154         }
 155
 156         public void Reset()
 157         {
 158             NDalicPINVOKE.RulerPtr_Reset__SWIG_0(swigCPtr);
 159             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 160         }
 161
 162         public void Reset(Ruler rhs)
 163         {
 164             NDalicPINVOKE.RulerPtr_Reset__SWIG_1(swigCPtr, Ruler.getCPtr(rhs));
 165             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 166         }
 167
 168         public Ruler Detach()
 169         {
 170             global::System.IntPtr cPtr = NDalicPINVOKE.RulerPtr_Detach(swigCPtr);
 171             Ruler ret = (cPtr == global::System.IntPtr.Zero) ? null : new Ruler(cPtr, false);
 172             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 173             return ret;
 174         }
 175
 176         public float Snap(float x, float bias)
 177         {
 178             float ret = NDalicPINVOKE.RulerPtr_Snap__SWIG_0(swigCPtr, x, bias);
 179             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 180             return ret;
 181         }
 182
 183         public float Snap(float x)
 184         {
 185             float ret = NDalicPINVOKE.RulerPtr_Snap__SWIG_1(swigCPtr, x);
 186             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 187             return ret;
 188         }
 189
 190         public float GetPositionFromPage(uint page, out uint volume, bool wrap)
 191         {
 192             float ret = NDalicPINVOKE.RulerPtr_GetPositionFromPage(swigCPtr, page, out volume, wrap);
 193             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 194             return ret;
 195         }
 196
 197         public uint GetPageFromPosition(float position, bool wrap)
 198         {
 199             uint ret = NDalicPINVOKE.RulerPtr_GetPageFromPosition(swigCPtr, position, wrap);
 200             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 201             return ret;
 202         }
 203
 204         public uint GetTotalPages()
 205         {
 206             uint ret = NDalicPINVOKE.RulerPtr_GetTotalPages(swigCPtr);
 207             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 208             return ret;
 209         }
 210
 211         public new Ruler.RulerType GetType()
 212         {
 213             Ruler.RulerType ret = (Ruler.RulerType)NDalicPINVOKE.RulerPtr_GetType(swigCPtr);
 214             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 215             return ret;
 216         }
 217
 218         public bool IsEnabled()
 219         {
 220             bool ret = NDalicPINVOKE.RulerPtr_IsEnabled(swigCPtr);
 221             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 222             return ret;
 223         }
 224
 225         public void Enable()
 226         {
 227             NDalicPINVOKE.RulerPtr_Enable(swigCPtr);
 228             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 229         }
 230
 231         public void Disable()
 232         {
 233             NDalicPINVOKE.RulerPtr_Disable(swigCPtr);
 234             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 235         }
 236
 237         public void SetDomain(RulerDomain domain)
 238         {
 239             NDalicPINVOKE.RulerPtr_SetDomain(swigCPtr, RulerDomain.getCPtr(domain));
 240             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 241         }
 242
 243         public RulerDomain GetDomain()
 244         {
 245             RulerDomain ret = new RulerDomain(NDalicPINVOKE.RulerPtr_GetDomain(swigCPtr), false);
 246             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 247             return ret;
 248         }
 249
 250         public void DisableDomain()
 251         {
 252             NDalicPINVOKE.RulerPtr_DisableDomain(swigCPtr);
 253             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 254         }
 255
 256         public float Clamp(float x, float length, float scale)
 257         {
 258             float ret = NDalicPINVOKE.RulerPtr_Clamp__SWIG_0(swigCPtr, x, length, scale);
 259             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 260             return ret;
 261         }
 262
 263         public float Clamp(float x, float length)
 264         {
 265             float ret = NDalicPINVOKE.RulerPtr_Clamp__SWIG_1(swigCPtr, x, length);
 266             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 267             return ret;
 268         }
 269
 270         public float Clamp(float x)
 271         {
 272             float ret = NDalicPINVOKE.RulerPtr_Clamp__SWIG_2(swigCPtr, x);
 273             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 274             return ret;
 275         }
 276
 277         internal float Clamp(float x, float length, float scale, SWIGTYPE_p_Dali__Toolkit__ClampState clamped)
 278         {
 279             float ret = NDalicPINVOKE.RulerPtr_Clamp__SWIG_3(swigCPtr, x, length, scale, SWIGTYPE_p_Dali__Toolkit__ClampState.getCPtr(clamped));
 280             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 281             return ret;
 282         }
 283
 284         public float SnapAndClamp(float x, float bias, float length, float scale)
 285         {
 286             float ret = NDalicPINVOKE.RulerPtr_SnapAndClamp__SWIG_0(swigCPtr, x, bias, length, scale);
 287             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 288             return ret;
 289         }
 290
 291         public float SnapAndClamp(float x, float bias, float length)
 292         {
 293             float ret = NDalicPINVOKE.RulerPtr_SnapAndClamp__SWIG_1(swigCPtr, x, bias, length);
 294             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 295             return ret;
 296         }
 297
 298         public float SnapAndClamp(float x, float bias)
 299         {
 300             float ret = NDalicPINVOKE.RulerPtr_SnapAndClamp__SWIG_2(swigCPtr, x, bias);
 301             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 302             return ret;
 303         }
 304
 305         public float SnapAndClamp(float x)
 306         {
 307             float ret = NDalicPINVOKE.RulerPtr_SnapAndClamp__SWIG_3(swigCPtr, x);
 308             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 309             return ret;
 310         }
 311
 312         internal float SnapAndClamp(float x, float bias, float length, float scale, SWIGTYPE_p_Dali__Toolkit__ClampState clamped)
 313         {
 314             float ret = NDalicPINVOKE.RulerPtr_SnapAndClamp__SWIG_4(swigCPtr, x, bias, length, scale, SWIGTYPE_p_Dali__Toolkit__ClampState.getCPtr(clamped));
 315             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 316             return ret;
 317         }
 318
 319         public void Reference()
 320         {
 321             NDalicPINVOKE.RulerPtr_Reference(swigCPtr);
 322             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 323         }
 324
 325         public void Unreference()
 326         {
 327             NDalicPINVOKE.RulerPtr_Unreference(swigCPtr);
 328             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 329         }
 330
 331         public int ReferenceCount()
 332         {
 333             int ret = NDalicPINVOKE.RulerPtr_ReferenceCount(swigCPtr);
 334             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 335             return ret;
 336         }
 337
 338     }
 339
 340 }