// Copyright (c) 1999-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:
// Definition of classes related to Anim DLL's
// 
//

#ifndef __ANIM_H__
#define __ANIM_H__

#include <e32std.h>
#include <w32adll.h>
#include "server.h"
#include "sprite.h"

class CWsAnimDll : public CWsObject
	{
public:
	static void InitStaticsL();
	static void DeleteStatics();
public:
	CWsAnimDll(CWsClient *owner);
	~CWsAnimDll();
	TInt CreateInstanceL(TUint32 aHandle, TInt aType, TAny *aArgs, TBool aIsWindow);
	void LoadL(const TDesC &aDllName);
	void CommandL(TInt aOpcode, const TAny *aCmdData);
	void Remove(TInt aHandle);
	inline TInt AnimObjectHandle(CWsAnim *aAnimObject) const;
	inline CWsAnim* AnimObjectL(TInt aAnimHandle) const;
	
private:
	TInt doCreateInstanceL(CWsAnim *aInstance, TInt aType, TAny *aArgs, TBool aIsWindow);
private:
	static CObjectConIx *AnimObjectConIx;
private:
	CObjectCon *iInstanceCon;
	CObjectIx *iInstanceIndex;
	CAnimDll *iAnimDll;
	RLibrary iAnimLib;
	
public:
	TSglQueLink iQue;
	};
	
class CWsAnimGc;

class CWsAnim : public CObject, public MAnimGeneralFunctions, public MAnimGeneralFunctionsWindowExtension,
													public MAnimFreeTimerWindowFunctions, public MAnimSpriteFunctions, public MAnimGeneralFunctionsEventExtension,
													public MWsWindowTreeNode
	{
public:
	~CWsAnim();
	void RedrawWindowAnimL(const TTime& aTimeNow, MWsGraphicsContext* aGc, const TRegion* aRegion);
	void AnimateSpriteAnimL(const TTime& aTimeNow);
	void UserDeactivateAnimGc();
	static void WindowClosing(CWsAnim *aWsAnim);
	static void CloseAnim(CWsAnim *aWsAnim);
	TRect BestRect() const;
	void FocusChanged(TBool aNewFocusState);
	void SetMessage(const RMessagePtr2* aMessage);
	TInt CommandReply(TInt aOpcode, TAny* aArgs);
	void SessionPanic() const;
	void Panic() const;
	void Panic(TClientPanic aPanic) const;
	inline CWsAnim * Next();
	inline CWsClientWindow* ClientWindow() const;
	void SendState(MWsWindowTreeObserver& aWindowTreeObserver) const;

private:
	CWsAnim(CWsAnimDll *aDll);
	void Connect(CWsClientWindow *aWindow);
	void Connect(CWsSprite *aSprite);
	void ConstructL(CAnim *aAnim, TAny *aArgs, CWsAnimDll *aAnimDll, TBool aIsWindow);
	inline CAnim *Anim() const;
	const TRect& Rect() const;
	
// Functions from MAnimGeneralFunctions
	TDateTime SystemTime() const;
	TBool FlashStateOn() const;				// Return ETrue if in the on part of the flash cycle

	const CFbsScreenDevice *ScreenDevice();						// Pointer to screen device
	CFbsBitmap *DuplicateBitmapL(TInt aHandle);
	CFbsFont *DuplicateFontL(TInt aHandle);
	void CloseFont(CFbsFont *);
	TAnimSync Sync() const;					// Return the current sync mode
	void Animate(TDateTime *aDateTime);		// Trigger a call to the DLL's Animate function
	void SetSync(TAnimSync aSyncMode);
	void SetInterval(TInt aInterval);		// Set the regular repeat interval, does not affect the current countdown
	void SetNextInterval(TInt aInterval);	// Sets the interval to the next Animate, after that it will fall back to the usual rate
	const RThread &Client();				// Return a reference to the calling clients thread
	void ReplyBuf(const TDesC8 &aDes);
	void ReplyBuf(const TDesC16 &aDes);
	void GetRawEvents(TBool aGetEvents) const;	// Raw events are passed to CAnim::OfferRawEventL
	void PostRawEvent(const TRawEvent &aRawEvent) const;
	void PostKeyEvent(const TKeyEvent &aRawEvent) const;
	const RMessagePtr2* Message();
	TAny* ExtendedInterface(TInt aInterface);
	TInt RegisterForNotifications(TUint32 aNotifications);

// Functions from MAnimGeneralFunctionsWindowExtension
	TInt Screens() const;
	TInt FocusScreens() const;
	void SetFocusScreen(TInt aScreenNo);
	TInt WindowGroups(TInt aScreen) const;
	TBool WindowGroupInfo(TWindowGroupInfo& aInfo,TInt aScreen,TInt aWindowGroup) const;
	TBool WindowGroupName(TPtrC& aWindowName,TInt aScreen,TInt aWindowGroup) const;
	TInt SetOrdinalPosition(TInt aWindowGroupId,TInt aPos,TInt aOrdinalPriority);
	void WindowConfig(TWindowConfig& aWindowConfig) const;	
// Functions from MAnimWindowFunctions
	void ActivateGc();	// Activate the GC to enable drawing in a command or animate function
	void Invalidate(const TRect &aRect);
	void Parameters(TWindowInfo &aData);
	void VisibleRegion(TRegion& aRegion);
 	TSize WindowSize() const;				// Return the window size
	TBool IsHidden();
	void SetVisible(TBool aState);
	void SetRect(const TRect &aRect);		// Sets the rect that this instance wants to draw to.
// Functions from MAnimFreeTimerWindowFunctions
	void DeactivateGc();					// Deactivate the GC after drawing from our own RunL
	void Update();
// Functions from MAnimSpriteFunctions
	TSpriteMember *GetSpriteMember(TInt aMember) const;	//Returns sprite member data
	void UpdateMember(TInt aMember,const TRect& aRect,TBool aFullUpdate);		//redraw of part of a sprite
	void Activate(TBool aActive);		// Turn sprite on or off
	void SizeChangedL();
	void SetPosition(const TPoint &aPos);			//Change the positon of the sprite
	TBool SpriteCanBeSeen() const;
// Functions from MAnimGeneralFunctionsEventExtension
	void PostKeyEvent(const TKeyEvent& aRawEvent,TInt aRepeats) const; //Repeated key events
// Functions from MWsWindowTreeNode
	MWsWindowTreeNode::TType NodeType() const;
	const MWsWindow* Window() const;
	const MWsSprite* Sprite() const;
	const MWsStandardTextCursor* StandardTextCursor() const;
	const MWsWindowGroup* WindowGroup() const;
	const MWsWindowTreeNode* ParentNode() const;

	void ScheduleSelf(const TTimeIntervalMicroSeconds& aFrom);
	void AnimateL(const TTime& aTimeNow, TInt& aFrame, TInt64& aAdjustedStart);
	void RedrawWindowAnimL(MWsGraphicsContext* aGc, const TRegion* aRegion);
	void ReSchedule(const TTime& aTimeNow, const TInt& aFrame, const TInt64& aAdjustedStart);

private:
	CWsClient *iClient;
	TTimeIntervalMicroSeconds iInterval;
	TAnimSync iAnimSync;
	/* Linked list of animated objects attached to a window */
	CWsAnim *iNextWin;
	union 
		{
		CWindowAnim* iWindowAnim; 
		CSpriteAnim* iSpriteAnim; 
		} iAnim;
	CWsAnimGc *iAnimGc;
	CWsAnimDll *iAnimDll;
	CWsClientWindow *iWindow;
	TRect iRect;
	CWsSprite *iSprite;
	const RMessagePtr2* iMessage;
	TWindowInfo::TRegionPair* iRedrawRegionPair;
	friend class CWsAnimDll;
	friend class DllAnimator;
	mutable TBool iAnimAddedInHandler;
	TTime iStartTime;
	TInt iLastFrame;
	enum TFlags
		{
		/** ETrue if this anim accepts advanced pointer events
		   (TRawEvents with pointer number, pointer pressure and proximity info) */
		EAdvancedPointersEnabled,
		EFlashOn,
		EWinAnimConstructed,
		/** This flag is set when this anim is called in the context of CScreenRedraw::OnAnimation
		    i.e. when the screen is in the process of sending a new frame to the display hardware. */
		EInRedraw,
		};
	TBitFlags iBitFlags;
	};

class CAnimFbsFont;

class CWsAnimGc : public CAnimGc
	{
public:
	CWsAnimGc(CWsAnim& aWsAnim);
	~CWsAnimGc();
//
	void Activate(const TRegion* aRegion, MWsGraphicsContext* aGc);
	void Deactivate();
	TBool IsActive() const;
	void UserActivate();
	void UserDeactivate();
// From CGraphicsContext
	virtual CGraphicsDevice* Device() const;
	virtual void SetDrawMode(TDrawMode aDrawingMode);
	virtual void SetClippingRect(const TRect& aRect);
	virtual void CancelClippingRect();
	virtual void CancelClippingRegion();
	virtual void UseFont(const CFont *aFont);
	virtual void DiscardFont();
	virtual void SetUnderlineStyle(TFontUnderline aUnderlineStyle);
	virtual void SetStrikethroughStyle(TFontStrikethrough aStrikethroughStyle);
	virtual void SetWordJustification(TInt aExcessWidth,TInt aNumGaps);
	virtual void SetCharJustification(TInt aExcessWidth,TInt aNumChars);
	virtual void SetPenColor(const TRgb &aColor);
	virtual void SetPenStyle(TPenStyle aPenStyle);
	virtual void SetPenSize(const TSize& aSize);
	virtual void SetBrushColor(const TRgb &aColor);
	virtual void SetBrushStyle(TBrushStyle aBrushStyle);
	virtual void SetBrushOrigin(const TPoint &aOrigin);
	virtual void UseBrushPattern(const CFbsBitmap *aBitmap);
	virtual void DiscardBrushPattern();
	virtual void DrawArc(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd);
	virtual void DrawLine(const TPoint &aPoint1,const TPoint &aPoint2);
	virtual void DrawLineTo(const TPoint &aPoint);
	virtual void DrawLineBy(const TPoint &aPoint);
	virtual void DrawPolyLine(const CArrayFix<TPoint> *aPointList);
	virtual void DrawPolyLine(const TPoint* aPointList,TInt aNumPoints);
	virtual void DrawPie(const TRect &aRect,const TPoint &aStart,const TPoint &aEnd);
	virtual void DrawEllipse(const TRect &aRect);
	virtual void DrawRect(const TRect &aRect);
	virtual void DrawRoundRect(const TRect &aRect,const TSize &aCornerSize);
	virtual void Clear(const TRect &aRect);
	virtual void Clear();
	virtual TInt DrawPolygon(const CArrayFix<TPoint> *aPointList,TFillRule aFillRule);
	virtual TInt DrawPolygon(const TPoint* aPointList,TInt aNumPoints,TFillRule aFillRule=EAlternate);
	virtual void DrawBitmap(const TPoint &aTopLeft, const CFbsBitmap *aSource);
	virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aSource);
	virtual void DrawBitmap(const TRect &aDestRect, const CFbsBitmap *aSource, const TRect &aSourceRect);
	virtual void DrawBitmapMasked(const TRect &aDestRect, const CFbsBitmap *aBitmap, const TRect &aSrcRect, const CFbsBitmap* aMaskBitmap, TBool aInvertMask);
	virtual void DrawText(const TDesC &aString,const TPoint &aPosition);
	virtual void DrawText(const TDesC &aString,const TRect &aBox,TInt aBaselineOffset,TTextAlign aHoriz=ELeft,TInt aLeftMrg=0);
	virtual void MoveTo(const TPoint &aPoint);
	virtual void MoveBy(const TPoint &aPoint);
	virtual void Plot(const TPoint &aPoint);
	virtual void SetOrigin(const TPoint &aPoint);
	virtual void BitBlt(const TPoint &,const CFbsBitmap *aBitmap);
	virtual void BitBlt(const TPoint &,const CFbsBitmap *aBitmap,const TRect &);
	virtual void BitBltMasked(const TPoint& aPoint,const CFbsBitmap* aBitmap,const TRect& aSourceRect,const CFbsBitmap* aMaskBitmap,TBool aInvertMask);
	virtual void CopyRect(const TPoint& aOffset,const TRect& aRect);
	virtual void Reset();
// Extra command defined in CBitmapContext
	virtual void SetFaded(TBool aFaded);
	virtual void SetFadingParameters(TUint8 aBlackMap,TUint8 aWhiteMap);

	virtual TInt SetClippingRegion(const TRegion &aRegion);	
	virtual TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CFbsBitmap* aSrcBmp, const TRect& aSrcRect, const CFbsBitmap* aAlphaBmp,	const TPoint& aAlphaPt);	
	virtual void MapColors(const TRect &aRect,const TRgb *aColors,TInt aNumPairs,TBool aMapForwards);
	virtual void DrawTextVertical(const TDesC& aText,const TPoint& aPos,TBool aUp);
	virtual void DrawTextVertical(const TDesC& aText,const TRect& aBox,TInt aBaselineOffset,TBool aUp,TTextAlign aVert=ELeft,TInt aMargin=0);
	
private:
	void CloseCurrentFont();
	virtual void DrawBitmapMasked(const TRect& /*aDestRect*/,const CWsBitmap* /*aBitmap*/,const TRect& /*aSrcRect*/,const CWsBitmap* /*aMaskBitmap*/, TBool /*aInvertMask*/);
	TInt AlphaBlendBitmaps(const TPoint& aDestPt, const CWsBitmap* aSrcBmp,	const TRect& aSrcRect, const CWsBitmap* aAlphaBmp,	const TPoint& aAlphaPt);
private:
	CWsAnim& iOwningWsAnim;
	MWsGraphicsContext* iGc;
	TBool iUserActive;
	const TRegion *iBaseRegion;	// Base clipping region provided on activation
	TBool iUseDrawingRegion;	// Indicates that the user has set a drawing region
	RWsRegion iDrawingRegion;	// Drawing region provided by the user (in screen coordinates)
	TRect iClippingRect;		// Clipping rectangle (in screen coordinates)
	CAnimFbsFont *iFont;
	};

//
// inlines			//
//

inline CAnim *CWsAnim::Anim() const
	{
	if(iWindow)
		return iAnim.iWindowAnim;
	else
		return iAnim.iSpriteAnim;
	}
inline TInt CWsAnimDll::AnimObjectHandle(CWsAnim *aAnimObject) const
	{return(iInstanceIndex->At(aAnimObject));}
inline CWsAnim* CWsAnimDll::AnimObjectL(TInt aAnimHandle) const
	{return STATIC_CAST(CWsAnim*,iInstanceIndex->AtL(aAnimHandle));}
inline CWsAnim* CWsAnim::Next()
	{return iNextWin;}
inline CWsClientWindow* CWsAnim::ClientWindow() const
	{return iWindow;}
#endif