// 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();
	}