// Copyright (c) 2006-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:
// CWsSprite and associated classes definitions
// 
//

#ifndef __SPRITE_H__
#define __SPRITE_H__

#include "server.h"
#include "window.h"
#include <graphics/wsgraphicscontext.h>
#include <babitflags.h>

//
// CWsSpriteMember
//
class CWsSpriteMember : public CBase
	{
public:
	CWsSpriteMember();
	~CWsSpriteMember();
	TBool SetL(const TCmdSpriteMember &aCmdSpriteMember);
public:
	CFbsBitmap *iBitmap;
	CFbsBitmap *iMaskBitmap;
	TBool iInvertMask;
	CGraphicsContext::TDrawMode iDrawMode;
	TPoint iOffset;
	TTimeIntervalMicroSeconds32 iInterval;
	};

//
// CWsSpriteBase
//
class CWsSpriteBase : public CWsScreenObject, public MWsWindowTreeNode, public MWsSprite
	{
protected:
	enum {ENoChildPriorityBoost=1,EPointerPriorityBoost=2};
public:
	friend class CWsSpriteTimer;
	friend class CWsAnim;
	friend class TCursorSprite;
public:
	static void InitStaticsL();
	static void DeleteStatics();

	CWsSpriteBase(CWsClient *aOwner, WH_HANDLES aType);
	~CWsSpriteBase();

	//from MWsSprite
	TRect Rect() const;
	TSpriteType SpriteType() const;
	
	TPoint Pos() const;
	void SetPos(const TPoint &Pos);
	void Deactivate();
	void DisconnectGroupWin();
	void TimerExpired();
	void Activate();
	inline TBool IsActive() const;
	inline TBool IsFlashingEnabled() const;
	inline TBool AdvancedPointersEnabled() const;
	TBool CanBeSeen() const;
	CWsSpriteBase * Next() { return iNext; }
	void SetNext(CWsSpriteBase * aNext) { iNext = aNext; }
	void CalcRedrawRegion(const TRegion& aSourceRegion, TRegion& aTarget) const;
	void Redraw(MWsGraphicsContext * aGc, const TRegion& aRegion);
	void ForceRedraw();
	inline const CWsWindow* Win() const;
	inline CWsWindow* Win();
	TBool IsActivated() const;
	inline TBool HasSpriteMember() const { return  iMembers->Count(); }
	void SendState(MWsWindowTreeObserver& aWindowTreeObserver) const;
	
public: // 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;

protected:
	void ConstructL(TUint aFlags, CWsWindow *aWindow);
	void CommandL(TInt aOpcode, const TAny *aCmdData);
	void AppendMemberL(const TCmdSpriteMember &aCmdSpriteMember);
	virtual void CompleteL();
	void SetMember(TInt aIndex);
	void CheckSizesL();
	TBool UpdateMemberL(CWsSpriteMember *aMember, const TCmdSpriteMember &aCmdSpriteMember);
	void QueueDeltaTimer();
	void NotifyExtentChanged() const;
	enum TInternalFlags 
		{
		EFloating, 
		EClipSprite,
		EHasAnimation,
		EDirty
		};
	inline void SetIsFloating(TBool aIsFloating);
	inline TBool IsFloating() const;
	inline void SetClipSprite(TBool aClipSprite);
	inline TBool ClipSprite() const;
public:	
	inline void SetHasAnimation(TBool aValue);
	inline TBool HasAnimation() const;
	inline void SetDirty(TBool aValue);
	inline TBool IsDirty() const;

protected:
	CWsWindow *iWin;
	CWsWindowGroup *iGroupWin;
	TPoint iBasePos;
	TPoint iPos;		// Combined position and offset
	TSize iMaxSize;
	TSize iSize;
    TUint iFlags;
	TRect iClipRect;
	CArrayPtrFlat<CWsSpriteMember> *iMembers;
	TInt iCurIndex;
	TWsDeltaTimerEntry iDeltaTimerEntry;
	TDisplayMode iDisplayMode;
	TPoint iClipOffset;
	TSize iClipSize;
	CWsSpriteBase * iNext; // linked list per window
	TBitFlags iInternalFlags;
//
// Static data
//
	static CWsDeltaTimer *iDeltaTimer;
	};

/** Sprite flags.

These can be combined with each other and TSpriteFlags using a bit-wise OR operation.

@internalComponent
@released
@see RWsPointerCursor::Construct()
@see RWsSprite::Construct() */
enum TSystemSpriteFlags
	{
	ESpriteNonSystemFlags=0x0000FFFF,
	ESpriteSystemFlags=	  0xFFFF0000,
	ESpritePointer=0x10000,
	ESpriteOOM=0x20000,
	ESpriteDisabled=0x40000,
	ESpriteActive=0x80000,
	ESpriteDirty=0x100000
	};

//
// CWsSpriteBase inlines
//
inline TBool CWsSpriteBase::IsActive() const
	{
	return (iFlags&ESpriteActive);
	}
inline TBool CWsSpriteBase::IsFlashingEnabled() const
	{
	return (iFlags&ESpriteFlash);
	}
inline const CWsWindow* CWsSpriteBase::Win() const
	{
	return iWin;
	}
inline CWsWindow* CWsSpriteBase::Win()
	{
	return iWin;
	}
/*
@return ETrue if this sprite belongs to window which has Advanced Pointer Support enabled.
*/
inline TBool CWsSpriteBase::AdvancedPointersEnabled() const
	{
	return iWin ? iWin->AdvancedPointersEnabled() : EFalse;
	}

inline void CWsSpriteBase::SetIsFloating(TBool aIsFloating) 
	{ 
	iInternalFlags.Assign(EFloating, aIsFloating); }	

inline TBool CWsSpriteBase::IsFloating() const 
	{
	return iInternalFlags.IsSet(EFloating);
	}

inline void CWsSpriteBase::SetClipSprite(TBool aClipSprite) 
	{ 
	iInternalFlags.Assign(EClipSprite, aClipSprite);
	}

inline TBool CWsSpriteBase::ClipSprite() const 
	{ 
	return iInternalFlags.IsSet(EClipSprite);
	}

inline void CWsSpriteBase::SetHasAnimation(TBool aValue) 
	{
	iInternalFlags.Assign(EHasAnimation, aValue);
	}

inline TBool CWsSpriteBase::HasAnimation() const
	{
	return iInternalFlags.IsSet(EHasAnimation);
	}

inline void CWsSpriteBase::SetDirty(TBool aValue)
	{
	iInternalFlags.Assign(EDirty, aValue);
	}

inline TBool CWsSpriteBase::IsDirty() const	
	{ 
	return iInternalFlags.IsSet(EDirty);
	}	
	

//
// CWsSprite
//
class CWsSprite : public CWsSpriteBase
	{
public:
	CWsSprite(CWsClient *aOwner);
	~CWsSprite();
	void ConstructL(const TWsClCmdCreateSprite &aParams);
	void CommandL(TInt aOpcode, const TAny *aCmdData);
	void CompleteL();
	void Update(TInt aMember,TRect aRect,TBool aFullUpdate);
public:
	CWsAnim *iAnim;	// The AnimDLL on this sprite if there is one.
	};

//
// CWsSpriteManager
//
class CWsSpriteManager : public CBase
	{
public:
	~CWsSpriteManager();
	static CWsSpriteManager* NewL();
	void DrawFloatingSprites(MWsGraphicsContext* aGc,const TRegion& aRegion);
	void AddFloatingSprite(CWsSpriteBase* aSprite);
	void RemoveFloatingSprite(CWsSpriteBase* aSprite);
	void Schedule(CWsSpriteBase* aSprite, TRect* aRect = 0);
	TFlashState CurrentSpriteFlashState(const CWsSpriteBase* aSprite) const;
	TInt SpriteCount() const { return iFloatingSprites.Count(); }
	TTimeIntervalMicroSeconds NextCursorFlashStateChange() const;
	void CalcFloatingSpriteRgn( TRegion& aResultRgn, const TRect& aDefaultRect );
	void SendState(MWsWindowTreeObserver& aWindowTreeObserver) const;
private:
	CWsSpriteManager();
	void ConstructL();
	TTimeIntervalMicroSeconds NextSpriteFlashStateChange(const CWsSpriteBase* aSprite) const;
	TTimeIntervalMicroSeconds CalculateTimeToNextFlash(TTimeIntervalMicroSeconds aTime) const;
private:
	RPointerArray<CWsSpriteBase> iFloatingSprites;
	};
#endif