using System.Runtime.InteropServices;
/// <summary>
- /// Actor is the primary object with which Dali applications interact.
- /// UI controls can be built by combining multiple actors.
+ /// Actor is the primary object with which Dali applications interact.<br>
+ /// UI controls can be built by combining multiple actors.<br>
/// </summary>
public class Actor : Handle
{
}
/// <summary>
- /// Retrieve the position of the Actor.
- /// The coordinates are relative to the Actor's parent.
+ /// Retrieve the position of the Actor.<br>
+ /// The coordinates are relative to the Actor's parent.<br>
/// </summary>
public Position CurrentPosition
{
}
/// <summary>
- /// Retrieve the size of the Actor.
- /// The coordinates are relative to the Actor's parent.
+ /// Retrieve the size of the Actor.<br>
+ /// The coordinates are relative to the Actor's parent.<br>
/// </summary>
public Size CurrentSize
{
}
/// <summary>
- /// Retrieves the actor's parent.
+ /// Retrieves the actor's parent.<br>
/// </summary>
public Actor Parent
{
}
/// <summary>
- /// Retrieves and sets the actor's opacity.
+ /// Retrieves and sets the actor's opacity.<br>
/// </summary>
public float Opacity
{
}
/// <summary>
- /// Retrieves screen postion of actor's
+ /// Retrieves screen postion of actor's.<br>
/// </summary>
public Vector2 ScreenPosition
{
}
/// <summary>
- /// Determines whether the anchor point should be used to determine the position of the actor.
- /// This is true by default.
- /// Note: If false, then the top-left of the actor is used for the position.
- /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the actor's position.
+ /// Determines whether the anchor point should be used to determine the position of the actor.<br>
+ /// This is true by default.<br>
+ /// Note: If false, then the top-left of the actor is used for the position.<br>
+ /// Setting this to false will allow scaling or rotation around the anchor-point without affecting the actor's position.<br>
/// </summary>
protected bool PositionUsesAnchorPoint
{
}
/// <summary>
- /// Queries whether the actor is connected to the Stage.
- /// When an actor is connected, it will be directly or indirectly parented to the root Actor.
+ /// Queries whether the actor is connected to the Stage.<br>
+ /// When an actor is connected, it will be directly or indirectly parented to the root Actor.<br>
/// </summary>
public bool IsOnStage
{
}
/// <summary>
- /// Sets the sibling order of the actor so depth position can be defined within the same parent.
- /// Note The initial value is 0.
- /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove and LowerBelow will override the sibling order.
- /// The values set by this Property will likely change.
+ /// Sets the sibling order of the actor so depth position can be defined within the same parent.<br>
+ /// Note The initial value is 0.<br>
+ /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove and LowerBelow will override the sibling order.<br>
+ /// The values set by this Property will likely change.<br>
/// </summary>
public int SiblingOrder
{
}
/// <summary>
- /// Sets the size of an actor for Width and Height.
- /// Geometry can be scaled to fit within this area.
- /// This does not interfere with the actors scale factor.
- /// The actors default depth is the minimum of Width & Height.
+ /// Sets the size of an actor for Width and Height.<br>
+ /// Geometry can be scaled to fit within this area.<br>
+ /// This does not interfere with the actors scale factor.<br>
+ /// The actors default depth is the minimum of Width & Height.<br>
/// </summary>
public Size2D Size2D
{
}
/// <summary>
- /// Sets the position of the Actor for X and Y.
- /// By default, sets the position vector between the parent origin and anchor point(default).
- /// If Position inheritance if disabled, sets the world position.
+ /// Sets the position of the Actor for X and Y.<br>
+ /// By default, sets the position vector between the parent origin and anchor point(default).<br>
+ /// If Position inheritance if disabled, sets the world position.<br>
/// </summary>
public Position2D Position2D
{
}
/// <summary>
- /// Sets the visibility flag of an actor as true to be shown.
- /// Note This is an asynchronous method; the value written may not match a value subsequently read with Visible.
- /// If an actor's visibility flag is set to false, then the actor and its children will not be rendered.
- /// This is regardless of the individual visibility values of the children i.e.an actor will only be rendered if all of its parents have visibility set to true.
+ /// Sets the visibility flag of an actor as true to be shown.<br>
+ /// Note This is an asynchronous method; the value written may not match a value subsequently read with Visible.<br>
+ /// If an actor's visibility flag is set to false, then the actor and its children will not be rendered.<br>
+ /// This is regardless of the individual visibility values of the children i.e.an actor will only be rendered if all of its parents have visibility set to true.<br>
/// </summary>
public void Show()
{
}
/// <summary>
- /// Raise actor above the next highest level of actor(s).
- /// Note Sibling order of actors within the parent will be updated automatically.
- /// Initially actors added to a parent will have the same sibling order and shown in relation to insertion order.
- /// Raising this actor above actors with the same sibling order as each other will raise this actor above them.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
+ /// Raise actor above the next highest level of actor(s).<br>
+ /// Note Sibling order of actors within the parent will be updated automatically.<br>
+ /// Initially actors added to a parent will have the same sibling order and shown in relation to insertion order.<br>
+ /// Raising this actor above actors with the same sibling order as each other will raise this actor above them.<br>
+ /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
/// </summary>
public void Raise()
{
}
/// <summary>
- /// Lower the actor to underneath the level below actor(s).
- /// Note Sibling order of actors within the parent will be updated automatically.
- /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
+ /// Lower the actor to underneath the level below actor(s).<br>
+ /// Note Sibling order of actors within the parent will be updated automatically.<br>
+ /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.<br>
+ /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
/// </summary>
public void Lower()
{
}
/// <summary>
- /// Raise actor above all other actors.
- /// Note Sibling order of actors within the parent will be updated automatically.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
+ /// Raise actor above all other actors.<br>
+ /// Note Sibling order of actors within the parent will be updated automatically.<br>
+ /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
/// </summary>
public void RaiseToTop()
{
}
/// <summary>
- /// Lower actor to the bottom of all actors.
- /// Note Sibling order of actors within the parent will be updated automatically.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
+ /// Lower actor to the bottom of all actors.<br>
+ /// Note Sibling order of actors within the parent will be updated automatically.<br>
+ /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
/// </summary>
public void LowerToBottom()
{
}
/// <summary>
- /// Raise the actor to above the target actor.
- /// Note Sibling order of actors within the parent will be updated automatically.
- /// Actors on the level above the target actor will still be shown above this actor.
- /// Raising this actor above actors with the same sibling order as each other will raise this actor above them.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
+ /// Raise the actor to above the target actor.<br>
+ /// Note Sibling order of actors within the parent will be updated automatically.<br>
+ /// Actors on the level above the target actor will still be shown above this actor.<br>
+ /// Raising this actor above actors with the same sibling order as each other will raise this actor above them.<br>
+ /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
/// </summary>
/// <param name="target">Will be raised above this actor</param>
public void RaiseAbove(Actor target)
}
/// <summary>
- /// Lower the actor to below the target actor.
- /// Note Sibling order of actors within the parent will be updated automatically.
- /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.
- /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.
+ /// Lower the actor to below the target actor.<br>
+ /// Note Sibling order of actors within the parent will be updated automatically.<br>
+ /// Lowering this actor below actors with the same sibling order as each other will lower this actor above them.<br>
+ /// Once a raise or lower API is used that actor will then have an exclusive sibling order independent of insertion.<br>
/// </summary>
/// <param name="target">Will be lowered below this actor</param>
public void LowerBelow(Actor target)
}
/// <summary>
- /// Downcasts a handle to Actor handle.
- /// If handle points to an Actor object, the downcast produces valid handle.
- /// If not, the returned handle is left uninitialized. *
+ /// Downcasts a handle to Actor handle.<br>
+ /// If handle points to an Actor object, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">handle to An object</param>
/// <returns>handle to a Actor object or an uninitialized handle</returns>
}
/// <summary>
- /// Adds a child Actor to this Actor.
- /// Precondition : This Actor(the parent) has been initialized. The child actor has been initialized. The child actor is not the same as the parent actor.
- /// PostCondition : The child will be referenced by its parent. This means that the child will be kept alive, even if the handle passed into this method is reset or destroyed.
- /// Note : If the child already has a parent, it will be removed from old parent and reparented to this actor. This may change child's position, color, scale etc as it now inherits them from this actor.
+ /// Adds a child Actor to this Actor.<br>
+ /// Precondition : This Actor(the parent) has been initialized. The child actor has been initialized. The child actor is not the same as the parent actor.<br>
+ /// PostCondition : The child will be referenced by its parent. This means that the child will be kept alive, even if the handle passed into this method is reset or destroyed.<br>
+ /// Note : If the child already has a parent, it will be removed from old parent and reparented to this actor. This may change child's position, color, scale etc as it now inherits them from this actor.<br>
/// </summary>
/// <param name="child">The child</param>
public void Add(Actor child)
}
/// <summary>
- /// Removes a child Actor from this Actor. If the actor was not a child of this actor, this is a no-op.
- /// Precondition : This Actor(the parent) has been initialized. The child actor is not the same as the parent actor.
+ /// Removes a child Actor from this Actor. If the actor was not a child of this actor, this is a no-op.<br>
+ /// Precondition : This Actor(the parent) has been initialized. The child actor is not the same as the parent actor.<br>
/// </summary>
/// <param name="child">The child</param>
public void Remove(Actor child)
}
/// <summary>
- /// Retrieves the number of children held by the actor.
- /// Precondition : The Actor has been initialized.
+ /// Retrieves the number of children held by the actor.<br>
+ /// Precondition : The Actor has been initialized.<br>
/// </summary>
/// <returns>The number of children</returns>
public uint GetChildCount()
}
/// <summary>
- /// Retrieve and child actor by index.
- /// Precondition : The Actor has been initialized.
+ /// Retrieve and child actor by index.<br>
+ /// Precondition : The Actor has been initialized.<br>
/// </summary>
/// <param name="index">The index of the child to retrieve</param>
/// <returns>The actor for the given index or empty handle if children not initialized</returns>
}
/// <summary>
- /// Search through this actor's hierarchy for an actor with the given name.
- /// The actor itself is also considered in the search.
- ///Precondition : The Actor has been initialized.
+ /// Search through this actor's hierarchy for an actor with the given name.<br>
+ /// The actor itself is also considered in the search.<br>
+ ///Precondition : The Actor has been initialized.<br>
/// </summary>
/// <param name="actorName">The name of the actor to find</param>
/// <returns>A handle to the actor if found, or an empty handle if not</returns>
}
/// <summary>
- /// Returns the natural size of the actor.
- /// Deriving classes stipulate the natural size and by default an actor has a ZERO natural size.
+ /// Returns the natural size of the actor.<br>
+ /// Deriving classes stipulate the natural size and by default an actor has a ZERO natural size.<br>
/// </summary>
/// <returns>The actor's natural size</returns>
public Vector3 GetNaturalSize()
}
/// <summary>
- /// Converts screen coordinates into the actor's coordinate system using the default camera.
- /// Precondition : The Actor has been initialized.
- /// Note : The actor coordinates are relative to the top-left(0.0, 0.0, 0.5)
+ /// Converts screen coordinates into the actor's coordinate system using the default camera.<br>
+ /// Precondition : The Actor has been initialized.<br>
+ /// Note : The actor coordinates are relative to the top-left(0.0, 0.0, 0.5).<br>
/// </summary>
/// <param name="localX">On return, the X-coordinate relative to the actor</param>
/// <param name="localY">On return, the Y-coordinate relative to the actor</param>
}
/// <summary>
- /// Sets the relative to parent size factor of the actor.
- /// This factor is only used when ResizePolicy is set to either
- /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicy
- /// Precondition : The Actor has been initialized.
+ /// Sets the relative to parent size factor of the actor.<br>
+ /// This factor is only used when ResizePolicy is set to either.<br>
+ /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicy.<br>
+ /// Precondition : The Actor has been initialized.<br>
/// </summary>
/// <param name="factor">A Vector3 representing the relative factor to be applied to each axis</param>
public void SetSizeModeFactor(Vector3 factor)
}
/// <summary>
- /// Calculates the height of the actor given a width.
- /// The natural size is used for default calculation.
- /// size 0 is treated as aspect ratio 1:1.
+ /// Calculates the height of the actor given a width.<br>
+ /// The natural size is used for default calculation. <br>
+ /// size 0 is treated as aspect ratio 1:1.<br>
/// </summary>
/// <param name="width">Width to use</param>
/// <returns>the height based on the width</returns>
}
/// <summary>
- /// Calculates the width of the actor given a height.
- /// The natural size is used for default calculation.
- /// size 0 is treated as aspect ratio 1:1.
+ /// Calculates the width of the actor given a height.<br>
+ /// The natural size is used for default calculation.<br>
+ /// size 0 is treated as aspect ratio 1:1.<br>
/// </summary>
/// <param name="height">Height to use</param>
/// <returns>the width based on the height</returns>
}
/// <summary>
- /// Sets the padding for use in layout.
+ /// Sets the padding for use in layout.<br>
/// </summary>
/// <param name="padding">padding Padding for the actor</param>
public void SetPadding(PaddingType padding)
}
/// <summary>
- /// Returns the value of the padding.
+ /// Returns the value of the padding.<br>
/// </summary>
/// <param name="paddingOut">The returned padding data</param>
public void GetPadding(PaddingType paddingOut)
}
/// <summary>
- /// Gets/Sets the origin of an actor, within its parent's area.
- /// This is expressed in unit coordinates, such that(0.0, 0.0, 0.5) is the top-left corner of the parent, and(1.0, 1.0, 0.5) is the bottom-right corner.
- /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).
- /// An actor's position is the distance between this origin, and the actor's anchor-point.
- /// Precondition : The Actor has been initialized.
+ /// Gets/Sets the origin of an actor, within its parent's area.<br>
+ /// This is expressed in unit coordinates, such that(0.0, 0.0, 0.5) is the top-left corner of the parent, and(1.0, 1.0, 0.5) is the bottom-right corner.<br>
+ /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).<br>
+ /// An actor's position is the distance between this origin, and the actor's anchor-point.<br>
+ /// Precondition : The Actor has been initialized.<br>
/// </summary>
public Position ParentOrigin
{
}
/// <summary>
- /// Gets/Sets the anchor-point of an actor.
- /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the actor, and(1.0, 1.0, 0.5) is the bottom-right corner.
- /// The default anchor point is AnchorPoint.Center (0.5, 0.5, 0.5).
- /// An actor position is the distance between its parent-origin and this anchor-point.
- /// An actor's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.
+ /// Gets/Sets the anchor-point of an actor.<br>
+ /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the actor, and(1.0, 1.0, 0.5) is the bottom-right corner.<br>
+ /// The default anchor point is AnchorPoint.Center (0.5, 0.5, 0.5).<br>
+ /// An actor position is the distance between its parent-origin and this anchor-point.<br>
+ /// An actor's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.<br>
/// Precondition : The Actor has been initialized.
/// </summary>
public Position AnchorPoint
/// <summary>
- /// Gets/Sets the size of an actor.
- /// Geometry can be scaled to fit within this area.
- /// This does not interfere with the actors scale factor.
+ /// Gets/Sets the size of an actor.<br>
+ /// Geometry can be scaled to fit within this area.<br>
+ /// This does not interfere with the actors scale factor.<br>
/// </summary>
public Size Size
{
}
/// <summary>
- /// Gets/Sets the position of the Actor.
- /// By default, sets the position vector between the parent origin and anchor point(default).
- /// If Position inheritance if disabled, sets the world position.
+ /// Gets/Sets the position of the Actor.<br>
+ /// By default, sets the position vector between the parent origin and anchor point(default).<br>
+ /// If Position inheritance if disabled, sets the world position.<br>
/// </summary>
public Position Position
{
}
/// <summary>
- /// Gets/Sets the orientation of the Actor.
- /// An actor's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.
- /// Note: This is an asynchronous method.
+ /// Gets/Sets the orientation of the Actor.<br>
+ /// An actor's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.<br>
+ /// Note: This is an asynchronous method.<br>
/// </summary>
public Rotation Orientation
{
}
/// <summary>
- /// Gets/Sets the world orientation of the Actor.
+ /// Gets/Sets the world orientation of the Actor.<br>
/// </summary>
public Rotation WorldOrientation
{
}
/// <summary>
- /// Gets/Sets the scale factor applied to an actor.
- /// Note : This is an asynchronous method.
+ /// Gets/Sets the scale factor applied to an actor.<br>
+ /// Note : This is an asynchronous method.<br>
/// </summary>
public Vector3 Scale
{
}
/// <summary>
- /// Retrieves the visibility flag of an actor.
- /// Note : If an actor is not visible, then the actor and its children will not be rendered.
- /// This is regardless of the individual visibility values of the children i.e.an actor will only be rendered if all of its parents have visibility set to true.
+ /// Retrieves the visibility flag of an actor.<br>
+ /// Note : If an actor is not visible, then the actor and its children will not be rendered.<br>
+ /// This is regardless of the individual visibility values of the children i.e.an actor will only be rendered if all of its parents have visibility set to true.<br>
/// </summary>
public bool Visible
{
}
/// <summary>
- /// Gets/Sets the actor's color mode.
- /// This specifies whether the Actor uses its own color, or inherits its parent color.
- /// The default is UseOwnMultiplyParentAlpha.
+ /// Gets/Sets the actor's color mode.<br>
+ /// This specifies whether the Actor uses its own color, or inherits its parent color.<br>
+ /// The default is UseOwnMultiplyParentAlpha.<br>
/// </summary>
public ColorMode ColorMode
{
/// <summary>
- /// Gets/Sets the status of how the actor and its children should be drawn.
- /// Not all actors are renderable, but DrawMode can be inherited from any actor.
- /// If an object is in a 3D layer, it will be depth-tested against other objects in the world i.e. it may be obscured if other objects are in front.
- /// If DrawMode.Overlay2D is used, the actor and its children will be drawn as a 2D overlay.
- /// Overlay actors are drawn in a separate pass, after all non-overlay actors within the Layer.
- /// For overlay actors, the drawing order is with respect to tree levels of Actors, and depth-testing will not be used.
+ /// Gets/Sets the status of how the actor and its children should be drawn.<br>
+ /// Not all actors are renderable, but DrawMode can be inherited from any actor.<br>
+ /// If an object is in a 3D layer, it will be depth-tested against other objects in the world i.e. it may be obscured if other objects are in front.<br>
+ /// If DrawMode.Overlay2D is used, the actor and its children will be drawn as a 2D overlay.<br>
+ /// Overlay actors are drawn in a separate pass, after all non-overlay actors within the Layer.<br>
+ /// For overlay actors, the drawing order is with respect to tree levels of Actors, and depth-testing will not be used.<br>
/// </summary>
public DrawModeType DrawMode
{
}
/// <summary>
- /// Gets/Sets the relative to parent size factor of the actor.
- /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.
- /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicyType.
+ /// Gets/Sets the relative to parent size factor of the actor.<br>
+ /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.<br>
+ /// This actor's size is set to the actor's size multiplied by or added to this factor, depending on ResizePolicyType.<br>
/// </summary>
public Vector3 SizeModeFactor
{
}
/// <summary>
- /// Gets/Sets the policy to use when setting size with size negotiation.
- /// Defaults to SizeScalePolicyType.UseSizeSet.
+ /// Gets/Sets the policy to use when setting size with size negotiation.<br>
+ /// Defaults to SizeScalePolicyType.UseSizeSet.<br>
/// </summary>
public SizeScalePolicyType SizeScalePolicy
{
}
/// <summary>
- /// Gets/Sets whether a child actor inherits it's parent's position.
- /// Default is to inherit.
- /// Switching this off means that using Position sets the actor's world position, i.e. translates from the world origin(0,0,0) to the anchor point of the actor.
+ /// Gets/Sets whether a child actor inherits it's parent's position.<br>
+ /// Default is to inherit.<br>
+ /// Switching this off means that using Position sets the actor's world position, i.e. translates from the world origin(0,0,0) to the anchor point of the actor.<br>
/// </summary>
public bool InheritPosition
{
}
/// <summary>
- /// Gets/Sets clipping behavior(mode) of it's children
+ /// Gets/Sets clipping behavior(mode) of it's children.
/// </summary>
public ClippingModeType ClippingMode
{
}
/// <summary>
- /// This specifies whether the Actor uses its own color, or inherits
- /// ColorMode.UseOwnColor : Actor will use its own color
- /// ColorMode.UseParentColor : Actor will use its parent color
- /// ColorMode.UseOwnMultiplyParentColor : Actor will blend its color with its parents color.
- /// ColorMode.UseOwnMultiplyParentAlpha : Actor will blend its alpha with its parents alpha. This means when parent fades in or out child does as well. This is the default.
+ /// This specifies whether the Actor uses its own color, or inherits.<br>
+ /// ColorMode.UseOwnColor : Actor will use its own color.<br>
+ /// ColorMode.UseParentColor : Actor will use its parent color.<br>
+ /// ColorMode.UseOwnMultiplyParentColor : Actor will blend its color with its parents color.<br>
+ /// ColorMode.UseOwnMultiplyParentAlpha : Actor will blend its alpha with its parents alpha. This means when parent fades in or out child does as well. This is the default.<br>
/// </summary>
public enum ColorMode
{
{
/// <summary>
- /// Alpha functions are used in animations to specify the rate of change of the animation parameter over time.
+ /// Alpha functions are used in animations to specify the rate of change of the animation parameter over time.<br>
/// Understanding an animation as a parametric function over time, the alpha function is applied to the parameter of
/// the animation before computing the final animation value.
/// </summary>
}
/// <summary>
- /// Constructor.
- /// Creates an alpha function object with user defined alpha function.
+ /// Constructor.<br>
+ /// Creates an alpha function object with user defined alpha function.<br>
/// </summary>
/// <param name="func">User defined fuction. It must be a method formatted as float alphafunction(float progress)</param>
public AlphaFunction(System.Delegate func) : this(NDalicPINVOKE.new_AlphaFunction__SWIG_2(SWIGTYPE_p_f_float__float.getCPtr(new SWIGTYPE_p_f_float__float(System.Runtime.InteropServices.Marshal.GetFunctionPointerForDelegate(func), true))), true)
}
/// <summary>
- /// Default constructor.
- /// Creates an alpha function object with the default built-in alpha function.
+ /// Default constructor.<br>
+ /// Creates an alpha function object with the default built-in alpha function.<br>
/// </summary>
public AlphaFunction() : this(NDalicPINVOKE.new_AlphaFunction__SWIG_0(), true)
{
}
/// <summary>
- /// Constructor.
- /// Creates an alpha function object with the built-in alpha function passed as a parameter to the constructor.
+ /// Constructor.<br>
+ /// Creates an alpha function object with the built-in alpha function passed as a parameter to the constructor.<br>
/// </summary>
/// <param name="function">One of the built-in alpha functions</param>
public AlphaFunction(AlphaFunction.BuiltinFunctions function) : this(NDalicPINVOKE.new_AlphaFunction__SWIG_1((int)function), true)
}
/// <summary>
- /// Constructor.
- /// Creates a bezier alpha function.The bezier will have the first point at(0,0) and the end point at(1,1).
- /// Note : The x components of the control points will be clamped to the range[0, 1] to prevent non monotonic curves.
+ /// Constructor.<br>
+ /// Creates a bezier alpha function.The bezier will have the first point at(0,0) and the end point at(1,1).<br>
+ /// Note : The x components of the control points will be clamped to the range[0, 1] to prevent non monotonic curves.<br>
/// </summary>
/// <param name="controlPoint0">A Vector2 which will be used as the first control point of the curve</param>
/// <param name="controlPoint1">A Vector2 which will be used as the second control point of the curve</param>
}
/// <summary>
- /// Retrives the control points of the alpha function.
+ /// Retrives the control points of the alpha function.<br>
/// </summary>
/// <param name="controlPoint0">A Vector2 which is used as the first control point of the curve</param>
/// <param name="controlPoint1">A Vector2 which is used as the second control point of the curve</param>
}
/// <summary>
- /// Returns the built-in function used by the alpha function.
- /// In case no built-in function has been specified, it will return AlphaFunction::DEFAULT
+ /// Returns the built-in function used by the alpha function.<br>
+ /// In case no built-in function has been specified, it will return AlphaFunction::DEFAULT.<br>
/// </summary>
/// <returns>One of the built-in alpha functions.</returns>
public AlphaFunction.BuiltinFunctions GetBuiltinFunction()
using System.Runtime.InteropServices;
/// <summary>
- /// Animation can be used to animate the properties of any number of objects, typically Actors.
- /// If the "Finished" event is connected to a member function of an object, it must be disconnected before the object is destroyed.
- /// This is typically done in the object destructor, and requires either the Animation handle to be stored.
- /// The overall animation time is superseded by the values given in the Duration property used when calling the AnimateTo(), AnimateBy(), AnimateBetween() and AnimatePath() methods.
- /// If any of the individual calls to those functions exceeds the overall animation time(Duration), then the overall animation time is automatically extended.
+ /// Animation can be used to animate the properties of any number of objects, typically Actors.<br>
+ /// If the "Finished" event is connected to a member function of an object, it must be disconnected before the object is destroyed.<br>
+ /// This is typically done in the object destructor, and requires either the Animation handle to be stored.<br>
+ /// The overall animation time is superseded by the values given in the Duration property used when calling the AnimateTo(), AnimateBy(), AnimateBetween() and AnimatePath() methods.<br>
+ /// If any of the individual calls to those functions exceeds the overall animation time(Duration), then the overall animation time is automatically extended.<br>
/// </summary>
public class Animation : BaseHandle
{
}
/// <summary>
- /// Create an initialized Animation.
- /// The animation will not loop.
- /// The default end action is "Cancel".
- /// The default Alpha function is linear.
- /// Precodition : DurationmSeconds must be greater than zero.
+ /// Create an initialized Animation.<br>
+ /// The animation will not loop.<br>
+ /// The default end action is "Cancel".<br>
+ /// The default Alpha function is linear.<br>
+ /// Precodition : DurationmSeconds must be greater than zero.<br>
/// </summary>
/// <param name="durationMilliSeconds">The duration in milli seconds (int).</param>
public Animation(int durationMilliSeconds) : this(NDalicPINVOKE.Animation_New((float)durationMilliSeconds / 1000.0f), true)
private delegate void AnimationFinishedEventCallbackType(IntPtr data);
private event EventHandler _animationFinishedEventHandler;
/**
- * @brief Event for Finished signal which can be used to subscribe/unsubscribe the event handler
+ * @brief Event for Finished signal which can be used to subscribe/unsubscribe the event handler.
* Finished signal is emitted when an Animation's animations have finished.
*/
public event EventHandler Finished
/// <summary>
- /// Gets/Sets the duration of animation
+ /// Gets/Sets the duration of animation.
/// </summary>
public int Duration
{
}
/// <summary>
- /// Set : Enables looping for 'count' repeats. A zero is the same as Looping = true; i.e.repeat forever.
- /// If Play() Stop() or 'count' loops is reached, the loop counter will reset.
- /// Setting this parameter does not cause the animation to Play().
- ///
- /// Get : Gets the loop count. A zero is the same as Looping = true; ie repeat forever.
- /// The loop count is initially 1 for play once.
+ /// Set : Enables looping for 'count' repeats. A zero is the same as Looping = true; i.e.repeat forever.<br>
+ /// If Play() Stop() or 'count' loops is reached, the loop counter will reset.<br>
+ /// Setting this parameter does not cause the animation to Play().<br>
+ /// Get : Gets the loop count. A zero is the same as Looping = true; ie repeat forever.<br>
+ /// The loop count is initially 1 for play once.<br>
/// </summary>
public int LoopCount
{
}
/// <summary>
- /// Gets/Sets the status of whether the animation will loop.
- /// This property resets the loop count and should not be used with LoopCount property.
- /// Setting this parameter does not cause the animation to Play().
+ /// Gets/Sets the status of whether the animation will loop.<br>
+ /// This property resets the loop count and should not be used with LoopCount property.<br>
+ /// Setting this parameter does not cause the animation to Play().<br>
/// </summary>
public bool Looping
{
/// <summary>
- /// Gets/Sets the end action of the animation.
- /// This action is performed when the animation ends or if it is stopped.
- /// Default end action is Cancel
+ /// Gets/Sets the end action of the animation.<br>
+ /// This action is performed when the animation ends or if it is stopped.<br>
+ /// Default end action is Cancel.<br>
/// </summary>
public EndActions EndAction
{
}
/// <summary>
- /// Gets the current loop count.
- /// A value 0 to CurrentLoop indicating the current loop count when looping.
+ /// Gets the current loop count.<br>
+ /// A value 0 to CurrentLoop indicating the current loop count when looping.<br>
/// </summary>
public int CurrentLoop
{
}
/// <summary>
- /// Gets/Sets the disconnect action.
- /// If any of the animated property owners are disconnected from the stage while the animation is being played, then this action is performed.
- /// Default action is to Cancel.
+ /// Gets/Sets the disconnect action.<br>
+ /// If any of the animated property owners are disconnected from the stage while the animation is being played, then this action is performed.<br>
+ /// Default action is to Cancel.<br>
/// </summary>
public EndActions DisconnectAction
{
/// <summary>
- /// Gets/Sets the progress of the animation.
- /// The animation will play(or continue playing) from this point.
- /// The progress must be in the 0-1 interval or in the play range interval if defined
- /// otherwise, it will be ignored.
+ /// Gets/Sets the progress of the animation.<br>
+ /// The animation will play(or continue playing) from this point.<br>
+ /// The progress must be in the 0-1 interval or in the play range interval if defined.<br>
+ /// otherwise, it will be ignored.<br>
/// </summary>
public float CurrentProgress
{
}
/// <summary>
- /// Gets/Sets Specifies a speed factor for the animation.
- /// The speed factor is a multiplier of the normal velocity of the animation.
- /// Values between[0, 1] will slow down the animation and values above one will speed up the animation.
- /// It is also possible to specify a negative multiplier to play the animation in reverse.
+ /// Gets/Sets Specifies a speed factor for the animation.<br>
+ /// The speed factor is a multiplier of the normal velocity of the animation.<br>
+ /// Values between[0, 1] will slow down the animation and values above one will speed up the animation.<br>
+ /// It is also possible to specify a negative multiplier to play the animation in reverse.<br>
/// </summary>
public float SpeedFactor
{
}
/// <summary>
- /// Gets/Sets the playing range.
+ /// Gets/Sets the playing range.<br>
/// Animation will play between the values specified. Both values(range.x and range.y ) should be between 0-1,
- /// otherwise they will be ignored.If the range provided is not in proper order(minimum, maximum ), it will be reordered.
+ /// otherwise they will be ignored.If the range provided is not in proper order(minimum, maximum ), it will be reordered.<br>
/// </summary>
public Vector2 PlayRange
{
}
/// <summary>
- /// Animates a property value by a relative amount.
- /// The default alpha function will be used.
- /// The effect will start & end when the animation begins & ends.
+ /// Animates a property value by a relative amount.<br>
+ /// The default alpha function will be used.<br>
+ /// The effect will start & end when the animation begins & ends.<br>
/// </summary>
/// <param name="target">The target object to animate</param>
/// <param name="property">The target property to animate</param>
}
/// <summary>
- /// Animates a property value by a relative amount.
- /// The default alpha function will be used.
- /// The effect will start & end when the animation begins & ends.
+ /// Animates a property value by a relative amount.<br>
+ /// The default alpha function will be used.<br>
+ /// The effect will start & end when the animation begins & ends.<br>
/// </summary>
/// <param name="target">The target object to animate</param>
/// <param name="property">The target property to animate</param>
}
/// <summary>
- /// Animates a property to a destination value.
- /// The default alpha function will be used.
- /// The effect will start & end when the animation begins & ends.
+ /// Animates a property to a destination value.<br>
+ /// The default alpha function will be used.<br>
+ /// The effect will start & end when the animation begins & ends.<br>
/// </summary>
/// <param name="target">The target object to animate</param>
/// <param name="property">The target property to animate</param>
}
/// <summary>
- /// Animates a property to a destination value.
- /// The default alpha function will be used.
- /// The effect will start & end when the animation begins & ends.
+ /// Animates a property to a destination value.<br>
+ /// The default alpha function will be used.<br>
+ /// The effect will start & end when the animation begins & ends.<br>
/// </summary>
/// <param name="target">The target object to animate</param>
/// <param name="property">The target property to animate</param>
}
/// <summary>
- /// Animates an actor's position and orientation through a predefined path.
- /// The actor will rotate to orient the supplied forward vector with the path's tangent.
- /// If forward is the zero vector then no rotation will happen.
+ /// Animates an actor's position and orientation through a predefined path.<br>
+ /// The actor will rotate to orient the supplied forward vector with the path's tangent.<br>
+ /// If forward is the zero vector then no rotation will happen.<br>
/// </summary>
/// <param name="actor">The actor to animate</param>
/// <param name="path">It defines position and orientation</param>
}
/// <summary>
- /// Animates an actor's position and orientation through a predefined path.
- /// The actor will rotate to orient the supplied forward vector with the path's tangent.
- /// If forward is the zero vector then no rotation will happen.
+ /// Animates an actor's position and orientation through a predefined path.<br>
+ /// The actor will rotate to orient the supplied forward vector with the path's tangent.<br>
+ /// If forward is the zero vector then no rotation will happen.<br>
/// </summary>
/// <param name="actor">The actor to animate</param>
/// <param name="path">It defines position and orientation</param>
}
/// <summary>
- /// Creates an initialized Animation.
- /// The animation will not loop.
- /// The default end action is "Cancel".
- /// The default alpha function is linear.
+ /// Creates an initialized Animation.<br>
+ /// The animation will not loop.<br>
+ /// The default end action is "Cancel".<br>
+ /// The default alpha function is linear.<br>
/// </summary>
public Animation() : this(NDalicPINVOKE.Animation_New(0.0f), true)
{
}
/// <summary>
- /// Downcasts a handle to Animation handle.
- /// If handle points to an Animation object, the downcast produces valid handle.
- /// If not, the returned handle is left uninitialized.
+ /// Downcasts a handle to Animation handle.<br>
+ /// If handle points to an Animation object, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>Handle to an Animation object or an uninitialized handle</returns>
}
/// <summary>
- /// Plays the animation from a given point.
- /// The progress must be in the 0-1 interval or in the play range interval if defined
- /// otherwise, it will be ignored.
+ /// Plays the animation from a given point.<br>
+ /// The progress must be in the 0-1 interval or in the play range interval if defined,
+ /// otherwise, it will be ignored.<br>
/// </summary>
/// <param name="progress">A value between [0,1], or between the play range if specified, from where the animation should start playing</param>
public void PlayFrom(float progress)
}
/// <summary>
- /// Clears the animation.
- /// This disconnects any objects that were being animated, effectively stopping the animation.
+ /// Clears the animation.<br>
+ /// This disconnects any objects that were being animated, effectively stopping the animation.<br>
/// </summary>
public void Clear()
{
}
/// <summary>
- /// Enumeration for what to do when the animation ends, is stopped, or is destroyed.
- /// Cancel : When the animation ends, the animated property values are saved.
- /// Discard : When the animation ends, the animated property values are forgotten.
- /// StopFinal : If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Cancel.
+ /// Enumeration for what to do when the animation ends, is stopped, or is destroyed.<br>
+ /// Cancel : When the animation ends, the animated property values are saved.<br>
+ /// Discard : When the animation ends, the animated property values are forgotten.<br>
+ /// StopFinal : If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Cancel.<br>
/// </summary>
public enum EndActions
{
}
/// <summary>
- /// Enumeration for what interpolation method to use on key-frame animations.
- /// Linear : Values in between key frames are interpolated using a linear polynomial. (Default)
- /// Cubic : Values in between key frames are interpolated using a cubic polynomial.
+ /// Enumeration for what interpolation method to use on key-frame animations.<br>
+ /// Linear : Values in between key frames are interpolated using a linear polynomial. (Default).<br>
+ /// Cubic : Values in between key frames are interpolated using a cubic polynomial.<br>
/// </summary>
public enum Interpolation
{
}
/// <summary>
- /// Enumeration for what state the animation is in.
- /// Note: Calling Reset() on this class will NOT reset the animation. It will call BaseHandle.Reset() which drops the object handle.
+ /// Enumeration for what state the animation is in.<br>
+ /// Note: Calling Reset() on this class will NOT reset the animation. It will call BaseHandle.Reset() which drops the object handle.<br>
/// </summary>
public enum States
{
using System.Runtime.InteropServices;
/// <summary>
- /// Button is a base class for different kinds of buttons.
- /// This class provides the disabled property and the clicked signal.
- /// A Clicked event handler is emitted when the button is touched and the touch point doesn't leave the boundary of the button.
- /// When the disabled property is set to true, no signal is emitted.
- /// 'Visual' describes not just traditional images like png, bmp but refers to whatever is used to show the button, it could be a color, gradient or some other kind of renderer.
- /// The button's appearance can be modified by setting properties for the various visuals/images.
- /// It is not mandatory to set all visuals. A button could be defined only by setting its background visual or by setting its background and selected visuals.
- /// The button visual is shown over the background visual.
- /// When pressed the unselected visuals are replaced by the selected visual.
- /// The text label is always placed on the top of all images.
- /// When the button is disabled, background, button and selected visuals are replaced by their disabled visuals.
+ /// Button is a base class for different kinds of buttons.<br>
+ /// This class provides the disabled property and the clicked signal.<br>
+ /// A Clicked event handler is emitted when the button is touched and the touch point doesn't leave the boundary of the button.<br>
+ /// When the disabled property is set to true, no signal is emitted.<br>
+ /// 'Visual' describes not just traditional images like png, bmp but refers to whatever is used to show the button, it could be a color, gradient or some other kind of renderer.<br>
+ /// The button's appearance can be modified by setting properties for the various visuals/images.<br>
+ /// It is not mandatory to set all visuals. A button could be defined only by setting its background visual or by setting its background and selected visuals.<br>
+ /// The button visual is shown over the background visual.<br>
+ /// When pressed the unselected visuals are replaced by the selected visual.<br>
+ /// The text label is always placed on the top of all images.<br>
+ /// When the button is disabled, background, button and selected visuals are replaced by their disabled visuals.<br>
/// </summary>
public class Button : View
{
private delegate bool ClickedCallbackType(global::System.IntPtr data);
private ClickedCallbackType _clickedCallback;
+ /// <summary>
+ /// Clicked will be triggered when the button is touched and the touch point doesn't leave the boundary of the button.
+ /// </summary>
public event EventHandlerWithReturnType<object, EventArgs, bool> Clicked
{
add
private delegate bool PressedCallbackType(global::System.IntPtr data);
private PressedCallbackType _pressedCallback;
+ /// <summary>
+ /// Pressed will be triggered when the button is touched.
+ /// </summary>
public event EventHandlerWithReturnType<object, EventArgs, bool> Pressed
{
add
private delegate bool ReleasedCallbackType(global::System.IntPtr data);
private ReleasedCallbackType _releasedCallback;
+ /// <summary>
+ /// Released will be triggered when the button is touched and the touch point leaves the boundary of the button.
+ /// </summary>
public event EventHandlerWithReturnType<object, EventArgs, bool> Released
{
add
private delegate bool StateChangedCallback(global::System.IntPtr data);
private StateChangedCallback _stateChangedCallback;
+ /// <summary>
+ /// StateChanged will be triggered when the button's state is changed.
+ /// </summary>
public event EventHandlerWithReturnType<object, EventArgs, bool> StateChanged
{
add
}
/// <summary>
- /// Creates an uninitialized Button.
- /// Only derived versions can be instantiated.
+ /// Creates an uninitialized Button.<br>
+ /// Only derived versions can be instantiated.<br>
/// </summary>
public Button() : this(NDalicPINVOKE.new_Button__SWIG_0(), true)
{
}
/// <summary>
- /// Downcasts a handle to Button handle.
- /// If handle points to a Button, the downcast produces valid handle.
- /// If not the returned handle is left uninitialized.
+ /// Downcasts a handle to Button handle.<br>
+ /// If handle points to a Button, the downcast produces valid handle.<br>
+ /// If not the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>A handle to a Button or an uninitialized handle</returns>
}
/// <summary>
- /// If the autorepeating property is set to true then the togglable property is set to false
+ /// If the autorepeating property is set to true then the togglable property is set to false.
/// </summary>
public bool AutoRepeating
{
}
/// <summary>
- /// default this value is set to 0.05 seconds
+ /// default this value is set to 0.05 seconds.
/// </summary>
public float NextAutoRepeatingDelay
{
}
/// <summary>
- /// Gets/Sets the unselected button foreground image
+ /// Gets/Sets the unselected button foreground image.
/// </summary>
public Tizen.NUI.PropertyMap UnselectedStateImage
{
}
/// <summary>
- /// Gets/Sets the selected button foreground image
+ /// Gets/Sets the selected button foreground image.
/// </summary>
public Tizen.NUI.PropertyMap SelectedStateImage
{
}
/// <summary>
- /// Gets/Sets the disabled whilst unselected foreground button visual
+ /// Gets/Sets the disabled whilst unselected foreground button visual.
/// </summary>
public Tizen.NUI.PropertyMap DisabledStateImage
{
}
/// <summary>
- /// Gets/Sets unselected color
+ /// Gets/Sets unselected color.
/// </summary>
public Color UnselectedColor
{
}
/// <summary>
- /// Gets/Sets selected color
+ /// Gets/Sets selected color.
/// </summary>
public Color SelectedColor
{
}
/// <summary>
- /// Gets/Sets label
+ /// Gets/Sets label.
/// </summary>
public Tizen.NUI.PropertyMap Label
{
}
/// <summary>
- /// Gets/Sets text of label
+ /// Gets/Sets text of label.
/// </summary>
public string LabelText
{
{
/// <summary>
- /// This class will be deprecated.
- /// CameraActor controls a camera.
- /// Allows the developer to use actor semantics to control a camera.
- /// NUI has a concept of a camera to display its virtual 3D world to a 2D screen.
- /// There are 2 ways of using the camera in NUI:
+ /// This class will be deprecated.<br>
+ /// CameraActor controls a camera.<br>
+ /// Allows the developer to use actor semantics to control a camera.<br>
+ /// NUI has a concept of a camera to display its virtual 3D world to a 2D screen.<br>
+ /// There are 2 ways of using the camera in NUI:<br>
/// - For 2D applications, you do not need to care about the camera at all. The default camera is already best suited for 2D applications
- /// (configured to have the origin of the coordinate system at the top-left corner of the screen, and unit 1 as 1 pixel of the screen). This is a typical way.
- /// - For 3D applications, you can change the view by manipulating the camera.You can translate or rotate the camera in this case.
- /// Note that the top-left corner of the screen and unit 1 no longer are (0,0,0) and 1 pixel after manipulating the camera.
- /// There are two types of camera actor, FreeLook and LookAtTarget By default, the camera actor will be FreeLook.
- /// - A FreeLook camera uses actor's orientation to control where the camera is looking.
- /// If no additional rotations are specified, the camera looks in the negative Z direction.
- /// - For LookAtTarget, the actor's orientation is ignored, instead the camera looks at TargetPosition in world coordinates.
+ /// (configured to have the origin of the coordinate system at the top-left corner of the screen, and unit 1 as 1 pixel of the screen). This is a typical way.<br>
+ /// - For 3D applications, you can change the view by manipulating the camera.You can translate or rotate the camera in this case.<br>
+ /// Note that the top-left corner of the screen and unit 1 no longer are (0,0,0) and 1 pixel after manipulating the camera.<br>
+ /// There are two types of camera actor, FreeLook and LookAtTarget By default, the camera actor will be FreeLook.<br>
+ /// - A FreeLook camera uses actor's orientation to control where the camera is looking.<br>
+ /// If no additional rotations are specified, the camera looks in the negative Z direction.<br>
+ /// - For LookAtTarget, the actor's orientation is ignored, instead the camera looks at TargetPosition in world coordinates.<br>
/// /// </summary>
public class CameraActor : Actor
{
}
/// <summary>
- /// Creates a CameraActor object.
- /// Sets the default camera perspective projection for the given canvas size
+ /// Creates a CameraActor object.<br>
+ /// Sets the default camera perspective projection for the given canvas size.<br>
/// </summary>
/// <param name="size">The canvas size</param>
public CameraActor(Size2D size) : this(NDalicPINVOKE.CameraActor_New__SWIG_1(Size2D.getCPtr(size)), true)
}
/// <summary>
- /// Downcasts a handle to CameraActor handle.
- /// If handle points to a CameraActor, the downcast produces valid handle.
- /// If not, the returned handle is left uninitialized.
+ /// Downcasts a handle to CameraActor handle.<br>
+ /// If handle points to a CameraActor, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">to An object</param>
/// <returns>Handle to a CameraActor or an uninitialized handle</returns>
}
/// <summary>
- /// Gets/Sets near plane distance
+ /// Gets/Sets near plane distance.
/// </summary>
public float NearPlaneDistance
{
}
/// <summary>
- /// Gets/Sets far plane distance
+ /// Gets/Sets far plane distance.
/// </summary>
public float FarPlaneDistance
{
}
/// <summary>
- /// Gets/Sets left plane distance
+ /// Gets/Sets left plane distance.
/// </summary>
public float LeftPlaneDistance
{
}
/// <summary>
- /// Gets/Sets right plane distance
+ /// Gets/Sets right plane distance.
/// </summary>
public float RightPlaneDistance
{
}
/// <summary>
- /// Gets/Sets top plane distance
+ /// Gets/Sets top plane distance.
/// </summary>
public float TopPlaneDistance
{
}
/// <summary>
- /// Gets/Sets bottom plane distance
+ /// Gets/Sets bottom plane distance.
/// </summary>
public float BottomPlaneDistance
{
}
/// <summary>
- /// Enumeration for type determination of how camera operates.
- /// FreeLook : Camera orientation is taken from CameraActor
- /// LookAtTarget : Camera is oriented to always look at a target
+ /// Enumeration for type determination of how camera operates.<br>
+ /// FreeLook : Camera orientation is taken from CameraActor.<br>
+ /// LookAtTarget : Camera is oriented to always look at a target.<br>
/// </summary>
public enum CameraType
{
}
/// <summary>
- /// Enumeration for projection modes.
- /// PerspectiveProjection : Distance causes foreshortening; objects further from the camera appear smaller
- /// OrthographicProjection : Relative distance from the camera does not affect the size of objects
+ /// Enumeration for projection modes.<br>
+ /// PerspectiveProjection : Distance causes foreshortening; objects further from the camera appear smaller.<br>
+ /// OrthographicProjection : Relative distance from the camera does not affect the size of objects.<br>
/// </summary>
public enum ProjectionMode
{
{
/// <summary>
- /// CheckBoxButton provides a check box button which user can check or uncheck.
- /// By default, a CheckBoxButton emits a Button.Clicked event when the button changes its state to selected or unselected.
- /// The button's appearance could be modified by Button.UnselectedImage, Button.BackgroundImage, Button.SelectedImage,
- /// Button.SelectedBackgroundImage, Button.DisabledBackgroundImage, Button.DisabledImage, and Button.DisabledSelectedImage.
- /// When the button is not disabled, if it's not selected it only shows the background image.
- /// The selected image is shown over the background image when the box is selected (background image is not replaced by \e selected image).
- /// When the button is disabled, background image and selected image are replaced by disabled images.
+ /// CheckBoxButton provides a check box button which user can check or uncheck.<br>
+ /// By default, a CheckBoxButton emits a Button.Clicked event when the button changes its state to selected or unselected.<br>
+ /// The button's appearance could be modified by Button.UnselectedImage, Button.BackgroundImage, Button.SelectedImage,
+ /// Button.SelectedBackgroundImage, Button.DisabledBackgroundImage, Button.DisabledImage, and Button.DisabledSelectedImage.<br>
+ /// When the button is not disabled, if it's not selected it only shows the background image.<br>
+ /// The selected image is shown over the background image when the box is selected (background image is not replaced by \e selected image).<br>
+ /// When the button is disabled, background image and selected image are replaced by disabled images.<br>
/// /// </summary>
public class CheckBoxButton : Button
{
using System;
/// <summary>
- /// Color class
+ /// Color class.
/// </summary>
public class Color : global::System.IDisposable
{
}
/// <summary>
- /// red component
+ /// red component.
/// </summary>
public float R
{
}
/// <summary>
- /// green component
+ /// green component.
/// </summary>
public float G
{
}
/// <summary>
- /// blue component
+ /// blue component.
/// </summary>
public float B
{
}
/// <summary>
- /// alpha component
+ /// alpha component.
/// </summary>
public float A
{
}
/// <summary>
- /// Get black colored Color class
+ /// Get black colored Color class.
/// </summary>
public static Color Black
{
}
/// <summary>
- /// Get white colored Color class
+ /// Get white colored Color class.
/// </summary>
public static Color White
{
}
/// <summary>
- /// Get red colored Color class
+ /// Get red colored Color class.
/// </summary>
public static Color Red
{
}
/// <summary>
- /// Get green colored Color class
+ /// Get green colored Color class.
/// </summary>
public static Color Green
{
}
/// <summary>
- /// Get blue colored Color class
+ /// Get blue colored Color class.
/// </summary>
public static Color Blue
{
}
/// <summary>
- /// Get yellow colored Color class
+ /// Get yellow colored Color class.
/// </summary>
public static Color Yellow
{
}
/// <summary>
- /// Get magenta colored Color class
+ /// Get magenta colored Color class.
/// </summary>
public static Color Magenta
{
}
/// <summary>
- /// Get cyan colored Color class
+ /// Get cyan colored Color class.
/// </summary>
public static Color Cyan
{
}
/// <summary>
- /// Get transparent colored Color class
+ /// Get transparent colored Color class.
/// </summary>
public static Color Transparent
{
viewWrapperImpl.SetBackground(map);
}
- /**
- * @brief Allows deriving classes to enable any of the gesture detectors that are available.
- *
- * Gesture detection can be enabled one at a time or in bitwise format as shown:
- * @code
- * EnableGestureDetection(Gesture.Type.Pinch | Gesture.Type.Tap | Gesture.Type.Pan));
- * @endcode
- * @param[in] type The gesture type(s) to enable.
- */
+ /// <summary>
+ /// Allows deriving classes to enable any of the gesture detectors that are available.<br>
+ /// Gesture detection can be enabled one at a time or in bitwise format.<br>
+ /// </summary>
+ /// <param name="type">The gesture type(s) to enable</param>
public void EnableGestureDetection(Gesture.GestureType type)
{
viewWrapperImpl.EnableGestureDetection(type);
}
- /**
- * @brief Allows deriving classes to disable any of the gesture detectors.
- *
- * Like EnableGestureDetection, this can also be called using bitwise or.
- * @param[in] type The gesture type(s) to disable.
- * @see EnableGetureDetection
- */
+ /// <summary>
+ /// Allows deriving classes to disable any of the gesture detectors.<br>
+ /// Like EnableGestureDetection, this can also be called using bitwise or one at a time.<br>
+ /// </summary>
+ /// <param name="type">The gesture type(s) to disable</param>
internal void DisableGestureDetection(Gesture.GestureType type)
{
viewWrapperImpl.DisableGestureDetection(type);
/// <summary>
/// Sets whether this control supports two dimensional keyboard navigation
- /// (i.e. whether it knows how to handle the keyboard focus movement between its child actors).
- /// The control doesn't support it by default.
+ /// (i.e. whether it knows how to handle the keyboard focus movement between its child actors).<br>
+ /// The control doesn't support it by default.<br>
/// </summary>
/// <param name="isSupported">Whether this control supports two dimensional keyboard navigation.</param>
public bool FocusNavigationSupport
viewWrapperImpl.SetKeyboardNavigationSupport(isSupported);
}
-
- /**
- * @brief Gets whether this control supports two dimensional keyboard navigation.
- *
- * @return true if this control supports two dimensional keyboard navigation.
- */
+ /// <summary>
+ /// Gets whether this control supports two dimensional keyboard navigation.
+ /// </summary>
+ /// <returns>true if this control supports two dimensional keyboard navigation</returns>
internal bool IsKeyboardNavigationSupported()
{
return viewWrapperImpl.IsKeyboardNavigationSupported();
}
}
- /**
- * @brief Sets whether this control is a focus group for keyboard navigation.
- *
- * (i.e. the scope of keyboard focus movement
- * can be limitied to its child actors). The control is not a focus group by default.
- * @param[in] isFocusGroup Whether this control is set as a focus group for keyboard navigation.
- */
+ /// <summary>
+ /// Sets whether this control is a focus group for keyboard navigation.
+ /// (i.e. the scope of keyboard focus movement can be limitied to its child actors). The control is not a focus group by default.
+ /// </summary>
+ /// <param name="isFocusGroup">Whether this control is set as a focus group for keyboard navigation</param>
internal void SetAsKeyboardFocusGroup(bool isFocusGroup)
{
viewWrapperImpl.SetAsFocusGroup(isFocusGroup);
}
- /**
- * @brief Gets whether this control is a focus group for keyboard navigation.
- *
- * @return true if this control is set as a focus group for keyboard navigation.
- */
+ /// <summary>
+ /// Gets whether this control is a focus group for keyboard navigation.
+ /// </summary>
internal bool IsKeyboardFocusGroup()
{
return viewWrapperImpl.IsFocusGroup();
}
- /**
- * @brief Called by the AccessibilityManager to activate the Control.
- * @SINCE_1_0.0
- */
+ /// <summary>
+ /// Called by the AccessibilityManager to activate the Control.
+ /// </summary>
internal void AccessibilityActivate()
{
viewWrapperImpl.AccessibilityActivate();
return viewWrapperImpl.EmitKeyEventSignal(key);
}
- /**
- * @brief Request a relayout, which means performing a size negotiation on this actor, its parent and children (and potentially whole scene).
- *
- * This method can also be called from a derived class every time it needs a different size.
- * At the end of event processing, the relayout process starts and
- * all controls which requested Relayout will have their sizes (re)negotiated.
- *
- * @note RelayoutRequest() can be called multiple times; the size negotiation is still
- * only performed once, i.e. there is no need to keep track of this in the calling side.
- */
+ /// <summary>
+ /// Request a relayout, which means performing a size negotiation on this actor, its parent and children (and potentially whole scene).<br>
+ /// This method can also be called from a derived class every time it needs a different size.<br>
+ /// At the end of event processing, the relayout process starts and all controls which requested Relayout will have their sizes (re)negotiated.<br>
+ /// It can be called multiple times; the size negotiation is still only performed once, i.e. there is no need to keep track of this in the calling side.<br>
+ /// <summary>
protected void RelayoutRequest()
{
viewWrapperImpl.RelayoutRequest();
}
- /**
- * @brief Provides the Actor implementation of GetHeightForWidth.
- * @param width Width to use.
- * @return The height based on the width.
- */
+ /// <summary>
+ /// Provides the Actor implementation of GetHeightForWidth.
+ /// <summary>
+ /// <param name="width">Width to use</param>
+ /// <returns>The height based on the width</returns>
protected float GetHeightForWidthBase(float width)
{
return viewWrapperImpl.GetHeightForWidthBase(width);
}
- /**
- * @brief Provides the Actor implementation of GetWidthForHeight.
- * @param height Height to use.
- * @return The width based on the height.
- */
+ /// <summary>
+ /// Provides the Actor implementation of GetWidthForHeight.
+ /// </summary>
+ /// <param name="height">Height to use</param>
+ /// <returns>The width based on the height</returns>
protected float GetWidthForHeightBase(float height)
{
return viewWrapperImpl.GetWidthForHeightBase(height);
}
- /**
- * @brief Calculate the size for a child using the base actor object.
- *
- * @param[in] child The child actor to calculate the size for
- * @param[in] dimension The dimension to calculate the size for. E.g. width or height
- * @return Return the calculated size for the given dimension. If more than one dimension is requested, just return the first one found.
- */
+ /// <summary>
+ /// Calculate the size for a child using the base actor object.
+ /// </summary>
+ /// <param name="child">The child actor to calculate the size for</param>
+ /// <param name="dimension">The dimension to calculate the size for. E.g. width or height</param>
+ /// <returns>Return the calculated size for the given dimension. If more than one dimension is requested, just return the first one found</returns>
protected float CalculateChildSizeBase(Actor child, DimensionType dimension)
{
return viewWrapperImpl.CalculateChildSizeBase(child, dimension);
}
- /**
- * @brief Determine if this actor is dependent on it's children for relayout from the base class.
- *
- * @param dimension The dimension(s) to check for
- * @return Return if the actor is dependent on it's children.
- */
+ /// <summary>
+ /// Determine if this actor is dependent on it's children for relayout from the base class.
+ /// </summary>
+ /// <param name="dimension">The dimension(s) to check for</param>
+ /// <returns>Return if the actor is dependent on it's children</returns>
protected bool RelayoutDependentOnChildrenBase(DimensionType dimension)
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase(dimension);
}
- /**
- * @brief Determine if this actor is dependent on it's children for relayout from the base class.
- *
- * @param dimension The dimension(s) to check for
- * @return Return if the actor is dependent on it's children.
- */
+ /// <summary>
+ /// Determine if this actor is dependent on it's children for relayout from the base class.
+ /// </summary>
+ /// <returns>Return if the actor is dependent on it's children</returns>
protected bool RelayoutDependentOnChildrenBase()
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase();
}
- /**
- * @brief Register a visual by Property Index, linking an Actor to visual when required.
- * In the case of the visual being an actor or control deeming visual not required then visual should be an empty handle.
- * No parenting is done during registration, this should be done by derived class.
- *
- * @param[in] index The Property index of the visual, used to reference visual
- * @param[in] visual The visual to register
- * @note Derived class should not call visual.SetOnStage(actor). It is the responsibility of the base class to connect/disconnect registered visual to stage.
- * Use below API with enabled set to false if derived class wishes to control when visual is staged.
- */
+ /// <summary>
+ /// Register a visual by Property Index, linking an Actor to visual when required.<br>
+ /// In the case of the visual being an actor or control deeming visual not required then visual should be an empty handle.<br>
+ /// No parenting is done during registration, this should be done by derived class.<br>
+ /// </summary>
+ /// <param name="index">The Property index of the visual, used to reference visual</param>
+ /// <param name="visual">The visual to register</param>
protected void RegisterVisual(int index, VisualBase visual)
{
viewWrapperImpl.RegisterVisual(index, visual);
}
- /**
- * @brief Register a visual by Property Index, linking an Actor to visual when required.
- * In the case of the visual being an actor or control deeming visual not required then visual should be an empty handle.
- * If enabled is false then the visual is not set on stage until enabled by the derived class.
- * @see EnableVisual
- *
- * @param[in] index The Property index of the visual, used to reference visual
- * @param[in] visual The visual to register
- * @param[in] enabled false if derived class wants to control when visual is set on stage.
- *
- */
+ /// <summary>
+ /// Register a visual by Property Index, linking an Actor to visual when required.<br>
+ /// In the case of the visual being an actor or control deeming visual not required then visual should be an empty handle.<br>
+ /// If enabled is false then the visual is not set on stage until enabled by the derived class.<br>
+ /// </summary>
+ /// <param name="index">The Property index of the visual, used to reference visual</param>
+ /// <param name="visual">The visual to register</param>
+ /// <param name="enabled">false if derived class wants to control when visual is set on stage</param>
protected void RegisterVisual(int index, VisualBase visual, bool enabled)
{
viewWrapperImpl.RegisterVisual(index, visual, enabled);
}
- /**
- * @brief Erase the entry matching the given index from the list of registered visuals
- * @param[in] index The Property index of the visual, used to reference visual
- *
- */
+ /// <summary>
+ /// Erase the entry matching the given index from the list of registered visuals.
+ /// </summary>
+ /// <param name="index">The Property index of the visual, used to reference visual</param>
protected void UnregisterVisual(int index)
{
viewWrapperImpl.UnregisterVisual(index);
}
- /**
- * @brief Retrieve the visual associated with the given property index.
- *
- * @param[in] index The Property index of the visual.
- * @return The registered visual if exist, otherwise empty handle.
- * @note For managing object life-cycle, do not store the returned visual as a member which increments its reference count.
- */
+ /// <summary>
+ /// Retrieve the visual associated with the given property index.<br>
+ /// For managing object life-cycle, do not store the returned visual as a member which increments its reference count.<br>
+ /// </summary>
+ /// <param name="index">The Property index of the visual, used to reference visual</param>
+ /// <returns>The registered visual if exist, otherwise empty handle</returns>
protected VisualBase GetVisual(int index)
{
return viewWrapperImpl.GetVisual(index);
}
- /**
- * @brief Sets the given visual to be displayed or not when parent staged.
- *
- * @param[in] index The Property index of the visual
- * @param[in] enable flag to set enabled or disabled.
- */
+ /// <summary>
+ /// Sets the given visual to be displayed or not when parent staged.<br>
+ /// For managing object life-cycle, do not store the returned visual as a member which increments its reference count.<br>
+ /// </summary>
+ /// <param name="index">The Property index of the visual, used to reference visual</param>
+ /// <param name="enable">flag to set enabled or disabled</param>
protected void EnableVisual(int index, bool enable)
{
viewWrapperImpl.EnableVisual(index, enable);
}
- /**
- * @brief Queries if the given visual is to be displayed when parent staged.
- *
- * @param[in] index The Property index of the visual
- * @return bool whether visual is enabled or not
- */
+ /// <summary>
+ /// Queries if the given visual is to be displayed when parent staged.<br>
+ /// For managing object life-cycle, do not store the returned visual as a member which increments its reference count.<br>
+ /// </summary>
+ /// <param name="index">The Property index of the visual</param>
+ /// <returns>Whether visual is enabled or not</returns>
protected bool IsVisualEnabled(int index)
{
return viewWrapperImpl.IsVisualEnabled(index);
}
- /**
- * @brief Create a transition effect on the control.
- *
- * @param[in] transitionData The transition data describing the effect to create
- * @return A handle to an animation defined with the given effect, or an empty
- * handle if no properties match.
- */
+ /// <summary>
+ /// Create a transition effect on the control.
+ /// </summary>
+ /// <param name="transitionData">transitionData The transition data describing the effect to create</param>
+ /// <returns>A handle to an animation defined with the given effect, or an empty handle if no properties match </returns>
protected Animation CreateTransition(TransitionData transitionData)
{
return viewWrapperImpl.CreateTransition(transitionData);
}
- /**
- * @brief Emits KeyInputFocusGained signal if true else emits KeyInputFocusLost signal
- *
- * Should be called last by the control after it acts on the Input Focus change.
- *
- * @param[in] focusGained True if gained, False if lost
- */
+ /// <summary>
+ /// Emits KeyInputFocusGained signal if true else emits KeyInputFocusLost signal.<br>
+ /// Should be called last by the control after it acts on the Input Focus change.<br>
+ /// </summary>
+ /// <param name="focusGained">focusGained True if gained, False if lost</param>
protected void EmitFocusSignal(bool focusGained)
{
viewWrapperImpl.EmitFocusSignal(focusGained);
}
- /**
- * @brief This method is called after the Control has been initialized.
- *
- * Derived classes should do any second phase initialization by overriding this method.
- */
+ /// <summary>
+ /// This method is called after the Control has been initialized.<br>
+ /// Derived classes should do any second phase initialization by overriding this method.<br>
+ /// </summary>
public virtual void OnInitialize()
{
}
- /**
- * @brief Called after the actor has been connected to the stage.
- *
- * When an actor is connected, it will be directly or indirectly parented to the root Actor.
- * @param[in] depth The depth in the hierarchy for the actor
- *
- * @note The root Actor is provided automatically by Dali::Stage, and is always considered to be connected.
- * When the parent of a set of actors is connected to the stage, then all of the children
- * will received this callback.
- * For the following actor tree, the callback order will be A, B, D, E, C, and finally F.
- *
- * @code
- *
- * A (parent)
- * / \
- * B C
- * / \ \
- * D E F
- *
- * @endcode
- * @param[in] depth The depth in the hierarchy for the actor
- */
+ /// <summary>
+ /// Called after the actor has been connected to the stage.<br>
+ /// When an actor is connected, it will be directly or indirectly parented to the root Actor.<br>
+ /// The root Actor is provided automatically by Tizen.NUI.Stage, and is always considered to be connected.<br>
+ /// When the parent of a set of actors is connected to the stage, then all of the children will received this callback.<br>
+ /// </summary>
+ /// <param name="depth">The depth in the hierarchy for the actor</param>
public virtual void OnStageConnection(int depth)
{
}
- /**
- * @brief Called after the actor has been disconnected from Stage.
- *
- * If an actor is disconnected it either has no parent, or is parented to a disconnected actor.
- *
- * @note When the parent of a set of actors is disconnected to the stage, then all of the children
- * will received this callback, starting with the leaf actors.
- * For the following actor tree, the callback order will be D, E, B, F, C, and finally A.
- *
- * @code
- *
- * A (parent)
- * / \
- * B C
- * / \ \
- * D E F
- *
- * @endcode
- */
+ /// <summary>
+ /// Called after the actor has been disconnected from Stage.<br>
+ /// If an actor is disconnected it either has no parent, or is parented to a disconnected actor.<br>
+ /// When the parent of a set of actors is disconnected to the stage, then all of the children will received this callback, starting with the leaf actors.<br>
+ /// </summary>
public virtual void OnStageDisconnection()
{
}
- /**
- * @brief Called after a child has been added to the owning actor.
- *
- * @param[in] child The child which has been added
- */
+ /// <summary>
+ /// Called after a child has been added to the owning actor.
+ /// </summary>
+ /// <param name="actor">The child which has been added</param>
public virtual void OnChildAdd(Actor actor)
{
}
- /**
- * @brief Called after the owning actor has attempted to remove a child( regardless of whether it succeeded or not ).
- *
- * @param[in] child The child being removed
- */
+ /// <summary>
+ /// Called after the owning actor has attempted to remove a child( regardless of whether it succeeded or not ).
+ /// </summary>
+ /// <param name="actor">The child being removed</param>
public virtual void OnChildRemove(Actor actor)
{
}
- /**
- * @brief Called when the owning actor property is set.
- *
- * @param[in] index The Property index that was set
- * @param[in] propertyValue The value to set
- */
+ /// <summary>
+ /// Called when the owning actor property is set.
+ /// </summary>
+ /// <param name="index">The Property index that was set</param>
+ /// <param name="propertyValue">The value to set</param>
public virtual void OnPropertySet(int index, Tizen.NUI.PropertyValue propertyValue)
{
}
- /**
- * @brief Called when the owning actor's size is set e.g. using Actor::SetSize().
- *
- * @param[in] targetSize The target size. Note that this target size may not match the size returned via Actor.GetTargetSize.
- */
+ /// <summary>
+ /// Called when the owning actor's size is set e.g. using Actor.SetSize().
+ /// </summary>
+ /// <param name="targetSize">The target size. Note that this target size may not match the size returned via Actor.GetTargetSize</param>
public virtual void OnSizeSet(Vector3 targetSize)
{
}
- /**
- * @brief Called when the owning actor's size is animated e.g. using Animation::AnimateTo( Property( actor, Actor::Property::SIZE ), ... ).
- *
- * @param[in] animation The object which is animating the owning actor.
- * @param[in] targetSize The target size. Note that this target size may not match the size returned via @ref Actor.GetTargetSize.
- */
+ /// <summary>
+ /// Called when the owning actor's size is animated e.g. using Animation::AnimateTo( Property( actor, Actor::Property::SIZE ), ... ).
+ /// </summary>
+ /// <param name="animation">The object which is animating the owning actor</param>
+ /// <param name="targetSize">The target size. Note that this target size may not match the size returned via @ref Actor.GetTargetSize</param>
public virtual void OnSizeAnimation(Animation animation, Vector3 targetSize)
{
}
- /**
- * @DEPRECATED_1_1.37 Connect to TouchSignal() instead.
- *
- * @brief Called after a touch-event is received by the owning actor.
- *
- * @param[in] touch The touch event
- * @return True if the event should be consumed.
- * @note CustomViewBehaviour.REQUIRES_TOUCH_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).
- */
+ /// <summary>
+ /// Called after a touch-event is received by the owning actor.<br>
+ /// CustomViewBehaviour.REQUIRES_TOUCH_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).<br>
+ /// </summary>
+ /// <param name="touch">The touch event</param>
+ /// <returns>True if the event should be consumed</returns>
public virtual bool OnTouch(Touch touch)
{
return false; // Do not consume
}
- /**
- * @brief Called after a hover-event is received by the owning actor.
- *
- * @param[in] hover The hover event
- * @return True if the hover event should be consumed.
- * @note CustomViewBehaviour.REQUIRES_HOVER_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).
- */
+ /// <summary>
+ /// Called after a hover-event is received by the owning actor.<br>
+ /// CustomViewBehaviour.REQUIRES_HOVER_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).<br>
+ /// </summary>
+ /// <param name="hover">The hover event</param>
+ /// <returns>True if the hover event should be consumed</returns>
public virtual bool OnHover(Hover hover)
{
return false; // Do not consume
}
- /**
- * @brief Called after a key-event is received by the actor that has had its focus set.
- *
- * @param[in] key the Key Event
- * @return True if the event should be consumed.
- */
+ /// <summary>
+ /// Called after a key-event is received by the actor that has had its focus set.
+ /// </summary>
+ /// <param name="key">The key event</param>
+ /// <returns>True if the key event should be consumed</returns>
public virtual bool OnKey(Key key)
{
return false; // Do not consume
}
- /**
- * @brief Called after a wheel-event is received by the owning actor.
- *
- * @param[in] wheel The wheel event
- * @return True if the event should be consumed.
- * @note CustomViewBehaviour.REQUIRES_WHEEL_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).
- */
+ /// <summary>
+ /// Called after a wheel-event is received by the owning actor.<br>
+ /// CustomViewBehaviour.REQUIRES_WHEEL_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).<br>
+ /// </summary>
+ /// <param name="wheel">The wheel event</param>
+ /// <returns>True if the wheel event should be consumed</returns>
public virtual bool OnWheel(Wheel wheel)
{
return false; // Do not consume
}
- /**
- * @brief Called after the size negotiation has been finished for this control.
- *
- * The control is expected to assign this given size to itself/its children.
- *
- * Should be overridden by derived classes if they need to layout
- * actors differently after certain operations like add or remove
- * actors, resize or after changing specific properties.
- *
- * @param[in] size The allocated size.
- * @param[in,out] container The control should add actors to this container that it is not able
- * to allocate a size for.
- * @note As this function is called from inside the size negotiation algorithm, you cannot
- * call RequestRelayout (the call would just be ignored).
- */
+ /// <summary>
+ /// Called after the size negotiation has been finished for this control.<br>
+ /// The control is expected to assign this given size to itself/its children.<br>
+ /// Should be overridden by derived classes if they need to layout actors differently after certain operations like add or remove actors, resize or after changing specific properties.<br>
+ /// As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored).<br>
+ /// </summary>
+ /// <param name="size">The allocated size</param>
+ /// <param name="container">The control should add actors to this container that it is not able to allocate a size for</param>
public virtual void OnRelayout(Vector2 size, RelayoutContainer container)
{
}
- /**
- * @brief Notification for deriving classes
- *
- * @param[in] policy The policy being set
- * @param[in] dimension The dimension the policy is being set for
- */
+ /// <summary>
+ /// Notification for deriving classes.
+ /// </summary>
+ /// <param name="policy">policy The policy being set</param>
+ /// <param name="dimension">dimension The dimension the policy is being set for</param>
public virtual void OnSetResizePolicy(ResizePolicyType policy, DimensionType dimension)
{
}
- /**
- * @brief Return the natural size of the actor.
- *
- * @return The actor's natural size
- */
+ /// <summary>
+ /// Return the natural size of the actor.
+ /// </summary>
+ /// <returns>The actor's natural size</returns>
public virtual Size GetNaturalSize()
{
return new Size(0.0f, 0.0f, 0.0f);
}
- /**
- * @brief Calculate the size for a child.
- *
- * @param[in] child The child actor to calculate the size for
- * @param[in] dimension The dimension to calculate the size for. E.g. width or height.
- * @return Return the calculated size for the given dimension.
- */
+ /// <summary>
+ /// Calculate the size for a child.
+ /// </summary>
+ /// <param name="child">The child actor to calculate the size for</param>
+ /// <param name="dimension">The dimension to calculate the size for. E.g. width or height</param>
+ /// <returns>Return the calculated size for the given dimension</returns>
public virtual float CalculateChildSize(Actor child, DimensionType dimension)
{
return viewWrapperImpl.CalculateChildSizeBase(child, dimension);
}
- /**
- * @brief This method is called during size negotiation when a height is required for a given width.
- *
- * Derived classes should override this if they wish to customize the height returned.
- *
- * @param width Width to use.
- * @return The height based on the width.
- */
+ /// <summary>
+ /// This method is called during size negotiation when a height is required for a given width.<br>
+ /// Derived classes should override this if they wish to customize the height returned.<br>
+ /// </summary>
+ /// <param name="width">Width to use</param>
+ /// <returns>The height based on the width</returns>
public virtual float GetHeightForWidth(float width)
{
return viewWrapperImpl.GetHeightForWidthBase(width);
}
- /**
- * @brief This method is called during size negotiation when a width is required for a given height.
- *
- * Derived classes should override this if they wish to customize the width returned.
- *
- * @param height Height to use.
- * @return The width based on the width.
- */
+ /// <summary>
+ /// This method is called during size negotiation when a width is required for a given height.<br>
+ /// Derived classes should override this if they wish to customize the width returned.<br>
+ /// </summary>
+ /// <param name="height">Height to use</param>
+ /// <returns>The width based on the width</returns>
public virtual float GetWidthForHeight(float height)
{
return viewWrapperImpl.GetWidthForHeightBase(height);
}
- /**
- * @brief Determine if this actor is dependent on it's children for relayout.
- *
- * @param dimension The dimension(s) to check for
- * @return Return if the actor is dependent on it's children.
- */
+ /// <summary>
+ /// Determine if this actor is dependent on it's children for relayout.
+ /// </summary>
+ /// <param name="dimension">The dimension(s) to check for</param>
+ /// <returns>Return if the actor is dependent on it's children</returns>
public virtual bool RelayoutDependentOnChildren(DimensionType dimension)
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase(dimension);
}
- /**
- * @brief Determine if this actor is dependent on it's children for relayout from the base class.
- *
- * @return Return if the actor is dependent on it's children.
- */
+ /// <summary>
+ /// Determine if this actor is dependent on it's children for relayout from the base class.
+ /// </summary>
+ /// <returns>Return true if the actor is dependent on it's children</returns>
public virtual bool RelayoutDependentOnChildren()
{
return viewWrapperImpl.RelayoutDependentOnChildrenBase();
}
- /**
- * @brief Virtual method to notify deriving classes that relayout dependencies have been
- * met and the size for this object is about to be calculated for the given dimension
- *
- * @param dimension The dimension that is about to be calculated
- */
+ /// <summary>
+ /// Virtual method to notify deriving classes that relayout dependencies have been
+ /// met and the size for this object is about to be calculated for the given dimension.
+ /// </summary>
+ /// <param name="dimension">The dimension that is about to be calculated</param>
public virtual void OnCalculateRelayoutSize(DimensionType dimension)
{
}
- /**
- * @brief Virtual method to notify deriving classes that the size for a dimension
- * has just been negotiated
- *
- * @param[in] size The new size for the given dimension
- * @param[in] dimension The dimension that was just negotiated
- */
+ /// <summary>
+ /// Virtual method to notify deriving classes that the size for a dimension has just been negotiated.
+ /// </summary>
+ /// <param name="size">The new size for the given dimension</param>
+ /// <param name="dimension">The dimension that was just negotiated</param>
public virtual void OnLayoutNegotiated(float size, DimensionType dimension)
{
}
- /**
- * @brief This method should be overridden by deriving classes requiring notifications when the style changes.
- *
- * @param[in] styleManager The StyleManager object.
- * @param[in] change Information denoting what has changed.
- */
+ /// <summary>
+ /// This method should be overridden by deriving classes requiring notifications when the style changes.
+ /// </summary>
+ /// <param name="styleManager">The StyleManager object</param>
+ /// <param name="change">Information denoting what has changed</param>
public virtual void OnStyleChange(StyleManager styleManager, StyleChangeType change)
{
}
- /**
- * @brief This method is called when the control is accessibility activated.
- *
- * Derived classes should override this to perform custom accessibility activation.
- * @return true if this control can perform accessibility activation.
- */
+ /// <summary>
+ /// This method is called when the control is accessibility activated.<br>
+ /// Derived classes should override this to perform custom accessibility activation.<br>
+ /// </summary>
+ /// <returns>true if this control can perform accessibility activation</returns>
internal virtual bool OnAccessibilityActivated()
{
return false;
}
- /**
- * @brief This method should be overridden by deriving classes when they wish to respond the accessibility
- * pan gesture.
- *
- * @param[in] gesture The pan gesture.
- * @return true if the pan gesture has been consumed by this control
- */
+ /// <summary>
+ /// This method should be overridden by deriving classes when they wish to respond the accessibility.
+ /// </summary>
+ /// <param name="gestures">The pan gesture</param>
+ /// <returns>true if the pan gesture has been consumed by this control</returns>
internal virtual bool OnAccessibilityPan(PanGesture gestures)
{
return false;
}
- /**
- * @brief This method should be overridden by deriving classes when they wish to respond the accessibility
- * touch event.
- *
- * @param[in] touch The touch event.
- * @return true if the touch event has been consumed by this control
- */
+ /// <summary>
+ /// This method should be overridden by deriving classes when they wish to respond the accessibility
+ /// </summary>
+ /// <param name="touch">The touch gesture</param>
+ /// <returns>true if the touch event has been consumed by this control</returns>
internal virtual bool OnAccessibilityTouch(Touch touch)
{
return false;
}
- /**
- * @brief This method should be overridden by deriving classes when they wish to respond
- * the accessibility up and down action (i.e. value change of slider control).
- *
- * @param[in] isIncrease Whether the value should be increased or decreased
- * @return true if the value changed action has been consumed by this control
- */
+ /// <summary>
+ /// This method should be overridden by deriving classes when they wish to respond the accessibility up and down action (i.e. value change of slider control).
+ /// </summary>
+ /// <param name="isIncrease">isIncrease Whether the value should be increased or decreased</param>
+ /// <returns>true if the value changed action has been consumed by this control</returns>
internal virtual bool OnAccessibilityValueChange(bool isIncrease)
{
return false;
}
- /**
- * @brief This method should be overridden by deriving classes when they wish to respond
- * the accessibility zoom action.
- *
- * @return true if the zoom action has been consumed by this control
- */
+ /// <summary>
+ /// This method should be overridden by deriving classes when they wish to respond the accessibility zoom action.
+ /// </summary>
+ /// <returns>true if the zoom action has been consumed by this control</returns>
internal virtual bool OnAccessibilityZoom()
{
return false;
}
- /**
- * @brief This method should be overridden by deriving classes when they wish to respond
- * the accessibility zoom action.
- *
- * @return true if the zoom action has been consumed by this control
- */
+ /// <summary>
+ /// Called when the control gain key input focus. Should be overridden by derived classes if they need to customize what happens when focus is gained.
+ /// </summary>
public virtual void OnFocusGained()
{
}
- /**
- * @brief Called when the control loses key input focus.
- *
- * Should be overridden by derived classes if they need to customize what happens when focus is lost.
- */
+ /// <summary>
+ /// Called when the control loses key input focus. Should be overridden by derived classes if they need to customize what happens when focus is lost.
+ /// </summary>
public virtual void OnFocusLost()
{
}
- /**
- * @brief Gets the next keyboard focusable actor in this control towards the given direction.
- *
- * A control needs to override this function in order to support two dimensional keyboard navigation.
- * @param[in] currentFocusedActor The current focused actor.
- * @param[in] direction The direction to move the focus towards.
- * @param[in] loopEnabled Whether the focus movement should be looped within the control.
- * @return the next keyboard focusable actor in this control or an empty handle if no actor can be focused.
- */
+ /// <summary>
+ /// Gets the next keyboard focusable actor in this control towards the given direction.<br>
+ /// A control needs to override this function in order to support two dimensional keyboard navigation.<br>
+ /// </summary>
+ /// <param name="currentFocusedView">The current focused actor</param>
+ /// <param name="direction">The direction to move the focus towards</param>
+ /// <param name="loopEnabled">Whether the focus movement should be looped within the control</param>
+ /// <returns>the next keyboard focusable actor in this control or an empty handle if no actor can be focused</returns>
public virtual View GetNextFocusableView(View currentFocusedView, View.FocusDirection direction, bool loopEnabled)
{
return new View();
}
- /**
- * @brief Informs this control that its chosen focusable actor will be focused.
- *
- * This allows the application to preform any actions if wishes
- * before the focus is actually moved to the chosen actor.
- *
- * @param[in] commitedFocusableActor The commited focusable actor.
- */
+ /// <summary>
+ /// Informs this control that its chosen focusable actor will be focused.<br>
+ /// This allows the application to preform any actions if wishes before the focus is actually moved to the chosen actor.<br>
+ /// </summary>
+ /// <param name="commitedFocusableView">The commited focused actor</param>
public virtual void OnFocusChangeCommitted(View commitedFocusableView)
{
}
- /**
- * @brief This method is called when the control has enter pressed on it.
- *
- * Derived classes should override this to perform custom actions.
- * @return true if this control supported this action.
- */
+ /// <summary>
+ /// This method is called when the control has enter pressed on it.<br>
+ /// Derived classes should override this to perform custom actions.<br>
+ /// </summary>
+ /// <returns>true if this control supported this action</returns>
public virtual bool OnKeyboardEnter()
{
return false;
}
- /**
- * @brief Called whenever a pinch gesture is detected on this control.
- *
- * This can be overridden by deriving classes when pinch detection
- * is enabled. The default behaviour is to scale the control by the
- * pinch scale.
- *
- * @param[in] pinch The pinch gesture.
- * @note If overridden, then the default behaviour will not occur.
- * @note Pinch detection should be enabled via EnableGestureDetection().
- * @see EnableGestureDetection
- */
+ /// <summary>
+ /// Called whenever a pinch gesture is detected on this control.<br>
+ /// This can be overridden by deriving classes when pinch detection is enabled. The default behaviour is to scale the control by the pinch scale.<br>
+ /// If overridden, then the default behaviour will not occur.<br>
+ /// Pinch detection should be enabled via EnableGestureDetection().<br>
+ /// </summary>
+ /// <param name="pinch">pinch tap gesture</param>
internal virtual void OnPinch(PinchGesture pinch)
{
}
- /**
- * @brief Called whenever a pan gesture is detected on this control.
- *
- * This should be overridden by deriving classes when pan detection
- * is enabled.
- *
- * @param[in] pan The pan gesture.
- * @note There is no default behaviour with panning.
- * @note Pan detection should be enabled via EnableGestureDetection().
- * @see EnableGestureDetection
- */
+ /// <summary>
+ /// Called whenever a pan gesture is detected on this control.<br>
+ /// This should be overridden by deriving classes when pan detection is enabled.<br>
+ /// There is no default behaviour with panning.<br>
+ /// Pan detection should be enabled via EnableGestureDetection().<br>
+ /// </summary>
+ /// <param name="pan">The pan gesture</param>
public virtual void OnPan(PanGesture pan)
{
}
- /**
- * @brief Called whenever a tap gesture is detected on this control.
- *
- * This should be overridden by deriving classes when tap detection
- * is enabled.
- *
- * @param[in] tap The tap gesture.
- * @note There is no default behaviour with a tap.
- * @note Tap detection should be enabled via EnableGestureDetection().
- * @see EnableGestureDetection
- */
+ /// <summary>
+ /// Called whenever a tap gesture is detected on this control.<br>
+ /// This should be overridden by deriving classes when tap detection is enabled.<br>
+ /// There is no default behaviour with a tap.<br>
+ /// Tap detection should be enabled via EnableGestureDetection().<br>
+ /// </summary>
+ /// <param name="tap">The tap gesture</param>
public virtual void OnTap(TapGesture tap)
{
}
- /**
- * @brief Called whenever a long press gesture is detected on this control.
- *
- * This should be overridden by deriving classes when long press
- * detection is enabled.
- *
- * @param[in] longPress The long press gesture.
- * @note There is no default behaviour associated with a long press.
- * @note Long press detection should be enabled via EnableGestureDetection().
- * @see EnableGestureDetection
- */
+ /// <summary>
+ /// Called whenever a long press gesture is detected on this control.<br>
+ /// This should be overridden by deriving classes when long press detection is enabled.<br>
+ /// There is no default behaviour associated with a long press.<br>
+ /// Long press detection should be enabled via EnableGestureDetection().<br>
+ /// </summary>
+ /// <param name="longPress">The long press gesture</param>
internal virtual void OnLongPress(LongPressGesture longPress)
{
}
{
}
}
+
+ /// <summary>
+ /// This specifies ccustomView behaviour types.
+ /// </summary>
public enum CustomViewBehaviour
{
ViewBehaviourDefault = 0,
ViewRegistry.Instance.Register(CreateInstance, typeof(Spin));
}
+ /// <summary>
+ /// Creates an initialized Spin.
+ /// </summary>
public Spin() : base(typeof(Spin).Name, CustomViewBehaviour.RequiresKeyboardNavigationSupport)
{
}
/// <summary>
- /// Override method of OnInitialize() for CustomView class.
- /// This method is called after the Control has been initialized.
- /// Derived classes should do any second phase initialization by overriding this method.
+ /// Override method of OnInitialize() for CustomView class.<br>
+ /// This method is called after the Control has been initialized.<br>
+ /// Derived classes should do any second phase initialization by overriding this method.<br>
/// </summary>
public override void OnInitialize()
{
}
/// <summary>
- /// Override method of GetNaturalSize() for CustomView class.
- /// Return the natural size of the actor.
+ /// Override method of GetNaturalSize() for CustomView class.<br>
+ /// Return the natural size of the actor.<br>
/// </summary>
/// <returns> Natural size of this Spin itself</returns>
public override Size GetNaturalSize()
}
/// <summary>
- /// Event handler when the TextField in Spin gets the Key focus
- /// Make sure when the current spin that takes input focus also takes the keyboard focus
- /// For example, when you tap the spin directly
+ /// Event handler when the TextField in Spin gets the Key focus.<br>
+ /// Make sure when the current spin that takes input focus also takes the keyboard focus.<br>
+ /// For example, when you tap the spin directly.<br>
/// </summary>
/// <param name="source">Sender of this event</param>
/// <param name="e">Event arguments</param>
}
/// <summary>
- /// Override method of GetNextKeyboardFocusableView() for CustomView class.
- /// Gets the next key focusable view in this View towards the given direction.
- /// A View needs to override this function in order to support two dimensional key navigation.
+ /// Override method of GetNextKeyboardFocusableView() for CustomView class.<br>
+ /// Gets the next key focusable view in this View towards the given direction.<br>
+ /// A View needs to override this function in order to support two dimensional key navigation.<br>
/// </summary>
/// <param name="currentFocusedView">The current focused view</param>
/// <param name="direction">The direction to move the focus towards</param>
}
/// <summary>
- /// Value to be set in Spin
+ /// Value to be set in Spin.
/// </summary>
[ScriptableProperty()]
public int Value
}
/// <summary>
- /// Minimum Value of Spin Value
+ /// Minimum Value of Spin Value.
/// </summary>
// MinValue property of type int:
[ScriptableProperty()]
}
/// <summary>
- /// Maximum Value of Spin Value
+ /// Maximum Value of Spin Value.
/// </summary>
// MaxValue property of type int:
[ScriptableProperty()]
}
/// <summary>
- /// Increasing, decresing step of Spin Value when Up or Down key is pressed
+ /// Increasing, decresing step of Spin Value when Up or Down key is pressed.
/// </summary>
// Step property of type int:
[ScriptableProperty()]
}
/// <summary>
- /// Wrapping enabled status
+ /// Wrapping enabled status.
/// </summary>
// WrappingEnabled property of type bool:
[ScriptableProperty()]
}
/// <summary>
- /// Text point size of Spin Value
+ /// Text point size of Spin Value.
/// </summary>
// TextPointSize property of type int:
[ScriptableProperty()]
}
/// <summary>
- /// The color of Spin Value
+ /// The color of Spin Value.
/// </summary>
// TextColor property of type Color:
[ScriptableProperty()]
}
/// <summary>
- /// Maximum text lengh of Spin Value
+ /// Maximum text lengh of Spin Value.
/// </summary>
// MaxTextLength property of type int:
[ScriptableProperty()]
}
/// <summary>
- /// Reference of TextField of Spin
+ /// Reference of TextField of Spin.
/// </summary>
public TextField SpinText
{
using System.Linq;
/// <summary>
- /// A visual view control for user add any visual to it.
- /// Example:
- /// VisualView _visualView = new VisualView();
- /// ImageVisualMap imageVisualMap1 = new ImageVisualMap();
- /// imageVisualMap1.URL = "./NUISample/res/images/image-1.jpg";
- /// imageVisualMap1.VisualSize = new Vector2( 300.0f, 300.0f );
- /// imageVisualMap1.Offset = new Vector2( 50.0f, 50.0f );
- /// imageVisualMap1.OffsetSizeMode = new Vector4( 1.0f, 1.0f, 1.0f, 1.0f );
- /// imageVisualMap1.Origin = AlignType.TOP_BEGIN;
- /// imageVisualMap1.AnchorPoint = AlignType.TOP_BEGIN;
- /// _visualView.AddVisual("imageVisual1", imageVisualMap1);
+ /// A visual view control for user add any visual to it.<br>
+ /// Example:<br>
+ /// VisualView _visualView = new VisualView();<br>
+ /// ImageVisualMap imageVisualMap1 = new ImageVisualMap();<br>
+ /// imageVisualMap1.URL = "./NUISample/res/images/image-1.jpg";<br>
+ /// imageVisualMap1.VisualSize = new Vector2( 300.0f, 300.0f );<br>
+ /// imageVisualMap1.Offset = new Vector2( 50.0f, 50.0f );<br>
+ /// imageVisualMap1.OffsetSizeMode = new Vector4( 1.0f, 1.0f, 1.0f, 1.0f );<br>
+ /// imageVisualMap1.Origin = AlignType.TOP_BEGIN;<br>
+ /// imageVisualMap1.AnchorPoint = AlignType.TOP_BEGIN;<br>
+ /// _visualView.AddVisual("imageVisual1", imageVisualMap1);<br>
/// </summary>
public class VisualView : CustomView
{
public int NumberOfVisuals
{
get
- {
- return _visualDictionary.Count;
- }
+ {
+ return _visualDictionary.Count;
+ }
}
}
/// <summary>
- /// Override method of OnRelayout() for CustomView class.
- /// Called after the size negotiation has been finished for this control.
- /// The control is expected to assign this given size to itself/its children.
- /// Should be overridden by derived classes if they need to layout actors differently after certain operations like add or remove actors, resize or after changing specific properties.
- /// Note! As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored)
+ /// Override method of OnRelayout() for CustomView class.<br>
+ /// Called after the size negotiation has been finished for this control.<br>
+ /// The control is expected to assign this given size to itself/its children.<br>
+ /// Should be overridden by derived classes if they need to layout actors differently after certain operations like add or remove actors, resize or after changing specific properties.<br>
+ /// Note! As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored).<br>
/// </summary>
/// <param name="size">The allocated size</param>
/// <param name="container">The control should add actors to this container that it is not able to allocate a size for.</param>
{
/// <summary>
- /// An angle in degrees.
- /// This reduces ambiguity when using methods which accept angles in degrees or radians.
+ /// An angle in degrees.<br>
+ /// This reduces ambiguity when using methods which accept angles in degrees or radians.<br>
/// </summary>
public class Degree : global::System.IDisposable
{
namespace Tizen.NUI
{
-
+ /// <summary>
+ /// FlexContainer implements a subset of the flexbox spec (defined by W3C):https://www.w3.org/TR/css3-flexbox/<br>
+ /// It aims at providing a more efficient way to lay out, align and distribute space among items in the container, even when their size is unknown or dynamic.<br>
+ /// FlexContainer has the ability to alter the width and height of its children (i.e. flex items) to fill the available space in the best possible way on different screen sizes.<br>
+ /// FlexContainer can expand items to fill available free space, or shrink them to prevent overflow.<br>
+ /// </summary>
public class FlexContainer : View
{
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
using System.Runtime.InteropServices;
/// <summary>
- /// Provides the functionality of handling keyboard navigation and maintaining the two dimensional keyboard focus chain.
- /// It provides functionality of setting the focus and moving the focus in four directions(i.e.Left, Right, Up and Down).
- /// It also draws a highlight for the focused View and sends a event when the focus is changed.
+ /// Provides the functionality of handling keyboard navigation and maintaining the two dimensional keyboard focus chain.<br>
+ /// It provides functionality of setting the focus and moving the focus in four directions(i.e.Left, Right, Up and Down).<br>
+ /// It also draws a highlight for the focused View and sends a event when the focus is changed.<br>
/// </summary>
public class FocusManager : BaseHandle
{
internal delegate IntPtr PreFocusChangeEventCallback(IntPtr current, IntPtr proposed, View.FocusDirection direction);
private PreFocusChangeEventCallback _preFocusChangeCallback;
+ /// <summary>
+ /// PreFocusChange will be triggered before the focus is going to be changed.<br>
+ /// FocusManager makes the best guess for which actor to focus towards the given direction, but applications might want to change that.<br>
+ /// By connecting with this event, they can check the proposed actor to focus and return a different actor if they wish.<br>
+ /// This event is only triggered when the navigation key is pressed and KeyboardFocusManager tries to move the focus automatically.<br>
+ /// It won't be emitted for focus movement by calling SetCurrentFocusView directly.<br>
+ /// </summary>
public event EventHandlerWithReturnType<object, PreFocusChangeEventArgs, View> PreFocusChange
{
add
}
///<summary>
- ///Event arguments that passed via FocusChanged signal
+ ///Event arguments that passed via FocusChanged signal.
/// </summary>
public class FocusChangedEventArgs : EventArgs
{
internal delegate void FocusChangedEventCallback(IntPtr current, IntPtr next);
private FocusChangedEventCallback _focusChangedEventCallback;
+ /// <summary>
+ /// FocusGroupChanged will be triggered after the current focused actor has been changed.
+ /// </summary>
public event EventHandler<FocusChangedEventArgs> FocusChanged
{
add
}
///<summary>
- ///Event arguments that passed via FocusGroupChanged signal
+ ///Event arguments that passed via FocusGroupChanged signal.
/// </summary>
public class FocusGroupChangedEventArgs : EventArgs
{
private delegate void FocusGroupChangedEventCallback(IntPtr current, bool forwardDirection);
private FocusGroupChangedEventCallback _focusGroupChangedEventCallback;
+ /// <summary>
+ /// FocusGroupChanged will be triggered when the focus group has been changed.<br>
+ /// If the current focus group has a parent layout control, FocusManager will make the best guess for the next focus group to move the focus to in the given direction (forward or backward).<br>
+ /// If not, the application has to set the new focus.<br>
+ /// </summary>
public event EventHandler<FocusGroupChangedEventArgs> FocusGroupChanged
{
add
private delegate void FocusedViewEnterKeyEventCallback(IntPtr view);
private FocusedViewEnterKeyEventCallback _focusedViewEnterKeyEventCallback;
+ /// <summary>
+ /// FocusedViewEnterKeyPressed will be triggered when the current focused actor has the enter key pressed on it.
+ /// </summary>
public event EventHandler<FocusedViewEnterKeyEventArgs> FocusedViewEnterKeyPressed
{
add
}
/// <summary>
- /// Moves the keyboard focus to the given View.
- /// Only one View can be focused at the same time.
- /// The View must be in the stage already and keyboard focusable.
+ /// Moves the keyboard focus to the given View.<br>
+ /// Only one View can be focused at the same time.<br>
+ /// The View must be in the stage already and keyboard focusable.<br>
/// </summary>
/// <param name="view">The View to be focused</param>
/// <returns>Whether the focus is successful or not</returns>
}
/// <summary>
- /// Clears the focus from the current focused actor if any, so that no actor is focused in the focus chain.
- /// It will emit FocusChanged event without current focused View.
+ /// Clears the focus from the current focused actor if any, so that no actor is focused in the focus chain.<br>
+ /// It will emit FocusChanged event without current focused View.<br>
/// </summary>
public void ClearFocus()
{
}
/// <summary>
- /// Sets/Gets the status of whether the focus movement should be looped within the same focus group.
- /// The focus movement is not looped by default.
+ /// Sets/Gets the status of whether the focus movement should be looped within the same focus group.<br>
+ /// The focus movement is not looped by default.<br>
/// </summary>
public bool FocusGroupLoop
{
}
/// <summary>
- /// Sets whether an View is a focus group that can limit the scope of focus movement to its child actors in the focus chain.
- /// Layout controls set themselves as focus groups by default.
+ /// Sets whether an View is a focus group that can limit the scope of focus movement to its child actors in the focus chain.<br>
+ /// Layout controls set themselves as focus groups by default.<br>
/// </summary>
/// <param name="view">The View to be set as a focus group</param>
/// <param name="isFocusGroup">Whether to set the View as a focus group or not</param>
}
/// <summary>
- /// Sets/Gets the focus indicator View.
- /// This will replace the default focus indicator view in FocusManager and will be added to the focused view as a highlight.
+ /// Sets/Gets the focus indicator View.<br>
+ /// This will replace the default focus indicator view in FocusManager and will be added to the focused view as a highlight.<br>
/// </summary>
public View FocusIndicator
{
return ret;
}
+ /// <summary>
+ /// Provide the implementation of custom Focus algorithm interface to allow the app define the focus logic.<br>
+ /// </summary>
+ /// <param name="arg0">The user's implementation of ICustomFocusAlgorithm</param>
public void SetCustomAlgorithm(ICustomFocusAlgorithm arg0)
{
_customAlgorithmInterfaceWrapper = new CustomAlgorithmInterfaceWrapper();
}
}
+ /// <summary>
+ /// ICustomFocusAlgorithm is used to provide custom keyboard focus algorithm for retrieving the next focusable actor.<br>
+ /// The application can implement the interface and override the keyboard focus behaviour.<br>
+ /// If focus is changing within a layout container, then the layout container is queried first to provide the next focusable actor.<br>
+ /// If this does not provide a valid actor, then the Keyboard FocusManager will check focusable properties to determine next focusable actor.<br>
+ /// If focusable properties are not set, then the Keyboard FocusManager calls the GetNextFocusableActor() method of this interface.<br>
+ /// </summary>
public interface ICustomFocusAlgorithm
{
View GetNextFocusableActor(View current, View proposed, View.FocusDirection direction);
{
/// <summary>
- /// Base structure for different gestures that an application can receive.
+ /// Base structure for different gestures that an application can receive.<br>
/// A gesture is an event that is produced from a combination of several touch events
- /// in a particular order or within a certain time frame (e.g pinch).
+ /// in a particular order or within a certain time frame (e.g pinch).<br>
/// </summary>
public class Gesture : global::System.IDisposable
{
{
/// <summary>
- /// Hover events are a collection of points at a specific moment in time.
+ /// Hover events are a collection of points at a specific moment in time.<br>
/// When a multi event occurs, each point represents the points that are currently being
- /// hovered or the points where a hover has stopped.
+ /// hovered or the points where a hover has stopped.<br>
/// </summary>
public class Hover : global::System.IDisposable
{
}
/// <summary>
- /// Returns the ID of the device used for the Point specified.
+ /// Returns the ID of the device used for the Point specified.<br>
/// Each point has a unique device ID which specifies the device used for that
- /// point. This is returned by this method.
+ /// point. This is returned by this method.<br>
/// </summary>
/// <param name="point">The point required</param>
/// <returns>The Device ID of this poin</returns>
{
/// <summary>
- /// ImageView is a class for displaying an image resource.
- /// An instance of ImageView can be created using a URL or an Image instance.
+ /// ImageView is a class for displaying an image resource.<br>
+ /// An instance of ImageView can be created using a URL or an Image instance.<br>
/// </summary>
public class ImageView : View
{
}
/// <summary>
- /// Creates an initialized ImageView from an URL to an image resource.
- /// If the string is empty, ImageView will not display anything.
+ /// Creates an initialized ImageView from an URL to an image resource.<br>
+ /// If the string is empty, ImageView will not display anything.<br>
/// </summary>
/// <param name="url">The url of the image resource to display</param>
public ImageView(string url) : this(NDalicPINVOKE.ImageView_New__SWIG_2(url), true)
return ret;
}
/// <summary>
- /// Downcasts a handle to ImageView handle.
- /// If handle points to a ImageView, the downcast produces valid handle.
- /// If not, the returned handle is left uninitialized.
+ /// Downcasts a handle to ImageView handle.<br>
+ /// If handle points to a ImageView, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>Handle to a ImageView or an uninitialized handle</returns>
return ret;
}
/// <summary>
- /// Sets this ImageView from the given URL.
- /// If the URL is empty, ImageView will not display anything.
+ /// Sets this ImageView from the given URL.<br>
+ /// If the URL is empty, ImageView will not display anything.<br>
/// </summary>
/// <param name="url">The URL to the image resource to display</param>
public void SetImage(string url)
}
}
/// <summary>
- /// ImageView PreMultipliedAlpha, type Boolean
- /// Image must be initialized.
+ /// ImageView PreMultipliedAlpha, type Boolean.<br>
+ /// Image must be initialized.<br>
/// </summary>
public bool PreMultipliedAlpha
{
}
}
/// <summary>
- /// ImageView PixelArea, type Vector4 (Animatable property)
- /// Pixel area is a relative value with the whole image area as [0.0, 0.0, 1.0, 1.0].
+ /// ImageView PixelArea, type Vector4 (Animatable property).<br>
+ /// Pixel area is a relative value with the whole image area as [0.0, 0.0, 1.0, 1.0].<br>
/// </summary>
public Vector4 PixelArea
{
{
/// <summary>
- /// A set of key frames for a property that can be animated using Dali Animation.
- /// This allows the generation of key frame objects from individual Property::Values.
+ /// A set of key frames for a property that can be animated using Dali Animation.<br>
+ /// This allows the generation of key frame objects from individual Property::Values.<br>
/// </summary>
public class KeyFrames : BaseHandle
{
}
/// <summary>
- /// Downcasts a handle to KeyFrames handle.
- /// If handle points to a KeyFrames object, the downcast produces valid handle.
- /// If not, the returned handle is left uninitialized.
+ /// Downcasts a handle to KeyFrames handle.<br>
+ /// If handle points to a KeyFrames object, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>Handle to a KeyFrames object or an uninitialized handle</returns>
}
/// <summary>
- /// Downcasts a handle to Layer handle.
- /// If handle points to a Layer, the downcast produces valid handle.
- /// If not, the returned handle is left uninitialized.
+ /// Downcasts a handle to Layer handle.<br>
+ /// If handle points to a Layer, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>Handle to a Layer or an uninitialized handle</returns>
}
/// <summary>
- /// Queries the depth of the layer.
- /// 0 is the bottom most layer, higher number is on top.
+ /// Queries the depth of the layer.<br>
+ /// 0 is the bottom most layer, higher number is on top.<br>
/// </summary>
public uint Depth
{
}
/// <summary>
- /// Moves the layer directly above the given layer.
- /// After the call, this layers depth will be immediately above target.
+ /// Moves the layer directly above the given layer.<br>
+ /// After the call, this layers depth will be immediately above target.<br>
/// </summary>
/// <param name="target">Layer to get on top of</param>
public void MoveAbove(Layer target)
}
/// <summary>
- /// Moves the layer directly below the given layer
- /// After the call, this layers depth will be immediately below target.
+ /// Moves the layer directly below the given layer.<br>
+ /// After the call, this layers depth will be immediately below target.<br>
/// </summary>
/// <param name="target">Layer to get below of</param>
public void MoveBelow(Layer target)
}
/// <summary>
- /// Sets the clipping box of a layer, in window coordinates.
+ /// Sets the clipping box of a layer, in window coordinates.<br>
/// The contents of the layer will not be visible outside this box, when clipping is
- /// enabled. The default clipping box is empty (0,0,0,0) which means everything is clipped.
+ /// enabled. The default clipping box is empty (0,0,0,0) which means everything is clipped.<br>
/// </summary>
/// <param name="box">The clipping box</param>
public void SetClippingBox(Rectangle box)
{
/// <summary>
- /// A LongPressGesture is emitted when the user holds the screen with the stated number of fingers.
- /// Long press gesture finishes when all touches have been released.
+ /// A LongPressGesture is emitted when the user holds the screen with the stated number of fingers.<br>
+ /// Long press gesture finishes when all touches have been released.<br>
/// </summary>
public class LongPressGesture : Gesture
{
/// <summary>
/// The number of touch points in this long press gesture, i.e. the number of fingers the user had
- /// on the screen to generate the long press gesture.
+ /// on the screen to generate the long press gesture.<br>
/// </summary>
public uint NumberOfTouches
{
}
/// <summary>
- /// This is the point, in screen coordinates, where the long press occurred.
- /// If a multi-touch long press, then this is the centroid of all the touch points.
+ /// This is the point, in screen coordinates, where the long press occurred.<br>
+ /// If a multi-touch long press, then this is the centroid of all the touch points.<br>
/// </summary>
public Vector2 ScreenPoint
{
}
/// <summary>
- /// This is the point, in local actor coordinates, where the long press occurred.
- /// If a multi-touch long press, then this is the centroid of all the touch points.
+ /// This is the point, in local actor coordinates, where the long press occurred.<br>
+ /// If a multi-touch long press, then this is the centroid of all the touch points.<br>
/// </summary>
public Vector2 LocalPoint
{
}
/// <summary>
- /// Overrides this method if want to handle behavior before calling OnCreate().
- /// stage property is initialized in this overrided method.
+ /// Overrides this method if want to handle behavior before calling OnCreate().<br>
+ /// stage property is initialized in this overrided method.<br>
/// </summary>
protected override void OnPreCreate()
{
Transparent = 1
}
+ /// <summary>
+ /// Get the window instance.
+ /// </summary>
public Window Window
{
get
{
/// <summary>
- /// A PanGesture is emitted when the user moves one or more fingers in a particular direction.
- /// A pan gesture will end in the following ways:
- /// - User releases the primary finger (the first touch).
- /// - User has more fingers on the screen than the maximum specified.
- /// - User has less fingers on the screen than the minimum specified.
- /// - Cancelled by the system.
- /// A pan gesture will continue to be sent to the actor under than initial pan until it ends.
+ /// A PanGesture is emitted when the user moves one or more fingers in a particular direction.<br>
+ /// A pan gesture will end in the following ways:<br>
+ /// - User releases the primary finger (the first touch).<br>
+ /// - User has more fingers on the screen than the maximum specified.<br>
+ /// - User has less fingers on the screen than the minimum specified.<br>
+ /// - Cancelled by the system.<br>
+ /// A pan gesture will continue to be sent to the actor under than initial pan until it ends.<br>
/// </summary>
public class PanGesture : Gesture
{
}
/// <summary>
- /// The velocity at which the user is moving their fingers.
- /// This is represented as a Vector2 and is the pixel movement per millisecond.
- /// A positive x value shows that the user is panning to the right, a negative x value means the opposite.
- /// A positive y value shows that the user is panning downwards, a negative y values means upwards.
+ /// The velocity at which the user is moving their fingers.<br>
+ /// This is represented as a Vector2 and is the pixel movement per millisecond.<br>
+ /// A positive x value shows that the user is panning to the right, a negative x value means the opposite.<br>
+ /// A positive y value shows that the user is panning downwards, a negative y values means upwards.<br>
/// </summary>
public Vector2 Velocity
{
/// <summary>
/// This is a Vector2 showing how much the user has panned (dragged) since the last pan gesture or,
- /// if the gesture has just started, then the amount panned since the user touched the screen.
- /// A positive x value shows that the user is panning to the right, a negative x value means the opposite.
- /// A positive y value shows that the user is panning downwards, a negative y value means upwards.
+ /// if the gesture has just started, then the amount panned since the user touched the screen.<br>
+ /// A positive x value shows that the user is panning to the right, a negative x value means the opposite.<br>
+ /// A positive y value shows that the user is panning downwards, a negative y value means upwards.<br>
/// </summary>
public Vector2 Displacement
{
}
/// <summary>
- /// The velocity at which the user is moving their fingers.
- /// This is represented as a Vector2 and is the pixel movement per millisecond.
- /// A positive x value shows that the user is panning to the right, a negative x value means the opposite.
- /// A positive y value shows that the user is panning downwards, a negative y values means upwards.
- /// This value represents the screen coordinates.
+ /// The velocity at which the user is moving their fingers.<br>
+ /// This is represented as a Vector2 and is the pixel movement per millisecond.<br>
+ /// A positive x value shows that the user is panning to the right, a negative x value means the opposite.<br>
+ /// A positive y value shows that the user is panning downwards, a negative y values means upwards.<br>
+ /// This value represents the screen coordinates.<br>
/// </summary>
public Vector2 ScreenVelocity
{
/// <summary>
/// This is a Vector2 showing how much the user has panned (dragged) since the last pan gesture or,
- /// if the gesture has just started, then the amount panned since the user touched the screen.
- /// A positive x value shows that the user is panning to the right, a negative x value means the opposite.
- /// A positive y value shows that the user is panning downwards, a negative y value means upwards.
- /// This value is in screen coordinates.
+ /// if the gesture has just started, then the amount panned since the user touched the screen.<br>
+ /// A positive x value shows that the user is panning to the right, a negative x value means the opposite.<br>
+ /// A positive y value shows that the user is panning downwards, a negative y value means upwards.<br>
+ /// This value is in screen coordinates.<br>
/// </summary>
public Vector2 ScreenDisplacement
{
}
/// <summary>
- /// Returns the speed at which the user is moving their fingers.
- /// This is the pixel movement per millisecond.
+ /// Returns the speed at which the user is moving their fingers.<br>
+ /// This is the pixel movement per millisecond.<br>
/// </summary>
/// <returns>The speed of the pan (in pixels per millisecond)</returns>
public float GetSpeed()
/// <summary>
/// This returns the distance the user has panned (dragged) since the last pan gesture or,
- /// if the gesture has just started, then the distance moved since the user touched the screen.
- /// This is always a positive value.
+ /// if the gesture has just started, then the distance moved since the user touched the screen.<br>
+ /// This is always a positive value.<br>
/// </summary>
/// <returns>The distance, as a float, a user's finger has panned</returns>
public float GetDistance()
}
/// <summary>
- /// Returns the speed at which the user is moving their fingers relative to screen coordinates.
- /// This is the pixel movement per millisecond.
+ /// Returns the speed at which the user is moving their fingers relative to screen coordinates.<br>
+ /// This is the pixel movement per millisecond.<br>
/// </summary>
/// <returns>The speed of the pan (in pixels per millisecond)</returns>
public float GetScreenSpeed()
/// <summary>
/// This returns the distance the user has panned (dragged) since the last pan gesture in screen
/// coordinates or, if the gesture has just started, then the distance in screen coordinates moved
- /// since the user touched the screen.
- /// This is always a positive value.
+ /// since the user touched the screen.<br>
+ /// This is always a positive value.<br>
/// </summary>
/// <returns>The distance, as a float, a user's finger has panned</returns>
public float GetScreenDistance()
{
/// <summary>
- /// A 3D parametric curve.
- /// Paths can be used to animate position and orientation of actors.
+ /// A 3D parametric curve.<br>
+ /// Paths can be used to animate position and orientation of actors.<br>
/// </summary>
public class Path : Handle
{
}
/// <summary>
- /// Downcasts a handle to Path handle.
- /// If handle points to a Path object, the downcast produces valid handle.
- /// If not, the returned handle is left uninitialized.
+ /// Downcasts a handle to Path handle.<br>
+ /// If handle points to a Path object, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
public new static Path DownCast(BaseHandle handle)
}
/// <summary>
- /// Automatic generation of control points. Generated control points which result in a smooth join between the splines of each segment.
- /// The generating algorithm is as follows:
- /// For a given knot point K[N], find the vector that bisects K[N-1],[N] and [N],[N+1].
- /// Calculate the tangent vector by taking the normal of this bisector.
- /// The in control point is the length of the preceding segment back along this bisector multiplied by the curvature.
- /// The out control point is the length of the succeeding segment forward along this bisector multiplied by the curvature.
+ /// Automatic generation of control points. Generated control points which result in a smooth join between the splines of each segment.<br>
+ /// The generating algorithm is as follows:<br>
+ /// For a given knot point K[N], find the vector that bisects K[N-1],[N] and [N],[N+1].<br>
+ /// Calculate the tangent vector by taking the normal of this bisector.<br>
+ /// The in control point is the length of the preceding segment back along this bisector multiplied by the curvature.<br>
+ /// The out control point is the length of the succeeding segment forward along this bisector multiplied by the curvature.<br>
/// </summary>
/// <param name="curvature">The curvature of the spline. 0 gives straight lines between the knots, negative values means the spline contains loops, positive values up to 0.5 result in a smooth curve, positive values between 0.5 and 1 result in looped curves where the loops are not distinct (i.e. the curve appears to be non-continuous), positive values higher than 1 result in looped curves</param>
public void GenerateControlPoints(float curvature)
{
/// <summary>
- /// A PinchGesture is emitted when the user moves two fingers towards or away from each other.
- /// A pinch gesture will continue to be sent to the actor under the center point of the pinch until the pinch ends.
+ /// A PinchGesture is emitted when the user moves two fingers towards or away from each other.<br>
+ /// A pinch gesture will continue to be sent to the actor under the center point of the pinch until the pinch ends.<br>
/// </summary>
public class PinchGesture : Gesture
{
}
/// <summary>
- /// The scale factor from the start of the pinch gesture till the latest pinch gesture.
+ /// The scale factor from the start of the pinch gesture till the latest pinch gesture.<br>
/// If the user is moving their fingers away from each other, then
/// this value increases. Conversely, if the user is moving their
- /// fingers towards each other, this value will decrease.
+ /// fingers towards each other, this value will decrease.<br>
/// </summary>
public float Scale
{
}
/// <summary>
- /// The speed at which the user is moving their fingers.
- /// This is the pixel movement per second.
+ /// The speed at which the user is moving their fingers.<br>
+ /// This is the pixel movement per second.<br>
/// </summary>
public float Speed
{
}
/// <summary>
- /// Downcasts a handle to Popup handle.
- /// If handle points to a Popup, the downcast produces valid handle.
- /// If not the returned handle is left uninitialized.
+ /// Downcasts a handle to Popup handle.<br>
+ /// If handle points to a Popup, the downcast produces valid handle.<br>
+ /// If not the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>handle to a Popup or an uninitialized handle</returns>
}
/// <summary>
- /// Sets the display state of Popup.
- /// There are 4 total display states.
- /// Only 2 can be set, but all four can be read for better inspection of the current popup state.
- ///
- /// The other two states are getable, but not setable and are there for consistency.
- ///
- /// | Value | Setting the state | Getting the state |
- /// |----------|--------------------------------|--------------------------------|
- /// | SHOWN | Show the popup | The popup is fully shown |
- /// | HIDDEN | Hide the popup | The popup is fully hidden |
- /// | SHOWING | | The popup is transitioning in |
- /// | HIDING | | The popup is transitioning out |
- ///
- /// All 4 state changes cause notifications via 4 respective signals that can be connected to.
+ /// Sets the display state of Popup.<br>
+ /// There are 4 total display states.<br>
+ /// Only 2 can be set, but all four can be read for better inspection of the current popup state.<br>
+ /// <br>
+ /// The other two states are getable, but not setable and are there for consistency.<br>
+ /// <br>
+ /// | Value | Setting the state | Getting the state |<br>
+ /// |----------|--------------------------------|--------------------------------|<br>
+ /// | SHOWN | Show the popup | The popup is fully shown |<br>
+ /// | HIDDEN | Hide the popup | The popup is fully hidden |<br>
+ /// | SHOWING | | The popup is transitioning in |<br>
+ /// | HIDING | | The popup is transitioning out |<br>
+ /// <br>
+ /// All 4 state changes cause notifications via 4 respective signals that can be connected to.<br>
/// </summary>
/// <param name="displayState">The desired display state to change to</param>
public void SetDisplayState(Popup.DisplayStateType displayState)
}
/// <summary>
- /// The animation mode within popup.
- /// Choose from a predefined mode or "CUSTOM" to use the ANIMATION_IN and ANIMATION_OUT properties.
+ /// The animation mode within popup.<br>
+ /// Choose from a predefined mode or "CUSTOM" to use the ANIMATION_IN and ANIMATION_OUT properties.<br>
/// </summary>
public enum AnimationModeType
{
}
/// <summary>
- /// Types of contextual layout.
- /// The Popup is positioned adjacent to it's parent in the direction specified by this mode.
- /// NON_CONTEXTUAL disables any contextual positioning.
+ /// Types of contextual layout.<br>
+ /// The Popup is positioned adjacent to it's parent in the direction specified by this mode.<br>
+ /// NON_CONTEXTUAL disables any contextual positioning.<br>
/// </summary>
public enum ContextualModeType
{
}
/// <summary>
- /// Popup title
+ /// Popup title.
/// </summary>
public PropertyMap Title
{
}
}
/// <summary>
- /// Popup content
+ /// Popup content.
/// </summary>
public PropertyMap Content
{
}
}
/// <summary>
- /// Popup footer
+ /// Popup footer.
/// </summary>
public PropertyMap Footer
{
}
}
/// <summary>
- /// Popup display state
+ /// Popup display state.
/// </summary>
public string DisplayState
{
}
}
/// <summary>
- /// Touch transparent
+ /// Touch transparent.
/// </summary>
public bool TouchTransparent
{
}
}
/// <summary>
- /// Popup tail visibility
+ /// Popup tail visibility.
/// </summary>
public bool TailVisibility
{
}
}
/// <summary>
- /// Popup tail position
+ /// Popup tail position.
/// </summary>
public Vector3 TailPosition
{
}
}
/// <summary>
- /// Contextual mode
+ /// Contextual mode.
/// </summary>
public string ContextualMode
{
}
}
/// <summary>
- /// Animation duration
+ /// Animation duration.
/// </summary>
public float AnimationDuration
{
}
}
/// <summary>
- /// Animation mode
+ /// Animation mode.
/// </summary>
public string AnimationMode
{
}
}
/// <summary>
- /// Entry animation
+ /// Entry animation.
/// </summary>
public PropertyMap EntryAnimation
{
}
}
/// <summary>
- /// Exit animation
+ /// Exit animation.
/// </summary>
public PropertyMap ExitAnimation
{
}
}
/// <summary>
- /// Auto hide delay
+ /// Auto hide delay.
/// </summary>
public int AutoHideDelay
{
}
}
/// <summary>
- /// Backing enabled
+ /// Backing enabled.
/// </summary>
public bool BackingEnabled
{
}
}
/// <summary>
- /// Backing color
+ /// Backing color.
/// </summary>
public Vector4 BackingColor
{
}
}
/// <summary>
- /// Background image
+ /// Background image.
/// </summary>
public string PopupBackgroundImage
{
}
}
/// <summary>
- /// Background border
+ /// Background border.
/// </summary>
public Rectangle PopupBackgroundBorder
{
}
}
/// <summary>
- /// Tail up image
+ /// Tail up image.
/// </summary>
public string TailUpImage
{
}
}
/// <summary>
- /// Tail down image
+ /// Tail down image.
/// </summary>
public string TailDownImage
{
}
}
/// <summary>
- /// Tail left image
+ /// Tail left image.
/// </summary>
public string TailLeftImage
{
}
}
/// <summary>
- /// Tail right image
+ /// Tail right image.
/// </summary>
public string TailRightImage
{
}
/// <summary>
+ /// Convert a position instance to a vector3 instance.
/// </summary>
public static implicit operator Vector3(Position Position)
{
}
/// <summary>
+ /// Convert a vector3 instance to a position instance.
/// </summary>
public static implicit operator Position(Vector3 vec)
{
}
+ /// <summary>
+ /// ParentOrigin constants.
+ /// </summary>
public struct ParentOrigin
{
public static readonly float Top = Position.ParentOriginTop;
public static readonly Position BottomCenter = Position.ParentOriginBottomCenter;
public static readonly Position BottomRight = Position.ParentOriginBottomRight;
}
+
+ /// <summary>
+ /// AnchorPoint constants.
+ /// </summary>
public struct AnchorPoint
{
public static readonly float Top = Position.AnchorPointTop;
public static readonly Position BottomCenter = Position.AnchorPointBottomCenter;
public static readonly Position BottomRight = Position.AnchorPointBottomRight;
}
+
+ /// <summary>
+ /// PositionAxis constants.
+ /// </summary>
public struct PositionAxis
{
public static readonly Position X = Position.XAxis;
namespace Tizen.NUI {
+/// <summary>
+/// Position2D is a two dimensional vector.
+/// </summary>
public class Position2D : global::System.IDisposable {
private global::System.Runtime.InteropServices.HandleRef swigCPtr;
protected bool swigCMemOwn;
}
}
-
+ /// <summary>
+ /// Addition operator.
+ /// </summary>
+ /// <param name="arg1">Vector to add</param>
+ /// <param name="arg2">Vector to add</param>
+ /// <returns>A vector containing the result of the addition</returns>
public static Position2D operator+(Position2D arg1, Position2D arg2) {
return arg1.Add(arg2);
}
+ /// <summary>
+ /// Subtraction operator.
+ /// </summary>
+ /// <param name="arg1">Vector to subtract</param>
+ /// <param name="arg2">Vector to subtract</param>
+ /// <returns>A vector containing the result of the subtraction</returns>
public static Position2D operator-(Position2D arg1, Position2D arg2) {
return arg1.Subtract(arg2);
}
+ /// <summary>
+ /// Unary negation operator.
+ /// </summary>
+ /// <param name="arg1">Vector to netate</param>
+ /// <returns>A vector containing the negation</returns>
public static Position2D operator-(Position2D arg1) {
return arg1.Subtract();
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">Vector to multiply</param>
+ /// <param name="arg2">Vector to multiply</param>
+ /// <returns>A vector containing the result of the multiplication</returns>
public static Position2D operator*(Position2D arg1, Position2D arg2) {
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Multiplication operator.
+ /// </summary>
+ /// <param name="arg1">Vector to multiply</param>
+ /// <param name="arg2">The int value to scale the vector</param>
+ /// <returns>A vector containing the result of the multiplication</returns>
public static Position2D operator*(Position2D arg1, int arg2) {
return arg1.Multiply(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">Vector to divide</param>
+ /// <param name="arg2">Vector to divide</param>
+ /// <returns>A vector containing the result of the division</returns>
public static Position2D operator/(Position2D arg1, Position2D arg2) {
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Division operator.
+ /// </summary>
+ /// <param name="arg1">Vector to divide</param>
+ /// <param name="arg2">The int value to scale the vector by</param>
+ /// <returns>A vector containing the result of the division</returns>
public static Position2D operator/(Position2D arg1, int arg2) {
return arg1.Divide(arg2);
}
+ /// <summary>
+ /// Const array subscript operator overload. Should be 0, or 1.
+ /// </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 Position2D() : this(NDalicPINVOKE.new_Vector2__SWIG_0(), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
+ /// <param name="x">x component</param>
+ /// <param name="y">y component</param>
public Position2D(int x, int y) : this(NDalicPINVOKE.new_Vector2__SWIG_1((float)x, (float)y), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
+ /// <param name="position">Position to create this vector from</param>
public Position2D(Position position) : this(NDalicPINVOKE.new_Vector2__SWIG_3(Position.getCPtr(position)), true) {
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
return ret;
}
+ /// <summary>
+ /// Compare if rhs is equal to.
+ /// </summary>
+ /// <param name="rhs">The vector to compare</param>
+ /// <returns>Returns true if the two vectors are equal, otherwise false</returns>
public bool EqualTo(Position2D rhs) {
bool ret = NDalicPINVOKE.Vector2_EqualTo(swigCPtr, Position2D.getCPtr(rhs));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
+ /// <summary>
+ /// Compare if rhs is not equal to.
+ /// </summary>
+ /// <param name="rhs">The vector to compare</param>
+ /// <returns>Returns true if the two vectors are not equal, otherwise false</returns>
public bool NotEqualTo(Position2D rhs) {
bool ret = NDalicPINVOKE.Vector2_NotEqualTo(swigCPtr, Position2D.getCPtr(rhs));
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
-
+ /// <summary>
+ /// x component.
+ /// </summary>
public int X {
set {
NDalicPINVOKE.Vector2_X_set(swigCPtr, (float)value);
}
}
+ /// <summary>
+ /// y component.
+ /// </summary>
public int Y {
set {
NDalicPINVOKE.Vector2_Y_set(swigCPtr, (float)value);
}
}
+ /// <summary>
+ /// Convert a position2D instance to a vector2 instance.
+ /// </summary>
public static implicit operator Vector2(Position2D position2d)
{
return new Vector2((float)position2d.X, (float)position2d.Y);
}
+ /// <summary>
+ /// Convert a vector2 instance to a position2D instance.
+ /// </summary>
public static implicit operator Position2D(Vector2 vec)
{
return new Position2D((int)vec.X, (int)vec.Y);
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make ProgressBar instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
/// <summary>
- /// Downcasts a handle to ProgressBar handle.
- /// If handle points to a ProgressBar, the downcast produces valid handle.
- /// If not the returned handle is left uninitialized.
+ /// Downcasts a handle to ProgressBar handle.<br>
+ /// If handle points to a ProgressBar, the downcast produces valid handle.<br>
+ /// If not the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>handle to a ProgressBar or an uninitialized handle</returns>
}
/// <summary>
- /// The progress value of progress bar, progress runs form 0 to 1.
- /// If Value is set to 0, progress bar will be set to beginning.
- /// If Value is set to 1, progress bar will be set to end.
- /// Any Value outside of the range is ignored.
+ /// The progress value of progress bar, progress runs form 0 to 1.<br>
+ /// If Value is set to 0, progress bar will be set to beginning.<br>
+ /// If Value is set to 1, progress bar will be set to end.<br>
+ /// Any Value outside of the range is ignored.<br>
/// </summary>
public float ProgressValue
{
}
}
/// <summary>
- /// The secondary progress value of progress bar, secondary progress runs form 0 to 1.
- /// Optional. If not supplied, the default is 0.
- /// If Value is set to 0, progress bar will be set secondary progress to beginning.
- /// If Value is set to 1, progress bar will be set secondary progress to end.
- /// Any Value outside of the range is ignored.
+ /// The secondary progress value of progress bar, secondary progress runs form 0 to 1.<br>
+ /// Optional. If not supplied, the default is 0.<br>
+ /// If Value is set to 0, progress bar will be set secondary progress to beginning.<br>
+ /// If Value is set to 1, progress bar will be set secondary progress to end.<br>
+ /// Any Value outside of the range is ignored.<br>
/// </summary>
public float SecondaryProgressValue
{
}
}
/// <summary>
- /// The track Visual value of progress bar, it's a full progress area and it's shown behind PROGRESS_VISUAL.
- /// Optional. If not supplied, the default track visual will be shown.
+ /// The track Visual value of progress bar, it's a full progress area and it's shown behind PROGRESS_VISUAL.<br>
+ /// Optional. If not supplied, the default track visual will be shown.<br>
/// </summary>
public Tizen.NUI.PropertyMap TrackVisual
{
}
}
/// <summary>
- /// The progress Visual value of progress bar, size of the progress visual is changed based on PROGRESS_VALUE.
- /// Optional. If not supplied, the default progress visual will be shown.
+ /// The progress Visual value of progress bar, size of the progress visual is changed based on PROGRESS_VALUE.<br>
+ /// Optional. If not supplied, the default progress visual will be shown.<br>
/// </summary>
public Tizen.NUI.PropertyMap ProgressVisual
{
}
}
/// <summary>
- /// The secondary progress visual of progress bar, size of the secondary progress visual is changed based on SECONDARY_PROGRESS_VALUE.
- /// Optional. If not supplied, the secondary progress visual will not be shown.
+ /// The secondary progress visual of progress bar, size of the secondary progress visual is changed based on SECONDARY_PROGRESS_VALUE.<br>
+ /// Optional. If not supplied, the secondary progress visual will not be shown.<br>
/// </summary>
public Tizen.NUI.PropertyMap SecondaryProgressVisual
{
}
}
/// <summary>
- /// The indeterminate visual of progress bar.
- /// Optional. If not supplied, the default inditerminate visual will be shown.
+ /// The indeterminate visual of progress bar.<br>
+ /// Optional. If not supplied, the default inditerminate visual will be shown.<br>
/// </summary>
public Tizen.NUI.PropertyMap IndeterminateVisual
{
}
}
/// <summary>
- /// The transition data for indeterminate visual animation.
- /// Optional. If not supplied, default animation will be played.
+ /// The transition data for indeterminate visual animation.<br>
+ /// Optional. If not supplied, default animation will be played.<br>
/// </summary>
public Tizen.NUI.PropertyArray IndeterminateVisualAnimation
{
}
}
+ /// <summary>
+ /// Constructor. Create a Property instance.
+ /// </summary>
+ /// <param name="arg0">A valid handle to the target object</param>
+ /// <param name="propertyIndex">The index of a property</param>
public Property(Handle arg0, int propertyIndex) : this(NDalicPINVOKE.new_Property__SWIG_0(Handle.getCPtr(arg0), propertyIndex), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor. Create a Property instance.
+ /// </summary>
+ /// <param name="arg0">A valid handle to the target object</param>
+ /// <param name="propertyIndex">The index of a property</param>
+ /// <param name="componentIndex">Index to a sub component of a property, for use with Vector2, Vector3 and Vector4. -1 for main property (default is -1)</param>
public Property(Handle arg0, int propertyIndex, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_1(Handle.getCPtr(arg0), propertyIndex, componentIndex), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor. Create a Property instance.<br>
+ /// This performs a property index query and is therefore slower than constructing a Property directly with the index.<br>
+ /// </summary>
+ /// <param name="arg0">A valid handle to the target object</param>
+ /// <param name="propertyName">The property name</param>
public Property(Handle arg0, string propertyName) : this(NDalicPINVOKE.new_Property__SWIG_2(Handle.getCPtr(arg0), propertyName), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Constructor. Create a Property instance.<br>
+ /// This performs a property index query and is therefore slower than constructing a Property directly with the index.<br>
+ /// </summary>
+ /// <param name="arg0">A valid handle to the target object</param>
+ /// <param name="propertyName">The property name</param>
+ /// <param name="componentIndex">Index to a sub component of a property, for use with Vector2, Vector3 and Vector4. -1 for main property (default is -1)</param>
public Property(Handle arg0, string propertyName, int componentIndex) : this(NDalicPINVOKE.new_Property__SWIG_3(Handle.getCPtr(arg0), propertyName, componentIndex), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
}
+ /// <summary>
+ /// Gets/Sets the index of the property.
+ /// </summary>
public int propertyIndex
{
set
}
}
+ /// <summary>
+ /// Gets/Sets the componentIndex of the property.
+ /// </summary>
public int componentIndex
{
set
}
/// <summary>
- /// Operator to access the element with the specified string key.
- /// If an element with the key does not exist, then it is created.
+ /// Operator to access the element with the specified string key.<br>
+ /// If an element with the key does not exist, then it is created.<br>
/// </summary>
/// <param name="key">The key whose value to access</param>
/// <returns>A value for the element with the specified key</returns>
}
/// <summary>
- /// Operator to access the element with the specified index key.
- /// If an element with the key does not exist, then it is created.
+ /// Operator to access the element with the specified index key.<br>
+ /// If an element with the key does not exist, then it is created.<br>
/// </summary>
/// <param name="key">The key whose value to access</param>
/// <returns>A value for the element with the specified key</returns>
}
/// <summary>
- /// Inserts the key-value pair in the Map, with the key type as string.
- /// Does not check for duplicates.
+ /// Inserts the key-value pair in the Map, with the key type as string.<br>
+ /// Does not check for duplicates.<br>
/// </summary>
/// <param name="key">The key to insert</param>
/// <param name="value">The value to insert</param>
}
/// <summary>
- /// Inserts the key-value pair in the Map, with the key type as index.
- /// Does not check for duplicates.
+ /// Inserts the key-value pair in the Map, with the key type as index.<br>
+ /// Does not check for duplicates.<br>
/// </summary>
/// <param name="key">The key to insert</param>
/// <param name="value">The value to insert</param>
}
/// <summary>
- /// Inserts the key-value pair in the Map, with the key type as string.
- /// Does not check for duplicates.
+ /// Inserts the key-value pair in the Map, with the key type as string.<br>
+ /// Does not check for duplicates.<br>
/// </summary>
/// <param name="key">The key to insert</param>
/// <param name="value">The value to insert</param>
}
/// <summary>
- /// Inserts the key-value pair in the Map, with the key type as string.
- /// Does not check for duplicates.
+ /// Inserts the key-value pair in the Map, with the key type as string.<br>
+ /// Does not check for duplicates.<br>
/// </summary>
/// <param name="key">The key to insert</param>
/// <param name="value">The value to insert</param>
}
/// <summary>
- /// Merges values from the map 'from' to the current.
- /// Any values in 'from' will overwrite the values in the current map.
+ /// Merges values from the map 'from' to the current.<br>
+ /// Any values in 'from' will overwrite the values in the current map.<br>
/// </summary>
/// <param name="from">The map to merge from</param>
public void Merge(PropertyMap from)
/// <summary>
/// Extension to property value class that allows us to create a
- /// PropertyValue from a C# object, e.g. int, float, string
+ /// PropertyValue from a C# object, e.g. int, float, string.<br>
/// </summary>
/// <param name="obj">An object to create</param>
/// <returns>The created value</returns>
}
+ /// <summary>
+ /// This specifies all the property types.
+ /// </summary>
public enum PropertyType
{
None,
Map
}
+ /// <summary>
+ /// This specifies the property access mode types.
+ /// </summary>
public enum PropertyAccessMode
{
ReadOnly,
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make PushButton instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
/// <summary>
- /// Downcasts a handle to PushButton handle.
- /// If handle points to a PushButton, the downcast produces valid handle.
- /// If not the returned handle is left uninitialized.
+ /// Downcasts a handle to PushButton handle.<br>
+ /// If handle points to a PushButton, the downcast produces valid handle.<br>
+ /// If not the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>handle to a PushButton or an uninitialized handle</returns>
{
/// <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.
+ /// A RadioButton provides a radio button which two states \e selected or \e unselected.<br>
+ /// Radio buttons are designed to select one of many option at the same time.<br>
+ /// RadioButton can change its current state using Selected.<br>
+ /// <br>
+ /// RadioButtons can be grouped.<br>
+ /// Two or more RadioButtons are in one group when they have this same parent.<br>
+ /// In each groups only one RadioButton can be \e selected at a given time.<br>
+ /// So when RadioButton is set to \e selected, other RadioButtons in its group are set to \e unselected.<br>
+ /// When \e selected RadioButton is set to \e unselected no other RadioButtons in his group is set to \e selected.<br>
+ /// <br>
+ /// A StateChanged Event is emitted when the RadioButton change its state to \e selected or \e unselected.<br>
/// </summary>
public class RadioButton : Button
{
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make RadioButton instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
}
+ /// <summary>
+ /// Constructor
+ /// </summary>
+ /// <param name="x">position in x coordinate</param>
+ /// <param name="y">position in y coordinate</param>
+ /// <param name="width">Width of the rectangle</param>
+ /// <param name="height">Height of the rectangle</param>
public Rectangle(float x, float y, float width, float height) : this( (int)x, (int)y, (int)width, (int)height )
{
}
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make Rotation instance be disposed.
+ /// </summary>
public virtual void Dispose()
{
if (!Stage.IsInstalled())
/// <summary>
/// ScrollBar is a UI component that can be linked to the scrollable objects
- /// indicating the current scroll position of the scrollable object.
+ /// indicating the current scroll position of the scrollable object.<br>
/// </summary>
public class ScrollBar : View
{
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make ScrollBar instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
/// <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.
+ /// Downcasts a handle to ScrollBar handle.<br>
+ /// If handle points to a ScrollBar, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>Handle to a ScrollBar or an uninitialized handle</returns>
}
/// <summary>
- /// Check equality.
- /// Utilizes appropriate machine epsilon values.
+ /// Check equality.<br>
+ /// Utilizes appropriate machine epsilon values.<br>
/// </summary>
/// <param name="rhs">The Size to test against</param>
/// <returns>True if the Sizes are equal</returns>
}
/// <summary>
- /// Check inequality.
- /// Utilizes appropriate machine epsilon values.
+ /// Check inequality.<br>
+ /// Utilizes appropriate machine epsilon values.<br>
/// </summary>
/// <param name="rhs">The Size to test against</param>
/// <returns>True if the Sizes are not equal</returns>
}
/// <summary>
- /// Check equality.
- /// Utilizes appropriate machine epsilon values.
+ /// Check equality.<br>
+ /// Utilizes appropriate machine epsilon values.<br>
/// </summary>
/// <param name="rhs">The Size to test against</param>
/// <returns>True if the Sizes are equal</returns>
}
/// <summary>
- /// Check inequality.
- /// Utilizes appropriate machine epsilon values.
+ /// Check inequality.<br>
+ /// Utilizes appropriate machine epsilon values.<br>
/// </summary>
/// <param name="rhs">The Size to test against</param>
/// <returns>True if the Sizes are not equal</returns>
}
/// <summary>
- /// Downcasts an Object handle to Slider.
- /// If handle points to a Slider, the downcast produces valid handle.
- /// If not, the returned handle is left uninitialized.
+ /// Downcasts an Object handle to Slider.<br>
+ /// If handle points to a Slider, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>Handle to a Slider or an uninitialized handle</returns>
using System.Runtime.InteropServices;
/// <summary>
- /// The Stage is a top-level object used for displaying a tree of Actors.
- /// Stage is a top-level object that represents the entire screen.
+ /// The Stage is a top-level object used for displaying a tree of Actors.<br>
+ /// Stage is a top-level object that represents the entire screen.<br>
/// It is used for displaying a hierarchy of actors managed by the scene graph structure,
/// which means an actor inherits a position relative to its parent,
- /// and can be moved in relation to this point.
+ /// and can be moved in relation to this point.<br>
/// The stage instance is a singleton object (the only instance of its class during the
- /// lifetime of the program). You can get it using a static function.
- /// To display the contents of an actor, it must be added to a stage.
+ /// lifetime of the program). You can get it using a static function.<br>
+ /// To display the contents of an actor, it must be added to a stage.<br>
/// </summary>
public class Stage : BaseHandle
{
private EventCallbackDelegateType1 _stageTouchCallbackDelegate;
/// <summary>
- /// This is emitted when the screen is touched and when the touch ends.
+ /// This is emitted when the screen is touched and when the touch ends.<br>
/// If there are multiple touch points, then this will be emitted when the first touch occurs and
- /// then when the last finger is lifted.
- /// An interrupted event will also be emitted (if it occurs).
+ /// then when the last finger is lifted.<br>
+ /// An interrupted event will also be emitted (if it occurs).<br>
/// </summary>
public event EventHandler<TouchEventArgs> Touch
{
}
/// <summary>
- /// Dpi property (read-only).
- /// Retrieves the DPI of the display device to which the stage is connected.
+ /// Dpi property (read-only).<br>
+ /// Retrieves the DPI of the display device to which the stage is connected.<br>
/// </summary>
public Vector2 Dpi
{
}
/// <summary>
- /// Layer count property (read-only).
- /// Queries the number of on-stage layers.
+ /// Layer count property (read-only).<br>
+ /// Queries the number of on-stage layers.<br>
/// </summary>
public uint LayerCount
{
private static readonly Stage instance = Stage.GetCurrent();
/// <summary>
- /// Stage instance property (read-only).
- /// Gets the current Stage.
+ /// Stage instance property (read-only).<br>
+ /// Gets the current Stage.<br>
/// </summary>
public static Stage Instance
{
/// <summary>
/// StyleManager informs applications of system theme change,
- /// and supports application theme change at runtime.
- /// Applies various styles to Controls using the properties system.
+ /// and supports application theme change at runtime.<br>
+ /// Applies various styles to Controls using the properties system.<br>
/// On theme change, it automatically updates all controls, then raises
- /// a event to inform the application.
- ///
+ /// a event to inform the application.<br>
+ /// <br>
/// If the application wants to customize the theme, RequestThemeChange
- /// needs to be called.
+ /// needs to be called.<br>
/// It provides the path to the application resource root folder,
/// from there the filename can an be specified along with
- /// any sub folders, e.g Images, Models etc.
+ /// any sub folders, e.g Images, Models etc.<br>
/// </summary>
public class StyleManager : BaseHandle
{
/// <summary>
/// StyleChange - contains Style change information (default font changed or
- /// default font size changed or theme has changed)
+ /// default font size changed or theme has changed).<br>
/// </summary>
public StyleChangeType StyleChange
{
/// <summary>
/// Event for StyleChanged signal which can be used to subscribe/unsubscribe the
- /// event handler provided by the user.
+ /// event handler provided by the user.<br>
/// StyleChanged signal is is emitted after the style (e.g. theme/font change) has changed
- /// and the controls have been informed.
+ /// and the controls have been informed.<br>
/// </summary>
public event EventHandler<StyleChangedEventArgs> StyleChanged
{
}
/// <summary>
- /// Creates a StyleManager handle.
- /// this can be initialized with StyleManager::Get().
+ /// Creates a StyleManager handle.<br>
+ /// this can be initialized with StyleManager::Get().<br>
/// </summary>
public StyleManager() : this(NDalicPINVOKE.new_StyleManager(), true)
{
}
/// <summary>
- /// Applies a new theme to the application.
- /// This will be merged on top of the default Toolkit theme.
+ /// Applies a new theme to the application. <br>
+ /// This will be merged on top of the default Toolkit theme.<br>
/// If the application theme file doesn't style all controls that the
/// application uses, then the default Toolkit theme will be used
- /// instead for those controls.
+ /// instead for those controls.<br>
/// </summary>
/// <param name="themeFile">A relative path is specified for style theme</param>
public void ApplyTheme(string themeFile)
{
/// <summary>
- /// TableView is a layout container for aligning child actors in a grid like layout.
- /// TableView constrains the x and y position and width and height of the child actors.
+ /// TableView is a layout container for aligning child actors in a grid like layout.<br>
+ /// TableView constrains the x and y position and width and height of the child actors.<br>
/// z position and depth are left intact so that 3D model actors can also be laid out
- /// in a grid without loosing their depth scaling.
+ /// in a grid without loosing their depth scaling.<br>
/// </summary>
public class TableView : View
{
}
/// <summary>
- /// Downcasts a handle to TableView handle.
- /// If handle points to a TableView, the downcast produces valid handle.
- /// If not, the returned handle is left uninitialized.
+ /// Downcasts a handle to TableView handle.<br>
+ /// If handle points to a TableView, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>Handle to a TableView or an uninitialized handle</returns>
}
/// <summary>
- /// Adds a child to the table.
- /// If the row or column index is outside the table, the table gets resized bigger.
+ /// Adds a child to the table.<br>
+ /// If the row or column index is outside the table, the table gets resized bigger.<br>
/// </summary>
/// <param name="child">The child to add</param>
/// <param name="position">The position for the child</param>
}
/// <summary>
- /// Deletes a row from the given index.
- /// Removed elements are deleted.
+ /// Deletes a row from the given index.<br>
+ /// Removed elements are deleted.<br>
/// </summary>
/// <param name="rowIndex">The rowIndex of the row to delete</param>
public void DeleteRow(uint rowIndex)
}
/// <summary>
- /// Deletes a column from the given index.
- /// Removed elements are deleted.
+ /// Deletes a column from the given index.<br>
+ /// Removed elements are deleted.<br>
/// </summary>
/// <param name="columnIndex">The columnIndex of the column to delete</param>
public void DeleteColumn(uint columnIndex)
}
/// <summary>
- /// Sets a row to have fixed height.
- /// Setting a fixed height of 0 has no effect.
+ /// Sets a row to have fixed height.<br>
+ /// Setting a fixed height of 0 has no effect.<br>
/// </summary>
/// <param name="rowIndex">The rowIndex for row with fixed height</param>
/// <param name="height">The height in world coordinate units</param>
/// <summary>
/// Sets a row to have relative height. Relative height means percentage of
- /// the remainder of the table height after subtracting Padding and Fixed height rows.
- /// Setting a relative height of 0 has no effect.
+ /// the remainder of the table height after subtracting Padding and Fixed height rows.<br>
+ /// Setting a relative height of 0 has no effect.<br>
/// </summary>
/// <param name="rowIndex">The rowIndex for row with relative height</param>
/// <param name="heightPercentage">The height percentage between 0.0f and 1.0f</param>
}
/// <summary>
- /// Sets a column to have fixed width.
- /// Setting a fixed width of 0 has no effect.
+ /// Sets a column to have fixed width.<br>
+ /// Setting a fixed width of 0 has no effect.<br>
/// </summary>
/// <param name="columnIndex">The columnIndex for column with fixed width</param>
/// <param name="width">The width in world coordinate units</param>
/// <summary>
/// Sets a column to have relative width. Relative width means percentage of
- /// the remainder of table width after subtracting Padding and Fixed width columns.
- /// Setting a relative width of 0 has no effect.
+ /// the remainder of table width after subtracting Padding and Fixed width columns.<br>
+ /// Setting a relative width of 0 has no effect.<br>
/// </summary>
/// <param name="columnIndex">The columnIndex for column with fixed width</param>
/// <param name="widthPercentage">The widthPercentage between 0.0f and 1.0f</param>
}
/// <summary>
- /// Sets the alignment on a cell.
- /// Cells without calling this function have the default values of LEFT and TOP respectively.
+ /// Sets the alignment on a cell.<br>
+ /// Cells without calling this function have the default values of LEFT and TOP respectively.<br>
/// </summary>
/// <param name="position">The cell to set alignment on</param>
/// <param name="horizontal">The horizontal alignment</param>
/// <summary>
/// Event for TextChanged signal which can be used to subscribe/unsubscribe the event handler
- /// provided by the user. TextChanged signal is emitted when the text changes.
+ /// provided by the user. TextChanged signal is emitted when the text changes.<br>
/// </summary>
public event EventHandler<TextChangedEventArgs> TextChanged
{
{
/// <summary>
- /// A control which renders a short text string.
- /// Text labels are lightweight, non-editable and do not respond to user input.
+ /// A control which renders a short text string.<br>
+ /// Text labels are lightweight, non-editable and do not respond to user input.<br>
/// </summary>
public class TextLabel : View
{
}
/// <summary>
- /// RenderingBackend property
+ /// RenderingBackend property.<br>
/// The type of rendering e.g. bitmap-based.
/// </summary>
public int RenderingBackend
}
/// <summary>
- /// Text property
- /// The text to display in UTF-8 format.
+ /// Text property.<br>
+ /// The text to display in UTF-8 format.<br>
/// </summary>
public string Text
{
}
/// <summary>
- /// FontFamily property
- /// The requested font family to use.
+ /// FontFamily property.<br>
+ /// The requested font family to use.<br>
/// </summary>
public string FontFamily
{
}
/// <summary>
- /// FontStyle property
- /// The requested font style to use.
+ /// FontStyle property.<br>
+ /// The requested font style to use.<br>
/// </summary>
public PropertyMap FontStyle
{
}
/// <summary>
- /// PointSize property
- /// The size of font in points.
+ /// PointSize property.<br>
+ /// The size of font in points.<br>
/// </summary>
public float PointSize
{
}
/// <summary>
- /// MultiLine property
- /// The single-line or multi-line layout option.
+ /// MultiLine property.<br>
+ /// The single-line or multi-line layout option.<br>
/// </summary>
public bool MultiLine
{
}
/// <summary>
- /// HorizontalAlignment property
- /// The line horizontal alignment.
+ /// HorizontalAlignment property.<br>
+ /// The line horizontal alignment.<br>
/// </summary>
public string HorizontalAlignment
{
}
/// <summary>
- /// VerticalAlignment property
- /// The line vertical alignment.
+ /// VerticalAlignment property.<br>
+ /// The line vertical alignment.<br>
/// </summary>
public string VerticalAlignment
{
}
/// <summary>
- /// TextColor property
- /// The color of the text.
+ /// TextColor property.<br>
+ /// The color of the text.<br>
/// </summary>
public Color TextColor
{
}
/// <summary>
- /// ShadowOffset property
- /// The drop shadow offset 0 indicates no shadow.
+ /// ShadowOffset property.<br>
+ /// The drop shadow offset 0 indicates no shadow.<br>
/// </summary>
public Vector2 ShadowOffset
{
}
/// <summary>
- /// ShadowColor property
- /// The color of a drop shadow.
+ /// ShadowColor property.<br>
+ /// The color of a drop shadow.<br>
/// </summary>
public Vector4 ShadowColor
{
}
/// <summary>
- /// UnderlineEnabled property
- /// The underline enabled flag.
+ /// UnderlineEnabled property.<br>
+ /// The underline enabled flag.<br>
/// </summary>
public bool UnderlineEnabled
{
}
/// <summary>
- /// UnderlineColor property
- /// Overrides the underline height from font metrics.
+ /// UnderlineColor property.<br>
+ /// Overrides the underline height from font metrics.<br>
/// </summary>
public Vector4 UnderlineColor
{
}
/// <summary>
- /// UnderlineHeight property
- /// Overrides the underline height from font metrics.
+ /// UnderlineHeight property.<br>
+ /// Overrides the underline height from font metrics.<br>
/// </summary>
public float UnderlineHeight
{
}
/// <summary>
- /// EnableMarkup property
- /// Whether the mark-up processing is enabled.
+ /// EnableMarkup property.<br>
+ /// Whether the mark-up processing is enabled.<br>
/// </summary>
public bool EnableMarkup
{
}
/// <summary>
- /// EnableAutoScroll property
- /// Starts or stops auto scrolling.
+ /// EnableAutoScroll property.<br>
+ /// Starts or stops auto scrolling.<br>
/// </summary>
public bool EnableAutoScroll
{
}
/// <summary>
- /// AutoScrollSpeed property
- /// Sets the speed of scrolling in pixels per second.
+ /// AutoScrollSpeed property.<br>
+ /// Sets the speed of scrolling in pixels per second.<br>
/// </summary>
public int AutoScrollSpeed
{
}
/// <summary>
- /// AutoScrollLoopCount property
- /// Number of complete loops when scrolling enabled.
+ /// AutoScrollLoopCount property.<br>
+ /// Number of complete loops when scrolling enabled.<br>
/// </summary>
public int AutoScrollLoopCount
{
}
/// <summary>
- /// AutoScrollGap property
- /// Gap before scrolling wraps.
+ /// AutoScrollGap property.<br>
+ /// Gap before scrolling wraps.<br>
/// </summary>
public float AutoScrollGap
{
}
/// <summary>
- /// LineSpacing property
- /// The default extra space between lines in points.
+ /// LineSpacing property.<br>
+ /// The default extra space between lines in points.<br>
/// </summary>
public float LineSpacing
{
}
/// <summary>
- /// Underline property
- /// The default underline parameters.
+ /// Underline property.<br>
+ /// The default underline parameters.<br>
/// </summary>
public PropertyMap Underline
{
}
/// <summary>
- /// Shadow property
- /// The default shadow parameters.
+ /// Shadow property.<br>
+ /// The default shadow parameters.<br>
/// </summary>
public PropertyMap Shadow
{
}
/// <summary>
- /// Emboss property
- /// The default emboss parameters.
+ /// Emboss property.<br>
+ /// The default emboss parameters.<br>
/// </summary>
public string Emboss
{
}
/// <summary>
- /// Outline property
- /// The default outline parameters.
+ /// Outline property.<br>
+ /// The default outline parameters.<br>
/// </summary>
public string Outline
{
using System.Runtime.InteropServices;
/// <summary>
- /// Mechanism to issue simple periodic or one-shot events.
+ /// Mechanism to issue simple periodic or one-shot events.<br>
/// 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.
+ /// in sync with Dali's render timer.<br>
/// This class is a handle class so it can be stack allocated and used
- /// as a member.
+ /// as a member.<br>
/// </summary>
public class Timer : BaseHandle
{
/// <summary>
- /// Event arguments that passed via Tick event
+ /// Event arguments that passed via Tick event.
/// </summary>
public class TickEventArgs : EventArgs
{
/// <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.
+ /// (in the type of TickEventHandler-DaliEventHandlerWithReturnType<object,TickEventArgs,bool>).<br>
+ /// provided by the user. Ticked signal is emitted after specified time interval.<br>
/// </summary>
public event EventHandlerWithReturnType<object, TickEventArgs, bool> Tick
{
}
/// <summary>
- /// Starts timer
- /// In case a Timer is already running, its time is reset and timer is restarted.
+ /// Starts timer.<br>
+ /// In case a Timer is already running, its time is reset and timer is restarted.<br>
/// </summary>
public void Start()
{
}
/// <summary>
- /// Sets a new interval on the timer and starts the timer.
- /// Cancels the previous timer.
+ /// Sets a new interval on the timer and starts the timer.<br>
+ /// Cancels the previous timer.<br>
/// </summary>
/// <param name="milliSec">milliSec Interval in milliseconds</param>
internal void SetInterval(uint milliSec)
namespace Tizen.NUI
{
/// <summary>
- /// Touch events are a collection of points at a specific moment in time.
+ /// Touch events are a collection of points at a specific moment in time.<br>
/// When a multi-touch event occurs, each point represents the points that are currently being
- /// touched or the points where a touch has stopped.
+ /// touched or the points where a touch has stopped.<br>
/// </summary>
public class Touch : BaseHandle
{
}
/// <summary>
- /// An uninitialized Touch instance.
- /// Calling member functions with an uninitialized Touch handle is not allowed.
+ /// An uninitialized Touch instance.<br>
+ /// Calling member functions with an uninitialized Touch handle is not allowed.<br>
/// </summary>
public Touch() : this(NDalicPINVOKE.new_Touch__SWIG_0(), true)
{
}
/// <summary>
- /// Returns the ID of the device used for the Point specified.
+ /// Returns the ID of the device used for the Point specified.<br>
/// 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.
+ /// point. This is returned by this method.<br>
+ /// If point is greater than GetPointCount() then this method will return -1.<br>
/// </summary>
/// <param name="point">The point required</param>
/// <returns>The Device ID of this point</returns>
}
/// <summary>
- /// Retrieves the State of the point specified.
- /// If point is greater than GetPointCount() then this method will return PointState.Finished.
+ /// Retrieves the State of the point specified.<br>
+ /// If point is greater than GetPointCount() then this method will return PointState.Finished.<br>
/// </summary>
/// <param name="point">The point required</param>
/// <returns>The state of the point specified</returns>
}
/// <summary>
- /// Retrieves the actor that was underneath the point specified.
- /// If point is greater than GetPointCount() then this method will return an empty handle.
+ /// Retrieves the actor that was underneath the point specified.<br>
+ /// If point is greater than GetPointCount() then this method will return an empty handle.<br>
/// </summary>
/// <param name="point">The point required</param>
/// <returns>The actor that was underneath the point specified</returns>
}
/// <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).
+ /// Retrieves the co-ordinates relative to the top-left of the hit-actor at the point specified.<br>
+ /// The top-left of an actor is (0.0, 0.0, 0.5).<br>
/// 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.
+ /// then you should use Actor::ScreenToLocal().<br>
+ /// If point is greater than GetPointCount() then this method will return Vector2.Zero.<br>
/// </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>
}
/// <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.
+ /// Retrieves the co-ordinates relative to the top-left of the screen of the point specified.<br>
+ /// If point is greater than GetPointCount() then this method will return Vector2.Zero.<br>
/// </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>
}
/// <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.
+ /// Retrieves the radius of the press point.<br>
+ /// This is the average of both the horizontal and vertical radii of the press point.<br>
+ /// If point is greater than GetPointCount() then this method will return 0.0f.<br>
/// </summary>
/// <param name="point">The point required</param>
/// <returns>The radius of the press point</returns>
}
/// <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.
+ /// Retrieves BOTH the horizontal and the vertical radii of the press point.<br>
+ /// If point is greater than GetPointCount() then this method will return Vector2.Zero.<br>
/// </summary>
/// <param name="point">The point required</param>
/// <returns>The horizontal and vertical radii of the press point</returns>
}
/// <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.
+ /// Retrieves the touch pressure.<br>
+ /// The pressure range starts at 0.0f.<br>
+ /// Normal pressure is defined as 1.0f.<br>
+ /// A value between 0.0f and 1.0f means light pressure has been applied.<br>
+ /// A value greater than 1.0f means more pressure than normal has been applied.<br>
+ /// If point is greater than GetPointCount() then this method will return 1.0f.<br>
/// </summary>
/// <param name="point">point The point required</param>
/// <returns>The touch pressure</returns>
}
/// <summary>
- /// Returns the length of the vector squared.
+ /// Returns the length of the vector squared.<br>
/// This is more efficient than Length() for threshold
- /// testing as it avoids the use of a square root.
+ /// testing as it avoids the use of a square root.<br>
/// </summary>
/// <returns>The length of the vector squared</returns>
public float LengthSquared()
}
/// <summary>
- /// Returns the length of the vector squared.
+ /// Returns the length of the vector squared.<br>
/// This is more efficient than Length() for threshold
- /// testing as it avoids the use of a square root.
+ /// testing as it avoids the use of a square root.<br>
/// </summary>
/// <returns>The length of the vector squared</returns>
public float LengthSquared()
}
/// <summary>
- /// Returns the length of the vector squared.
+ /// Returns the length of the vector squared.<br>
/// This is faster than using Length() when performing
- /// threshold checks as it avoids use of the square root.
+ /// threshold checks as it avoids use of the square root.<br>
/// </summary>
/// <returns>The length of the vector squared</returns>
public float LengthSquared()
}
/// <summary>
- /// Normalizes the vector.
- /// Sets the vector to unit length whilst maintaining its direction.
+ /// Normalizes the vector.<br>
+ /// Sets the vector to unit length whilst maintaining its direction.<br>
/// </summary>
public void Normalize()
{
/// <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.
+ /// (in the type of FinishedEventHandler-DaliEventHandler<object,FinishedEventArgs>) provided by the user.<br>
+ /// Finished signal is emitted when a video playback have finished.<br>
/// </summary>
public event EventHandler<FinishedEventArgs> Finished
{
}
/// <summary>
- /// Creates an initialized VideoView.
- /// If the string is empty, VideoView will not display anything.
+ /// Creates an initialized VideoView.<br>
+ /// If the string is empty, VideoView will not display anything.<br>
/// </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)
}
/// <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.
+ /// Downcasts a handle to VideoView handle.<br>
+ /// If handle points to a VideoView, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>Handle to a VideoView or an uninitialized handle</returns>
private delegate void KeyInputFocusGainedCallbackType(IntPtr control);
private KeyInputFocusGainedCallbackType _keyInputFocusGainedCallback;
- /**
- * @brief Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler
- * provided by the user. KeyInputFocusGained signal is emitted when the control gets Key Input Focus.
- */
+ /// <summary>
+ /// Event for KeyInputFocusGained signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
+ /// KeyInputFocusGained signal is emitted when the control gets Key Input Focus.<br>
+ /// </summary>
public event EventHandler FocusGained
{
add
private delegate void KeyInputFocusLostCallbackType(IntPtr control);
private KeyInputFocusLostCallbackType _keyInputFocusLostCallback;
- /**
- * @brief Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler
- * provided by the user. KeyInputFocusLost signal is emitted when the control loses Key Input Focus.
- */
+ /// <summary>
+ /// Event for KeyInputFocusLost signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
+ /// KeyInputFocusLost signal is emitted when the control loses Key Input Focus.<br>
+ /// </summary>
public event EventHandler FocusLost
{
add
}
}
-
- /**
- * @brief Event arguments that passed via KeyEvent signal
- *
- */
+ /// <summary>
+ /// Event arguments that passed via KeyEvent signal.
+ /// </summary>
public class KeyEventArgs : EventArgs
{
private Key _key;
- /**
- * @brief KeyEvent - is the keyevent sent to the View.
- *
- */
+ /// <summary>
+ /// Key - is the key sent to the View.
+ /// </summary>
public Key Key
{
get
private delegate bool KeyCallbackType(IntPtr control, IntPtr keyEvent);
private KeyCallbackType _keyCallback;
- /**
- * @brief Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler
- * provided by the user. KeyPressed signal is emitted when key event is received.
- */
+ /// <summary>
+ /// Event for KeyPressed signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
+ /// KeyPressed signal is emitted when key event is received.<br>
+ /// </summary>
public event EventHandlerWithReturnType<object, KeyEventArgs, bool> KeyEvent
{
add
private delegate void OnRelayoutEventCallbackType(IntPtr control);
private OnRelayoutEventCallbackType _onRelayoutEventCallback;
- /**
- * @brief Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler
- * OnRelayout signal is emitted after the size has been set on the view during relayout.
- */
+ /// <summary>
+ /// Event for OnRelayout signal which can be used to subscribe/unsubscribe the event handler.<br>
+ /// OnRelayout signal is emitted after the size has been set on the view during relayout.<br>
+ /// </summary>
public event EventHandler OnRelayoutEvent
{
add
}
}
-
- /**
- * @brief Event arguments that passed via Touch signal
- *
- */
+ /// <summary>
+ /// Event arguments that passed via Touch signal.
+ /// </summary>
public class TouchEventArgs : EventArgs
{
private Touch _touch;
- /**
- * @brief TouchData - contains the information of touch points
- *
- */
+ /// <summary>
+ /// Touch - contains the information of touch points
+ /// </summary>
public Touch Touch
{
get
private delegate bool TouchDataCallbackType(IntPtr view, IntPtr touchData);
private TouchDataCallbackType _touchDataCallback;
- /**
- * @brief Event for Touched signal which can be used to subscribe/unsubscribe the event handler
- * provided by the user. Touched signal is emitted when touch input is received.
- */
+ /// <summary>
+ /// Event for Touched signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
+ /// Touched signal is emitted when touch input is received.<br>
+ /// </summary>
public event EventHandlerWithReturnType<object, TouchEventArgs, bool> Touched
{
add
}
- /**
- * @brief Event arguments that passed via Hover signal
- *
- */
+ /// <summary>
+ /// Event arguments that passed via Hover signal.
+ /// </summary>
public class HoverEventArgs : EventArgs
{
private Hover _hover;
- /**
- * @brief HoverEvent - contains touch points that represent the points
- * that are currently being hovered or the points where a hover has stopped
- *
- */
+
+ /// <summary>
+ /// Hover - contains touch points that represent the points that are currently being hovered or the points where a hover has stopped.
+ /// </summary>
public Hover Hover
{
get
private delegate bool HoverEventCallbackType(IntPtr view, IntPtr hoverEvent);
private HoverEventCallbackType _hoverEventCallback;
- /**
- * @brief Event for Hovered signal which can be used to subscribe/unsubscribe the event handler
- * provided by the user. Hovered signal is emitted when hover input is received.
- */
+ /// <summary>
+ /// Event for Hovered signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
+ /// Hovered signal is emitted when hover input is received.<br>
+ /// </summary>
public event EventHandlerWithReturnType<object, HoverEventArgs, bool> Hovered
{
add
}
- /**
- * @brief Event arguments that passed via Wheel signal
- *
- */
+ /// <summary>
+ /// Event arguments that passed via Wheel signal.
+ /// </summary>
public class WheelEventArgs : EventArgs
{
private Wheel _wheel;
- /**
- * @brief WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
- *
- */
+
+ /// <summary>
+ /// WheelEvent - store a wheel rolling type : MOUSE_WHEEL or CUSTOM_WHEEL
+ /// </summary>
public Wheel Wheel
{
get
private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
private WheelEventCallbackType _wheelEventCallback;
- /**
- * @brief Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler
- * provided by the user. WheelMoved signal is emitted when wheel event is received.
- */
+ /// <summary>
+ /// Event for WheelMoved signal which can be used to subscribe/unsubscribe the event handler provided by the user.<br>
+ /// WheelMoved signal is emitted when wheel event is received.<br>
+ /// </summary>
public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelMoved
{
add
private delegate void OnStageEventCallbackType(IntPtr control);
private OnStageEventCallbackType _onStageEventCallback;
- /**
- * @brief Event for OnStage signal which can be used to subscribe/unsubscribe the event handler
- * OnStage signal is emitted after the view has been connected to the stage.
- */
+ /// <summary>
+ /// Event for OnStage signal which can be used to subscribe/unsubscribe the event handler.<br>
+ /// OnStage signal is emitted after the view has been connected to the stage.<br>
+ /// </summary>
public event EventHandler OnStageEvent
{
add
private delegate void OffStageEventCallbackType(IntPtr control);
private OffStageEventCallbackType _offStageEventCallback;
- /**
- * @brief Event for OffStage signal which can be used to subscribe/unsubscribe the event handler
- * OffStage signal is emitted after the view has been disconnected from the stage.
- */
+ /// <summary>
+ /// Event for OffStage signal which can be used to subscribe/unsubscribe the event handler.<br>
+ /// OffStage signal is emitted after the view has been disconnected from the stage.<br>
+ /// </summary>
public event EventHandler OffStageEvent
{
add
}
/// <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.
+ /// Downcasts a handle to View handle.<br>
+ /// If handle points to a View, the downcast produces valid handle.<br>
+ /// If not, the returned handle is left uninitialized.<br>
/// </summary>
/// <param name="handle">Handle to an object</param>
/// <returns>A handle to a View or an uninitialized handle</returns>
}
/// <summary>
- /// Child Property of FlexContainer
- /// The proportion of the free space in the container the flex item will receive.
- /// If all items in the container set this property, their sizes will be proportional to the specified flex factor
+ /// Child Property of FlexContainer.<br>
+ /// The proportion of the free space in the container the flex item will receive.<br>
+ /// If all items in the container set this property, their sizes will be proportional to the specified flex factor.<br>
/// </summary>
public float Flex
{
}
/// <summary>
- /// Child Property of FlexContainer
- /// The alignment of the flex item along the cross axis, which, if set, overides the default alignment for all items in the container
+ /// Child Property of FlexContainer.<br>
+ /// The alignment of the flex item along the cross axis, which, if set, overides the default alignment for all items in the container.<br>
/// </summary>
public int AlignSelf
{
}
/// <summary>
- /// Child Property of FlexContainer
- /// The space around the flex item
+ /// Child Property of FlexContainer.<br>
+ /// The space around the flex item.<br>
/// </summary>
public Vector4 FlexMargin
{
}
/// <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.
+ /// The left focusable view.<br>
+ /// This will return NULL if not set.<br>
+ /// This will also return NULL if the specified left focusable view is not on stage.<br>
/// </summary>
public View LeftFocusableView
{
}
/// <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.
+ /// The right focusable view.<br>
+ /// This will return NULL if not set.<br>
+ /// This will also return NULL if the specified right focusable view is not on stage.<br>
/// </summary>
public View RightFocusableView
{
}
/// <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.
+ /// The up focusable view.<br>
+ /// This will return NULL if not set.<br>
+ /// This will also return NULL if the specified up focusable view is not on stage.<br>
/// </summary>
public View UpFocusableView
{
}
/// <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.
+ /// The down focusable view.<br>
+ /// This will return NULL if not set.<br>
+ /// This will also return NULL if the specified down focusable view is not on stage.<br>
/// </summary>
public View DownFocusableView
{
{
/// <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.
+ /// Sets whether the actor should be focusable by keyboard navigation.<br>
+ /// Visuals reuse geometry, shader etc. across controls. They ensure that the renderer and texture sets exist only when control is on-stage.<br>
+ /// Each visual also responds to actor size and color change, and provides clipping at the renderer level.<br>
+ /// Note: The visual responds to the the Actor::COLOR by blending it with the 'Multiply' operator.<br>
/// </summary>
public class VisualBase : BaseHandle
{
}
/// <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.
+ /// Return the natural size of the visual.<br>
+ /// Deriving classes stipulate the natural size and by default a visual has a ZERO natural size.<br>
+ /// A visual may not actually have a natural size until it has been placed on stage and acquired all it's resources.<br>
/// </summary>
/// <param name="naturalSize">The visual's natural size</param>
public void GetNaturalSize(Size2D naturalSize)
}
/// <summary>
- /// Get or set size of the visual.
+ /// Get or set size of the visual.<br>
/// It can be either relative (percentage of the parent)
- /// or absolute (in world units).
+ /// or absolute (in world units).<br>
/// </summary>
public Vector2 VisualSize
{
}
/// <summary>
- /// Get or set offset of the visual.
+ /// Get or set offset of the visual.<br>
/// It can be either relative (percentage of the parent)
- /// or absolute (in world units).
+ /// or absolute (in world units).<br>
/// </summary>
public Vector2 Offset
{
}
/// <summary>
- /// Get or set offset policy of the visual.
+ /// Get or set offset policy of the visual.<br>
/// Indicates which components of the offset are relative
- /// (percentage of the parent) or absolute (in world units).
- /// 0 indicates the component is relative, and 1 absolute.
+ /// (percentage of the parent) or absolute (in world units).<br>
+ /// 0 indicates the component is relative, and 1 absolute.<br>
/// </summary>
public Vector2 OffsetPolicy
{
}
/// <summary>
- /// Get or set size policy of the visual.
+ /// Get or set size policy of the visual.<br>
/// Indicates which components of the size are relative
- /// (percentage of the parent) or absolute (in world units).
- /// 0 indicates the component is relative, and 1 absolute.
+ /// (percentage of the parent) or absolute (in world units).<br>
+ /// 0 indicates the component is relative, and 1 absolute.<br>
/// </summary>
public Vector2 SizePolicy
{
}
/// <summary>
- /// Get or set fitting options, used when resizing images to fit desired dimensions.
- /// If not supplied, default is FittingMode::SHRINK_TO_FIT.
- /// For Normal Quad images only.
+ /// Get or set fitting options, used when resizing images to fit desired dimensions.<br>
+ /// If not supplied, default is FittingMode::SHRINK_TO_FIT.<br>
+ /// For Normal Quad images only.<br>
/// </summary>
public FittingModeType FittingMode
{
}
/// <summary>
- /// Get or set filtering options, used when resizing images to sample original pixels.
- /// If not supplied, default is SamplingMode::BOX.
- /// For Normal Quad images only.
+ /// Get or set filtering options, used when resizing images to sample original pixels.<br>
+ /// If not supplied, default is SamplingMode::BOX.<br>
+ /// For Normal Quad images only.<br>
/// </summary>
public SamplingModeType SamplingMode
{
}
/// <summary>
- /// Get or set the desired image width.
- /// If not specified, the actual image width is used.
- /// For Normal Quad images only.
+ /// Get or set the desired image width.<br>
+ /// If not specified, the actual image width is used.<br>
+ /// For Normal Quad images only.<br>
/// </summary>
public int DesiredWidth
{
}
/// <summary>
- /// Get or set the desired image height.
- /// If not specified, the actual image height is used.
- /// For Normal Quad images only.
+ /// Get or set the desired image height.<br>
+ /// If not specified, the actual image height is used.<br>
+ /// For Normal Quad images only.<br>
/// </summary>
public int DesiredHeight
{
}
/// <summary>
- /// Get or set whether to load the image synchronously.
- /// If not specified, the default is false, i.e. the image is loaded asynchronously.
- /// For Normal Quad images only.
+ /// Get or set whether to load the image synchronously.<br>
+ /// If not specified, the default is false, i.e. the image is loaded asynchronously.<br>
+ /// For Normal Quad images only.<br>
/// </summary>
public bool SynchronousLoading
{
}
/// <summary>
- /// Get or set whether to draws the borders only(If true).
- /// If not specified, the default is false.
- /// For N-Patch images only.
+ /// Get or set whether to draws the borders only(If true).<br>
+ /// If not specified, the default is false.<br>
+ /// For N-Patch images only.<br>
/// </summary>
public bool BorderOnly
{
}
/// <summary>
- /// Get or set the image area to be displayed.
- /// It is a rectangular area.
- /// The first two elements indicate the top-left position of the area, and the last two elements are the area width and height respectively.
- /// If not specified, the default value is [0.0, 0.0, 1.0, 1.0], i.e. the entire area of the image.
- /// For For Normal QUAD image only.
+ /// Get or set the image area to be displayed.<br>
+ /// It is a rectangular area.<br>
+ /// The first two elements indicate the top-left position of the area, and the last two elements are the area width and height respectively.<br>
+ /// If not specified, the default value is [0.0, 0.0, 1.0, 1.0], i.e. the entire area of the image.<br>
+ /// For For Normal QUAD image only.<br>
/// </summary>
public Vector4 PixelArea
{
}
/// <summary>
- /// Get or set the wrap mode for u coordinate.
- /// It decides how the texture should be sampled when the u coordinate exceeds the range of 0.0 to 1.0.
- /// If not specified, the default is CLAMP.
- /// For Normal QUAD image only.
+ /// Get or set the wrap mode for u coordinate.<br>
+ /// It decides how the texture should be sampled when the u coordinate exceeds the range of 0.0 to 1.0.<br>
+ /// If not specified, the default is CLAMP.<br>
+ /// For Normal QUAD image only.<br>
/// </summary>
public WrapModeType WrapModeU
{
}
/// <summary>
- /// Get or set the wrap mode for v coordinate.
- /// It decides how the texture should be sampled when the v coordinate exceeds the range of 0.0 to 1.0.
- /// The first two elements indicate the top-left position of the area, and the last two elements are the area width and height respectively.
- /// If not specified, the default is CLAMP.
+ /// Get or set the wrap mode for v coordinate.<br>
+ /// It decides how the texture should be sampled when the v coordinate exceeds the range of 0.0 to 1.0.<br>
+ /// The first two elements indicate the top-left position of the area, and the last two elements are the area width and height respectively.<br>
+ /// If not specified, the default is CLAMP.<br>
/// For Normal QUAD image only.
/// </summary>
public WrapModeType WrapModeV
}
/// <summary>
- /// Get or set the line horizontal alignment.
- /// If not specified, the default is BEGIN.
+ /// Get or set the line horizontal alignment.<br>
+ /// If not specified, the default is BEGIN.<br>
/// </summary>
public string HorizontalAlignment
{
}
/// <summary>
- /// Get or set the line vertical alignment.
- /// If not specified, the default is TOP.
+ /// Get or set the line vertical alignment.<br>
+ /// If not specified, the default is TOP.<br>
/// </summary>
public string VerticalAlignment
{
}
/// <summary>
- /// Get or set whether anti-aliasing of the border is required.
- /// If not supplied, default is false.
+ /// Get or set whether anti-aliasing of the border is required.<br>
+ /// If not supplied, default is false.<br>
/// </summary>
public bool AntiAliasing
{
private GradientVisualSpreadMethodType _spreadMethod = GradientVisualSpreadMethodType.Pad;
/// <summary>
- /// Get or set the start position of a linear gradient.
- /// Mandatory for Linear.
+ /// Get or set the start position of a linear gradient.<br>
+ /// Mandatory for Linear.<br>
/// </summary>
public Vector2 StartPosition
{
}
/// <summary>
- /// Get or set the end position of a linear gradient.
- /// Mandatory for Linear.
+ /// Get or set the end position of a linear gradient.<br>
+ /// Mandatory for Linear.<br>
/// </summary>
public Vector2 EndPosition
{
}
/// <summary>
- /// Get or set the center point of a radial gradient.
- /// Mandatory for Radial.
+ /// Get or set the center point of a radial gradient.<br>
+ /// Mandatory for Radial.<br>
/// </summary>
public Vector2 Center
{
}
/// <summary>
- /// Get or set the size of the radius of a radial gradient.
- /// Mandatory for Radial.
+ /// Get or set the size of the radius of a radial gradient.<br>
+ /// Mandatory for Radial.<br>
/// </summary>
public float Radius
{
}
/// <summary>
- /// Get or set all the stop offsets.
- /// A PropertyArray of float.
- /// If not supplied, default is 0.0f and 1.0f.
+ /// Get or set all the stop offsets.<br>
+ /// A PropertyArray of float.<br>
+ /// If not supplied, default is 0.0f and 1.0f.<br>
/// </summary>
public PropertyArray StopOffset
{
}
/// <summary>
- /// Get or set the color at the stop offsets.
- /// A PropertyArray of Color.
- /// At least 2 values required to show a gradient.
+ /// Get or set the color at the stop offsets.<br>
+ /// A PropertyArray of Color.<br>
+ /// At least 2 values required to show a gradient.<br>
/// </summary>
public PropertyArray StopColor
{
}
/// <summary>
- /// Get or set defines the coordinate system for certain attributes of the points in a gradient.
- /// If not supplied, default is GradientVisualUnitsType.OBJECT_BOUNDING_BOX.
+ /// Get or set defines the coordinate system for certain attributes of the points in a gradient.<br>
+ /// If not supplied, default is GradientVisualUnitsType.OBJECT_BOUNDING_BOX.<br>
/// </summary>
public GradientVisualUnitsType Units
{
}
/// <summary>
- /// Get or set indicates what happens if the gradient starts or ends inside the bounds of the target rectangle.
- /// If not supplied, default is GradientVisualSpreadMethodType.PAD.
+ /// Get or set indicates what happens if the gradient starts or ends inside the bounds of the target rectangle.<br>
+ /// If not supplied, default is GradientVisualSpreadMethodType.PAD.<br>
/// </summary>
public GradientVisualSpreadMethodType SpreadMethod
{
}
/// <summary>
- /// Get or set the location of the ".mtl" file.
- /// If not specified, then a textureless object is assumed.
+ /// Get or set the location of the ".mtl" file.<br>
+ /// If not specified, then a textureless object is assumed.<br>
/// </summary>
public string MaterialtURL
{
}
/// <summary>
- /// Get or set path to the directory the textures (including gloss and normal) are stored in.
- /// Mandatory if using material.
+ /// Get or set path to the directory the textures (including gloss and normal) are stored in.<br>
+ /// Mandatory if using material.<br>
/// </summary>
public string TexturesPath
{
}
/// <summary>
- /// Get or set the type of shading mode that the mesh will use.
- /// If anything the specified shading mode requires is missing, a simpler mode that can be handled with what has been supplied will be used instead.
- /// If not specified, it will use the best it can support (will try MeshVisualShadingModeValue.TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING first).
+ /// Get or set the type of shading mode that the mesh will use.<br>
+ /// If anything the specified shading mode requires is missing, a simpler mode that can be handled with what has been supplied will be used instead.<br>
+ /// If not specified, it will use the best it can support (will try MeshVisualShadingModeValue.TEXTURED_WITH_DETAILED_SPECULAR_LIGHTING first).<br>
/// </summary>
public MeshVisualShadingModeValue ShadingMode
{
}
/// <summary>
- /// Get or set whether to use mipmaps for textures or not.
- /// If not specified, the default is true.
+ /// Get or set whether to use mipmaps for textures or not.<br>
+ /// If not specified, the default is true.<br>
/// </summary>
public bool UseMipmapping
{
}
/// <summary>
- /// Get or set whether to average normals at each point to smooth textures or not.
- /// If not specified, the default is true.
+ /// Get or set whether to average normals at each point to smooth textures or not.<br>
+ /// If not specified, the default is true.<br>
/// </summary>
public bool UseSoftNormals
{
}
/// <summary>
- /// Get or set the position, in stage space, of the point light that applies lighting to the model.
+ /// Get or set the position, in stage space, of the point light that applies lighting to the model.<br>
/// This is based off the stage's dimensions, so using the width and height of the stage halved will correspond to the center,
- /// and using all zeroes will place the light at the top left corner.
- /// If not specified, the default is an offset outwards from the center of the screen.
+ /// and using all zeroes will place the light at the top left corner.<br>
+ /// If not specified, the default is an offset outwards from the center of the screen.<br>
/// </summary>
public Vector3 LightPosition
{
private Vector3 _lightPosition = null; // default ?? center of screen
/// <summary>
- /// Get or set the specific shape to render.
- /// If not specified, the default is PrimitiveVisualShapeType.SPHERE.
+ /// Get or set the specific shape to render.<br>
+ /// If not specified, the default is PrimitiveVisualShapeType.SPHERE.<br>
/// </summary>
public PrimitiveVisualShapeType Shape
{
}
/// <summary>
- /// Get or set the color of the shape.
- /// If not specified, the default is Color(0.5, 0.5, 0.5, 1.0).
- /// Applies to ALL shapes.
+ /// Get or set the color of the shape.<br>
+ /// If not specified, the default is Color(0.5, 0.5, 0.5, 1.0).<br>
+ /// Applies to ALL shapes.<br>
/// </summary>
public Color MixColor
{
}
/// <summary>
- /// Get or set the number of slices as you go around the shape.
- /// For spheres and conical frustrums, this determines how many divisions there are as you go around the object.
- /// If not specified, the default is 128.
- /// The range is from 1 to 255.
+ /// Get or set the number of slices as you go around the shape.<br>
+ /// For spheres and conical frustrums, this determines how many divisions there are as you go around the object.<br>
+ /// If not specified, the default is 128.<br>
+ /// The range is from 1 to 255.<br>
/// </summary>
public int Slices
{
}
/// <summary>
- /// Get or set the number of stacks as you go down the shape.
- /// For spheres, 'stacks' determines how many layers there are as you go down the object.
- /// If not specified, the default is 128.
- /// The range is from 1 to 255.
+ /// Get or set the number of stacks as you go down the shape.<br>
+ /// For spheres, 'stacks' determines how many layers there are as you go down the object.<br>
+ /// If not specified, the default is 128.<br>
+ /// The range is from 1 to 255.<br>
/// </summary>
public int Stacks
{
}
/// <summary>
- /// Get or set the scale of the radius of the top circle of a conical frustrum.
- /// If not specified, the default is 1.0f.
- /// Applies to: - PrimitiveVisualShapeType.CONICAL_FRUSTRUM
- /// Only values greater than or equal to 0.0f are accepted.
+ /// Get or set the scale of the radius of the top circle of a conical frustrum.<br>
+ /// If not specified, the default is 1.0f.<br>
+ /// Applies to: - PrimitiveVisualShapeType.CONICAL_FRUSTRUM<br>
+ /// Only values greater than or equal to 0.0f are accepted.<br>
/// </summary>
public float ScaleTopRadius
{
}
/// <summary>
- /// Get or set the scale of the radius of the bottom circle of a conical frustrum.
- /// If not specified, the default is 1.5f.
- /// Applies to: - PrimitiveVisualShapeType.CONICAL_FRUSTRUM
- /// - PrimitiveVisualShapeType.CONE
- /// Only values greater than or equal to 0.0f are accepted.
+ /// Get or set the scale of the radius of the bottom circle of a conical frustrum.<br>
+ /// If not specified, the default is 1.5f.<br>
+ /// Applies to: - PrimitiveVisualShapeType.CONICAL_FRUSTRUM<br>
+ /// - PrimitiveVisualShapeType.CONE<br>
+ /// Only values greater than or equal to 0.0f are accepted.<br>
/// </summary>
public float ScaleBottomRadius
{
}
/// <summary>
- /// Get or set the scale of the height of a conic.
- /// If not specified, the default is 3.0f.
- /// Applies to:
- /// - Shape::CONICAL_FRUSTRUM
- /// - Shape::CONE
- /// - Shape::CYLINDER
- /// Only values greater than or equal to 0.0f are accepted.
+ /// Get or set the scale of the height of a conic.<br>
+ /// If not specified, the default is 3.0f.<br>
+ /// Applies to:<br>
+ /// - Shape::CONICAL_FRUSTRUM<br>
+ /// - Shape::CONE<br>
+ /// - Shape::CYLINDER<br>
+ /// Only values greater than or equal to 0.0f are accepted.<br>
/// </summary>
public float ScaleHeight
{
}
/// <summary>
- /// Get or set the scale of the radius of a cylinder.
- /// If not specified, the default is 1.0f.
- /// Applies to:
- /// - Shape::CYLINDER
- /// Only values greater than or equal to 0.0f are accepted.
+ /// Get or set the scale of the radius of a cylinder.<br>
+ /// If not specified, the default is 1.0f.<br>
+ /// Applies to:<br>
+ /// - Shape::CYLINDER<br>
+ /// Only values greater than or equal to 0.0f are accepted.<br>
/// </summary>
public float ScaleRadius
{
}
/// <summary>
- /// Get or set the dimensions of a cuboid. Scales in the same fashion as a 9-patch image.
- /// If not specified, the default is Vector3.One.
- /// Applies to:
- /// - Shape::CUBE
- /// - Shape::OCTAHEDRON
- /// - Shape::BEVELLED_CUBE
- /// Each vector3 parameter should be greater than or equal to 0.0f.
+ /// Get or set the dimensions of a cuboid. Scales in the same fashion as a 9-patch image.<br>
+ /// If not specified, the default is Vector3.One.<br>
+ /// Applies to:<br>
+ /// - Shape::CUBE<br>
+ /// - Shape::OCTAHEDRON<br>
+ /// - Shape::BEVELLED_CUBE<br>
+ /// Each vector3 parameter should be greater than or equal to 0.0f.<br>
/// </summary>
public Vector3 ScaleDimensions
{
}
/// <summary>
- /// Get or set determines how bevelled the cuboid should be, based off the smallest dimension.
- /// Bevel percentage ranges from 0.0 to 1.0. It affects the ratio of the outer face widths to the width of the overall cube.
- /// If not specified, the default is 0.0f (no bevel).
- /// Applies to:
- /// - Shape::BEVELLED_CUBE
- /// The range is from 0.0f to 1.0f.
+ /// Get or set determines how bevelled the cuboid should be, based off the smallest dimension.<br>
+ /// Bevel percentage ranges from 0.0 to 1.0. It affects the ratio of the outer face widths to the width of the overall cube.<br>
+ /// If not specified, the default is 0.0f (no bevel).<br>
+ /// Applies to:<br>
+ /// - Shape::BEVELLED_CUBE<br>
+ /// The range is from 0.0f to 1.0f.<br>
/// </summary>
public float BevelPercentage
{
}
/// <summary>
- /// Get or set defines how smooth the bevelled edges should be.
- /// If not specified, the default is 0.0f (sharp edges).
- /// Applies to:
- /// - Shape::BEVELLED_CUBE
- /// The range is from 0.0f to 1.0f.
+ /// Get or set defines how smooth the bevelled edges should be.<br>
+ /// If not specified, the default is 0.0f (sharp edges).<br>
+ /// Applies to:<br>
+ /// - Shape::BEVELLED_CUBE<br>
+ /// The range is from 0.0f to 1.0f.<br>
/// </summary>
public float BevelSmoothness
{
}
/// <summary>
- /// Get or set the position, in stage space, of the point light that applies lighting to the model.
+ /// Get or set the position, in stage space, of the point light that applies lighting to the model.<br>
/// This is based off the stage's dimensions, so using the width and height of the stage halved will correspond to the center,
- /// and using all zeroes will place the light at the top left corner.
- /// If not specified, the default is an offset outwards from the center of the screen.
+ /// and using all zeroes will place the light at the top left corner.<br>
+ /// If not specified, the default is an offset outwards from the center of the screen.<br>
/// Applies to ALL shapes.
/// </summary>
public Vector3 LightPosition
}
/// <summary>
- /// Get or set whether to draws the borders only(If true).
- /// If not specified, the default is false.
- /// For N-Patch images only.
+ /// Get or set whether to draws the borders only(If true).<br>
+ /// If not specified, the default is false.<br>
+ /// For N-Patch images only.<br>
/// </summary>
public bool BorderOnly
{
}
-
+ /// <summary>
+ /// This specifies wrap mode types
+ /// </summary>
public enum WrapModeType
{
Default = 0,
MirroredRepeat
}
+ /// <summary>
+ /// This specifies all kind os types of coordinate system for certain attributes of the points in a gradient.
+ /// </summary>
public enum GradientVisualUnitsType
{
ObjectBoundingBox,
UserSpace
}
+ /// <summary>
+ /// This specifies SpreadMethod types.<br>
+ /// SpreadMethod defines what happens if the gradient starts or ends inside the bounds of the target rectangle.<br>
+ /// </summary>
public enum GradientVisualSpreadMethodType
{
Pad,
Repeat
}
+ /// <summary>
+ /// This specifies shading mode types.
+ /// </summary>
public enum MeshVisualShadingModeValue
{
TexturelessWithDiffuseLighting,
TexturedWithDetailedSpecularLighting
}
+ /// <summary>
+ /// This specifies shape types.
+ /// </summary>
public enum PrimitiveVisualShapeType
{
Sphere,
BevelledCube
}
+ /// <summary>
+ /// This specifies fitting mode types. Fitting options, used when resizing images to fit desired dimensions.<br>
+ /// A fitting mode controls the region of a loaded image to be mapped to the desired image rectangle.<br>
+ /// All fitting modes preserve the aspect ratio of the image contents.<br>
+ /// </summary>
public enum FittingModeType
{
ShrinkToFit,
FitHeight
}
+ /// <summary>
+ /// This specifies sampling mode types. Filtering options, used when resizing images to sample original pixels.<br>
+ /// A SamplingMode controls how pixels in an input image are sampled and combined to generate each pixel of a destination image during a scaling.<br>
+ /// NoFilter and Box modes do not guarantee that the output pixel array exactly matches the rectangle specified by the desired dimensions and FittingMode,
+ /// but all other filter modes do if the desired dimensions are `<=` the raw dimensions of the input image file.<br>
+ /// </summary>
public enum SamplingModeType
{
Box,
DontCare
}
+ /// <summary>
+ /// This specifies policy types that could be used by the transform for the offset or size.
+ /// </summary>
public enum VisualTransformPolicyType
{
Relative = 0,
Absolute = 1
}
+ /// <summary>
+ /// This specifies align types.
+ /// </summary>
public enum AlignType
{
TopBegin = 0,
BottomEnd
}
+ /// <summary>
+ /// This specifies all the transform property types.
+ /// </summary>
public enum VisualTransformPropertyType
{
Offset,
SizePolicy
}
+ /// <summary>
+ /// This specifies visual types.
+ /// </summary>
public struct Visual
{
public enum Type
NPatch
}
+ /// <summary>
+ /// This specifies visual properties.
+ /// </summary>
public struct Property
{
public static readonly int Type = NDalic.VISUAL_PROPERTY_TYPE;
public static readonly int MixColor = NDalic.VISUAL_PROPERTY_MIX_COLOR;
}
+ /// <summary>
+ /// This specifies shader properties.
+ /// </summary>
public struct ShaderProperty
{
public static readonly int VertexShader = NDalic.VISUAL_SHADER_VERTEX;
}
}
+ /// <summary>
+ /// This specifies properties of BorderVisual.
+ /// </summary>
public struct BorderVisualProperty
{
public static readonly int Color = NDalic.BORDER_VISUAL_COLOR;
public static readonly int AntiAliasing = NDalic.BORDER_VISUAL_ANTI_ALIASING;
}
+ /// <summary>
+ /// This specifies properties of ColorVisual.
+ /// </summary>
public struct ColorVisualProperty
{
public static readonly int MixColor = NDalic.COLOR_VISUAL_MIX_COLOR;
}
+ /// <summary>
+ /// This specifies properties of GradientVisual.
+ /// </summary>
public struct GradientVisualProperty
{
public static readonly int StartPosition = NDalic.GRADIENT_VISUAL_START_POSITION;
public static readonly int SpreadMethod = NDalic.GRADIENT_VISUAL_SPREAD_METHOD;
}
+ /// <summary>
+ /// This specifies properties of ImageVisual.
+ /// </summary>
public struct ImageVisualProperty
{
public static readonly int URL = NDalic.IMAGE_VISUAL_URL;
public static readonly int WrapModeV = NDalic.IMAGE_VISUAL_WRAP_MODE_V;
}
+ /// <summary>
+ /// This specifies properties of MeshVisual.
+ /// </summary>
public struct MeshVisualProperty
{
public static readonly int ObjectURL = NDalic.MESH_VISUAL_OBJECT_URL;
public static readonly int LightPosition = NDalic.MESH_VISUAL_LIGHT_POSITION;
}
+ /// <summary>
+ /// This specifies properties of PrimitiveVisual.
+ /// </summary>
public struct PrimitiveVisualProperty
{
public static readonly int Shape = NDalic.PRIMITIVE_VISUAL_SHAPE;
public static readonly int LightPosition = NDalic.PRIMITIVE_VISUAL_LIGHT_POSITION;
}
+ /// <summary>
+ /// This specifies properties of TextVisual.
+ /// </summary>
public struct TextVisualProperty
{
public static readonly int Text = NDalic.TEXT_VISUAL_TEXT;
public static readonly int TextColor = NDalic.TEXT_VISUAL_TEXT_COLOR;
public static readonly int EnableMarkup = NDalic.TEXT_VISUAL_ENABLE_MARKUP;
}
- public struct NpatchImageVisualProperty
+
+ /// <summary>
+ /// This specifies properties of NpatchImageVisual.
+ /// </summary>
+ public struct NpatchImageVisualProperty
{
public static readonly int URL = NDalic.IMAGE_VISUAL_URL;
public static readonly int FittingMode = NDalic.IMAGE_VISUAL_FITTING_MODE;
/// <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.
- ///
+ /// processing of the wheel rolling and passing to other libraries like Toolkit.<br>
+ /// <br>
/// 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.
+ /// supplied to check if they have been pressed when the wheel is being rolled.<br>
+ /// <br>
+ /// 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.<br>
+ /// The mouse wheel event can be sent to the specific actor but the custom wheel event will be sent to the stage.<br>
/// </summary>
public class Wheel : global::System.IDisposable
{
/// <summary>
- /// The window class is used internally for drawing.
- /// A Window has an orientation and indicator properties.
+ /// The window class is used internally for drawing.<br>
+ /// A Window has an orientation and indicator properties.<br>
/// </summary>
public class Window : BaseHandle
{
DisposeQueue.Instance.Add(this);
}
+ /// <summary>
+ /// To make Window instance be disposed.
+ /// </summary>
public override void Dispose()
{
if (!Stage.IsInstalled())
}
}
-
+ /// <summary>
+ /// Sets the focus acceptable flag of an window as true.
+ /// </summary>
public void SetAcceptFocus(bool accept)
{
NDalicPINVOKE.SetAcceptFocus(swigCPtr, accept);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrieves whether the window is focus acceptable or not.
+ /// </summary>
public bool IsFocusAcceptable()
{
return NDalicPINVOKE.IsFocusAcceptable(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Shows the window if it is hidden.
+ /// </summary>
public void Show()
{
NDalicPINVOKE.Show(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Hides the window if it is showing.
+ /// </summary>
public void Hide()
{
NDalicPINVOKE.Hide(swigCPtr);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
+ /// <summary>
+ /// Retrieves whether the window is visible or not.
+ /// </summary>
public void IsVisible()
{
NDalicPINVOKE.IsVisible(swigCPtr);
}
/// <summary>
- /// This sets the orientation of indicator bar.
- /// It does not implicitly show the indicator if it is currently hidden.
+ /// This sets the orientation of indicator bar.<br>
+ /// It does not implicitly show the indicator if it is currently hidden.<br>
/// </summary>
/// <param name="orientation">The orientation</param>
internal void RotateIndicator(Window.WindowOrientation orientation)
projects / platform / core / csapi / tizenfx.git / commitdiff