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