The animation component is a framework that provides support to build animated graphics applications. It provides the basic data types that allow animations to be incorporated into the normal drawing of a window from the client, or to be managed on the server as a sprite.
The component has the following key concepts:
The animation is a fairly abstract interface owned by a client application. The interface is independent of the source of the data it uses, as the data providers are responsible for providing data to the animation.
The animator represents each data type supported by the animation framework. It can handle data interpretation, timing and control of the animation. An animator is not be visible to the owner of the animation, but is controlled through it using a standard interface. The animators can either reside on the client or on the server. Each animation selects an animator plug-in to be used by providing an appropriate string obtained from the data provider.
A data provider is a generic interface to handle different kinds of data, which has different structures and behaviours, for example, GIFs and SVG (Scalable Vector Graphics). Animations access the data providers they own through an observer interface, which reports events to the animation. The interface in turn reports these events to the respective animators.
An observer acts as an interface and is responsible for reporting events. The animation framework provides two such observers: a data provider observer, and an animation observer. The data provider observer is an interface between the animation and the data provider. Using this observer the animation can receive data and events from the data provider. The animation observer is an interface between the animation and the client application, and is used to report events to the client application. In Symbian OS v9.1, the animation observer is implemented to report only errors to the client application.
The animation component provides a set of abstract classes with some basic functionality required for any type of animation. Implementors have to derive their own classes using these abstract classes to support specific animation types such as bitmap animation, sprite animation and so on.
The animation framework also provides concrete implementations of the abstract classes. The concrete implementations of the CAnimation class are:
CBasicAnimation
This is a client-side animation class which can also act as a data provider observer and an animation drawer. It provides a bitmap and a mask on which the animation is submitted. This class establishes a session with the windows server before submitting the animation to a particular window.
CSpriteAnimation
This is a server-side animation class for sprite based animations. The client has limited control over the animation, as sprites are server-side graphic objects and are controlled by the server. This class makes use of the windows server animation API to submit sprite animations. For more information on these APIs, refer to Using Window Server (WSERV).
CAnimationGroup
This class is not an animation class by itself, but is a collection of animations grouped together. It provides access to an array of animation references and handles all synchronisation issues among the animations in the group, provided all the animations are of the same type. For example, if a set of client-side animations are grouped together, they respond to commands collectively in synchronisation with each other. If the group includes both sprite and client-side animations, they will respond to commands collectively in asynchronous mode.
The framework provides the following concrete implementations for the other two abstract classes, CAnimationDataProvider and CAnimator:
CICLAnimationDataProvider
This class interprets various data types including animated GIFs using the Image Conversion Library (ICL). It provides data to the animation class in the form of individual frames using the CAnimationFrame object which contains a bitmap, a mask, and frame information.
CBitmapAnimator
This class can handle fixed sequence of bitmap frames passed by the data provider.
| Class Name | Description |
|---|---|
This is an abstract generic class which provides the basic functionality for all types of animations. |
|
This is an abstract class, which represents each type of data supported by the animation framework. This class is implemented as an ECOM plug-in. |
|
This is an abstract class, which takes the animation data and converts it into a format recognized by the animator. |
|
This is a concrete implementation class of the CAnimation class. This class is used for basic client-side animations. |
|
This is a concrete implementation class of the CAnimation class. This class is used for sprite animations. |
Creating a basic animation
The animation framework can be used to create a basic client-side animation using the CBasicAnimation class. You can also have your own implementation for other type of animations. For more information, refer to How to create a basic animation.
Creating a sprite animation
The animation framework supports server-side sprite animations using the CSpriteAnimation class. The procedure to create a sprite animation is the same as that for creating a basic client-side animation. The only difference between a client-side animation and a sprite animation is that client-side animations are redrawn by the client application. Whereas, for sprite animations redraws are handled automatically, as they run in the window server's high priority thread.