}
/// <summary>
- /// Retrieve the position of the Actor.<br>
+ /// Retrieves 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.<br>
+ /// Retrieves the size of the Actor.<br>
/// The coordinates are relative to the Actor's parent.<br>
/// </summary>
public Size CurrentSize
}
/// <summary>
- /// 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>
+ /// Determines whether the anchor point should be used to determine the position of the actor.
+ /// This is true by default.
/// </summary>
+ /// <remarks>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.
+ /// </remarks>
protected bool PositionUsesAnchorPoint
{
get
}
/// <summary>
- /// 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>
+ /// Sets the sibling order of the actor so depth position can be defined within the same parent.
/// </summary>
+ /// <remarks>
+ /// 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.
+ /// </remarks>
public int SiblingOrder
{
get
}
/// <summary>
- /// Sets the size of an actor for Width and Height.<br>
+ /// 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>
+ /// The actors default depth is the minimum of width & height.<br>
/// </summary>
public Size2D Size2D
{
}
/// <summary>
- /// 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>
+ /// Shows the Actor.
/// </summary>
+ /// <remarks>
+ /// This is an asynchronous method.
+ /// </remarks>
public void Show()
{
SetVisible(true);
}
/// <summary>
- /// Sets the visibility flag of an actor as false to be hidden.
+ /// Hides the Actor.
/// </summary>
+ /// <remarks>
+ /// This is an asynchronous method.
+ /// If an actor is hidden, then the actor and its children will not be rendered.
+ /// This is regardless of the individual visibility of the children i.e.an actor will only be rendered if all of its parents are shown.
+ /// </remarks>
public void Hide()
{
SetVisible(false);
}
/// <summary>
- /// 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>
+ /// Raise actor above the next highest level of actor(s).
/// </summary>
+ /// <remarks>
+ /// 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.
+ /// </remarks>
public void Raise()
{
NDalicPINVOKE.Raise(swigCPtr);
}
/// <summary>
- /// 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>
+ /// Lower the actor to underneath the level below actor(s).
/// </summary>
+ /// <remarks>
+ /// 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.
+ /// </remarks>
public void Lower()
{
NDalicPINVOKE.Lower(swigCPtr);
}
/// <summary>
- /// 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>
+ /// Raise actor above all other actors.
/// </summary>
+ /// <remarks>
+ /// 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.
+ /// </remarks>
public void RaiseToTop()
{
NDalicPINVOKE.RaiseToTop(swigCPtr);
}
/// <summary>
- /// 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>
+ /// Lower actor to the bottom of all actors.
/// </summary>
+ /// <remarks>
+ /// 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.
+ /// </remarks>
public void LowerToBottom()
{
NDalicPINVOKE.LowerToBottom(swigCPtr);
}
/// <summary>
- /// 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>
+ /// Raise the actor to above the target actor.
/// </summary>
+ /// <remarks>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.
+ /// </remarks>
/// <param name="target">Will be raised above this actor</param>
public void RaiseAbove(Actor target)
{
}
/// <summary>
- /// 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>
+ /// Lower the actor to below the target actor.
/// </summary>
+ /// <remarks>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.
+ /// </remarks>
/// <param name="target">Will be lowered below this actor</param>
public void LowerBelow(Actor target)
{
/// 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>
+ /// <returns>handle to an Actor object or an uninitialized handle</returns>
public new static Actor DownCast(BaseHandle handle)
{
Actor ret = new Actor(NDalicPINVOKE.Actor_DownCast(BaseHandle.getCPtr(handle)), true);
}
/// <summary>
- /// 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>
+ /// Adds a child Actor to this Actor.
/// </summary>
+ /// <pre>This Actor(the parent) has been initialized. The child actor has been initialized. The child actor is not the same as the parent actor.</pre>
+ /// <post>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.</post>
+ /// <remarks>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.</remarks>
/// <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.<br>
- /// Precondition : This Actor(the parent) has been initialized. The child actor is not the same as the parent actor.<br>
+ /// Removes a child Actor from this Actor. If the actor was not a child of this actor, this is a no-op.
/// </summary>
+ /// <pre>This Actor(the parent) has been initialized. The child actor is not the same as the parent actor.</pre>
/// <param name="child">The child</param>
public void Remove(Actor child)
{
}
/// <summary>
- /// Retrieves the number of children held by the actor.<br>
- /// Precondition : The Actor has been initialized.<br>
+ /// Retrieves the number of children held by the actor.
/// </summary>
+ /// <pre>The Actor has been initialized.</pre>
/// <returns>The number of children</returns>
public uint GetChildCount()
{
}
/// <summary>
- /// Retrieve and child actor by index.<br>
- /// Precondition : The Actor has been initialized.<br>
+ /// Retrieves child actor by index.
/// </summary>
+ /// <pre>The Actor has been initialized.</pre>
/// <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>
public Actor GetChildAt(uint index)
}
/// <summary>
- /// 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>
+ /// Search through this actor's hierarchy for an actor with the given name.
+ /// The actor itself is also considered in the search.
/// </summary>
+ /// <pre>The Actor has been initialized.</pre>
/// <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>
public Actor FindChildByName(string actorName)
}
/// <summary>
- /// 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>
+ /// Converts screen coordinates into the actor's coordinate system using the default camera.
/// </summary>
+ /// <pre>The Actor has been initialized.</pre>
+ /// <remarks>The actor coordinates are relative to the top-left(0.0, 0.0, 0.5)</remarks>
/// <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>
/// <param name="screenX">The screen X-coordinate</param>
/// <summary>
/// Sets the relative to parent size factor of the actor.<br>
- /// This factor is only used when ResizePolicy is set to either.<br>
+ /// This factor is only used when ResizePolicy is set to either:
+ /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<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>
+ /// <pre>The Actor has been initialized.</pre>
/// <param name="factor">A Vector3 representing the relative factor to be applied to each axis</param>
public void SetSizeModeFactor(Vector3 factor)
{
/// 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>
+ /// <returns>The height based on the width</returns>
public float GetHeightForWidth(float width)
{
float ret = NDalicPINVOKE.Actor_GetHeightForWidth(swigCPtr, width);
/// 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>
+ /// <returns>The width based on the height</returns>
public float GetWidthForHeight(float height)
{
float ret = NDalicPINVOKE.Actor_GetWidthForHeight(swigCPtr, height);
/// <summary>
/// Sets the padding for use in layout.<br>
/// </summary>
- /// <param name="padding">padding Padding for the actor</param>
+ /// <param name="padding">Padding for the actor</param>
public void SetPadding(PaddingType padding)
{
NDalicPINVOKE.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
/// <summary>
/// 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>
+ /// 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>
+ /// <pre>The Actor has been initialized.</pre>
public Position ParentOrigin
{
get
/// <summary>
/// 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>
+ /// 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.
+ /// <pre>The Actor has been initialized.</pre>
/// </summary>
public Position AnchorPoint
{
/// <summary>
/// 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>
+ /// <remarks>This is an asynchronous method.</remarks>
public Rotation Orientation
{
get
/// <summary>
/// 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.<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>
+ /// Retrieves the visibility flag of an actor.
/// </summary>
+ /// <remarks>
+ /// 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.
+ /// </remarks>
public bool Visible
{
get
}
/// <summary>
- /// Gets/Sets the width resize policy to be used for the given dimension(s).
+ /// Gets/Sets the width resize policy to be used.
/// </summary>
public ResizePolicyType WidthResizePolicy
{
}
/// <summary>
- /// Gets/Sets the height resize policy to be used for the given dimension(s).
+ /// Gets/Sets the height resize policy to be used.
/// </summary>
public ResizePolicyType HeightResizePolicy
{
}
/// <summary>
- /// 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>
+ /// This specifies whether the Actor uses its own color, or inherits.
/// </summary>
public enum ColorMode
{
+ /// <summary>
+ /// Actor will use its own color.
+ /// </summary>
UseOwnColor,
+ /// <summary>
+ /// Actor will use its parent color.
+ /// </summary>
UseParentColor,
+ /// <summary>
+ /// Actor will blend its color with its parents color.
+ /// </summary>
UseOwnMultiplyParentColor,
+ /// <summary>
+ /// 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.
+ /// </summary>
UseOwnMultiplyParentAlpha
}
/// </summary>
public enum DimensionType
{
+ /// <summary>
+ /// Width dimension
+ /// </summary>
Width = 0x1,
+ /// <summary>
+ /// Height dimension
+ /// </summary>
Height = 0x2,
+ /// <summary>
+ /// Mask to cover all flags
+ /// </summary>
AllDimensions = 0x3
}
/// <summary>
- /// This specifies draw mode types
+ /// Enumeration for the instance of how the actor and it's children will be drawn.
/// </summary>
public enum DrawModeType
{
+ /// <summary>
+ /// The default draw-mode
+ /// </summary>
Normal = 0,
+ /// <summary>
+ /// Draw the actor and its children as an overlay
+ /// </summary>
Overlay2D = 1,
+ /// <summary>
+ /// Will be replaced by separate ClippingMode enum. Draw the actor and its children into the stencil buffer
+ /// </summary>
Stencil = 3
}
/// <summary>
- /// This specifies resize policy types
+ /// Enumeration for size negotiation resize policies.
/// </summary>
public enum ResizePolicyType
{
+ /// <summary>
+ /// Size is fixed as set by SetSize
+ /// </summary>
Fixed,
+ /// <summary>
+ /// Size is to use the actor's natural size
+ /// </summary>
+ /// <see cref="Actor.GetNaturalSize"/>
UseNaturalSize,
+ /// <summary>
+ /// Size is to fill up to the actor's parent's bounds. Aspect ratio is not maintained.
+ /// </summary>
FillToParent,
+ /// <summary>
+ /// The actors size will be ( ParentSize * SizeRelativeToParentFactor ).
+ /// </summary>
SizeRelativeToParent,
+ /// <summary>
+ /// The actors size will be ( ParentSize + SizeRelativeToParentFactor ).
+ /// </summary>
SizeFixedOffsetFromParent,
+ /// <summary>
+ /// Size will adjust to wrap around all children
+ /// </summary>
FitToChildren,
+ /// <summary>
+ /// One dimension is dependent on the other
+ /// </summary>
DimensionDependency,
+ /// <summary>
+ /// The size will be assigned to the actor
+ /// </summary>
UseAssignedSize
}
/// <summary>
- /// This specifies size scale policy types
+ /// Enumeration for policies to determine how an actor should resize itself when having its size set in size negotiation.
/// </summary>
public enum SizeScalePolicyType
{
+ /// <summary>
+ /// Use the size that was set
+ /// </summary>
UseSizeSet,
+ /// <summary>
+ /// Fit within the size set maintaining natural size aspect ratio
+ /// </summary>
FitWithAspectRatio,
- FillWithAspectRatio
+ /// <summary>
+ /// Fit within the size set maintaining natural size aspect ratio
+ /// </summary>
+ FillWithAspectRatiox
}
/// <summary>
- /// This specifies clipping mode types
+ /// Enumeration for ClippingMode describing how this Actor's children will be clipped against it.
/// </summary>
public enum ClippingModeType
{
+ /// <summary>
+ /// This Actor will not clip its children.
+ /// </summary>
Disabled,
+ /// <summary>
+ /// This Actor will clip all children to within its boundaries (the actor will also be visible itself).
+ /// </summary>
ClipChildren
}
/// 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>
+ /// The overall animation time is superseded by the values given in the animation time 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
/// 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>
+ /// <remarks>DurationmSeconds must be greater than zero.</remarks>
+ /// <param name="durationMilliSeconds">The duration in milli seconds.</param>
public Animation(int durationMilliSeconds) : this(NDalicPINVOKE.Animation_New((float)durationMilliSeconds / 1000.0f), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
/// <summary>
- /// Gets/Sets the duration of animation.
+ /// Gets/Sets the duration in milli seconds of the animation.
/// </summary>
public int Duration
{
}
/// <summary>
- /// Gets/Sets the default alpha function for an animation.
+ /// Gets/Sets the default alpha function for the animation.
/// </summary>
public AlphaFunction DefaultAlphaFunction
{
/// <summary>
/// Gets the current loop count.<br>
- /// A value 0 to CurrentLoop indicating the current loop count when looping.<br>
+ /// A value 0 indicating the current loop count when looping.<br>
/// </summary>
public int CurrentLoop
{
/// <summary>
/// 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.<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.<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.<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>
/// <param name="alphaFunction">The alpha function to apply</param>
/// <param name="startTime">Start time of animation</param>
/// <param name="endTime">End time of animation</param>
- /// <param name="alphaFunction"></param>
+ /// <param name="alphaFunction">The alpha function to apply</param>
public void AnimateTo(Actor target, string property, object destinationValue, int startTime, int endTime, AlphaFunction alphaFunction = null)
{
string _str1 = property.Substring(0, 1);
/// <param name="target">The target object to animate</param>
/// <param name="property">The target property to animate</param>
/// <param name="keyFrames">The set of time/value pairs between which to animate</param>
- /// <param name="startTime">Start time of animation</param>
- /// <param name="endTime">End time of animation</param>
+ /// <param name="startTime">Start time of animation in milli seconds</param>
+ /// <param name="endTime">End time of animation in milli seconds</param>
/// <param name="interpolation">The method used to interpolate between values</param>
/// <param name="alphaFunction">The alpha function to apply</param>
public void AnimateBetween(Actor target, string property, KeyFrames keyFrames, int startTime, int endTime, Interpolation interpolation = Interpolation.Linear, AlphaFunction alphaFunction = null)
}
/// <summary>
- /// Play the animation.
+ /// Plays the animation.
/// </summary>
public void Play()
{
}
/// <summary>
- /// 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>
+ /// Enumeration for what to do when the animation ends, is stopped, or is destroyed.
/// </summary>
public enum EndActions
{
+ /// <summary>
+ /// When the animation ends, the animated property values are saved.
+ /// </summary>
Cancel,
+ /// <summary>
+ /// When the animation ends, the animated property values are forgotten.
+ /// </summary>
Discard,
+ /// <summary>
+ /// If the animation is stopped, the animated property values are saved as if the animation had run to completion, otherwise behaves like Cancel.
+ /// </summary>
StopFinal
}
/// <summary>
- /// 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>
+ /// Enumeration for what interpolation method to use on key-frame animations.
/// </summary>
public enum Interpolation
{
+ /// <summary>
+ /// Values in between key frames are interpolated using a linear polynomial. (Default)
+ /// </summary>
Linear,
+ /// <summary>
+ /// Values in between key frames are interpolated using a cubic polynomial.
+ /// </summary>
Cubic
}
/// <summary>
- /// 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>
+ /// Enumeration for what state the animation is in.
/// </summary>
+ /// <remarks>Calling Reset() on this class will NOT reset the animation. It will call BaseHandle.Reset() which drops the object handle.</remarks>
public enum States
{
+ /// <summary>
+ /// Animation has stopped
+ /// </summary>
Stopped,
+ /// <summary>
+ /// The animation is playing
+ /// </summary>
Playing,
+ /// <summary>
+ /// The animation is paused
+ /// </summary>
Paused
}
projects / platform / core / csapi / tizenfx.git / commitdiff