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