src/Tizen.NUI/src/public/Position.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 using System;
  19
  20 namespace Tizen.NUI
  21 {
  22
  23     /// <summary>
  24     /// Position is a three-dimensional vector.
  25     /// </summary>
  26     public class Position : global::System.IDisposable
  27     {
  28         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  29         protected bool swigCMemOwn;
  30
  31         internal Position(global::System.IntPtr cPtr, bool cMemoryOwn)
  32         {
  33             swigCMemOwn = cMemoryOwn;
  34             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  35         }
  36
  37         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Position obj)
  38         {
  39             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  40         }
  41
  42         //A Flag to check who called Dispose(). (By User or DisposeQueue)
  43         private bool isDisposeQueued = false;
  44         //A Flat to check if it is already disposed.
  45         protected bool disposed = false;
  46
  47         ~Position()
  48         {
  49             if(!isDisposeQueued)
  50             {
  51                 isDisposeQueued = true;
  52                 DisposeQueue.Instance.Add(this);
  53             }
  54         }
  55
  56         public void Dispose()
  57         {
  58             //Throw excpetion if Dispose() is called in separate thread.
  59             if (!Window.IsInstalled())
  60             {
  61                 throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
  62             }
  63
  64             if (isDisposeQueued)
  65             {
  66                 Dispose(DisposeTypes.Implicit);
  67             }
  68             else
  69             {
  70                 Dispose(DisposeTypes.Explicit);
  71                 System.GC.SuppressFinalize(this);
  72             }
  73         }
  74
  75         protected virtual void Dispose(DisposeTypes type)
  76         {
  77             if (disposed)
  78             {
  79                 return;
  80             }
  81
  82             if(type == DisposeTypes.Explicit)
  83             {
  84                 //Called by User
  85                 //Release your own managed resources here.
  86                 //You should release all of your own disposable objects here.
  87             }
  88
  89             //Release your own unmanaged resources here.
  90             //You should not access any managed member here except static instance.
  91             //because the execution order of Finalizes is non-deterministic.
  92
  93             if (swigCPtr.Handle != global::System.IntPtr.Zero)
  94             {
  95                 if (swigCMemOwn)
  96                 {
  97                     swigCMemOwn = false;
  98                     NDalicPINVOKE.delete_Vector3(swigCPtr);
  99                 }
 100                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 101             }
 102             disposed = true;
 103         }
 104
 105
 106         /// <summary>
 107         /// An addition operator.
 108         /// </summary>
 109         /// <param name="arg1">The vector to add.</param>
 110         /// <param name="arg2">The vector to add.</param>
 111         /// <returns>The vector containing the result of the addition.</returns>
 112         /// <since_tizen> 3 </since_tizen>
 113         public static Position operator +(Position arg1, Position arg2)
 114         {
 115             return arg1.Add(arg2);
 116         }
 117
 118         /// <summary>
 119         /// The subtraction operator.
 120         /// </summary>
 121         /// <param name="arg1">The vector to subtract.</param>
 122         /// <param name="arg2">The vector to subtract.</param>
 123         /// <returns>The vector containing the result of the subtraction.</returns>
 124         /// <since_tizen> 3 </since_tizen>
 125         public static Position operator -(Position arg1, Position arg2)
 126         {
 127             return arg1.Subtract(arg2);
 128         }
 129
 130         /// <summary>
 131         /// The unary negation operator.
 132         /// </summary>
 133         /// <param name="arg1">The vector to negate.</param>
 134         /// <returns>The vector containg the negation.</returns>
 135         /// <since_tizen> 3 </since_tizen>
 136         public static Position operator -(Position arg1)
 137         {
 138             return arg1.Subtract();
 139         }
 140
 141         /// <summary>
 142         /// The multiplication operator.
 143         /// </summary>
 144         /// <param name="arg1">The vector to multiply.</param>
 145         /// <param name="arg2">The vector to multiply.</param>
 146         /// <returns>The vector containing the result of the multiplication.</returns>
 147         /// <since_tizen> 3 </since_tizen>
 148         public static Position operator *(Position arg1, Position arg2)
 149         {
 150             return arg1.Multiply(arg2);
 151         }
 152
 153         /// <summary>
 154         /// The multiplication operator.
 155         /// </summary>
 156         /// <param name="arg1">The vector to multiply</param>
 157         /// <param name="arg2">The float value to scale the vector.</param>
 158         /// <returns>The vector containing the result of scaling.</returns>
 159         /// <since_tizen> 3 </since_tizen>
 160         public static Position operator *(Position arg1, float arg2)
 161         {
 162             return arg1.Multiply(arg2);
 163         }
 164
 165         /// <summary>
 166         /// The division operator.
 167         /// </summary>
 168         /// <param name="arg1">The vector to divide.</param>
 169         /// <param name="arg2">The vector to divide.</param>
 170         /// <returns>The vector containing the result of the division.</returns>
 171         /// <since_tizen> 3 </since_tizen>
 172         public static Position operator /(Position arg1, Position arg2)
 173         {
 174             return arg1.Divide(arg2);
 175         }
 176
 177         /// <summary>
 178         /// The division operator.
 179         /// </summary>
 180         /// <param name="arg1">The vector to divide.</param>
 181         /// <param name="arg2">The float value to scale the vector by.</param>
 182         /// <returns>The vector containing the result of scaling.</returns>
 183         /// <since_tizen> 3 </since_tizen>
 184         public static Position operator /(Position arg1, float arg2)
 185         {
 186             return arg1.Divide(arg2);
 187         }
 188
 189
 190         /// <summary>
 191         /// The const array subscript operator overload. Should be 0, 1, or 2.
 192         /// </summary>
 193         /// <param name="index">The subscript index.</param>
 194         /// <returns>The float at the given index.</returns>
 195         /// <since_tizen> 3 </since_tizen>
 196         public float this[uint index]
 197         {
 198             get
 199             {
 200                 return ValueOfIndex(index);
 201             }
 202         }
 203
 204         internal static Position GetPositionFromPtr(global::System.IntPtr cPtr)
 205         {
 206             Position ret = new Position(cPtr, false);
 207             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 208             return ret;
 209         }
 210
 211
 212         /// <summary>
 213         /// The constructor.
 214         /// </summary>
 215         /// <since_tizen> 3 </since_tizen>
 216         public Position() : this(NDalicPINVOKE.new_Vector3__SWIG_0(), true)
 217         {
 218             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 219         }
 220
 221         /// <summary>
 222         /// The constructor.
 223         /// </summary>
 224         /// <param name="x">The x component.</param>
 225         /// <param name="y">The y component.</param>
 226         /// <param name="z">The z component.</param>
 227         /// <since_tizen> 3 </since_tizen>
 228         public Position(float x, float y, float z) : this(NDalicPINVOKE.new_Vector3__SWIG_1(x, y, z), true)
 229         {
 230             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 231         }
 232
 233         /// <summary>
 234         /// The constructor.
 235         /// </summary>
 236         /// <param name="position2d">Position2D to create this vector from.</param>
 237         /// <since_tizen> 3 </since_tizen>
 238         public Position(Position2D position2d) : this(NDalicPINVOKE.new_Vector3__SWIG_3(Position2D.getCPtr(position2d)), true)
 239         {
 240             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 241         }
 242
 243
 244
 245         private Position Add(Position rhs)
 246         {
 247             Position ret = new Position(NDalicPINVOKE.Vector3_Add(swigCPtr, Position.getCPtr(rhs)), true);
 248             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 249             return ret;
 250         }
 251
 252         private Position Subtract(Position rhs)
 253         {
 254             Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 255             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 256             return ret;
 257         }
 258
 259         private Position Multiply(Position rhs)
 260         {
 261             Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 262             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 263             return ret;
 264         }
 265
 266         private Position Multiply(float rhs)
 267         {
 268             Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_1(swigCPtr, rhs), true);
 269             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 270             return ret;
 271         }
 272
 273         private Position Divide(Position rhs)
 274         {
 275             Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 276             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 277             return ret;
 278         }
 279
 280         private Position Divide(float rhs)
 281         {
 282             Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_1(swigCPtr, rhs), true);
 283             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 284             return ret;
 285         }
 286
 287         private Position Subtract()
 288         {
 289             Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_1(swigCPtr), true);
 290             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 291             return ret;
 292         }
 293
 294         private float ValueOfIndex(uint index)
 295         {
 296             float ret = NDalicPINVOKE.Vector3_ValueOfIndex__SWIG_0(swigCPtr, index);
 297             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 298             return ret;
 299         }
 300
 301         /// <summary>
 302         /// Compares if rhs is equal to.
 303         /// </summary>
 304         /// <param name="rhs">The vector to compare.</param>
 305         /// <returns>Returns true if the two vectors are equal, otherwise false.</returns>
 306         /// <since_tizen> 3 </since_tizen>
 307         public bool EqualTo(Position rhs)
 308         {
 309             bool ret = NDalicPINVOKE.Vector3_EqualTo(swigCPtr, Position.getCPtr(rhs));
 310             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 311             return ret;
 312         }
 313
 314         /// <summary>
 315         /// Compares if rhs is not equal to.
 316         /// </summary>
 317         /// <param name="rhs">The vector to compare.</param>
 318         /// <returns>Returns true if the two vectors are not equal, otherwise false.</returns>
 319         /// <since_tizen> 3 </since_tizen>
 320         public bool NotEqualTo(Position rhs)
 321         {
 322             bool ret = NDalicPINVOKE.Vector3_NotEqualTo(swigCPtr, Position.getCPtr(rhs));
 323             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 324             return ret;
 325         }
 326
 327
 328         /// <summary>
 329         /// The x component.
 330         /// </summary>
 331         /// <since_tizen> 3 </since_tizen>
 332         public float X
 333         {
 334             set
 335             {
 336                 NDalicPINVOKE.Vector3_X_set(swigCPtr, value);
 337                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 338             }
 339             get
 340             {
 341                 float ret = NDalicPINVOKE.Vector3_X_get(swigCPtr);
 342                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 343                 return ret;
 344             }
 345         }
 346
 347         /// <summary>
 348         /// The y component.
 349         /// </summary>
 350         /// <since_tizen> 3 </since_tizen>
 351         public float Y
 352         {
 353             set
 354             {
 355                 NDalicPINVOKE.Vector3_Y_set(swigCPtr, value);
 356                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 357             }
 358             get
 359             {
 360                 float ret = NDalicPINVOKE.Vector3_Y_get(swigCPtr);
 361                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 362                 return ret;
 363             }
 364         }
 365
 366         /// <summary>
 367         /// The z component.
 368         /// </summary>
 369         /// <since_tizen> 3 </since_tizen>
 370         public float Z
 371         {
 372             set
 373             {
 374                 NDalicPINVOKE.Vector3_Z_set(swigCPtr, value);
 375                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 376             }
 377             get
 378             {
 379                 float ret = NDalicPINVOKE.Vector3_Z_get(swigCPtr);
 380                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 381                 return ret;
 382             }
 383         }
 384
 385         /// <summary>
 386         /// ParentOrigin constants. It's 0.0.
 387         /// </summary>
 388         /// <since_tizen> 3 </since_tizen>
 389         public static float ParentOriginTop
 390         {
 391             get
 392             {
 393                 float ret = NDalicPINVOKE.ParentOriginTop_get();
 394                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 395                 return ret;
 396             }
 397         }
 398
 399         /// <summary>
 400         /// ParentOrigin constants. It's 1.0.
 401         /// </summary>
 402         /// <since_tizen> 3 </since_tizen>
 403         public static float ParentOriginBottom
 404         {
 405             get
 406             {
 407                 float ret = NDalicPINVOKE.ParentOriginBottom_get();
 408                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 409                 return ret;
 410             }
 411         }
 412
 413         /// <summary>
 414         /// ParentOrigin constants. It's 0.0.
 415         /// </summary>
 416         /// <since_tizen> 3 </since_tizen>
 417         public static float ParentOriginLeft
 418         {
 419             get
 420             {
 421                 float ret = NDalicPINVOKE.ParentOriginLeft_get();
 422                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 423                 return ret;
 424             }
 425         }
 426
 427         /// <summary>
 428         /// ParentOrigin constants. It's 1.0.
 429         /// </summary>
 430         /// <since_tizen> 3 </since_tizen>
 431         public static float ParentOriginRight
 432         {
 433             get
 434             {
 435                 float ret = NDalicPINVOKE.ParentOriginRight_get();
 436                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 437                 return ret;
 438             }
 439         }
 440
 441         /// <summary>
 442         /// ParentOrigin constants. It's 0.5.
 443         /// </summary>
 444         /// <since_tizen> 3 </since_tizen>
 445         public static float ParentOriginMiddle
 446         {
 447             get
 448             {
 449                 float ret = NDalicPINVOKE.ParentOriginMiddle_get();
 450                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 451                 return ret;
 452             }
 453         }
 454
 455         /// <summary>
 456         /// ParentOrigin constants: 0.0, 0.0, 0.5.
 457         /// </summary>
 458         /// <since_tizen> 3 </since_tizen>
 459         public static Position ParentOriginTopLeft
 460         {
 461             get
 462             {
 463                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopLeft_get();
 464                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 465                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 466                 return ret;
 467             }
 468         }
 469
 470         /// <summary>
 471         /// ParentOrigin constants: 0.5, 0.0, 0.5.
 472         /// </summary>
 473         /// <since_tizen> 3 </since_tizen>
 474         public static Position ParentOriginTopCenter
 475         {
 476             get
 477             {
 478                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopCenter_get();
 479                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 480                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 481                 return ret;
 482             }
 483         }
 484
 485         /// <summary>
 486         /// ParentOrigin constants: 1.0, 0.0, 0.5.
 487         /// </summary>
 488         /// <since_tizen> 3 </since_tizen>
 489         public static Position ParentOriginTopRight
 490         {
 491             get
 492             {
 493                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopRight_get();
 494                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 495                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 496                 return ret;
 497             }
 498         }
 499
 500         /// <summary>
 501         /// ParentOrigin constants: 0.0, 0.5, 0.5.
 502         /// </summary>
 503         /// <since_tizen> 3 </since_tizen>
 504         public static Position ParentOriginCenterLeft
 505         {
 506             get
 507             {
 508                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterLeft_get();
 509                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 510                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 511                 return ret;
 512             }
 513         }
 514
 515         /// <summary>
 516         /// ParentOrigin constants: 0.0, 0.5, 0.5
 517         /// </summary>
 518         /// <since_tizen> 3 </since_tizen>
 519         public static Position ParentOriginCenter
 520         {
 521             get
 522             {
 523                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenter_get();
 524                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 525                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 526                 return ret;
 527             }
 528         }
 529
 530         /// <summary>
 531         /// ParentOrigin constants: 1.0, 0.5, 0.5.
 532         /// </summary>
 533         /// <since_tizen> 3 </since_tizen>
 534         public static Position ParentOriginCenterRight
 535         {
 536             get
 537             {
 538                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterRight_get();
 539                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 540                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 541                 return ret;
 542             }
 543         }
 544
 545         /// <summary>
 546         /// ParentOrigin constants: 0.0f, 1.0f, 0.5f.
 547         /// </summary>
 548         /// <since_tizen> 3 </since_tizen>
 549         public static Position ParentOriginBottomLeft
 550         {
 551             get
 552             {
 553                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomLeft_get();
 554                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 555                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 556                 return ret;
 557             }
 558         }
 559
 560         /// <summary>
 561         /// ParentOrigin constants: 0.5, 1.0, 0.5.
 562         /// </summary>
 563         /// <since_tizen> 3 </since_tizen>
 564         public static Position ParentOriginBottomCenter
 565         {
 566             get
 567             {
 568                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomCenter_get();
 569                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 570                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 571                 return ret;
 572             }
 573         }
 574
 575         /// <summary>
 576         /// ParentOrigin constants: 1.0, 1.0, 0.5.
 577         /// </summary>
 578         /// <since_tizen> 3 </since_tizen>
 579         public static Position ParentOriginBottomRight
 580         {
 581             get
 582             {
 583                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomRight_get();
 584                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 585                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 586                 return ret;
 587             }
 588         }
 589
 590         /// <summary>
 591         /// PivotPoint constants: 0.0.
 592         /// </summary>
 593         /// <since_tizen> 4 </since_tizen>
 594         public static float PivotPointTop
 595         {
 596             get
 597             {
 598                 float ret = NDalicPINVOKE.AnchorPointTop_get();
 599                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 600                 return ret;
 601             }
 602         }
 603
 604         /// <summary>
 605         /// PivotPoint constants: 1.0.
 606         /// </summary>
 607         /// <since_tizen> 4 </since_tizen>
 608         public static float PivotPointBottom
 609         {
 610             get
 611             {
 612                 float ret = NDalicPINVOKE.AnchorPointBottom_get();
 613                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 614                 return ret;
 615             }
 616         }
 617
 618         /// <summary>
 619         /// PivotPoint constants: 0.0.
 620         /// </summary>
 621         /// <since_tizen> 4 </since_tizen>
 622         public static float PivotPointLeft
 623         {
 624             get
 625             {
 626                 float ret = NDalicPINVOKE.AnchorPointLeft_get();
 627                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 628                 return ret;
 629             }
 630         }
 631
 632         /// <summary>
 633         /// PivotPoint constants: 1.0.
 634         /// </summary>
 635         /// <since_tizen> 4 </since_tizen>
 636         public static float PivotPointRight
 637         {
 638             get
 639             {
 640                 float ret = NDalicPINVOKE.AnchorPointRight_get();
 641                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 642                 return ret;
 643             }
 644         }
 645
 646         /// <summary>
 647         /// PivotPoint constants: 0.0.
 648         /// </summary>
 649         /// <since_tizen> 4 </since_tizen>
 650         public static float PivotPointMiddle
 651         {
 652             get
 653             {
 654                 float ret = NDalicPINVOKE.AnchorPointMiddle_get();
 655                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 656                 return ret;
 657             }
 658         }
 659
 660         /// <summary>
 661         /// PivotPoint constants: 0.0, 0.0, 0.5.
 662         /// </summary>
 663         /// <since_tizen> 4 </since_tizen>
 664         public static Position PivotPointTopLeft
 665         {
 666             get
 667             {
 668                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopLeft_get();
 669                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 670                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 671                 return ret;
 672             }
 673         }
 674
 675         /// <summary>
 676         /// PivotPoint constants: 0.5, 0.0, 0.5.
 677         /// </summary>
 678         /// <since_tizen> 4 </since_tizen>
 679         public static Position PivotPointTopCenter
 680         {
 681             get
 682             {
 683                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopCenter_get();
 684                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 685                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 686                 return ret;
 687             }
 688         }
 689
 690         /// <summary>
 691         /// PivotPoint constants: 1.0, 0.0, 0.5.
 692         /// </summary>
 693         /// <since_tizen> 4 </since_tizen>
 694         public static Position PivotPointTopRight
 695         {
 696             get
 697             {
 698                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopRight_get();
 699                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 700                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 701                 return ret;
 702             }
 703         }
 704
 705         /// <summary>
 706         /// PivotPoint constants: 0.0, 0.5, 0.5.
 707         /// </summary>
 708         /// <since_tizen> 4 </since_tizen>
 709         public static Position PivotPointCenterLeft
 710         {
 711             get
 712             {
 713                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterLeft_get();
 714                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 715                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 716                 return ret;
 717             }
 718         }
 719
 720         /// <summary>
 721         /// PivotPoint constants: 0.5, 0.5, 0.5.
 722         /// </summary>
 723         /// <since_tizen> 4 </since_tizen>
 724         public static Position PivotPointCenter
 725         {
 726             get
 727             {
 728                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenter_get();
 729                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 730                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 731                 return ret;
 732             }
 733         }
 734
 735         /// <summary>
 736         /// PivotPoint constants: 1.0, 0.5, 0.5.
 737         /// </summary>
 738         /// <since_tizen> 4 </since_tizen>
 739         public static Position PivotPointCenterRight
 740         {
 741             get
 742             {
 743                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterRight_get();
 744                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 745                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 746                 return ret;
 747             }
 748         }
 749
 750         /// <summary>
 751         /// PivotPoint constants: 0.0, 1.0, 0.5.
 752         /// </summary>
 753         /// <since_tizen> 4 </since_tizen>
 754         public static Position PivotPointBottomLeft
 755         {
 756             get
 757             {
 758                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomLeft_get();
 759                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 760                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 761                 return ret;
 762             }
 763         }
 764
 765         /// <summary>
 766         /// PivotPoint constants: 0.5, 1.0, 0.5
 767         /// </summary>
 768         /// <since_tizen> 4 </since_tizen>
 769         public static Position PivotPointBottomCenter
 770         {
 771             get
 772             {
 773                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomCenter_get();
 774                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 775                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 776                 return ret;
 777             }
 778         }
 779
 780         /// <summary>
 781         /// PivotPoint constants: 1.0, 1.0, 0.5.
 782         /// </summary>
 783         /// <since_tizen> 4 </since_tizen>
 784         public static Position PivotPointBottomRight
 785         {
 786             get
 787             {
 788                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomRight_get();
 789                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 790                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 791                 return ret;
 792             }
 793         }
 794
 795         /// <summary>
 796         /// Constant ( 1.0f, 1.0f, 1.0f ).
 797         /// </summary>
 798         /// <since_tizen> 3 </since_tizen>
 799         public static Position One
 800         {
 801             get
 802             {
 803                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ONE_get();
 804                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 805                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 806                 return ret;
 807             }
 808         }
 809
 810         internal static Position XAxis
 811         {
 812             get
 813             {
 814                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_XAXIS_get();
 815                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 816                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 817                 return ret;
 818             }
 819         }
 820
 821         internal static Position YAxis
 822         {
 823             get
 824             {
 825                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_YAXIS_get();
 826                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 827                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 828                 return ret;
 829             }
 830         }
 831
 832         internal static Position ZAxis
 833         {
 834             get
 835             {
 836                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZAXIS_get();
 837                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 838                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 839                 return ret;
 840             }
 841         }
 842
 843         internal static Position NegativeXAxis
 844         {
 845             get
 846             {
 847                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_XAXIS_get();
 848                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 849                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 850                 return ret;
 851             }
 852         }
 853
 854         internal static Position NegativeYAxis
 855         {
 856             get
 857             {
 858                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_YAXIS_get();
 859                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 860                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 861                 return ret;
 862             }
 863         }
 864
 865         internal static Position NegativeZAxis
 866         {
 867             get
 868             {
 869                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_ZAXIS_get();
 870                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 871                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 872                 return ret;
 873             }
 874         }
 875
 876         /// <summary>
 877         /// Constant ( 0.0f, 0.0f, 0.0f ).
 878         /// </summary>
 879         /// <since_tizen> 3 </since_tizen>
 880         public static Position Zero
 881         {
 882             get
 883             {
 884                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZERO_get();
 885                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 886                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 887                 return ret;
 888             }
 889         }
 890
 891         /// <summary>
 892         /// Converts a position instance to a Vector3 instance.
 893         /// </summary>
 894         /// <since_tizen> 3 </since_tizen>
 895         public static implicit operator Vector3(Position Position)
 896         {
 897             return new Vector3(Position.X, Position.Y, Position.Z);
 898         }
 899
 900         /// <summary>
 901         /// Converts a Vector3 instance to a position instance.
 902         /// </summary>
 903         /// <since_tizen> 3 </since_tizen>
 904         public static implicit operator Position(Vector3 vec)
 905         {
 906             return new Position(vec.X, vec.Y, vec.Z);
 907         }
 908
 909
 910         [Obsolete("Please do not use! this will be deprecated")]
 911         public static float AnchorPointTop
 912         {
 913             get
 914             {
 915                 float ret = NDalicPINVOKE.AnchorPointTop_get();
 916                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 917                 return ret;
 918             }
 919         }
 920
 921         [Obsolete("Please do not use! this will be deprecated")]
 922         public static float AnchorPointBottom
 923         {
 924             get
 925             {
 926                 float ret = NDalicPINVOKE.AnchorPointBottom_get();
 927                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 928                 return ret;
 929             }
 930         }
 931
 932         [Obsolete("Please do not use! this will be deprecated")]
 933         public static float AnchorPointLeft
 934         {
 935             get
 936             {
 937                 float ret = NDalicPINVOKE.AnchorPointLeft_get();
 938                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 939                 return ret;
 940             }
 941         }
 942
 943         [Obsolete("Please do not use! this will be deprecated")]
 944         public static float AnchorPointRight
 945         {
 946             get
 947             {
 948                 float ret = NDalicPINVOKE.AnchorPointRight_get();
 949                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 950                 return ret;
 951             }
 952         }
 953
 954         [Obsolete("Please do not use! this will be deprecated")]
 955         public static float AnchorPointMiddle
 956         {
 957             get
 958             {
 959                 float ret = NDalicPINVOKE.AnchorPointMiddle_get();
 960                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 961                 return ret;
 962             }
 963         }
 964
 965         [Obsolete("Please do not use! this will be deprecated")]
 966         public static Position AnchorPointTopLeft
 967         {
 968             get
 969             {
 970                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopLeft_get();
 971                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 972                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 973                 return ret;
 974             }
 975         }
 976
 977         [Obsolete("Please do not use! this will be deprecated")]
 978         public static Position AnchorPointTopCenter
 979         {
 980             get
 981             {
 982                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopCenter_get();
 983                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 984                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 985                 return ret;
 986             }
 987         }
 988
 989         [Obsolete("Please do not use! this will be deprecated")]
 990         public static Position AnchorPointTopRight
 991         {
 992             get
 993             {
 994                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopRight_get();
 995                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 996                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 997                 return ret;
 998             }
 999         }
1000
1001         [Obsolete("Please do not use! this will be deprecated")]
1002         public static Position AnchorPointCenterLeft
1003         {
1004             get
1005             {
1006                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterLeft_get();
1007                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1008                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1009                 return ret;
1010             }
1011         }
1012
1013
1014         [Obsolete("Please do not use! this will be deprecated")]
1015         public static Position AnchorPointCenter
1016         {
1017             get
1018             {
1019                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenter_get();
1020                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1021                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1022                 return ret;
1023             }
1024         }
1025
1026         [Obsolete("Please do not use! this will be deprecated")]
1027         public static Position AnchorPointCenterRight
1028         {
1029             get
1030             {
1031                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterRight_get();
1032                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1033                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1034                 return ret;
1035             }
1036         }
1037
1038         [Obsolete("Please do not use! this will be deprecated")]
1039         public static Position AnchorPointBottomLeft
1040         {
1041             get
1042             {
1043                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomLeft_get();
1044                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1045                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1046                 return ret;
1047             }
1048         }
1049
1050         [Obsolete("Please do not use! this will be deprecated")]
1051         public static Position AnchorPointBottomCenter
1052         {
1053             get
1054             {
1055                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomCenter_get();
1056                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1057                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1058                 return ret;
1059             }
1060         }
1061
1062         [Obsolete("Please do not use! this will be deprecated")]
1063         public static Position AnchorPointBottomRight
1064         {
1065             get
1066             {
1067                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomRight_get();
1068                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
1069                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1070                 return ret;
1071             }
1072         }
1073
1074     }
1075 }