+/*
+ * Copyright (c) 2017 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
namespace Dali {
- namespace CSharp {
- using System;
- public class Position
+public class Position : global::System.IDisposable {
+ private global::System.Runtime.InteropServices.HandleRef swigCPtr;
+ protected bool swigCMemOwn;
+
+ internal Position(global::System.IntPtr cPtr, bool cMemoryOwn) {
+ swigCMemOwn = cMemoryOwn;
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
+ }
+
+ internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Position obj) {
+ return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
+ }
+
+ ~Position() {
+ DisposeQueue.Instance.Add(this);
+ }
+
+ public virtual void Dispose() {
+ if (!Stage.IsInstalled()) {
+ DisposeQueue.Instance.Add(this);
+ return;
+ }
+
+ lock(this) {
+ if (swigCPtr.Handle != global::System.IntPtr.Zero) {
+ if (swigCMemOwn) {
+ swigCMemOwn = false;
+ NDalicPINVOKE.delete_Vector3(swigCPtr);
+ }
+ swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+ }
+ global::System.GC.SuppressFinalize(this);
+ }
+ }
+
+
+ public static Position operator+(Position arg1, Position arg2) {
+ return arg1.Add(arg2);
+ }
+
+ public static Position operator-(Position arg1, Position arg2) {
+ return arg1.Subtract(arg2);
+ }
+
+ public static Position operator-(Position arg1) {
+ return arg1.Subtract();
+ }
+
+ public static Position operator*(Position arg1, Position arg2) {
+ return arg1.Multiply(arg2);
+ }
+
+ public static Position operator*(Position arg1, float arg2) {
+ return arg1.Multiply(arg2);
+ }
+
+ public static Position operator/(Position arg1, Position arg2) {
+ return arg1.Divide(arg2);
+ }
+
+ public static Position operator/(Position arg1, float arg2) {
+ return arg1.Divide(arg2);
+ }
+
+
+ public float this[uint index]
+ {
+ get
{
- public float[] v;
+ return ValueOfIndex(index);
+ }
+ }
+
+ public static Position GetPositionFromPtr(global::System.IntPtr cPtr) {
+ Position ret = new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+
+ public Position() : this(NDalicPINVOKE.new_Vector3__SWIG_0(), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Position(float x, float y, float z) : this(NDalicPINVOKE.new_Vector3__SWIG_1(x, y, z), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+ public Position(Position2D position2d) : this(NDalicPINVOKE.new_Vector3__SWIG_3(Position2D.getCPtr(position2d)), true) {
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+
+
+
+ private Position Add(Position rhs) {
+ Position ret = new Position(NDalicPINVOKE.Vector3_Add(swigCPtr, Position.getCPtr(rhs)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ private Position Subtract(Position rhs) {
+ Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ private Position Multiply(Position rhs) {
+ Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ private Position Multiply(float rhs) {
+ Position ret = new Position(NDalicPINVOKE.Vector3_Multiply__SWIG_1(swigCPtr, rhs), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ private Position Divide(Position rhs) {
+ Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_0(swigCPtr, Position.getCPtr(rhs)), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ private Position Divide(float rhs) {
+ Position ret = new Position(NDalicPINVOKE.Vector3_Divide__SWIG_1(swigCPtr, rhs), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ private Position Subtract() {
+ Position ret = new Position(NDalicPINVOKE.Vector3_Subtract__SWIG_1(swigCPtr), true);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ private float ValueOfIndex(uint index) {
+ float ret = NDalicPINVOKE.Vector3_ValueOfIndex__SWIG_0(swigCPtr, index);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public bool EqualTo(Position rhs) {
+ bool ret = NDalicPINVOKE.Vector3_EqualTo(swigCPtr, Position.getCPtr(rhs));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ public bool NotEqualTo(Position rhs) {
+ bool ret = NDalicPINVOKE.Vector3_NotEqualTo(swigCPtr, Position.getCPtr(rhs));
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
- /**
- * @brief default constructor
- *
- * @since 1.0.0
- */
- public Position()
+ public float X {
+ set {
+ NDalicPINVOKE.Vector3_X_set(swigCPtr, value);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ get {
+ float ret = NDalicPINVOKE.Vector3_X_get(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ public float Y {
+ set {
+ NDalicPINVOKE.Vector3_Y_set(swigCPtr, value);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ get {
+ float ret = NDalicPINVOKE.Vector3_Y_get(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ public float Z {
+ set {
+ NDalicPINVOKE.Vector3_Z_set(swigCPtr, value);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ }
+ get {
+ float ret = NDalicPINVOKE.Vector3_Z_get(swigCPtr);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static float ParentOriginTop
+ {
+ get
{
- v = new float[3];
+ float ret = NDalicPINVOKE.ParentOriginTop_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- /**
- * @brief constructor
- *
- * @since 1.0.0
- * @param [in] a The Position X.
- * @param [in] b The Position Y.
- * @param [in] c The Position Z.
- */
- public Position(float a, float b, float c):this()
+ internal static float ParentOriginBottom
+ {
+ get
{
- v[0] = a;
- v[1] = b;
- v[2] = c;
+ float ret = NDalicPINVOKE.ParentOriginBottom_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- /**
- * @brief constructor
- *
- * @since 1.0.0
- * @param [in] o The Vector Position X, Y, Z.
- */
- public Position(Vector3 o)
- : this(o.x, o.y, o.z)
+ internal static float ParentOriginLeft
+ {
+ get
{
+ float ret = NDalicPINVOKE.ParentOriginLeft_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
+ internal static float ParentOriginRight
+ {
+ get
+ {
+ float ret = NDalicPINVOKE.ParentOriginRight_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
- ///< name "X", type float (Position X value)
- //@since 1.0.0
- public float X
+ internal static float ParentOriginMiddle
+ {
+ get
{
- get { return v[0]; }
- set { v[0] = value; }
+ float ret = NDalicPINVOKE.ParentOriginMiddle_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- ///< name "Y", type float (Position Y value)
- //@since 1.0.0
- public float Y
+ internal static Position ParentOriginTopLeft
+ {
+ get
{
- get { return v[1]; }
- set { v[1] = value; }
+ global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopLeft_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- ///< name "Z", type float (Position Z value)
- //@since 1.0.0
- public float Z
+ internal static Position ParentOriginTopCenter
+ {
+ get
{
- get { return v[2]; }
- set { v[2] = value; }
+ global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopCenter_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- /**
- * @brief operator+
- *
- * @since 1.0.0
- * @param [in] l The Position to add.
- * @param [in] r The Position to add
- * @return A reference to this
- */
- public static Position operator +(Position l, Position r)
+ internal static Position ParentOriginTopRight
+ {
+ get
{
- return new Position(l.X + r.X, l.Y + r.Y, l.Z + r.Z);
+ global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginTopRight_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- /**
- * @brief operator-
- *
- * @since 1.0.0
- * @param [in] l The Position to substract.
- * @param [in] r The Position to substract
- * @return A reference to this
- */
- public static Position operator -(Position l, Position r)
+ internal static Position ParentOriginCenterLeft
+ {
+ get
{
- return new Position(l.X - r.X, l.Y - r.Y, l.Z - r.Z);
+ global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterLeft_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- /**
- * @brief operator*
- *
- * @since 1.0.0
- * @param [in] a The Position to multiply.
- * @param [in] b The Position to multiply
- * @return A reference to this
- */
- public static Position operator *(Position a, double b)
+ internal static Position ParentOriginCenter
+ {
+ get
{
- return new Position((float)(a.X * b), (float)(a.Y * b), (float)(a.Z * b));
+ global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenter_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- /**
- * @brief operator/
- *
- * @since 1.0.0
- * @param [in] a The Position to divide.
- * @param [in] b The Position to divide
- * @return float value of division operation
- */
- public static float operator /(Position a, Position b)
+ internal static Position ParentOriginCenterRight
+ {
+ get
{
- return (float)System.Math.Sqrt((a.X / b.X) * (a.Y / b.Y) * (a.Z / b.Z));
+ global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginCenterRight_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- /**
- * @brief Equals
- *
- * @since 1.0.0
- * @param [in] o The Position object to compare.
- * @return bool, whether object equal or not
- */
- public override bool Equals(object obj)
+ internal static Position ParentOriginBottomLeft
+ {
+ get
{
- Position r = obj as Position;
- if (r == null)
- {
- return false;
- }
- return this.X == r.X && this.Y == r.Y && this.Z == r.Z;
+ global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomLeft_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
- /**
- * @brief Clone
- *
- * @since 1.0.0
- * @return Position object
- */
- public Position Clone()
+ internal static Position ParentOriginBottomCenter
+ {
+ get
{
- Position copy = new Position(X, Y, Z);
- return copy;
+ global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomCenter_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
+ }
+
+ internal static Position ParentOriginBottomRight
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.ParentOriginBottomRight_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static float AnchorPointTop
+ {
+ get
+ {
+ float ret = NDalicPINVOKE.AnchorPointTop_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static float AnchorPointBottom
+ {
+ get
+ {
+ float ret = NDalicPINVOKE.AnchorPointBottom_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static float AnchorPointLeft
+ {
+ get
+ {
+ float ret = NDalicPINVOKE.AnchorPointLeft_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static float AnchorPointRight
+ {
+ get
+ {
+ float ret = NDalicPINVOKE.AnchorPointRight_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static float AnchorPointMiddle
+ {
+ get
+ {
+ float ret = NDalicPINVOKE.AnchorPointMiddle_get();
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position AnchorPointTopLeft
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopLeft_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position AnchorPointTopCenter
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopCenter_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position AnchorPointTopRight
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointTopRight_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position AnchorPointCenterLeft
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterLeft_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position AnchorPointCenter
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenter_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position AnchorPointCenterRight
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointCenterRight_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position AnchorPointBottomLeft
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomLeft_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position AnchorPointBottomCenter
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomCenter_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position AnchorPointBottomRight
+ {
+ get
+ {
+ global::System.IntPtr cPtr = NDalicPINVOKE.AnchorPointBottomRight_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ public static Position One {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ONE_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position XAxis {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_XAXIS_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position YAxis {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_YAXIS_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position ZAxis {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZAXIS_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position NegativeXAxis {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_XAXIS_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position NegativeYAxis {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_YAXIS_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ internal static Position NegativeZAxis {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_NEGATIVE_ZAXIS_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+ }
+
+ public static Position Zero {
+ get {
+ global::System.IntPtr cPtr = NDalicPINVOKE.Vector3_ZERO_get();
+ Position ret = (cPtr == global::System.IntPtr.Zero) ? null : new Position(cPtr, false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
}
}
+ public static implicit operator Vector3(Position Position)
+ {
+ return new Vector3(Position.X, Position.Y, Position.Z);
+ }
+
+ public static implicit operator Position(Vector3 vec)
+ {
+ return new Position(vec.X, vec.Y, vec.Z);
+ }
+
}
+
+ public struct ParentOrigin
+ {
+ public static readonly float Top = Position.ParentOriginTop;
+ public static readonly float Bottom = Position.ParentOriginBottom;
+ public static readonly float Left = Position.ParentOriginLeft;
+ public static readonly float Right = Position.ParentOriginRight;
+ public static readonly float Middle = Position.ParentOriginMiddle;
+ public static readonly Position TopLeft = Position.ParentOriginTopLeft;
+ public static readonly Position TopCenter = Position.ParentOriginTopCenter;
+ public static readonly Position TopRight = Position.ParentOriginTopRight;
+ public static readonly Position CenterLeft = Position.ParentOriginCenterLeft;
+ public static readonly Position Center = Position.ParentOriginCenter;
+ public static readonly Position CenterRight = Position.ParentOriginCenterRight;
+ public static readonly Position BottomLeft = Position.ParentOriginBottomLeft;
+ public static readonly Position BottomCenter = Position.ParentOriginBottomCenter;
+ public static readonly Position BottomRight = Position.ParentOriginBottomRight;
+ }
+ public struct AnchorPoint
+ {
+ public static readonly float Top = Position.AnchorPointTop;
+ public static readonly float Bottom = Position.AnchorPointBottom;
+ public static readonly float Left = Position.AnchorPointLeft;
+ public static readonly float Right = Position.AnchorPointRight;
+ public static readonly float Middle = Position.AnchorPointMiddle;
+ public static readonly Position TopLeft = Position.AnchorPointTopLeft;
+ public static readonly Position TopCenter = Position.AnchorPointTopCenter;
+ public static readonly Position TopRight = Position.AnchorPointTopRight;
+ public static readonly Position CenterLeft = Position.AnchorPointCenterLeft;
+ public static readonly Position Center = Position.AnchorPointCenter;
+ public static readonly Position CenterRight = Position.AnchorPointCenterRight;
+ public static readonly Position BottomLeft = Position.AnchorPointBottomLeft;
+ public static readonly Position BottomCenter = Position.AnchorPointBottomCenter;
+ public static readonly Position BottomRight = Position.AnchorPointBottomRight;
+ }
+ public struct PositionAxis
+ {
+ public static readonly Position X = Position.XAxis;
+ public static readonly Position Y = Position.YAxis;
+ public static readonly Position Z = Position.ZAxis;
+ public static readonly Position NegativeX = Position.NegativeXAxis;
+ public static readonly Position NegativeY = Position.NegativeYAxis;
+ public static readonly Position NegativeZ = Position.NegativeZAxis;
+ }
+
+}
+
+
projects / platform / core / uifw / dali-toolkit.git / blobdiff