A timer helps to manage animation rendering by automatically indicating the passage of a small unit of time, called a tick. In turn, ticks can trigger animation rendering or other animation events. Each animation timer provides timing for a single animation manager.

The timing system is designed to provide the necessary timing services needed to support animations and does not require applications to play an explicit role in generating the ticks. The animation timer can be set up to automatically update the animation manager for each tick without application-side handling.

An application may not need to use a timer with Windows Animation, depending on the graphics platform it is using. For example, an application drawing with Direct2D or Direct3D can synchronize to monitor's refresh rate, yielding very smooth animation. However, such applications may still find the interface useful for its GetTime method, which returns an accurate system time in UI_ANIMATION_SECONDS, the units used throughout the Windows Animation API.

The timer update handler receives time updates (ticks) from the timer. The timer indicates an update by calling the method on the specified handler.

Passing null for the updateHandler parameter causes Windows Animation to release its reference to any handler object you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Timing events include the OnPreUpdate, OnPostUpdate, and OnRenderingTooSlow methods of the interface.

Passing null for the handler parameter causes Windows Animation to release its reference to any handler object you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

This method can be used in both the application-driven and timer-driven configurations to retrieve the system time in UI_ANIMATION_SECONDS, the units used throughout the Windows Animation API.

If the rendering frame rate for an animation falls below the specified frame rate, an event is raised.

This method can be used in both the application-driven and timer-driven configurations to retrieve the system time in UI_ANIMATION_SECONDS, the units used throughout the Windows Animation API.

If the rendering frame rate for an animation falls below the specified frame rate, an event is raised.

is one of the primary interfaces used to add animation to an application, along with the and interfaces.

UIAnimationTransitionLibrary implements a library of standard transitions.

This method should not be called after the transition has been added to a storyboard.

This method should not be called after the transition has been added to a storyboard.

This method should not be called when the storyboard to which the transition has been added is scheduled or playing.

An application should typically call the method before calling this method. This method should not be called when the storyboard to which the transition has been added is scheduled or playing.

This method should not be called after the transition has been added to a storyboard.

This method should not be called after the transition has been added to a storyboard.

An application should typically call the method before calling this method. This method should not be called when the storyboard to which the transition has been added is scheduled or playing.

Windows Animation includes a library of common transitions that developers can apply to variables through a storyboard. The parameters for specifying a transition depend on the type of transition. For some transitions, the duration of the transition is an explicit parameter; for others, the duration is determined by other parameters, such as speed or acceleration when the transition begins. A transition's initial value or velocity can be overridden if a discontinuous jump is desired, and duration can be queried after the transition is added to a storyboard.

If an application requires an effect that cannot be specified using the transition library, developers can implement custom transitions. A custom transition is created by first implementing the interpolator function for the transition, and then by using a factory object to generate transitions from interpolators. An interpolator must implement the interface; an implementation of the transition factory object is provided by UIAnimationTransitionFactory.

During an instantaneous transition, the value of the animation variable changes instantly from its current value to a specified final value. The duration of this transition is always zero.

The figure below shows the effect on an animation variable over time during an instantaneous transition.

During a constant transition, the value of an animation variable remains at the initial value over the duration of the transition.

The figure below shows the effect on an animation variable over time during a constant-duration transition.

During a discrete transition, the animation variable remains at the initial value for a specified delay time, then switches instantaneously to a specified final value and remains at that value for a given hold time.

The figure below shows the effect on an animation variable over time during a discrete transition.

During a linear transition, the value of the animation variable transitions linearly from its initial value to a specified final value.

The figure below shows the effect on an animation variable over time during a linear transition.

During a linear-speed transition, the value of the animation variable changes at a specified rate. The duration of the transition is determined by the difference between the initial value and the specified final value.

The figure below shows the effect on an animation variable over time during a linear-speed transition.

The value of the animation variable oscillates around the initial value over the entire duration of a sinusoidal-range transition. The amplitude of the oscillation is determined by the velocity when the transition begins.

The figure below shows the effect on an animation variable over time during a sinusoidal-velocity transition.

The value of the animation variable fluctuates between the specified minimum and maximum values over the entire duration of a sinusodial-range transition. The slope parameter is used to disambiguate between the two possible sine waves specified by the other parameters.

The figure below shows the effect on an animation variable over time during a sinusoidal-range transition. Passing in the enumeration value yields a wave like the solid curve shown in the figure, whereas the value yields a wave like the dashed curve.

During an accelerate-decelerate transition, the animation variable speeds up and then slows down over the duration of the transition, ending at a specified value. You can control how quickly the variable accelerates and decelerates independently, by specifying different acceleration and deceleration ratios.

When the initial velocity is zero, the acceleration ratio is the fraction of the duration that the variable will spend accelerating; likewise with the deceleration ratio. If the initial velocity is nonzero, it is the fraction of the time between the velocity reaching zero and the end of transition. The acceleration ratio and the deceleration ratio should sum to a maximum of 1.0.

The figures below show the effect on animation variables with different initial velocities during accelerate-decelerate transitions.

Note??d' in the above figure on the right shows the time between the velocity reaching zero and the end of the transition.

A reversal transition smoothly changes direction over the specified duration. The final value will be the same as the initial value and the final velocity will be the negative of the initial velocity. The figure below shows such a reversal transition.

During a cubic transition, the value of the animation variable changes from its initial value to a specified final value over the duration of the transition, ending at a specified velocity.

The figure below shows the effect on an animation variable over time during a cubic transition.

A smooth-stop transition slows down as it approaches the specified final value, and reaches it with a velocity of zero. The duration of the transition is determined by the initial velocity, the difference between the initial and final values, and the specified maximum duration. If there is no solution consisting of a single parabolic arc, this method creates a cubic transition.

The figure below shows the effect on an animation variable over time during a smooth-stop transition.

During a parabolic-acceleration transition, the value of the animation variable changes from the initial value to the final value ending at the specified velocity. You can control how quickly the variable reaches the final value by specifying the rate of acceleration.

The figure below shows the effect on an animation variable over time during a parabolic-acceleration transition.

A single animation variable can be included in multiple storyboards, but multiple storyboards cannot animate the same variable at the same time. If a newly scheduled storyboard attempts to animate one or more variables that are currently scheduled for animation by different storyboards, a scheduling conflict occurs. To determine which storyboard has priority, the animation manager can call HasPriority on one or more priority comparison handlers provided by the application.

Multiple values can be combined using a bitwise-OR operation.

This enumeration is used as the priorityEffect parameter of , informing the client of the potential effect on the storyboard to be scheduled when the return value is false (S_FALSE). means that the attempt to schedule the storyboard might fail if the return value is false. means that the attempt to schedule the storyboard will succeed, but if the return value is false, the storyboard could play later than it would otherwise.

This enumeration can help an application decide how aggressive to be about reducing latency in the UI. For example, if the application returns true when the effect is , then other animations might get canceled or compressed even though doing so was not strictly necessary to play a new animation within the application-specified longest acceptable delay.

returns only if the application attempts to schedule a storyboard during a callback to .

Unless is called from a handler for OnStoryboardStatusChanged events, it returns only the following status values:

All status values can be passed to .

The following diagram illustrates the transitions between these states.

Client applications can use the transitions provided in or in a library provided by a third party; however, if you need custom behavior, you can create your own transitions by implementing the interface.

Before Windows Animation can use your custom interpolator, you must wrap it in an object that implements by calling the method and passing in the custom interpolator. After the interpolator is wrapped, client applications interact with your interpolator using the interface.

Custom interpolators can be reused across applications, but it is recommended that they be exposed using factory interfaces that return interfaces.

Windows Animation always calls SetInitialValueAndVelocity before calling the other methods of at different offsets. However, it can be called multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to these methods reflect the updated state.

Windows Animation calls this method only after calling the GetDependencies method, and only if that call returns as one of its durationDependencies flags.

Typically, an interpolator with a duration dependency will have a duration parameter in its associated creation method of . The interpolator should store its duration when first initialized and overwrite it when SetDuration is called.

Windows Animation always calls the SetInitialValueAndVelocity method to set the initial value and velocity before calling SetDuration, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity and SetDuration multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to SetDuration reflect the updated state.

Windows Animation always calls the SetInitialValueAndVelocity method to set the initial value and velocity before calling GetDuration, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to GetDuration reflect the updated state.

Windows Animation always calls the SetInitialValueAndVelocity method to set the initial value and velocity before calling GetFinalValue, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to GetFinalValue reflect the updated state.

Windows Animation always calls the SetInitialValueAndVelocity method to set the initial value and velocity before calling InterpolateValue, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to InterpolateValue reflect the updated state.

Windows Animation always calls the SetInitialValueAndVelocity method to set the initial value and velocity before calling InterpolateVelocity, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to InterpolateVelocity reflect the updated state.

This method is called to identify which aspects of the custom interpolator are affected by certain inputs: value, velocity, and duration. For each of these inputs, the interpolator returns either of the following:

• The bitwise-OR of any members of that apply.
• if nothing depends on the input.

For example, consider an interpolator (1) that accepts a final value as a parameter, (2) that always comes to a gradual stop at that final value, and (3) whose duration is determined by the difference between the final and initial values. The interpolator should return |UI_ANIMATION_DURATION for initialValueDependencies. It should not return because this is set when the interpolator is created and is not affected by the initial value. Likewise it should not return because the slope of the curve is defined to always be zero when it reaches the final value.

It is important that an interpolator return correct set of flags. If a flag is not present for an output, Windows Animation assumes that the corresponding parameter does not affect that aspect of the interpolator's results. For example, if the custom interpolator does not include for initialVelocityDependencies, Windows Animation may call SetInitialValueAndVelocity with an arbitrary velocity parameter, then call GetFinalValue to determine the final value. The interpolator's implementation of GetFinalValue must return the same result no matter what velocity parameter has been passed to SetInitialValueAndVelocity because the interpolator has claimed that the transition's final value does not depend on the initial velocity.

Note??If the flags returned for durationDependencies do not include , SetDuration will never be called on the interpolator.

Windows Animation always calls the SetInitialValueAndVelocity method to set the initial value and velocity before calling GetDuration, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to GetDuration reflect the updated state.

Windows Animation always calls the SetInitialValueAndVelocity method to set the initial value and velocity before calling GetFinalValue, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to GetFinalValue reflect the updated state.

Client applications can use the transitions provided in the or interfaces, or in a library provided by a third party; however, custom transitions can be created by implementing the or interfaces.

Before Windows Animation can use your custom interpolator, you must wrap it in an object that implements the interface (by calling ) or the interface (by calling ) and passing in the custom interpolator. After the interpolator wrapper has been created, client applications interact with your interpolator using the or interfaces.

Custom interpolators can be reused across applications, but it is recommended that they be exposed using factory interfaces that return an interface or an interface.

Windows Animation always calls SetInitialValueAndVelocity before calling the other methods of at different offsets. However, SetInitialValueAndVelocity can be called multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to these methods reflect the updated state.

Windows Animation calls this method only after calling the method, and only if that call returns as one of its durationDependencies flags.

Typically, an interpolator with a duration dependency has a duration parameter in the or creation method that is associated with that interpolator. The interpolator should store its duration when first initialized and overwrite the duration when SetDuration is called.

Windows Animation always calls the method to set the initial value and velocity before calling SetDuration, so a custom interpolator doesn't need to check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity and SetDuration multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to SetDuration reflect the updated state.

Windows Animation always calls the method to set the initial value and velocity before calling GetDuration, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to GetDuration reflect the updated state.

Windows Animation always calls the method to set the initial value and velocity before calling GetFinalValue, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to GetFinalValue reflect the updated state.

Windows Animation always calls the method to set the initial value and velocity before calling InterpolateValue, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to InterpolateValue reflect the updated state.

Windows Animation always calls the method to set the initial value and velocity before calling InterpolateVelocity, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to InterpolateVelocity reflect the updated state.

This method is called to identify which aspects of the custom interpolator are affected by certain inputs: value, velocity, and duration. For each of these inputs, the interpolator returns either of the following:

• The bitwise-OR of any members of that apply.
• if nothing depends on the input.

For example, consider an interpolator that:

• Accepts a final value as a parameter.
• Always comes to a gradual stop at that final value.
• Has a duration determined by the difference between the final value and the initial value.

In this case the interpolator should return |UI_ANIMATION_DURATION for the initialValueDependencies parameter. It should not return , because this value is set when the interpolator is created and is not affected by the initial value. Likewise, the interpolator should not return , because the slope of the curve is defined to always be zero when it reaches the final value.

It is important that an interpolator return a correct set of flags. If a flag is not present for an output, Windows Animation assumes that the corresponding parameter does not affect that aspect of the interpolator's results. For example, if the custom interpolator does not include for initialVelocityDependencies, Windows Animation may call SetInitialValueAndVelocity with an arbitrary velocity parameter, and then call GetFinalValue to determine the final value. The interpolator's implementation of GetFinalValue must return the same result no matter which velocity parameter has been passed to SetInitialValueAndVelocity, because the interpolator has claimed that the transition's final value does not depend on the initial velocity.

Note??If the flags returned for durationDependencies do not include , SetDuration will never be called on the interpolator.

Windows Animation always calls the method to set the initial value and velocity before calling GetDuration, so a custom interpolator need not check whether the initial value and velocity have been set.

Windows Animation can call SetInitialValueAndVelocity multiple times with different parameters. Interpolators can cache internal state to improve performance, but they must update this cached state each time SetInitialValueAndVelocity is called and ensure that the results of subsequent calls to GetDuration reflect the updated state.

defines a central control object for animations. A single instance of is typically used to compose, schedule, and manage all animations for a client application.

, , and are the primary components for building animations. Use to create and manage these components.

The initial value of an animation variable is specified when the variable is created. After an animation variable is created, its value cannot be changed directly; it must be updated through the animation manager.

An animation variable is typically created to represent each visual characteristic that is to be animated. For example, an application might create two animation variables for the X and Y coordinates of an object that can move freely within a window.

This method schedules a new storyboard by creating the storyboard, applying the specified transition to the specified variable, and then scheduling the storyboard.

Storyboards can specify complex coordinated updates to many animation variables. These updates happen in sequence or in parallel, and they are guaranteed to remain synchronized within the storyboard. A storyboard is created, populated with transitions on animation variables, and then scheduled.

Calling FinishAllStoryboards ensures that all active storyboards finish within the specified completion deadline. If a storyboard is scheduled to play past the deadline, it is compressed. A storyboard is considered active if its status is or .

Calling this method is equivalent to calling the method for each active storyboard. A storyboard is considered active if its status is or .

Calling this method advances the animation manager to timeNow, changing statuses of storyboards as necessary and updating any animation variables to appropriate interpolated values. If the animation manager is paused, no storyboards or variables are updated. If the animation mode is , all scheduled storyboards finish playing immediately. If the values of any variables change during this call, the value of updateResult is ; otherwise, it is .

A tag is a pairing of an integer identifier (id) with a COM object (object). An application can use tags to identify animation variables and storyboards. null is a valid object component of a tag; therefore, the object parameter can be null.

Tags are not necessarily unique; this method returns UI_E_AMBIGUOUS_MATCH if more than one animation variable exists with the specified tag.

A tag is a pairing of an integer identifier (id) with a COM object (object). An application can use tags to identify animation variables and storyboards. null is a valid object component of a tag; therefore, the object parameter can be null.

Tags are not necessarily unique; this method returns UI_E_AMBIGUOUS_MATCH if more than one storyboard exists with the specified tag.

This method is used to enable or disable animation globally. While animation is disabled, all storyboards finish immediately when they are scheduled. The default mode is , which lets Windows decide when to enable or disable animation in the application.

When an animation manager is paused, its status is set to .

When an animation manager is resumed, and at least one animation is currently scheduled or playing, its status is set to .

Passing null for the handler parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by canceling storyboards.

A scheduled storyboard can be canceled only if it has not started playing and the priority comparison object registered with this method returns . Canceled storyboards are completely removed from the schedule.

Passing null for the comparison parameter causes Windows Animation to release its reference to any priority comparison handler object you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by trimming the scheduled storyboard.

A scheduled storyboard can be trimmed only if the priority comparison object registered with this method returns . If the new storyboard trims the scheduled storyboard, the scheduled storyboard can no longer affect a variable once the new storyboard begins to animate that variable.

Passing null for the comparison parameter causes Windows Animation to release its reference to any handler object you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when the scheduling conflicts can be resolved by compressing the scheduled storyboard and any other storyboards animating the same variables.

A storyboard can be compressed only if the priority comparison object registered with this method returns for all the other scheduled storyboards that will be affected by compression. When the storyboards are compressed, time is temporarily accelerated for affected storyboards, so they play faster.

Passing null for the comparison parameter causes Windows Animation to release its reference to any handler object you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by concluding the scheduled storyboard.

A scheduled storyboard can be concluded only if it contains a loop with a repetition count of UI_ANIMATION_REPEAT_INDEFINITELY and the priority comparison object registered with this method returns . If the storyboard is concluded, the current repetition of the loop completes, and the reminder of the storyboard then plays.

Passing null for the comparison parameter causes Windows Animation to release its reference to any handler object you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

For a storyboard to be successfully scheduled, it must begin before the longest acceptable delay has elapsed. This delay is determined in the following order: the delay value set by calling for this specific storyboard, the delay value set by calling this method, or 0.0 if neither method has been called.

Calling this method directs the animation manager, and all the objects it created, to release all their references to other objects. After has been called, no other methods may be called on the animation manager or any objects that it created. An application can call this method to clean up if there is any possibility that the application has introduced a reference cycle that includes some animation objects.

This method is used to enable or disable animation globally. While animation is disabled, all storyboards finish immediately when they are scheduled. The default mode is , which lets Windows decide when to enable or disable animation in the application.

For a storyboard to be successfully scheduled, it must begin before the longest acceptable delay has elapsed. This delay is determined in the following order: the delay value set by calling for this specific storyboard, the delay value set by calling this method, or 0.0 if neither method has been called.

The initial value of an animation variable is specified when the variable is created. After an animation variable is created, its value cannot be changed directly; it must be updated through the animation manager.

An animation variable is typically created to represent each visual characteristic that is to be animated. For example, an application might create three animation variables for the X, Y, and Z coordinates of an object that can move freely within a a three-dimensional space.

The initial value of an animation variable is specified when the variable is created. After an animation variable is created, its value cannot be changed directly; it must be updated through the animation manager.

An animation variable is typically created to represent each visual characteristic that is to be animated. For example, an application might create two animation variables for the X and Y coordinates of an object that can move freely within a window.

This method schedules a new storyboard by creating the storyboard, applying the specified transition to the specified variable, and then scheduling the storyboard.

Calling the FinishAllStoryboards method ensures that all active storyboards finish within the specified completion deadline. If a storyboard is scheduled to play past the deadline, it is compressed.

A storyboard is considered active if a call to the method returns or .

Calling this method is equivalent to calling the method for each active storyboard.

A storyboard is considered active if a call to the method returns or .

Calling this method advances the animation manager to timeNow, changes the status of all storyboards as necessary, and updates any animation variables to appropriate interpolated values. If the animation manager is paused, no storyboards or variables are updated. If the animation mode is , all scheduled storyboards finish playing immediately. If the values of any variables change during this call, the value of updateResult is ; otherwise, it is .

A tag is a pairing of an integer identifier (id) with a COM object (object). An application can use tags to identify animation variables and storyboards. null is a valid object component of a tag; therefore, the object parameter can be null.

Tags are not necessarily unique; this method returns UI_E_AMBIGUOUS_MATCH if more than one animation variable exists with the specified tag.

A tag is a pairing of an integer identifier (id) with a COM object (object). An application can use tags to identify animation variables and storyboards. null is a valid object component of a tag; therefore, the object parameter can be null.

Tags are not necessarily unique; this method returns UI_E_AMBIGUOUS_MATCH if more than one storyboard exists with the specified tag.

Use this method to enable or disable animation globally. While animation is disabled, all storyboards finish immediately when they are scheduled. The default mode is , which lets Windows decide when to enable or disable animation in the application.

When an animation manager is paused, its status is set to .

When an animation manager is resumed, and at least one animation is currently scheduled or playing, its status is set to .

Passing null for the handler parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by canceling storyboards.

A scheduled storyboard can be canceled only if it hasn't started playing and the priority comparison object registered with this method returns . Canceled storyboards are completely removed from the schedule.

Passing null for the comparison parameter causes Windows Animation to release its reference to any priority comparison handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by trimming the scheduled storyboard.

A scheduled storyboard can be trimmed only if the priority comparison object registered with this method returns . If the new storyboard trims the scheduled storyboard, the scheduled storyboard can no longer affect a variable after the new storyboard begins to animate that variable.

Passing null for the comparison parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by compressing the scheduled storyboard and any other storyboards animating the same variables.

A storyboard can be compressed only if the priority comparison object registered with this method returns for all the other scheduled storyboards that will be affected by compression. When the storyboards are compressed, time is temporarily accelerated for affected storyboards, so they play faster.

Passing null for the comparison parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by concluding the scheduled storyboard.

A scheduled storyboard can be concluded only if it contains a loop with a repetition count of UI_ANIMATION_REPEAT_INDEFINITELY and the priority comparison object registered with this method returns . If the storyboard is concluded, the current repetition of the loop completes, and the rest of the storyboard then plays.

Passing null for the comparison parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

For Windows Animation to schedule a storyboard successfully, the storyboard must begin before the longest acceptable delay has elapsed. Windows Animation determines this delay in the following order: the delay value set by calling for this specific storyboard, the delay value set by calling this method, or 0.0 if neither method has been called.

Calling this method directs the animation manager, and all the objects it created, to release all their references to other objects. After has been called, no other methods may be called on the animation manager or on any objects that it created. An application can call this method to clean up if there is any possibility that the application has introduced a reference cycle that includes some animation objects.

Use this method to enable or disable animation globally. While animation is disabled, all storyboards finish immediately when they are scheduled. The default mode is , which lets Windows decide when to enable or disable animation in the application.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by canceling storyboards.

A scheduled storyboard can be canceled only if it hasn't started playing and the priority comparison object registered with this method returns . Canceled storyboards are completely removed from the schedule.

Passing null for the comparison parameter causes Windows Animation to release its reference to any priority comparison handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by trimming the scheduled storyboard.

A scheduled storyboard can be trimmed only if the priority comparison object registered with this method returns . If the new storyboard trims the scheduled storyboard, the scheduled storyboard can no longer affect a variable after the new storyboard begins to animate that variable.

Passing null for the comparison parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by compressing the scheduled storyboard and any other storyboards animating the same variables.

A storyboard can be compressed only if the priority comparison object registered with this method returns for all the other scheduled storyboards that will be affected by compression. When the storyboards are compressed, time is temporarily accelerated for affected storyboards, so they play faster.

Passing null for the comparison parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Setting a priority comparison handler with this method enables the application to indicate when scheduling conflicts can be resolved by concluding the scheduled storyboard.

A scheduled storyboard can be concluded only if it contains a loop with a repetition count of UI_ANIMATION_REPEAT_INDEFINITELY and the priority comparison object registered with this method returns . If the storyboard is concluded, the current repetition of the loop completes, and the rest of the storyboard then plays.

Passing null for the comparison parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

For Windows Animation to schedule a storyboard successfully, the storyboard must begin before the longest acceptable delay has elapsed. Windows Animation determines this delay in the following order: the delay value set by calling for this specific storyboard, the delay value set by calling this method, or 0.0 if neither method has been called.

This method will fail with an error code of UI_E_INVALID_PRIMITIVE if the start time is either less than 0 or less than the start time of a previous segment.

Defined by the function Y(t) = bias + amplitude*sin(360*frequency*t + phase), where 'sin' is the sin of an angle specified in degrees (for example, sin(n + 360) == sin(n) for any real number 'n').

This method will fail with an error code of UI_E_INVALID_PRIMITIVE if the start time is either less than 0 or less than the start time of a previous segment.

A single animation variable can be included in multiple storyboards, but multiple storyboards cannot animate the same variable at the same time. If a newly scheduled storyboard attempts to animate one or more variables that are currently scheduled for animation by different storyboards, a scheduling conflict occurs. To determine which storyboard has priority, the animation manager can call the HasPriority method on one or more priority comparison handlers provided by the application.

A single animation variable can be included in multiple storyboards, but multiple storyboards cannot animate the same variable at the same time. If a new storyboard attempts to animate one or more variables that are currently scheduled for animation by a different storyboard, a scheduling conflict occurs. To determine which storyboard has priority, the animation manager can call the HasPriority method on one or more priority comparison handlers provided by the application.

Registering priority comparison objects is optional. By default, all storyboards can be trimmed, concluded, or compressed to prevent failure, but none can be canceled, and by default no storyboards will be canceled or trimmed to prevent a delay.

By default, a call made in a callback method to any other animation method results in the call failing and returning UI_E_ILLEGAL_REENTRANCY. However, there are exceptions to this default. The following methods can be successfully called from HasPriority:

is a primary component for building animations, along with and .

The AddTransition method applies the specified transition to the specified variable in the storyboard. If this is the first transition applied to this variable in this storyboard, the transition begins at the start of the storyboard. Otherwise, the transition is appended to the transition that was most recently added to the variable.

A keyframe represents a moment in time within a storyboard and can be used to specify the start and end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

A keyframe represents a moment in time within a storyboard and can be used to specify the start and end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

Transitions must be added in the order in which they will be played. A transition may begin playing before the preceding transition in the storyboard has finished, in which case the initial value and velocity seen by the new transition is determined by the state of the preceding one. A transition should not begin before the start of the preceding transition.

A keyframe represents a moment in time within a storyboard and can be used to specify the start and end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

This method applies the specified transition to the specified variable in the storyboard, with the transition starting and ending at the specified keyframes. If the transition was created with a duration parameter specified, that duration is overwritten with the duration of time between the start and end keyframes. Otherwise, Windows Animation speeds up or slows down the transition as necessary.

A keyframe represents a moment in time within a storyboard and can be used to specify the start and end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

Transitions must be added in the order in which they will be played. A transition may begin playing before the preceding transition in the storyboard has finished, in which case the initial value and velocity seen by the new transition will be determined by the state of the preceding one. It must not be possible for a transition to begin before the start of the preceding transition.

This method directs a storyboard to play the interval between the given keyframes repeatedly before playing the remainder of the storyboard. If a finite repetition count is specified, the loop always plays that number of times. If UI_ANIMATION_REPEAT_INDEFINITELY (-1) is specified, the loop repeats until the storyboard is concluded, in which case the current iteration of the loop completes and the remainder of the storyboard plays. A storyboard that loops indefinitely also ends if it is truncated.

Nested and overlapping loops are not supported.

A keyframe represents a moment in time within a storyboard and can be used to specify the start or end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

When a storyboard is playing, it has exclusive access to any variables it animates unless the storyboard is trimmed by a higher priority storyboard. Typically, this exclusive access is released when the last transition in the storyboard for that variable finishes playing. Applications can call this method to maintain exclusive access to the animation variable and hold the variable, at the final value of the last transition, until the end of the storyboard.

For a storyboard to be successfully scheduled, it must begin before the longest acceptable delay has elapsed. This delay is determined in the following order: the delay value set by calling this method, the delay value set by calling the method, or 0.0 if neither of these methods has been called.

This method directs a storyboard to attempt to add itself to the schedule of playing storyboards. The rules are as follows:

• If there are no playing storyboards animating any of the same animation variables, the attempt succeeds and the storyboard starts playing immediately.

• If the storyboard has priority to cancel, trim, conclude, or compress conflicting storyboards, the attempt to schedule succeeds and the storyboard begins playing as soon as possible.

• If the storyboard does not have priority, the attempt fails and the schedulingResult parameter is set to .

If this method is called from a handler for OnStoryboardStatusChanged events, the schedulingResult parameter is set to . The only way to determine whether the storyboard is successfully scheduled is to set a storyboard event handler and check whether the storyboard's status ever becomes .

It is possible reuse a storyboard by calling Schedule again after its status has reached . An attempt to schedule a storyboard when it is in any state other than or fails, and schedulingResult is set to .

This method specifies that any subsequent keyframe loops that have a repetition count of UI_ANIMATION_REPEAT_INDEFINITELY (-1) will be skipped while the remainder of the storyboard is played.

An iteration of a keyframe loop that is in progress will be completed before the remainder of the storyboard plays.

If this method is called at the end of a keyframe loop iteration, the loop is terminated and the loop value is set to the starting loop value.

This method has no effect on storyboard events. Events continue to be raised as expected while the storyboard plays.

This method can be called before or after the storyboard starts playing.

This method does not trigger any storyboard events.

A tag is a pairing of an integer identifier (id) with a COM object (object); it can be used by an application to identify a storyboard.

A tag is a pairing of an integer identifier (id) with a COM object (object); it can be used by an application to identify a storyboard.

The parameters are optional so that the method can return both portions of the tag, or just the identifier or object portion.

Unless this method is called from a handler for OnStoryboardStatusChanged events, the only values it returns are , , , and .

Passing null for the handler parameter causes Windows Animation to release its reference to any handler object you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

For a storyboard to be successfully scheduled, it must begin before the longest acceptable delay has elapsed. This delay is determined in the following order: the delay value set by calling this method, the delay value set by calling the method, or 0.0 if neither of these methods has been called.

Unless this method is called from a handler for OnStoryboardStatusChanged events, the only values it returns are , , , and .

is the primary component for building animations, along with and .

The AddTransition method applies the specified transition to the specified variable in the storyboard. If this is the first transition applied to this variable in this storyboard, the transition begins at the start of the storyboard. Otherwise, the transition is appended to the transition that was most recently added to the variable.

A keyframe represents a moment in time within a storyboard and can be used to specify the start and end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

A keyframe represents a moment in time within a storyboard and can be used to specify the start and end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

Transitions must be added in the order in which they will be played. A transition may begin playing before the preceding transition in the storyboard has finished, in which case the initial value and velocity seen by the new transition is determined by the state of the preceding one. A transition should not begin before the start of the preceding transition.

A keyframe represents a moment in time within a storyboard and can be used to specify the start and end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

This method applies the specified transition to the specified variable in the storyboard, with the transition starting and ending at the specified keyframes. If the transition was created with a duration parameter specified, that duration is overwritten with the duration of time between the start and end keyframes. Otherwise, Windows Animation speeds up or slows down the transition as necessary.

A keyframe represents a moment in time within a storyboard and can be used to specify the start and end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

Transitions must be added in the order in which they will be played. A transition may begin playing before the preceding transition in the storyboard has finished, in which case the initial value and velocity seen by the new transition will be determined by the state of the preceding one. It must not be possible for a transition to begin before the start of the preceding transition.

This method directs a storyboard to play the interval between the given keyframes repeatedly before playing the remainder of the storyboard. If a finite repetition count is specified, the loop always plays that number of times. If UI_ANIMATION_REPEAT_INDEFINITELY (-1) is specified, the loop repeats until the storyboard is concluded, in which case the current iteration of the loop completes and the remainder of the storyboard plays. A storyboard that loops indefinitely also ends if it is truncated.

Nested and overlapping loops are not supported.

A keyframe represents a moment in time within a storyboard and can be used to specify the start or end times of transitions. Because keyframes can be added at the ends of transitions, their offsets from the start of the storyboard may not be known until the storyboard is playing.

When a storyboard is playing, it has exclusive access to any variables it animates unless the storyboard is trimmed by a higher-priority storyboard. Typically, this exclusive access is released when the last transition in the storyboard for that variable finishes playing. Applications can call this method to maintain exclusive access to the animation variable and hold the variable, at the final value of the last transition, until the end of the storyboard.

For Windows Animation to schedule a storyboard successfully, the storyboard must begin before the longest acceptable delay has elapsed. Windows Animation determines this delay in the following order: the delay value set by calling this method, the delay value set by calling the method, or 0.0 if neither of these methods has been called.

Use to start a storyboard animation at a specified offset instead of delaying the start of a storyboard.

Calls to SetSkipDuration fail if the storyboard has been scheduled.

SetSkipDuration does not delay the start of a scheduled storyboard. See for more info on how to set a delay for a scheduled storyboard.

This diagram shows a skip duration, or offset, for a storyboard.

This method directs a storyboard to try to add itself to the schedule of playing storyboards, using these rules:

• If there are no playing storyboards animating any of the same animation variables, the attempt succeeds and the storyboard starts playing immediately.

• If the storyboard has priority to cancel, trim, conclude, or compress conflicting storyboards, the attempt to schedule succeeds and the storyboard starts playing as soon as possible.

• If the storyboard does not have priority, the attempt fails and the schedulingResult parameter is set to .

If this method is called from a handler for OnStoryboardStatusChanged events, the schedulingResult parameter is set to . The only way to determine whether the storyboard is successfully scheduled is to set a storyboard event handler and check whether the storyboard's status ever becomes .

It is possible to reuse a storyboard by calling Schedule again after its status has reached . An attempt to schedule a storyboard when it is in any state other than or fails, and schedulingResult is set to .

This method specifies that any subsequent keyframe loops that have a repetition count of UI_ANIMATION_REPEAT_INDEFINITELY (-1) will be skipped while the remainder of the storyboard is played.

An iteration of a keyframe loop that is in progress will be completed before the remainder of the storyboard plays.

If this method is called at the end of an alternating keyframe loop iteration, the loop is terminated with the loop value set to the ending loop value.

If this method is called at the end of a non-alternating keyframe loop iteration, where "loop wrapping" results in the loop value being set to the starting value of the next iteration, the loop is executed once more in order for the loop value to be set to the ending loop value.

For alternating keyframe loops, each iteration has a starting value that is equivalent to the ending value of the preceding loop. In this case, "loop wrapping" is not an issue.

This method has no effect on storyboard events. Events continue to be raised as expected while the storyboard plays.

This method can be called before or after the storyboard starts playing.

This method does not trigger any storyboard events.

A tag is a pairing of an integer identifier (id) with a COM object (object). It can be used by an application to identify a storyboard.

A tag is a pairing of an integer identifier (id) with a COM object (object); it can be used by an application to identify a storyboard.

This method can return the identifier, the object, or both portions of the tag.

Unless this method is called from a handler for OnStoryboardStatusChanged events, the only values it returns are , , , and .

Passing null for the handler parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

For Windows Animation to schedule a storyboard successfully, the storyboard must begin before the longest acceptable delay has elapsed. Windows Animation determines this delay in the following order: the delay value set by calling this method, the delay value set by calling the method, or 0.0 if neither of these methods has been called.

Use to start a storyboard animation at a specified offset instead of delaying the start of a storyboard.

Calls to SetSkipDuration fail if the storyboard has been scheduled.

SetSkipDuration does not delay the start of a scheduled storyboard. See for more info on how to set a delay for a scheduled storyboard.

This diagram shows a skip duration, or offset, for a storyboard.

Unless this method is called from a handler for OnStoryboardStatusChanged events, the only values it returns are , , , and .

Use SetTimerEventHandler to specify the timing events handler for an instance of .

The UIAnimationManager object implements this interface, so a client application can query the UIAnimationManager object for this interface and then pass the interface to . It is not necessary to disconnect the UIAnimationManager and UIAnimationTimer objects; releasing them both is sufficient to clean up.

Do not call this method after the transition has been added to a storyboard.

The animation manager should not call this method after the transition has been added to a storyboard.

This method should not be called when the storyboard to which the transition has been added is scheduled or playing.

An application should typically call the IsDurationKnown method before calling this method.

This method should not be called when the storyboard to which the transition has been added is scheduled or playing.

Do not call this method after the transition has been added to a storyboard.

This method should not be called when the storyboard to which the transition has been added is scheduled or playing.

An application should typically call the IsDurationKnown method before calling this method.

This method should not be called when the storyboard to which the transition has been added is scheduled or playing.

When an application requires animation effects that are not available in the transition library, developers can implement custom transitions that it can use. A custom transition is created by first implementing the interpolator function for the transition, and then by using a factory object to generate transitions from the interpolator. An interpolator must implement the interface; an implementation of the transition factory object is provided by UIAnimationTransitionFactory.

When an application requires animation effects that are not available in the transition library, developers can implement custom transitions that the application can use. A custom transition is created by first implementing the interpolator function for the transition, and then by using a factory object to generate transitions from the interpolator. An interpolator must implement either the interface or the interface; an implementation of the transition factory object is provided by UIAnimationTransitionFactory or by UIAnimationTransitionFactory2.

During a cubic B?zier linear transition, the value of the animation variable changes from its initial value to the finalValue over the duration of the transition. The ordered pairs, (x1, y1) and (x2, y2), act as control points that provide directional information to transform the linear path of the transition into a smooth parametric curve.

The following figure shows the change in value over time for an animation variable during a cubic B?zier linear transition.

During an instantaneous transition, the value of the animation variable changes instantly from its current value to a specified final value. The duration of this transition is always zero.

The following figure shows the change in value over time of an animation variable during an instantaneous transition.

During an instantaneous transition, the value of the animation variable changes instantly from its current value to a specified final value. The duration of this transition is always zero.

The following figure shows the change in value over time of an animation variable during an instantaneous transition.

During a constant transition, the value of an animation variable remains at the initial value over the duration of the transition.

The following figure shows the change in value for an animation variable over time during a constant-duration transition.

During a discrete transition, the animation variable remains at the initial value for a specified delay time, then switches instantaneously to a specified final value and remains at that value for a given hold time.

The following figure shows the change in value over time of an animation variable during a discrete transition.

During a discrete transition, the animation variable remains at the initial value for a specified delay time, then switches instantaneously to a specified final value and remains at that value for a given hold time.

The following figure shows the change in value over time of an animation variable during a discrete transition.

During a linear transition, the value of the animation variable transitions linearly from its initial value to a specified final value.

The following figure shows the change in value over time of an animation variable during a linear transition.

During a linear transition, the value of the animation variable transitions linearly from its initial value to a specified final value.

The following figure shows the change in value over time of an animation variable during a linear transition.

During a linear-speed transition, the value of the animation variable changes at a specified rate. The duration of the transition is determined by the difference between the initial value and the specified final value.

The following figure shows the change in value over time of an animation variable during a linear-speed transition.

During a linear-speed transition, the value of the animation variable changes at a specified rate. The duration of the transition is determined by the difference between the initial value and the specified final value.

The following figure shows the change in value over time of an animation variable during a linear-speed transition.

The value of the animation variable oscillates around the initial value over the entire duration of a sinusoidal-range transition. The amplitude of the oscillation is determined by the velocity when the transition begins.

The following figure shows the change in value over time of an animation variable during a sinusoidal-velocity transition.

The value of the animation variable fluctuates between the specified minimum and maximum values over the entire duration of a sinusodial-range transition. The slope parameter is used to disambiguate between the two possible sine waves specified by the other parameters.

The following figure shows the change in value over time of an animation variable during a sinusoidal-range transition. Passing in the enumeration value yields a wave like the solid curve shown in the figure, whereas the value yields a wave like the dashed curve.

During an accelerate-decelerate transition, the animation variable speeds up and then slows down over the duration of the transition, ending at a specified value. You can control how quickly the variable accelerates and decelerates independently, by specifying different acceleration and deceleration ratios.

When the initial velocity is zero, the acceleration ratio is the fraction of the duration that the variable will spend accelerating; likewise for the deceleration ratio. If the value of initial velocity is nonzero, the value is the fraction of the time between the velocity reaching zero and the end of transition. The acceleration ratio and the deceleration ratio should sum to a maximum of 1.0.

The following figures show the change in value for animation variables with different initial velocities during accelerate-decelerate transitions.

Note??d' in the figure on the right shows the time between the velocity reaching zero and the end of the transition.

A reversal transition smoothly changes direction over the specified duration. The final value will be the same as the initial value and the final velocity will be the negative of the initial velocity. The folllowing figure shows such a reversal transition.

During a cubic transition, the value of the animation variable changes from its initial value to the finalValue over the duration of the transition, ending at the finalVelocity.

The following figure shows the effect on an animation variable over time during a cubic transition.

During a cubic transition, the value of the animation variable changes from its initial value to the finalValue over the duration of the transition, ending at the finalVelocity.

The following figure shows the effect on an animation variable over time during a cubic transition.

A smooth-stop transition slows down as it approaches the specified final value, and reaches the final value with a velocity of zero. The duration of the transition is determined by the initial velocity, the difference between the initial and final values, and the specified maximum duration. If there is no solution consisting of a single parabolic arc, this method creates a cubic transition.

The following figure shows the change in value over time of an animation variable during a smooth-stop transition.

During a parabolic-acceleration transition, the value of the animation variable changes from the initial value to the final value, ending at the specified velocity. You can control how quickly the variable reaches the final value by specifying the rate of acceleration.

The following figure shows the change in value over time of an animation variable during a parabolic-acceleration transition.

During a cubic B?zier linear transition, the value of the animation variable changes from its initial value to the finalValue over the duration of the transition. The ordered pairs, (x1, y1) and (x2, y2), act as control points that provide directional information to transform the linear path of the transition into a smooth parametric curve.

The following figure shows the change in value over time for an animation variable during a cubic B?zier linear transition.

During a cubic B?zier linear transition, the value of the animation variable changes from its initial value to the finalValue over the duration of the transition. The ordered pairs, (x1, y1) and (x2, y2), act as control points that provide directional information to transform the linear path of the transition into a smooth parametric curve.

The following figure shows the change in value over time of an animation variable during a cubic B?zier linear transition.

Along with and , is a primary component for building animations. To create and manage animation variables, use .

The results can be affected by the lower and upper bounds determined by and , respectively.

The result can be affected by the lower and upper bounds determined by and , respectively.

The results can be affected by the lower and upper bounds determined by and , respectively.

To specify the rounding mode to be used when converting the value, use the method.

The result can also be affected by the lower and upper bounds determined by and , respectively.

To specify the rounding mode to be used when converting the value, use the method.

The result can also be affected by the lower and upper bounds determined by and , respectively.

To specify the rounding mode to be used when converting the value, use the method.

The result can also be affected by the lower and upper bounds determined by and , respectively.

An animation variable's rounding mode determines how a floating-point value is converted to an integer. The default mode for each variable is .

A tag is a pairing of an integer identifier (id) with a COM object (object); it can be used by an application to identify an animation variable. Because null is a valid object component of a tag, the object parameter can be null.

A tag is a pairing of an integer identifier (id) with a COM object (object); it can be used by an application to identify an animation variable.

The parameters are optional so that the method can return both portions of the tag, or just the identifier or object portion.

Passing null for the handler parameter causes Windows Animation to release its reference to any handler object you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Passing null for the handler parameter causes Windows Animation to release its reference to any handler object you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

is called only if the rounded value has changed since the last update.

The results can be affected by the lower and upper bounds determined by and , respectively.

The result can be affected by the lower and upper bounds determined by and , respectively.

The results can be affected by the lower and upper bounds determined by and , respectively.

To specify the rounding mode to be used when converting the value, use the method.

The result can also be affected by the lower and upper bounds determined by and , respectively.

To specify the rounding mode to be used when converting the value, use the method.

The result can also be affected by the lower and upper bounds determined by and , respectively.

To specify the rounding mode to be used when converting the value, use the method.

The result can also be affected by the lower and upper bounds determined by and , respectively.

An animation variable's rounding mode determines how a floating-point value is converted to an integer. The default mode for each variable is .

The application implements the object that is referenced by the animation parameter.

The application implements the object that is referenced by the animation parameter.

The application implements the object that is referenced by the animation parameter.

An animation variable's rounding mode determines how a floating-point value is converted to an integer. The default mode for each variable is .

A tag is a pairing of an integer identifier (id) with a COM object (object), and it can be used by an application to identify an animation variable. Because null is a valid object component of a tag, the object parameter can be null.

A tag is a pairing of an integer identifier (id) with a COM object (object); it can be used by an application to identify an animation variable.

The parameters are optional, so that the method can return both portions of the tag, or just the identifier or object portion.

Passing null for the handler parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the method.

Passing null for the handler parameter causes Windows Animation to release its reference to any handler object that you passed in earlier. This technique can be essential for breaking reference cycles without having to call the Shutdown method.

is called only if the rounded value has changed since the last update.

An animation variable's rounding mode determines how a floating-point value is converted to an integer. The default mode for each variable is .

OnValueChanged receives animation variable value updates as DOUBLE values. To receive value updates as INT32 values, use .

The OnValueChanged method receives animation variable value updates as DOUBLE values. To receive value updates as INT32 values, use the method.

OnIntegerValueChanged receives animation variable value updates as INT32 values. To receive value updates as DOUBLE values, use the method.