Size, Position, Color high level class added
[platform/core/uifw/dali-toolkit.git] / plugins / dali-swig / manual / csharp / 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