// 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 event queues

 // 

 //

 #if !defined(__EVQUEUE_H__)

 #define __EVQUEUE_H__

 #include <e32std.h>

 #include <e32base.h>

 #include <w32std.h>

 #include <graphics/wsgraphicdrawerinterface.h>

 class CWsClient;

 class CWsWindowRedraw;

 class CWsGraphicDrawer;

 enum TEventQueueWalkRet

 	{

 	EEventQueueWalkOk,

 	EEventQueueWalkDeleteEvent,

 	EEventQueueWalkRestart,

 	};

 class TWsEvent;

 typedef TEventQueueWalkRet (*EventQueueWalk)(TAny *aPtr, TWsEvent *aEvent);

 enum TWservEventPriorities

 	{

 	EEventPriorityHigh,

 	EEventPriorityLow,

 	};

 struct TRedraw

 	{

 	CWsWindowRedraw *iRedraw;

 	TUint iPriority;

 	};

 class CEventBase : public CBase

 	{

 private:

 	enum TEventSignalledState

 		{

 		EEventFlagSignalled=0x1,

 		EEventFlagCancelled=0x2

 		};

 public:

 	CEventBase(CWsClient *aOwner);

 	~CEventBase();

 	void CancelRead();

 	void EventReadyCheck();

 	virtual void EventReady(const RMessagePtr2& aEventMsg);

 	void GetData(TAny *aData, TInt aLen);

 protected:

 	void SignalEvent(TInt aCode = KErrNone);

 	inline TBool IsEventCancelled();

 protected:

 	TInt iEventSignalledState;

 	CWsClient *iWsOwner;

 	RMessagePtr2 iEventMsg;

 	};

 class CEventQueue : public CEventBase

 	{

 private:

 	enum {EExtraQueueSize=16};

 	enum {EMaxQueueSize=32};

 	enum {EMinQueueSize=2};

 	enum {EQueueGranularity=4};

 	enum TCompressMode

 		{

 		ECompressNoPurge,	// Compress only free space

 		ECompressPurge1,	// Purge from only non-foreground queues

 		ECompressPurge2,	// Purge from all queues

 		};

 // Functions

 public:

 	CEventQueue(CWsClient *aOwner);

 	~CEventQueue();

 	void ConstructL();

 	TBool QueueEvent(const TWsEvent &event);

 	TBool QueueEvent(const TWsEvent &event, TWservEventPriorities aPriority);

 	TBool QueueEvent(TUint32 aTarget, TInt aEvent);

 	TBool CheckRoom();

 	void GetData();

 	void UpdateLastEvent(const TWsEvent &event);

 	void RemoveEvent(TInt index);

 	void PurgePointerEvents();

 	const TWsEvent *PeekLastEvent();

 	void WalkEventQueue(EventQueueWalk aFunc, TAny *aFuncParam);

 	void MoveToFront();

 	static void Wait();

 	static void Signal();

 	static void InitStaticsL();

 	static void DeleteStaticsL();

 	//void LogUpDownEvents(TChar aChar);

 public:// from CEventBase

 	void EventReady(const RMessagePtr2& aEventMsg);

 private:

 	static void EventCopy(TWsEvent *aStart, TWsEvent *aEnd, TInt aNumEvents);

 	static TInt RequiredQueueSize(TInt aNumConnections);

 	void AdjustQueueSizeL(TInt aNewSize);

 	void IncreaseQueueSize(TInt aNumSpaces);

 	TInt FollowingGap() const;

 	void Purge();

 	TInt PurgeInactiveEvents(const TInt& aSizeRequired);

 	void Compress(TCompressMode aCompressMode);

 	void AddQueueL();

 	void RemoveQueue();

 	TBool Expand(TWservEventPriorities aPriority);

 	TBool doExpand(TCompressMode aCompressMode);

 	TInt SqueezeUp();

 	void SqueezeDown();

 	void MoveUp(TInt aMove);

 	void MoveDown(TInt aMove);

 	TBool MoveDownAndExpand(TDblQueIter<CEventQueue> &aIter, TInt aExpand);

 #if defined(_DEBUG)

 	void CheckQueue();

 	void ZapEvent(TWsEvent *aTarget);

 	void ZapEvents(TWsEvent *aTarget, TInt aLen);

 #endif

 private:

 	void QueueActive();

 	TWsEvent *EventPtr(TInt index);

 // Data

     TInt iHead;

     TInt iCount;

     TInt iQueueSize;

     TWsEvent *iEventPtr;

 	TDblQueLink iLink;

 	static RMutex iMutex;

 	static TWsEvent iNullEvent;

 	static TDblQue<CEventQueue> iQueueList;

 	static TWsEvent *iGlobalEventQueue;

 	static TInt iGlobalEventQueueSize;

 	static TInt iNumConnections;

 	};

 class TWsRedrawEvent;

 class CRedrawQueue : public CEventBase

 	{

 // Functions

 public:

 	CRedrawQueue(CWsClient *aOwner);

 	~CRedrawQueue();

 	void ConstructL();

 	TBool TriggerRedraw();

 	void ReCalcOrder();

 	void AddInvalid(CWsWindowRedraw *redrawWin);

 	void RemoveInvalid(CWsWindowRedraw *redrawWin);

 	void GetData();

 	TUint RedrawPriority(CWsWindowRedraw *aRedrawWin);

 public:// from CEventBase

 	void EventReady(const RMessagePtr2& aEventMsg);

 private:

 	void DeleteFromQueue(TInt aIndex);

 	void QueueActive();

 	TBool FindOutstandingRedrawEvent(CWsWindowRedraw& aRedraw, TWsRedrawEvent& aEvent);

 	TBool FindWindowNeedingRedrawEvent(TWsRedrawEvent& aEvent);

 private:

 // Data

 	CArrayFixSeg<TRedraw> *iRedraws;	// List of windows and their areas that require redraws

 	TBool iAllocError;

 	TBool iRedrawTrigger;

 	TKeyArrayFix *iKeyPriority;

 	TKeyArrayFix *iKeyWindow;

 	static TWsRedrawEvent iNullRedrawEvent;

 	};

 class CWsGraphicMessageQueue: public CEventBase

 	{

 public:

 	class CMessage: public CWsMessageData

 		{

 	public:

 		static CMessage* New(const TDesC8& aData);

 		~CMessage();

 	public: // From CWsMessageData

 		TPtrC8 Data() const;

 		void Release();

 	private:

 		CMessage(const TDesC8& aData);

 	private:

 		TPtr8 iData;

 		};

 public:

 	CWsGraphicMessageQueue(CWsClient *aOwner);

 	~CWsGraphicMessageQueue();

 	void GetGraphicMessage();

 	void AbortMessage(TInt aError);

 	void EventReady(const RMessagePtr2& aEventMsg);

 	void Queue(CWsMessageData* aMessage);

 	TInt TopClientHandle() const;

 private:

 	CWsMessageData* iHead;

 	CWsMessageData* iTail;

 	CWsMessageData* Pop();

 	void GetDataWithHeader(TUint aHeader, const TDesC8& aData, TInt aDataLen);

 	};

 #endif