// 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;