Add tag and document to Tizen.NUI.
[platform/core/csapi/tizenfx.git] / src / Tizen.NUI / src / public / Position.cs
index 1b358f4..dccf09e 100755 (executable)
@@ -1,38 +1,28 @@
-// Copyright (c) 2016 Samsung Electronics Co., Ltd All Rights Reserved
-// PROPRIETARY/CONFIDENTIAL 
-// This software is the confidential and proprietary
-// information of SAMSUNG ELECTRONICS ("Confidential Information"). You shall
-// not disclose such Confidential Information and shall use it only in
-// accordance with the terms of the license agreement you entered into with
-// SAMSUNG ELECTRONICS. SAMSUNG make no representations or warranties about the
-// suitability of the software, either express or implied, including but not
-// limited to the implied warranties of merchantability, fitness for a
-// particular purpose, or non-infringement. SAMSUNG shall not be liable for any
-// damages suffered by licensee as a result of using, modifying or distributing
-// this software or its derivatives.
-
-// 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.
-//
-
-// This File has been auto-generated by SWIG and then modified using DALi Ruby Scripts
-// Some have been manually changed
+/*
+ * 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.
+ *
+ */
 
+using System;
 
 namespace Tizen.NUI
 {
 
+    /// <summary>
+    /// Position is a three-dimensional vector.
+    /// </summary>
     public class Position : global::System.IDisposable
     {
         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
@@ -49,51 +39,296 @@ namespace Tizen.NUI
             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
         }
 
+        //A Flag to check who called Dispose(). (By User or DisposeQueue)
+        private bool isDisposeQueued = false;
+        //A Flat to check if it is already disposed.
+        protected bool disposed = false;
+
         ~Position()
         {
-            DisposeQueue.Instance.Add(this);
+            if(!isDisposeQueued)
+            {
+                isDisposeQueued = true;
+                DisposeQueue.Instance.Add(this);
+            }
         }
 
-        public virtual void Dispose()
+        public void Dispose()
         {
-            if (!Stage.IsInstalled())
+            //Throw excpetion if Dispose() is called in separate thread.
+            if (!Window.IsInstalled())
+            {
+                throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
+            }
+
+            if (isDisposeQueued)
+            {
+                Dispose(DisposeTypes.Implicit);
+            }
+            else
+            {
+                Dispose(DisposeTypes.Explicit);
+                System.GC.SuppressFinalize(this);
+            }
+        }
+
+        protected virtual void Dispose(DisposeTypes type)
+        {
+            if (disposed)
             {
-                DisposeQueue.Instance.Add(this);
                 return;
             }
 
-            lock (this)
+            if(type == DisposeTypes.Explicit)
+            {
+                //Called by User
+                //Release your own managed resources here.
+                //You should release all of your own disposable objects here.
+            }
+
+            //Release your own unmanaged resources here.
+            //You should not access any managed member here except static instance.
+            //because the execution order of Finalizes is non-deterministic.
+
+            if (swigCPtr.Handle != global::System.IntPtr.Zero)
             {
-                if (swigCPtr.Handle != global::System.IntPtr.Zero)
+                if (swigCMemOwn)
                 {
-                    if (swigCMemOwn)
-                    {
-                        swigCMemOwn = false;
-                        NDalicPINVOKE.delete_Vector3(swigCPtr);
-                    }
-                    swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+                    swigCMemOwn = false;
+                    NDalicPINVOKE.delete_Vector3(swigCPtr);
                 }
-                global::System.GC.SuppressFinalize(this);
+                swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
+            }
+            disposed = true;
+        }
+
+
+        /// <summary>
+        /// An addition operator.
+        /// </summary>
+        /// <param name="arg1">The vector to add.</param>
+        /// <param name="arg2">The vector to add.</param>
+        /// <returns>The vector containing the result of the addition.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public static Position operator +(Position arg1, Position arg2)
+        {
+            return arg1.Add(arg2);
+        }
+
+        /// <summary>
+        /// The subtraction operator.
+        /// </summary>
+        /// <param name="arg1">The vector to subtract.</param>
+        /// <param name="arg2">The vector to subtract.</param>
+        /// <returns>The vector containing the result of the subtraction.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public static Position operator -(Position arg1, Position arg2)
+        {
+            return arg1.Subtract(arg2);
+        }
+
+        /// <summary>
+        /// The unary negation operator.
+        /// </summary>
+        /// <param name="arg1">The vector to negate.</param>
+        /// <returns>The vector containg the negation.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public static Position operator -(Position arg1)
+        {
+            return arg1.Subtract();
+        }
+
+        /// <summary>
+        /// The multiplication operator.
+        /// </summary>
+        /// <param name="arg1">The vector to multiply.</param>
+        /// <param name="arg2">The vector to multiply.</param>
+        /// <returns>The vector containing the result of the multiplication.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public static Position operator *(Position arg1, Position arg2)
+        {
+            return arg1.Multiply(arg2);
+        }
+
+        /// <summary>
+        /// The multiplication operator.
+        /// </summary>
+        /// <param name="arg1">The vector to multiply</param>
+        /// <param name="arg2">The float value to scale the vector.</param>
+        /// <returns>The vector containing the result of scaling.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public static Position operator *(Position arg1, float arg2)
+        {
+            return arg1.Multiply(arg2);
+        }
+
+        /// <summary>
+        /// The division operator.
+        /// </summary>
+        /// <param name="arg1">The vector to divide.</param>
+        /// <param name="arg2">The vector to divide.</param>
+        /// <returns>The vector containing the result of the division.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public static Position operator /(Position arg1, Position arg2)
+        {
+            return arg1.Divide(arg2);
+        }
+
+        /// <summary>
+        /// The division operator.
+        /// </summary>
+        /// <param name="arg1">The vector to divide.</param>
+        /// <param name="arg2">The float value to scale the vector by.</param>
+        /// <returns>The vector containing the result of scaling.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public static Position operator /(Position arg1, float arg2)
+        {
+            return arg1.Divide(arg2);
+        }
+
+
+        /// <summary>
+        /// The const array subscript operator overload. Should be 0, 1, or 2.
+        /// </summary>
+        /// <param name="index">The subscript index.</param>
+        /// <returns>The float at the given index.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public float this[uint index]
+        {
+            get
+            {
+                return ValueOfIndex(index);
             }
         }
 
-        internal static Position GetVector3FromPtr(global::System.IntPtr cPtr)
+        internal static Position GetPositionFromPtr(global::System.IntPtr cPtr)
         {
             Position ret = new Position(cPtr, false);
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
             return ret;
         }
 
+
+        /// <summary>
+        /// The constructor.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public Position() : this(NDalicPINVOKE.new_Vector3__SWIG_0(), true)
         {
             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
         }
 
+        /// <summary>
+        /// The constructor.
+        /// </summary>
+        /// <param name="x">The x component.</param>
+        /// <param name="y">The y component.</param>
+        /// <param name="z">The z component.</param>
+        /// <since_tizen> 3 </since_tizen>
         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();
         }
 
+        /// <summary>
+        /// The constructor.
+        /// </summary>
+        /// <param name="position2d">Position2D to create this vector from.</param>
+        /// <since_tizen> 3 </since_tizen>
+        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;
+        }
+
+        /// <summary>
+        /// Compares if rhs is equal to.
+        /// </summary>
+        /// <param name="rhs">The vector to compare.</param>
+        /// <returns>Returns true if the two vectors are equal, otherwise false.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public bool EqualTo(Position rhs)
+        {
+            bool ret = NDalicPINVOKE.Vector3_EqualTo(swigCPtr, Position.getCPtr(rhs));
+            if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+            return ret;
+        }
+
+        /// <summary>
+        /// Compares if rhs is not equal to.
+        /// </summary>
+        /// <param name="rhs">The vector to compare.</param>
+        /// <returns>Returns true if the two vectors are not equal, otherwise false.</returns>
+        /// <since_tizen> 3 </since_tizen>
+        public bool NotEqualTo(Position rhs)
+        {
+            bool ret = NDalicPINVOKE.Vector3_NotEqualTo(swigCPtr, Position.getCPtr(rhs));
+            if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+            return ret;
+        }
+
+
+        /// <summary>
+        /// The x component.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public float X
         {
             set
@@ -109,6 +344,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// The y component.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public float Y
         {
             set
@@ -124,6 +363,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// The z component.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public float Z
         {
             set
@@ -139,6 +382,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants. It's 0.0.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static float ParentOriginTop
         {
             get
@@ -149,6 +396,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants. It's 1.0.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static float ParentOriginBottom
         {
             get
@@ -159,6 +410,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants. It's 0.0.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static float ParentOriginLeft
         {
             get
@@ -169,6 +424,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants. It's 1.0.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static float ParentOriginRight
         {
             get
@@ -179,6 +438,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants. It's 0.5.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static float ParentOriginMiddle
         {
             get
@@ -189,6 +452,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants: 0.0, 0.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static Position ParentOriginTopLeft
         {
             get
@@ -200,6 +467,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants: 0.5, 0.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static Position ParentOriginTopCenter
         {
             get
@@ -211,6 +482,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants: 1.0, 0.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static Position ParentOriginTopRight
         {
             get
@@ -222,6 +497,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants: 0.0, 0.5, 0.5.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static Position ParentOriginCenterLeft
         {
             get
@@ -233,6 +512,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants: 0.0, 0.5, 0.5
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static Position ParentOriginCenter
         {
             get
@@ -244,6 +527,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants: 1.0, 0.5, 0.5.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static Position ParentOriginCenterRight
         {
             get
@@ -255,6 +542,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants: 0.0f, 1.0f, 0.5f.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static Position ParentOriginBottomLeft
         {
             get
@@ -266,6 +557,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants: 0.5, 1.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static Position ParentOriginBottomCenter
         {
             get
@@ -277,6 +572,10 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// ParentOrigin constants: 1.0, 1.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
         public static Position ParentOriginBottomRight
         {
             get
@@ -288,6 +587,327 @@ namespace Tizen.NUI
             }
         }
 
+        /// <summary>
+        /// PivotPoint constants: 0.0.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static float PivotPointTop
+        {
+            get
+            {
+                float ret = NDalicPINVOKE.AnchorPointTop_get();
+                if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                return ret;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 1.0.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static float PivotPointBottom
+        {
+            get
+            {
+                float ret = NDalicPINVOKE.AnchorPointBottom_get();
+                if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                return ret;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 0.0.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static float PivotPointLeft
+        {
+            get
+            {
+                float ret = NDalicPINVOKE.AnchorPointLeft_get();
+                if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                return ret;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 1.0.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static float PivotPointRight
+        {
+            get
+            {
+                float ret = NDalicPINVOKE.AnchorPointRight_get();
+                if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                return ret;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 0.0.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static float PivotPointMiddle
+        {
+            get
+            {
+                float ret = NDalicPINVOKE.AnchorPointMiddle_get();
+                if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+                return ret;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 0.0, 0.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static Position PivotPointTopLeft
+        {
+            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;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 0.5, 0.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static Position PivotPointTopCenter
+        {
+            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;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 1.0, 0.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static Position PivotPointTopRight
+        {
+            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;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 0.0, 0.5, 0.5.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static Position PivotPointCenterLeft
+        {
+            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;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 0.5, 0.5, 0.5.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static Position PivotPointCenter
+        {
+            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;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 1.0, 0.5, 0.5.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static Position PivotPointCenterRight
+        {
+            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;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 0.0, 1.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static Position PivotPointBottomLeft
+        {
+            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;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 0.5, 1.0, 0.5
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static Position PivotPointBottomCenter
+        {
+            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;
+            }
+        }
+
+        /// <summary>
+        /// PivotPoint constants: 1.0, 1.0, 0.5.
+        /// </summary>
+        /// <since_tizen> 4 </since_tizen>
+        public static Position PivotPointBottomRight
+        {
+            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;
+            }
+        }
+
+        /// <summary>
+        /// Constant ( 1.0f, 1.0f, 1.0f ).
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
+        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;
+            }
+        }
+
+        /// <summary>
+        /// Constant ( 0.0f, 0.0f, 0.0f ).
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
+        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;
+            }
+        }
+
+        /// <summary>
+        /// Converts a position instance to a Vector3 instance.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
+        public static implicit operator Vector3(Position Position)
+        {
+            return new Vector3(Position.X, Position.Y, Position.Z);
+        }
+
+        /// <summary>
+        /// Converts a Vector3 instance to a position instance.
+        /// </summary>
+        /// <since_tizen> 3 </since_tizen>
+        public static implicit operator Position(Vector3 vec)
+        {
+            return new Position(vec.X, vec.Y, vec.Z);
+        }
+
+
+        [Obsolete("Please do not use! this will be deprecated")]
         public static float AnchorPointTop
         {
             get
@@ -298,6 +918,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static float AnchorPointBottom
         {
             get
@@ -308,6 +929,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static float AnchorPointLeft
         {
             get
@@ -318,6 +940,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static float AnchorPointRight
         {
             get
@@ -328,6 +951,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static float AnchorPointMiddle
         {
             get
@@ -338,6 +962,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static Position AnchorPointTopLeft
         {
             get
@@ -349,6 +974,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static Position AnchorPointTopCenter
         {
             get
@@ -360,6 +986,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static Position AnchorPointTopRight
         {
             get
@@ -371,6 +998,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static Position AnchorPointCenterLeft
         {
             get
@@ -382,6 +1010,8 @@ namespace Tizen.NUI
             }
         }
 
+
+        [Obsolete("Please do not use! this will be deprecated")]
         public static Position AnchorPointCenter
         {
             get
@@ -393,6 +1023,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static Position AnchorPointCenterRight
         {
             get
@@ -404,6 +1035,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static Position AnchorPointBottomLeft
         {
             get
@@ -415,6 +1047,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static Position AnchorPointBottomCenter
         {
             get
@@ -426,6 +1059,7 @@ namespace Tizen.NUI
             }
         }
 
+        [Obsolete("Please do not use! this will be deprecated")]
         public static Position AnchorPointBottomRight
         {
             get
@@ -438,40 +1072,4 @@ namespace Tizen.NUI
         }
 
     }
-
-    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;
-    }
-
-}
+}
\ No newline at end of file