mirror of https://github.com/UMSKT/xpmgr.git
1123 lines
47 KiB
Plaintext
1123 lines
47 KiB
Plaintext
//--------------------------------------------------------------------------
|
|
//
|
|
// UIAnimation.idl
|
|
//
|
|
// Windows Animation interface definitions and related types and enums
|
|
//
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
cpp_quote("//--------------------------------------------------------------------------")
|
|
cpp_quote("//")
|
|
cpp_quote("// UIAnimation.h")
|
|
cpp_quote("//")
|
|
cpp_quote("// Windows Animation interface definitions and related types and enums")
|
|
cpp_quote("// (Generated from UIAnimation.idl)")
|
|
cpp_quote("//")
|
|
cpp_quote("// Copyright (c) Microsoft Corporation. All rights reserved.")
|
|
cpp_quote("//")
|
|
cpp_quote("//--------------------------------------------------------------------------")
|
|
|
|
import "wtypes.idl";
|
|
import "unknwn.idl";
|
|
#include "sdkddkver.h"
|
|
|
|
interface IUIAnimationManager;
|
|
interface IUIAnimationVariable;
|
|
interface IUIAnimationStoryboard;
|
|
interface IUIAnimationTransition;
|
|
interface IUIAnimationManagerEventHandler;
|
|
interface IUIAnimationVariableChangeHandler;
|
|
interface IUIAnimationVariableIntegerChangeHandler;
|
|
interface IUIAnimationStoryboardEventHandler;
|
|
interface IUIAnimationPriorityComparison;
|
|
interface IUIAnimationTransitionLibrary;
|
|
|
|
interface IUIAnimationInterpolator;
|
|
interface IUIAnimationTransitionFactory;
|
|
|
|
interface IUIAnimationTimer;
|
|
interface IUIAnimationTimerUpdateHandler;
|
|
interface IUIAnimationTimerClientEventHandler;
|
|
interface IUIAnimationTimerEventHandler;
|
|
|
|
// Annotations on methods are not supported by earlier versions of MIDL
|
|
#ifdef NTDDI_WIN7
|
|
#define UI_CHECKRETURN [annotation("__checkReturn")]
|
|
#else
|
|
#define UI_CHECKRETURN
|
|
#endif
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Animation API
|
|
|
|
// The units of time used for all animations
|
|
typedef DOUBLE UI_ANIMATION_SECONDS;
|
|
|
|
// Special value to indicate that any predetermined time in the future will be acceptable
|
|
const UI_ANIMATION_SECONDS UI_ANIMATION_SECONDS_EVENTUALLY = -1.0;
|
|
|
|
// Defines results for animation updates
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_UPDATE_NO_CHANGE = 0, // No animation variables changed
|
|
UI_ANIMATION_UPDATE_VARIABLES_CHANGED = 1 // One or more animation variables changed
|
|
} UI_ANIMATION_UPDATE_RESULT;
|
|
|
|
// Defines activity status for an animation manager
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_MANAGER_IDLE = 0, // The animation manager is idle; no animations are currently playing
|
|
UI_ANIMATION_MANAGER_BUSY = 1 // The animation manager is busy; one or more animations are currently playing
|
|
} UI_ANIMATION_MANAGER_STATUS;
|
|
|
|
// Defines animation modes
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_MODE_DISABLED = 0, // Animation is disabled
|
|
UI_ANIMATION_MODE_SYSTEM_DEFAULT = 1, // Animation is system managed
|
|
UI_ANIMATION_MODE_ENABLED = 2 // Animation is enabled
|
|
} UI_ANIMATION_MODE;
|
|
|
|
// Defines the animation manager, which provides a central interface for creating and managing UI animations
|
|
[
|
|
local,
|
|
object,
|
|
uuid(9169896C-AC8D-4e7d-94E5-67FA4DC2F2E8),
|
|
helpstring("IUIAnimationManager Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationManager : IUnknown
|
|
{
|
|
// Creates a new animation variable
|
|
UI_CHECKRETURN HRESULT
|
|
CreateAnimationVariable
|
|
(
|
|
[in, annotation("__in")] DOUBLE initialValue, // The initial value for the variable
|
|
[out, retval, annotation("__deref_out")] IUIAnimationVariable **variable // The new animation variable
|
|
);
|
|
|
|
// Creates and schedules a single-transition storyboard
|
|
UI_CHECKRETURN HRESULT
|
|
ScheduleTransition
|
|
(
|
|
[in, annotation("__in")] IUIAnimationVariable *variable, // The variable to schedule for transition
|
|
[in, annotation("__in")] IUIAnimationTransition *transition, // The transition to apply to the variable
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS timeNow // The current time
|
|
);
|
|
|
|
// Creates a new storyboard
|
|
UI_CHECKRETURN HRESULT
|
|
CreateStoryboard
|
|
(
|
|
[out, retval, annotation("__deref_out")] IUIAnimationStoryboard **storyboard // The new storyboard
|
|
);
|
|
|
|
// Directs the animation manager to finish all active storyboards
|
|
UI_CHECKRETURN HRESULT
|
|
FinishAllStoryboards
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS completionDeadline // The maximum amount of time any storyboard is allowed
|
|
);
|
|
|
|
// Directs the animation manager to abandon all active storyboards
|
|
UI_CHECKRETURN HRESULT
|
|
AbandonAllStoryboards
|
|
(
|
|
);
|
|
|
|
// Directs the animation manager to update the elapsed time for all scheduled storyboards
|
|
UI_CHECKRETURN HRESULT
|
|
Update
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS timeNow, // The current time
|
|
[out, defaultvalue(0),
|
|
annotation("__out_opt")] UI_ANIMATION_UPDATE_RESULT *updateResult // The update result
|
|
);
|
|
|
|
// Gets the animation variable with a specified tag
|
|
UI_CHECKRETURN HRESULT
|
|
GetVariableFromTag
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUnknown *object, // The tag object
|
|
[in, annotation("__in")] UINT32 id, // The tag ID
|
|
[out, retval, annotation("__deref_out")] IUIAnimationVariable **variable // The animation variable that matches the specified tag, or NULL if no match is found
|
|
);
|
|
|
|
// Gets the storyboard with a specified tag
|
|
UI_CHECKRETURN HRESULT
|
|
GetStoryboardFromTag
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUnknown *object, // The tag object
|
|
[in, annotation("__in")] UINT32 id, // The tag ID
|
|
[out, retval, annotation("__deref_out")] IUIAnimationStoryboard **storyboard // The animation storyboard that matches the specified tag, or NULL if no match is found
|
|
);
|
|
|
|
// Gets the animation manager's status
|
|
UI_CHECKRETURN HRESULT
|
|
GetStatus
|
|
(
|
|
[out, retval, annotation("__out")] UI_ANIMATION_MANAGER_STATUS *status // The animation manager's status
|
|
);
|
|
|
|
// Sets the animation mode for the animation manager
|
|
UI_CHECKRETURN HRESULT
|
|
SetAnimationMode
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_MODE mode // The animation mode
|
|
);
|
|
|
|
// Pauses all animations
|
|
UI_CHECKRETURN HRESULT
|
|
Pause
|
|
(
|
|
);
|
|
|
|
// Resumes all animations
|
|
UI_CHECKRETURN HRESULT
|
|
Resume
|
|
(
|
|
);
|
|
|
|
// Specifies a handler for animation manager status updates
|
|
UI_CHECKRETURN HRESULT
|
|
SetManagerEventHandler
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUIAnimationManagerEventHandler *handler // A handler for animation manager status update events
|
|
);
|
|
|
|
// Sets a priority comparison handler for cancellation
|
|
UI_CHECKRETURN HRESULT
|
|
SetCancelPriorityComparison
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUIAnimationPriorityComparison *comparison // The handler for priority comparisons to determine if a scheduled storyboard can be cancelled
|
|
);
|
|
|
|
// Sets a priority comparison handler for trimming
|
|
UI_CHECKRETURN HRESULT
|
|
SetTrimPriorityComparison
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUIAnimationPriorityComparison *comparison // The handler for priority comparisons to determine if a scheduled storyboard can be trimmed
|
|
);
|
|
|
|
// Sets a priority comparison handler for compression
|
|
UI_CHECKRETURN HRESULT
|
|
SetCompressPriorityComparison
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUIAnimationPriorityComparison *comparison // The handler for priority comparisons to determine if a scheduled storyboard can be compressed
|
|
);
|
|
|
|
// Sets a priority comparison handler for conclusion
|
|
UI_CHECKRETURN HRESULT
|
|
SetConcludePriorityComparison
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUIAnimationPriorityComparison *comparison // The handler for priority comparisons to determine if a scheduled storyboard can be concluded
|
|
);
|
|
|
|
// Sets the default acceptable animation delay
|
|
UI_CHECKRETURN HRESULT
|
|
SetDefaultLongestAcceptableDelay
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS delay // The default value for acceptable delay before scheduled storyboards start
|
|
);
|
|
|
|
// Shuts down the animation manager and all objects it has created
|
|
UI_CHECKRETURN HRESULT
|
|
Shutdown
|
|
(
|
|
);
|
|
};
|
|
|
|
// Defines rounding modes to use when converting values from floating point to integer
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_ROUNDING_NEAREST = 0, // Round to the nearest integer
|
|
UI_ANIMATION_ROUNDING_FLOOR = 1, // Round down
|
|
UI_ANIMATION_ROUNDING_CEILING = 2 // Round up
|
|
} UI_ANIMATION_ROUNDING_MODE;
|
|
|
|
// Defines an animation variable, which represents a value that may be animated
|
|
[
|
|
local,
|
|
object,
|
|
uuid(8CEEB155-2849-4ce5-9448-91FF70E1E4D9),
|
|
helpstring("IUIAnimationVariable Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationVariable : IUnknown
|
|
{
|
|
// Gets the animation variable's current value
|
|
UI_CHECKRETURN HRESULT
|
|
GetValue
|
|
(
|
|
[out, retval, annotation("__out")] DOUBLE *value // The current value
|
|
);
|
|
|
|
// Gets the animation variable's final value, after all currently scheduled animations have finished
|
|
UI_CHECKRETURN HRESULT
|
|
GetFinalValue
|
|
(
|
|
[out, retval, annotation("__out")] DOUBLE *finalValue // The final value
|
|
);
|
|
|
|
// Gets the animation variable's value before the most recent update
|
|
UI_CHECKRETURN HRESULT
|
|
GetPreviousValue
|
|
(
|
|
[out, retval, annotation("__out")] DOUBLE *previousValue // The previous value
|
|
);
|
|
|
|
// Gets the animation variable's current value, converted to INT32
|
|
UI_CHECKRETURN HRESULT
|
|
GetIntegerValue
|
|
(
|
|
[out, retval, annotation("__out")] INT32 *value // The animation variable's current value, converted to INT32
|
|
);
|
|
|
|
// Gets the animation variable's final value, converted to INT32
|
|
UI_CHECKRETURN HRESULT
|
|
GetFinalIntegerValue
|
|
(
|
|
[out, retval, annotation("__out")] INT32 *finalValue // The animation variable's final value, converted to INT32
|
|
);
|
|
|
|
// Gets the animation variable's value before the most recent update, converted to INT32
|
|
UI_CHECKRETURN HRESULT
|
|
GetPreviousIntegerValue
|
|
(
|
|
[out, retval, annotation("__out")] INT32 *previousValue // The animation variable's previous value, converted to INT32
|
|
);
|
|
|
|
// Gets the storyboard that is currently animating the variable
|
|
UI_CHECKRETURN HRESULT
|
|
GetCurrentStoryboard
|
|
(
|
|
[out, retval, annotation("__deref_out")] IUIAnimationStoryboard **storyboard // The current storyboard, or NULL if no storyboard is currently animating the variable
|
|
);
|
|
|
|
// Sets the lower bound (floor) for the animation variable's value
|
|
UI_CHECKRETURN HRESULT
|
|
SetLowerBound
|
|
(
|
|
[in, annotation("__in")] DOUBLE bound // The lower bound
|
|
);
|
|
|
|
// Sets the upper bound (ceiling) for the animation variable's value
|
|
UI_CHECKRETURN HRESULT
|
|
SetUpperBound
|
|
(
|
|
[in, annotation("__in")] DOUBLE bound // The upper bound
|
|
);
|
|
|
|
// Specifies a rounding mode for the animation variable
|
|
UI_CHECKRETURN HRESULT
|
|
SetRoundingMode
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_ROUNDING_MODE mode // A rounding mode for the animation variable
|
|
);
|
|
|
|
// Sets the animation variable's object/ID tag
|
|
UI_CHECKRETURN HRESULT
|
|
SetTag
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUnknown *object, // The tag object
|
|
[in, annotation("__in")] UINT32 id // The tag ID
|
|
);
|
|
|
|
// Gets the animation variable's object/ID tag
|
|
UI_CHECKRETURN HRESULT
|
|
GetTag
|
|
(
|
|
[out, annotation("__deref_opt_out")] IUnknown **object, // The tag object
|
|
[out, annotation("__out_opt")] UINT32 *id // The tag ID
|
|
);
|
|
|
|
// Specifies a handler for value updates
|
|
UI_CHECKRETURN HRESULT
|
|
SetVariableChangeHandler
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUIAnimationVariableChangeHandler *handler // A handler for animation variable value updates
|
|
);
|
|
|
|
// Specifies a handler for value updates; values are converted to INT32
|
|
UI_CHECKRETURN HRESULT
|
|
SetVariableIntegerChangeHandler
|
|
(
|
|
[in, unique,
|
|
annotation("__in_opt")] IUIAnimationVariableIntegerChangeHandler *handler // A handler for animation variable value updates
|
|
);
|
|
};
|
|
|
|
// Defines status for a storyboard
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_STORYBOARD_BUILDING = 0, // The storyboard has not yet been scheduled
|
|
UI_ANIMATION_STORYBOARD_SCHEDULED = 1, // The storyboard is scheduled to play
|
|
UI_ANIMATION_STORYBOARD_CANCELLED = 2, // The storyboard was cancelled
|
|
UI_ANIMATION_STORYBOARD_PLAYING = 3, // The storyboard is currently playing
|
|
UI_ANIMATION_STORYBOARD_TRUNCATED = 4, // The storyboard was truncated
|
|
UI_ANIMATION_STORYBOARD_FINISHED = 5, // The storyboard finished playing
|
|
UI_ANIMATION_STORYBOARD_READY = 6, // The storyboard is built and ready for re-scheduling
|
|
UI_ANIMATION_STORYBOARD_INSUFFICIENT_PRIORITY = 7 // Scheduling failed; a scheduling conflict occurred, and the currently scheduled storyboard has higher priority
|
|
} UI_ANIMATION_STORYBOARD_STATUS;
|
|
|
|
// Defines results for storyboard scheduling
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_SCHEDULING_UNEXPECTED_FAILURE = 0, // Scheduling failed for an unexpected reason
|
|
UI_ANIMATION_SCHEDULING_INSUFFICIENT_PRIORITY = 1, // Scheduling failed; a scheduling conflict occurred, and the currently scheduled storyboard has higher priority
|
|
UI_ANIMATION_SCHEDULING_ALREADY_SCHEDULED = 2, // Scheduling failed; the storyboard is already scheduled
|
|
UI_ANIMATION_SCHEDULING_SUCCEEDED = 3, // Scheduling succeeded
|
|
UI_ANIMATION_SCHEDULING_DEFERRED = 4 // Scheduling will be attempted when the current operation completes
|
|
} UI_ANIMATION_SCHEDULING_RESULT;
|
|
|
|
// Defines a keyframe, which represents a time offset within a storyboard
|
|
typedef struct { int _; } *UI_ANIMATION_KEYFRAME;
|
|
|
|
// Special value representing the implicit keyframe at the start of every storyboard
|
|
const UI_ANIMATION_KEYFRAME UI_ANIMATION_KEYFRAME_STORYBOARD_START = (UI_ANIMATION_KEYFRAME)(-1);
|
|
|
|
// Special value to direct a storyboard to repeat the interval between two keyframes indefinitely
|
|
const INT32 UI_ANIMATION_REPEAT_INDEFINITELY = -1;
|
|
|
|
// Defines a storyboard, which combines animation variables and transitions to define an animation
|
|
[
|
|
local,
|
|
object,
|
|
uuid(A8FF128F-9BF9-4af1-9E67-E5E410DEFB84),
|
|
helpstring("IUIAnimationStoryboard Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationStoryboard : IUnknown
|
|
{
|
|
// Adds a transition to the storyboard
|
|
UI_CHECKRETURN HRESULT
|
|
AddTransition
|
|
(
|
|
[in, annotation("__in")] IUIAnimationVariable *variable, // The animation variable to transition
|
|
[in, annotation("__in")] IUIAnimationTransition *transition // The transition to apply to the variable
|
|
);
|
|
|
|
// Adds a keyfame offset from an existing keyframe
|
|
UI_CHECKRETURN HRESULT
|
|
AddKeyframeAtOffset
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_KEYFRAME existingKeyframe, // An existing keyframe
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS offset, // The offset from existingKeyframe at which to add keyframe
|
|
[out, retval, annotation("__out")] UI_ANIMATION_KEYFRAME *keyframe // The new keyframe
|
|
);
|
|
|
|
// Adds a keyfame at the end of a specified transition
|
|
UI_CHECKRETURN HRESULT
|
|
AddKeyframeAfterTransition
|
|
(
|
|
[in, annotation("__in")] IUIAnimationTransition *transition, // The transition to add a keyframe after
|
|
[out, retval, annotation("__out")] UI_ANIMATION_KEYFRAME *keyframe // The new keyframe
|
|
);
|
|
|
|
// Adds a transition that starts at a specified keyframe
|
|
UI_CHECKRETURN HRESULT
|
|
AddTransitionAtKeyframe
|
|
(
|
|
[in, annotation("__in")] IUIAnimationVariable *variable, // The animation variable to transition
|
|
[in, annotation("__in")] IUIAnimationTransition *transition, // The transition to apply to the variable
|
|
[in, annotation("__in")] UI_ANIMATION_KEYFRAME startKeyframe // A keyframe that specifies the beginning of the new transition
|
|
);
|
|
|
|
// Adds a transition between two keyframes
|
|
UI_CHECKRETURN HRESULT
|
|
AddTransitionBetweenKeyframes
|
|
(
|
|
[in, annotation("__in")] IUIAnimationVariable *variable, // The animation variable to transition
|
|
[in, annotation("__in")] IUIAnimationTransition *transition, // The transition to apply to the variable
|
|
[in, annotation("__in")] UI_ANIMATION_KEYFRAME startKeyframe, // A keyframe that specifies the beginning of the new transition
|
|
[in, annotation("__in")] UI_ANIMATION_KEYFRAME endKeyframe // A keyframe that specifies the end of the new transition
|
|
);
|
|
|
|
// Creates a play cycle between two specified keyframes
|
|
UI_CHECKRETURN HRESULT
|
|
RepeatBetweenKeyframes
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_KEYFRAME startKeyframe, // The keyframe at which to start the cycle
|
|
[in, annotation("__in")] UI_ANIMATION_KEYFRAME endKeyframe, // The keyframe at which to end the cycle
|
|
[in, annotation("__in")] INT32 repetitionCount // The number of times to repeat; must be 1 or more, or UI_ANIMATION_REPEAT_INDEFINITELY
|
|
);
|
|
|
|
// Directs the storyboard to hold an animation variable at its final value until the storyboard ends
|
|
UI_CHECKRETURN HRESULT
|
|
HoldVariable
|
|
(
|
|
[in, annotation("__in")] IUIAnimationVariable *variable // The animation variable to hold
|
|
);
|
|
|
|
// Sets the longest acceptable delay before the storyboard plays
|
|
UI_CHECKRETURN HRESULT
|
|
SetLongestAcceptableDelay
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS delay // The longest acceptable delay before the storyboard plays
|
|
);
|
|
|
|
// Directs the storyboard to schedule for play
|
|
UI_CHECKRETURN HRESULT
|
|
Schedule
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS timeNow, // The current time
|
|
[out, defaultvalue(0),
|
|
annotation("__out_opt")] UI_ANIMATION_SCHEDULING_RESULT *schedulingResult // The result of the scheduling request
|
|
);
|
|
|
|
// Directs the storyboard to conclude
|
|
UI_CHECKRETURN HRESULT
|
|
Conclude
|
|
(
|
|
);
|
|
|
|
// Directs the storyboard to finish playing within a specified amount of time
|
|
UI_CHECKRETURN HRESULT
|
|
Finish
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS completionDeadline // The maximum time the storyboard has to finish playing
|
|
);
|
|
|
|
// Directs the storyboard to abandon playing
|
|
UI_CHECKRETURN HRESULT
|
|
Abandon
|
|
(
|
|
);
|
|
|
|
// Sets the storyboard's object/ID tag
|
|
UI_CHECKRETURN HRESULT
|
|
SetTag
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUnknown *object, // The tag object
|
|
[in, annotation("__in")] UINT32 id // The tag ID
|
|
);
|
|
|
|
// Gets the storyboard's object/ID tag
|
|
UI_CHECKRETURN HRESULT
|
|
GetTag
|
|
(
|
|
[out, annotation("__deref_opt_out")] IUnknown **object, // The tag object
|
|
[out, annotation("__out_opt")] UINT32 *id // The tag ID
|
|
);
|
|
|
|
// Gets the storyboard's status
|
|
UI_CHECKRETURN HRESULT
|
|
GetStatus
|
|
(
|
|
[out, retval, annotation("__out")] UI_ANIMATION_STORYBOARD_STATUS *status // The storyboard's status
|
|
);
|
|
|
|
// Gets time elapsed since the storyboard started playing
|
|
UI_CHECKRETURN HRESULT
|
|
GetElapsedTime
|
|
(
|
|
[out, annotation("__out")] UI_ANIMATION_SECONDS *elapsedTime // Time elapsed since the storyboard started playing
|
|
);
|
|
|
|
// Specifies a handler for storyboard status and update events
|
|
UI_CHECKRETURN HRESULT
|
|
SetStoryboardEventHandler
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUIAnimationStoryboardEventHandler *handler // A handler for storyboard status and update events
|
|
);
|
|
};
|
|
|
|
// Defines a transition, which determines how an animation variable changes over time
|
|
[
|
|
local,
|
|
object,
|
|
uuid(DC6CE252-F731-41cf-B610-614B6CA049AD),
|
|
helpstring("IUIAnimationTransition Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationTransition : IUnknown
|
|
{
|
|
// Forces the transition to start at a given initial value
|
|
UI_CHECKRETURN HRESULT
|
|
SetInitialValue
|
|
(
|
|
[in, annotation("__in")] DOUBLE value // The initial value
|
|
);
|
|
|
|
// Forces the transition to start with a given initial velocity
|
|
UI_CHECKRETURN HRESULT
|
|
SetInitialVelocity
|
|
(
|
|
[in, annotation("__in")] DOUBLE velocity // The initial velocity
|
|
);
|
|
|
|
// Determines whether a transition's duration is currently known
|
|
UI_CHECKRETURN HRESULT
|
|
IsDurationKnown
|
|
(
|
|
);
|
|
|
|
// Gets the transition's duration
|
|
UI_CHECKRETURN HRESULT
|
|
GetDuration
|
|
(
|
|
[out, retval, annotation("__out")] UI_ANIMATION_SECONDS *duration // The duration
|
|
);
|
|
};
|
|
|
|
// Defines methods for handling animation manager status change events
|
|
[
|
|
local,
|
|
object,
|
|
uuid(783321ED-78A3-4366-B574-6AF607A64788),
|
|
helpstring("IUIAnimationManagerEventHandler Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationManagerEventHandler : IUnknown
|
|
{
|
|
// Handles OnManagerStatusChanged events, which occur when the animation manager's status changes
|
|
UI_CHECKRETURN HRESULT
|
|
OnManagerStatusChanged
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_MANAGER_STATUS newStatus, // The new status
|
|
[in, annotation("__in")] UI_ANIMATION_MANAGER_STATUS previousStatus // The previous status
|
|
);
|
|
};
|
|
|
|
// Defines methods for handling animation variable update events
|
|
[
|
|
local,
|
|
object,
|
|
uuid(6358B7BA-87D2-42d5-BF71-82E919DD5862),
|
|
helpstring("IUIAnimationVariableChangeHandler Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationVariableChangeHandler : IUnknown
|
|
{
|
|
// Handles OnValueChanged events, which occur when an animation variable's value changes; receives value updates as DOUBLE
|
|
UI_CHECKRETURN HRESULT
|
|
OnValueChanged
|
|
(
|
|
[in, annotation("__in")] IUIAnimationStoryboard *storyboard, // The storyboard that is animating the variable
|
|
[in, annotation("__in")] IUIAnimationVariable *variable, // The animation variable that was updated
|
|
[in, annotation("__in")] DOUBLE newValue, // The new value
|
|
[in, annotation("__in")] DOUBLE previousValue // The previous value
|
|
);
|
|
};
|
|
|
|
// Defines methods for handling animation variable update events
|
|
[
|
|
local,
|
|
object,
|
|
uuid(BB3E1550-356E-44b0-99DA-85AC6017865E),
|
|
helpstring("IUIAnimationVariableIntegerChangeHandler Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationVariableIntegerChangeHandler : IUnknown
|
|
{
|
|
// Handles OnIntegerValueChanged events, which occur when an animation variable's rounded value changes; receives value updates as INT32
|
|
UI_CHECKRETURN HRESULT
|
|
OnIntegerValueChanged
|
|
(
|
|
[in, annotation("__in")] IUIAnimationStoryboard *storyboard, // The storyboard that is animating the variable
|
|
[in, annotation("__in")] IUIAnimationVariable *variable, // The animation variable that was updated
|
|
[in, annotation("__in")] INT32 newValue, // The new rounded value
|
|
[in, annotation("__in")] INT32 previousValue // The previous rounded value
|
|
);
|
|
};
|
|
|
|
// Defines methods for handling animation variable update events
|
|
[
|
|
local,
|
|
object,
|
|
uuid(3D5C9008-EC7C-4364-9F8A-9AF3C58CBAE6),
|
|
helpstring("IUIAnimationStoryboardEventHandler Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationStoryboardEventHandler : IUnknown
|
|
{
|
|
// Handles OnStoryboardStatusChanged events, which occur when a storyboard's status changes
|
|
UI_CHECKRETURN HRESULT
|
|
OnStoryboardStatusChanged
|
|
(
|
|
[in, annotation("__in")] IUIAnimationStoryboard *storyboard, // The storyboard that changed status
|
|
[in, annotation("__in")] UI_ANIMATION_STORYBOARD_STATUS newStatus, // The new status
|
|
[in, annotation("__in")] UI_ANIMATION_STORYBOARD_STATUS previousStatus // The previous status
|
|
);
|
|
|
|
// Handles OnStoryboardUpdated events, which occur when a storyboard is updated
|
|
UI_CHECKRETURN HRESULT
|
|
OnStoryboardUpdated
|
|
(
|
|
[in, annotation("__in")] IUIAnimationStoryboard *storyboard // The storyboard that was updated
|
|
);
|
|
};
|
|
|
|
// Defines the effect on the current attempt to schedule a storyboard if a priority comparison were to return S_FALSE
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_PRIORITY_EFFECT_FAILURE = 0, // The attempt to schedule the storyboard will fail
|
|
UI_ANIMATION_PRIORITY_EFFECT_DELAY = 1 // The storyboard will be schedule later than it would if the priority comparion were to return S_OK
|
|
} UI_ANIMATION_PRIORITY_EFFECT;
|
|
|
|
// Defines a priority comparison that the animation manager uses to resolve scheduling conflicts
|
|
[
|
|
local,
|
|
object,
|
|
uuid(83FA9B74-5F86-4618-BC6A-A2FAC19B3F44),
|
|
helpstring("IUIAnimationPriorityComparison Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationPriorityComparison : IUnknown
|
|
{
|
|
// Determines the relative priority between a scheduled storyboard and a new storyboard
|
|
UI_CHECKRETURN HRESULT
|
|
HasPriority
|
|
(
|
|
[in, annotation("__in")] IUIAnimationStoryboard *scheduledStoryboard, // The currently scheduled storyboard
|
|
[in, annotation("__in")] IUIAnimationStoryboard *newStoryboard, // The new storyboard that is in scheduling conflict with scheduledStoryboard
|
|
[in, annotation("__in")] UI_ANIMATION_PRIORITY_EFFECT priorityEffect // The effect on newStoryboard if scheduledStoryboard has priority
|
|
);
|
|
};
|
|
|
|
|
|
// Defines animation slope characteristics
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_SLOPE_INCREASING = 0, // The slope is increasing
|
|
UI_ANIMATION_SLOPE_DECREASING = 1 // The slope is decreasing
|
|
} UI_ANIMATION_SLOPE;
|
|
|
|
// Defines a library of standard transitions
|
|
[
|
|
local,
|
|
object,
|
|
uuid(CA5A14B1-D24F-48b8-8FE4-C78169BA954E),
|
|
helpstring("IUIAnimationTransitionLibrary Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationTransitionLibrary : IUnknown
|
|
{
|
|
// Creates an instantaneous transition
|
|
UI_CHECKRETURN HRESULT
|
|
CreateInstantaneousTransition
|
|
(
|
|
[in, annotation("__in")] DOUBLE finalValue, // The final value this transition leads to when applied to an animation variable
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new instantaneous transition
|
|
);
|
|
|
|
// Creates a constant-value transition
|
|
UI_CHECKRETURN HRESULT
|
|
CreateConstantTransition
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS duration, // The transition duration
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new constant-value transition
|
|
);
|
|
|
|
// Creates a discrete transition
|
|
UI_CHECKRETURN HRESULT
|
|
CreateDiscreteTransition
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS delay, // The delay before the variable changes value
|
|
[in, annotation("__in")] DOUBLE finalValue, // The final value this transition leads to when applied to an animation variable
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS hold, // The hold time at the final value
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new discrete transition
|
|
);
|
|
|
|
// Creates a linear transition
|
|
UI_CHECKRETURN HRESULT
|
|
CreateLinearTransition
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS duration, // The transition duration
|
|
[in, annotation("__in")] DOUBLE finalValue, // The final value this transition leads to when applied to an animation variable
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new linear transition
|
|
);
|
|
|
|
// Creates a linear transition with a given speed
|
|
UI_CHECKRETURN HRESULT
|
|
CreateLinearTransitionFromSpeed
|
|
(
|
|
[in, annotation("__in")] DOUBLE speed, // The speed, in units/second, at which the variable will transition to the final value
|
|
[in, annotation("__in")] DOUBLE finalValue, // The final value this transition leads to when applied to an animation variable
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new linear transition
|
|
);
|
|
|
|
// Creates a sinusoidal transition with an amplitude determined by its initial velocity
|
|
UI_CHECKRETURN HRESULT
|
|
CreateSinusoidalTransitionFromVelocity
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS duration, // The transition duration
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS period, // The duration of each cycle
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new sinusoidal transition
|
|
);
|
|
|
|
// Creates a sinusoidal transition with a given range of oscillation
|
|
UI_CHECKRETURN HRESULT
|
|
CreateSinusoidalTransitionFromRange
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS duration, // The transition duration
|
|
[in, annotation("__in")] DOUBLE minimumValue, // The value at each trough of the sine wave
|
|
[in, annotation("__in")] DOUBLE maximumValue, // The value at each peak of the sine wave
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS period, // The duration of each cycle
|
|
[in, annotation("__in")] UI_ANIMATION_SLOPE slope, // The slope at the start of the transition
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new sinusoidal transition
|
|
);
|
|
|
|
// Creates an accelerate-decelerate transition
|
|
UI_CHECKRETURN HRESULT
|
|
CreateAccelerateDecelerateTransition
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS duration, // The transition duration
|
|
[in, annotation("__in")] DOUBLE finalValue, // The final value this transition leads to when applied to an animation variable
|
|
[in, annotation("__in")] DOUBLE accelerationRatio, // The fraction of the duration to spend accelerating
|
|
[in, annotation("__in")] DOUBLE decelerationRatio, // The fraction of the duration to spend decelerating
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new accelerate-decelerate transition
|
|
);
|
|
|
|
// Creates a reversal transition
|
|
UI_CHECKRETURN HRESULT
|
|
CreateReversalTransition
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS duration, // The transition duration
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new reversal transition
|
|
);
|
|
|
|
// Creates a cubic transition
|
|
UI_CHECKRETURN HRESULT
|
|
CreateCubicTransition
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS duration, // The transition duration
|
|
[in, annotation("__in")] DOUBLE finalValue, // The final value this transition leads to when applied to an animation variable
|
|
[in, annotation("__in")] DOUBLE finalVelocity, // The final velocity
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new cubic transition
|
|
);
|
|
|
|
// Creates a smooth-stop transition
|
|
UI_CHECKRETURN HRESULT
|
|
CreateSmoothStopTransition
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS maximumDuration, // The maximum duration for the transition
|
|
[in, annotation("__in")] DOUBLE finalValue, // The final value this transition leads to when applied to an animation variable
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new smooth-stop transition
|
|
);
|
|
|
|
// Creates a parabolic transition with a given acceleration
|
|
UI_CHECKRETURN HRESULT
|
|
CreateParabolicTransitionFromAcceleration
|
|
(
|
|
[in, annotation("__in")] DOUBLE finalValue, // The final value this transition leads to when applied to an animation variable
|
|
[in, annotation("__in")] DOUBLE finalVelocity, // The final velocity
|
|
[in, annotation("__in")] DOUBLE acceleration, // The rate of change of the velocity
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new parabolic transition
|
|
);
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Interpolator API
|
|
|
|
// Defines the aspects of an interpolator that depend on a given input
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_DEPENDENCY_NONE = 0x00000000, // No aspects depend on the input
|
|
UI_ANIMATION_DEPENDENCY_INTERMEDIATE_VALUES = 0x00000001, // The intermediate values depend on the input
|
|
UI_ANIMATION_DEPENDENCY_FINAL_VALUE = 0x00000002, // The final value depends on the input
|
|
UI_ANIMATION_DEPENDENCY_FINAL_VELOCITY = 0x00000004, // The final velocity depends on the input
|
|
UI_ANIMATION_DEPENDENCY_DURATION = 0x00000008 // The duration depends on the input
|
|
} UI_ANIMATION_DEPENDENCIES;
|
|
|
|
cpp_quote("DEFINE_ENUM_FLAG_OPERATORS(UI_ANIMATION_DEPENDENCIES);")
|
|
|
|
// Defines methods for creating a custom interpolator
|
|
[
|
|
local,
|
|
object,
|
|
uuid(7815CBBA-DDF7-478c-A46C-7B6C738B7978),
|
|
helpstring("IUIAnimationInterpolator Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationInterpolator : IUnknown
|
|
{
|
|
// Sets the interpolator's initial value and velocity
|
|
UI_CHECKRETURN HRESULT
|
|
SetInitialValueAndVelocity
|
|
(
|
|
[in, annotation("__in")] DOUBLE initialValue, // The initial value
|
|
[in, annotation("__in")] DOUBLE initialVelocity // The initial velocity
|
|
);
|
|
|
|
// Sets the interpolator's duration
|
|
UI_CHECKRETURN HRESULT
|
|
SetDuration
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS duration // The interpolator duration
|
|
);
|
|
|
|
// Gets the interpolator's duration
|
|
UI_CHECKRETURN HRESULT
|
|
GetDuration
|
|
(
|
|
[out, retval, annotation("__out")] UI_ANIMATION_SECONDS *duration // The interpolator duration
|
|
);
|
|
|
|
// Gets the final value to which the interpolator leads
|
|
UI_CHECKRETURN HRESULT
|
|
GetFinalValue
|
|
(
|
|
[out, retval, annotation("__out")] DOUBLE *value // The final value
|
|
);
|
|
|
|
// Interpolates the value at a given offset
|
|
UI_CHECKRETURN HRESULT
|
|
InterpolateValue
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS offset, // The offset
|
|
[out, retval, annotation("__out")] DOUBLE *value // The interpolated value
|
|
);
|
|
|
|
// Interpolates the velocity at a given offset
|
|
UI_CHECKRETURN HRESULT
|
|
InterpolateVelocity
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS offset, // The offset
|
|
[out, retval, annotation("__out")] DOUBLE *velocity // The interpolated velocity
|
|
);
|
|
|
|
// Get's the interpolator's dependencies
|
|
UI_CHECKRETURN HRESULT
|
|
GetDependencies
|
|
(
|
|
[out, annotation("__out")] UI_ANIMATION_DEPENDENCIES *initialValueDependencies, // The aspects of the interpolator that depend on its initial value
|
|
[out, annotation("__out")] UI_ANIMATION_DEPENDENCIES *initialVelocityDependencies, // The aspects of the interpolator that depend on its initial velocity
|
|
[out, annotation("__out")] UI_ANIMATION_DEPENDENCIES *durationDependencies // The aspects of the interpolator that depend on its duration
|
|
);
|
|
};
|
|
|
|
// Defines methods for creating transitions from custom interpolators
|
|
[
|
|
local,
|
|
object,
|
|
uuid(FCD91E03-3E3B-45ad-BBB1-6DFC8153743D),
|
|
helpstring("IUIAnimationTransitionFactory Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationTransitionFactory : IUnknown
|
|
{
|
|
// Creates a transition from a custom interpolator
|
|
UI_CHECKRETURN HRESULT
|
|
CreateTransition
|
|
(
|
|
[in, annotation("__in")] IUIAnimationInterpolator *interpolator, // The interpolator to create a transition from
|
|
[out, retval, annotation("__deref_out")] IUIAnimationTransition **transition // The new transition
|
|
);
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Timer API
|
|
|
|
// Defines behaviors for a timer when its client is idle
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_IDLE_BEHAVIOR_CONTINUE = 0, // The timer continues to generate timer events (is enabled) when the client is idle
|
|
UI_ANIMATION_IDLE_BEHAVIOR_DISABLE = 1 // The timer is suspended (disabled) when the animation manager is idle
|
|
} UI_ANIMATION_IDLE_BEHAVIOR;
|
|
|
|
// Defines an animation timer, which provides services for managing animation timing
|
|
[
|
|
local,
|
|
object,
|
|
uuid(6B0EFAD1-A053-41d6-9085-33A689144665),
|
|
helpstring("IUIAnimationTimer Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationTimer : IUnknown
|
|
{
|
|
// Specifies a handler for timing updates
|
|
UI_CHECKRETURN HRESULT
|
|
SetTimerUpdateHandler
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUIAnimationTimerUpdateHandler *updateHandler, // A handler for timing events
|
|
[in, annotation("__in")] UI_ANIMATION_IDLE_BEHAVIOR idleBehavior // The desired behavior of the timer when it is idle
|
|
);
|
|
|
|
// Specifies a handler for timing events
|
|
UI_CHECKRETURN HRESULT
|
|
SetTimerEventHandler
|
|
(
|
|
[in, unique, annotation("__in_opt")] IUIAnimationTimerEventHandler *handler // A handler for timing events
|
|
);
|
|
|
|
// Enables the animation timer
|
|
UI_CHECKRETURN HRESULT
|
|
Enable
|
|
(
|
|
);
|
|
|
|
// Disables the animation timer
|
|
UI_CHECKRETURN HRESULT
|
|
Disable
|
|
(
|
|
);
|
|
|
|
// Determines whether the timer is currently enabled
|
|
UI_CHECKRETURN HRESULT
|
|
IsEnabled
|
|
(
|
|
);
|
|
|
|
// Gets the current time
|
|
UI_CHECKRETURN HRESULT
|
|
GetTime
|
|
(
|
|
[out, annotation("__out")] UI_ANIMATION_SECONDS *seconds // Current update time
|
|
);
|
|
|
|
// Sets the frame rate below which the timer event handler will be called
|
|
UI_CHECKRETURN HRESULT
|
|
SetFrameRateThreshold
|
|
(
|
|
[in, annotation("__in")] UINT32 framesPerSecond // The minimum acceptable frame rate, in frames-per-second
|
|
);
|
|
};
|
|
|
|
// Defines methods for handling timing update events
|
|
[
|
|
local,
|
|
object,
|
|
uuid(195509B7-5D5E-4e3e-B278-EE3759B367AD),
|
|
helpstring("IUIAnimationTimerUpdateHandler Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationTimerUpdateHandler : IUnknown
|
|
{
|
|
// Handles OnUpdate events, which occur when it is time to update an animation
|
|
UI_CHECKRETURN HRESULT
|
|
OnUpdate
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_SECONDS timeNow, // The current time
|
|
[out, retval, annotation("__out")] UI_ANIMATION_UPDATE_RESULT *result // The result of the animation update
|
|
);
|
|
|
|
// Specifies a handler for timer client status change events
|
|
UI_CHECKRETURN HRESULT
|
|
SetTimerClientEventHandler
|
|
(
|
|
[in, annotation("__in")] IUIAnimationTimerClientEventHandler *handler // A handler for timer client events
|
|
);
|
|
|
|
// Clears the handler for timer client status change events
|
|
UI_CHECKRETURN HRESULT
|
|
ClearTimerClientEventHandler
|
|
(
|
|
);
|
|
};
|
|
|
|
// Defines activity status for a timer's client
|
|
typedef [v1_enum] enum
|
|
{
|
|
UI_ANIMATION_TIMER_CLIENT_IDLE = 0, // The timer's client is idle
|
|
UI_ANIMATION_TIMER_CLIENT_BUSY = 1 // The timer's client is busy
|
|
} UI_ANIMATION_TIMER_CLIENT_STATUS;
|
|
|
|
// Defines methods for handling events related to changes in timer client status
|
|
[
|
|
local,
|
|
object,
|
|
uuid(BEDB4DB6-94FA-4bfb-A47F-EF2D9E408C25),
|
|
helpstring("IUIAnimationTimerClientEventHandler Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationTimerClientEventHandler : IUnknown
|
|
{
|
|
// Handles OnTimerClientStatusChanged events, which occur when the timer client's status changes
|
|
UI_CHECKRETURN HRESULT
|
|
OnTimerClientStatusChanged
|
|
(
|
|
[in, annotation("__in")] UI_ANIMATION_TIMER_CLIENT_STATUS newStatus, // The new status
|
|
[in, annotation("__in")] UI_ANIMATION_TIMER_CLIENT_STATUS previousStatus // The previous status
|
|
);
|
|
};
|
|
|
|
// Defines methods for handling timing events
|
|
[
|
|
local,
|
|
object,
|
|
uuid(274A7DEA-D771-4095-ABBD-8DF7ABD23CE3),
|
|
helpstring("IUIAnimationTimerEventHandler Interface"),
|
|
pointer_default(unique)
|
|
]
|
|
interface IUIAnimationTimerEventHandler : IUnknown
|
|
{
|
|
// Handles OnPreUpdate events, which occur before an animation update begins
|
|
UI_CHECKRETURN HRESULT
|
|
OnPreUpdate
|
|
(
|
|
);
|
|
|
|
// Handles OnPostUpdate events, which occur after an animation update is finished
|
|
UI_CHECKRETURN HRESULT
|
|
OnPostUpdate
|
|
(
|
|
);
|
|
|
|
// Handles OnRenderingTooSlow events, which occur when the rendering frame rate for an animation falls below the minimum acceptable frame rate
|
|
UI_CHECKRETURN HRESULT
|
|
OnRenderingTooSlow
|
|
(
|
|
[in, annotation("__in")] UINT32 framesPerSecond // The current frame rate, in frames-per-second
|
|
);
|
|
};
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
// Type Library
|
|
|
|
[
|
|
uuid(44CA24DB-1A92-4149-BAB5-FB14D64B401E),
|
|
version(1.0),
|
|
helpstring("UIAnimation 1.0 Type Library")
|
|
]
|
|
library UIAnimation
|
|
{
|
|
importlib("stdole32.tlb");
|
|
|
|
[
|
|
uuid(4C1FC63A-695C-47E8-A339-1A194BE3D0B8),
|
|
helpstring("UIAnimationManager Class")
|
|
]
|
|
coclass UIAnimationManager
|
|
{
|
|
[default] interface IUIAnimationManager;
|
|
};
|
|
|
|
[
|
|
uuid(1D6322AD-AA85-4EF5-A828-86D71067D145),
|
|
helpstring("UIAnimationTransitionLibrary Class")
|
|
]
|
|
coclass UIAnimationTransitionLibrary
|
|
{
|
|
[default] interface IUIAnimationTransitionLibrary;
|
|
};
|
|
|
|
[
|
|
uuid(8A9B1CDD-FCD7-419c-8B44-42FD17DB1887),
|
|
helpstring("UIAnimationTransitionFactory Class")
|
|
]
|
|
coclass UIAnimationTransitionFactory
|
|
{
|
|
[default] interface IUIAnimationTransitionFactory;
|
|
};
|
|
|
|
[
|
|
uuid(BFCD4A0C-06B6-4384-B768-0DAA792C380E),
|
|
helpstring("UIAnimationTimer Class")
|
|
]
|
|
coclass UIAnimationTimer
|
|
{
|
|
[default] interface IUIAnimationTimer;
|
|
};
|
|
};
|
|
|
|
|
|
#undef UI_CHECKRETURN
|
|
|