// Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "Eclipse Public License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.eclipse.org/legal/epl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// Header for writing animated DLL add ons

// 

//

#if !defined(__W32ADLL_H__)

#define __W32ADLL_H__

#if !defined(__W32STD_H__)

#include <w32std.h>

#endif

#if !defined(__BITSTD_H__)

#include <bitstd.h>

#endif

/**

@publishedAll

@deprecated

*/

const TUint KWservAnimDllUidValue8=268435858;

/**

@publishedAll

@deprecated

*/

const TUid KWservAnimDllUid8={KWservAnimDllUidValue8};

/**

@publishedAll

@released

*/

const TUint KWservAnimDllUidValue16=268450594;

/**

@publishedAll

@released

*/

const TUid KWservAnimDllUid16={KWservAnimDllUidValue16};

/**

@publishedAll

@released

*/

const TUint KWservAnimDllUidValue=KWservAnimDllUidValue16;

/**

@publishedAll

@released

*/

const TUid KWservAnimDllUid={KWservAnimDllUidValue};

//

// Contains functions callable from animated DLLs

//

class TWindowInfo

/** Animation window information.

Stores the window position and display mode for the animation.

During a redraw of the animation window, the redraw regions

can be retrieved by calling GetRedrawRegionAndRedrawShadowRegion().

@publishedAll 

@released

@see TWindowInfo::GetRedrawRegionAndRedrawShadowRegion() */

	{

public:

	/** The screen position. */

	TRect iScreenPos;

	/** The display mode.

	This is the minimum display mode that the screen has to be in to display this window. */

	TDisplayMode iMode;

public:

	/** Constructs an animation window information object. */

	inline TWindowInfo() : iRegionPair(NULL) {}

public:

	/** Stores a pair of region pointers. */

	struct TRegionPair

		{

		const TRegion* iRegion1;

		const TRegion* iRegion2;

		};

	/** Returns the current redraw region and redraw shadow region.

	This function must only be called from an override of CWindowAnim's pure virtual Redraw function.

	The region pointers retrieved must not be used beyond the end of the Redraw override.

	@param aRedrawRegion The redraw region in screen coordinates.

	@param aRedrawShadowRegion The redraw shadow region in screen coordinates. */

	inline void GetRedrawRegionAndRedrawShadowRegion(const TRegion*& aRedrawRegion, const TRegion*& aRedrawShadowRegion) const

		{

		if (iRegionPair)

			{

			aRedrawRegion=iRegionPair->iRegion1;

			aRedrawShadowRegion=iRegionPair->iRegion2;

			iRegionPair=NULL;

			}

		else

			{

			aRedrawRegion=NULL;

			aRedrawShadowRegion=NULL;

			}

		}

private:

	mutable const TRegionPair* iRegionPair;

	TAny *iFree2;

	friend class CWsAnim;

	};

class MEventHandler

/** Event handler interface.

The interface provides a function to handle raw events, e.g. key presses, 

pen events, power buttons etc. Raw events are passed to the OfferRawEvent() 

function when the MAnimGeneralFunctions::GetRawEvents() function has been 

called.

@publishedAll

@released */

	{

public:

	/** Handles raw events. 

	If the incoming event can be handled, the function should 

	process it and then return true. If it cannot be processed the function should 

	return false, and the event will be passed to other event handling code.

	This function must be implemented in every animation DLL. If event 

	handling is not required, the function should simply return false.

	@param aRawEvent The raw event to be processed

	@return ETrue if the raw event is handled by this function, EFalse if the function 

	chooses not to process it. */

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent)=0;

	};

enum TAnimNotifications

/** Bit flags to be used by anims when registering for notifications */

	{

	/** Notify when direct screen access begins or ends.*/

	EDirectScreenAccess = 0x0001,

	/** Notify when the wserv heartbeat timer starts or stops. */

	EHeartbeatTimer	= 0x0002,

	/** Notify when screen device changes.*/

	EScreenDeviceChange = 0x0004

	};

//Forward Declaration.

class MAnimGeneralFunctionsWindowExtension;    

class MAnimGeneralFunctionsEventExtension ;

class MAnimGeneralFunctions

/** General animation utility functions interface. 

The interface provides functions to set the animation timing, 

event functions, and other general functions.

You do not have to create an object of this type. The class is implemented 

by the window server and provides utility functions to all CAnim-derived 

classes via the CAnim::iFunctions pointer.

It is not intended for user derivation.

@publishedAll

@released */

	{

public:

	/** Animation synchronisation flags. 

	The animation can be synchronised to any of these values; 

	the Animate() call will take place at the start of the new unit (day, hour, etc...). */

	enum TAnimSync

		{

		/** Not synchronised. Animate() is called after some number of flash cycles - 

		set by SetSync(). */

		ESyncNone,

		/** Animate() every flash tick. This occurs twice a second, on the second and after 

		7/12ths of a second, e.g. the function is called in a flash-on (7/12 seconds) - 

		flash-off (5/12 seconds) cycle. */

		ESyncFlash,

		/** Animate() called as soon after every second as system activity allows. */

		ESyncSecond,

		/** Animate() called as soon after every minute as system activity allows. */

		ESyncMinute,

		/** Animate() called as soon after midnight every day as system activity allows. */

		ESyncDay,

		};

	enum

		{

		ENumberOfExtendedInterfaces=0,

		EWindowExtensionInterface,

		EEventExtentionInterface,

		EInterfaceCount, // Always keep at the end.

		};

	//Timing functions

	/** Calls the DLL's Animate() function then deactivates the graphics context. 

	This allows users to do drawing from their own active object.

	Note:

	If the user calls the CAnim-derived classes' Animate() function directly, 

	or otherwise does drawing from their own active object, then this will not 

	deactivate the graphics context. This causes the window server to panic the 

	client.

	Alternatively, use CFreeTimerWindowAnim, which allows you to deactivate the 

	graphics context yourself.

	@param aDateTime The parameter passed into the animation DLL's Animate() 

	function. */

	virtual void Animate(TDateTime *aDateTime)=0;

	/** Sets the synchronisation mode. 

	This determines the time intervals between calls to the Animate() function.

	@param aSyncMode The synchronisation mode. */

	virtual void SetSync(TAnimSync aSyncMode)=0;

	/** Sets the repeat interval. 

	If the synchronisation mode is TAnimSync::ESyncNone, then the Animate() function 

	is called at intervals defined by some number of flash ticks. There are two 

	flash ticks a second, with a 7/12 second - 5/12 second cycle. If the function 

	is called when the synchronisation mode is not TAnimSync::ESyncNone, then 

	the window server panics the client.

	If the new interval is greater than the current countdown, then the call does 

	not affect the current countdown. For example, if the countdown has 10 flash 

	ticks remaining, and the interval is set to 20, the new interval does not 

	apply until the current countdown is complete. 

	However if the new interval is less the current countdown, then the new interval 

	applies immediately i.e. the countdown is reset to the interval value.

	If the interval is set to zero the countdown stops, and the Animate() function 

	is no longer called.

	@param aInterval The number of flash ticks between calls to the Animate() 

	function. */

	virtual void SetInterval(TInt aInterval)=0;

	/** Sets the next interval. 

	This function immediately resets the current countdown to the specified number 

	of flash ticks, irrespective of its current value. After the countdown expires, 

	the interval returns to its usual rate. Note that this may be zero (i.e. 

	not at all).

	To call this function, the synchronisation mode must be TAnimSync::ESyncNone, 

	otherwise the window server panics the client.

	Note: there are two flash ticks a second, with a 7/12 second - 5/12 second cycle.

	@param aInterval The interval to the next Animate(). If the value is less 

	than 1, it automatically gets set to 1.

	@see SetInterval() */

	virtual void SetNextInterval(TInt aInterval)=0;

	/** Gets the system time as it was when Animate() was last called.

	@return The system time when Animate() was last called. */

	virtual TDateTime SystemTime() const=0;

	/** Tests the flash cycle state. 

	The flash cycle has 2 states: on (7/12 second) or off (5/12 second).

	@return ETrue if in the on part of the flash cycle, otherwise EFalse. */

	virtual TBool FlashStateOn() const=0;

	/** Gets the current synchronisation mode.

	@return The current sync mode. */

	virtual TAnimSync Sync() const=0;

	//Other functions generally useful

	/** Gets a pointer to the screen device. 

	For example, this might be used to gain access to twips to pixel conversion functions.

	@return A pointer to the screen device. */

	virtual const CFbsScreenDevice *ScreenDevice()=0;

	/** Creates and duplicates a bitmap from a handle. 

	This function might be used to duplicate client side bitmaps on the server side.

	@param aHandle A handle to the bitmap to be duplicated.

	@return A pointer to the duplicate bitmap. */

	virtual CFbsBitmap *DuplicateBitmapL(TInt aHandle)=0;

	/** Creates and duplicates a font from a handle.

	This function might be used to duplicate client side fonts on the server side.

	@param aHandle A handle to the font to be duplicated.

	@return A pointer to the duplicate font. */

	virtual CFbsFont *DuplicateFontL(TInt aHandle)=0;

	/** Closes a duplicate font.

	@param Pointer to the duplicate font.

	@see DuplicateFontL() */

	virtual void CloseFont(CFbsFont *)=0;

	/** Gets a reference to the calling client's thread.

	@return A reference to the calling client's thread. */

	virtual const RThread &Client()=0;

	/** Send a reply to the client process in response to a request

	from the client. 	

	@see RAnim::CommandReply()

	@param aDes The data to be sent back to the client

	 */

	virtual void ReplyBuf(const TDesC8 &aDes)=0;

	/** Send a reply to the client process in response to a request

	from the client. 	

	@see RAnim::CommandReply()

	@param aDes The data to be sent back to the client

	 */

	virtual void ReplyBuf(const TDesC16 &aDes)=0;				

	/** Panics the client. 

	This will result in the client thread being destroyed. */

	virtual void Panic() const=0;

	//Event functions

	/** Switches animation raw event handling on and off.

	If raw event handling is switched on, then raw events, e.g. pointer, key, or power events

	are all offered to the animation event handling code's MEventHandler::OfferRawEvent().

	If Animation works in a window for which advanced pointers have been enabled,

	then after switching on raw event handling it will receive pointer events from all 

	detected pointers. Otherwise it will receive events only from one emulated pointer.

	@param aGetEvents If ETrue, raw events are passed to the animation 

	event handling code. If EFalse, events are not passed to the animation. 

	@see RWindowBase::EnableAdvancedPointers() */

	virtual void GetRawEvents(TBool aGetEvents) const=0;

	/** Posts a raw event, just as if it had come from the kernel.

	If aRawEvent has pointer-related type (move, switch on, down, up or out of range),

	then its Z coordinate and iPointerNumber fields will be validated and may be

	overwritten by WSERV in order to guarantee correct behaviour depending on:

	1. Pointer Pressure and Proximity support on current platform.

	2. Multiple pointers support on current platform.

	3. Animation's awareness of these fields. If Animation works in a window

	   for which advanced pointers have been enabled, it is assumed that it has

	   initialized these fields. Otherwise WSERV will assume that these fields have

	   not been provided and may overwrite them with most appropriate values.

	For more information about event validation, please refer to System Documentation.

	@param aRawEvent The raw event 

	@see RWindowBase::EnableAdvancedPointers() */

	virtual void PostRawEvent(const TRawEvent &aRawEvent) const=0;

	/** Posts a key event.

	The function is similar to PostRawEvent() but should be 

	used for posting key events. 

	@param aRawEvent The key event. */

	virtual void PostKeyEvent(const TKeyEvent &aRawEvent) const=0;

	/** Get the address of an object which can retrieve information from and send

	information to the client-side.

	@return A pointer to RMessagePtr2. Complete must be called on the returned object (or a 

	copy of it) if and only if Message is called from an override of CAnim's CommandReplyL which 

	has been caused by a client-side RAnim::AsyncCommandReply call. If Message is called outside 

	an override of CAnim's CommandReplyL or outside an override of CWindowAnim's ConstructL or 

	CSpriteAnim's ConstructL, the it returns NULL. 

	@see RMessagePtr2 */

	virtual const RMessagePtr2* Message()=0; // replaces Reserved1

	/**Returns an extension interface, maybe extended further in the future.

	@param aInterfaceId The ID of the interface to return.

	@return A pointer to the extension interface.

	When aInterface=0 (ENumberOfExtendedInterfaces), the number of interfaces is returned (currently 2).

	When aInterface=1 (EWindowExtensionInterface), a pointer to the Window Extension interface is returned.

	When aInterface=2 (EEventExtentionInterface), a pointer to the Event Extension interface is returned.

	*/

	virtual TAny* ExtendedInterface(TInt aInterface)=0; // replaces Reserved2

	/** Register to receive notifications.

	@param aNotifications A bitset of TAnimNotifications values indicating which notifications are required

	@return One of the system wide error codes

	*/

	virtual TInt RegisterForNotifications(TUint32 aNotifications)=0;

	/*

	Return number of ExtendedInterfaces. */

	inline TInt NumberOfExtendedInterfaces()

		{

		return reinterpret_cast<TInt>(ExtendedInterface(ENumberOfExtendedInterfaces));

		}

	/** Gets access to Window Extension utility functions.

	@return A pointer to a class containing functions for working with Window. */

	inline MAnimGeneralFunctionsWindowExtension* WindowExtension()

		{

		return static_cast<MAnimGeneralFunctionsWindowExtension*>(ExtendedInterface(EWindowExtensionInterface));

		}

	/** Gets access to EventExtension utility functions. 

	@return A pointer to a class containing functions for working with Event. */

	inline MAnimGeneralFunctionsEventExtension* EventExtension()

		{

		return static_cast<MAnimGeneralFunctionsEventExtension*>(ExtendedInterface(EEventExtentionInterface));

		}

	private:

	virtual void Reserved1() const;

	virtual void Reserved2() const;

	virtual void Reserved3() const;

	};

/* Structure for passing window configuration information. Currently transparancey

related configuration information is supported, though this may be added to, as

apprioriate.

@publishedAll

@released

*/

class TWindowConfig

	{

public:

	/** Transparency flags. 

	Used to represent transparency configuration of the window. */

	enum

		{

		/** Transparency is enabled on the window. */

		ETransparencyEnabled=0x0001,

		/** Window transparency uses alpha blending channel. */

		EAlphaBlendedTransparency=0x0002,

		};

public:

	/** Indicate configuration of window, using enumerations defined within this class. */

	TInt iFlags;

private:

	TInt iReserved0;

	TInt iReserved1;

	TInt iReserved2;

	};

class MAnimGeneralFunctionsWindowExtension

/** General Window utility functions interface. 

The member functions define the interface for querying and manipulating 

the window and screen attributes.

You obtain one by calling: iFunctions->ExtendedInterface(MAnimGeneralFunctions::EWindowExtensionInterface) 

and casting the result.

It is not intended for user derivation.

@publishedAll 

@released */

	{

public:

	/** Class contains the information pertaining to a window group: name, priority, 

	focusability. */

	class TWindowGroupInfo

		{

	public:

		enum

			{

			/** Window is focusable flag. */

			EIsFocusable=0x0001,

			};

	public:

		/** Returns whether or not the window is focusable. 

		@return ETrue if focusable, else returns EFalse. */

		inline TBool IsFocusable() const {return iFlags&EIsFocusable;}

	public:

	/* Window group attributes. */

		TInt iId;

		TUint32 iFlags;

		TInt iOrdinalPriority;

		TInt iNameLength;

		TInt iParentId;

		};

public:

	/** Returns the total number of screens.

	@return The total number of screens. */

	virtual TInt Screens() const=0;

	/** Returns the number of the screen which is currently in focus.

	@return The number of the screen which is currently in focus.*/

	virtual TInt FocusScreens() const=0;

	/** Changes the focused screen.

	@param aScreenNo New screen number. */

	virtual void SetFocusScreen(TInt aScreenNo)=0;

	/** Returns the number of window groups available for the specified screen.

	@param aScreen The screen number.

	@return The number of window groups. */

	virtual TInt WindowGroups(TInt aScreen) const=0;

	/** Takes a screen number and an ordinal position and returns the complete window 

	group information of the specified window. If the window group does not exist, the 

	function returns EFalse.

	Note: the ordinal position specified should be the total or full ordinal position 

	of all group windows of all priorities on that screen.

	@param aInfo on return, complete window information.

	@param aScreen Screen number.

	@param aFullOrdinalPosition Ordinal position of the window.

	@return ETrue if window group information exists, EFalse otherwise.  */

	virtual TBool WindowGroupInfo(TWindowGroupInfo& aInfo,TInt aScreen,TInt aFullOrdinalPosition) const=0;

	/** Takes a screen number and an ordinal position and returns the window group name.

	If the window group does not exist, the function returns false.

	Note: the ordinal position specified should be the total or full ordinal position of 

	all group windows of all priorities on that screen.

	Note: if the name does not fit into the descriptor provided then it will be truncated.

	@param aWindowName On return, the window group name.

	@param aScreen The screen number.

	@param aFullOrdinalPosition The ordinal position of the window.

	@return ETrue if the window group name exists, EFalse otherwise. */

	virtual TBool WindowGroupName(TPtrC& aWindowName,TInt aScreen,TInt aFullOrdinalPosition) const=0;

	/** Changes the ordinal position and priority of the window group with the specified ID.

	@param aWindowGroupId The window group ID.

	@param aPos The ordinal position to move the window to.

	@param aOrdinalPriority The new ordinal priority of the window.

	@return KErrNotFound if there is no window group with the specified ID, KErrNone otherwise. */

	virtual TInt SetOrdinalPosition(TInt aWindowGroupId,TInt aPos,TInt aOrdinalPriority)=0;

	/** Accessor for window configuration.

	@param aWindowConfig Gets filled in with window configuration details. */

	virtual void WindowConfig(TWindowConfig& aWindowConfig) const=0;

private:

	virtual void Reserved1() const;

	virtual void Reserved2() const;

	virtual void Reserved3() const;

	};

class MAnimGeneralFunctionsEventExtension

/** Event utility functions interface. 

The member functions define the interface for generate repeated key events .

It is not intended for user derivation.

*/

	{

public:

	/** Posts a key event.

	The function is similar to PostKeyEvent() but should be 

used for posting repeated key events. 

	@param aRawEvent The key event.

	@param aRepeats value */

	virtual void PostKeyEvent(const TKeyEvent& aRawEvent, TInt aRepeats) const=0;

private:

	virtual void Reserved1() const;

	virtual void Reserved2() const;

	};

class MAnimWindowFunctions

/** Window utility functions interface. 

The member functions define the interface for querying and manipulating 

the window in which the animation takes place.

You do not have to create an object of this type. The class is implemented 

by the window server, and provides these utility functions to all CWindowAnim 

and CFreeTimerWindowAnim derived classes via the iWindowFunctions pointer.

It is not intended for user derivation.

@publishedAll 

@released */

	{

public:

	/** Activates the graphics context.

	This function should be called to enable drawing in the CAnim-derived classes'

	Command(), CommandReplyL(), Animate(), or FocusChanged() functions.

	Note: this function is called automatically by the animation DLL framework in the 

	Redraw() function. */

	virtual void ActivateGc()=0;

	/** Sets the rectangle that this animation will draw to. 

	This function must be called as part of the initialisation/construction of 

	the CAnim-derived object, i.e. in CAnim::ConstructL(). This is so that the 

	window server knows which area the animation is operating in. Anything that 

	is drawn by the animation outside this rectangle may not be redrawn correctly

	as the window server uses this rectangle to decide when the animation should

	be redrawn.

	@param aRect The rectangle to be drawn to. */

	virtual void SetRect(const TRect &aRect)=0;

	/** Gets the window size.

	@return The window size, in pixels. */

	virtual TSize WindowSize() const=0;

	/** Tests whether to draw the animation. 

	If the window is completely hidden, there is normally no need to draw 

	the animation. However in some conditions the animation should be drawn even 

	if it is obscured. The window server is aware of these cases, and returns 

	ETrue if it is not safe to draw the animation.

	@return True if the window is completely hidden and there is no requirement 

	to continue drawing the animation, otherwise false. */

	virtual TBool IsHidden()=0;

	/** Sets the visibility of the window the animation is drawing to.

	This does the same as RWindowBase::SetVisible().

	@param aState True for visible, false otherwise. */

	virtual void SetVisible(TBool aState)=0;

	/** Forces a redraw of a rectangular part of the window.

	The function causes a redraw message on the part of the window specified, 

	which provides a non-immediate way to do drawing.

	It can be used to redraw the whole of the window, not just the part used by 

	the animation.

	@param aRect The rectangle to be redrawn. These co-ordinates are relative 

	to the origin of the window. */

	virtual void Invalidate(const TRect &aRect)=0;

	/** Gets window information.

	@param aData The window information. */

	virtual void Parameters(TWindowInfo &aData)=0;

	/** Gets the visible region.

	This region is the area of the visible window which 

	is currently unshadowed. If there is not enough memory to calculate this region 

	then aRegion's error flag is set.

	@param aRegion The visible region. */

	virtual void VisibleRegion(TRegion& aRegion)=0;

	//virtual void CopyScreen(CFbsBitGc *aBitmapGc,TRect aRect)=0;

private:

	virtual void Reserved() const;

	virtual void Reserved1() const;

	virtual void Reserved2() const;

	virtual void Reserved3() const;

	};

class MAnimFreeTimerWindowFunctions : public MAnimWindowFunctions

/** Free timer animation utility functions interface.

The class inherits functions from MAnimWindowFunctions, and defines the additional 

interface required for window operations which support animations with their 

own timers.

You do NOT have to create an object of this type. The class is implemented 

by the window server, and provides utility functions to all CFreeTimerWindowAnim 

derived classes via the WindowFunctions() member. 

It is not intended for user derivation.

@publishedAll 

@released */

	{

public:

	/** Deactivates the graphics context. 

	This function is used in the context of a CFreeTimerWindowAnim derived class 

	when writing animation DLLs with their own timer. Within the timer's RunL(), 

	the ActivateGc() function should be called prior to drawing to the window. 

	DeactivateGc() should be called after drawing is finished. */

	virtual void DeactivateGc()=0;

	/** Forces the screen to update. */

	virtual void Update()=0;

private:

	virtual void Reserved3() const;

	};

class MAnimSpriteFunctions

/** Sprite animation utility functions interface.

The interface includes functions for querying and manipulating a sprite.

You do NOT have to create an object of this type. The class is implemented 

by the window server, and provides utility functions to all CSpriteAnim derived 

classes via the CSpriteAnim::iSpriteFunctions pointer. 

It is not intended for user derivation.

@publishedAll 

@released */

	{

public:

	/** Gets sprite member data.

	Each member of the sprite is effectively a bitmap, which is displayed for a 

	different amount of time.

	@param aMember The index of the sprite member for which information is required.

	@return A pointer to the sprite member. */

	virtual TSpriteMember *GetSpriteMember(TInt aMember) const=0;

	/** Redraws part of a sprite.

	Updates a sprite on the screen, possibly after the bitmap for a particular 

	sprite member has been changed.

	Use the	aRect parameter to specify the (small) part of the sprite which has been changed, 

	then any flicker will only occur in this rectangle. 

	A full update used to be required if you had removed pixels from the mask, i.e. made 

	pixels in the sprite transparent when they were not before. If drawing is 

	additive, e.g. you are using a mask or the draw mode is EDrawModePEN, a partial 

	update used to be possible. But current versions of the window-server always do full back to front rendering.

	Note: if the sprite member aMember is not visible then there is no need for a change 

	to the display, so the aRect and aFullUpdate parameters are ignored.

	@param aMember The index of the sprite member that is to be updated.

	@param aRect The part of the sprite member which has changed.

	@param aFullUpdate	Not used. Wserv now always do full back to front rendering. */

	virtual void UpdateMember(TInt aMember,const TRect& aRect,TBool aFullUpdate)=0;

	/** Turns a sprite on or off.

	In effect this makes the sprite bitmap visible.

	@param aActive ETrue to turn sprite on. EFalse to turn it off. */

	virtual void Activate(TBool aActive)=0;

	/** Finishes constructing the sprite.

	It also sets the currently displayed sprite member to zero.

	This function must be called after members change size. */

	virtual void SizeChangedL()=0;

	/** Set the sprite's position.

	@param aPos The new position of the sprite. */

	virtual void SetPosition(const TPoint &aPos)=0;

private:

	virtual void Reserved() const;

public:

	/** Returns the visibility of the sprite.

	A sprite can be seen if it is neither obscured by another window nor hidden.

	@return ETrue if the sprite can be seen, EFalse otherwise. */

	virtual TBool SpriteCanBeSeen() const = 0;

private:

	virtual void Reserved2() const;

	virtual void Reserved3() const;

	virtual void Reserved4() const;

	};

class CAnimGc : public CBitmapContext

/** Animation graphics context. 

An object of this type is linked into CAnim by the window server, which allows 

you to draw to the animation window. The object's functions allow you to set 

and cancel the clipping region, and to draw to the visible window using 

the inherited CBitmapContext functions. 

@publishedAll

@released */

	{

public:

	/** Sets the clipping region.

	Only the parts of the animation which are within the clipping region are drawn.

	@param aRegion The clipping region. */

	virtual TInt SetClippingRegion(const TRegion &aRegion)=0;

	/** Cancels the clipping region.

	@see SetClippingRegion() */

	virtual void CancelClippingRegion()=0;

	};

class CWsAnim; // Forward ref for friend declaration

class CAnim : public CBase , public MEventHandler

/** Server side animated object base interface.

Animations implement this interface, which is called by the window server 

to pass commands from clients, perform a step in the animation, or to pass 

window server events (if required) so that the animation can handle them 

before the application.

The functions are all pure virtual, and must be implemented in 

the derived class to provide server side behaviour. The functions will be 

called by the window server with optional arguments passed in from the client 

side animation class RAnim.

You should derive from CWindowAnim, CFreeTimerWindowAnim or CSpriteAnim, 

depending on whether the animation is to draw to a sprite or a window,

rather than directly from this class.

The derived class is constructed in the DLL factory class CAnimDll::CreateInstanceL() 

function.

The operation to perform an animation step is called by the window server 

on a timer. The timing properties are set through an MAnimGeneralFunctions 

member, which also provides other utility functions. 

@publishedAll 

@released */

	{

public:

	/** Implements client-side initiated commands, returning a value. 

	The window server calls this function in response to application calls to 

	the client side command function RAnim::CommandReplyL(). The arguments passed 

	to the function by the window server are the same as were used on the client 

	side function call.

	This function returns values to the client side, and should be used to return 

	error codes for commands which might leave.

	@param aOpcode Opcode understood by the class.

	@param aArgs Arguments packaged on the client side, for example as a struct 

	of a type determined by the aOpcode argument. These mirror the aArgs argument 

	passed in to RAnim::CommandReply().

	@return Value passed back to client side function when this function completes. 

	Typically this would be KErrNone or another of the system-wide error codes. 

	However any value may be returned to the client side.

	@see RAnim */

	virtual TInt CommandReplyL(TInt aOpcode, TAny *aArgs)=0;

	/** Implements client-side initiated commands. 

	The window server calls this function in response to application calls to 

	the client side command function RAnim::Command(). The arguments passed to 

	the function by the window server are the same as were used on the client 

	side function call.

	Because this function does not return errors, it is not safe for commands 

	which might leave.

	@param aOpcode Opcode understood by the class

	@param aArgs Arguments packaged on the client side, for example as a struct 

	of a type determined by the aOpcode argument. These mirror the aArgs argument 

	passed in to RAnim::Command().

	@see RAnim */

	virtual void Command(TInt aOpcode, TAny *aArgs)=0;

	/** Main animation function, called by the window server. 

	The drawing code which implements a given animation should be provided here.

	This function is called at a frequency determined by the SetSync() helper 

	function. Note that if sync is not set, then this function will never be 

	called. This effect can be exploited to use the animation framework, with 

	its server side speed, for what are strictly not animations, e.g. for streaming 

	video images.

	The aDateTime parameter will be null if the current time (as determined by 

	the window server) matches the time implied by the sync period, modulo normalisation, 

	otherwise it will contain a valid (non-normalised) time.

	Normalisation is to some specified granularity, for example if one minute 

	is specified as the animation frequency, then in effect the window server 

	will decide whether the implied time is correct to the minute, but not to 

	the second.

	Implied time is the time implied by the (normalised) actual time of the previous 

	animation call plus the sync interval. For example if the last call was at 

	time 't' and the sync interval is 1 second then if the time at this call 

	is t + 1 second, then actual time and implied time match and the value placed 

	into aDateTime will be NULL.

	Cases in which the two may not match include, for example, system time having 

	been reset between animation calls (perhaps British Summer Time or other daylight 

	saving time has just come into effect). The intention is that when system 

	time changes, a mechanism is provided to alert the animation code and allow 

	it to reset itself. The assumption is that somewhere in its initialisation 

	code, the animation will have performed a CAnimFunctions utility call to set 

	a base time, which is then implicitly tracked by incrementing by a suitable 

	interval; when aDateTime is non-NULL after a call to Animate(), base time 

	should be reset.

	@param aDateTime Null if the current time w.r.t. the window server matches 

	the time implied by the synch period. Otherwise a valid (non-normalised) time. */

	virtual void Animate(TDateTime *aDateTime)=0;

	virtual void HandleNotification(const TWsEvent& /*aEvent*/) {};

private:

	inline CAnim() {}

	virtual void Reserved1() const {};

	virtual void Reserved2() const {};

	virtual void Reserved3() const {};

protected:

	/** Pointer to a class containing functions implemented by the window server. 

	These are available to any CAnim derived class.

	Note that this value is automatically set for you by the animation framework. 

	You do not need to assign a value to this pointer. 

	@publishedAll

	@released	*/

	MAnimGeneralFunctions *iFunctions;

	friend class CWsAnim;

	friend class CWindowAnim;

	friend class CSpriteAnim;

	};

class CWindowAnim : public CAnim

/** Window animation interface. 

This interface is provided to create animations other than sprites. A window 

animation can be provided by deriving from this class.

The interface inherits from CAnim and has access to its functions. It additionally 

can access an interface for querying and manipulating the window in which 

the animation takes place, using its iWindowFunctions member.

The derived class is constructed in the DLL factory class CAnimDll::CreateInstanceL().

@publishedAll

@released 

@see CFreeTimerWindowAnim

@see CSpriteAnim */

	{

public:

	/** Server side construction and initialisation of an animation class. 

	Note: the aHasFocus argument allows the animation to start in a known focus state. 

	For example, an animation may or may not have focus, depending on how it was 

	started. Together with the FocusChanged() function, this allows an animation 

	to always know its focus state.

	@param aArgs Packaged arguments which may be required during construction. 

	These are transferred from the aParams argument of the client side constructor's 

	RAnim::Construct().

	@param aHasFocus Specifies whether or not the animation has window server focus. */

	virtual void ConstructL(TAny *aArgs, TBool aHasFocus)=0;

	/** Redraws the objects.

	The function is called by the window server when it needs to redraw the object. 

	The object must provide all the low level drawing code. */

	virtual void Redraw()=0;

	/** Notifies change of focus.

	The function is called by the window server to notify a change of focus, 

	allowing the animation code to track whether it does or does not have focus, 

	and to change its appearance accordingly.

	@param aState Indicates whether the focus has or has not changed. */

	virtual void FocusChanged(TBool aState)=0;

protected:

	/** Protected constructor.

	Prevents objects of this class being directly constructed. */

	inline CWindowAnim() {}

private:

	virtual void ReservedW1() const {};

	virtual void ReservedW2() const {};

protected:

	/** Pointer to a class containing functions implemented by the window server.

	These are available to any CWindowAnim-derived class.

	Note that this and the iGc pointer are automatically set for you by the 

	animation framework - you do not need to assign a value to them.*/

	MAnimWindowFunctions *iWindowFunctions;

	/** Pointer to the graphics context. */

	CAnimGc *iGc;

	friend class CWsAnim;

	};

class CFreeTimerWindowAnim : public CWindowAnim

/** Free timer animation interface.

This interface allows animations to have their own timers or other active 

objects, and to draw to the window when the timer completes. The implication 

of this is that animations derived from this class can have an extremely short 

user-defined time between calls to the Animate() function, unlike the 

other animation classes, which are tied to the (approximately) half second 

flash cycle.

The interface inherits from CWindowAnim and has access to its functions. It 

additionally can access functions declared in the MAnimFreeTimerWindowFunctions 

interface, using WindowFunctions(). 

In order to draw to the window inside the RunL() of your own timer, you will