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 namespace Tizen.NUI
  19 {
  20
  21     /// <summary>
  22     /// Position is a three dimensional vector.
  23     /// </summary>
  24     public class Position : global::System.IDisposable
  25     {
  26         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  27         protected bool swigCMemOwn;
  28
  29         internal Position(global::System.IntPtr cPtr, bool cMemoryOwn)
  30         {
  31             swigCMemOwn = cMemoryOwn;
  32             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  33         }
  34
  35         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Position obj)
  36         {
  37             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  38         }
  39
  40         ~Position()
  41         {
  42             DisposeQueue.Instance.Add(this);
  43         }
  44
  45         public virtual void Dispose()
  46         {
  47             if (!Stage.IsInstalled())
  48             {
  49                 DisposeQueue.Instance.Add(this);
  50                 return;
  51             }
  52
  53             lock (this)
  54             {
  55                 if (swigCPtr.Handle != global::System.IntPtr.Zero)
  56                 {
  57                     if (swigCMemOwn)
  58                     {
  59                         swigCMemOwn = false;
  60                         NDalicPINVOKE.delete_Vector3(swigCPtr);
  61                     }
  62                     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  63                 }
  64                 global::System.GC.SuppressFinalize(this);
  65             }
  66         }
  67
  68
  69         /// <summary>
  70         /// Addition operator.
  71         /// </summary>
  72         /// <param name="arg1">Vector to add</param>
  73         /// <param name="arg2">Vector to add</param>
  74         /// <returns>A vector containing the result of the addition</returns>
  75         public static Position operator +(Position arg1, Position arg2)
  76         {
  77             return arg1.Add(arg2);
  78         }
  79
  80         /// <summary>
  81         /// Subtraction operator.
  82         /// </summary>
  83         /// <param name="arg1">Vector to subtract</param>
  84         /// <param name="arg2">Vector to subtract</param>
  85         /// <returns>A vector containing the result of the subtraction</returns>
  86         public static Position operator -(Position arg1, Position arg2)
  87         {
  88             return arg1.Subtract(arg2);
  89         }
  90
  91         /// <summary>
  92         /// Unary negation operator.
  93         /// </summary>
  94         /// <param name="arg1">Vector to netate</param>
  95         /// <returns>A vector containg the negation</returns>
  96         public static Position operator -(Position arg1)
  97         {
  98             return arg1.Subtract();
  99         }
 100
 101         /// <summary>
 102         /// Multiplication operator.
 103         /// </summary>
 104         /// <param name="arg1">The vector to multiply</param>
 105         /// <param name="arg2">The vector to multiply</param>
 106         /// <returns>A vector containing the result of the multiplication</returns>
 107         public static Position operator *(Position arg1, Position arg2)
 108         {
 109             return arg1.Multiply(arg2);
 110         }
 111
 112         /// <summary>
 113         /// Multiplication operator.
 114         /// </summary>
 115         /// <param name="arg1">The vector to multiply</param>
 116         /// <param name="arg2">The float value to scale the vector</param>
 117         /// <returns>A vector containing the result of the scaling</returns>
 118         public static Position operator *(Position arg1, float arg2)
 119         {
 120             return arg1.Multiply(arg2);
 121         }
 122
 123         /// <summary>
 124         /// Division operator.
 125         /// </summary>
 126         /// <param name="arg1">The vector to divide</param>
 127         /// <param name="arg2">The vector to divide</param>
 128         /// <returns>A vector containing the result of the division</returns>
 129         public static Position operator /(Position arg1, Position arg2)
 130         {
 131             return arg1.Divide(arg2);
 132         }
 133
 134         /// <summary>
 135         /// Division operator.
 136         /// </summary>
 137         /// <param name="arg1">The vector to divide</param>
 138         /// <param name="arg2">The float value to scale the vector by</param>
 139         /// <returns>A vector containing the result of the scaling</returns>
 140         public static Position operator /(Position arg1, float arg2)
 141         {
 142             return arg1.Divide(arg2);
 143         }
 144
 145
 146         /// <summary>
 147         /// Const array subscript operator overload. Should be 0, 1 or 2.
 148         /// </summary>
 149         /// <param name="index">Subscript index</param>
 150         /// <returns>The float at the given index</returns>
 151         public float this[uint index]
 152         {
 153             get
 154             {
 155                 return ValueOfIndex(index);
 156             }
 157         }
 158
 159         /// <summary>
 160         /// </summary>
 161         internal static Position GetPositionFromPtr(global::System.IntPtr cPtr)
 162         {
 163             Position ret = new Position(cPtr, false);
 164             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 165             return ret;
 166         }
 167
 168
 169         /// <summary>
 170         /// Constructor
 171         /// </summary>
 172         public Position() : this(NDalicPINVOKE.new_Vector3__SWIG_0(), true)
 173         {
 174             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 175         }
 176
 177         /// <summary>
 178         /// Constructor
 179         /// </summary>
 180         /// <param name="x">x component</param>
 181         /// <param name="y">y component</param>
 182         /// <param name="z">z component</param>
 183         public Position(float x, float y, float z) : this(NDalicPINVOKE.new_Vector3__SWIG_1(x, y, z), true)
 184         {
 185             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 186         }
 187
 188         /// <summary>
 189         /// Constructor
 190         /// </summary>
 191         /// <param name="position2d">Position2D to create this vector from</param>
 192         public Position(Position2D position2d) : this(NDalicPINVOKE.new_Vector3__SWIG_3(Position2D.getCPtr(position2d)), true)
 193         {
 194             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 195         }
 196
 197
 198
 199         private Position Add(Position rhs)
 200         {
 201             Position ret = new Position(NDalicPINVOKE.Vector3_Add(swigCPtr, Position.getCPtr(rhs)), true);
 202             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 203             return ret;
 204         }
 205
 206         private Position Subtract(Position rhs)
 207         {
 208             Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 209             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 210             return ret;
 211         }
 212
 213         private Position Multiply(Position rhs)
 214         {
 215             Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 216             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 217             return ret;
 218         }
 219
 220         private Position Multiply(float rhs)
 221         {
 222             Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_1(swigCPtr, rhs), true);
 223             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 224             return ret;
 225         }
 226
 227         private Position Divide(Position rhs)
 228         {
 229             Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 230             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 231             return ret;
 232         }
 233
 234         private Position Divide(float rhs)
 235         {
 236             Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_1(swigCPtr, rhs), true);
 237             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 238             return ret;
 239         }
 240
 241         private Position Subtract()
 242         {
 243             Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_1(swigCPtr), true);
 244             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 245             return ret;
 246         }
 247
 248         private float ValueOfIndex(uint index)
 249         {
 250             float ret = NDalicPINVOKE.Vector3_ValueOfIndex__SWIG_0(swigCPtr, index);
 251             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 252             return ret;
 253         }
 254
 255         /// <summary>
 256         /// Compare if rhs is equal to
 257         /// </summary>
 258         /// <param name="rhs">The vector to compare</param>
 259         /// <returns>Returns true if the two vectors are equal, otherwise false</returns>
 260         public bool EqualTo(Position rhs)
 261         {
 262             bool ret = NDalicPINVOKE.Vector3_EqualTo(swigCPtr, Position.getCPtr(rhs));
 263             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 264             return ret;
 265         }
 266
 267         /// <summary>
 268         /// Compare if rhs is not equal to
 269         /// </summary>
 270         /// <param name="rhs">The vector to compare</param>
 271         /// <returns>Returns true if the two vectors are not equal, otherwise false</returns>
 272         public bool NotEqualTo(Position rhs)
 273         {
 274             bool ret = NDalicPINVOKE.Vector3_NotEqualTo(swigCPtr, Position.getCPtr(rhs));
 275             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 276             return ret;
 277         }
 278
 279
 280         /// <summary>
 281         /// x component
 282         /// </summary>
 283         public float X
 284         {
 285             set
 286             {
 287                 NDalicPINVOKE.Vector3_X_set(swigCPtr, value);
 288                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 289             }
 290             get
 291             {
 292                 float ret = NDalicPINVOKE.Vector3_X_get(swigCPtr);
 293                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 294                 return ret;
 295             }
 296         }
 297
 298         /// <summary>
 299         /// y component
 300         /// </summary>
 301         public float Y
 302         {
 303             set
 304             {
 305                 NDalicPINVOKE.Vector3_Y_set(swigCPtr, value);
 306                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 307             }
 308             get
 309             {
 310                 float ret = NDalicPINVOKE.Vector3_Y_get(swigCPtr);
 311                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 312                 return ret;
 313             }
 314         }
 315
 316         /// <summary>
 317         /// z component
 318         /// </summary>
 319         public float Z
 320         {
 321             set
 322             {
 323                 NDalicPINVOKE.Vector3_Z_set(swigCPtr, value);
 324                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 325             }
 326             get
 327             {
 328                 float ret = NDalicPINVOKE.Vector3_Z_get(swigCPtr);
 329                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 330                 return ret;
 331             }
 332         }
 333
 334         /// <summary>
 335         /// ParentOrigin constants. It's 0.0.
 336         /// </summary>
 337         public static float ParentOriginTop
 338         {
 339             get
 340             {
 341                 float ret = NDalicPINVOKE.ParentOriginTop_get();
 342                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 343                 return ret;
 344             }
 345         }
 346
 347         /// <summary>
 348         /// ParentOrigin constants. It's 1.0.
 349         /// </summary>
 350         public static float ParentOriginBottom
 351         {
 352             get
 353             {
 354                 float ret = NDalicPINVOKE.ParentOriginBottom_get();
 355                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 356                 return ret;
 357             }
 358         }
 359
 360         /// <summary>
 361         /// ParentOrigin constants. It's 0.0.
 362         /// </summary>
 363         public static float ParentOriginLeft
 364         {
 365             get
 366             {
 367                 float ret = NDalicPINVOKE.ParentOriginLeft_get();
 368                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 369                 return ret;
 370             }
 371         }
 372
 373         /// <summary>
 374         /// ParentOrigin constants. It's 1.0.
 375         /// </summary>
 376         public static float ParentOriginRight
 377         {
 378             get
 379             {
 380                 float ret = NDalicPINVOKE.ParentOriginRight_get();
 381                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 382                 return ret;
 383             }
 384         }
 385
 386         /// <summary>
 387         /// ParentOrigin constants. It's 0.5.
 388         /// </summary>
 389         public static float ParentOriginMiddle
 390         {
 391             get
 392             {
 393                 float ret = NDalicPINVOKE.ParentOriginMiddle_get();
 394                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 395                 return ret;
 396             }
 397         }
 398
 399         /// <summary>
 400         /// ParentOrigin constants: 0.0, 0.0, 0.5
 401         /// </summary>
 402         public static Position ParentOriginTopLeft
 403         {
 404             get
 405             {
 406                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopLeft_get();
 407                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 408                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 409                 return ret;
 410             }
 411         }
 412
 413         /// <summary>
 414         /// ParentOrigin constants: 0.5, 0.0, 0.5
 415         /// </summary>
 416         public static Position ParentOriginTopCenter
 417         {
 418             get
 419             {
 420                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopCenter_get();
 421                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 422                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 423                 return ret;
 424             }
 425         }
 426
 427         /// <summary>
 428         /// ParentOrigin constants: 1.0, 0.0, 0.5
 429         /// </summary>
 430         public static Position ParentOriginTopRight
 431         {
 432             get
 433             {
 434                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopRight_get();
 435                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 436                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 437                 return ret;
 438             }
 439         }
 440
 441         /// <summary>
 442         /// ParentOrigin constants: 0.0, 0.5, 0.5
 443         /// </summary>
 444         public static Position ParentOriginCenterLeft
 445         {
 446             get
 447             {
 448                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterLeft_get();
 449                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 450                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 451                 return ret;
 452             }
 453         }
 454
 455         /// <summary>
 456         /// ParentOrigin constants: 0.0, 0.5, 0.5
 457         /// </summary>
 458         public static Position ParentOriginCenter
 459         {
 460             get
 461             {
 462                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenter_get();
 463                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 464                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 465                 return ret;
 466             }
 467         }
 468
 469         /// <summary>
 470         /// ParentOrigin constants: 1.0, 0.5, 0.5
 471         /// </summary>
 472         public static Position ParentOriginCenterRight
 473         {
 474             get
 475             {
 476                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterRight_get();
 477                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 478                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 479                 return ret;
 480             }
 481         }
 482
 483         /// <summary>
 484         /// ParentOrigin constants: 0.0f, 1.0f, 0.5f
 485         /// </summary>
 486         public static Position ParentOriginBottomLeft
 487         {
 488             get
 489             {
 490                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomLeft_get();
 491                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 492                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 493                 return ret;
 494             }
 495         }
 496
 497         /// <summary>
 498         /// ParentOrigin constants: 0.5, 1.0, 0.5
 499         /// </summary>
 500         public static Position ParentOriginBottomCenter
 501         {
 502             get
 503             {
 504                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomCenter_get();
 505                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 506                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 507                 return ret;
 508             }
 509         }
 510
 511         /// <summary>
 512         /// ParentOrigin constants: 1.0, 1.0, 0.5
 513         /// </summary>
 514         public static Position ParentOriginBottomRight
 515         {
 516             get
 517             {
 518                 global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomRight_get();
 519                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 520                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 521                 return ret;
 522             }
 523         }
 524
 525         /// <summary>
 526         /// AnchorPoint constants: 0.0
 527         /// </summary>
 528         public static float AnchorPointTop
 529         {
 530             get
 531             {
 532                 float ret = NDalicPINVOKE.AnchorPointTop_get();
 533                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 534                 return ret;
 535             }
 536         }
 537
 538         /// <summary>
 539         /// AnchorPoint constants: 1.0
 540         /// </summary>
 541         public static float AnchorPointBottom
 542         {
 543             get
 544             {
 545                 float ret = NDalicPINVOKE.AnchorPointBottom_get();
 546                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 547                 return ret;
 548             }
 549         }
 550
 551         /// <summary>
 552         /// AnchorPoint constants: 0.0
 553         /// </summary>
 554         public static float AnchorPointLeft
 555         {
 556             get
 557             {
 558                 float ret = NDalicPINVOKE.AnchorPointLeft_get();
 559                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 560                 return ret;
 561             }
 562         }
 563
 564         /// <summary>
 565         /// AnchorPoint constants: 1.0
 566         /// </summary>
 567         public static float AnchorPointRight
 568         {
 569             get
 570             {
 571                 float ret = NDalicPINVOKE.AnchorPointRight_get();
 572                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 573                 return ret;
 574             }
 575         }
 576
 577         /// <summary>
 578         /// AnchorPoint constants: 0.0
 579         /// </summary>
 580         public static float AnchorPointMiddle
 581         {
 582             get
 583             {
 584                 float ret = NDalicPINVOKE.AnchorPointMiddle_get();
 585                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 586                 return ret;
 587             }
 588         }
 589
 590         /// <summary>
 591         /// AnchorPoint constants: 0.0, 0.0, 0.5
 592         /// </summary>
 593         public static Position AnchorPointTopLeft
 594         {
 595             get
 596             {
 597                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopLeft_get();
 598                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 599                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 600                 return ret;
 601             }
 602         }
 603
 604         /// <summary>
 605         /// AnchorPoint constants: 0.5, 0.0, 0.5
 606         /// </summary>
 607         public static Position AnchorPointTopCenter
 608         {
 609             get
 610             {
 611                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopCenter_get();
 612                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 613                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 614                 return ret;
 615             }
 616         }
 617
 618         /// <summary>
 619         /// AnchorPoint constants: 1.0, 0.0, 0.5
 620         /// </summary>
 621         public static Position AnchorPointTopRight
 622         {
 623             get
 624             {
 625                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopRight_get();
 626                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 627                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 628                 return ret;
 629             }
 630         }
 631
 632         /// <summary>
 633         /// AnchorPoint constants: 0.0, 0.5, 0.5
 634         /// </summary>
 635         public static Position AnchorPointCenterLeft
 636         {
 637             get
 638             {
 639                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterLeft_get();
 640                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 641                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 642                 return ret;
 643             }
 644         }
 645
 646         /// <summary>
 647         /// AnchorPoint constants: 0.5, 0.5, 0.5
 648         /// </summary>
 649         public static Position AnchorPointCenter
 650         {
 651             get
 652             {
 653                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenter_get();
 654                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 655                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 656                 return ret;
 657             }
 658         }
 659
 660         /// <summary>
 661         /// AnchorPoint constants: 1.0, 0.5, 0.5
 662         /// </summary>
 663         public static Position AnchorPointCenterRight
 664         {
 665             get
 666             {
 667                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterRight_get();
 668                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 669                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 670                 return ret;
 671             }
 672         }
 673
 674         /// <summary>
 675         /// AnchorPoint constants: 0.0, 1.0, 0.5
 676         /// </summary>
 677         public static Position AnchorPointBottomLeft
 678         {
 679             get
 680             {
 681                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomLeft_get();
 682                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 683                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 684                 return ret;
 685             }
 686         }
 687
 688         /// <summary>
 689         /// AnchorPoint constants: 0.5, 1.0, 0.5
 690         /// </summary>
 691         public static Position AnchorPointBottomCenter
 692         {
 693             get
 694             {
 695                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomCenter_get();
 696                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 697                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 698                 return ret;
 699             }
 700         }
 701
 702         /// <summary>
 703         /// AnchorPoint constants: 1.0, 1.0, 0.5
 704         /// </summary>
 705         public static Position AnchorPointBottomRight
 706         {
 707             get
 708             {
 709                 global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomRight_get();
 710                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 711                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 712                 return ret;
 713             }
 714         }
 715
 716         /// <summary>
 717         /// Constant ( 1.0f, 1.0f, 1.0f )
 718         /// </summary>
 719         public static Position One
 720         {
 721             get
 722             {
 723                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ONE_get();
 724                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 725                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 726                 return ret;
 727             }
 728         }
 729
 730         internal static Position XAxis
 731         {
 732             get
 733             {
 734                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_XAXIS_get();
 735                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 736                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 737                 return ret;
 738             }
 739         }
 740
 741         internal static Position YAxis
 742         {
 743             get
 744             {
 745                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_YAXIS_get();
 746                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 747                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 748                 return ret;
 749             }
 750         }
 751
 752         internal static Position ZAxis
 753         {
 754             get
 755             {
 756                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZAXIS_get();
 757                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 758                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 759                 return ret;
 760             }
 761         }
 762
 763         internal static Position NegativeXAxis
 764         {
 765             get
 766             {
 767                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_XAXIS_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         internal static Position NegativeYAxis
 775         {
 776             get
 777             {
 778                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_YAXIS_get();
 779                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 780                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 781                 return ret;
 782             }
 783         }
 784
 785         internal static Position NegativeZAxis
 786         {
 787             get
 788             {
 789                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_ZAXIS_get();
 790                 Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 791                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 792                 return ret;
 793             }
 794         }
 795
 796         /// <summary>
 797         /// Constant ( 0.0f, 0.0f, 0.0f )
 798         /// </summary>
 799         public static Position Zero
 800         {
 801             get
 802             {
 803                 global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZERO_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         /// <summary>
 811         /// Convert a position instance to a vector3 instance.
 812         /// </summary>
 813         public static implicit operator Vector3(Position Position)
 814         {
 815             return new Vector3(Position.X, Position.Y, Position.Z);
 816         }
 817
 818         /// <summary>
 819         /// Convert a vector3 instance to a position instance.
 820         /// </summary>
 821         public static implicit operator Position(Vector3 vec)
 822         {
 823             return new Position(vec.X, vec.Y, vec.Z);
 824         }
 825     }
 826 }