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

// 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 <hal.h>

#include "advancedpointereventhelper.h"

#include "graphics/pointereventdata.h"

TTimeIntervalMicroSeconds32 TWsPointer::iDoubleClickMaxInterval;

TInt 			   TWsPointer::iDoubleClickMaxDistance;

CWsPointerCursor*  TWsPointer::iCursorSprite;

TPointerCursorMode TWsPointer::iPointerCursorMode=EPointerCursorNormal;

TXYInputType 	   TWsPointer::iXyInputType;

TBool 			   TWsPointer::iTimerQueued;

TBool 			   TWsPointer::iUpdateRequired;

CPeriodic* 		   TWsPointer::iPeriodicTimer;

CWsRootWindow*     TWsPointer::iRootWindow;

TInt			   TWsPointer::iMaxPointers;

TBool			   TWsPointer::iIs3DPointer;

RArray<TWsPointer> TWsPointer::iPointers;

TInt 			   TWsPointer::iPrimaryPointer = TAdvancedPointerEvent::EDefaultPointerNumber;

TInt			   TWsPointer::iPreviousPrimaryPointer;

TInt			   TWsPointer::iEnterCloseProximityThreshold;

TInt			   TWsPointer::iExitCloseProximityThreshold;

TInt			   TWsPointer::iEnterHighPressureThreshold;

TInt			   TWsPointer::iExitHighPressureThreshold;

TBool			   CWsPointerBuffer::iSignalled=EFalse;

CWsPointerBuffer*  CWsPointerBuffer::iCurrentBuffer=NULL;

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

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

TInt                TWsPointer::iYOffset;

#if defined(__WINS__)

TBool               TWsPointer::iEmulatorRotatePointerCoords;

#endif

static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);

void TWsPointer::InitStaticsL()

	{

	//This iYOffset setting is specific for capacitive touch screens, where user's finger is the pointer device.

	//This is typically used so that the pointer event location is more inline with where the user perceives their 

	//finger to be on the screen (for example, due to refraction and the relatively large touch area of a finger).

	iYOffset = 0;

    _LIT( KWSERVIniFileVarYShifting, "YSHIFTING");

    TBool fetchingSucceeded = WsIniFile->FindVar(KWSERVIniFileVarYShifting, iYOffset);

    WS_ASSERT_ALWAYS(iYOffset>=0, EWsPanicInvalidPointerOffset);

    if ( !fetchingSucceeded )

       {

       iYOffset = 0;

       }

#if defined(__WINS__)    

	//An emulator may or may not deploy a renderchain or displaydriver that supports rotated drawing.

	//On a real device target the coordinate system is always rotated together with wserv's screendevice.

	_LIT( KWSERVIniFileVarEmulatorRotPointCoords, "EMULATOR_ROTATE_POINTER_COORDS");

	iEmulatorRotatePointerCoords = WsIniFile->FindVar(KWSERVIniFileVarEmulatorRotPointCoords);

#endif

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

	TMachineInfoV1Buf machineInfo;

	UserHal::MachineInfo(machineInfo);

	iXyInputType=machineInfo().iXYInputType;

	// Read EPointerMaxPointers from HAL and check if reported value is consistent

	// with iXyInputType.

	// Even if HAL reports that device doesn't support any pointer, WSERV

	// always has to support at least one pointer for compatibility reasons

	// and for keeping state of pointer cursor.

	if(HAL::Get(HALData::EPointerMaxPointers,iMaxPointers)!=KErrNone)

		{

		iMaxPointers = 1;

		}

	else

		{

		WS_ASSERT_ALWAYS(iMaxPointers >= 0 && iMaxPointers <= TAdvancedPointerEvent::EMaximumWServNumberOfPointers,

						 EWsPanicMaxPointersOutOfRange);

		WS_ASSERT_ALWAYS(( XyInput() && iMaxPointers >  0) || (!XyInput() && iMaxPointers == 0),

						 EWsPanicMaxPointersInconsistent);

		if (iMaxPointers == 0)

			{

			iMaxPointers = 1;

			}

		}

	// Does device support Z coordinate of the pointers?

	if(HAL::Get(HALData::EPointer3D,iIs3DPointer)!=KErrNone)

		{

		iIs3DPointer=EFalse; // No API, then no 3D pointers

		}

	WS_ASSERT_ALWAYS(!iIs3DPointer || XyInput(), EWsPanicPointer3DInconsistent);

	// Initialize thresholds for EEnterCloseProximity, EExitCloseProximity,

	// EEnterHighPressure and EExitHightPressure events.

	if(HAL::Get(HALData::EPointer3DEnterCloseProximityThreshold,

			iEnterCloseProximityThreshold) != KErrNone)

		{

		iEnterCloseProximityThreshold = KMaxTInt;

		}

	if(HAL::Get(HALData::EPointer3DExitCloseProximityThreshold,

			iExitCloseProximityThreshold) != KErrNone)

		{

		iExitCloseProximityThreshold  = KMinTInt;

		}

	if(HAL::Get(HALData::EPointer3DEnterHighPressureThreshold,

			iEnterHighPressureThreshold)  != KErrNone)

		{

		iEnterHighPressureThreshold   = KMaxTInt;

		}

	if(HAL::Get(HALData::EPointer3DExitHighPressureThreshold,

			iExitHighPressureThreshold)   != KErrNone)

		{

		iExitHighPressureThreshold    = KMinTInt;

		}

	iPointers = RArray<TWsPointer>(iMaxPointers);

	TWsPointer emptyPointer;	

	emptyPointer.iRepeatTimer = NULL;

	emptyPointer.Clear();

	for (TInt ii = 0; ii < iMaxPointers; ii++)

		{

		emptyPointer.iNumber = ii;

		User::LeaveIfError(iPointers.Append(emptyPointer));

		RepeatTimer(ii) = CWsPointerTimer::NewL(iPointers[ii]);

		}

	iPeriodicTimer=CPeriodic::NewL(EPointerCursorPriority);

	}

void TWsPointer::Clear()

	{

	iState = EPointerStateOutOfRange;

	iPos.iX = 0;

	iPos.iY = 0;

	iPressureProximity = 0;

	iCurrentWindow=MovesAvailable() ? iRootWindow : NULL;

	iActualWinPointerIsOver = NULL;

	iGrabWindow = NULL;

	iLastUnmatchedDown1 = NULL;

	iLastUnmatchedDown2 = NULL;

	iLastUnmatchedDown3 = NULL;

	iLastUnmatchedEnterHighPressure = NULL;

	iPrevClickWindow = NULL;

	iInCloseProximity = EFalse;

	iInHighPressure = EFalse;

	CancelPointerRepeatEventRequest();	

	}

/**

Turns off pointer cursor, deletes permenently pointer cursor update timer and pointer event repeat timer.

*/

void TWsPointer::Stop()

	{

	SetPointerCursorMode(EPointerCursorNone);

	UpdatePointerCursor();

	delete iPeriodicTimer;

	}

void TWsPointer::DeleteStatics()

	{

	for (TInt ii = 0; ii < iMaxPointers; ii++)

		{

		delete RepeatTimer(ii);	

		}		

	iPointers.Close();

	}

void TWsPointer::SetPointerCursorPos(TPoint aPos)

	{

	RestrictPos(aPos,EFalse);

	iPointers[iPrimaryPointer].iPos=aPos; 

	iPointers[iPrimaryPointer].ReLogCurrentWindow();

	UpdatePointerCursor();

	}

void TWsPointer::SendEnterExitEvent(TEventCode aType)

	{

	if (iCurrentWindow

		&& (iState != EPointerStateOutOfRange)

		&& (iNumber == iPrimaryPointer || iCurrentWindow->AdvancedPointersEnabled())

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

		&& !iCurrentWindow->ShutDownInProgress())

		{

		iCurrentWindow->QueueEvent(aType, iNumber);

		}

	}

void TWsPointer::SetCurrentWindow(const CWsWindow* aWin)

	{

	if (aWin!=iCurrentWindow)

		{

		SendEnterExitEvent(EEventPointerExit);

		iCurrentWindow=aWin;

		SendEnterExitEvent(EEventPointerEnter);

		}

	}

/**

Relogs the current window (sets iCurrentWindow) for this pointer. 

Retrieves pointer relative position in current window and pointer position in current 

window's parent window. 

*/

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

	{

	if (iRootWindow)

		{

		SetCurrentWindow(iRootWindow->PointerWindow(iPos,&aPos,&aParentPos,iGrabWindow,

				                                    iActualWinPointerIsOver,aForceInGroup));

		}

	else

		{

		iCurrentWindow=NULL;

		}

	}

/**

Relog all pointer's current windows when the window layout has changed.

*/

void TWsPointer::ReLogPointersCurrentWindows()

	{

	for (TInt ii = 0; ii < iMaxPointers; ii++)

		{

		TWsPointer& pointer = iPointers[ii];

		pointer.ReLogCurrentWindow();

		}

	}

/*

Relog this pointer's current pointer window when the window layout has changed.

Works similarly to ReLogCurrentWindow(TPoint &aPos, TPoint &aParentPos, const CWsWindowGroup* aForceInGroup),

but doesn't set relative positions.

*/

void TWsPointer::ReLogCurrentWindow()

	{

	if (iCurrentWindow)

		{

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

		}

	}

/*

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

is the current window

*/

void TWsPointer::ReLogWindow(const CWsWindow* aWin)

	{

	for (TInt ii = 0; ii < iMaxPointers; ii++)

		{

		if (aWin == iPointers[ii].iCurrentWindow)

			{

			iPointers[ii].SendEnterExitEvent(EEventPointerEnter);

			}

		}

	}

void TWsPointer::UnmatchedEventPurged(TPointerEvent::TType aPointerType, TUint aHandle)

	{

	if (aPointerType==TPointerEvent::EButton1Up)

		{

		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;

		case TPointerEvent::EExitHighPressure:

			iLastUnmatchedEnterHighPressure=aHandle;

			break;

		default:;

		}

	}

void TWsPointer::WindowDisconnected(const CWsWindow* deletedWindow)

	{

	for (TInt pointerNum = 0; pointerNum < iMaxPointers; pointerNum++)

		{

		TWsPointer& pointer = iPointers[pointerNum];

		if (pointer.iRepeatWindow==deletedWindow)

			{

			pointer.CancelPointerRepeatEventRequest();

			}		

		if (pointer.iGrabWindow==deletedWindow)

			{

			pointer.iGrabWindow=NULL;

			}

		if (pointer.iCurrentWindow==deletedWindow)

			{

			pointer.ReLogCurrentWindow();

			if (pointerNum == iPrimaryPointer)

				{

				UpdatePointerCursor();

				}

			}

		}

	}

/*

Callback function pointer for up event remove event queue walk

*/

TEventQueueWalkRet RemovePointerUpFunc(TAny* aHandle, TWsEvent* aEvent)

	{

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

		{

		return(EEventQueueWalkDeleteEvent);

		}

	return(EEventQueueWalkOk);

	}

/*

If the specified 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 if the 

pointer was released now.

If no pointer is specifed do the above for the primary pointer.

@return	KErrNone if successful,

		KErrNotFound if pointernumber out of range,

		KErrNotSupported if incorrect pointer grab claimed for window in emulation mode,

		KErrPermissionDenied if trying to grab from a different window owner without the required capability.

*/

TInt TWsPointer::ClaimGrab(const CWsWindow *aWindow,const TWsWinCmdGrabControl& aGrabControl)

	{

	TInt pointerNumber(aGrabControl.HasPointerNumber() ? aGrabControl.pointerNumber : iPrimaryPointer);

	TBool advancedPointersEnabled(aWindow->AdvancedPointersEnabled());

	TInt errNo(KErrNone);

	if(!advancedPointersEnabled	&& aGrabControl.HasPointerNumber() && (TAdvancedPointerEvent::EDefaultPointerNumber!=pointerNumber))

		{

		// The window is in emulation mode, and cannot get events for anything other than the primary pointer		

		errNo=KErrNotSupported;

		}

	else if(advancedPointersEnabled && ((pointerNumber<0) || (pointerNumber>=iMaxPointers)))

		{

		// Unknown pointer number

		errNo=KErrNotFound;

		}

	else if(aGrabControl.HasPointerNumber()	&& (aWindow->WsOwner()!=iPointers[pointerNumber].iCurrentWindow->WsOwner())

			&& !KSecurityPolicy_SwEvent().CheckPolicy(aWindow->WsOwner()->ClientMessage(), __PLATSEC_DIAGNOSTIC_STRING("Capability check failed for RWindowBase::ClaimPointerGrab")))

		{

		// Trying to grab from a different window owner requires the relevant permission

		//     - Only for the multipointer API, RWindowBase::ClaimPointerGrab(TInt, TBool), which provides a pointer number

		//     - Doing so for the legacy non-multipointer API, RWindowBase::ClaimPointerGrab(TBool), would be a compatibility break

		errNo=KErrPermissionDenied;

		}

	else

		{

		iPointers[pointerNumber].ClaimGrab(aWindow,aGrabControl.CheckFlags(TWsWinCmdGrabControl::ESendUpEvent));		

		}	

	return errNo;

	}

/*

If this 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 if the 

pointer was released now.

*/

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

	{	

	TInt modState=TWindowServerEvent::GetModifierState();

	TWsEvent event;

	TAdvancedPointerEvent& pointerEvent=*event.Pointer();

	TAdvancedPointerEventHelper::InitAdvancedPointerEvent(event, TPointerEvent::EButton1Up,modState,TPoint3D(iPos.iX,iPos.iY,iPressureProximity),iNumber);

	if (iState == EPointerStateDown)

		{

		if (iCurrentWindow!=aWindow)

			{

			if (aSendUpEvent)

				{

				ProcessEvent(event,NULL,EFalse);

				}

			else // If up event already in queue purge it

				{

				CEventQueue* eventQueue = iCurrentWindow->EventQueue();

				if (eventQueue)

					{

					TUint handle=iCurrentWindow->ClientHandle();

					eventQueue->WalkEventQueue(&RemovePointerUpFunc,&handle);

					}

				}

			iState = EPointerStateDown;

			if (aWindow->HasPointerGrab())

				{

				iGrabWindow=aWindow;

				}

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

			pointerEvent.iType=TPointerEvent::EDrag;

			ProcessPointerEvent(event);

			}

		}

	else if (iState == EPointerStateUp)

		{

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

		ProcessPointerEvent(event);

		iGrabWindow=NULL;

		iCurrentWindow=current;

		}

	}

/**

@return ETrue if matching event has been purged, so current event should not be delivered,

        EFalse otherwise.

*/

TBool TWsPointer::CheckMatchingEventPurged(TPointerEvent::TType aType)

	{

	switch(aType)

		{

		TUint lastUnmatchedDown;

		case TPointerEvent::EButton1Up:

			lastUnmatchedDown=iLastUnmatchedDown1;

			iLastUnmatchedDown1=0;

			iLastUnmatchedEnterHighPressure=0;

			goto lastUnmatchedDownCheck;

		case TPointerEvent::EButton2Up:

			lastUnmatchedDown=iLastUnmatchedDown2;

			iLastUnmatchedDown2=0;

			goto lastUnmatchedDownCheck;

		case TPointerEvent::EButton3Up:

			lastUnmatchedDown=iLastUnmatchedDown3;

			iLastUnmatchedDown3=0;

			goto lastUnmatchedDownCheck;

		case TPointerEvent::EExitHighPressure:

			lastUnmatchedDown=iLastUnmatchedEnterHighPressure;

			iLastUnmatchedEnterHighPressure=0;

lastUnmatchedDownCheck:

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

			{

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

			}

		default:		//Should never get to default

			break;

		}

	return EFalse;

	}

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

	{

	if (aWindow->WsOwner() &&

		(aWindow->AdvancedPointersEnabled() || 

		TAdvancedPointerEventHelper::PointerNumber(aEvent) == iPrimaryPointer))

		{

		CEventQueue* queue=aWindow->EventQueue();

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

		if (aEvent.Handle()!=0)

			{

 			if(!aWindow->AdvancedPointersEnabled())

 				{

 				// Re-assign from WServ primary pointer number, to EDefaultPointerNumber for Cone and other clients.

 				// This should not get confused with any real pointer of the same number due to the TWsEvents' window handle

 				// being different.

 				TAdvancedPointerEventHelper::SetPointerNumber(aEvent,TAdvancedPointerEvent::EDefaultPointerNumber);

 				aEvent.Pointer()->iModifiers&=~EModifierAdvancedPointerEvent;  // Clear the advanced pointer flag

 				}

			if (queue->UpdateLastPointerEvent(aEvent))

				{

				return EFalse;

				}

			TWservEventPriorities priority=EEventPriorityLow;

			switch (aEvent.Pointer()->iType)

				{

				case TPointerEvent::EButton1Up:

				case TPointerEvent::EButton2Up:

				case TPointerEvent::EButton3Up:

				case TPointerEvent::EExitHighPressure:

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

						{

						return ETrue;

						}

					if (queue->CheckRoom())

						{

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

							{

							return ETrue;

							}

						}

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

				case TPointerEvent::EButton1Down:

				case TPointerEvent::EButton2Down:

				case TPointerEvent::EButton3Down:

				case TPointerEvent::EEnterHighPressure:

				case TPointerEvent::EOutOfRange:

					priority=EEventPriorityHigh;

					break;

				default:;

				}