// 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 <Graphics/WSGRAPHICDRAWERINTERFACE.H>

#include "W32STD.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, TInt aIntVal = 0);

	TBool CheckRoom();

	void GetData();

	void UpdateLastEvent(const TWsEvent &event);

	TBool UpdateLastPointerEvent(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);

	void RemoveEvent(TWsEvent* aEvToRemove);

	inline void IncEventPointer(TWsEvent*& aEventPtr);	

	inline void DecEventPointer(TWsEvent*& aEventPtr);	

	void PurgeEventPairs(TWsEvent* aEventToPurge, TPointerEvent::TType aMatchingType, TPointerEvent::TType aSearchTerminator);

	TWsEvent* NextPointerEvent(TWsEvent* aBaseEvent);

	TBool CheckPurgePointerEvent(TWsEvent* aEventToPurge);

private:

    /** Position of head in local queue relative to iEventPtr. 

        First event to send to the Client. */ 

	TInt iHead;

	/** Number of events waiting in local queue */

    TInt iCount;

    /** Size of local queue = maximum number of events */

    TInt iQueueSize;

    /** Beginning of local queue */

    TWsEvent* iEventPtr;

    /** Used by iQueueList to link local queues */

	TDblQueLink iLink;

	/** Mutex for operations on global event queue */

	static RMutex iMutex;

	/** Always filled with zeros */

	static TWsEvent iNullEvent;

	/** List of event queues */

	static TDblQue<CEventQueue> iQueueList;

	/** Global queue that keeps all events queues */

	static TWsEvent* iGlobalEventQueue;

	/** Size of global queue */

	static TInt iGlobalEventQueueSize;

	/** Number of event queues */

	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