diff -r 000000000000 -r 2f259fa3e83a lafagnosticuifoundation/bmpanimation/inc/bmpansrv.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/lafagnosticuifoundation/bmpanimation/inc/bmpansrv.h	Tue Feb 02 01:00:49 2010 +0200
@@ -0,0 +1,311 @@
+// 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
+