// Copyright (c) 1997-2010 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) && (iIndex < Count()) && 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

