// 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 "advancedpointereventhelper.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);

	}

/**

If there is an outstanding read cancel it.

*/

void CEventBase::CancelRead()

	{

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

	}

/**

Queue a read of an event notification

*/

void CEventBase::EventReadyCheck()

	{

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

	}*/

inline void CEventQueue::IncEventPointer(TWsEvent*& aEventPtr)

	{

	// iEventPtr[iQueueSize] is the element beyond the array, used for efficient bounds checking of the circular buffer only, do not access!!

	if(++aEventPtr==&iEventPtr[iQueueSize])

		{

		aEventPtr=iEventPtr;

		}

	}

inline void CEventQueue::DecEventPointer(TWsEvent*& aEventPtr)

	{

	if(aEventPtr--==iEventPtr)

		{

		aEventPtr=&iEventPtr[iQueueSize - 1];

		}

	}

/*

Starting from aEventToPurge searches the queue for matching event by iterating towards end of queue.

Matching event will be a pointer event with the same window handle and pointer number

as aEventToPurge, but will have type aMatchingType. If matching event is found, it will 

be removed from the queue and search will finish.

Search will be stopped if an event of type aSearchTerminator is found with the same pointer number 

as aEventToPurge.

If search is not stopped by aSearchTerminator and matching event is not found, TWsPointer

class is notified that matching event has not been removed, so if it arrives in the future,

TWsPointer class will be able to ignore it.

*/

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

		{

		TWsEvent* eventToMatch = aEventToPurge;

		TWsEvent* lastEvent = EventPtr(iCount);

		for(IncEventPointer(eventToMatch);eventToMatch!=lastEvent;IncEventPointer(eventToMatch))

			{

			if ( (eventToMatch->Type()==EEventPointer)  // Must be checked first to ensure it is pointer data checked later

					&&	(TAdvancedPointerEventHelper::PointerNumber(*eventToMatch) == TAdvancedPointerEventHelper::PointerNumber(*aEventToPurge))) // same pointer 

				{

				if ((eventToMatch->Pointer()->iType==aMatchingType) // correct event type

						&& (eventToMatch->Handle()==aEventToPurge->Handle())) // same window

					{

					*eventToMatch=iNullEvent;

					return;

					}

				else if (eventToMatch->Pointer()->iType==aSearchTerminator) // stop searching for mathing type

					{

					return;

					}

				}

			};

		TWsPointer::UnmatchedEventPurged(aMatchingType, aEventToPurge);

		}

/**

Starting from pointer event aBasePointerEvent searches the queue for next pointer event for 

the same pointer by iterating towards end of queue.

@param aBasePointerEvent must be of type EEventPointer

@return Next pointer event in the queue for the same pointer as aBasePointerEvent 

        if it has the same handle as aBasePointerEvent or NULL if it has different handle.

        NULL if there is no next pointer event for the same pointer in the queue.

*/

TWsEvent* CEventQueue::NextPointerEvent(TWsEvent* aBasePointerEvent)

	{

	WS_ASSERT_DEBUG(aBasePointerEvent->Type() == EEventPointer, EWsPanicCheckEventQueue);

	TWsEvent* currentEvent = aBasePointerEvent;

	TWsEvent* lastEvent = EventPtr(iCount);

	TUint8 pointerNumber = TAdvancedPointerEventHelper::PointerNumber(*aBasePointerEvent);

	TUint handle = aBasePointerEvent->Handle();

	for(IncEventPointer(currentEvent);currentEvent!=lastEvent;IncEventPointer(currentEvent))

		{

		if ((currentEvent->Type() == EEventPointer) && 

			(TAdvancedPointerEventHelper::PointerNumber(*currentEvent) == pointerNumber))

			{

			if (currentEvent->Handle() == handle)

				{

				return currentEvent;

				}

			else

				{

				return NULL;

				}

			}

		};

	return NULL;

	}

/**

Checks if aEventToPurge should be purged. If it can be purged, then events that should

be purged together with aEventToPurge (matching events) are overwritten with iNullEvent.