From: dongsug.song Date: Fri, 17 Mar 2017 12:41:07 +0000 (+0900) Subject: Comment work X-Git-Tag: accepted/tizen/common/20170320.174038~5 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=refs%2Fchanges%2F00%2F119600%2F1;p=platform%2Fcore%2Fcsapi%2Fnui.git Comment work - work done by Mr.Sun Signed-off-by: dongsug.song Change-Id: I339d12ae0168551d32722be8328f5e6e3dd65504 --- diff --git a/Tizen.NUI/src/public/RadioButton.cs b/Tizen.NUI/src/public/RadioButton.cs index f062ac2..48527dc 100755 --- a/Tizen.NUI/src/public/RadioButton.cs +++ b/Tizen.NUI/src/public/RadioButton.cs @@ -27,6 +27,19 @@ namespace Tizen.NUI { + /// + /// 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. + /// public class RadioButton : Button { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -70,12 +83,19 @@ namespace Tizen.NUI } } - + /// + /// Creates an uninitialized RadioButton + /// public RadioButton() : this(NDalicPINVOKE.RadioButton_New__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + + /// + /// Creates an uninitialized RadioButton with Label + /// + /// Label text public RadioButton(string label) : this(NDalicPINVOKE.RadioButton_New__SWIG_1(label), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); @@ -93,6 +113,13 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// Handle to an object + /// A handle to a RadioButton or an uninitialized handle public new static RadioButton DownCast(BaseHandle handle) { RadioButton ret = new RadioButton(NDalicPINVOKE.RadioButton_DownCast(BaseHandle.getCPtr(handle)), true); diff --git a/Tizen.NUI/src/public/Rectangle.cs b/Tizen.NUI/src/public/Rectangle.cs index 19c7c82..dada221 100755 --- a/Tizen.NUI/src/public/Rectangle.cs +++ b/Tizen.NUI/src/public/Rectangle.cs @@ -11,6 +11,9 @@ namespace Tizen.NUI { + /// + /// Rectangle class + /// public class Rectangle : global::System.IDisposable { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -55,7 +58,12 @@ namespace Tizen.NUI } } - + /// + /// Equality operator. + /// + /// First operand + /// Second operand + /// True if boxes are exactly same public static bool operator ==(Rectangle a, Rectangle b) { // If both are null, or both are same instance, return true. @@ -74,12 +82,20 @@ namespace Tizen.NUI return a.X == b.X && a.Y == b.Y && a.Width == b.Width && a.Height == b.Height; } + /// + /// Inequality operator. + /// + /// The first rectangle + /// The second rectangle + /// True if rectangles are not identical public static bool operator !=(Rectangle a, Rectangle b) { return !(a == b); } - ///< X position of the rectangle + /// + /// X position of the rectangle + /// public int X { set @@ -92,7 +108,9 @@ namespace Tizen.NUI } } - ///< Y position of the rectangle + /// + /// Y position of the rectangle + /// public int Y { set @@ -105,7 +123,9 @@ namespace Tizen.NUI } } - ///< Width of the rectangle + /// + /// Width of the rectangle + /// public int Width { set @@ -118,7 +138,9 @@ namespace Tizen.NUI } } - ///< Height of the rectangle + /// + /// Height of the rectangle + /// public int Height { set @@ -131,21 +153,40 @@ namespace Tizen.NUI } } + /// + /// Constructor. + /// public Rectangle() : this(NDalicPINVOKE.new_Rectangle__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Constructor. + /// + /// X coordinate (or left) + /// Y coordinate (or right) + /// Width (or bottom) + /// Height (or top) 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(); } + /// + /// Copy constructor. + /// + /// The original object public Rectangle(Rectangle rhs) : this(NDalicPINVOKE.new_Rectangle__SWIG_2(Rectangle.getCPtr(rhs)), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Make reference of original Rectangle object. + /// + /// The original object + /// Reference to this public Rectangle Assign(Rectangle rhs) { Rectangle ret = new Rectangle(NDalicPINVOKE.Rectangle_Assign(swigCPtr, Rectangle.getCPtr(rhs)), false); @@ -153,12 +194,23 @@ namespace Tizen.NUI return ret; } + /// + /// Assignment from individual values. + /// + /// X coordinate + /// Y coordinate + /// Width + /// Height 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(); } + /// + /// Determines whether or not this Rectangle is empty. + /// + /// True if width or height are zero public bool IsEmpty() { bool ret = NDalicPINVOKE.Rectangle_IsEmpty(swigCPtr); @@ -166,6 +218,10 @@ namespace Tizen.NUI return ret; } + /// + /// Gets the left of the rectangle. + /// + /// The left edge of the rectangle public int Left() { int ret = NDalicPINVOKE.Rectangle_Left(swigCPtr); @@ -173,6 +229,10 @@ namespace Tizen.NUI return ret; } + /// + /// Gets the right of the rectangle. + /// + /// The right edge of the rectangle public int Right() { int ret = NDalicPINVOKE.Rectangle_Right(swigCPtr); @@ -180,6 +240,10 @@ namespace Tizen.NUI return ret; } + /// + /// Gets the top of the rectangle. + /// + /// The top of the rectangle public int Top() { int ret = NDalicPINVOKE.Rectangle_Top(swigCPtr); @@ -187,6 +251,10 @@ namespace Tizen.NUI return ret; } + /// + /// Gets the bottom of the rectangle. + /// + /// The bottom of the rectangle public int Bottom() { int ret = NDalicPINVOKE.Rectangle_Bottom(swigCPtr); @@ -194,6 +262,10 @@ namespace Tizen.NUI return ret; } + /// + /// Gets the area of the rectangle. + /// + /// The area of the rectangle public int Area() { int ret = NDalicPINVOKE.Rectangle_Area(swigCPtr); @@ -201,6 +273,11 @@ namespace Tizen.NUI return ret; } + /// + /// Determines whether or not this rectangle and the specified rectangle intersect. + /// + /// The other rectangle to test against this rectangle + /// True if the rectangles intersect public bool Intersects(Rectangle other) { bool ret = NDalicPINVOKE.Rectangle_Intersects(swigCPtr, Rectangle.getCPtr(other)); @@ -208,6 +285,11 @@ namespace Tizen.NUI return ret; } + /// + /// Determines whether or not this Rectangle contains the specified rectangle. + /// + /// The other rectangle to test against this rectangle + /// True if the specified rectangle is contained public bool Contains(Rectangle other) { bool ret = NDalicPINVOKE.Rectangle_Contains(swigCPtr, Rectangle.getCPtr(other)); diff --git a/Tizen.NUI/src/public/RelayoutContainer.cs b/Tizen.NUI/src/public/RelayoutContainer.cs index 2d3135b..cf01adb 100755 --- a/Tizen.NUI/src/public/RelayoutContainer.cs +++ b/Tizen.NUI/src/public/RelayoutContainer.cs @@ -11,6 +11,9 @@ namespace Tizen.NUI { + /// + /// Interface to encapsulate information required for relayout. + /// public class RelayoutContainer : global::System.IDisposable { private global::System.Runtime.InteropServices.HandleRef swigCPtr; diff --git a/Tizen.NUI/src/public/Rotation.cs b/Tizen.NUI/src/public/Rotation.cs index 48d9841..b42ab5b 100755 --- a/Tizen.NUI/src/public/Rotation.cs +++ b/Tizen.NUI/src/public/Rotation.cs @@ -11,6 +11,9 @@ namespace Tizen.NUI { + /// + /// Rotation Class + /// public class Rotation : global::System.IDisposable { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -55,57 +58,114 @@ namespace Tizen.NUI } } - + /// + /// Addition operator. + /// + /// First Rotation + /// Second Rotation + /// A Rotation containing the result of the Addition public static Rotation operator +(Rotation arg1, Rotation arg2) { return arg1.Add(arg2); } + /// + /// Subtraction operator. + /// + /// First Rotation + /// Second Rotation + /// A Rotation containing the result of the subtract public static Rotation operator -(Rotation arg1, Rotation arg2) { return arg1.Subtract(arg2); } + /// + /// Unary Negation operator. + /// + /// First Rotation + /// A Rotation containing the negated result public static Rotation operator -(Rotation arg1) { return arg1.Subtract(); } + /// + /// Multiplication operator. + /// + /// First Rotation + /// Second Rotation + /// A Rotation containing the result of the Multiplication public static Rotation operator *(Rotation arg1, Rotation arg2) { return arg1.Multiply(arg2); } + /// + /// Multiplication operator. + /// + /// Rotation + /// The vector to multiply + /// A Rotation containing the result of the multiplication public static Vector3 operator *(Rotation arg1, Vector3 arg2) { return arg1.Multiply(arg2); } + /// + /// Scale operator. + /// + /// Rotation + /// A value to scale by + /// A Rotation containing the result of the scaling public static Rotation operator *(Rotation arg1, float arg2) { return arg1.Multiply(arg2); } + /// + /// Division operator. + /// + /// First Rotation + /// Second Rotation + /// A Rotation containing the result of the scaling public static Rotation operator /(Rotation arg1, Rotation arg2) { return arg1.Divide(arg2); } + /// + /// Scale operator. + /// + /// Rotation + /// A value to scale by + /// A Rotation containing the result of the scaling public static Rotation operator /(Rotation arg1, float arg2) { return arg1.Divide(arg2); } + /// + /// Default Constructor. + /// public Rotation() : this(NDalicPINVOKE.new_Rotation__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Constructor from an axis and angle. + /// + /// The angle around the axis + /// The vector of the axis 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(); } + /// + /// (0.0f,0.0f,0.0f,1.0f) + /// public static Rotation IDENTITY { get @@ -117,6 +177,10 @@ namespace Tizen.NUI } } + /// + /// Helper to check if this is an identity quaternion. + /// + /// True if this is identity quaternion public bool IsIdentity() { bool ret = NDalicPINVOKE.Rotation_IsIdentity(swigCPtr); @@ -124,6 +188,12 @@ namespace Tizen.NUI return ret; } + /// + /// Converts the quaternion to an axis/angle pair. + /// + /// the result of axis + /// the result of angle Angle in radians + /// True if converted correctly public bool GetAxisAngle(Vector3 axis, Radian angle) { bool ret = NDalicPINVOKE.Rotation_GetAxisAngle(swigCPtr, Vector3.getCPtr(axis), Radian.getCPtr(angle)); @@ -236,6 +306,10 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the length of the rotation + /// + /// The length of the rotation public float Length() { float ret = NDalicPINVOKE.Rotation_Length(swigCPtr); @@ -243,6 +317,10 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the squared length of the rotation + /// + /// The squared length of the rotation public float LengthSquared() { float ret = NDalicPINVOKE.Rotation_LengthSquared(swigCPtr); @@ -250,12 +328,19 @@ namespace Tizen.NUI return ret; } + /// + /// Normalizes this to unit length. + /// public void Normalize() { NDalicPINVOKE.Rotation_Normalize(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Normalized. + /// + /// A normalized version of this rotation public Rotation Normalized() { Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Normalized(swigCPtr), true); @@ -263,18 +348,28 @@ namespace Tizen.NUI return ret; } + /// + /// Conjugates this rotation. + /// public void Conjugate() { NDalicPINVOKE.Rotation_Conjugate(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Inverts this rotation. + /// public void Invert() { NDalicPINVOKE.Rotation_Invert(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Performs the logarithm of a rotation + /// + /// A rotation representing the logarithm public Rotation Log() { Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Log(swigCPtr), true); @@ -282,6 +377,10 @@ namespace Tizen.NUI return ret; } + /// + /// Performs an exponent + /// + /// A rotation representing the exponent public Rotation Exp() { Rotation ret = new Rotation(NDalicPINVOKE.Rotation_Exp(swigCPtr), true); @@ -289,6 +388,12 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the dot product of two rotations. + /// + /// The first rotation + /// The second rotation + /// The dot product of the two rotations public static float Dot(Rotation q1, Rotation q2) { float ret = NDalicPINVOKE.Rotation_Dot(Rotation.getCPtr(q1), Rotation.getCPtr(q2)); @@ -296,6 +401,13 @@ namespace Tizen.NUI return ret; } + /// + /// Linear Interpolation (using a straight line between the two rotations). + /// + /// The start rotation + /// The end rotation + /// A progress value between 0 and 1 + /// The interpolated rotation 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); @@ -303,6 +415,13 @@ namespace Tizen.NUI return ret; } + /// + /// Spherical Linear Interpolation (using the shortest arc of a great circle between the two rotations). + /// + /// The start rotation + /// The end rotation + /// A progress value between 0 and 1 + /// The interpolated rotation 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); @@ -310,6 +429,13 @@ namespace Tizen.NUI return ret; } + /// + /// This version of Slerp, used by Squad, does not check for theta > 90. + /// + /// The start rotation + /// The end rotation + /// A progress value between 0 and 1 + /// The interpolated rotation 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); @@ -317,6 +443,15 @@ namespace Tizen.NUI return ret; } + /// + /// Spherical Cubic Interpolation. + /// + /// The start rotation + /// The end rotation + /// The control rotation for q1 + /// The control rotation for q2 + /// A progress value between 0 and 1 + /// The interpolated rotation 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); @@ -324,6 +459,12 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the shortest angle between two rotations in Radians. + /// + /// The first rotation + /// The second rotation + /// The angle between the two rotation public static float AngleBetween(Rotation q1, Rotation q2) { float ret = NDalicPINVOKE.Rotation_AngleBetween(Rotation.getCPtr(q1), Rotation.getCPtr(q2)); diff --git a/Tizen.NUI/src/public/ScrollBar.cs b/Tizen.NUI/src/public/ScrollBar.cs index 518da8c..0324903 100755 --- a/Tizen.NUI/src/public/ScrollBar.cs +++ b/Tizen.NUI/src/public/ScrollBar.cs @@ -30,7 +30,10 @@ namespace Tizen.NUI using System; using System.Runtime.InteropServices; - + /// + /// ScrollBar is a UI component that can be linked to the scrollable objects + /// indicating the current scroll position of the scrollable object. + /// public class ScrollBar : View { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -74,17 +77,23 @@ namespace Tizen.NUI } } - - - + /// + /// Event arguments that passed via PanFinished event + /// public class PanFinishedEventArgs : EventArgs { } + /// + /// Event arguments that passed via ScrollPositionIntervalReached event + /// public class ScrollPositionIntervalReachedEventArgs : EventArgs { private float _currentScrollPosition; + /// + /// current scroll position of the scrollable content + /// public float CurrentScrollPosition { get @@ -108,6 +117,9 @@ namespace Tizen.NUI private EventHandler _scrollBarScrollPositionIntervalReachedEventHandler; private ScrollPositionIntervalReachedEventCallbackDelegate _scrollBarScrollPositionIntervalReachedEventCallbackDelegate; + /// + /// Event emitted when panning is finished on the scroll indicator. + /// public event EventHandler PanFinished { add @@ -142,6 +154,9 @@ namespace Tizen.NUI } + /// + /// Event emitted when the current scroll position of the scrollable content + /// public event EventHandler ScrollPositionIntervalReached { add @@ -231,11 +246,18 @@ namespace Tizen.NUI } + /// + /// Creates an initialized ScrollBar. + /// + /// The direction of scroll bar (either vertically or horizontally) public ScrollBar(ScrollBar.Direction direction) : this(NDalicPINVOKE.ScrollBar_New__SWIG_0((int)direction), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); - } + + /// + /// Creates an uninitialized ScrollBar + /// public ScrollBar() : this(NDalicPINVOKE.ScrollBar_New__SWIG_1(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); @@ -253,6 +275,13 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// Handle to an object + /// Handle to a ScrollBar or an uninitialized handle public new static ScrollBar DownCast(BaseHandle handle) { ScrollBar ret = new ScrollBar(NDalicPINVOKE.ScrollBar_DownCast(BaseHandle.getCPtr(handle)), true); @@ -389,18 +418,27 @@ namespace Tizen.NUI PROPERTY_END_INDEX = View.PropertyRange.PROPERTY_START_INDEX + 1000 } + /// + /// Direction of scroll bar + /// public enum Direction { Vertical = 0, Horizontal } + /// + /// Indicator height policy. + /// public enum IndicatorHeightPolicyType { Variable = 0, Fixed } + /// + /// Direction of scroll bar + /// public string ScrollDirection { get @@ -414,6 +452,10 @@ namespace Tizen.NUI SetProperty(ScrollBar.Property.SCROLL_DIRECTION, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// Indicator height policy. + /// public string IndicatorHeightPolicy { get @@ -427,6 +469,10 @@ namespace Tizen.NUI SetProperty(ScrollBar.Property.INDICATOR_HEIGHT_POLICY, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// the fixed height of scroll indicator. + /// public float IndicatorFixedHeight { get @@ -440,6 +486,10 @@ namespace Tizen.NUI SetProperty(ScrollBar.Property.INDICATOR_FIXED_HEIGHT, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// the duration in seconds for the scroll indicator to become fully visible. + /// public float IndicatorShowDuration { get @@ -453,6 +503,10 @@ namespace Tizen.NUI SetProperty(ScrollBar.Property.INDICATOR_SHOW_DURATION, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// the duration in seconds for the scroll indicator to become fully invisible. + /// public float IndicatorHideDuration { get @@ -466,6 +520,10 @@ namespace Tizen.NUI SetProperty(ScrollBar.Property.INDICATOR_HIDE_DURATION, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// the list of values to get notification when the current scroll position of the scrollable object goes above or below any of these values. + /// public Tizen.NUI.PropertyArray ScrollPositionIntervals { get @@ -479,6 +537,10 @@ namespace Tizen.NUI SetProperty(ScrollBar.Property.SCROLL_POSITION_INTERVALS, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// The minimum height for a variable size indicator. + /// public float IndicatorMinimumHeight { get @@ -492,6 +554,10 @@ namespace Tizen.NUI SetProperty(ScrollBar.Property.INDICATOR_MINIMUM_HEIGHT, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// The padding at the start of the indicator. For example, the top if scrollDirection is Vertical. + /// public float IndicatorStartPadding { get @@ -505,6 +571,10 @@ namespace Tizen.NUI SetProperty(ScrollBar.Property.INDICATOR_START_PADDING, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// The padding at the end of the indicator. For example, the bottom if scrollDirection is Vertical. + /// public float IndicatorEndPadding { get diff --git a/Tizen.NUI/src/public/Timer.cs b/Tizen.NUI/src/public/Timer.cs index 23e5694..fbe2abe 100755 --- a/Tizen.NUI/src/public/Timer.cs +++ b/Tizen.NUI/src/public/Timer.cs @@ -30,7 +30,16 @@ namespace Tizen.NUI using System; using System.Runtime.InteropServices; - + /// + /// 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. + /// public class Timer : BaseHandle { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -75,11 +84,9 @@ namespace Tizen.NUI } - - /** - * @brief Event arguments that passed via Tick signal - * - */ + /// + /// Event arguments that passed via Tick event + /// public class TickEventArgs : EventArgs { } @@ -89,11 +96,11 @@ namespace Tizen.NUI private EventHandlerWithReturnType _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) - * provided by the user. Ticked signal is emitted after specified time interval. - */ + /// + /// brief Event for Ticked signal which can be used to subscribe/unsubscribe the event handler + /// (in the type of TickEventHandler-DaliEventHandlerWithReturnType) + /// provided by the user. Ticked signal is emitted after specified time interval. + /// public event EventHandlerWithReturnType Tick { add @@ -115,7 +122,6 @@ namespace Tizen.NUI } } - // Callback for Timer Tick signal private bool OnTick(IntPtr data) { TickEventArgs e = new TickEventArgs(); @@ -128,7 +134,11 @@ namespace Tizen.NUI return false; } - + /// + /// Creates a tick Timer that emits periodic signal. + /// + /// Interval in milliseconds + /// A new timer public Timer(uint milliSec) : this(NDalicPINVOKE.Timer_New(milliSec), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); @@ -146,6 +156,11 @@ namespace Tizen.NUI return ret; } + /// + /// Downcasts a handle to Timer handle. + /// + /// handle to An object + /// handle to a Timer object or an uninitialized handle public static Timer DownCast(BaseHandle handle) { Timer ret = new Timer(NDalicPINVOKE.Timer_DownCast(BaseHandle.getCPtr(handle)), true); @@ -153,18 +168,30 @@ namespace Tizen.NUI return ret; } + /// + /// Starts timer + /// In case a Timer is already running, its time is reset and timer is restarted. + /// public void Start() { NDalicPINVOKE.Timer_Start(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Stops timer. + /// public void Stop() { NDalicPINVOKE.Timer_Stop(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Sets a new interval on the timer and starts the timer. + /// Cancels the previous timer. + /// + /// milliSec Interval in milliseconds internal void SetInterval(uint milliSec) { NDalicPINVOKE.Timer_SetInterval(swigCPtr, milliSec); @@ -178,6 +205,10 @@ namespace Tizen.NUI return ret; } + /// + /// Tells whether timer is running. + /// + /// Whether Timer is started or not public bool IsRunning() { bool ret = NDalicPINVOKE.Timer_IsRunning(swigCPtr); diff --git a/Tizen.NUI/src/public/Touch.cs b/Tizen.NUI/src/public/Touch.cs index c93706b..6118a84 100755 --- a/Tizen.NUI/src/public/Touch.cs +++ b/Tizen.NUI/src/public/Touch.cs @@ -10,7 +10,11 @@ namespace Tizen.NUI { - + /// + /// 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. + /// public class Touch : BaseHandle { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -62,6 +66,10 @@ namespace Tizen.NUI return ret; } + /// + /// An uninitialized Touch instance. + /// Calling member functions with an uninitialized Touch handle is not allowed. + /// public Touch() : this(NDalicPINVOKE.new_Touch__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); @@ -79,6 +87,10 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the time (in ms) that the touch event occurred. + /// + /// The time (in ms) that the touch event occurred public uint GetTime() { uint ret = NDalicPINVOKE.Touch_GetTime(swigCPtr); @@ -86,6 +98,10 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the total number of points in this TouchData. + /// + /// Total number of Points public uint GetPointCount() { uint ret = NDalicPINVOKE.Touch_GetPointCount(swigCPtr); @@ -93,6 +109,14 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// The point required + /// The Device ID of this point public int GetDeviceId(uint point) { int ret = NDalicPINVOKE.Touch_GetDeviceId(swigCPtr, point); @@ -100,6 +124,12 @@ namespace Tizen.NUI return ret; } + /// + /// Retrieves the State of the point specified. + /// If point is greater than GetPointCount() then this method will return PointState.Finished. + /// + /// The point required + /// The state of the point specified public PointStateType GetState(uint point) { PointStateType ret = (PointStateType)NDalicPINVOKE.Touch_GetState(swigCPtr, point); @@ -107,6 +137,12 @@ namespace Tizen.NUI return ret; } + /// + /// Retrieves the actor that was underneath the point specified. + /// If point is greater than GetPointCount() then this method will return an empty handle. + /// + /// The point required + /// The actor that was underneath the point specified public Actor GetHitActor(uint point) { Actor ret = new Actor(NDalicPINVOKE.Touch_GetHitActor(swigCPtr, point), true); @@ -114,6 +150,15 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// The point required + /// The co-ordinates relative to the top-left of the hit-actor of the point specified public Vector2 GetLocalPosition(uint point) { Vector2 ret = new Vector2(NDalicPINVOKE.Touch_GetLocalPosition(swigCPtr, point), false); @@ -121,6 +166,12 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// The point required + /// The co-ordinates relative to the top-left of the screen of the point specified public Vector2 GetScreenPosition(uint point) { Vector2 ret = new Vector2(NDalicPINVOKE.Touch_GetScreenPosition(swigCPtr, point), false); @@ -128,6 +179,13 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// The point required + /// The radius of the press point public float GetRadius(uint point) { float ret = NDalicPINVOKE.Touch_GetRadius(swigCPtr, point); @@ -135,6 +193,12 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// The point required + /// The horizontal and vertical radii of the press point public Vector2 GetEllipseRadius(uint point) { Vector2 ret = new Vector2(NDalicPINVOKE.Touch_GetEllipseRadius(swigCPtr, point), false); @@ -142,6 +206,16 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// point The point required + /// The touch pressure public float GetPressure(uint point) { float ret = NDalicPINVOKE.Touch_GetPressure(swigCPtr, point); @@ -158,6 +232,9 @@ namespace Tizen.NUI } + /// + /// Enumeration for point state type. + /// public enum PointStateType { Started, diff --git a/Tizen.NUI/src/public/Vector2.cs b/Tizen.NUI/src/public/Vector2.cs index 8156332..888130d 100755 --- a/Tizen.NUI/src/public/Vector2.cs +++ b/Tizen.NUI/src/public/Vector2.cs @@ -11,6 +11,9 @@ namespace Tizen.NUI { + /// + /// A two dimensional vector. + /// public class Vector2 : global::System.IDisposable { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -55,42 +58,87 @@ namespace Tizen.NUI } } - + /// + /// Addition operator. + /// + /// First value + /// Second value + /// A vector containing the result of the addition public static Vector2 operator +(Vector2 arg1, Vector2 arg2) { return arg1.Add(arg2); } + /// + /// Subtraction operator. + /// + /// First value + /// Second value + /// A vector containing the result of the subtraction public static Vector2 operator -(Vector2 arg1, Vector2 arg2) { return arg1.Subtract(arg2); } + /// + /// Unary negation operator. + /// + /// Target Value + /// A vector containg the negation public static Vector2 operator -(Vector2 arg1) { return arg1.Subtract(); } + /// + /// Multiplication operator. + /// + /// First Value + /// Second Value + /// A vector containing the result of the multiplication public static Vector2 operator *(Vector2 arg1, Vector2 arg2) { return arg1.Multiply(arg2); } + /// + /// Multiplication operator. + /// + /// First Value + /// The float value to scale the vector + /// A vector containing the result of the scaling public static Vector2 operator *(Vector2 arg1, float arg2) { return arg1.Multiply(arg2); } + /// + /// Division operator. + /// + /// First Value + /// Second Value + /// A vector containing the result of the division public static Vector2 operator /(Vector2 arg1, Vector2 arg2) { return arg1.Divide(arg2); } + /// + /// Division operator. + /// + /// First Value + /// The float value to scale the vector by + /// A vector containing the result of the scaling public static Vector2 operator /(Vector2 arg1, float arg2) { return arg1.Divide(arg2); } + /// + /// Array subscript operator overload. + /// + /// Subscript index + /// The float at the given index public float this[uint index] { get @@ -106,32 +154,54 @@ namespace Tizen.NUI return ret; } - + /// + /// Default constructor, initializes the vector to 0. + /// public Vector2() : this(NDalicPINVOKE.new_Vector2__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Constructor. + /// + /// x or width component + /// y or height component public Vector2(float x, float y) : this(NDalicPINVOKE.new_Vector2__SWIG_1(x, y), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Conversion constructor from an array of two floats. + /// + /// Array of xy public Vector2(float[] array) : this(NDalicPINVOKE.new_Vector2__SWIG_2(array), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Constructor. + /// + /// Vector3 to create this vector from public Vector2(Vector3 vec3) : this(NDalicPINVOKE.new_Vector2__SWIG_3(Vector3.getCPtr(vec3)), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Constructor. + /// + /// Vector4 to create this vector from public Vector2(Vector4 vec4) : this(NDalicPINVOKE.new_Vector2__SWIG_4(Vector4.getCPtr(vec4)), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// (1.0f,1.0f) + /// public static Vector2 One { get @@ -143,6 +213,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the X axis + /// public static Vector2 XAxis { get @@ -154,6 +227,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the Y axis + /// public static Vector2 YAxis { get @@ -165,6 +241,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the negative X axis + /// public static Vector2 NegativeXAxis { get @@ -176,6 +255,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the negative Y axis + /// public static Vector2 NegativeYAxis { get @@ -187,6 +269,9 @@ namespace Tizen.NUI } } + /// + /// (0.0f, 0.0f) + /// public static Vector2 Zero { get @@ -331,6 +416,10 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the length of the vector. + /// + /// The length of the vector public float Length() { float ret = NDalicPINVOKE.Vector2_Length(swigCPtr); @@ -338,6 +427,12 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// The length of the vector squared public float LengthSquared() { float ret = NDalicPINVOKE.Vector2_LengthSquared(swigCPtr); @@ -345,12 +440,20 @@ namespace Tizen.NUI return ret; } + /// + /// Sets the vector to be unit length, whilst maintaining its direction. + /// public void Normalize() { NDalicPINVOKE.Vector2_Normalize(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Clamps the vector between minimum and maximum vectors. + /// + /// The minimum vector + /// The maximum vector public void Clamp(Vector2 min, Vector2 max) { NDalicPINVOKE.Vector2_Clamp(swigCPtr, Vector2.getCPtr(min), Vector2.getCPtr(max)); @@ -365,6 +468,9 @@ namespace Tizen.NUI return ret; } + /// + /// x component + /// public float X { set @@ -380,6 +486,9 @@ namespace Tizen.NUI } } + /// + /// width + /// public float Width { set @@ -395,6 +504,9 @@ namespace Tizen.NUI } } + /// + /// y component + /// public float Y { set @@ -410,6 +522,9 @@ namespace Tizen.NUI } } + /// + /// height + /// public float Height { set diff --git a/Tizen.NUI/src/public/Vector3.cs b/Tizen.NUI/src/public/Vector3.cs index 08dd60b..ef7f883 100755 --- a/Tizen.NUI/src/public/Vector3.cs +++ b/Tizen.NUI/src/public/Vector3.cs @@ -11,6 +11,9 @@ namespace Tizen.NUI { + /// + /// A three dimensional vector. + /// public class Vector3 : global::System.IDisposable { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -55,42 +58,87 @@ namespace Tizen.NUI } } - + /// + /// Addition operator. + /// + /// First Value + /// Second Value + /// A vector containing the result of the addition public static Vector3 operator +(Vector3 arg1, Vector3 arg2) { return arg1.Add(arg2); } + /// + /// Subtraction operator. + /// + /// First Value + /// Second Value + /// A vector containing the result of the subtraction public static Vector3 operator -(Vector3 arg1, Vector3 arg2) { return arg1.Subtract(arg2); } + /// + /// Unary negation operator. + /// + /// Target Value + /// A vector containg the negation public static Vector3 operator -(Vector3 arg1) { return arg1.Subtract(); } + /// + /// Multiplication operator. + /// + /// First Value + /// Second Value + /// A vector containing the result of the multiplication public static Vector3 operator *(Vector3 arg1, Vector3 arg2) { return arg1.Multiply(arg2); } + /// + /// Multiplication operator. + /// + /// First Value + /// The float value to scale the vector + /// A vector containing the result of the scaling public static Vector3 operator *(Vector3 arg1, float arg2) { return arg1.Multiply(arg2); } + /// + /// Division operator. + /// + /// First Value + /// Second Value + /// A vector containing the result of the division public static Vector3 operator /(Vector3 arg1, Vector3 arg2) { return arg1.Divide(arg2); } + /// + /// Division operator. + /// + /// First Value + /// The float value to scale the vector by + /// A vector containing the result of the scaling public static Vector3 operator /(Vector3 arg1, float arg2) { return arg1.Divide(arg2); } + /// + /// Array subscript operator overload. + /// + /// Subscript index + /// The float at the given index public float this[uint index] { get @@ -106,32 +154,55 @@ namespace Tizen.NUI return ret; } - + /// + /// Constructor. + /// public Vector3() : this(NDalicPINVOKE.new_Vector3__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Default constructor, initializes the vector to 0. + /// + /// x (or width) component + /// y (or height) component + /// z (or depth) component 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(); } + /// + /// Conversion constructor from an array of three floats. + /// + /// Array of xyz public Vector3(float[] array) : this(NDalicPINVOKE.new_Vector3__SWIG_2(array), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Constructor. + /// + /// Vector2 to create this vector from public Vector3(Vector2 vec2) : this(NDalicPINVOKE.new_Vector3__SWIG_3(Vector2.getCPtr(vec2)), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Constructor + /// + /// Vector4 to create this vector from public Vector3(Vector4 vec4) : this(NDalicPINVOKE.new_Vector3__SWIG_4(Vector4.getCPtr(vec4)), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// (1.0f,1.0f,1.0f) + /// public static Vector3 One { get @@ -143,6 +214,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the X axis + /// public static Vector3 XAxis { get @@ -154,6 +228,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the Y axis + /// public static Vector3 YAxis { get @@ -165,6 +242,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the Z axis + /// public static Vector3 ZAxis { get @@ -176,6 +256,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the negative X axis + /// public static Vector3 NegativeXAxis { get @@ -187,6 +270,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the negative Y axis + /// public static Vector3 NegativeYAxis { get @@ -198,6 +284,9 @@ namespace Tizen.NUI } } + /// + /// Vector representing the negative Z axis + /// public static Vector3 NegativeZAxis { get @@ -209,6 +298,9 @@ namespace Tizen.NUI } } + /// + /// (0.0f, 0.0f, 0.0f) + /// public static Vector3 Zero { get @@ -374,6 +466,10 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the length of the vector. + /// + /// The length of the vector public float Length() { float ret = NDalicPINVOKE.Vector3_Length(swigCPtr); @@ -381,6 +477,12 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// The length of the vector squared public float LengthSquared() { float ret = NDalicPINVOKE.Vector3_LengthSquared(swigCPtr); @@ -388,12 +490,20 @@ namespace Tizen.NUI return ret; } + /// + /// Sets the vector to be unit length, whilst maintaining its direction. + /// public void Normalize() { NDalicPINVOKE.Vector3_Normalize(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Clamps the vector between minimum and maximum vectors. + /// + /// The minimum vector + /// The maximum vector public void Clamp(Vector3 min, Vector3 max) { NDalicPINVOKE.Vector3_Clamp(swigCPtr, Vector3.getCPtr(min), Vector3.getCPtr(max)); @@ -408,6 +518,10 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the x & y components (or width & height, or r & g) as a Vector2. + /// + /// The partial vector contents as Vector2 (x,y) public Vector2 GetVectorXY() { Vector2 ret = new Vector2(NDalicPINVOKE.Vector3_GetVectorXY__SWIG_0(swigCPtr), false); @@ -415,6 +529,10 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the y & z components (or height & depth, or g & b) as a Vector2. + /// + /// The partial vector contents as Vector2 (y,z) public Vector2 GetVectorYZ() { Vector2 ret = new Vector2(NDalicPINVOKE.Vector3_GetVectorYZ__SWIG_0(swigCPtr), false); @@ -422,6 +540,9 @@ namespace Tizen.NUI return ret; } + /// + /// x component + /// public float X { set @@ -437,6 +558,9 @@ namespace Tizen.NUI } } + /// + /// width component + /// public float Width { set @@ -452,6 +576,9 @@ namespace Tizen.NUI } } + /// + /// red component + /// public float R { set @@ -467,6 +594,9 @@ namespace Tizen.NUI } } + /// + /// y component + /// public float Y { set @@ -482,6 +612,9 @@ namespace Tizen.NUI } } + /// + /// height component + /// public float Height { set @@ -497,6 +630,9 @@ namespace Tizen.NUI } } + /// + /// green component + /// public float G { set @@ -512,6 +648,9 @@ namespace Tizen.NUI } } + /// + /// z component + /// public float Z { set @@ -527,6 +666,9 @@ namespace Tizen.NUI } } + /// + /// depth component + /// public float Depth { set @@ -542,6 +684,9 @@ namespace Tizen.NUI } } + /// + /// blue component + /// public float B { set diff --git a/Tizen.NUI/src/public/Vector4.cs b/Tizen.NUI/src/public/Vector4.cs index be1ab18..491dc51 100755 --- a/Tizen.NUI/src/public/Vector4.cs +++ b/Tizen.NUI/src/public/Vector4.cs @@ -11,6 +11,9 @@ namespace Tizen.NUI { + /// + /// A four dimensional vector. + /// public class Vector4 : global::System.IDisposable { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -55,42 +58,87 @@ namespace Tizen.NUI } } - + /// + /// Addition operator. + /// + /// First value + /// Second value + /// A vector containing the result of the addition public static Vector4 operator +(Vector4 arg1, Vector4 arg2) { return arg1.Add(arg2); } + /// + /// Subtraction operator. + /// + /// First value + /// Second value + /// A vector containing the result of the subtraction public static Vector4 operator -(Vector4 arg1, Vector4 arg2) { return arg1.Subtract(arg2); } + /// + /// Unary negation operator. + /// + /// Target Value + /// A vector containg the negation public static Vector4 operator -(Vector4 arg1) { return arg1.Subtract(); } + /// + /// Multiplication operator. + /// + /// First Value + /// Second Value + /// A vector containing the result of the multiplication public static Vector4 operator *(Vector4 arg1, Vector4 arg2) { return arg1.Multiply(arg2); } + /// + /// Multiplication operator. + /// + /// First Value + /// The float value to scale the vector + /// A vector containing the result of the scaling public static Vector4 operator *(Vector4 arg1, float arg2) { return arg1.Multiply(arg2); } + /// + /// Division operator. + /// + /// First Value + /// Second Value + /// A vector containing the result of the division public static Vector4 operator /(Vector4 arg1, Vector4 arg2) { return arg1.Divide(arg2); } + /// + /// Division operator. + /// + /// First Value + /// The float value to scale the vector by + /// A vector containing the result of the scaling public static Vector4 operator /(Vector4 arg1, float arg2) { return arg1.Divide(arg2); } + /// + /// Array subscript operator overload. + /// + /// Subscript index + /// The float at the given index public float this[uint index] { get @@ -106,32 +154,56 @@ namespace Tizen.NUI return ret; } - + /// + /// Default constructor, initializes the vector to 0. + /// public Vector4() : this(NDalicPINVOKE.new_Vector4__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Conversion constructor from four floats. + /// + /// x (or r/s) component + /// y (or g/t) component + /// z (or b/p) component + /// w (or a/q) component 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(); } + /// + /// Conversion constructor from an array of four floats. + /// + /// array Array of either xyzw/rgba/stpq public Vector4(float[] array) : this(NDalicPINVOKE.new_Vector4__SWIG_2(array), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Conversion constructor from Vector2. + /// + /// Vector2 to copy from, z and w are initialized to 0 public Vector4(Vector2 vec2) : this(NDalicPINVOKE.new_Vector4__SWIG_3(Vector2.getCPtr(vec2)), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Conversion constructor from Vector3. + /// + /// Vector3 to copy from, w is initialized to 0 public Vector4(Vector3 vec3) : this(NDalicPINVOKE.new_Vector4__SWIG_4(Vector3.getCPtr(vec3)), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// (1.0f,1.0f,1.0f,1.0f) + /// public static Vector4 One { get @@ -143,6 +215,9 @@ namespace Tizen.NUI } } + /// + /// (1.0f,0.0f,0.0f,0.0f) + /// public static Vector4 XAxis { get @@ -154,6 +229,9 @@ namespace Tizen.NUI } } + /// + /// (0.0f,1.0f,0.0f,0.0f) + /// public static Vector4 YAxis { get @@ -165,6 +243,9 @@ namespace Tizen.NUI } } + /// + /// (0.0f,0.0f,1.0f,0.0f) + /// public static Vector4 ZAxis { get @@ -176,6 +257,9 @@ namespace Tizen.NUI } } + /// + /// (0.0f, 0.0f, 0.0f, 0.0f) + /// public static Vector4 Zero { get @@ -348,6 +432,10 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the length of the vector. + /// + /// The length public float Length() { float ret = NDalicPINVOKE.Vector4_Length(swigCPtr); @@ -355,6 +443,12 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// The length of the vector squared public float LengthSquared() { float ret = NDalicPINVOKE.Vector4_LengthSquared(swigCPtr); @@ -362,12 +456,21 @@ namespace Tizen.NUI return ret; } + /// + /// Normalizes the vector. + /// Sets the vector to unit length whilst maintaining its direction. + /// public void Normalize() { NDalicPINVOKE.Vector4_Normalize(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Clamps the vector between minimum and maximum vectors. + /// + /// The minimum vector + /// The maximum vector public void Clamp(Vector4 min, Vector4 max) { NDalicPINVOKE.Vector4_Clamp(swigCPtr, Vector4.getCPtr(min), Vector4.getCPtr(max)); @@ -382,6 +485,9 @@ namespace Tizen.NUI return ret; } + /// + /// x component + /// public float X { set @@ -397,6 +503,9 @@ namespace Tizen.NUI } } + /// + /// red component + /// public float R { set @@ -412,6 +521,9 @@ namespace Tizen.NUI } } + /// + /// s component + /// public float S { set @@ -427,6 +539,9 @@ namespace Tizen.NUI } } + /// + /// y component + /// public float Y { set @@ -442,6 +557,9 @@ namespace Tizen.NUI } } + /// + /// green component + /// public float G { set @@ -457,6 +575,9 @@ namespace Tizen.NUI } } + /// + /// t component + /// public float T { set @@ -472,6 +593,9 @@ namespace Tizen.NUI } } + /// + /// z component + /// public float Z { set @@ -487,6 +611,9 @@ namespace Tizen.NUI } } + /// + /// blue component + /// public float B { set @@ -502,6 +629,9 @@ namespace Tizen.NUI } } + /// + /// p component + /// public float P { set @@ -517,6 +647,9 @@ namespace Tizen.NUI } } + /// + /// w component + /// public float W { set @@ -532,6 +665,9 @@ namespace Tizen.NUI } } + /// + /// alpha component + /// public float A { set @@ -547,6 +683,9 @@ namespace Tizen.NUI } } + /// + /// q component + /// public float Q { set diff --git a/Tizen.NUI/src/public/VideoView.cs b/Tizen.NUI/src/public/VideoView.cs index 9dd3a86..b8dfa97 100755 --- a/Tizen.NUI/src/public/VideoView.cs +++ b/Tizen.NUI/src/public/VideoView.cs @@ -30,7 +30,9 @@ namespace Tizen.NUI using System; using System.Runtime.InteropServices; - + /// + /// VideoView is a control for video playback and display. + /// public class VideoView : View { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -74,20 +76,16 @@ namespace Tizen.NUI } } - - - /** - * @brief Event arguments that passed via Finished signal - * - */ + /// + /// Event arguments that passed via Finished signal + /// public class FinishedEventArgs : EventArgs { private VideoView _videoView; - /** - * @brief VideoView - VideoView is a control for video playback and display. - * - */ + /// + /// The view for video playback and display. + /// public VideoView VideoView { get @@ -107,11 +105,12 @@ namespace Tizen.NUI private EventHandler _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) provided by the user. - * Finished signal is emitted when a video playback have finished. - */ + + /// + /// Event for Finished signal which can be used to subscribe/unsubscribe the event handler + /// (in the type of FinishedEventHandler-DaliEventHandler) provided by the user. + /// Finished signal is emitted when a video playback have finished. + /// public event EventHandler Finished { add @@ -206,11 +205,20 @@ namespace Tizen.NUI } + /// + /// Creates an initialized VideoView. + /// public VideoView() : this(NDalicPINVOKE.VideoView_New__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + + /// + /// Creates an initialized VideoView. + /// If the string is empty, VideoView will not display anything. + /// + /// The url of the video resource to display public VideoView(string url) : this(NDalicPINVOKE.VideoView_New__SWIG_1(url), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); @@ -228,6 +236,13 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// Handle to an object + /// Handle to a VideoView or an uninitialized handle public new static VideoView DownCast(BaseHandle handle) { VideoView ret = new VideoView(NDalicPINVOKE.VideoView_DownCast(BaseHandle.getCPtr(handle)), true); @@ -235,30 +250,47 @@ namespace Tizen.NUI return ret; } + /// + /// Starts the video playback. + /// public void Play() { NDalicPINVOKE.VideoView_Play(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Pauses the video playback. + /// public void Pause() { NDalicPINVOKE.VideoView_Pause(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Stops the video playback. + /// public void Stop() { NDalicPINVOKE.VideoView_Stop(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Seeks forward by the specified number of milliseconds. + /// + /// The position for forward playback public void Forward(int millisecond) { NDalicPINVOKE.VideoView_Forward(swigCPtr, millisecond); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Seeks backward by the specified number of milliseconds. + /// + /// The position for backward playback public void Backward(int millisecond) { NDalicPINVOKE.VideoView_Backward(swigCPtr, millisecond); @@ -277,6 +309,9 @@ namespace Tizen.NUI PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX } + /// + /// video file url as string type or PropertyMap. + /// public PropertyMap Video { get @@ -290,6 +325,10 @@ namespace Tizen.NUI SetProperty(VideoView.Property.VIDEO, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// looping status, true or false. + /// public bool Looping { get @@ -303,6 +342,10 @@ namespace Tizen.NUI SetProperty(VideoView.Property.LOOPING, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// mute status, true or false. + /// public bool Muted { get @@ -316,6 +359,10 @@ namespace Tizen.NUI SetProperty(VideoView.Property.MUTED, new Tizen.NUI.PropertyValue(value)); } } + + /// + /// left and right volume scalar as float type, PropertyMap with two values ( "left" and "right" ). + /// public PropertyMap Volume { get diff --git a/Tizen.NUI/src/public/View.cs b/Tizen.NUI/src/public/View.cs index 9173331..b96f474 100755 --- a/Tizen.NUI/src/public/View.cs +++ b/Tizen.NUI/src/public/View.cs @@ -20,7 +20,9 @@ namespace Tizen.NUI using System; using System.Runtime.InteropServices; - + /// + /// View is the base class for all views. + /// public class View : CustomActor { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -653,6 +655,9 @@ namespace Tizen.NUI } + /// + /// Describes the direction to move the keyboard focus towards. + /// public enum FocusDirection { Left, @@ -663,7 +668,9 @@ namespace Tizen.NUI PageDown } - + /// + /// Creates a new instance of a View. + /// public View() : this(NDalicPINVOKE.View_New(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); @@ -681,6 +688,13 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// Handle to an object + /// A handle to a View or an uninitialized handle public new static View DownCast(BaseHandle handle) { View ret = new View(NDalicPINVOKE.View_DownCast(BaseHandle.getCPtr(handle)), true); @@ -688,6 +702,12 @@ namespace Tizen.NUI return ret; } + /// + /// Downcasts a handle to class which inherit View handle. + /// + /// Class which inherit View + /// Actor to an object + /// A object which inherit View public static T DownCast(Actor actor) where T : View { return (T)(ViewRegistry.GetViewFromActor(actor)); @@ -716,6 +736,10 @@ namespace Tizen.NUI if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Quries whether the view has key input focus. + /// + /// true if this view has keyboard input focus public bool HasKeyInputFocus() { bool ret = NDalicPINVOKE.View_HasKeyInputFocus(swigCPtr); @@ -757,12 +781,20 @@ namespace Tizen.NUI return ret; } + /// + /// Sets the name of the style to be applied to the view. + /// + /// A string matching a style described in a stylesheet public void SetStyleName(string styleName) { NDalicPINVOKE.View_SetStyleName(swigCPtr, styleName); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Retrieves the name of the style to be applied to the view (if any). + /// + /// A string matching a style, or an empty string public string GetStyleName() { string ret = NDalicPINVOKE.View_GetStyleName(swigCPtr); @@ -789,6 +821,9 @@ namespace Tizen.NUI if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Clears the background. + /// public void ClearBackground() { NDalicPINVOKE.View_ClearBackground(swigCPtr); @@ -828,6 +863,9 @@ namespace Tizen.NUI CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000 } + /// + /// styleName, type string. + /// public string StyleName { get @@ -842,6 +880,9 @@ namespace Tizen.NUI } } + /// + /// mutually exclusive with BACKGROUND_IMAGE & BACKGROUND, type Vector4. + /// public Color BackgroundColor { get @@ -864,6 +905,9 @@ namespace Tizen.NUI } } + /// + /// mutually exclusive with BACKGROUND_COLOR & BACKGROUND, type Map. + /// public string BackgroundImage { get @@ -900,6 +944,9 @@ namespace Tizen.NUI } } + /// + /// mutually exclusive with BACKGROUND_COLOR & BACKGROUND_IMAGE, type Map or string for URL. + /// public Tizen.NUI.PropertyMap Background { get @@ -914,6 +961,9 @@ namespace Tizen.NUI } } + /// + /// The current state of the view. + /// public string State { get @@ -928,6 +978,9 @@ namespace Tizen.NUI } } + /// + /// The current sub state of the view. + /// public string SubState { get @@ -942,6 +995,9 @@ namespace Tizen.NUI } } + /// + /// Displays a tooltip + /// public Tizen.NUI.PropertyMap Tooltip { get @@ -956,6 +1012,9 @@ namespace Tizen.NUI } } + /// + /// Displays a tooltip as Text + /// public string TooltipText { set @@ -1075,6 +1134,9 @@ namespace Tizen.NUI } } + /// + /// The top-left cell this child occupies, if not set, the first available cell is used + /// public Vector2 CellIndex { get @@ -1089,6 +1151,9 @@ namespace Tizen.NUI } } + /// + /// The number of rows this child occupies, if not set, default value is 1 + /// public float RowSpan { get @@ -1103,6 +1168,9 @@ namespace Tizen.NUI } } + /// + /// The number of columns this child occupies, if not set, default value is 1 + /// public float ColumnSpan { get @@ -1117,6 +1185,9 @@ namespace Tizen.NUI } } + /// + /// The horizontal alignment of this child inside the cells, if not set, default value is 'left' + /// public string CellHorizontalAlignment { get @@ -1131,6 +1202,9 @@ namespace Tizen.NUI } } + /// + /// The vertical alignment of this child inside the cells, if not set, default value is 'top' + /// public string CellVerticalAlignment { get @@ -1145,12 +1219,11 @@ namespace Tizen.NUI } } - /** - * @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. - * - */ + /// + /// 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. + /// public View LeftFocusableView { // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa. @@ -1168,12 +1241,11 @@ namespace Tizen.NUI } } - /** - * @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. - * - */ + /// + /// 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. + /// public View RightFocusableView { // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa. @@ -1191,12 +1263,11 @@ namespace Tizen.NUI } } - /** - * @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. - * - */ + /// + /// 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. + /// public View UpFocusableView { // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa. @@ -1214,12 +1285,11 @@ namespace Tizen.NUI } } - /** - * @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. - * - */ + /// + /// 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. + /// public View DownFocusableView { // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa. @@ -1237,6 +1307,9 @@ namespace Tizen.NUI } } + /// + /// whether the view should be focusable by keyboard navigation. + /// public bool Focusable { set diff --git a/Tizen.NUI/src/public/VisualBase.cs b/Tizen.NUI/src/public/VisualBase.cs index 2b1a43a..91bb66e 100755 --- a/Tizen.NUI/src/public/VisualBase.cs +++ b/Tizen.NUI/src/public/VisualBase.cs @@ -11,6 +11,12 @@ namespace Tizen.NUI { + /// + /// 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. + /// public class VisualBase : BaseHandle { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -48,6 +54,9 @@ namespace Tizen.NUI } } + /// + /// Create an empty Visual Handle + /// public VisualBase() : this(NDalicPINVOKE.new_VisualBase__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); @@ -65,6 +74,9 @@ namespace Tizen.NUI return ret; } + /// + /// name of the visual + /// public string Name { set @@ -90,12 +102,22 @@ namespace Tizen.NUI return ret; } + /// + /// Sets the transform and the control size + /// + /// A property map describing the transform + /// The size of the parent control for visuals that need to scale internally. 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(); } + /// + /// Returns the height for a given width. + /// + /// Width to use. + /// The height based on the width. public float GetHeightForWidth(float width) { float ret = NDalicPINVOKE.VisualBase_GetHeightForWidth(swigCPtr, width); @@ -103,6 +125,11 @@ namespace Tizen.NUI return ret; } + /// + /// Returns the width for a given height. + /// + /// Height to use. + /// The width based on the height. public float GetWidthForHeight(float height) { float ret = NDalicPINVOKE.VisualBase_GetWidthForHeight(swigCPtr, height); @@ -110,12 +137,21 @@ namespace Tizen.NUI return ret; } + /// + /// 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. + /// + /// The visual's natural size public void GetNaturalSize(Size2D naturalSize) { NDalicPINVOKE.VisualBase_GetNaturalSize(swigCPtr, Size2D.getCPtr(naturalSize)); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// the depth index of this visual. + /// public float DepthIndex { set @@ -140,6 +176,9 @@ namespace Tizen.NUI return ret; } + /// + /// Create the property map representing this visual. + /// public PropertyMap Creation { set diff --git a/Tizen.NUI/src/public/VisualFactory.cs b/Tizen.NUI/src/public/VisualFactory.cs index 26d576e..1ca74fb 100755 --- a/Tizen.NUI/src/public/VisualFactory.cs +++ b/Tizen.NUI/src/public/VisualFactory.cs @@ -11,6 +11,9 @@ namespace Tizen.NUI { + /// + /// VisualFactory is a singleton object that provides and shares visuals between views + /// public class VisualFactory : BaseHandle { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -55,6 +58,10 @@ namespace Tizen.NUI } + /// + /// Create or retrieve VisualFactory singleton. + /// + /// A handle to the VisualFactory control. public static VisualFactory Get() { VisualFactory ret = new VisualFactory(NDalicPINVOKE.VisualFactory_Get(), true); @@ -79,6 +86,11 @@ namespace Tizen.NUI return ret; } + /// + /// Request the visual + /// + /// The map contains the properties required by the visual. The content of the map determines the type of visual that will be returned. + /// The handle to the created visual public VisualBase CreateVisual(PropertyMap propertyMap) { VisualBase ret = new VisualBase(NDalicPINVOKE.VisualFactory_CreateVisual__SWIG_0(swigCPtr, PropertyMap.getCPtr(propertyMap)), true); @@ -101,6 +113,9 @@ namespace Tizen.NUI } private static readonly VisualFactory instance = VisualFactory.Get(); + /// + /// retrieve VisualFactory singleton. + /// public static VisualFactory Instance { get diff --git a/Tizen.NUI/src/public/Wheel.cs b/Tizen.NUI/src/public/Wheel.cs index 2c122d1..280956f 100755 --- a/Tizen.NUI/src/public/Wheel.cs +++ b/Tizen.NUI/src/public/Wheel.cs @@ -11,6 +11,16 @@ namespace Tizen.NUI { + /// + /// 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. + /// public class Wheel : global::System.IDisposable { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -63,6 +73,9 @@ namespace Tizen.NUI return ret; } + /// + /// The type of the wheel event + /// public Wheel.WheelType Type { get @@ -71,6 +84,9 @@ namespace Tizen.NUI } } + /// + /// he direction of wheel rolling (0 = default vertical wheel, 1 = horizontal wheel) + /// public int Direction { get @@ -79,6 +95,9 @@ namespace Tizen.NUI } } + /// + /// Modifier keys pressed during the event (such as shift, alt and control) + /// public uint Modifiers { get @@ -87,6 +106,9 @@ namespace Tizen.NUI } } + /// + /// The co-ordinates of the cursor relative to the top-left of the screen + /// public Vector2 Point { get @@ -95,6 +117,9 @@ namespace Tizen.NUI } } + /// + /// The offset of rolling (positive value means roll down or clockwise, and negative value means roll up or counter-clockwise) + /// public int Z { get @@ -103,6 +128,9 @@ namespace Tizen.NUI } } + /// + /// The time the wheel is being rolled + /// public uint TimeStamp { get @@ -111,16 +139,32 @@ namespace Tizen.NUI } } + /// + /// Default constructor. + /// public Wheel() : this(NDalicPINVOKE.new_Wheel__SWIG_0(), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Constructor. + /// + /// The type of the wheel event + /// The direction of wheel rolling (0 = default vertical wheel, 1 = horizontal wheel) + /// Modifier keys pressed during the event (such as shift, alt and control) + /// The co-ordinates of the cursor relative to the top-left of the screen + /// The offset of rolling (positive value means roll down or clockwise, and negative value means roll up or counter-clockwise) + /// The time the wheel is being rolled 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(); } + /// + /// Checks to see if Shift key modifier has been supplied. + /// + /// True if shift modifier public bool IsShiftModifier() { bool ret = NDalicPINVOKE.Wheel_IsShiftModifier(swigCPtr); @@ -128,6 +172,10 @@ namespace Tizen.NUI return ret; } + /// + /// Checks to see if Ctrl (control) key modifier has been supplied. + /// + /// True if ctrl modifier public bool IsCtrlModifier() { bool ret = NDalicPINVOKE.Wheel_IsCtrlModifier(swigCPtr); @@ -135,6 +183,10 @@ namespace Tizen.NUI return ret; } + /// + /// Checks to see if Alt key modifier has been supplied. + /// + /// True if alt modifier public bool IsAltModifier() { bool ret = NDalicPINVOKE.Wheel_IsAltModifier(swigCPtr); @@ -233,6 +285,9 @@ namespace Tizen.NUI } } + /// + /// The type of the wheel event + /// public enum WheelType { MouseWheel, diff --git a/Tizen.NUI/src/public/Window.cs b/Tizen.NUI/src/public/Window.cs index e8b335e..a8c0d17 100755 --- a/Tizen.NUI/src/public/Window.cs +++ b/Tizen.NUI/src/public/Window.cs @@ -26,7 +26,10 @@ namespace Tizen.NUI { - + /// + /// The window class is used internally for drawing. + /// A Window has an orientation and indicator properties. + /// public class Window : BaseHandle { private global::System.Runtime.InteropServices.HandleRef swigCPtr; @@ -70,22 +73,48 @@ namespace Tizen.NUI } } - + /// + /// Creates an initialized handle to a new Window. + /// + /// The position and size of the Window + /// The Window title + /// Whether Window is transparent 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(); } + + /// + /// Creates an initialized handle to a new Window. + /// + /// The position and size of the Window + /// The Window title 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(); } + + /// + /// Creates an initialized handle to a new Window. + /// + /// The position and size of the Window + /// The Window title + /// The Window class name + /// Whether Window is transparent 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(); } + + /// + /// Creates an initialized handle to a new Window. + /// + /// The position and size of the Window + /// The Window title + /// The Window class name 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(); @@ -103,18 +132,31 @@ namespace Tizen.NUI return ret; } + /// + /// This sets whether the indicator bar should be shown or not. + /// + /// Visible mode for indicator bar, Visible in default public void ShowIndicator(Window.IndicatorVisibleMode visibleMode) { NDalicPINVOKE.Window_ShowIndicator(swigCPtr, (int)visibleMode); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// This sets the opacity mode of indicator bar. + /// + /// The opacity mode public void SetIndicatorBgOpacity(Window.IndicatorBgOpacity opacity) { NDalicPINVOKE.Window_SetIndicatorBgOpacity(swigCPtr, (int)opacity); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// This sets the orientation of indicator bar. + /// It does not implicitly show the indicator if it is currently hidden. + /// + /// The orientation public void RotateIndicator(Window.WindowOrientation orientation) { NDalicPINVOKE.Window_RotateIndicator(swigCPtr, (int)orientation); @@ -127,18 +169,27 @@ namespace Tizen.NUI if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Raises window to the top of Window stack. + /// public void Raise() { NDalicPINVOKE.Window_Raise(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Lowers window to the bottom of Window stack. + /// public void Lower() { NDalicPINVOKE.Window_Lower(swigCPtr); if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } + /// + /// Activates window to the top of Window stack even it is iconified. + /// public void Activate() { NDalicPINVOKE.Window_Activate(swigCPtr); @@ -191,6 +242,9 @@ namespace Tizen.NUI return ret; } + /// + /// Enumeration for orientation of the window is the way in which a rectangular page is oriented for normal viewing. + /// public enum WindowOrientation { Portrait = 0, @@ -199,6 +253,9 @@ namespace Tizen.NUI LandscapeInverse = 270 } + /// + /// Enumeration for opacity of the indicator. + /// public enum IndicatorBgOpacity { Opaque = 100, @@ -206,6 +263,9 @@ namespace Tizen.NUI Transparent = 0 } + /// + /// Enumeration for visible mode of the indicator. + /// public enum IndicatorVisibleMode { Invisible = 0,