plugins/dali-sharp/sharp/internal/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 Dali {
  19
  20 public class Position : global::System.IDisposable {
  21   private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  22   protected bool swigCMemOwn;
  23
  24   internal Position(global::System.IntPtr cPtr, bool cMemoryOwn) {
  25     swigCMemOwn = cMemoryOwn;
  26     swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
  27   }
  28
  29   internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Position obj) {
  30     return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
  31   }
  32
  33   ~Position() {
  34     DisposeQueue.Instance.Add(this);
  35   }
  36
  37   public virtual void Dispose() {
  38     if (!Stage.IsInstalled()) {
  39       DisposeQueue.Instance.Add(this);
  40       return;
  41     }
  42
  43     lock(this) {
  44       if (swigCPtr.Handle != global::System.IntPtr.Zero) {
  45         if (swigCMemOwn) {
  46           swigCMemOwn = false;
  47           NDalicPINVOKE.delete_Vector3(swigCPtr);
  48         }
  49         swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
  50       }
  51       global::System.GC.SuppressFinalize(this);
  52     }
  53   }
  54
  55
  56   public static Position operator+(Position arg1, Position arg2) {
  57     return arg1.Add(arg2);
  58   }
  59
  60   public static Position operator-(Position arg1, Position arg2) {
  61     return arg1.Subtract(arg2);
  62   }
  63
  64   public static Position operator-(Position arg1) {
  65     return arg1.Subtract();
  66   }
  67
  68   public static Position operator*(Position arg1, Position arg2) {
  69     return arg1.Multiply(arg2);
  70   }
  71
  72   public static Position operator*(Position arg1, float arg2) {
  73     return arg1.Multiply(arg2);
  74   }
  75
  76   public static Position operator/(Position arg1, Position arg2) {
  77     return arg1.Divide(arg2);
  78   }
  79
  80   public static Position operator/(Position arg1, float arg2) {
  81     return arg1.Divide(arg2);
  82   }
  83
  84
  85   public float this[uint index]
  86   {
  87     get
  88     {
  89       return ValueOfIndex(index);
  90     }
  91   }
  92
  93   public static Position GetPositionFromPtr(global::System.IntPtr cPtr) {
  94     Position ret = new Position(cPtr, false);
  95     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  96        return ret;
  97   }
  98
  99
 100   public Position() : this(NDalicPINVOKE.new_Vector3__SWIG_0(), true) {
 101     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 102   }
 103
 104   public Position(float x, float y, float z) : this(NDalicPINVOKE.new_Vector3__SWIG_1(x, y, z), true) {
 105     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 106   }
 107
 108   public Position(Position2D position2d) : this(NDalicPINVOKE.new_Vector3__SWIG_3(Position2D.getCPtr(position2d)), true) {
 109     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 110   }
 111
 112
 113
 114   private Position Add(Position rhs) {
 115     Position ret = new Position(NDalicPINVOKE.Vector3_Add(swigCPtr, Position.getCPtr(rhs)), true);
 116     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 117     return ret;
 118   }
 119
 120   private Position Subtract(Position rhs) {
 121     Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 122     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 123     return ret;
 124   }
 125
 126   private Position Multiply(Position rhs) {
 127     Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 128     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 129     return ret;
 130   }
 131
 132   private Position Multiply(float rhs) {
 133     Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_1(swigCPtr, rhs), true);
 134     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 135     return ret;
 136   }
 137
 138   private Position Divide(Position rhs) {
 139     Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
 140     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 141     return ret;
 142   }
 143
 144   private Position Divide(float rhs) {
 145     Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_1(swigCPtr, rhs), true);
 146     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 147     return ret;
 148   }
 149
 150   private Position Subtract() {
 151     Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_1(swigCPtr), true);
 152     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 153     return ret;
 154   }
 155
 156   private float ValueOfIndex(uint index) {
 157     float ret = NDalicPINVOKE.Vector3_ValueOfIndex__SWIG_0(swigCPtr, index);
 158     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 159     return ret;
 160   }
 161
 162   public bool EqualTo(Position rhs) {
 163     bool ret = NDalicPINVOKE.Vector3_EqualTo(swigCPtr, Position.getCPtr(rhs));
 164     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 165     return ret;
 166   }
 167
 168   public bool NotEqualTo(Position rhs) {
 169     bool ret = NDalicPINVOKE.Vector3_NotEqualTo(swigCPtr, Position.getCPtr(rhs));
 170     if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 171     return ret;
 172   }
 173
 174
 175   public float X {
 176     set {
 177       NDalicPINVOKE.Vector3_X_set(swigCPtr, value);
 178       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 179     }
 180     get {
 181       float ret = NDalicPINVOKE.Vector3_X_get(swigCPtr);
 182       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 183       return ret;
 184     }
 185   }
 186
 187   public float Y {
 188     set {
 189       NDalicPINVOKE.Vector3_Y_set(swigCPtr, value);
 190       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 191     }
 192     get {
 193       float ret = NDalicPINVOKE.Vector3_Y_get(swigCPtr);
 194       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 195       return ret;
 196     }
 197   }
 198
 199   public float Z {
 200     set {
 201       NDalicPINVOKE.Vector3_Z_set(swigCPtr, value);
 202       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 203     }
 204     get {
 205       float ret = NDalicPINVOKE.Vector3_Z_get(swigCPtr);
 206       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 207       return ret;
 208     }
 209   }
 210
 211   internal static float ParentOriginTop
 212   {
 213       get
 214       {
 215           float ret = NDalicPINVOKE.ParentOriginTop_get();
 216           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 217           return ret;
 218       }
 219   }
 220
 221   internal static float ParentOriginBottom
 222   {
 223       get
 224       {
 225           float ret = NDalicPINVOKE.ParentOriginBottom_get();
 226           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 227           return ret;
 228       }
 229   }
 230
 231   internal static float ParentOriginLeft
 232   {
 233       get
 234       {
 235           float ret = NDalicPINVOKE.ParentOriginLeft_get();
 236           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 237           return ret;
 238       }
 239   }
 240
 241   internal static float ParentOriginRight
 242   {
 243       get
 244       {
 245           float ret = NDalicPINVOKE.ParentOriginRight_get();
 246           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 247           return ret;
 248       }
 249   }
 250
 251   internal static float ParentOriginMiddle
 252   {
 253       get
 254       {
 255           float ret = NDalicPINVOKE.ParentOriginMiddle_get();
 256           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 257           return ret;
 258       }
 259   }
 260
 261   internal static Position ParentOriginTopLeft
 262   {
 263       get
 264       {
 265           global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopLeft_get();
 266           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 267           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 268           return ret;
 269       }
 270   }
 271
 272   internal static Position ParentOriginTopCenter
 273   {
 274       get
 275       {
 276           global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopCenter_get();
 277           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 278           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 279           return ret;
 280       }
 281   }
 282
 283   internal static Position ParentOriginTopRight
 284   {
 285       get
 286       {
 287           global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopRight_get();
 288           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 289           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 290           return ret;
 291       }
 292   }
 293
 294   internal static Position ParentOriginCenterLeft
 295   {
 296       get
 297       {
 298           global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterLeft_get();
 299           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 300           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 301           return ret;
 302       }
 303   }
 304
 305   internal static Position ParentOriginCenter
 306   {
 307       get
 308       {
 309           global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenter_get();
 310           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 311           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 312           return ret;
 313       }
 314   }
 315
 316   internal static Position ParentOriginCenterRight
 317   {
 318       get
 319       {
 320           global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterRight_get();
 321           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 322           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 323           return ret;
 324       }
 325   }
 326
 327   internal static Position ParentOriginBottomLeft
 328   {
 329       get
 330       {
 331           global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomLeft_get();
 332           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 333           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 334           return ret;
 335       }
 336   }
 337
 338   internal static Position ParentOriginBottomCenter
 339   {
 340       get
 341       {
 342           global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomCenter_get();
 343           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 344           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 345           return ret;
 346       }
 347   }
 348
 349   internal static Position ParentOriginBottomRight
 350   {
 351       get
 352       {
 353           global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomRight_get();
 354           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 355           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 356           return ret;
 357       }
 358   }
 359
 360   internal static float AnchorPointTop
 361   {
 362       get
 363       {
 364           float ret = NDalicPINVOKE.AnchorPointTop_get();
 365           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 366           return ret;
 367       }
 368   }
 369
 370   internal static float AnchorPointBottom
 371   {
 372       get
 373       {
 374           float ret = NDalicPINVOKE.AnchorPointBottom_get();
 375           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 376           return ret;
 377       }
 378   }
 379
 380   internal static float AnchorPointLeft
 381   {
 382       get
 383       {
 384           float ret = NDalicPINVOKE.AnchorPointLeft_get();
 385           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 386           return ret;
 387       }
 388   }
 389
 390   internal static float AnchorPointRight
 391   {
 392       get
 393       {
 394           float ret = NDalicPINVOKE.AnchorPointRight_get();
 395           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 396           return ret;
 397       }
 398   }
 399
 400   internal static float AnchorPointMiddle
 401   {
 402       get
 403       {
 404           float ret = NDalicPINVOKE.AnchorPointMiddle_get();
 405           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 406           return ret;
 407       }
 408   }
 409
 410   internal static Position AnchorPointTopLeft
 411   {
 412       get
 413       {
 414           global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopLeft_get();
 415           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 416           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 417           return ret;
 418       }
 419   }
 420
 421   internal static Position AnchorPointTopCenter
 422   {
 423       get
 424       {
 425           global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopCenter_get();
 426           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 427           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 428           return ret;
 429       }
 430   }
 431
 432   internal static Position AnchorPointTopRight
 433   {
 434       get
 435       {
 436           global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopRight_get();
 437           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 438           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 439           return ret;
 440       }
 441   }
 442
 443   internal static Position AnchorPointCenterLeft
 444   {
 445       get
 446       {
 447           global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterLeft_get();
 448           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 449           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 450           return ret;
 451       }
 452   }
 453
 454   internal static Position AnchorPointCenter
 455   {
 456       get
 457       {
 458           global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenter_get();
 459           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 460           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 461           return ret;
 462       }
 463   }
 464
 465   internal static Position AnchorPointCenterRight
 466   {
 467       get
 468       {
 469           global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterRight_get();
 470           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 471           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 472           return ret;
 473       }
 474   }
 475
 476   internal static Position AnchorPointBottomLeft
 477   {
 478       get
 479       {
 480           global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomLeft_get();
 481           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 482           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 483           return ret;
 484       }
 485   }
 486
 487   internal static Position AnchorPointBottomCenter
 488   {
 489       get
 490       {
 491           global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomCenter_get();
 492           Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 493           if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 494           return ret;
 495       }
 496   }
 497
 498   internal static Position AnchorPointBottomRight
 499   {
 500       get
 501       {
 502           global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomRight_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   public static Position One {
 510     get {
 511       global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ONE_get();
 512       Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 513       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 514       return ret;
 515     }
 516   }
 517
 518   internal static Position XAxis {
 519     get {
 520       global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_XAXIS_get();
 521       Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 522       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 523       return ret;
 524     }
 525   }
 526
 527   internal static Position YAxis {
 528     get {
 529       global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_YAXIS_get();
 530       Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 531       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 532       return ret;
 533     }
 534   }
 535
 536   internal static Position ZAxis {
 537     get {
 538       global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZAXIS_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   internal static Position NegativeXAxis {
 546     get {
 547       global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_XAXIS_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   internal static Position NegativeYAxis {
 555     get {
 556       global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_YAXIS_get();
 557       Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 558       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 559       return ret;
 560     }
 561   }
 562
 563   internal static Position NegativeZAxis {
 564     get {
 565       global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_ZAXIS_get();
 566       Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 567       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 568       return ret;
 569     }
 570   }
 571
 572   public static Position Zero {
 573     get {
 574       global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZERO_get();
 575       Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
 576       if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 577       return ret;
 578     }
 579   }
 580
 581   public static implicit operator Vector3(Position Position)
 582   {
 583     return new Vector3(Position.X, Position.Y, Position.Z);
 584   }
 585
 586   public static implicit operator Position(Vector3 vec)
 587   {
 588     return new Position(vec.X, vec.Y, vec.Z);
 589   }
 590
 591 }
 592
 593   public struct ParentOrigin
 594   {
 595       public static readonly float Top = Position.ParentOriginTop;
 596       public static readonly float Bottom = Position.ParentOriginBottom;
 597       public static readonly float Left = Position.ParentOriginLeft;
 598       public static readonly float Right = Position.ParentOriginRight;
 599       public static readonly float Middle = Position.ParentOriginMiddle;
 600       public static readonly Position TopLeft = Position.ParentOriginTopLeft;
 601       public static readonly Position TopCenter = Position.ParentOriginTopCenter;
 602       public static readonly Position TopRight = Position.ParentOriginTopRight;
 603       public static readonly Position CenterLeft = Position.ParentOriginCenterLeft;
 604       public static readonly Position Center = Position.ParentOriginCenter;
 605       public static readonly Position CenterRight = Position.ParentOriginCenterRight;
 606       public static readonly Position BottomLeft = Position.ParentOriginBottomLeft;
 607       public static readonly Position BottomCenter = Position.ParentOriginBottomCenter;
 608       public static readonly Position BottomRight = Position.ParentOriginBottomRight;
 609   }
 610   public struct AnchorPoint
 611   {
 612       public static readonly float Top = Position.AnchorPointTop;
 613       public static readonly float Bottom = Position.AnchorPointBottom;
 614       public static readonly float Left = Position.AnchorPointLeft;
 615       public static readonly float Right = Position.AnchorPointRight;
 616       public static readonly float Middle = Position.AnchorPointMiddle;
 617       public static readonly Position TopLeft = Position.AnchorPointTopLeft;
 618       public static readonly Position TopCenter = Position.AnchorPointTopCenter;
 619       public static readonly Position TopRight = Position.AnchorPointTopRight;
 620       public static readonly Position CenterLeft = Position.AnchorPointCenterLeft;
 621       public static readonly Position Center = Position.AnchorPointCenter;
 622       public static readonly Position CenterRight = Position.AnchorPointCenterRight;
 623       public static readonly Position BottomLeft = Position.AnchorPointBottomLeft;
 624       public static readonly Position BottomCenter = Position.AnchorPointBottomCenter;
 625       public static readonly Position BottomRight = Position.AnchorPointBottomRight;
 626   }
 627   public struct PositionAxis
 628   {
 629       public static readonly Position X = Position.XAxis;
 630       public static readonly Position Y = Position.YAxis;
 631       public static readonly Position Z = Position.ZAxis;
 632       public static readonly Position NegativeX = Position.NegativeXAxis;
 633       public static readonly Position NegativeY = Position.NegativeYAxis;
 634       public static readonly Position NegativeZ = Position.NegativeZAxis;
 635   }
 636
 637 }
 638
 639