src/Tizen.NUI/src/public/Position2D.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     /// <summary>
  22     /// Position2D is a two-dimensional vector.
  23     /// </summary>
  24     /// <since_tizen> 3 </since_tizen>
  25     public class Position2D : global::System.IDisposable
  26     {
  27         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  28         /// <summary>
  29         /// swigCMemOwn
  30         /// </summary>
  31         /// <since_tizen> 3 </since_tizen>
  32         protected bool swigCMemOwn;
  33
  34         internal Position2D(global::System.IntPtr cPtr, bool cMemoryOwn)
  35         {
  36             swigCMemOwn = cMemoryOwn;
  37             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  38         }
  39
  40         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Position2D obj)
  41         {
  42             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  43         }
  44
  45         //A Flag to check who called Dispose(). (By User or DisposeQueue)
  46         private bool isDisposeQueued = false;
  47         /// <summary>
  48         /// A Flat to check if it is already disposed.
  49         /// </summary>
  50         /// <since_tizen> 3 </since_tizen>
  51         protected bool disposed = false;
  52
  53         /// <summary>
  54         /// Dispose.
  55         /// </summary>
  56         /// <since_tizen> 3 </since_tizen>
  57         ~Position2D()
  58         {
  59             if (!isDisposeQueued)
  60             {
  61                 isDisposeQueued = true;
  62                 DisposeQueue.Instance.Add(this);
  63             }
  64         }
  65
  66         /// <summary>
  67         /// Dispose.
  68         /// </summary>
  69         /// <since_tizen> 3 </since_tizen>
  70         public void Dispose()
  71         {
  72             //Throw excpetion if Dispose() is called in separate thread.
  73             if (!Window.IsInstalled())
  74             {
  75                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
  76             }
  77
  78             if (isDisposeQueued)
  79             {
  80                 Dispose(DisposeTypes.Implicit);
  81             }
  82             else
  83             {
  84                 Dispose(DisposeTypes.Explicit);
  85                 System.GC.SuppressFinalize(this);
  86             }
  87         }
  88
  89         /// <summary>
  90         /// Dispose.
  91         /// </summary>
  92         /// <param name="type">The dispose type.</param>
  93         /// <since_tizen> 3 </since_tizen>
  94         protected virtual void Dispose(DisposeTypes type)
  95         {
  96             if (disposed)
  97             {
  98                 return;
  99             }
 100
 101             if (type == DisposeTypes.Explicit)
 102             {
 103                 //Called by User
 104                 //Release your own managed resources here.
 105                 //You should release all of your own disposable objects here.
 106             }
 107
 108             //Release your own unmanaged resources here.
 109             //You should not access any managed member here except static instance.
 110             //because the execution order of Finalizes is non-deterministic.
 111
 112             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 113             {
 114                 if (swigCMemOwn)
 115                 {
 116                     swigCMemOwn = false;
 117                     NDalicPINVOKE.delete_Vector2(swigCPtr);
 118                 }
 119                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 120             }
 121             disposed = true;
 122         }
 123
 124         /// <summary>
 125         /// The addition operator.
 126         /// </summary>
 127         /// <param name="arg1">The vector to add.</param>
 128         /// <param name="arg2">The vector to add.</param>
 129         /// <returns>The vector containing the result of the addition.</returns>
 130         /// <since_tizen> 3 </since_tizen>
 131         public static Position2D operator +(Position2D arg1, Position2D arg2)
 132         {
 133             return arg1.Add(arg2);
 134         }
 135
 136         /// <summary>
 137         /// The subtraction operator.
 138         /// </summary>
 139         /// <param name="arg1">The vector to subtract.</param>
 140         /// <param name="arg2">The vector to subtract.</param>
 141         /// <returns>The vector containing the result of the subtraction.</returns>
 142         /// <since_tizen> 3 </since_tizen>
 143         public static Position2D operator -(Position2D arg1, Position2D arg2)
 144         {
 145             return arg1.Subtract(arg2);
 146         }
 147
 148         /// <summary>
 149         /// The unary negation operator.
 150         /// </summary>
 151         /// <param name="arg1">The vector to negate.</param>
 152         /// <returns>The vector containing the negation.</returns>
 153         /// <since_tizen> 3 </since_tizen>
 154         public static Position2D operator -(Position2D arg1)
 155         {
 156             return arg1.Subtract();
 157         }
 158
 159         /// <summary>
 160         /// The multiplication operator.
 161         /// </summary>
 162         /// <param name="arg1">The vector to multiply.</param>
 163         /// <param name="arg2">The vector to multiply.</param>
 164         /// <returns>The vector containing the result of the multiplication.</returns>
 165         /// <since_tizen> 3 </since_tizen>
 166         public static Position2D operator *(Position2D arg1, Position2D arg2)
 167         {
 168             return arg1.Multiply(arg2);
 169         }
 170
 171         /// <summary>
 172         /// The multiplication operator.
 173         /// </summary>
 174         /// <param name="arg1">The vector to multiply.</param>
 175         /// <param name="arg2">The integer value to scale the vector.</param>
 176         /// <returns>The vector containing the result of the multiplication.</returns>
 177         /// <since_tizen> 3 </since_tizen>
 178         public static Position2D operator *(Position2D arg1, int arg2)
 179         {
 180             return arg1.Multiply(arg2);
 181         }
 182
 183         /// <summary>
 184         /// The division operator.
 185         /// </summary>
 186         /// <param name="arg1">The vector to divide.</param>
 187         /// <param name="arg2">The vector to divide.</param>
 188         /// <returns>The vector containing the result of the division.</returns>
 189         /// <since_tizen> 3 </since_tizen>
 190         public static Position2D operator /(Position2D arg1, Position2D arg2)
 191         {
 192             return arg1.Divide(arg2);
 193         }
 194
 195         /// <summary>
 196         /// The division operator.
 197         /// </summary>
 198         /// <param name="arg1">The vector to divide.</param>
 199         /// <param name="arg2">The integer value to scale the vector by.</param>
 200         /// <returns>The vector containing the result of the division.</returns>
 201         /// <since_tizen> 3 </since_tizen>
 202         public static Position2D operator /(Position2D arg1, int arg2)
 203         {
 204             return arg1.Divide(arg2);
 205         }
 206
 207         /// <summary>
 208         /// The const array subscript operator overload. Should be 0, or 1.
 209         /// </summary>
 210         /// <param name="index">The subscript index.</param>
 211         /// <returns>The float at the given index.</returns>
 212         /// <since_tizen> 3 </since_tizen>
 213         public float this[uint index]
 214         {
 215             get
 216             {
 217                 return ValueOfIndex(index);
 218             }
 219         }
 220
 221         internal static Position2D GetPosition2DFromPtr(global::System.IntPtr cPtr)
 222         {
 223             Position2D ret = new Position2D(cPtr, false);
 224             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 225             return ret;
 226         }
 227
 228         /// <summary>
 229         /// The constructor.
 230         /// </summary>
 231         /// <since_tizen> 3 </since_tizen>
 232         public Position2D() : this(NDalicPINVOKE.new_Vector2__SWIG_0(), true)
 233         {
 234             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 235         }
 236
 237         /// <summary>
 238         /// The constructor.
 239         /// </summary>
 240         /// <param name="x">x component</param>
 241         /// <param name="y">y component</param>
 242         /// <since_tizen> 3 </since_tizen>
 243         public Position2D(int x, int y) : this(NDalicPINVOKE.new_Vector2__SWIG_1((float)x, (float)y), true)
 244         {
 245             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 246         }
 247
 248         /// <summary>
 249         /// The constructor.
 250         /// </summary>
 251         /// <param name="position">Position to create this vector from</param>
 252         /// <since_tizen> 3 </since_tizen>
 253         public Position2D(Position position) : this(NDalicPINVOKE.new_Vector2__SWIG_3(Position.getCPtr(position)), true)
 254         {
 255             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 256         }
 257
 258         private Position2D Add(Position2D rhs)
 259         {
 260             Position2D ret = new Position2D(NDalicPINVOKE.Vector2_Add(swigCPtr, Position2D.getCPtr(rhs)), true);
 261             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 262             return ret;
 263         }
 264
 265         private Position2D Subtract(Position2D rhs)
 266         {
 267             Position2D ret = new Position2D(NDalicPINVOKE.Vector2_Subtract__SWIG_0(swigCPtr, Position2D.getCPtr(rhs)), true);
 268             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 269             return ret;
 270         }
 271
 272
 273         private Position2D Multiply(Position2D rhs)
 274         {
 275             Position2D ret = new Position2D(NDalicPINVOKE.Vector2_Multiply__SWIG_0(swigCPtr, Position2D.getCPtr(rhs)), true);
 276             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 277             return ret;
 278         }
 279
 280         private Position2D Multiply(int rhs)
 281         {
 282             Position2D ret = new Position2D(NDalicPINVOKE.Vector2_Multiply__SWIG_1(swigCPtr, (float)rhs), true);
 283             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 284             return ret;
 285         }
 286
 287
 288         private Position2D Divide(Position2D rhs)
 289         {
 290             Position2D ret = new Position2D(NDalicPINVOKE.Vector2_Divide__SWIG_0(swigCPtr, Position2D.getCPtr(rhs)), true);
 291             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 292             return ret;
 293         }
 294
 295         private Position2D Divide(int rhs)
 296         {
 297             Position2D ret = new Position2D(NDalicPINVOKE.Vector2_Divide__SWIG_1(swigCPtr, (float)rhs), true);
 298             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 299             return ret;
 300         }
 301
 302         private Position2D Subtract()
 303         {
 304             Position2D ret = new Position2D(NDalicPINVOKE.Vector2_Subtract__SWIG_1(swigCPtr), true);
 305             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 306             return ret;
 307         }
 308
 309         /// <summary>
 310         /// Compares if the rhs is equal to.
 311         /// </summary>
 312         /// <param name="rhs">The vector to compare</param>
 313         /// <returns>Returns true if the two vectors are equal, otherwise false</returns>
 314         /// <since_tizen> 3 </since_tizen>
 315         public bool EqualTo(Position2D rhs)
 316         {
 317             bool ret = NDalicPINVOKE.Vector2_EqualTo(swigCPtr, Position2D.getCPtr(rhs));
 318             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 319             return ret;
 320         }
 321
 322         /// <summary>
 323         /// Compares if the rhs is not equal to.
 324         /// </summary>
 325         /// <param name="rhs">The vector to compare.</param>
 326         /// <returns>Returns true if the two vectors are not equal, otherwise false.</returns>
 327         /// <since_tizen> 3 </since_tizen>
 328         public bool NotEqualTo(Position2D rhs)
 329         {
 330             bool ret = NDalicPINVOKE.Vector2_NotEqualTo(swigCPtr, Position2D.getCPtr(rhs));
 331             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 332             return ret;
 333         }
 334
 335         private int ValueOfIndex(uint index)
 336         {
 337             int ret = (int)NDalicPINVOKE.Vector2_ValueOfIndex__SWIG_0(swigCPtr, index);
 338             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 339             return ret;
 340         }
 341
 342         /// <summary>
 343         /// The x component.
 344         /// </summary>
 345         /// <since_tizen> 3 </since_tizen>
 346         public int X
 347         {
 348             set
 349             {
 350                 NDalicPINVOKE.Vector2_X_set(swigCPtr, (float)value);
 351                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 352             }
 353             get
 354             {
 355                 float ret = NDalicPINVOKE.Vector2_X_get(swigCPtr);
 356                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 357                 return (int)ret;
 358             }
 359         }
 360
 361         /// <summary>
 362         /// The y component.
 363         /// </summary>
 364         /// <since_tizen> 3 </since_tizen>
 365         public int Y
 366         {
 367             set
 368             {
 369                 NDalicPINVOKE.Vector2_Y_set(swigCPtr, (float)value);
 370                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 371             }
 372             get
 373             {
 374                 float ret = NDalicPINVOKE.Vector2_Y_get(swigCPtr);
 375                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 376                 return (int)ret;
 377             }
 378         }
 379
 380         /// <summary>
 381         /// Converts a Position2D instance to a Vector2 instance.
 382         /// </summary>
 383         /// <param name="position2d">An object of the Position2D type.</param>
 384         /// <returns>return an object of the Vector2 type</returns>
 385         /// <since_tizen> 3 </since_tizen>
 386         public static implicit operator Vector2(Position2D position2d)
 387         {
 388             return new Vector2((float)position2d.X, (float)position2d.Y);
 389         }
 390
 391         /// <summary>
 392         /// Converts a Vector2 instance to a Position2D instance.
 393         /// </summary>
 394         /// <param name="vec">An object of the Vector2 type.</param>
 395         /// <returns>return an object of the Position2D type</returns>
 396         /// <since_tizen> 3 </since_tizen>
 397         public static implicit operator Position2D(Vector2 vec)
 398         {
 399             return new Position2D((int)vec.X, (int)vec.Y);
 400         }
 401
 402     }
 403
 404 }
 405