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

// Pointer functions

// 

//

#include <e32std.h>

#include <e32hal.h>

#include "W32CLICK.H"

#include "pointer.h"

#include "rootwin.h"

#include "windowgroup.h"

#include "KEYCLICK.H"

#include "ScrDev.H"

#include "EVENT.H"

#include "panics.h"

#include "wstop.h"

#include "inifile.h"

#include "graphics/pointereventdata.h"

TPoint WsPointer::iCurrentPos;

TBool WsPointer::iPointerDown;

const CWsWindow *WsPointer::iCurrentWindow;

const CWsWindow *WsPointer::iActualWinPointerIsOver;

const CWsWindow *WsPointer::iGrabWindow;

const CWsWindow *WsPointer::iPrevClickWindow;

TPoint WsPointer::iPrevClickPos;

TTime WsPointer::iPrevClickTime;

TPointerEvent::TType WsPointer::iPrevClickEventType;

TTimeIntervalMicroSeconds32 WsPointer::iDoubleClickMaxInterval;

TInt WsPointer::iDoubleClickMaxDistance;

CWsPointerCursor *WsPointer::iCursorSprite;

CWsPointerTimer *WsPointer::iRepeatTimer=NULL;

TPointerCursorMode WsPointer::iPointerCursorMode=EPointerCursorNormal;

CWsWindow *WsPointer::iRepeatWindow=NULL;

TRect WsPointer::iRepeatRect;

TXYInputType  WsPointer::iXyInputType;

TUint WsPointer::iLastUnmatchedDown1;

TUint WsPointer::iLastUnmatchedDown2;

TUint WsPointer::iLastUnmatchedDown3;

TBool WsPointer::iTimerQueued;

TBool WsPointer::iUpdateRequired;

CPeriodic *WsPointer::iPeriodicTimer;

CWsRootWindow* WsPointer::iRootWindow;

TBool CWsPointerBuffer::iSignalled=EFalse;

CWsPointerBuffer *CWsPointerBuffer::iCurrentBuffer=NULL;

CCirBuf<TPoint> *CWsPointerBuffer::iPointerBuffer=NULL;

TSglQue<CWsPointerBuffer> CWsPointerBuffer::iList(_FOFF(CWsPointerBuffer,iQue));

void WsPointer::InitStaticsL()

	{

	iRepeatTimer=new(ELeave) CWsPointerTimer();

	iRepeatTimer->ConstructL();

	TMachineInfoV1Buf machineInfo;

	UserHal::MachineInfo(machineInfo);

	iXyInputType=machineInfo().iXYInputType;

	iRootWindow = CWsTop::Screen()->RootWindow();

	iCurrentWindow=MovesAvailable() ? iRootWindow : NULL;

	iPeriodicTimer=CPeriodic::NewL(EPointerCursorPriority);

	}

void WsPointer::DeleteStatics()

	{

	SetPointerCursorMode(EPointerCursorNone);

	UpdatePointerCursor();

	delete iRepeatTimer;

	delete iPeriodicTimer;

	}

void WsPointer::SetPointerCursorPos(TPoint aPos)

	{

	RestrictPos(aPos,EFalse);

	iCurrentPos=aPos;

	ReLogCurrentWindow();

	UpdatePointerCursor();

	}

void WsPointer::SendEnterExitEvent(TEventCode aType)

	{

	if (iCurrentWindow

		&& !(iCurrentWindow->PointerFilter()&EPointerFilterEnterExit)

		&& !iCurrentWindow->ShutDownInProgress())

		iCurrentWindow->QueueEvent(aType);

	}

void WsPointer::SetCurrentWindow(const CWsWindow *aWin)

	{

	if (aWin!=iCurrentWindow)

		{

		SendEnterExitEvent(EEventPointerExit);

		iCurrentWindow=aWin;

		SendEnterExitEvent(EEventPointerEnter);

		}

	}

void WsPointer::ReLogCurrentWindow(TPoint &aPos, TPoint &aParentPos, const CWsWindowGroup *aForceInGroup)

//

// Relog the current pointer window, can be used to set a new iCurrentPos or when the window layout has changed.

// Sets iCurrentPos to aPos and modifys aPos to the relative position within the new current window

//

	{

	if (iRootWindow)

		SetCurrentWindow(iRootWindow->PointerWindow(iCurrentPos,&aPos,&aParentPos,iGrabWindow,iActualWinPointerIsOver

																										,aForceInGroup));

	else

		iCurrentWindow=NULL;

	}

void WsPointer::ReLogCurrentWindow()

//

// Relog the current pointer window when the window layout has changed.

//

	{

	if (iCurrentWindow)	// NULL iCurrentWindow means pointer is up so don't relog it

		SetCurrentWindow(iRootWindow->PointerWindow(iCurrentPos,NULL,NULL,iGrabWindow,iActualWinPointerIsOver,NULL));

	}

void WsPointer::ReLogWindow(const CWsWindow *aWin)

//

// Called when a window has changed it's filter state, will trigger a 'Enter' message if the window

// is the current window

//

	{

	if (aWin==iCurrentWindow)

		SendEnterExitEvent(EEventPointerEnter);

	}

void WsPointer::UnmatchedDownPurged(TPointerEvent::TType aPointerType, TUint aHandle)

	{

	if (aPointerType==TPointerEvent::EButton1Up && iGrabWindow && iGrabWindow->ClientHandle()==aHandle)

		{

		if (iGrabWindow && iGrabWindow->ClientHandle()==aHandle)

			iGrabWindow=NULL;

		if (iRepeatWindow && iRepeatWindow->ClientHandle()==aHandle)

			CancelPointerRepeatEventRequest();

		}

	switch(aPointerType)

		{

		case TPointerEvent::EButton1Up:

			iLastUnmatchedDown1=aHandle;

			break;

		case TPointerEvent::EButton2Up:

			iLastUnmatchedDown2=aHandle;

			break;

		case TPointerEvent::EButton3Up:

			iLastUnmatchedDown3=aHandle;

			break;

		default:;

		}

	}

void WsPointer::WindowDisconected(const CWsWindow *deletedWindow)

	{

	if (iRepeatWindow==deletedWindow)

		CancelPointerRepeatEventRequest();

	if (iGrabWindow==deletedWindow)

		iGrabWindow=NULL;

	if (iCurrentWindow==deletedWindow)

		{

		ReLogCurrentWindow();

		UpdatePointerCursor();

		}

	}

TEventQueueWalkRet RemovePointerUpFunc(TAny *aHandle, TWsEvent *aEvent)

//

// Callback function pointer for up event remove event queue walk

//

	{

	if (aEvent->Type()==EEventPointer && aEvent->Pointer()->iType==TPointerEvent::EButton1Up && (*(TUint *)aHandle)==aEvent->Handle())

		return(EEventQueueWalkDeleteEvent);

	return(EEventQueueWalkOk);

	}

void WsPointer::ClaimGrab(const CWsWindow *aWindow,TBool aSendUpEvent)

//

// If the pointer is down claim grab in aWindow as though the down event had gone to this window

// also send an up event to the window (if any) that would receive it the pointer was released now

//

	{

	TInt modState=TWindowServerEvent::GetModifierState();

	TWsEvent event;

	TPointerEvent& pointerEvent=*event.Pointer();

	pointerEvent.iModifiers=modState;

	pointerEvent.iPosition=iCurrentPos;

	if (iPointerDown)

		{

		if (iCurrentWindow!=aWindow)

			{

			if (aSendUpEvent)

				ProcessEvent(TPointerEvent::EButton1Up,iCurrentPos,modState,NULL,EFalse);

			else // If up event already in queue purge it

				{

				TUint handle=iCurrentWindow->ClientHandle();

				iCurrentWindow->EventQueue()->WalkEventQueue(&RemovePointerUpFunc,&handle);

				}

			iPointerDown=ETrue;

			if (aWindow->HasPointerGrab())

				iGrabWindow=aWindow;

			ReLogCurrentWindow(pointerEvent.iPosition,pointerEvent.iParentPosition,NULL);

			pointerEvent.iType=TPointerEvent::EDrag;

			ProcessPointerEvent(event);

			}

		}

	else

		{

		const CWsWindow *current=iCurrentWindow;

		iCurrentWindow=aWindow;

		WS_ASSERT_DEBUG(iGrabWindow==NULL, EWsPanicPointerClaimGrab);

		iGrabWindow=aWindow;	// Force the up event to be sent to aWindow

		ReLogCurrentWindow(pointerEvent.iPosition,pointerEvent.iParentPosition,NULL);

		pointerEvent.iType=TPointerEvent::EButton1Up;

		ProcessPointerEvent(event);

		iGrabWindow=NULL;

		iCurrentWindow=current;

		}

	}

TBool WsPointer::CheckDownEventPurged(TPointerEvent::TType aType)

	{

	switch(aType)

		{

		TUint lastUnmatchedDown;

		case TPointerEvent::EButton1Up:

			lastUnmatchedDown=iLastUnmatchedDown1;

			iLastUnmatchedDown1=0;

			goto lastUnmatchedDownCheck;

		case TPointerEvent::EButton2Up:

			lastUnmatchedDown=iLastUnmatchedDown2;

			iLastUnmatchedDown2=0;

			goto lastUnmatchedDownCheck;

		case TPointerEvent::EButton3Up:

			lastUnmatchedDown=iLastUnmatchedDown3;

			iLastUnmatchedDown3=0;

lastUnmatchedDownCheck:

		if (lastUnmatchedDown==iCurrentWindow->ClientHandle())

			return ETrue; // Don't deliver the event as we've already thrown away the down

		default:		//Should never get to default

			break;

		}

	return EFalse;

	}

TBool WsPointer::QueuePointerEvent(const CWsWindow *aWindow, TWsEvent &aEvent)

	{

	CWsClient *client=aWindow->WsOwner();

	if (client)

		{

		CEventQueue *queue=aWindow->EventQueue();

		aEvent.SetHandle(aWindow->ClientHandle());

		if (aEvent.Handle()!=0)

			{

			if (aEvent.Pointer()->iType==TPointerEvent::EMove || aEvent.Pointer()->iType==TPointerEvent::EDrag)

				{

				queue->Wait();

				const TWsEvent *prev=queue->PeekLastEvent();

				if (prev!=NULL && prev->Type()==EEventPointer && prev->Handle()==aEvent.Handle() && prev->Pointer()->iType==aEvent.Pointer()->iType)

					{

					queue->UpdateLastEvent(aEvent);

					return EFalse;

					}

				queue->Signal();

				}

			TWservEventPriorities priority=EEventPriorityLow;

			switch (aEvent.Pointer()->iType)

				{

				case TPointerEvent::EButton1Up:

				case TPointerEvent::EButton2Up:

				case TPointerEvent::EButton3Up:

					if (CheckDownEventPurged(aEvent.Pointer()->iType))

						return ETrue;

					if (queue->CheckRoom())

						{

						if (CheckDownEventPurged(aEvent.Pointer()->iType))

							return ETrue;

						} 

					/*Fall Through if an event was not purged*/

				case TPointerEvent::EButton1Down:

				case TPointerEvent::EButton2Down:

				case TPointerEvent::EButton3Down:

					priority=EEventPriorityHigh;

					break;

				default:;

				}

			queue->QueueEvent(aEvent,priority);

			}

		}

	return EFalse;

	}

void WsPointer::ProcessForegroundCheck()

	{

	CWsWindowGroup *group=iCurrentWindow->WinGroup();

	if (group->iFlags&CWsWindowGroup::EGroupFlagAutoForeground)

		group->SetOrdinalPosition(0);

	}

void WsPointer::ProcessPointerEvent(TWsEvent& aEvent)

	{

	if (iCurrentWindow && iCurrentWindow!=iRootWindow)

		{

		aEvent.SetType(EEventPointer);

		aEvent.SetTimeNow();

		TPointerEvent::TType type=aEvent.Pointer()->iType;

		switch(type)

			{

			//TUint lastUnmatchedDown;

			case TPointerEvent::EButton1Down:

				ProcessForegroundCheck(); 

				/*Fall Through*/

			case TPointerEvent::EButton2Down:

			case TPointerEvent::EButton3Down:

				{

				TPoint& pos=aEvent.Pointer()->iPosition;

				if (iCurrentWindow==iPrevClickWindow &&

					type==iPrevClickEventType &&

					(Abs(pos.iX-iPrevClickPos.iX)+Abs(pos.iY-iPrevClickPos.iY))<iDoubleClickMaxDistance &&

					aEvent.Time()<(iPrevClickTime+iDoubleClickMaxInterval))

					{

					aEvent.Pointer()->iModifiers|=EModifierDoubleClick;

					iPrevClickWindow=NULL;	// Set to NULL to block a double double click

					}

				else

					iPrevClickWindow=iCurrentWindow;

				iPrevClickEventType=type;

				iPrevClickPos=pos;

				iPrevClickTime=aEvent.Time();

				}

				break;

			default:

				break;

			}

		if (iRepeatWindow)

			{

			if (PointerEventRepeatCheck(&aEvent, iCurrentWindow->ClientHandle()))

				return;

			CancelPointerRepeatEventRequest();

			}

		if (QueuePointerEvent(iCurrentWindow, aEvent))

			return;

		if (iCurrentWindow->DragDropCapture())

			{

			aEvent.SetType(EEventDragDrop);

			QueuePointerEvent(iActualWinPointerIsOver, aEvent);

			}

		}

	}

TInt PointerTimerCallBack(TAny *)

	{

	WsPointer::TimerExpired();

	return(KErrNone);

	}

void WsPointer::RestrictPos(TPoint& aPos,TBool aWithinDrawableArea/*=ETrue*/)

	{

	CScreen* screen = iRootWindow->Screen();

	WS_ASSERT_DEBUG(screen->IsValidScreenSizeMode(screen->ScreenSizeMode()), EWsPanicInvalidScreenSizeMode);

#if defined(__WINS__)

	if (aWithinDrawableArea)

		{

		if (!DeltaMouse() && !TRect(screen->DrawableArea()).Contains(aPos))

			{

			return;			//Not in the drawable area so user may be trying to click on facia button.

			}

		}

#endif

	TRect validRect=screen->GetPointerCursorArea(screen->ScreenSizeMode());

	if (aPos.iX<validRect.iTl.iX)

		aPos.iX=validRect.iTl.iX;

	else if (aPos.iX>=validRect.iBr.iX)

		aPos.iX=validRect.iBr.iX-1;

	if (aPos.iY<validRect.iTl.iY)

		aPos.iY=validRect.iTl.iY;

	else if (aPos.iY>=validRect.iBr.iY)

		aPos.iY=validRect.iBr.iY-1;

	}

#if defined(__WINS__)

TBool WsPointer::PreProcessEvent(TRawEvent &aRawEvent,TBool aFromHardware/*=EFlase*/)

#else

TBool WsPointer::PreProcessEvent(TRawEvent &aRawEvent)

#endif

	{

#if defined(__WINS__)

	WS_ASSERT_DEBUG(TRawEvent::EPointerMove==1, EWsPanicRawEventsTypeChanged);

	WS_ASSERT_DEBUG(TRawEvent::EPointerMove+1==TRawEvent::EPointerSwitchOn, EWsPanicRawEventsTypeChanged);

	WS_ASSERT_DEBUG(TRawEvent::EPointerSwitchOn+8==TRawEvent::EButton1Down, EWsPanicRawEventsTypeChanged);

	WS_ASSERT_DEBUG(TRawEvent::EButton1Down+5==TRawEvent::EButton3Up, EWsPanicRawEventsTypeChanged);

#endif

	TRawEvent::TType type=aRawEvent.Type();

	if (type<TRawEvent::EPointerMove || (type>TRawEvent::EPointerSwitchOn && type<TRawEvent::EButton1Down)

																						|| type>TRawEvent::EButton3Up)

		return ETrue;

	if (!XyInput())

		return EFalse;

	TPoint xy=aRawEvent.Pos();

	if (DeltaMouse())

		{

	#if defined(__WINS__)

		if (aFromHardware)

			return EFalse;

	#endif

		if (type==TRawEvent::EPointerMove)

			{

			xy+=iCurrentPos;

			RestrictPos(xy);

			}

		else

			xy=iCurrentPos;

		}

	else

		{

		CScreen* screen=iRootWindow->Screen();

	#if !defined(__WINS__)

		TSize screenSize=screen->ScreenDevice()->SizeInPixels()-TSize(1,1);             //This is in the current rotation

		switch (screen->Orientation())

			{

			case CFbsBitGc::EGraphicsOrientationRotated90:

				xy.SetXY(xy.iY,screenSize.iHeight-xy.iX);

				break;

			case CFbsBitGc::EGraphicsOrientationRotated180:

				xy=-(xy-screenSize);

				break;

			case CFbsBitGc::EGraphicsOrientationRotated270:

				xy.SetXY(screenSize.iWidth-xy.iY,xy.iX);

				break;

			default:;		//To stop warning

			}

	#endif

		// Move the raw event position by shifting it by Origin and scale

		xy=screen->PhysicalToLogical(xy);

		RestrictPos(xy);

		}

	aRawEvent.Set(type,xy.iX,xy.iY);

	return ETrue;

	}

void WsPointer::ProcessEvent(TPointerEvent::TType aType, const TPoint &aPos, TUint aModifiers

																				,const CWsWindowGroup *aForceInGroup,TBool aNatural)

	{

	iCurrentPos=aPos;

	if (aType==TPointerEvent::EMove && !MovesAvailable() && !iPointerDown)

		return;

	TPoint pos(iCurrentPos);	// We need a non-const TPoint for 'ReLogCurrentWindow'

	TPoint parPos;

	ReLogCurrentWindow(pos,parPos,aForceInGroup);

	TWsEvent event;

	TPointerEvent& pointerEvent=*event.Pointer();

	pointerEvent.iModifiers=aModifiers;

	pointerEvent.iPosition=pos;

	pointerEvent.iParentPosition=parPos;

	switch(aType)

		{

		case TPointerEvent::EButton1Down:

			iPointerDown=ETrue;

			if (iGrabWindow==NULL && iCurrentWindow->HasPointerGrab())

				iGrabWindow=iCurrentWindow;

			if (!MovesAvailable() && iCurrentWindow->PointerFilter()&EPointerGenerateSimulatedMove)

				{

				pointerEvent.iType=TPointerEvent::EMove;

				ProcessEvent(event);

				}

			break;

		case TPointerEvent::EButton1Up:

			iPointerDown=EFalse;

			iGrabWindow=NULL;

			break;

		case TPointerEvent::EMove:

			if (iPointerDown)

				aType=TPointerEvent::EDrag;

			break;

		default:;

		}

	pointerEvent.iType=aType;

	if (aNatural && CClick::IsHandler())

		{

		CClick::PointerEvent(iCurrentPos,pointerEvent);

		TPointerEventData params;

		params.iVersion=0;

		params.iCurrentPos=iCurrentPos;

		params.iPointerEvent.iType 		= pointerEvent.iType;

		params.iPointerEvent.iModifiers = pointerEvent.iModifiers;

		params.iPointerEvent.iPosition  = pointerEvent.iPosition;

		params.iPointerEvent.iParentPosition = pointerEvent.iParentPosition;

		params.iClientHandle=iCurrentWindow->ClientHandle();

		params.iWindowOrigin=iCurrentWindow->Origin();

		CWsWindowGroup* groupWin=iCurrentWindow->WinGroup();

		params.iWindowGroupId=groupWin ? groupWin->Identifier() : 0;

		params.iSource=TPointerEventData::EUnspecified;

		CClick::OtherEvent(EEventPointer,&params);

		}

	ProcessEvent(event);

	}

void WsPointer::ProcessEvent(TWsEvent& aEvent)

	{

	TUint filter=iCurrentWindow->PointerFilter();

	TPointerEvent::TType type=aEvent.Pointer()->iType;

	if ((type!=TPointerEvent::EMove || !(filter&EPointerFilterMove)) &&

		 (type!=TPointerEvent::EDrag || !(filter&EPointerFilterDrag)))

		{

		TPoint pos=aEvent.Pointer()->iPosition;

		if ((type==TPointerEvent::EMove || type==TPointerEvent::EDrag) && iCurrentWindow->UsingPointerBuffer())

			CWsPointerBuffer::PointerEvent((CWsClientWindow *)iCurrentWindow,pos);

		else if (!WsKeyboardEmulator::PointerEvent(type,pos,iCurrentWindow->PointerKeyList()))

			ProcessPointerEvent(aEvent);

		}

	if (!MovesAvailable() && (type==TPointerEvent::EButton1Up || type==TPointerEvent::ESwitchOn))

		iCurrentWindow=NULL;

	PointerCursorUpdateCheck();

	}

void WsPointer::TimerExpired()

	{

	WS_ASSERT_DEBUG(iTimerQueued, EWsPanicPointerTimer);

	if (iUpdateRequired)

		{

		UpdatePointerCursor();

		iUpdateRequired=EFalse;

		}

	else

		{

		iTimerQueued=EFalse;

		iPeriodicTimer->Cancel();

		}

	}

void WsPointer::GetDoubleClickSettings(TTimeIntervalMicroSeconds32 &aTime, TInt &aDistance)

	{

	aTime=iDoubleClickMaxInterval;

	aDistance=iDoubleClickMaxDistance;

	}

void WsPointer::SetDoubleClick(const TTimeIntervalMicroSeconds32 &aTime, TInt aDistance)

	{

	iDoubleClickMaxInterval=aTime;

	iDoubleClickMaxDistance=aDistance;

	}

void WsPointer::PointerCursorUpdateCheck()

	{

	CWsPointerCursor *sprite=CalculatePointerCursor();

	if (iCursorSprite || sprite)	// If there either was, or is a pointer cursor we need an update

		{

		if (!iTimerQueued)

			{

			UpdatePointerCursorTo(sprite);

			iPeriodicTimer->Start(TTimeIntervalMicroSeconds32(EPointerUpdateGapInMicroSeconds),

									TTimeIntervalMicroSeconds32(EPointerUpdateGapInMicroSeconds),

									  TCallBack(PointerTimerCallBack,NULL));

			iTimerQueued=ETrue;

			}

		else

			iUpdateRequired=ETrue;

		}

	}

void WsPointer::UpdatePointerCursor()

	{

//__PROFILE_START(3);

	CWsPointerCursor *sprite=CalculatePointerCursor();

	UpdatePointerCursorTo(sprite);

//__PROFILE_END(3);

	}

void WsPointer::UpdatePointerCursorTo(CWsPointerCursor* aNewCursor)

	{

	CScreen* screen=NULL;

	if (iCursorSprite!=aNewCursor)

		{

		if (iCursorSprite)

			{

			iCursorSprite->Deactivate();

			screen=iCursorSprite->Screen();		//This will need changing ##

			}

		iCursorSprite=aNewCursor;

		if (iCursorSprite)

			{

			iCursorSprite->SetPos(iCurrentPos);

			iCursorSprite->Activate();

			}

		goto Update;

		}

	else if (iCursorSprite)

		{

		iCursorSprite->SetPos(iCurrentPos);

	Update:

		if (!screen)

			screen=iCursorSprite->Screen();

		screen->Update();

		}

	}

CWsPointerCursor* WsPointer::CalculatePointerCursor()

	{

	CWsPointerCursor *sprite=NULL;

	if (iCurrentWindow && (iPointerCursorMode==EPointerCursorNormal || iPointerCursorMode==EPointerCursorWindow))

		{

		const CWsWindowBase* window=iCurrentWindow;

		do	{

			sprite=window->PointerCursor();

			if (window->WinType()!=EWinTypeClient)

				break;

			window=window->BaseParent();

			} while (!sprite);

		}

	if (!sprite && iCurrentWindow && (iPointerCursorMode==EPointerCursorFixed || iPointerCursorMode==EPointerCursorNormal))

		sprite=CWsClient::DefaultSystemPointerCursor();

	return sprite;

	}

TEventQueueWalkRet PointerRepeatPurgeFunc(TAny *, TWsEvent *aEvent)

//

// Callback function for event queue walk

//

	{

	return(WsPointer::PointerRepeatPurgeCheck(aEvent));

	}

TBool WsPointer::PointerEventRepeatCheck(const TWsEvent *aEvent, TUint32 aHandle)

//

// Return ETrue if this pointer event is consumed by the pointer repeat

//

	{

	TPointerEvent *pntEvent=aEvent->Pointer();

	if (aHandle==iRepeatWindow->ClientHandle() && 

		 (pntEvent->iType==TPointerEvent::EDrag || pntEvent->iType==TPointerEvent::EMove) &&

		  iRepeatRect.Contains(pntEvent->iPosition))

		return(ETrue);

	return(EFalse);

	}

TEventQueueWalkRet WsPointer::PointerRepeatPurgeCheck(const TWsEvent *aEvent)

	{

	if (iRepeatWindow && aEvent->Type()==EEventPointer)

		{

		if (PointerEventRepeatCheck(aEvent,aEvent->Handle()))

			return(EEventQueueWalkDeleteEvent);	// Purge the event as it is a move/drag within the repeat rect

		CancelPointerRepeatEventRequest();

		}

	return(EEventQueueWalkOk);

	}

void WsPointer::RequestPointerRepeatEvent(CWsWindow *aWindow, TTimeIntervalMicroSeconds32 aTime,const TRect &aRect)

	{

	CancelPointerRepeatEventRequest();

	iRepeatWindow=aWindow;

	iRepeatRect=aRect;

	iRepeatTimer->After(aTime);

	aWindow->EventQueue()->WalkEventQueue(&PointerRepeatPurgeFunc,NULL);

	if (iRepeatWindow && !iRepeatRect.Contains(iCurrentPos-iRepeatWindow->Origin()))

		CancelPointerRepeatEventRequest();

	}

void WsPointer::CancelPointerRepeatEventRequest()

	{

	if (iRepeatWindow)

		{

		iRepeatWindow=NULL;

		iRepeatTimer->Cancel();

		}

	}

void WsPointer::RepeatTimerCompleted()

	{

	TWsEvent event;

	event.SetType(EEventPointer);

	event.SetTimeNow();

	event.Pointer()->iModifiers=TWindowServerEvent::GetModifierState();

	event.Pointer()->iPosition=iCurrentPos-iRepeatWindow->Origin();

	event.Pointer()->iParentPosition=iCurrentPos-iRepeatWindow->BaseParent()->Origin();

	event.Pointer()->iType=TPointerEvent::EButtonRepeat;

	QueuePointerEvent(iRepeatWindow, event);

	iRepeatWindow=NULL;

	}

#if defined(__WINS__)

void WsPointer::SetXyInputType(TXYInputType aXyInputType)

	{

	if (iXyInputType>EXYInputPointer && aXyInputType<EXYInputMouse && !iPointerDown)

		{

		iCurrentWindow=NULL;

		UpdatePointerCursor();

		}

	else if (iXyInputType<EXYInputMouse && aXyInputType>EXYInputPointer && !iPointerDown)

		{

		TPoint pos(iCurrentPos);

		TPoint parPos;

		ReLogCurrentWindow(pos,parPos,NULL);

		UpdatePointerCursor();

		}

	iXyInputType=aXyInputType;

	}

#endif

//

CWsPointerTimer::CWsPointerTimer() : CTimer(EPointerRepeatPriority)

	{}

void CWsPointerTimer::ConstructL()

	{

	CTimer::ConstructL();

	CActiveScheduler::Add(this);

	}

void CWsPointerTimer::RunL()

	{

	User::ResetInactivityTime();

	WS_ASSERT_DEBUG(iStatus.Int()==KErrNone, EWsPanicPointerRepeatTimerStatus);

	WsPointer::RepeatTimerCompleted();

	}

//

CWsPointerBuffer::~CWsPointerBuffer()

	{

	if (this == iCurrentBuffer)

		{

		// We're about to be destroyed - don't want to be pointed at any more.

		iCurrentBuffer = NULL;

		}

	iList.Remove(*this);

	}

void CWsPointerBuffer::ConnectL(CWsClientWindow *aWindow, TInt aMaxPoints, TUint aFlags)

	{

	CWsPointerBuffer *pb=NULL;

	for(TSglQueIter<CWsPointerBuffer> iter(iList);(pb=iter++)!=NULL;)

		if (pb->iWindow==aWindow)

			User::Leave(KErrInUse);

	CWsPointerBuffer *pbuf=new(ELeave) CWsPointerBuffer;

	pbuf->iWindow=aWindow;

	pbuf->iMaxPoints=aMaxPoints;

	pbuf->iFlags=aFlags;

	iList.AddFirst(*pbuf);

	CleanupStack::PushL(pbuf);

	AdjustMaxSizeL();

	CleanupStack::Pop();

	}

void CWsPointerBuffer::Disconnect(CWsClientWindow *aWindow)

	{

	CWsPointerBuffer *pb=NULL;

	for(TSglQueIter<CWsPointerBuffer> iter(iList);(pb=iter++)!=NULL;)

		{

		if (pb->iWindow==aWindow)

			{

			delete pb; // Note that the destructor also sets iCurrentBuffer to NULL if it is pointing at pb

			TRAP_IGNORE(AdjustMaxSizeL());	// Shouldn't fail, but doesn't matter if it does as we simply have a larger buffer than needed

			break; // from for loop

			}

		}

	}

void CWsPointerBuffer::Reset()

	{

	iSignalled=EFalse;

	iPointerBuffer->Reset();

	}

void CWsPointerBuffer::SignalBufferReady()

	{

	if (!iSignalled)

		if (iCurrentBuffer && iCurrentBuffer->iWindow->QueueEvent(EEventPointerBufferReady))

			iSignalled=ETrue;

	}

void CWsPointerBuffer::PointerEvent(CWsClientWindow *aWindow,const TPoint &aPoint)

	{

	if (iCurrentBuffer==NULL || aWindow!=iCurrentBuffer->iWindow)

		{

		Reset();

		CWsPointerBuffer *pb=NULL;

		for(TSglQueIter<CWsPointerBuffer> iter(iList);(pb=iter++)!=NULL;)

			{

			if (pb->iWindow==aWindow)

				{

				iCurrentBuffer=pb;

				break; // from for loop

				}

			}

		}

	iPointerBuffer->Add(&aPoint);

	SignalBufferReady();

	}

void CWsPointerBuffer::RetrievePointerMoveBuffer(CWsClientWindow *aWindow,TInt aMaxPoints)

	{

	enum {KPointerMoveBufferSize=32};	// Puts 256 bytes on the stack

	if (iCurrentBuffer && aWindow==iCurrentBuffer->iWindow)

		{

		iSignalled=EFalse;

		TInt max=Min(aMaxPoints,iPointerBuffer->Count());

		TInt buflen=0;

		aWindow->WsOwner()->SetReply(max);

		TPoint point;

		TBuf8<KPointerMoveBufferSize*sizeof(TPoint)> pnts;

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

			{

			iPointerBuffer->Remove(&point);

			pnts.Append((TUint8 *)&point,sizeof(TPoint));

			buflen++;

			if (buflen==KPointerMoveBufferSize)

				{

				CWsClient::ReplyBuf(pnts);

				pnts.Zero();

				buflen=0;

				}

			}

		if (buflen>0)

			CWsClient::ReplyBuf(pnts);

		if (iPointerBuffer->Count())

			SignalBufferReady();

		}

	}

void CWsPointerBuffer::DiscardPointerMoveBuffer(TUint aHandle)

	{

	if (iCurrentBuffer && aHandle==iCurrentBuffer->iWindow->ClientHandle())

		Reset();

	}

void CWsPointerBuffer::DiscardPointerMoveBuffer(CWsClientWindow *aWindow)

	{

	if (iCurrentBuffer && aWindow==iCurrentBuffer->iWindow)

		Reset();

	}

void CWsPointerBuffer::AdjustMaxSizeL()

	{

	TInt max=0;

	CWsPointerBuffer *pb=NULL;

	for(TSglQueIter<CWsPointerBuffer> iter(iList);(pb=iter++)!=NULL;)

		if (pb->iMaxPoints>max)

			max=pb->iMaxPoints;

	if (max==0)

		{

		delete iPointerBuffer;

		iPointerBuffer=NULL;

		}

	else if (!iPointerBuffer)

		{

		CCirBuf<TPoint> *pointerBuffer=new(ELeave) CCirBuf<TPoint>;

		CleanupStack::PushL(pointerBuffer);

		pointerBuffer->SetLengthL(max);

		CleanupStack::Pop();

		iPointerBuffer=pointerBuffer;

		}

	else

		iPointerBuffer->SetLengthL(max);

	}