src/Tizen.NUI/src/internal/RulerPtr.cs

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