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

 	}