// Copyright (c) 1997-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:

//

/**

 @file

 @internalComponent 

*/

#if !defined(__BMPANSRV_H__)

#define __BMPANSRV_H__

#include <e32std.h>

#include <w32adll.h>

#include "bmpanconsts.h"

#include "bmpancli.h"

#include <e32math.h>

enum TBitmapAnimServerPanic

	{

	EAnimationServerPanicIndexOutOfRange,

	EAnimationServerPanicFrameIntervalNegative

	};

// For packaging the new animation position offset

struct SBitmapAnimNewPosition

	{

	TPoint iPosition;

	};

// For packaging the new animation index

struct SBitmapAnimIndexFrame

	{

	TInt iIndex;

	};

// For packaging the number of cycles

struct SBitmapAnimNumberOfCycles

	{

	TInt iCycles;

	};

/**

 TFrameData

 This class is used for packaging the data of one frame.

*/

class TFrameData

	{

public:

	TInt iBitmapHandle;

	TInt iMaskBitmapHandle;

	TPoint iPosition;

	TInt iIntervalInMilliSeconds;			// the time is expressed in ms

	};

/**

 TBmpAnimAttributes

 This class is used for packaging the attriutes of the animation.

*/

class TBmpAnimAttributes

	{

public:

	TBool iFlash;

	TInt iFrameIntervalInMilliSeconds;

	CBitmapAnimClientData::TPlayMode iPlayMode;

	};

/**

 class MBitmapAnimTimerObserver

*/

class MBitmapAnimTimerObserver

	{

public:

	virtual void DisplayNextFrameL()=0;

	};

/**

 class CBitmapAnimTimer

 This class is used to determine when to swap the current frame with the next one.

*/

class CBitmapAnimTimer : public CTimer

	{

public:

	~CBitmapAnimTimer();

	static CBitmapAnimTimer* NewL(MBitmapAnimTimerObserver* aObserver);

	void RunL();

private:

	CBitmapAnimTimer(MBitmapAnimTimerObserver* aObserver);

	void ConstructL();

private:

	MBitmapAnimTimerObserver* iAnimate;

	};

/**

 class MBitmapAnimFlashTimerObserver

*/

class MBitmapAnimFlashTimerObserver

	{

public:

	virtual void FlashFrame(TBool aFlash)=0;

	};

/**

 class CBitmapAnimFlashTimer

*/

class CBitmapAnimFlashTimer : public CTimer

	{

public:

	~CBitmapAnimFlashTimer();

	static CBitmapAnimFlashTimer* NewL(MBitmapAnimFlashTimerObserver* aObserver);

	void DoCancel();

	void RunL();

private:

	CBitmapAnimFlashTimer(MBitmapAnimFlashTimerObserver* aObserver);

	void ConstructL();

private:

	MBitmapAnimFlashTimerObserver* iAnimate;

	TBool iFlash;

	};

/**

 class CBitmapAnimFrameData

 This class encapsulates the information of one frame.

*/

class CBitmapAnimFrameData : public CBase

	{

public:

	static CBitmapAnimFrameData* NewL();

	static CBitmapAnimFrameData* NewLC();

	~CBitmapAnimFrameData();

	void FillFrameDataL(const TFrameData& aFrameDataArg);

	void CheckAndCreateBitmapsL();

private:

	CBitmapAnimFrameData();

	void InitialiseMembers();

public:

	CFbsBitmap* iBitmap;

	CFbsBitmap* iMaskBitmap;

	TPoint iPosition;

	TTimeIntervalMicroSeconds32 iInterval;

	};

/**

 class CBitmapAnim

 This class encapsulates the enire animation: attributes and frames.

*/

class CBitmapAnim : public CFreeTimerWindowAnim, MBitmapAnimTimerObserver//, MBitmapAnimFlashTimerObserver

	{

public:

	~CBitmapAnim();

	static CBitmapAnim* NewL();

private:

	CBitmapAnim();

private:

	enum TAnimateFlags

		{

//	State

		ERunning				= 0x0001,

		EFlashing				= 0x0002,

		EFrozen					= 0x0004,

//	Play mode

		EPlayModeCycle			= 0x0010,

		EPlayModeBounce			= 0x0020,

		EPlayForwards			= 0x0040,

		EPlayBackwards			= 0x0080,

//	General

		EFlash									= 0x0100,

		ENoBitmapWindowRestoring				= 0x0800,

		EDisplayLastFrameWhenFinished			= 0x4000,

		};

private: //Pure Virtual function from CAnim

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

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

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

	virtual void Animate(TDateTime* aDateTime);

	virtual void Redraw();

	virtual void FocusChanged(TBool aState);

private: //Pure Virtual function from MEventHandler

	virtual TBool OfferRawEvent(const TRawEvent &aRawEvent);

private: //Pure Virtual function from MBitmapAnimTimerObserver

	virtual void DisplayNextFrameL();

private: //Pure Virtual function from MBitmapAnimFlashTimerObserver

	virtual void FlashFrame(TBool aFlash);

private:

	void AppendFrameL(const TFrameData& aFrameData);

	inline TInt Count() const;

	void DisplayFrame(TInt aPreviousIndex=-1);

	void DrawBitmap(TInt aPreviousIndex=-1, TBool aRedraw=EFalse);

	inline TBool IsFrameDisplayable() const;

	inline TBool IsRunning() const;

	inline TBool IsFrozen() const;

	void ResetAnimation();

	void ClearFrameNow(TInt aIndex);

	void RenderFrameBackground(TInt aIndex);

	TRect CalcFrameRect(TInt aIndex);

	void SetBackgroundFrameL(TFrameData aFrameDataArg);

	void SetFlash(TBmpAnimAttributes aFlash);

	void SetFrameInterval(TBmpAnimAttributes aFrameInterval);

	TInt SetIndexFrame(SBitmapAnimIndexFrame aIndexFrame);

	void SetNumberOfCycles(SBitmapAnimNumberOfCycles aNumberOfCycles);

	void SetPlayMode(TBmpAnimAttributes aPlayMode);

	void SetPosition(SBitmapAnimNewPosition aNewPosition);

	void StartAnimationL();

	void StopAnimation();

	void UpdateCurrentIndex();

	inline TRect WindowRect() const;

	static TBool FrameNeedsRedrawing(const TRegion* aRedrawRegion, TRect aFrameScreenRect);

	void ResetFrameArray();

	void ClearFrameData();

private:

	RPointerArray<CBitmapAnimFrameData> iBitmapAnimFrameDataArray;

	CBitmapAnimTimer* iAnimTimer;

	CBitmapAnimFlashTimer* iFlashTimer;

	CBitmapAnimFrameData* iBackgroundFrame;

//

	TInt iDummy;

	TInt iFlags;

	TInt iIndex;

	TInt iNumberOfCycles;

	TPoint iPosition;

	TInt iWindowConfig;

	TTimeIntervalMicroSeconds32 iFrameInterval;	

	};

// Returns the number of frames store in the frame array.

inline TInt CBitmapAnim::Count() const

	{ return iBitmapAnimFrameDataArray.Count(); }

// Returns ETrue every time the index frame is valid, otherwise it returns EFalse.

inline TBool CBitmapAnim::IsFrameDisplayable() const

	{ return ( (iIndex >= 0) && iBitmapAnimFrameDataArray[iIndex]->iBitmap ); }

// Returns ETrue if the animation is running, otherwise it returns EFalse.

inline TBool CBitmapAnim::IsRunning() const

	{ return iFlags&ERunning; }

//Returns ETrue if the animation is frozen (app is not in the foreground)

inline TBool CBitmapAnim::IsFrozen() const

{ return iFlags&EFrozen; }

// Returns the available window rect.

inline TRect CBitmapAnim::WindowRect() const

	{ return TRect(TPoint(0, 0), iWindowFunctions->WindowSize()); }

/**

 CBitmapAnimDll class

*/

class CBitmapAnimDll : public CAnimDll

	{

public:

	CBitmapAnimDll();

	virtual CAnim* CreateInstanceL(TInt aType);

	};

/**

 global functions

*/

GLREF_C void Panic(TBitmapAnimServerPanic aReason);

#endif