using System;
+ /// <summary>
+ /// Color Class
+ /// </summary>
public class Color : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
+ /// <summary>
+ /// Addition operator.
+ /// </summary>
public static Color operator +(Color arg1, Color arg2)
{
return arg1.Add(arg2);
}
+ /// <summary>
+ /// Subtraction operator.
+ /// </summary>
public static Color operator -(Color arg1, Color arg2)
{
return arg1.Subtract(arg2);
}
+ /// <summary>
+ /// Subtraction operator, void
+ /// </summary>
public static Color operator -(Color arg1)
{
return arg1.Subtract();
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
public static Color operator *(Color arg1, Color arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Multiplication operator, using float.
+ /// </summary>
public static Color operator *(Color arg1, float arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
public static Color operator /(Color arg1, Color arg2)
{
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Division operator, using float.
+ /// </summary>
public static Color operator /(Color arg1, float arg2)
{
return arg1.Divide(arg2);
}
-
+ /// <summary>
+ /// Array subscript operator.
+ /// </summary>
public float this[uint index]
{
get
}
}
+ /// <summary>
+ /// GetColorFromPtr
+ /// </summary>
public static Color GetColorFromPtr(global::System.IntPtr cPtr)
{
Color ret = new Color(cPtr, false);
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
public Color() : this(NDalicPINVOKE.new_Vector4__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="r">The red component</param>
+ /// <param name="g">The green component</param>
+ /// <param name="b">The blue component</param>
+ /// <param name="a">The alpha component</param>
public Color(float r, float g, float b, float a) : this(NDalicPINVOKE.new_Vector4__SWIG_1(r, g, b, a), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="array">The array</param>
public Color(float[] array) : this(NDalicPINVOKE.new_Vector4__SWIG_2(array), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Add Color.
+ /// </summary>
+ /// <param name="rhs">A reference to the copied handle</param>
+ /// <returns>A reference to this</returns>
private Color Add(Color rhs)
{
Color ret = new Color(NDalicPINVOKE.Vector4_Add(swigCPtr, Color.getCPtr(rhs)), true);
return ret;
}
+ /// <summary>
+ /// Add assignment operator.
+ /// </summary>
+ /// <param name="rhs">A reference to the copied handle</param>
+ /// <returns>A reference to this</returns>
private Color AddAssign(Vector4 rhs)
{
Color ret = new Color(NDalicPINVOKE.Vector4_AddAssign(swigCPtr, Color.getCPtr(rhs)), false);
return ret;
}
+ /// <summary>
+ /// Assignment operator.
+ /// </summary>
+ /// <param name="rhs">A reference to the copied handle</param>
+ /// <returns>A reference to this</returns>
public bool EqualTo(Color rhs)
{
bool ret = NDalicPINVOKE.Vector4_EqualTo(swigCPtr, Color.getCPtr(rhs));
return ret;
}
+ /// <summary>
+ /// Assignment operator.
+ /// </summary>
+ /// <param name="rhs">A reference to the copied handle</param>
+ /// <returns>A reference to this</returns>
public bool NotEqualTo(Color rhs)
{
bool ret = NDalicPINVOKE.Vector4_NotEqualTo(swigCPtr, Color.getCPtr(rhs));
return ret;
}
+ /// <summary>
+ /// The red component
+ /// </summary>
public float R
{
set
}
}
+ /// <summary>
+ /// The Green Component.
+ /// </summary>
public float G
{
set
}
}
+ /// <summary>
+ /// The Blue Component.
+ /// </summary>
public float B
{
set
}
}
+ /// <summary>
+ /// The Alpha Component.
+ /// </summary>
public float A
{
set
}
}
+ /// <summary>
+ /// The Black Color.
+ /// </summary>
public static Color Black
{
get
}
}
+ /// <summary>
+ /// The White Color.
+ /// </summary>
public static Color White
{
get
}
}
+ /// <summary>
+ /// The Red Color.
+ /// </summary>
public static Color Red
{
get
}
}
+ /// <summary>
+ /// The Green Color.
+ /// </summary>
public static Color Green
{
get
}
}
+ /// <summary>
+ /// The Blue Color.
+ /// </summary>
public static Color Blue
{
get
}
}
+ /// <summary>
+ /// The Yellow Color.
+ /// </summary>
public static Color Yellow
{
get
}
}
+ /// <summary>
+ /// The Magenta Color.
+ /// </summary>
public static Color Magenta
{
get
}
}
+ /// <summary>
+ /// The Cyan Color.
+ /// </summary>
public static Color Cyan
{
get
}
}
+ /// <summary>
+ /// The Transparent Color.
+ /// </summary>
public static Color Transparent
{
get
{
}
}
+ /// <summary>
+ /// Enumeration for CustomViewBehaviour
+ /// </summary>
public enum CustomViewBehaviour
{
ViewBehaviourDefault = 0,
namespace Tizen.NUI
{
+ /// <summary>
+ /// A 3D parametric curve.
+ /// Paths can be used to animate position and orientation of actors.
+ /// </summary>
public class Path : Handle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
+ /// <summary>
+ /// Creates an initialized Path handle.
+ /// </summary>
public Path() : this(NDalicPINVOKE.Path_New(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Downcasts a handle to Path handle.
+ /// If handle points to a Path object, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized.
+ /// </summary>
+ /// <param name="handle">Handle to an object</param>
public new static Path DownCast(BaseHandle handle)
{
Path ret = new Path(NDalicPINVOKE.Path_DownCast(BaseHandle.getCPtr(handle)), true);
return ret;
}
+ /// <summary>
+ /// Adds an interpolation point.
+ /// </summary>
+ /// <param name="point">The new interpolation point to be added</param>
public void AddPoint(Position point)
{
NDalicPINVOKE.Path_AddPoint(swigCPtr, Position.getCPtr(point));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Adds a control point.
+ /// </summary>
+ /// <param name="point">The new control point to be added</param>
public void AddControlPoint(Vector3 point)
{
NDalicPINVOKE.Path_AddControlPoint(swigCPtr, Vector3.getCPtr(point));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Automatic generation of control points. Generated control points which result in a smooth join between the splines of each segment.
+ /// The generating algorithm is as follows:
+ /// For a given knot point K[N], find the vector that bisects K[N-1],[N] and [N],[N+1].
+ /// Calculate the tangent vector by taking the normal of this bisector.
+ /// The in control point is the length of the preceding segment back along this bisector multiplied by the curvature.
+ /// The out control point is the length of the succeeding segment forward along this bisector multiplied by the curvature.
+ /// </summary>
+ /// <param name="curvature">The curvature of the spline. 0 gives straight lines between the knots, negative values means the spline contains loops, positive values up to 0.5 result in a smooth curve, positive values between 0.5 and 1 result in looped curves where the loops are not distinct (i.e. the curve appears to be non-continuous), positive values higher than 1 result in looped curves</param>
public void GenerateControlPoints(float curvature)
{
NDalicPINVOKE.Path_GenerateControlPoints(swigCPtr, curvature);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Sample path at a given progress. Calculates position and tangent at that point of the curve.
+ /// </summary>
+ /// <param name="progress">A floating point value between 0.0 and 1.0</param>
+ /// <param name="position">The interpolated position at that progress</param>
+ /// <param name="tangent">The interpolated tangent at that progress</param>
public void Sample(float progress, Vector3 position, Vector3 tangent)
{
NDalicPINVOKE.Path_Sample(swigCPtr, progress, Vector3.getCPtr(position), Vector3.getCPtr(tangent));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Accessor for the interpolation points.
+ /// </summary>
+ /// <param name="index">The index of the interpolation point</param>
public Vector3 GetPoint(uint index)
{
Vector3 ret = new Vector3(NDalicPINVOKE.Path_GetPoint(swigCPtr, index), false);
return ret;
}
+ /// <summary>
+ /// Accessor for the control points.
+ /// </summary>
+ /// <param name="index">The index of the control point</param>
public Vector3 GetControlPoint(uint index)
{
Vector3 ret = new Vector3(NDalicPINVOKE.Path_GetControlPoint(swigCPtr, index), false);
return ret;
}
+ /// <summary>
+ /// Gets the number of interpolation points in the path.
+ /// </summary>
+ /// <returns>The number of interpolation points in the path</returns>
public uint GetPointCount()
{
uint ret = NDalicPINVOKE.Path_GetPointCount(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Enumeration for Points
+ /// </summary>
public PropertyArray Points
{
get
}
}
+ /// <summary>
+ /// Enumeration for ControlPoints
+ /// </summary>
public PropertyArray ControlPoints
{
get
namespace Tizen.NUI
{
+ /// <summary>
+ /// A PinchGesture is emitted when the user moves two fingers towards or away from each other.
+ /// A pinch gesture will continue to be sent to the actor under the center point of the pinch until the pinch ends.
+ /// </summary>
public class PinchGesture : Gesture
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
return ret;
}
+ /// <summary>
+ /// The scale factor from the start of the pinch gesture till the latest pinch gesture.
+ /// If the user is moving their fingers away from each other, then
+ /// this value increases. Conversely, if the user is moving their
+ /// fingers towards each other, this value will decrease.
+ /// </summary>
public float Scale
{
get
}
}
+ /// <summary>
+ /// The speed at which the user is moving their fingers.
+ /// This is the pixel movement per second.
+ /// </summary>
public float Speed
{
get
}
}
+ /// <summary>
+ /// The center point of the two points that caused the pinch gesture in screen coordinates.
+ /// </summary>
public Vector2 ScreenCenterPoint
{
get
}
}
+ /// <summary>
+ /// The center point of the two points that caused the pinch gesture in local actor coordinates.
+ /// </summary>
public Vector2 LocalCenterPoint
{
get
}
}
+ /// <summary>
+ /// Default Constructor.
+ /// </summary>
+ /// <param name="state">The state of the gesture</param>
public PinchGesture(Gesture.StateType state) : this(NDalicPINVOKE.new_PinchGesture__SWIG_0((int)state), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Copy constructor.
+ /// </summary>
+ /// <param name="rhs">A reference to the copied handle</param>
public PinchGesture(PinchGesture rhs) : this(NDalicPINVOKE.new_PinchGesture__SWIG_1(PinchGesture.getCPtr(rhs)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Assignment operator.
+ /// </summary>
+ /// <param name="rhs">A reference to the copied handle</param>
+ /// <returns>A reference to this</returns>
public PinchGesture Assign(PinchGesture rhs)
{
PinchGesture ret = new PinchGesture(NDalicPINVOKE.PinchGesture_Assign(swigCPtr, PinchGesture.getCPtr(rhs)), false);
projects / platform / core / csapi / tizenfx.git / commitdiff