// Copyright (c) 1994-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:

// Window server event queue handling

// 

//

#include "EVQUEUE.H"

#include "server.h"

#include "wstop.h"

#include "panics.h"

#include "pointer.h"

#include "wstraces.h"

GLREF_D CDebugLogBase *wsDebugLog;

#if defined(_DEBUG)

#define __CHECK_QUEUE() CheckQueue()

#define __ZAP_EVENTS(pointer,len) ZapEvents(pointer,len)

#define __ZAP_EVENT(pointer) ZapEvent(pointer)

#else

#define __CHECK_QUEUE()

#define __ZAP_EVENTS(pointer,len)

#define __ZAP_EVENT(pointer)

#endif

const TInt ECopyBufSize=4;

TDblQue<CEventQueue> CEventQueue::iQueueList(_FOFF(CEventQueue,iLink));

TWsEvent *CEventQueue::iGlobalEventQueue=NULL;

TInt CEventQueue::iGlobalEventQueueSize=0;

TInt CEventQueue::iNumConnections=0;

RMutex CEventQueue::iMutex;

TWsEvent CEventQueue::iNullEvent;

// CEventBase

CEventBase::~CEventBase()

	{

	if (!iEventMsg.IsNull() && CWsTop::ShuttingDown())

		{

		iEventMsg.Complete(KErrServerTerminated);

		}

	}

CEventBase::CEventBase(CWsClient *aOwner) : iWsOwner(aOwner)

	{

	}

void CEventBase::SignalEvent(TInt aCode)

	{

	if (wsDebugLog)

		wsDebugLog->SignalEvent(iWsOwner->ConnectionHandle());

	iEventMsg.Complete(aCode);

	iEventSignalledState|=EEventFlagSignalled;

	}

inline TBool CEventBase::IsEventCancelled()

	{

	return (iEventSignalledState & EEventFlagCancelled);

	}

void CEventBase::CancelRead()

//

// If there is an outstanding read cancel it.

//

	{

	if (!iEventMsg.IsNull())

		{

		iEventMsg.Complete(KErrCancel);

		}

	iEventSignalledState|=EEventFlagCancelled;

	}

void CEventBase::GetData(TAny *aData, TInt aLen)

	{

	if (!(iEventSignalledState&EEventFlagSignalled))

		{

		iWsOwner->PPanic(EWservPanicUnsignalledEventData);

		}

	iEventSignalledState&=~EEventFlagSignalled;

	CWsClient::ReplyBuf(aData,aLen);

	}

void CEventBase::EventReadyCheck()

//

// Queue a read of an event notification

//

	{

	if ((iEventSignalledState&EEventFlagSignalled && !(iEventSignalledState&EEventFlagCancelled)) || !iEventMsg.IsNull())

		{

		iWsOwner->PPanic(EWservPanicReadOutstanding);

		}

	}

void CEventBase::EventReady(const RMessagePtr2& aEventMsg)

	{

	EventReadyCheck();

	iEventMsg=aEventMsg;

	}

// CEventQueue - Queue organisation functions

#if defined(_DEBUG)

void CEventQueue::CheckQueue()

	{

	TDblQueIter<CEventQueue> iter(iQueueList);

	CEventQueue *qptr;

	iter.SetToFirst();

	while((qptr=iter++)!=NULL)

		{

		WS_ASSERT_DEBUG(qptr->iQueueSize>=0 && qptr->iQueueSize<=iGlobalEventQueueSize, EWsPanicCheckEventQueue);

		WS_ASSERT_DEBUG(qptr->iQueueSize==0 || qptr->iHead<qptr->iQueueSize, EWsPanicCheckEventQueue);

		WS_ASSERT_DEBUG(qptr->iCount<=qptr->iQueueSize, EWsPanicCheckEventQueue);

		WS_ASSERT_DEBUG(qptr->iEventPtr>=iGlobalEventQueue && qptr->iEventPtr<=(iGlobalEventQueue+iGlobalEventQueueSize), EWsPanicCheckEventQueue);

		}

	for(TInt index=0;index<iCount;index++)

		{

		TWsEvent *ev=EventPtr(index);

		WS_ASSERT_DEBUG(ev->Type()!=EEventMarkInvalid, EWsPanicCheckEventQueue);

		}

	}

void CEventQueue::ZapEvent(TWsEvent *aTarget)

	{

	aTarget->SetType(EEventMarkInvalid);

	aTarget->SetHandle(555);

	}

void CEventQueue::ZapEvents(TWsEvent *aTarget, TInt aLen)

	{

	for(TInt index=0;index<aLen;index++)

		ZapEvent(aTarget+index);

	}

#endif

void CEventQueue::EventCopy(TWsEvent *aTarget, TWsEvent *aSource, TInt aNumEvents)

	{

	WS_ASSERT_DEBUG(aTarget>=iGlobalEventQueue, EWsPanicEventQueueCopy);

	WS_ASSERT_DEBUG((aTarget+aNumEvents)<=(iGlobalEventQueue+iGlobalEventQueueSize), EWsPanicEventQueueCopy);

	Mem::Copy(aTarget,aSource,aNumEvents*sizeof(TWsEvent));

	}

TInt CEventQueue::RequiredQueueSize(TInt aNumConnections)

	{

	return(aNumConnections*EMinQueueSize+EMaxQueueSize+EExtraQueueSize);

	}

/**

Adjust the Global Queue Size.

@param aNewSize the size for event queue. 

*/

void CEventQueue::AdjustQueueSizeL(TInt aNewSize)

	{

	TWsEvent* oldQ=iGlobalEventQueue;

	if (aNewSize < iGlobalEventQueueSize)

		{

		// Re-alloc wont move the cell down to a lower address, this means once this cell is

		// high up in memory it may never move down again, thus wasting loads of global heap space.

		const CEventQueue* last=iQueueList.Last();

		if ((last->iEventPtr + last->iQueueSize) >= (iGlobalEventQueue + aNewSize))

			{

			return;

			}

		TInt allocSize = aNewSize * sizeof(TWsEvent);

		iGlobalEventQueue=static_cast<TWsEvent*>(User::AllocL(allocSize));

		Mem::Copy(iGlobalEventQueue,oldQ,allocSize);

		User::Free(oldQ);

		}

	else

		{

		iGlobalEventQueue = static_cast<TWsEvent*>(User::ReAllocL(iGlobalEventQueue, aNewSize * sizeof(TWsEvent)));

		}

	__ZAP_EVENTS(iGlobalEventQueue + iGlobalEventQueueSize, aNewSize - iGlobalEventQueueSize); 

	iGlobalEventQueueSize = aNewSize; 

	// coverity[use_after_free]

	TInt diff=(reinterpret_cast<TInt8*>(iGlobalEventQueue)-reinterpret_cast<TInt8*>(oldQ));

	if (diff)

		{

		TDblQueIter<CEventQueue> iter(iQueueList);

		CEventQueue* qptr;

		while((qptr=iter++)!=NULL)

			{

			qptr->iEventPtr=reinterpret_cast<TWsEvent*>(reinterpret_cast<TInt8*>(qptr->iEventPtr)+diff);

			}

		}

	}

void CEventQueue::AddQueueL()

	{

	Wait();

	if ((iNumConnections%EQueueGranularity)==0)

		{

		const TInt newSize = RequiredQueueSize(iNumConnections + EQueueGranularity);

		TRAPD(err,AdjustQueueSizeL(newSize));

		if (err!=KErrNone)

			{

			__CHECK_QUEUE();

			Signal();

			User::Leave(err);

			}

		}

	iNumConnections++;

	if (iQueueList.IsEmpty())

		iEventPtr=iGlobalEventQueue;

	else

		{

		CEventQueue *qptr=iQueueList.Last();

		iEventPtr=qptr->iEventPtr+qptr->iQueueSize;

		}

	iQueueList.AddLast(*this);

	//Initialize the queue size to at least EMinQueueSize

	//Check the queue by doing standard queue compression.

	TBool isExpanded = ETrue;

	do {isExpanded = Expand(EEventPriorityLow);} while ((iQueueSize < EMinQueueSize) && isExpanded);

	while (iQueueSize < EMinQueueSize)

		{

		//Cannot get enough spaces by doing standard queue compression,

		//try to grow the global queue.

		TInt sizeRequired = EMinQueueSize - iQueueSize;

		const TInt newSize = iGlobalEventQueueSize + sizeRequired;

		TRAPD(err, AdjustQueueSizeL(newSize));

		if (err != KErrNone)

			{

			//Cannot get enough spaces by growing global queue.

			//try to purge the oldest events from inactive clients.				

			TInt numEventCleared = PurgeInactiveEvents(sizeRequired);

			if (numEventCleared == 0)

				{

				__CHECK_QUEUE();

				Signal();

				User::Leave(err);

				}

			}

		while (doExpand(ECompressNoPurge)) {};

		}

	__CHECK_QUEUE();

	Signal();

	}

void CEventQueue::RemoveQueue()

	{

	Wait();

	if (iEventPtr)	// If this is still NULL this class hasn't been linked into the Q list

		{

		__ZAP_EVENTS(iEventPtr, iQueueSize);

		iLink.Deque();

		if (--iNumConnections==0)

			{

			User::Free(iGlobalEventQueue);

			iGlobalEventQueue=NULL;

			iGlobalEventQueueSize=0;

			}

		else if ((iNumConnections%EQueueGranularity)==0)

			{

			TDblQueIter<CEventQueue> iter(iQueueList);

			CEventQueue* qptr=iter++;

			qptr->Compress(ECompressNoPurge);

			while((qptr=iter++)!=NULL)

				{

				qptr->SqueezeDown();

				}

			const TInt newSize = RequiredQueueSize(iNumConnections);

			TRAP_IGNORE(AdjustQueueSizeL(newSize));

			// Can easily leave as we need to allocate the new smaller queue before freeing

			// the old queue. But if it does it doesn't matter as we'll simply be left with

			// a larger than necessary buffer until the next realloc

			}

		iCount=0;

		}

	__CHECK_QUEUE();

	Signal();

	}

void CEventQueue::IncreaseQueueSize(TInt aNumSpaces)

	{

	if ((iQueueSize+aNumSpaces)>EMaxQueueSize)

		aNumSpaces=EMaxQueueSize-iQueueSize;

	EventCopy(iEventPtr+iHead+aNumSpaces, iEventPtr+iHead, iQueueSize-iHead);

	__ZAP_EVENTS(iEventPtr+iHead, aNumSpaces);

	iQueueSize+=aNumSpaces;

	iHead=(iHead+aNumSpaces)%iQueueSize;

	}

TBool CEventQueue::Expand(TWservEventPriorities aPriority)

	{

	if (iQueueSize==EMaxQueueSize)

		{

		if (aPriority==EEventPriorityHigh)

			{

			Purge();

			if (iCount<iQueueSize)

				return(ETrue);	// Success!

			}

		}

	else if (doExpand(ECompressNoPurge) ||

			  doExpand(ECompressPurge1) ||

			   (aPriority==EEventPriorityHigh && doExpand(ECompressPurge2)))

		return(ETrue);

	return(EFalse);				// Failure

	}

TBool CEventQueue::doExpand(TCompressMode aCompressMode)

	{

	TDblQueIter<CEventQueue> iter(iQueueList);

	iter.SetToLast();

	CEventQueue* qptr=NULL;

	TInt spare=0;

	// while loop from last queue till current queue, moving all queues up 

	// to get all the space from between them

	while((qptr=iter)!=this)

		{

		spare=qptr->SqueezeUp();

		if (spare==0)

			qptr->Compress(aCompressMode);

		iter--;

		}

	// current queue, if we have space then expand the same and return

	spare=FollowingGap();

	if (spare>0)

		{

		IncreaseQueueSize(spare);

		__CHECK_QUEUE();

		return(ETrue);

		}

	// while loop from current queue till first queue, looking for a gap 

	// between queues and using the first one it finds

	iter--;

	TInt expanded=0;

	while((qptr=iter)!=NULL)

		{

		expanded=qptr->SqueezeUp();

		if (expanded>0)

			{

			return MoveDownAndExpand(iter, expanded);

			}

		else

			qptr->Compress(aCompressMode);

		iter--;

		}

	// Even by doing all the above if we did not find space then check if first 

	// queue has some space before it. If so then make use of it and movedown all the 

	// queue till the current queue and then use the space for expansion

	iter.SetToFirst();

	qptr=iter;

	if (qptr->iEventPtr>iGlobalEventQueue)

		{

		return MoveDownAndExpand(iter, qptr->iEventPtr-iGlobalEventQueue);

		}

	__CHECK_QUEUE();

	return(EFalse);	// Failed to expand enough room

	}

// This function moves the queue down by given amount and repeats this until

// the current queue and then expand the same

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

	{

	CEventQueue* qptr=NULL;

	FOREVER

		{

		qptr=aIter++;

		qptr->MoveDown(aExpand);

		if (qptr==this)

			{

			IncreaseQueueSize(aExpand);

			__CHECK_QUEUE();

			break;

			}

		}

	return ETrue;

	}

void CEventQueue::MoveDown(TInt aMove)

	{

	if (!aMove)

		{

		return;

		}

	EventCopy(iEventPtr-aMove,iEventPtr,iQueueSize);

	iEventPtr-=aMove;

	}

/*void CEventQueue::LogUpDownEvents(TChar aChar)

	{

	TWsEvent *event;

	TBuf<128> buf;

	buf.Zero();

	buf.Append(aChar);

	buf.Append('#');

	buf.Append('#');

	TBool some=EFalse;

	TInt index;

	for (index=0;index<iCount;index++)

		{

		event=EventPtr(index);

		if (event->Type()==EEventPointer)

			{

			if (event->Pointer()->iType==TPointerEvent::EButton1Down

										|| event->Pointer()->iType==TPointerEvent::EButton1Up)

				{

				some=ETrue;

				if (event->Pointer()->iType==TPointerEvent::EButton1Down)

					buf.Append('D');

				else

					buf.Append('U');

				buf.AppendNum(index);

				}

			}

		}

	if (wsDebugLog)

		wsDebugLog->MiscMessage(ELogImportant,buf);

	}*/

void CEventQueue::Purge()

	{

// Purgable events are:

//	Pointer Up/Down pairs

//  Pointer moves & drags

//  Key messages

//  Key Up/Down pairs

//  Key Ups if not foreground connection

//  Focus lost/gained pairs

//

// Events that must no be purged

//  Key ups for foreground connections queue

//  Lone pointer ups, must be delivered to match preceeding pointer down

//  Lone focus lost/gained messages

//	

	TWsEvent *event;

	TWsEvent *event2;

	TInt index2;

	TInt index=iCount;

	while(index>0)

		{

		event=EventPtr(--index);

		switch(event->Type())

			{

			case EEventPassword:

				break;

			case EEventMarkInvalid:

#if defined(_DEBUG)

				WS_PANIC_DEBUG(EWsPanicCheckEventQueue);

#endif

			case EEventNull:

			case EEventKey:

			case EEventPointerEnter:

			case EEventPointerExit:

			case EEventDragDrop:

breakLoopAndRemoveEvent:

				RemoveEvent(index);

				return;

			case EEventKeyUp:

				if (iQueueList.First()!=this)

					goto breakLoopAndRemoveEvent;

				break;

			case EEventKeyDown:

				if (iQueueList.First()!=this)

					goto breakLoopAndRemoveEvent;

				for (index2=index+1;index2<iCount;index2++)

					{

					event2=EventPtr(index2);

					if (event2->Type()==EEventKeyUp && event2->Key()->iScanCode==event->Key()->iScanCode)

						{

						*event2=iNullEvent;

						goto breakLoopAndRemoveEvent;

						}

					}

				break;

			case EEventModifiersChanged:

				for (index2=index;index2>0;)

					{

					event2=EventPtr(--index2);

					if (event2->Type()==EEventModifiersChanged)

						{

						event->ModifiersChanged()->iChangedModifiers|=event2->ModifiersChanged()->iChangedModifiers;

						index=index2;

						goto breakLoopAndRemoveEvent;

						}

					}

				break;

			case EEventPointerBufferReady:

				CWsPointerBuffer::DiscardPointerMoveBuffer(event->Handle());

				goto breakLoopAndRemoveEvent;

			case EEventFocusLost:

			case EEventFocusGained:

				if ((index+1)<iCount)

					{

					event2=EventPtr(index+1);

					if (event2->Type()==EEventFocusLost || event2->Type()==EEventFocusGained)

						{

						*event2=iNullEvent;

						goto breakLoopAndRemoveEvent;

						}

					}

				break;

			case EEventSwitchOn:

				if ((index+1)<iCount && EventPtr(index+1)->Type()==EEventSwitchOn)

					goto breakLoopAndRemoveEvent;

				break;

			case EEventPointer:

				{

				TPointerEvent::TType upType;

				switch(event->Pointer()->iType)

					{

					case TPointerEvent::EDrag:

					case TPointerEvent::EMove:

					case TPointerEvent::EButtonRepeat:

					case TPointerEvent::ESwitchOn:

						goto breakLoopAndRemoveEvent;

					case TPointerEvent::EButton1Down:

						upType=TPointerEvent::EButton1Up;

						goto purgeDownUp;

					case TPointerEvent::EButton2Down:

						upType=TPointerEvent::EButton2Up;

						goto purgeDownUp;

					case TPointerEvent::EButton3Down:

						upType=TPointerEvent::EButton3Up;

purgeDownUp:			for (index2=index+1;index2<iCount;index2++)

							{

							event2=EventPtr(index2);

							if (event2->Type()==EEventPointer && event2->Handle()==event->Handle() && event2->Pointer()->iType==upType)

								{

								*event2=iNullEvent;

								goto breakLoopAndRemoveEvent;

								}

							}

						WsPointer::UnmatchedDownPurged(upType, event->Handle());

						goto breakLoopAndRemoveEvent;

					case TPointerEvent::EButton1Up:

					case TPointerEvent::EButton2Up:

					case TPointerEvent::EButton3Up:

						break;

					}

				}

				break;

			}

		}

	}

void CEventQueue::PurgePointerEvents()

	{

	TWsEvent *event;

	TWsEvent *event2;

	TInt index2;

	TInt index=iCount;

	while(index>0)

		{

		event=EventPtr(--index);

		switch(event->Type())

			{

			case EEventPointerBufferReady:

				CWsPointerBuffer::DiscardPointerMoveBuffer(event->Handle());

				RemoveEvent(index);

				break;

			case EEventPointer:

				{

				TPointerEvent::TType upType;

				switch(event->Pointer()->iType)

					{

					case TPointerEvent::EDrag:

					case TPointerEvent::EMove:

					case TPointerEvent::EButtonRepeat:

					case TPointerEvent::ESwitchOn:

						RemoveEvent(index);

						break;

					case TPointerEvent::EButton1Down:

						upType=TPointerEvent::EButton1Up;

						goto purgeDownUp2;

					case TPointerEvent::EButton2Down:

						upType=TPointerEvent::EButton2Up;

						goto purgeDownUp2;

					case TPointerEvent::EButton3Down:

						upType=TPointerEvent::EButton3Up;

purgeDownUp2:			for (index2=index+1;index2<iCount;index2++)

							{

							event2=EventPtr(index2);

							if (event2->Type()==EEventPointer && event2->Handle()==event->Handle() && event2->Pointer()->iType==upType)

								{

								*event2=iNullEvent;

								goto purgedUp;

								}

							}

						WsPointer::UnmatchedDownPurged(upType, event->Handle());

purgedUp:				RemoveEvent(index);

						break;

					case TPointerEvent::EButton1Up:

					case TPointerEvent::EButton2Up:

					case TPointerEvent::EButton3Up:

						break;

					}

				}

				break;

			}

		}

	}

/**

Purge requested number of oldest events from inactive event queue.

@param aSizeRequired the total events required to be cleared. 

@return The number of events cleared.

*/

TInt CEventQueue::PurgeInactiveEvents(const TInt& aSizeRequired)

	{

	TInt numEventsCleared = 0;

	CEventQueue* qptr;

	TBool isRemoved;

	do	{

		TDblQueIter<CEventQueue> iter(iQueueList);

		isRemoved = EFalse;

		while ((qptr = iter++) != NULL && (aSizeRequired > numEventsCleared))

			{

			if ((qptr->IsEventCancelled() || (qptr->iEventMsg.IsNull() && !qptr->iEventSignalledState)) &&

				(qptr->iQueueSize > EMinQueueSize))

				{

				// we have a client that is not listening with a size larger than min queue size.

				// so lets remove it's oldest event until the number of removed events meet the requirement.

				qptr->RemoveEvent(0);

				numEventsCleared++;

				isRemoved = ETrue;

				}

			}

		} while ((aSizeRequired > numEventsCleared) && isRemoved);

	return numEventsCleared;

	}

void CEventQueue::Compress(TCompressMode aCompressMode)

	{

//

// The different purge modes are

//

// ECompressNoPurge,	// Don't purge anything

// ECompressPurge1,		// Don't purge foreground queue

// ECompressPurge2,		// Purge all queues

//

	if (aCompressMode==ECompressPurge2 ||

		(this!=iQueueList.First() && aCompressMode==ECompressPurge1))

		Purge();

	TInt compress=iQueueSize-(iCount>EMinQueueSize?iCount:EMinQueueSize);

	if (compress>0)

		{

		compress=(compress+1)/2;	// Compress half the free space in the queue

		TWsEvent *head=EventPtr(0);

		TWsEvent *tail=EventPtr(iCount);

		if (head>tail)

			{

			EventCopy(iEventPtr+compress,iEventPtr,tail-iEventPtr);

			iHead-=compress;

			}

		else

			{

			EventCopy(iEventPtr+compress,head,iCount);

			iHead=0;

			}

		iEventPtr+=compress;

		iQueueSize-=compress;

		}

	}

void CEventQueue::MoveUp(TInt aNumEvents)

	{

	if (!aNumEvents)

		{

		return;

		}

	EventCopy(iEventPtr+aNumEvents,iEventPtr,iQueueSize);

	iEventPtr+=aNumEvents;

	}

TInt CEventQueue::FollowingGap() const

	{

	TDblQueIter<CEventQueue> iter(iQueueList);

	CEventQueue *qptr;

	iter.Set(*(CEventQueue *)this);

	iter++;

	TWsEvent *end;

	if ((qptr=iter)!=NULL)

		end=qptr->iEventPtr;

	else

		end=iGlobalEventQueue+iGlobalEventQueueSize;

	return(end-(iEventPtr+iQueueSize));

	}

TInt CEventQueue::SqueezeUp()

	{

	TInt gap=FollowingGap();

	MoveUp(gap);

	return(gap);

	}

void CEventQueue::SqueezeDown()

	{

	TDblQueIter<CEventQueue> iter(iQueueList);

	iter.Set(*this);

	iter--;

	CEventQueue *qptr=iter;

	if (qptr!=NULL)

		{

		Compress(ECompressNoPurge);

		TInt gap=qptr->FollowingGap();

		MoveDown(gap);

		}

	}

void CEventQueue::MoveToFront()

	{

	if (this==iQueueList.First())

		return;

	Wait();

	CEventQueue *qptr;

	TInt gap=0;

	TDblQueIter<CEventQueue> iter(iQueueList);

	iter.SetToLast();

	while((qptr=iter--)!=NULL)

		{

		if (gap<iQueueSize)

			qptr->Compress(ECompressNoPurge);

		gap=qptr->SqueezeUp();

		}

	if (gap>=iQueueSize)

		EventCopy(iGlobalEventQueue,iEventPtr,iQueueSize);

	else

		{

		EventCopy(iGlobalEventQueue,iEventPtr,gap);

		iEventPtr+=gap;

		TWsEvent copyBuf[ECopyBufSize];	// temp buffer, can copy upto ECopyBufSize events at a time

		TInt eventsToGo=iQueueSize-gap;

		iQueueSize=gap;

		do

			{

			TInt copy=Min(eventsToGo,ECopyBufSize);

			Mem::Copy(&copyBuf[0],iEventPtr,copy*sizeof(TWsEvent));

			iter.Set(*this);

			iter--;

			while((qptr=iter--)!=NULL)

				qptr->MoveUp(copy);

			EventCopy(iGlobalEventQueue+iQueueSize,&copyBuf[0],copy);

			iQueueSize+=copy;

			eventsToGo-=copy;

			iEventPtr+=copy;

			} while(eventsToGo>0);

		}

	iEventPtr=iGlobalEventQueue;

	this->iLink.Deque();

	iQueueList.AddFirst(*this);

	__CHECK_QUEUE();

	Signal();

	}

// CEventQueue

CEventQueue::CEventQueue(CWsClient *aOwner) : CEventBase(aOwner)

	{

	__DECLARE_NAME(_S("CEventQueue"));

	}

CEventQueue::~CEventQueue()

	{

	RemoveQueue();

	}

void CEventQueue::InitStaticsL()

	{

	User::LeaveIfError(iMutex.CreateLocal());

	}

void CEventQueue::DeleteStaticsL()

	{

	iMutex.Close();

	}

void CEventQueue::ConstructL()

	{

	AddQueueL();

	Mem::FillZ(&iNullEvent,sizeof(iNullEvent));

	}

TWsEvent *CEventQueue::EventPtr(TInt index)	

	{

	return(iEventPtr+((iHead+index)%iQueueSize));

	}

TBool CEventQueue::QueueEvent(const TWsEvent &event)

	{

	TWservEventPriorities priority=EEventPriorityLow;

#ifdef SYMBIAN_PROCESS_MONITORING_AND_STARTUP

	if (event.Type()==EEventPassword || event.Type()==EEventSwitchOff || 

		event.Type()==EEventKeySwitchOff || event.Type()==EEventRestartSystem)

#else

	if (event.Type()==EEventPassword || event.Type()==EEventSwitchOff || event.Type()==EEventKeySwitchOff)

#endif

		{

		priority=EEventPriorityHigh;

		}

	return(QueueEvent(event,priority));

	}

TBool CEventQueue::CheckRoom()

//

// If the queue is full and room is created return ETrue

//

	{

	TBool ret=EFalse;

	Wait();

	if (iCount==iQueueSize && Expand(EEventPriorityHigh))

		ret=ETrue;

	Signal();

	return(ret);

	}

TBool CEventQueue::QueueEvent(const TWsEvent &event, TWservEventPriorities aPriority)

//

// Queue an event, returns ETrue if queued or delivered, EFalse if the queue was full.

//

	{

	WS_TRACE_SERVER_QUEUEEVENT();

	TBool ret=ETrue;

	Wait();

	if (iCount==iQueueSize && !Expand(aPriority))

		ret=EFalse;

	else

		{

		if (!iEventMsg.IsNull())

			{

			SignalEvent();

			}

		*EventPtr(iCount++)=event;

		}

	Signal();

	return(ret);

	}

TBool CEventQueue::QueueEvent(TUint32 aTarget, TInt aEvent)

	{

	TWsEvent event;

	event.SetType(aEvent);

	event.SetHandle(aTarget);

	event.SetTimeNow();

	return(QueueEvent(event));

	}

void CEventQueue::UpdateLastEvent(const TWsEvent &event)

	{

	WS_ASSERT_DEBUG(iCount>0, EWsPanicQueueUpdateCount);

	Mem::Copy(EventPtr(iCount-1)->EventData(),event.EventData(),TWsEvent::EWsEventDataSize);

	Signal();

	}

void CEventQueue::GetData()

//

// If there is an outstanding event in the queue, reply with it's data and remove it from the Q

//

	{

	if (iCount>0)

		{

		WS_ASSERT_DEBUG((iEventPtr+iHead)->Type()!=EEventMarkInvalid, EWsPanicCheckEventQueue);

		CEventBase::GetData(iEventPtr+iHead,sizeof(*iEventPtr));

		__ZAP_EVENT(iEventPtr+iHead);

		iHead=(iHead+1)%iQueueSize;

		iCount--;

		}

	else

		CEventBase::GetData(&iNullEvent,sizeof(iNullEvent));

	}

void CEventQueue::EventReady(const RMessagePtr2& aEventMsg)

//

// Queue a read of an event notification

//

	{

	EventReadyCheck();

	Wait();

	iEventMsg=aEventMsg;

	if (iCount>0)

		SignalEvent();

	Signal();

	}

void CEventQueue::RemoveEvent(TInt index)

//

// Remove event 'index' in the queue, this event MUST exist in the queue

//

	{

	WS_ASSERT_DEBUG(index < iCount, EWsPanicCheckEventQueue);

	iCount--;

	for(;index<iCount;index++)

		*EventPtr(index)= *EventPtr(index+1);

	__ZAP_EVENT(EventPtr(iCount));

	}

const TWsEvent *CEventQueue::PeekLastEvent()

//

// Return a read only pointer to the last event in the queue (or NULL if no event)

//

	{

	if (iCount==0)

		return(NULL);

	return(EventPtr(iCount-1));

	}

void CEventQueue::Wait()

	{

	iMutex.Wait();

	}

void CEventQueue::Signal()

	{

	iMutex.Signal();

	}

void CEventQueue::WalkEventQueue(EventQueueWalk aFunc, TAny *aFuncParam)

	{

	Wait();

restart:

	for (TInt index=0;index<iCount;index++)

		{

		TWsEvent *event=EventPtr(index);

		switch((aFunc)(aFuncParam,event))

			{

			case EEventQueueWalkDeleteEvent:

				RemoveEvent(index--);

			case EEventQueueWalkOk:

				break;

			case EEventQueueWalkRestart:

				goto restart;

			}

		}

	Signal();

	}