namespace Tizen.NUI
{
+ /// <summary>
+ /// A RadioButton provides a radio button which two states \e selected or \e unselected.
+ /// Radio buttons are designed to select one of many option at the same time.
+ /// RadioButton can change its current state using Selected.
+ ///
+ /// RadioButtons can be grouped.
+ /// Two or more RadioButtons are in one group when they have this same parent.
+ /// In each groups only one RadioButton can be \e selected at a given time.
+ /// So when RadioButton is set to \e selected, other RadioButtons in its group are set to \e unselected.
+ /// When \e selected RadioButton is set to \e unselected no other RadioButtons in his group is set to \e selected.
+ ///
+ /// A StateChanged Event is emitted when the RadioButton change its state to \e selected or \e unselected.
+ /// </summary>
public class RadioButton : Button
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
-
+ /// <summary>
+ /// Creates an uninitialized RadioButton
+ /// </summary>
public RadioButton() : this(NDalicPINVOKE.RadioButton_New__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+
+ /// <summary>
+ /// Creates an uninitialized RadioButton with Label
+ /// </summary>
+ /// <param name="label">Label text</param>
public RadioButton(string label) : this(NDalicPINVOKE.RadioButton_New__SWIG_1(label), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Downcasts a handle to RadioButton handle.
+ /// If handle points to a RadioButton, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized.
+ /// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>A handle to a RadioButton or an uninitialized handle</returns>
public new static RadioButton DownCast(BaseHandle handle)
{
RadioButton ret = new RadioButton(NDalicPINVOKE.RadioButton_DownCast(BaseHandle.getCPtr(handle)), true);
namespace Tizen.NUI
{
+ /// <summary>
+ /// Rectangle class
+ /// </summary>
public class Rectangle : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
-
+ /// <summary>
+ /// Equality operator.
+ /// </summary>
+ /// <param name="a">First operand</param>
+ /// <param name="b">Second operand</param>
+ /// <returns>True if boxes are exactly same</returns>
public static bool operator ==(Rectangle a, Rectangle b)
{
// If both are null, or both are same instance, return true.
return a.X == b.X && a.Y == b.Y && a.Width == b.Width && a.Height == b.Height;
}
+ /// <summary>
+ /// Inequality operator.
+ /// </summary>
+ /// <param name="a">The first rectangle</param>
+ /// <param name="b">The second rectangle</param>
+ /// <returns>True if rectangles are not identical</returns>
public static bool operator !=(Rectangle a, Rectangle b)
{
return !(a == b);
}
- ///< X position of the rectangle
+ /// <summary>
+ /// X position of the rectangle
+ /// </summary>
public int X
{
set
}
}
- ///< Y position of the rectangle
+ /// <summary>
+ /// Y position of the rectangle
+ /// </summary>
public int Y
{
set
}
}
- ///< Width of the rectangle
+ /// <summary>
+ /// Width of the rectangle
+ /// </summary>
public int Width
{
set
}
}
- ///< Height of the rectangle
+ /// <summary>
+ /// Height of the rectangle
+ /// </summary>
public int Height
{
set
}
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
public Rectangle() : this(NDalicPINVOKE.new_Rectangle__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="x">X coordinate (or left)</param>
+ /// <param name="y">Y coordinate (or right)</param>
+ /// <param name="width">Width (or bottom)</param>
+ /// <param name="height">Height (or top)</param>
public Rectangle(int x, int y, int width, int height) : this(NDalicPINVOKE.new_Rectangle__SWIG_1(x, y, width, height), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Copy constructor.
+ /// </summary>
+ /// <param name="rhs">The original object</param>
public Rectangle(Rectangle rhs) : this(NDalicPINVOKE.new_Rectangle__SWIG_2(Rectangle.getCPtr(rhs)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Make reference of original Rectangle object.
+ /// </summary>
+ /// <param name="rhs">The original object</param>
+ /// <returns>Reference to this</returns>
public Rectangle Assign(Rectangle rhs)
{
Rectangle ret = new Rectangle(NDalicPINVOKE.Rectangle_Assign(swigCPtr, Rectangle.getCPtr(rhs)), false);
return ret;
}
+ /// <summary>
+ /// Assignment from individual values.
+ /// </summary>
+ /// <param name="newX">X coordinate</param>
+ /// <param name="newY">Y coordinate</param>
+ /// <param name="newWidth">Width</param>
+ /// <param name="newHeight">Height</param>
public void Set(int newX, int newY, int newWidth, int newHeight)
{
NDalicPINVOKE.Rectangle_Set(swigCPtr, newX, newY, newWidth, newHeight);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Determines whether or not this Rectangle is empty.
+ /// </summary>
+ /// <returns>True if width or height are zero</returns>
public bool IsEmpty()
{
bool ret = NDalicPINVOKE.Rectangle_IsEmpty(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Gets the left of the rectangle.
+ /// </summary>
+ /// <returns>The left edge of the rectangle</returns>
public int Left()
{
int ret = NDalicPINVOKE.Rectangle_Left(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Gets the right of the rectangle.
+ /// </summary>
+ /// <returns>The right edge of the rectangle</returns>
public int Right()
{
int ret = NDalicPINVOKE.Rectangle_Right(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Gets the top of the rectangle.
+ /// </summary>
+ /// <returns>The top of the rectangle</returns>
public int Top()
{
int ret = NDalicPINVOKE.Rectangle_Top(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Gets the bottom of the rectangle.
+ /// </summary>
+ /// <returns>The bottom of the rectangle</returns>
public int Bottom()
{
int ret = NDalicPINVOKE.Rectangle_Bottom(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Gets the area of the rectangle.
+ /// </summary>
+ /// <returns>The area of the rectangle</returns>
public int Area()
{
int ret = NDalicPINVOKE.Rectangle_Area(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Determines whether or not this rectangle and the specified rectangle intersect.
+ /// </summary>
+ /// <param name="other">The other rectangle to test against this rectangle</param>
+ /// <returns>True if the rectangles intersect</returns>
public bool Intersects(Rectangle other)
{
bool ret = NDalicPINVOKE.Rectangle_Intersects(swigCPtr, Rectangle.getCPtr(other));
return ret;
}
+ /// <summary>
+ /// Determines whether or not this Rectangle contains the specified rectangle.
+ /// </summary>
+ /// <param name="other">The other rectangle to test against this rectangle</param>
+ /// <returns>True if the specified rectangle is contained</returns>
public bool Contains(Rectangle other)
{
bool ret = NDalicPINVOKE.Rectangle_Contains(swigCPtr, Rectangle.getCPtr(other));
namespace Tizen.NUI
{
+ /// <summary>
+ /// Interface to encapsulate information required for relayout.
+ /// </summary>
public class RelayoutContainer : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
namespace Tizen.NUI
{
+ /// <summary>
+ /// Rotation Class
+ /// </summary>
public class Rotation : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
-
+ /// <summary>
+ /// Addition operator.
+ /// </summary>
+ /// <param name="arg1">First Rotation</param>
+ /// <param name="arg2">Second Rotation</param>
+ /// <returns>A Rotation containing the result of the Addition</returns>
public static Rotation operator +(Rotation arg1, Rotation arg2)
{
return arg1.Add(arg2);
}
+ /// <summary>
+ /// Subtraction operator.
+ /// </summary>
+ /// <param name="arg1">First Rotation</param>
+ /// <param name="arg2">Second Rotation</param>
+ /// <returns>A Rotation containing the result of the subtract</returns>
public static Rotation operator -(Rotation arg1, Rotation arg2)
{
return arg1.Subtract(arg2);
}
+ /// <summary>
+ /// Unary Negation operator.
+ /// </summary>
+ /// <param name="arg1">First Rotation</param>
+ /// <returns>A Rotation containing the negated result</returns>
public static Rotation operator -(Rotation arg1)
{
return arg1.Subtract();
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">First Rotation</param>
+ /// <param name="arg2">Second Rotation</param>
+ /// <returns>A Rotation containing the result of the Multiplication</returns>
public static Rotation operator *(Rotation arg1, Rotation arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">Rotation</param>
+ /// <param name="arg2">The vector to multiply</param>
+ /// <returns>A Rotation containing the result of the multiplication</returns>
public static Vector3 operator *(Rotation arg1, Vector3 arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Scale operator.
+ /// </summary>
+ /// <param name="arg1">Rotation</param>
+ /// <param name="arg2">A value to scale by</param>
+ /// <returns>A Rotation containing the result of the scaling</returns>
public static Rotation operator *(Rotation arg1, float arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">First Rotation</param>
+ /// <param name="arg2">Second Rotation</param>
+ /// <returns>A Rotation containing the result of the scaling</returns>
public static Rotation operator /(Rotation arg1, Rotation arg2)
{
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Scale operator.
+ /// </summary>
+ /// <param name="arg1">Rotation</param>
+ /// <param name="arg2">A value to scale by</param>
+ /// <returns>A Rotation containing the result of the scaling</returns>
public static Rotation operator /(Rotation arg1, float arg2)
{
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Default Constructor.
+ /// </summary>
public Rotation() : this(NDalicPINVOKE.new_Rotation__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor from an axis and angle.
+ /// </summary>
+ /// <param name="angle">The angle around the axis</param>
+ /// <param name="axis">The vector of the axis</param>
public Rotation(Radian angle, Vector3 axis) : this(NDalicPINVOKE.new_Rotation__SWIG_1(Radian.getCPtr(angle), Vector3.getCPtr(axis)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// (0.0f,0.0f,0.0f,1.0f)
+ /// </summary>
public static Rotation IDENTITY
{
get
}
}
+ /// <summary>
+ /// Helper to check if this is an identity quaternion.
+ /// </summary>
+ /// <returns>True if this is identity quaternion</returns>
public bool IsIdentity()
{
bool ret = NDalicPINVOKE.Rotation_IsIdentity(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Converts the quaternion to an axis/angle pair.
+ /// </summary>
+ /// <param name="axis">the result of axis</param>
+ /// <param name="angle">the result of angle Angle in radians</param>
+ /// <returns>True if converted correctly</returns>
public bool GetAxisAngle(Vector3 axis, Radian angle)
{
bool ret = NDalicPINVOKE.Rotation_GetAxisAngle(swigCPtr, Vector3.getCPtr(axis), Radian.getCPtr(angle));
return ret;
}
+ /// <summary>
+ /// Returns the length of the rotation
+ /// </summary>
+ /// <returns>The length of the rotation</returns>
public float Length()
{
float ret = NDalicPINVOKE.Rotation_Length(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Returns the squared length of the rotation
+ /// </summary>
+ /// <returns>The squared length of the rotation</returns>
public float LengthSquared()
{
float ret = NDalicPINVOKE.Rotation_LengthSquared(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Normalizes this to unit length.
+ /// </summary>
public void Normalize()
{
NDalicPINVOKE.Rotation_Normalize(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Normalized.
+ /// </summary>
+ /// <returns>A normalized version of this rotation</returns>
public Rotation Normalized()
{
Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Normalized(swigCPtr), true);
return ret;
}
+ /// <summary>
+ /// Conjugates this rotation.
+ /// </summary>
public void Conjugate()
{
NDalicPINVOKE.Rotation_Conjugate(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Inverts this rotation.
+ /// </summary>
public void Invert()
{
NDalicPINVOKE.Rotation_Invert(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Performs the logarithm of a rotation
+ /// </summary>
+ /// <returns>A rotation representing the logarithm</returns>
public Rotation Log()
{
Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Log(swigCPtr), true);
return ret;
}
+ /// <summary>
+ /// Performs an exponent
+ /// </summary>
+ /// <returns>A rotation representing the exponent</returns>
public Rotation Exp()
{
Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Exp(swigCPtr), true);
return ret;
}
+ /// <summary>
+ /// Returns the dot product of two rotations.
+ /// </summary>
+ /// <param name="q1">The first rotation</param>
+ /// <param name="q2">The second rotation</param>
+ /// <returns>The dot product of the two rotations</returns>
public static float Dot(Rotation q1, Rotation q2)
{
float ret = NDalicPINVOKE.Rotation_Dot(Rotation.getCPtr(q1), Rotation.getCPtr(q2));
return ret;
}
+ /// <summary>
+ /// Linear Interpolation (using a straight line between the two rotations).
+ /// </summary>
+ /// <param name="q1">The start rotation</param>
+ /// <param name="q2">The end rotation</param>
+ /// <param name="t">A progress value between 0 and 1</param>
+ /// <returns>The interpolated rotation</returns>
public static Rotation Lerp(Rotation q1, Rotation q2, float t)
{
Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Lerp(Rotation.getCPtr(q1), Rotation.getCPtr(q2), t), true);
return ret;
}
+ /// <summary>
+ /// Spherical Linear Interpolation (using the shortest arc of a great circle between the two rotations).
+ /// </summary>
+ /// <param name="q1">The start rotation</param>
+ /// <param name="q2">The end rotation</param>
+ /// <param name="progress">A progress value between 0 and 1</param>
+ /// <returns>The interpolated rotation</returns>
public static Rotation Slerp(Rotation q1, Rotation q2, float progress)
{
Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Slerp(Rotation.getCPtr(q1), Rotation.getCPtr(q2), progress), true);
return ret;
}
+ /// <summary>
+ /// This version of Slerp, used by Squad, does not check for theta > 90.
+ /// </summary>
+ /// <param name="q1">The start rotation</param>
+ /// <param name="q2">The end rotation</param>
+ /// <param name="t">A progress value between 0 and 1</param>
+ /// <returns>The interpolated rotation</returns>
public static Rotation SlerpNoInvert(Rotation q1, Rotation q2, float t)
{
Rotation ret = new Rotation(NDalicPINVOKE.Rotation_SlerpNoInvert(Rotation.getCPtr(q1), Rotation.getCPtr(q2), t), true);
return ret;
}
+ /// <summary>
+ /// Spherical Cubic Interpolation.
+ /// </summary>
+ /// <param name="start">The start rotation</param>
+ /// <param name="end">The end rotation</param>
+ /// <param name="ctrl1">The control rotation for q1</param>
+ /// <param name="ctrl2">The control rotation for q2</param>
+ /// <param name="t">A progress value between 0 and 1</param>
+ /// <returns>The interpolated rotation</returns>
public static Rotation Squad(Rotation start, Rotation end, Rotation ctrl1, Rotation ctrl2, float t)
{
Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Squad(Rotation.getCPtr(start), Rotation.getCPtr(end), Rotation.getCPtr(ctrl1), Rotation.getCPtr(ctrl2), t), true);
return ret;
}
+ /// <summary>
+ /// Returns the shortest angle between two rotations in Radians.
+ /// </summary>
+ /// <param name="q1">The first rotation</param>
+ /// <param name="q2">The second rotation</param>
+ /// <returns>The angle between the two rotation</returns>
public static float AngleBetween(Rotation q1, Rotation q2)
{
float ret = NDalicPINVOKE.Rotation_AngleBetween(Rotation.getCPtr(q1), Rotation.getCPtr(q2));
using System;
using System.Runtime.InteropServices;
-
+ /// <summary>
+ /// ScrollBar is a UI component that can be linked to the scrollable objects
+ /// indicating the current scroll position of the scrollable object.
+ /// </summary>
public class ScrollBar : View
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
-
-
-
+ /// <summary>
+ /// Event arguments that passed via PanFinished event
+ /// </summary>
public class PanFinishedEventArgs : EventArgs
{
}
+ /// <summary>
+ /// Event arguments that passed via ScrollPositionIntervalReached event
+ /// </summary>
public class ScrollPositionIntervalReachedEventArgs : EventArgs
{
private float _currentScrollPosition;
+ /// <summary>
+ /// current scroll position of the scrollable content
+ /// </summary>
public float CurrentScrollPosition
{
get
private EventHandler<ScrollPositionIntervalReachedEventArgs> _scrollBarScrollPositionIntervalReachedEventHandler;
private ScrollPositionIntervalReachedEventCallbackDelegate _scrollBarScrollPositionIntervalReachedEventCallbackDelegate;
+ /// <summary>
+ /// Event emitted when panning is finished on the scroll indicator.
+ /// </summary>
public event EventHandler<PanFinishedEventArgs> PanFinished
{
add
}
+ /// <summary>
+ /// Event emitted when the current scroll position of the scrollable content
+ /// </summary>
public event EventHandler<ScrollPositionIntervalReachedEventArgs> ScrollPositionIntervalReached
{
add
}
+ /// <summary>
+ /// Creates an initialized ScrollBar.
+ /// </summary>
+ /// <param name="direction">The direction of scroll bar (either vertically or horizontally)</param>
public ScrollBar(ScrollBar.Direction direction) : this(NDalicPINVOKE.ScrollBar_New__SWIG_0((int)direction), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
}
+
+ /// <summary>
+ /// Creates an uninitialized ScrollBar
+ /// </summary>
public ScrollBar() : this(NDalicPINVOKE.ScrollBar_New__SWIG_1(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Downcasts a handle to ScrollBar handle.
+ /// If handle points to a ScrollBar, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized.
+ /// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>Handle to a ScrollBar or an uninitialized handle</returns>
public new static ScrollBar DownCast(BaseHandle handle)
{
ScrollBar ret = new ScrollBar(NDalicPINVOKE.ScrollBar_DownCast(BaseHandle.getCPtr(handle)), true);
PROPERTY_END_INDEX = View.PropertyRange.PROPERTY_START_INDEX + 1000
}
+ /// <summary>
+ /// Direction of scroll bar
+ /// </summary>
public enum Direction
{
Vertical = 0,
Horizontal
}
+ /// <summary>
+ /// Indicator height policy.
+ /// </summary>
public enum IndicatorHeightPolicyType
{
Variable = 0,
Fixed
}
+ /// <summary>
+ /// Direction of scroll bar
+ /// </summary>
public string ScrollDirection
{
get
SetProperty(ScrollBar.Property.SCROLL_DIRECTION, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// Indicator height policy.
+ /// </summary>
public string IndicatorHeightPolicy
{
get
SetProperty(ScrollBar.Property.INDICATOR_HEIGHT_POLICY, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// the fixed height of scroll indicator.
+ /// </summary>
public float IndicatorFixedHeight
{
get
SetProperty(ScrollBar.Property.INDICATOR_FIXED_HEIGHT, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// the duration in seconds for the scroll indicator to become fully visible.
+ /// </summary>
public float IndicatorShowDuration
{
get
SetProperty(ScrollBar.Property.INDICATOR_SHOW_DURATION, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// the duration in seconds for the scroll indicator to become fully invisible.
+ /// </summary>
public float IndicatorHideDuration
{
get
SetProperty(ScrollBar.Property.INDICATOR_HIDE_DURATION, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// the list of values to get notification when the current scroll position of the scrollable object goes above or below any of these values.
+ /// </summary>
public Tizen.NUI.PropertyArray ScrollPositionIntervals
{
get
SetProperty(ScrollBar.Property.SCROLL_POSITION_INTERVALS, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// The minimum height for a variable size indicator.
+ /// </summary>
public float IndicatorMinimumHeight
{
get
SetProperty(ScrollBar.Property.INDICATOR_MINIMUM_HEIGHT, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// The padding at the start of the indicator. For example, the top if scrollDirection is Vertical.
+ /// </summary>
public float IndicatorStartPadding
{
get
SetProperty(ScrollBar.Property.INDICATOR_START_PADDING, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// The padding at the end of the indicator. For example, the bottom if scrollDirection is Vertical.
+ /// </summary>
public float IndicatorEndPadding
{
get
using System;
using System.Runtime.InteropServices;
-
+ /// <summary>
+ /// Mechanism to issue simple periodic or one-shot events.
+ /// Timer is provided for application developers to be able to issue
+ /// simple periodic or one-shot events. Please note that timer
+ /// callback functions should return as soon as possible, because they
+ /// block the next SignalTick. Please note that timer signals are not
+ /// in sync with Dali's render timer.
+ /// This class is a handle class so it can be stack allocated and used
+ /// as a member.
+ /// </summary>
public class Timer : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
-
- /**
- * @brief Event arguments that passed via Tick signal
- *
- */
+ /// <summary>
+ /// Event arguments that passed via Tick event
+ /// </summary>
public class TickEventArgs : EventArgs
{
}
private EventHandlerWithReturnType<object, TickEventArgs, bool> _timerTickEventHandler;
private TickCallbackDelegate _timerTickCallbackDelegate;
- /**
- * @brief Event for Ticked signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of TickEventHandler-DaliEventHandlerWithReturnType<object,TickEventArgs,bool>)
- * provided by the user. Ticked signal is emitted after specified time interval.
- */
+ /// <summary>
+ /// brief Event for Ticked signal which can be used to subscribe/unsubscribe the event handler
+ /// (in the type of TickEventHandler-DaliEventHandlerWithReturnType<object,TickEventArgs,bool>)
+ /// provided by the user. Ticked signal is emitted after specified time interval.
+ /// </summary>
public event EventHandlerWithReturnType<object, TickEventArgs, bool> Tick
{
add
}
}
- // Callback for Timer Tick signal
private bool OnTick(IntPtr data)
{
TickEventArgs e = new TickEventArgs();
return false;
}
-
+ /// <summary>
+ /// Creates a tick Timer that emits periodic signal.
+ /// </summary>
+ /// <param name="millSec">Interval in milliseconds</param>
+ /// <returns>A new timer</returns>
public Timer(uint milliSec) : this(NDalicPINVOKE.Timer_New(milliSec), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Downcasts a handle to Timer handle.
+ /// </summary>
+ /// <param name="handle">handle to An object</param>
+ /// <returns>handle to a Timer object or an uninitialized handle</returns>
public static Timer DownCast(BaseHandle handle)
{
Timer ret = new Timer(NDalicPINVOKE.Timer_DownCast(BaseHandle.getCPtr(handle)), true);
return ret;
}
+ /// <summary>
+ /// Starts timer
+ /// In case a Timer is already running, its time is reset and timer is restarted.
+ /// </summary>
public void Start()
{
NDalicPINVOKE.Timer_Start(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Stops timer.
+ /// </summary>
public void Stop()
{
NDalicPINVOKE.Timer_Stop(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Sets a new interval on the timer and starts the timer.
+ /// Cancels the previous timer.
+ /// </summary>
+ /// <param name="milliSec">milliSec Interval in milliseconds</param>
internal void SetInterval(uint milliSec)
{
NDalicPINVOKE.Timer_SetInterval(swigCPtr, milliSec);
return ret;
}
+ /// <summary>
+ /// Tells whether timer is running.
+ /// </summary>
+ /// <returns>Whether Timer is started or not</returns>
public bool IsRunning()
{
bool ret = NDalicPINVOKE.Timer_IsRunning(swigCPtr);
namespace Tizen.NUI
{
-
+ /// <summary>
+ /// Touch events are a collection of points at a specific moment in time.
+ /// When a multi-touch event occurs, each point represents the points that are currently being
+ /// touched or the points where a touch has stopped.
+ /// </summary>
public class Touch : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
return ret;
}
+ /// <summary>
+ /// An uninitialized Touch instance.
+ /// Calling member functions with an uninitialized Touch handle is not allowed.
+ /// </summary>
public Touch() : this(NDalicPINVOKE.new_Touch__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Returns the time (in ms) that the touch event occurred.
+ /// </summary>
+ /// <returns>The time (in ms) that the touch event occurred</returns>
public uint GetTime()
{
uint ret = NDalicPINVOKE.Touch_GetTime(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Returns the total number of points in this TouchData.
+ /// </summary>
+ /// <returns>Total number of Points</returns>
public uint GetPointCount()
{
uint ret = NDalicPINVOKE.Touch_GetPointCount(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Returns the ID of the device used for the Point specified.
+ /// Each point has a unique device ID which specifies the device used for that
+ /// point. This is returned by this method.
+ /// If point is greater than GetPointCount() then this method will return -1.
+ /// </summary>
+ /// <param name="point">The point required</param>
+ /// <returns>The Device ID of this point</returns>
public int GetDeviceId(uint point)
{
int ret = NDalicPINVOKE.Touch_GetDeviceId(swigCPtr, point);
return ret;
}
+ /// <summary>
+ /// Retrieves the State of the point specified.
+ /// If point is greater than GetPointCount() then this method will return PointState.Finished.
+ /// </summary>
+ /// <param name="point">The point required</param>
+ /// <returns>The state of the point specified</returns>
public PointStateType GetState(uint point)
{
PointStateType ret = (PointStateType)NDalicPINVOKE.Touch_GetState(swigCPtr, point);
return ret;
}
+ /// <summary>
+ /// Retrieves the actor that was underneath the point specified.
+ /// If point is greater than GetPointCount() then this method will return an empty handle.
+ /// </summary>
+ /// <param name="point">The point required</param>
+ /// <returns>The actor that was underneath the point specified</returns>
public Actor GetHitActor(uint point)
{
Actor ret = new Actor(NDalicPINVOKE.Touch_GetHitActor(swigCPtr, point), true);
return ret;
}
+ /// <summary>
+ /// Retrieves the co-ordinates relative to the top-left of the hit-actor at the point specified.
+ /// The top-left of an actor is (0.0, 0.0, 0.5).
+ /// If you require the local coordinates of another actor (e.g the parent of the hit actor),
+ /// then you should use Actor::ScreenToLocal().
+ /// If point is greater than GetPointCount() then this method will return Vector2.Zero.
+ /// </summary>
+ /// <param name="point">The point required</param>
+ /// <returns>The co-ordinates relative to the top-left of the hit-actor of the point specified</returns>
public Vector2 GetLocalPosition(uint point)
{
Vector2 ret = new Vector2(NDalicPINVOKE.Touch_GetLocalPosition(swigCPtr, point), false);
return ret;
}
+ /// <summary>
+ /// Retrieves the co-ordinates relative to the top-left of the screen of the point specified.
+ /// If point is greater than GetPointCount() then this method will return Vector2.Zero.
+ /// </summary>
+ /// <param name="point">The point required</param>
+ /// <returns>The co-ordinates relative to the top-left of the screen of the point specified</returns>
public Vector2 GetScreenPosition(uint point)
{
Vector2 ret = new Vector2(NDalicPINVOKE.Touch_GetScreenPosition(swigCPtr, point), false);
return ret;
}
+ /// <summary>
+ /// Retrieves the radius of the press point.
+ /// This is the average of both the horizontal and vertical radii of the press point.
+ /// If point is greater than GetPointCount() then this method will return 0.0f.
+ /// </summary>
+ /// <param name="point">The point required</param>
+ /// <returns>The radius of the press point</returns>
public float GetRadius(uint point)
{
float ret = NDalicPINVOKE.Touch_GetRadius(swigCPtr, point);
return ret;
}
+ /// <summary>
+ /// Retrieves BOTH the horizontal and the vertical radii of the press point.
+ /// If point is greater than GetPointCount() then this method will return Vector2.Zero.
+ /// </summary>
+ /// <param name="point">The point required</param>
+ /// <returns>The horizontal and vertical radii of the press point</returns>
public Vector2 GetEllipseRadius(uint point)
{
Vector2 ret = new Vector2(NDalicPINVOKE.Touch_GetEllipseRadius(swigCPtr, point), false);
return ret;
}
+ /// <summary>
+ /// Retrieves the touch pressure.
+ /// The pressure range starts at 0.0f.
+ /// Normal pressure is defined as 1.0f.
+ /// A value between 0.0f and 1.0f means light pressure has been applied.
+ /// A value greater than 1.0f means more pressure than normal has been applied.
+ /// If point is greater than GetPointCount() then this method will return 1.0f.
+ /// </summary>
+ /// <param name="point">point The point required</param>
+ /// <returns>The touch pressure</returns>
public float GetPressure(uint point)
{
float ret = NDalicPINVOKE.Touch_GetPressure(swigCPtr, point);
}
+ /// <summary>
+ /// Enumeration for point state type.
+ /// </summary>
public enum PointStateType
{
Started,
namespace Tizen.NUI
{
+ /// <summary>
+ /// A two dimensional vector.
+ /// </summary>
public class Vector2 : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
-
+ /// <summary>
+ /// Addition operator.
+ /// </summary>
+ /// <param name="arg1">First value</param>
+ /// <param name="arg2">Second value</param>
+ /// <returns>A vector containing the result of the addition</returns>
public static Vector2 operator +(Vector2 arg1, Vector2 arg2)
{
return arg1.Add(arg2);
}
+ /// <summary>
+ /// Subtraction operator.
+ /// </summary>
+ /// <param name="arg1">First value</param>
+ /// <param name="arg2">Second value</param>
+ /// <returns>A vector containing the result of the subtraction</returns>
public static Vector2 operator -(Vector2 arg1, Vector2 arg2)
{
return arg1.Subtract(arg2);
}
+ /// <summary>
+ /// Unary negation operator.
+ /// </summary>
+ /// <param name="arg1">Target Value</param>
+ /// <returns>A vector containg the negation</returns>
public static Vector2 operator -(Vector2 arg1)
{
return arg1.Subtract();
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">Second Value</param>
+ /// <returns>A vector containing the result of the multiplication</returns>
public static Vector2 operator *(Vector2 arg1, Vector2 arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">The float value to scale the vector</param>
+ /// <returns>A vector containing the result of the scaling</returns>
public static Vector2 operator *(Vector2 arg1, float arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">Second Value</param>
+ /// <returns>A vector containing the result of the division</returns>
public static Vector2 operator /(Vector2 arg1, Vector2 arg2)
{
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">The float value to scale the vector by</param>
+ /// <returns>A vector containing the result of the scaling</returns>
public static Vector2 operator /(Vector2 arg1, float arg2)
{
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Array subscript operator overload.
+ /// </summary>
+ /// <param name="index">Subscript index</param>
+ /// <returns>The float at the given index</returns>
public float this[uint index]
{
get
return ret;
}
-
+ /// <summary>
+ /// Default constructor, initializes the vector to 0.
+ /// </summary>
public Vector2() : this(NDalicPINVOKE.new_Vector2__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="x">x or width component</param>
+ /// <param name="y">y or height component</param>
public Vector2(float x, float y) : this(NDalicPINVOKE.new_Vector2__SWIG_1(x, y), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Conversion constructor from an array of two floats.
+ /// </summary>
+ /// <param name="array">Array of xy</param>
public Vector2(float[] array) : this(NDalicPINVOKE.new_Vector2__SWIG_2(array), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="vec3">Vector3 to create this vector from</param>
public Vector2(Vector3 vec3) : this(NDalicPINVOKE.new_Vector2__SWIG_3(Vector3.getCPtr(vec3)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="vec4">Vector4 to create this vector from</param>
public Vector2(Vector4 vec4) : this(NDalicPINVOKE.new_Vector2__SWIG_4(Vector4.getCPtr(vec4)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// (1.0f,1.0f)
+ /// </summary>
public static Vector2 One
{
get
}
}
+ /// <summary>
+ /// Vector representing the X axis
+ /// </summary>
public static Vector2 XAxis
{
get
}
}
+ /// <summary>
+ /// Vector representing the Y axis
+ /// </summary>
public static Vector2 YAxis
{
get
}
}
+ /// <summary>
+ /// Vector representing the negative X axis
+ /// </summary>
public static Vector2 NegativeXAxis
{
get
}
}
+ /// <summary>
+ /// Vector representing the negative Y axis
+ /// </summary>
public static Vector2 NegativeYAxis
{
get
}
}
+ /// <summary>
+ /// (0.0f, 0.0f)
+ /// </summary>
public static Vector2 Zero
{
get
return ret;
}
+ /// <summary>
+ /// Returns the length of the vector.
+ /// </summary>
+ /// <returns>The length of the vector</returns>
public float Length()
{
float ret = NDalicPINVOKE.Vector2_Length(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Returns the length of the vector squared.
+ /// This is more efficient than Length() for threshold
+ /// testing as it avoids the use of a square root.
+ /// </summary>
+ /// <returns>The length of the vector squared</returns>
public float LengthSquared()
{
float ret = NDalicPINVOKE.Vector2_LengthSquared(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Sets the vector to be unit length, whilst maintaining its direction.
+ /// </summary>
public void Normalize()
{
NDalicPINVOKE.Vector2_Normalize(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Clamps the vector between minimum and maximum vectors.
+ /// </summary>
+ /// <param name="min">The minimum vector</param>
+ /// <param name="max">The maximum vector</param>
public void Clamp(Vector2 min, Vector2 max)
{
NDalicPINVOKE.Vector2_Clamp(swigCPtr, Vector2.getCPtr(min), Vector2.getCPtr(max));
return ret;
}
+ /// <summary>
+ /// x component
+ /// </summary>
public float X
{
set
}
}
+ /// <summary>
+ /// width
+ /// </summary>
public float Width
{
set
}
}
+ /// <summary>
+ /// y component
+ /// </summary>
public float Y
{
set
}
}
+ /// <summary>
+ /// height
+ /// </summary>
public float Height
{
set
namespace Tizen.NUI
{
+ /// <summary>
+ /// A three dimensional vector.
+ /// </summary>
public class Vector3 : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
-
+ /// <summary>
+ /// Addition operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">Second Value</param>
+ /// <returns>A vector containing the result of the addition</returns>
public static Vector3 operator +(Vector3 arg1, Vector3 arg2)
{
return arg1.Add(arg2);
}
+ /// <summary>
+ /// Subtraction operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">Second Value</param>
+ /// <returns>A vector containing the result of the subtraction</returns>
public static Vector3 operator -(Vector3 arg1, Vector3 arg2)
{
return arg1.Subtract(arg2);
}
+ /// <summary>
+ /// Unary negation operator.
+ /// </summary>
+ /// <param name="arg1">Target Value</param>
+ /// <returns>A vector containg the negation</returns>
public static Vector3 operator -(Vector3 arg1)
{
return arg1.Subtract();
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">Second Value</param>
+ /// <returns>A vector containing the result of the multiplication</returns>
public static Vector3 operator *(Vector3 arg1, Vector3 arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">The float value to scale the vector</param>
+ /// <returns>A vector containing the result of the scaling</returns>
public static Vector3 operator *(Vector3 arg1, float arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">Second Value</param>
+ /// <returns>A vector containing the result of the division</returns>
public static Vector3 operator /(Vector3 arg1, Vector3 arg2)
{
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">The float value to scale the vector by</param>
+ /// <returns>A vector containing the result of the scaling</returns>
public static Vector3 operator /(Vector3 arg1, float arg2)
{
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Array subscript operator overload.
+ /// </summary>
+ /// <param name="index">Subscript index</param>
+ /// <returns>The float at the given index</returns>
public float this[uint index]
{
get
return ret;
}
-
+ /// <summary>
+ /// Constructor.
+ /// </summary>
public Vector3() : this(NDalicPINVOKE.new_Vector3__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Default constructor, initializes the vector to 0.
+ /// </summary>
+ /// <param name="x">x (or width) component</param>
+ /// <param name="y">y (or height) component</param>
+ /// <param name="z">z (or depth) component</param>
public Vector3(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>
+ /// Conversion constructor from an array of three floats.
+ /// </summary>
+ /// <param name="array">Array of xyz</param>
public Vector3(float[] array) : this(NDalicPINVOKE.new_Vector3__SWIG_2(array), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="vec2">Vector2 to create this vector from</param>
public Vector3(Vector2 vec2) : this(NDalicPINVOKE.new_Vector3__SWIG_3(Vector2.getCPtr(vec2)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
+ /// <param name="vec4">Vector4 to create this vector from</param>
public Vector3(Vector4 vec4) : this(NDalicPINVOKE.new_Vector3__SWIG_4(Vector4.getCPtr(vec4)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// (1.0f,1.0f,1.0f)
+ /// </summary>
public static Vector3 One
{
get
}
}
+ /// <summary>
+ /// Vector representing the X axis
+ /// </summary>
public static Vector3 XAxis
{
get
}
}
+ /// <summary>
+ /// Vector representing the Y axis
+ /// </summary>
public static Vector3 YAxis
{
get
}
}
+ /// <summary>
+ /// Vector representing the Z axis
+ /// </summary>
public static Vector3 ZAxis
{
get
}
}
+ /// <summary>
+ /// Vector representing the negative X axis
+ /// </summary>
public static Vector3 NegativeXAxis
{
get
}
}
+ /// <summary>
+ /// Vector representing the negative Y axis
+ /// </summary>
public static Vector3 NegativeYAxis
{
get
}
}
+ /// <summary>
+ /// Vector representing the negative Z axis
+ /// </summary>
public static Vector3 NegativeZAxis
{
get
}
}
+ /// <summary>
+ /// (0.0f, 0.0f, 0.0f)
+ /// </summary>
public static Vector3 Zero
{
get
return ret;
}
+ /// <summary>
+ /// Returns the length of the vector.
+ /// </summary>
+ /// <returns>The length of the vector</returns>
public float Length()
{
float ret = NDalicPINVOKE.Vector3_Length(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Returns the length of the vector squared.
+ /// This is more efficient than Length() for threshold
+ /// testing as it avoids the use of a square root.
+ /// </summary>
+ /// <returns>The length of the vector squared</returns>
public float LengthSquared()
{
float ret = NDalicPINVOKE.Vector3_LengthSquared(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Sets the vector to be unit length, whilst maintaining its direction.
+ /// </summary>
public void Normalize()
{
NDalicPINVOKE.Vector3_Normalize(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Clamps the vector between minimum and maximum vectors.
+ /// </summary>
+ /// <param name="min">The minimum vector</param>
+ /// <param name="max">The maximum vector</param>
public void Clamp(Vector3 min, Vector3 max)
{
NDalicPINVOKE.Vector3_Clamp(swigCPtr, Vector3.getCPtr(min), Vector3.getCPtr(max));
return ret;
}
+ /// <summary>
+ /// Returns the x & y components (or width & height, or r & g) as a Vector2.
+ /// </summary>
+ /// <returns>The partial vector contents as Vector2 (x,y)</returns>
public Vector2 GetVectorXY()
{
Vector2 ret = new Vector2(NDalicPINVOKE.Vector3_GetVectorXY__SWIG_0(swigCPtr), false);
return ret;
}
+ /// <summary>
+ /// Returns the y & z components (or height & depth, or g & b) as a Vector2.
+ /// </summary>
+ /// <returns>The partial vector contents as Vector2 (y,z)</returns>
public Vector2 GetVectorYZ()
{
Vector2 ret = new Vector2(NDalicPINVOKE.Vector3_GetVectorYZ__SWIG_0(swigCPtr), false);
return ret;
}
+ /// <summary>
+ /// x component
+ /// </summary>
public float X
{
set
}
}
+ /// <summary>
+ /// width component
+ /// </summary>
public float Width
{
set
}
}
+ /// <summary>
+ /// red component
+ /// </summary>
public float R
{
set
}
}
+ /// <summary>
+ /// y component
+ /// </summary>
public float Y
{
set
}
}
+ /// <summary>
+ /// height component
+ /// </summary>
public float Height
{
set
}
}
+ /// <summary>
+ /// green component
+ /// </summary>
public float G
{
set
}
}
+ /// <summary>
+ /// z component
+ /// </summary>
public float Z
{
set
}
}
+ /// <summary>
+ /// depth component
+ /// </summary>
public float Depth
{
set
}
}
+ /// <summary>
+ /// blue component
+ /// </summary>
public float B
{
set
namespace Tizen.NUI
{
+ /// <summary>
+ /// A four dimensional vector.
+ /// </summary>
public class Vector4 : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
-
+ /// <summary>
+ /// Addition operator.
+ /// </summary>
+ /// <param name="arg1">First value</param>
+ /// <param name="arg2">Second value</param>
+ /// <returns>A vector containing the result of the addition</returns>
public static Vector4 operator +(Vector4 arg1, Vector4 arg2)
{
return arg1.Add(arg2);
}
+ /// <summary>
+ /// Subtraction operator.
+ /// </summary>
+ /// <param name="arg1">First value</param>
+ /// <param name="arg2">Second value</param>
+ /// <returns>A vector containing the result of the subtraction</returns>
public static Vector4 operator -(Vector4 arg1, Vector4 arg2)
{
return arg1.Subtract(arg2);
}
+ /// <summary>
+ /// Unary negation operator.
+ /// </summary>
+ /// <param name="arg1">Target Value</param>
+ /// <returns>A vector containg the negation</returns>
public static Vector4 operator -(Vector4 arg1)
{
return arg1.Subtract();
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">Second Value</param>
+ /// <returns>A vector containing the result of the multiplication</returns>
public static Vector4 operator *(Vector4 arg1, Vector4 arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">The float value to scale the vector</param>
+ /// <returns>A vector containing the result of the scaling</returns>
public static Vector4 operator *(Vector4 arg1, float arg2)
{
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">Second Value</param>
+ /// <returns>A vector containing the result of the division</returns>
public static Vector4 operator /(Vector4 arg1, Vector4 arg2)
{
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">First Value</param>
+ /// <param name="arg2">The float value to scale the vector by</param>
+ /// <returns>A vector containing the result of the scaling</returns>
public static Vector4 operator /(Vector4 arg1, float arg2)
{
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Array subscript operator overload.
+ /// </summary>
+ /// <param name="index">Subscript index</param>
+ /// <returns>The float at the given index</returns>
public float this[uint index]
{
get
return ret;
}
-
+ /// <summary>
+ /// Default constructor, initializes the vector to 0.
+ /// </summary>
public Vector4() : this(NDalicPINVOKE.new_Vector4__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Conversion constructor from four floats.
+ /// </summary>
+ /// <param name="x">x (or r/s) component</param>
+ /// <param name="y">y (or g/t) component</param>
+ /// <param name="z">z (or b/p) component</param>
+ /// <param name="w">w (or a/q) component</param>
public Vector4(float x, float y, float z, float w) : this(NDalicPINVOKE.new_Vector4__SWIG_1(x, y, z, w), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Conversion constructor from an array of four floats.
+ /// </summary>
+ /// <param name="array">array Array of either xyzw/rgba/stpq</param>
public Vector4(float[] array) : this(NDalicPINVOKE.new_Vector4__SWIG_2(array), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Conversion constructor from Vector2.
+ /// </summary>
+ /// <param name="vec2">Vector2 to copy from, z and w are initialized to 0</param>
public Vector4(Vector2 vec2) : this(NDalicPINVOKE.new_Vector4__SWIG_3(Vector2.getCPtr(vec2)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Conversion constructor from Vector3.
+ /// </summary>
+ /// <param name="vec3">Vector3 to copy from, w is initialized to 0</param>
public Vector4(Vector3 vec3) : this(NDalicPINVOKE.new_Vector4__SWIG_4(Vector3.getCPtr(vec3)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// (1.0f,1.0f,1.0f,1.0f)
+ /// </summary>
public static Vector4 One
{
get
}
}
+ /// <summary>
+ /// (1.0f,0.0f,0.0f,0.0f)
+ /// </summary>
public static Vector4 XAxis
{
get
}
}
+ /// <summary>
+ /// (0.0f,1.0f,0.0f,0.0f)
+ /// </summary>
public static Vector4 YAxis
{
get
}
}
+ /// <summary>
+ /// (0.0f,0.0f,1.0f,0.0f)
+ /// </summary>
public static Vector4 ZAxis
{
get
}
}
+ /// <summary>
+ /// (0.0f, 0.0f, 0.0f, 0.0f)
+ /// </summary>
public static Vector4 Zero
{
get
return ret;
}
+ /// <summary>
+ /// Returns the length of the vector.
+ /// </summary>
+ /// <returns>The length</returns>
public float Length()
{
float ret = NDalicPINVOKE.Vector4_Length(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Returns the length of the vector squared.
+ /// This is faster than using Length() when performing
+ /// threshold checks as it avoids use of the square root.
+ /// </summary>
+ /// <returns>The length of the vector squared</returns>
public float LengthSquared()
{
float ret = NDalicPINVOKE.Vector4_LengthSquared(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Normalizes the vector.
+ /// Sets the vector to unit length whilst maintaining its direction.
+ /// </summary>
public void Normalize()
{
NDalicPINVOKE.Vector4_Normalize(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Clamps the vector between minimum and maximum vectors.
+ /// </summary>
+ /// <param name="min">The minimum vector</param>
+ /// <param name="max">The maximum vector</param>
public void Clamp(Vector4 min, Vector4 max)
{
NDalicPINVOKE.Vector4_Clamp(swigCPtr, Vector4.getCPtr(min), Vector4.getCPtr(max));
return ret;
}
+ /// <summary>
+ /// x component
+ /// </summary>
public float X
{
set
}
}
+ /// <summary>
+ /// red component
+ /// </summary>
public float R
{
set
}
}
+ /// <summary>
+ /// s component
+ /// </summary>
public float S
{
set
}
}
+ /// <summary>
+ /// y component
+ /// </summary>
public float Y
{
set
}
}
+ /// <summary>
+ /// green component
+ /// </summary>
public float G
{
set
}
}
+ /// <summary>
+ /// t component
+ /// </summary>
public float T
{
set
}
}
+ /// <summary>
+ /// z component
+ /// </summary>
public float Z
{
set
}
}
+ /// <summary>
+ /// blue component
+ /// </summary>
public float B
{
set
}
}
+ /// <summary>
+ /// p component
+ /// </summary>
public float P
{
set
}
}
+ /// <summary>
+ /// w component
+ /// </summary>
public float W
{
set
}
}
+ /// <summary>
+ /// alpha component
+ /// </summary>
public float A
{
set
}
}
+ /// <summary>
+ /// q component
+ /// </summary>
public float Q
{
set
using System;
using System.Runtime.InteropServices;
-
+ /// <summary>
+ /// VideoView is a control for video playback and display.
+ /// </summary>
public class VideoView : View
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
-
-
- /**
- * @brief Event arguments that passed via Finished signal
- *
- */
+ /// <summary>
+ /// Event arguments that passed via Finished signal
+ /// </summary>
public class FinishedEventArgs : EventArgs
{
private VideoView _videoView;
- /**
- * @brief VideoView - VideoView is a control for video playback and display.
- *
- */
+ /// <summary>
+ /// The view for video playback and display.
+ /// </summary>
public VideoView VideoView
{
get
private EventHandler<FinishedEventArgs> _videoViewFinishedEventHandler;
private FinishedCallbackDelegate _videoViewFinishedCallbackDelegate;
- /**
- * @brief Event for Finished signal which can be used to subscribe/unsubscribe the event handler
- * (in the type of FinishedEventHandler-DaliEventHandler<object,FinishedEventArgs>) provided by the user.
- * Finished signal is emitted when a video playback have finished.
- */
+
+ /// <summary>
+ /// Event for Finished signal which can be used to subscribe/unsubscribe the event handler
+ /// (in the type of FinishedEventHandler-DaliEventHandler<object,FinishedEventArgs>) provided by the user.
+ /// Finished signal is emitted when a video playback have finished.
+ /// </summary>
public event EventHandler<FinishedEventArgs> Finished
{
add
}
+ /// <summary>
+ /// Creates an initialized VideoView.
+ /// </summary>
public VideoView() : this(NDalicPINVOKE.VideoView_New__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+
+ /// <summary>
+ /// Creates an initialized VideoView.
+ /// If the string is empty, VideoView will not display anything.
+ /// </summary>
+ /// <param name="url">The url of the video resource to display</param>
public VideoView(string url) : this(NDalicPINVOKE.VideoView_New__SWIG_1(url), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Downcasts a handle to VideoView handle.
+ /// If handle points to a VideoView, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized.
+ /// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>Handle to a VideoView or an uninitialized handle</returns>
public new static VideoView DownCast(BaseHandle handle)
{
VideoView ret = new VideoView(NDalicPINVOKE.VideoView_DownCast(BaseHandle.getCPtr(handle)), true);
return ret;
}
+ /// <summary>
+ /// Starts the video playback.
+ /// </summary>
public void Play()
{
NDalicPINVOKE.VideoView_Play(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Pauses the video playback.
+ /// </summary>
public void Pause()
{
NDalicPINVOKE.VideoView_Pause(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Stops the video playback.
+ /// </summary>
public void Stop()
{
NDalicPINVOKE.VideoView_Stop(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Seeks forward by the specified number of milliseconds.
+ /// </summary>
+ /// <param name="millisecond">The position for forward playback</param>
public void Forward(int millisecond)
{
NDalicPINVOKE.VideoView_Forward(swigCPtr, millisecond);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Seeks backward by the specified number of milliseconds.
+ /// </summary>
+ /// <param name="millisecond">The position for backward playback</param>
public void Backward(int millisecond)
{
NDalicPINVOKE.VideoView_Backward(swigCPtr, millisecond);
PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX
}
+ /// <summary>
+ /// video file url as string type or PropertyMap.
+ /// </summary>
public PropertyMap Video
{
get
SetProperty(VideoView.Property.VIDEO, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// looping status, true or false.
+ /// </summary>
public bool Looping
{
get
SetProperty(VideoView.Property.LOOPING, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// mute status, true or false.
+ /// </summary>
public bool Muted
{
get
SetProperty(VideoView.Property.MUTED, new Tizen.NUI.PropertyValue(value));
}
}
+
+ /// <summary>
+ /// left and right volume scalar as float type, PropertyMap with two values ( "left" and "right" ).
+ /// </summary>
public PropertyMap Volume
{
get
using System;
using System.Runtime.InteropServices;
-
+ /// <summary>
+ /// View is the base class for all views.
+ /// </summary>
public class View : CustomActor
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
+ /// <summary>
+ /// Describes the direction to move the keyboard focus towards.
+ /// </summary>
public enum FocusDirection
{
Left,
PageDown
}
-
+ /// <summary>
+ /// Creates a new instance of a View.
+ /// </summary>
public View() : this(NDalicPINVOKE.View_New(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Downcasts a handle to View handle.
+ /// If handle points to a View, the downcast produces valid handle.
+ /// If not, the returned handle is left uninitialized.
+ /// </summary>
+ /// <param name="handle">Handle to an object</param>
+ /// <returns>A handle to a View or an uninitialized handle</returns>
public new static View DownCast(BaseHandle handle)
{
View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true);
return ret;
}
+ /// <summary>
+ /// Downcasts a handle to class which inherit View handle.
+ /// </summary>
+ /// <typeparam name="T">Class which inherit View</typeparam>
+ /// <param name="actor">Actor to an object</param>
+ /// <returns>A object which inherit View</returns>
public static T DownCast<T>(Actor actor) where T : View
{
return (T)(ViewRegistry.GetViewFromActor(actor));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Quries whether the view has key input focus.
+ /// </summary>
+ /// <returns>true if this view has keyboard input focus</returns>
public bool HasKeyInputFocus()
{
bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Sets the name of the style to be applied to the view.
+ /// </summary>
+ /// <param name="styleName">A string matching a style described in a stylesheet</param>
public void SetStyleName(string styleName)
{
NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrieves the name of the style to be applied to the view (if any).
+ /// </summary>
+ /// <returns>A string matching a style, or an empty string</returns>
public string GetStyleName()
{
string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Clears the background.
+ /// </summary>
public void ClearBackground()
{
NDalicPINVOKE.View_ClearBackground(swigCPtr);
CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
}
+ /// <summary>
+ /// styleName, type string.
+ /// </summary>
public string StyleName
{
get
}
}
+ /// <summary>
+ /// mutually exclusive with BACKGROUND_IMAGE & BACKGROUND, type Vector4.
+ /// </summary>
public Color BackgroundColor
{
get
}
}
+ /// <summary>
+ /// mutually exclusive with BACKGROUND_COLOR & BACKGROUND, type Map.
+ /// </summary>
public string BackgroundImage
{
get
}
}
+ /// <summary>
+ /// mutually exclusive with BACKGROUND_COLOR & BACKGROUND_IMAGE, type Map or string for URL.
+ /// </summary>
public Tizen.NUI.PropertyMap Background
{
get
}
}
+ /// <summary>
+ /// The current state of the view.
+ /// </summary>
public string State
{
get
}
}
+ /// <summary>
+ /// The current sub state of the view.
+ /// </summary>
public string SubState
{
get
}
}
+ /// <summary>
+ /// Displays a tooltip
+ /// </summary>
public Tizen.NUI.PropertyMap Tooltip
{
get
}
}
+ /// <summary>
+ /// Displays a tooltip as Text
+ /// </summary>
public string TooltipText
{
set
}
}
+ /// <summary>
+ /// The top-left cell this child occupies, if not set, the first available cell is used
+ /// </summary>
public Vector2 CellIndex
{
get
}
}
+ /// <summary>
+ /// The number of rows this child occupies, if not set, default value is 1
+ /// </summary>
public float RowSpan
{
get
}
}
+ /// <summary>
+ /// The number of columns this child occupies, if not set, default value is 1
+ /// </summary>
public float ColumnSpan
{
get
}
}
+ /// <summary>
+ /// The horizontal alignment of this child inside the cells, if not set, default value is 'left'
+ /// </summary>
public string CellHorizontalAlignment
{
get
}
}
+ /// <summary>
+ /// The vertical alignment of this child inside the cells, if not set, default value is 'top'
+ /// </summary>
public string CellVerticalAlignment
{
get
}
}
- /**
- * @brief The left focusable view.
- * @note This will return NULL if not set.
- * This will also return NULL if the specified left focusable view is not on stage.
- *
- */
+ /// <summary>
+ /// The left focusable view.
+ /// This will return NULL if not set.
+ /// This will also return NULL if the specified left focusable view is not on stage.
+ /// </summary>
public View LeftFocusableView
{
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
}
}
- /**
- * @brief The right focusable view.
- * @note This will return NULL if not set.
- * This will also return NULL if the specified right focusable view is not on stage.
- *
- */
+ /// <summary>
+ /// The right focusable view.
+ /// This will return NULL if not set.
+ /// This will also return NULL if the specified right focusable view is not on stage.
+ /// </summary>
public View RightFocusableView
{
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
}
}
- /**
- * @brief The up focusable view.
- * @note This will return NULL if not set.
- * This will also return NULL if the specified up focusable view is not on stage.
- *
- */
+ /// <summary>
+ /// The up focusable view.
+ /// This will return NULL if not set.
+ /// This will also return NULL if the specified up focusable view is not on stage.
+ /// </summary>
public View UpFocusableView
{
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
}
}
- /**
- * @brief The down focusable view.
- * @note This will return NULL if not set.
- * This will also return NULL if the specified down focusable view is not on stage.
- *
- */
+ /// <summary>
+ /// The down focusable view.
+ /// This will return NULL if not set.
+ /// This will also return NULL if the specified down focusable view is not on stage.
+ /// </summary>
public View DownFocusableView
{
// As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
}
}
+ /// <summary>
+ /// whether the view should be focusable by keyboard navigation.
+ /// </summary>
public bool Focusable
{
set
namespace Tizen.NUI
{
+ /// <summary>
+ /// Sets whether the actor should be focusable by keyboard navigation.
+ /// Visuals reuse geometry, shader etc. across controls. They ensure that the renderer and texture sets exist only when control is on-stage.
+ /// Each visual also responds to actor size and color change, and provides clipping at the renderer level.
+ /// Note: The visual responds to the the Actor::COLOR by blending it with the 'Multiply' operator.
+ /// </summary>
public class VisualBase : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
+ /// <summary>
+ /// Create an empty Visual Handle
+ /// </summary>
public VisualBase() : this(NDalicPINVOKE.new_VisualBase__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// name of the visual
+ /// </summary>
public string Name
{
set
return ret;
}
+ /// <summary>
+ /// Sets the transform and the control size
+ /// </summary>
+ /// <param name="transform">A property map describing the transform</param>
+ /// <param name="controlSize">The size of the parent control for visuals that need to scale internally.</param>
public void SetTransformAndSize(PropertyMap transform, Vector2 controlSize)
{
NDalicPINVOKE.VisualBase_SetTransformAndSize(swigCPtr, PropertyMap.getCPtr(transform), Vector2.getCPtr(controlSize));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Returns the height for a given width.
+ /// </summary>
+ /// <param name="width">Width to use.</param>
+ /// <returns>The height based on the width.</returns>
public float GetHeightForWidth(float width)
{
float ret = NDalicPINVOKE.VisualBase_GetHeightForWidth(swigCPtr, width);
return ret;
}
+ /// <summary>
+ /// Returns the width for a given height.
+ /// </summary>
+ /// <param name="height">Height to use.</param>
+ /// <returns>The width based on the height.</returns>
public float GetWidthForHeight(float height)
{
float ret = NDalicPINVOKE.VisualBase_GetWidthForHeight(swigCPtr, height);
return ret;
}
+ /// <summary>
+ /// Return the natural size of the visual.
+ /// Deriving classes stipulate the natural size and by default a visual has a ZERO natural size.
+ /// A visual may not actually have a natural size until it has been placed on stage and acquired all it's resources.
+ /// </summary>
+ /// <param name="naturalSize">The visual's natural size</param>
public void GetNaturalSize(Size2D naturalSize)
{
NDalicPINVOKE.VisualBase_GetNaturalSize(swigCPtr, Size2D.getCPtr(naturalSize));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// the depth index of this visual.
+ /// </summary>
public float DepthIndex
{
set
return ret;
}
+ /// <summary>
+ /// Create the property map representing this visual.
+ /// </summary>
public PropertyMap Creation
{
set
namespace Tizen.NUI
{
+ /// <summary>
+ /// VisualFactory is a singleton object that provides and shares visuals between views
+ /// </summary>
public class VisualFactory : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
+ /// <summary>
+ /// Create or retrieve VisualFactory singleton.
+ /// </summary>
+ /// <returns>A handle to the VisualFactory control.</returns>
public static VisualFactory Get()
{
VisualFactory ret = new VisualFactory(NDalicPINVOKE.VisualFactory_Get(), true);
return ret;
}
+ /// <summary>
+ /// Request the visual
+ /// </summary>
+ /// <param name="propertyMap">The map contains the properties required by the visual. The content of the map determines the type of visual that will be returned.</param>
+ /// <returns>The handle to the created visual</returns>
public VisualBase CreateVisual(PropertyMap propertyMap)
{
VisualBase ret = new VisualBase(NDalicPINVOKE.VisualFactory_CreateVisual__SWIG_0(swigCPtr, PropertyMap.getCPtr(propertyMap)), true);
}
private static readonly VisualFactory instance = VisualFactory.Get();
+ /// <summary>
+ /// retrieve VisualFactory singleton.
+ /// </summary>
public static VisualFactory Instance
{
get
namespace Tizen.NUI
{
+ /// <summary>
+ /// The wheel event structure is used to store a wheel rolling, it facilitates
+ /// processing of the wheel rolling and passing to other libraries like Toolkit.
+ ///
+ /// There is a key modifier which relates to keys like alt, shift and control functions are
+ /// supplied to check if they have been pressed when the wheel is being rolled.
+ ///
+ /// We support a mouse device and there may be another custom device that support the wheel event. The device type is specified as \e type.
+ /// The mouse wheel event can be sent to the specific actor but the custom wheel event will be sent to the stage.
+ /// </summary>
public class Wheel : global::System.IDisposable
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
return ret;
}
+ /// <summary>
+ /// The type of the wheel event
+ /// </summary>
public Wheel.WheelType Type
{
get
}
}
+ /// <summary>
+ /// he direction of wheel rolling (0 = default vertical wheel, 1 = horizontal wheel)
+ /// </summary>
public int Direction
{
get
}
}
+ /// <summary>
+ /// Modifier keys pressed during the event (such as shift, alt and control)
+ /// </summary>
public uint Modifiers
{
get
}
}
+ /// <summary>
+ /// The co-ordinates of the cursor relative to the top-left of the screen
+ /// </summary>
public Vector2 Point
{
get
}
}
+ /// <summary>
+ /// The offset of rolling (positive value means roll down or clockwise, and negative value means roll up or counter-clockwise)
+ /// </summary>
public int Z
{
get
}
}
+ /// <summary>
+ /// The time the wheel is being rolled
+ /// </summary>
public uint TimeStamp
{
get
}
}
+ /// <summary>
+ /// Default constructor.
+ /// </summary>
public Wheel() : this(NDalicPINVOKE.new_Wheel__SWIG_0(), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor.
+ /// </summary>
+ /// <param name="type">The type of the wheel event</param>
+ /// <param name="direction">The direction of wheel rolling (0 = default vertical wheel, 1 = horizontal wheel)</param>
+ /// <param name="modifiers">Modifier keys pressed during the event (such as shift, alt and control)</param>
+ /// <param name="point">The co-ordinates of the cursor relative to the top-left of the screen</param>
+ /// <param name="z">The offset of rolling (positive value means roll down or clockwise, and negative value means roll up or counter-clockwise)</param>
+ /// <param name="timeStamp">The time the wheel is being rolled</param>
public Wheel(Wheel.WheelType type, int direction, uint modifiers, Vector2 point, int z, uint timeStamp) : this(NDalicPINVOKE.new_Wheel__SWIG_1((int)type, direction, modifiers, Vector2.getCPtr(point), z, timeStamp), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Checks to see if Shift key modifier has been supplied.
+ /// </summary>
+ /// <returns>True if shift modifier</returns>
public bool IsShiftModifier()
{
bool ret = NDalicPINVOKE.Wheel_IsShiftModifier(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Checks to see if Ctrl (control) key modifier has been supplied.
+ /// </summary>
+ /// <returns>True if ctrl modifier</returns>
public bool IsCtrlModifier()
{
bool ret = NDalicPINVOKE.Wheel_IsCtrlModifier(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Checks to see if Alt key modifier has been supplied.
+ /// </summary>
+ /// <returns>True if alt modifier</returns>
public bool IsAltModifier()
{
bool ret = NDalicPINVOKE.Wheel_IsAltModifier(swigCPtr);
}
}
+ /// <summary>
+ /// The type of the wheel event
+ /// </summary>
public enum WheelType
{
MouseWheel,
namespace Tizen.NUI
{
-
+ /// <summary>
+ /// The window class is used internally for drawing.
+ /// A Window has an orientation and indicator properties.
+ /// </summary>
public class Window : BaseHandle
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
}
}
-
+ /// <summary>
+ /// Creates an initialized handle to a new Window.
+ /// </summary>
+ /// <param name="windowPosition">The position and size of the Window</param>
+ /// <param name="name">The Window title</param>
+ /// <param name="isTransparent">Whether Window is transparent</param>
public Window(Rectangle windowPosition, string name, bool isTransparent) : this(NDalicPINVOKE.Window_New__SWIG_0(Rectangle.getCPtr(windowPosition), name, isTransparent), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+
+ /// <summary>
+ /// Creates an initialized handle to a new Window.
+ /// </summary>
+ /// <param name="windowPosition">The position and size of the Window</param>
+ /// <param name="name">The Window title</param>
public Window(Rectangle windowPosition, string name) : this(NDalicPINVOKE.Window_New__SWIG_1(Rectangle.getCPtr(windowPosition), name), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+
+ /// <summary>
+ /// Creates an initialized handle to a new Window.
+ /// </summary>
+ /// <param name="windowPosition">The position and size of the Window</param>
+ /// <param name="name">The Window title</param>
+ /// <param name="className">The Window class name</param>
+ /// <param name="isTransparent">Whether Window is transparent</param>
public Window(Rectangle windowPosition, string name, string className, bool isTransparent) : this(NDalicPINVOKE.Window_New__SWIG_2(Rectangle.getCPtr(windowPosition), name, className, isTransparent), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+
+ /// <summary>
+ /// Creates an initialized handle to a new Window.
+ /// </summary>
+ /// <param name="windowPosition">The position and size of the Window</param>
+ /// <param name="name">The Window title</param>
+ /// <param name="className">The Window class name</param>
public Window(Rectangle windowPosition, string name, string className) : this(NDalicPINVOKE.Window_New__SWIG_3(Rectangle.getCPtr(windowPosition), name, className), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// This sets whether the indicator bar should be shown or not.
+ /// </summary>
+ /// <param name="visibleMode">Visible mode for indicator bar, Visible in default</param>
public void ShowIndicator(Window.IndicatorVisibleMode visibleMode)
{
NDalicPINVOKE.Window_ShowIndicator(swigCPtr, (int)visibleMode);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// This sets the opacity mode of indicator bar.
+ /// </summary>
+ /// <param name="opacity">The opacity mode</param>
public void SetIndicatorBgOpacity(Window.IndicatorBgOpacity opacity)
{
NDalicPINVOKE.Window_SetIndicatorBgOpacity(swigCPtr, (int)opacity);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// This sets the orientation of indicator bar.
+ /// It does not implicitly show the indicator if it is currently hidden.
+ /// </summary>
+ /// <param name="orientation">The orientation</param>
public void RotateIndicator(Window.WindowOrientation orientation)
{
NDalicPINVOKE.Window_RotateIndicator(swigCPtr, (int)orientation);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Raises window to the top of Window stack.
+ /// </summary>
public void Raise()
{
NDalicPINVOKE.Window_Raise(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Lowers window to the bottom of Window stack.
+ /// </summary>
public void Lower()
{
NDalicPINVOKE.Window_Lower(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Activates window to the top of Window stack even it is iconified.
+ /// </summary>
public void Activate()
{
NDalicPINVOKE.Window_Activate(swigCPtr);
return ret;
}
+ /// <summary>
+ /// Enumeration for orientation of the window is the way in which a rectangular page is oriented for normal viewing.
+ /// </summary>
public enum WindowOrientation
{
Portrait = 0,
LandscapeInverse = 270
}
+ /// <summary>
+ /// Enumeration for opacity of the indicator.
+ /// </summary>
public enum IndicatorBgOpacity
{
Opaque = 100,
Transparent = 0
}
+ /// <summary>
+ /// Enumeration for visible mode of the indicator.
+ /// </summary>
public enum IndicatorVisibleMode
{
Invisible = 0,
projects / platform / core / csapi / tizenfx.git / commitdiff