1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Pointer functions

    15 // 

    16 //

    17 

    18 #include <e32std.h>

    19 #include <e32hal.h>

    20 #include "W32CLICK.H"

    21 #include "pointer.h"

    22 #include "rootwin.h"

    23 #include "windowgroup.h"

    24 #include "KEYCLICK.H"

    25 #include "ScrDev.H"

    26 #include "EVENT.H"

    27 #include "panics.h"

    28 #include "wstop.h"

    29 #include "inifile.h"

    30 #include <hal.h>

    31 #include "advancedpointereventhelper.h"

    32 #include "graphics/pointereventdata.h"

    33 

    34 TTimeIntervalMicroSeconds32 TWsPointer::iDoubleClickMaxInterval;

    35 TInt 			   TWsPointer::iDoubleClickMaxDistance;

    36 CWsPointerCursor*  TWsPointer::iCursorSprite;

    37 TPointerCursorMode TWsPointer::iPointerCursorMode=EPointerCursorNormal;

    38 TXYInputType 	   TWsPointer::iXyInputType;

    39 TBool 			   TWsPointer::iTimerQueued;

    40 TBool 			   TWsPointer::iUpdateRequired;

    41 CPeriodic* 		   TWsPointer::iPeriodicTimer;

    42 CWsRootWindow*     TWsPointer::iRootWindow;

    43 TInt			   TWsPointer::iMaxPointers;

    44 TBool			   TWsPointer::iIs3DPointer;

    45 RArray<TWsPointer> TWsPointer::iPointers;

    46 TInt 			   TWsPointer::iPrimaryPointer = TAdvancedPointerEvent::EDefaultPointerNumber;

    47 TInt			   TWsPointer::iPreviousPrimaryPointer;

    48 TInt			   TWsPointer::iEnterCloseProximityThreshold;

    49 TInt			   TWsPointer::iExitCloseProximityThreshold;

    50 TInt			   TWsPointer::iEnterHighPressureThreshold;

    51 TInt			   TWsPointer::iExitHighPressureThreshold;

    52 TBool			   CWsPointerBuffer::iSignalled=EFalse;

    53 CWsPointerBuffer*  CWsPointerBuffer::iCurrentBuffer=NULL;

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

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

    56 TInt                TWsPointer::iYOffset;

    57 

    58 static _LIT_SECURITY_POLICY_C1(KSecurityPolicy_SwEvent,ECapabilitySwEvent);

    59 

    60 void TWsPointer::InitStaticsL()

    61 	{

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

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

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

    65 	iYOffset = 0;

    66     _LIT( KWSERVIniFileVarYShifting, "YSHIFTING");

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

    68     WS_ASSERT_ALWAYS(iYOffset>=0, EWsPanicInvalidPointerOffset);

    69     if ( !fetchingSucceeded )

    70        {

    71        iYOffset = 0;

    72        }

    73 	

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

    75 	

    76 	TMachineInfoV1Buf machineInfo;

    77 	UserHal::MachineInfo(machineInfo);

    78 	iXyInputType=machineInfo().iXYInputType;

    79 	

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

    81 	// with iXyInputType.

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

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

    84 	// and for keeping state of pointer cursor.

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

    86 		{

    87 		iMaxPointers = 1;

    88 		}

    89 	else

    90 		{

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

    92 						 EWsPanicMaxPointersOutOfRange);

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

    94 						 EWsPanicMaxPointersInconsistent);

    95 		if (iMaxPointers == 0)

    96 			{

    97 			iMaxPointers = 1;

    98 			}

    99 		}

   100 	

   101 	// Does device support Z coordinate of the pointers?

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

   103 		{

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

   105 		}

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

   107 	

   108 	// Initialize thresholds for EEnterCloseProximity, EExitCloseProximity,

   109 	// EEnterHighPressure and EExitHightPressure events.

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

   111 			iEnterCloseProximityThreshold) != KErrNone)

   112 		{

   113 		iEnterCloseProximityThreshold = KMaxTInt;

   114 		}

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

   116 			iExitCloseProximityThreshold) != KErrNone)

   117 		{

   118 		iExitCloseProximityThreshold  = KMinTInt;

   119 		}

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

   121 			iEnterHighPressureThreshold)  != KErrNone)

   122 		{

   123 		iEnterHighPressureThreshold   = KMaxTInt;

   124 		}

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

   126 			iExitHighPressureThreshold)   != KErrNone)

   127 		{

   128 		iExitHighPressureThreshold    = KMinTInt;

   129 		}

   130 	

   131 	iPointers = RArray<TWsPointer>(iMaxPointers);

   132 	TWsPointer emptyPointer;	

   133 	emptyPointer.iRepeatTimer = NULL;

   134 	emptyPointer.Clear();

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

   136 		{

   137 		emptyPointer.iNumber = ii;

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

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

   140 		}

   141 	

   142 	iPeriodicTimer=CPeriodic::NewL(EPointerCursorPriority);

   143 	}

   144 

   145 void TWsPointer::Clear()

   146 	{

   147 	iState = EPointerStateOutOfRange;

   148 	iPos.iX = 0;

   149 	iPos.iY = 0;

   150 	iPressureProximity = 0;

   151 	iCurrentWindow=MovesAvailable() ? iRootWindow : NULL;

   152 	iActualWinPointerIsOver = NULL;

   153 	iGrabWindow = NULL;

   154 	iLastUnmatchedDown1 = NULL;

   155 	iLastUnmatchedDown2 = NULL;

   156 	iLastUnmatchedDown3 = NULL;

   157 	iLastUnmatchedEnterHighPressure = NULL;

   158 	iPrevClickWindow = NULL;

   159 	iInCloseProximity = EFalse;

   160 	iInHighPressure = EFalse;

   161 	CancelPointerRepeatEventRequest();	

   162 	}

   163 

   164 /**

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

   166 */

   167 void TWsPointer::Stop()

   168 	{

   169 	SetPointerCursorMode(EPointerCursorNone);

   170 	UpdatePointerCursor();

   171 	delete iPeriodicTimer;

   172 	}

   173 

   174 void TWsPointer::DeleteStatics()

   175 	{

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

   177 		{

   178 		delete RepeatTimer(ii);	

   179 		}		

   180 	iPointers.Close();

   181 	}

   182 

   183 void TWsPointer::SetPointerCursorPos(TPoint aPos)

   184 	{

   185 	RestrictPos(aPos,EFalse);

   186 	iPointers[iPrimaryPointer].iPos=aPos; 

   187 	iPointers[iPrimaryPointer].ReLogCurrentWindow();

   188 	UpdatePointerCursor();

   189 	}

   190 

   191 void TWsPointer::SendEnterExitEvent(TEventCode aType)

   192 	{

   193 	if (iCurrentWindow

   194 		&& (iState != EPointerStateOutOfRange)

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

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

   197 		&& !iCurrentWindow->ShutDownInProgress())

   198 		{

   199 		iCurrentWindow->QueueEvent(aType, iNumber);

   200 		}

   201 	}

   202 

   203 void TWsPointer::SetCurrentWindow(const CWsWindow* aWin)

   204 	{

   205 	if (aWin!=iCurrentWindow)

   206 		{

   207 		SendEnterExitEvent(EEventPointerExit);

   208 		iCurrentWindow=aWin;

   209 		SendEnterExitEvent(EEventPointerEnter);

   210 		}

   211 	}

   212 

   213 /**

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

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

   216 window's parent window. 

   217 */

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

   219 	{

   220 	if (iRootWindow)

   221 		{

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

   223 				                                    iActualWinPointerIsOver,aForceInGroup));

   224 		}

   225 	else

   226 		{

   227 		iCurrentWindow=NULL;

   228 		}

   229 	}

   230 

   231 /**

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

   233 */

   234 void TWsPointer::ReLogPointersCurrentWindows()

   235 	{

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

   237 		{

   238 		TWsPointer& pointer = iPointers[ii];

   239 		pointer.ReLogCurrentWindow();

   240 		}

   241 	}

   242 

   243 /*

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

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

   246 but doesn't set relative positions.

   247 */

   248 void TWsPointer::ReLogCurrentWindow()

   249 	{

   250 	if (iCurrentWindow)

   251 		{

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

   253 		}

   254 	}

   255 

   256 /*

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

   258 is the current window

   259 */

   260 void TWsPointer::ReLogWindow(const CWsWindow* aWin)

   261 	{

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

   263 		{

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

   265 			{

   266 			iPointers[ii].SendEnterExitEvent(EEventPointerEnter);

   267 			}

   268 		}

   269 	}

   270 

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

   272 	{

   273 	if (aPointerType==TPointerEvent::EButton1Up)

   274 		{

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

   276 			{

   277 			iGrabWindow=NULL;

   278 			}

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

   280 			{

   281 			CancelPointerRepeatEventRequest();

   282 			}

   283 		}

   284 	switch(aPointerType)

   285 		{

   286 		case TPointerEvent::EButton1Up:

   287 			iLastUnmatchedDown1=aHandle;

   288 			break;

   289 		case TPointerEvent::EButton2Up:

   290 			iLastUnmatchedDown2=aHandle;

   291 			break;

   292 		case TPointerEvent::EButton3Up:

   293 			iLastUnmatchedDown3=aHandle;

   294 			break;

   295 		case TPointerEvent::EExitHighPressure:

   296 			iLastUnmatchedEnterHighPressure=aHandle;

   297 			break;

   298 		default:;

   299 		}

   300 	}

   301 

   302 void TWsPointer::WindowDisconnected(const CWsWindow* deletedWindow)

   303 	{

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

   305 		{

   306 		TWsPointer& pointer = iPointers[pointerNum];

   307 		if (pointer.iRepeatWindow==deletedWindow)

   308 			{

   309 			pointer.CancelPointerRepeatEventRequest();

   310 			}		

   311 		if (pointer.iGrabWindow==deletedWindow)

   312 			{

   313 			pointer.iGrabWindow=NULL;

   314 			}

   315 		if (pointer.iCurrentWindow==deletedWindow)

   316 			{

   317 			pointer.ReLogCurrentWindow();

   318 			if (pointerNum == iPrimaryPointer)

   319 				{

   320 				UpdatePointerCursor();

   321 				}

   322 			}

   323 		}

   324 	}

   325 

   326 /*

   327 Callback function pointer for up event remove event queue walk

   328 */

   329 TEventQueueWalkRet RemovePointerUpFunc(TAny* aHandle, TWsEvent* aEvent)

   330 	{

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

   332 		{

   333 		return(EEventQueueWalkDeleteEvent);

   334 		}

   335 	return(EEventQueueWalkOk);

   336 	}

   337 

   338 /*

   339 If the specified pointer is down claim grab in aWindow as though the down event had 

   340 gone to this window. Also send an up event to the window (if any) that would receive it if the 

   341 pointer was released now.

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

   343 

   344 @return	KErrNone if successful,

   345 		KErrNotFound if pointernumber out of range,

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

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

   348 */

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

   350 	{

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

   352 	TBool advancedPointersEnabled(aWindow->AdvancedPointersEnabled());

   353 	TInt errNo(KErrNone);

   354 

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

   356 		{

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

   358 		errNo=KErrNotSupported;

   359 		}

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

   361 		{

   362 		// Unknown pointer number

   363 		errNo=KErrNotFound;

   364 		}

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

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

   367 		{

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

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

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

   371 		errNo=KErrPermissionDenied;

   372 		}

   373 	else

   374 		{

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

   376 		}	

   377 	

   378 	return errNo;

   379 	}

   380 

   381 /*

   382 If this pointer is down claim grab in aWindow as though the down event had 

   383 gone to this window. Also send an up event to the window (if any) that would receive it if the 

   384 pointer was released now.

   385 */

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

   387 	{	

   388 	TInt modState=TWindowServerEvent::GetModifierState();

   389 	TWsEvent event;

   390 	TAdvancedPointerEvent& pointerEvent=*event.Pointer();

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

   392 	if (iState == EPointerStateDown)

   393 		{

   394 		if (iCurrentWindow!=aWindow)

   395 			{

   396 			if (aSendUpEvent)

   397 				{

   398 				ProcessEvent(event,NULL,EFalse);

   399 				}

   400 			else // If up event already in queue purge it

   401 				{

   402 				CEventQueue* eventQueue = iCurrentWindow->EventQueue();

   403 				if (eventQueue)

   404 					{

   405 					TUint handle=iCurrentWindow->ClientHandle();

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

   407 					}

   408 				}

   409 			iState = EPointerStateDown;

   410 			if (aWindow->HasPointerGrab())

   411 				{

   412 				iGrabWindow=aWindow;

   413 				}

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

   415 			pointerEvent.iType=TPointerEvent::EDrag;

   416 			ProcessPointerEvent(event);

   417 			}

   418 		}

   419 	else if (iState == EPointerStateUp)

   420 		{

   421 		const CWsWindow *current=iCurrentWindow;

   422 		iCurrentWindow=aWindow;

   423 		WS_ASSERT_DEBUG(iGrabWindow==NULL, EWsPanicPointerClaimGrab);

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

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

   426 		ProcessPointerEvent(event);

   427 		iGrabWindow=NULL;

   428 		iCurrentWindow=current;

   429 		}

   430 	}

   431 

   432 /**

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

   434         EFalse otherwise.

   435 */

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

   437 	{

   438 	switch(aType)

   439 		{

   440 		TUint lastUnmatchedDown;

   441 		case TPointerEvent::EButton1Up:

   442 			lastUnmatchedDown=iLastUnmatchedDown1;

   443 			iLastUnmatchedDown1=0;

   444 			iLastUnmatchedEnterHighPressure=0;

   445 			goto lastUnmatchedDownCheck;

   446 		case TPointerEvent::EButton2Up:

   447 			lastUnmatchedDown=iLastUnmatchedDown2;

   448 			iLastUnmatchedDown2=0;

   449 			goto lastUnmatchedDownCheck;

   450 		case TPointerEvent::EButton3Up:

   451 			lastUnmatchedDown=iLastUnmatchedDown3;

   452 			iLastUnmatchedDown3=0;

   453 			goto lastUnmatchedDownCheck;

   454 		case TPointerEvent::EExitHighPressure:

   455 			lastUnmatchedDown=iLastUnmatchedEnterHighPressure;

   456 			iLastUnmatchedEnterHighPressure=0;

   457 lastUnmatchedDownCheck:

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

   459 			{

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

   461 			}

   462 		default:		//Should never get to default

   463 			break;

   464 		}

   465 	return EFalse;

   466 	}

   467 

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

   469 	{

   470 	if (aWindow->WsOwner() &&

   471 		(aWindow->AdvancedPointersEnabled() || 

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

   473 		{

   474 		CEventQueue* queue=aWindow->EventQueue();

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

   476 		if (aEvent.Handle()!=0)

   477 			{

   478  			if(!aWindow->AdvancedPointersEnabled())

   479  				{

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

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

   482  				// being different.

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

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

   485  				}

   486 			if (queue->UpdateLastPointerEvent(aEvent))

   487 				{

   488 				return EFalse;

   489 				}

   490 			TWservEventPriorities priority=EEventPriorityLow;

   491 			switch (aEvent.Pointer()->iType)

   492 				{

   493 				case TPointerEvent::EButton1Up:

   494 				case TPointerEvent::EButton2Up:

   495 				case TPointerEvent::EButton3Up:

   496 				case TPointerEvent::EExitHighPressure:

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

   498 						{

   499 						return ETrue;

   500 						}

   501 					if (queue->CheckRoom())

   502 						{

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

   504 							{

   505 							return ETrue;

   506 							}

   507 						}

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

   509 				case TPointerEvent::EButton1Down:

   510 				case TPointerEvent::EButton2Down:

   511 				case TPointerEvent::EButton3Down:

   512 				case TPointerEvent::EEnterHighPressure:

   513 				case TPointerEvent::EOutOfRange:

   514 					priority=EEventPriorityHigh;

   515 					break;

   516 				default:;

   517 				}

   518 			queue->QueueEvent(aEvent,priority);

   519 			}

   520 		}

   521 	return EFalse;

   522 	}

   523 

   524 /*

   525 Moves the window group which contains this pointer's iCurrentWindow on top.

   526 */

   527 void TWsPointer::ProcessForegroundCheck()

   528 	{

   529 	CWsWindowGroup* group=((CWsTopClientWindow *)iCurrentWindow)->TopClientWindow()->Parent();

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

   531 		{

   532 		group->SetOrdinalPosition(0);

   533 		}

   534 	}

   535 

   536 /*

   537 Pointer Event Processing - stage 3 of 3:

   538 - setting event's time

   539 - auto foreground check

   540 - double clicks detection

   541 - pointer repeats

   542 - add event to client's queue

   543 - drag&drop capturing

   544 */

   545 void TWsPointer::ProcessPointerEvent(TWsEvent& aEvent)

   546 	{

   547 	if (iCurrentWindow && iCurrentWindow!=iRootWindow)

   548 		{

   549 		aEvent.SetType(EEventPointer);

   550 		aEvent.SetTimeNow();

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

   552 		switch(type)

   553 			{

   554 			//TUint lastUnmatchedDown;

   555 			case TPointerEvent::EButton1Down:

   556 				ProcessForegroundCheck(); 

   557 				/*Fall Through*/

   558 			case TPointerEvent::EButton2Down:

   559 			case TPointerEvent::EButton3Down:

   560 				{

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

   562 				if (iCurrentWindow==iPrevClickWindow &&

   563 					type==iPrevClickEventType &&

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

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

   566 					{

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

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

   569 					}

   570 				else

   571 					{

   572 					iPrevClickWindow=iCurrentWindow;

   573 					}

   574 				iPrevClickEventType=type;

   575 				iPrevClickPos=pos;

   576 				iPrevClickTime=aEvent.Time();

   577 				}

   578 				break;

   579 			default:

   580 				break;

   581 			}

   582 		if (iRepeatWindow)

   583 			{

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

   585 				{

   586 				return;

   587 				}

   588 			CancelPointerRepeatEventRequest();

   589 			}

   590 		if (QueuePointerEvent(iCurrentWindow, aEvent))

   591 			{

   592 			return;

   593 			}

   594 		if (iCurrentWindow->DragDropCapture())

   595 			{

   596 			aEvent.SetType(EEventDragDrop);

   597 			QueuePointerEvent(iActualWinPointerIsOver, aEvent);

   598 			}

   599 		}

   600 	}

   601 

   602 TInt PointerTimerCallBack(TAny *)

   603 	{

   604 	TWsPointer::TimerExpired();

   605 	return(KErrNone);

   606 	}

   607 

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

   609 	{

   610 	CScreen* screen = iRootWindow->Screen();

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

   612 #if defined(__WINS__)

   613 	if (aWithinDrawableArea)

   614 		{

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

   616 			{

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

   618 			}

   619 		}

   620 #endif

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

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

   623 		aPos.iX=validRect.iTl.iX;

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

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

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

   627 		aPos.iY=validRect.iTl.iY;

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

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

   630 	}

   631 

   632 #if defined(__WINS__)

   633 TBool TWsPointer::PreProcessDriverEvent(TRawEvent &aRawEvent,TBool aFromHardware/*=EFlase*/)

   634 #else

   635 TBool TWsPointer::PreProcessDriverEvent(TRawEvent &aRawEvent)

   636 #endif

   637 	{

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

   639 	

   640 	if (!IsPointerEventType(type)) 

   641 		return ETrue;

   642 	

   643 	if (!XyInput())

   644 		{

   645 		return EFalse;

   646 		}

   647 	

   648 	// check correctness of aRawEvent.PointerNumber()

   649 	if (iMaxPointers > 1)

   650 		{

   651 		if (aRawEvent.PointerNumber() >= iMaxPointers)

   652 			{

   653 			return EFalse;

   654 			}

   655 		}

   656 	else

   657 		{

   658 		aRawEvent.SetPointerNumber(0);

   659 		}

   660 	

   661 	if (type != TRawEvent::EPointer3DOutOfRange)

   662 		{

   663 		// operations on coordinates are valid for all types except EPointer3DOutOfRange

   664 		TPoint xy=aRawEvent.Pos();

   665 		if (DeltaMouse())

   666 			{

   667 	#if defined(__WINS__)

   668 			if (aFromHardware)

   669 				return EFalse;

   670 	#endif

   671 			if (type==TRawEvent::EPointerMove)

   672 				{

   673 				xy+=iPointers[aRawEvent.PointerNumber()].iPos;

   674 				ShiftYCoordinate(xy.iY);

   675 				RestrictPos(xy);

   676 				}

   677 			else

   678 				xy=iPointers[aRawEvent.PointerNumber()].iPos;

   679 			}

   680 		else

   681 			{

   682 			CScreen* screen=iRootWindow->Screen();

   683 	#if !defined(__WINS__)

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

   685 			switch (screen->Orientation())

   686 				{

   687 				case CFbsBitGc::EGraphicsOrientationRotated90:

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

   689 					break;

   690 				case CFbsBitGc::EGraphicsOrientationRotated180:

   691 					xy=-(xy-screenSize);

   692 					break;

   693 				case CFbsBitGc::EGraphicsOrientationRotated270:

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

   695 					break;

   696 				default:;		//To stop warning

   697 				}

   698 	#endif

   699 			ShiftYCoordinate(xy.iY);

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

   701 			xy=screen->PhysicalToLogical(xy);

   702 			RestrictPos(xy);

   703 			}

   704 		aRawEvent.Set(type, xy.iX, xy.iY, 

   705 					  iIs3DPointer ? aRawEvent.Pos3D().iZ : 0);

   706 		}

   707 	return ETrue;

   708 	}

   709 

   710 /**

   711  * Validates events sent to the Window Server by its Client (Anim or Window Group).

   712  * May overwrite aRawEvent's Z coordinate and/or pointer number if Client or digitizer driver

   713  * doesn't support them.

   714  * @param aRawEvent event to validate

   715  * @param aAdvancedPointersEnabled ETrue if Client supports advanced pointer's data (Z coordiante

   716  *                                 and pointer number); EFalse otherwise.

   717  * @return ETrue if aRawEvent should be processed by Window Server. EFalse if it should be ignored.

   718  */

   719 TBool TWsPointer::PreProcessClientEvent(TRawEvent &aRawEvent, TBool aAdvancedPointersEnabled)

   720 	{

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

   722 	

   723 	if (!IsPointerEventType(type)) 

   724 		return ETrue;

   725 	

   726 	// validate pointer number

   727 	if (aAdvancedPointersEnabled)

   728 		{

   729 		// ignore event if both digitizer driver and Client support pointer numbers, but number is invalid

   730 		if (aRawEvent.PointerNumber() >= iMaxPointers)

   731 			{

   732 			return EFalse;

   733 			}		

   734 		}

   735 	else

   736 		{

   737 		// set to iPrimaryPointer if Client doesn't support pointer numbers

   738 		aRawEvent.SetPointerNumber(iPrimaryPointer);

   739 		}

   740 	

   741 	// validate Z coordinate for all pointer events except EPointer3DOutOfRange

   742 	if (type != TRawEvent::EPointer3DOutOfRange)

   743 		{

   744 		if (!iIs3DPointer)

   745 			{

   746 			// set Z to 0 for all events when the digitizer driver doesn't support Z coordinate

   747 			TPoint3D xyz=aRawEvent.Pos3D();

   748 			aRawEvent.Set(type, xyz.iX, xyz.iY, 0);

   749 			}

   750 		else if (!aAdvancedPointersEnabled)

   751 			{

   752 			// set Z to actual value if the digitizer driver does support Z coordinate but Client doesn't 

   753 			TPoint3D xyz=aRawEvent.Pos3D();

   754 			aRawEvent.Set(type, xyz.iX, xyz.iY, iPointers[aRawEvent.PointerNumber()].iPressureProximity);

   755 			}

   756 		}

   757 	

   758 	return ETrue;

   759 	}

   760 

   761 TBool TWsPointer::IsPointerEventType(TRawEvent::TType aType)

   762 	{

   763 #if defined(__WINS__)

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

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

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

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

   768 	WS_ASSERT_DEBUG(TRawEvent::EButton3Up+6==TRawEvent::EPointer3DOutOfRange, EWsPanicRawEventsTypeChanged);

   769 #endif

   770 	return (aType == TRawEvent::EPointerMove) ||

   771 		   (aType == TRawEvent::EPointerSwitchOn) ||

   772 		   (aType >= TRawEvent::EButton1Down && aType <= TRawEvent::EButton3Up) ||

   773 		   (aType == TRawEvent::EPointer3DOutOfRange);

   774 	}

   775 

   776 /*

   777 Pointer Event processing.

   778 

   779 This method redirects pointer event processing to proper TWsPointer object.

   780 */

   781 void TWsPointer::ProcessWsEvent(TWsEvent& aEvent,const CWsWindowGroup* aForceInGroup,TBool aNatural)

   782 	{

   783 	if(iPrimaryPointer!=iPreviousPrimaryPointer)

   784 		{

   785 		// The primary pointer may be updated while the TRawEvent is being processed, but this TRawEvent may be

   786 		// then be consumed by an anim.

   787 		// If it hasn't then we can leave any repeat request.

   788 		CancelPointerRepeatEventRequest(iPreviousPrimaryPointer);

   789 		}

   790 	

   791 	if (aEvent.Pointer()->iType == TPointerEvent::EOutOfRange)

   792 		{

   793 		iPointers[TAdvancedPointerEventHelper::PointerNumber(aEvent)].ProcessOutOfRangeEvent(aEvent, aForceInGroup, aNatural);

   794 		}

   795 	else

   796 		{

   797 		iPointers[TAdvancedPointerEventHelper::PointerNumber(aEvent)].ProcessEvent(aEvent, aForceInGroup, aNatural);

   798 		}

   799 	}

   800 

   801 /*

   802 Pointer Event Processing - stage 1 of 3:

   803 - updating this pointer's state: coordinates and grabbing window

   804 - updating coordinates of event

   805 - updating event type to Drag

   806 - simulated moves

   807 - generating events: EEnterCloseProximity, EExitCloseProximity, EEnterHighPressure, EExitHighPressure

   808 */

   809 void TWsPointer::ProcessEvent(TWsEvent& aEvent,const CWsWindowGroup* aForceInGroup,TBool aNatural)

   810  	{

   811 	TAdvancedPointerEvent& pointerEvent = *aEvent.Pointer();

   812 	TPointerEvent::TType eventType=pointerEvent.iType;

   813 	

   814  	if (iState == EPointerStateOutOfRange)

   815  		{

   816  		// new pointer comes in range, so clear information after previous one 		

   817  		Clear();

   818  		}

   819  	

   820 	// update coordinates

   821 	iPos=pointerEvent.iPosition;

   822 	iPressureProximity=TAdvancedPointerEventHelper::Z(aEvent);

   823 	

   824 	if (eventType == TPointerEvent::EMove && !MovesAvailable() && iState != EPointerStateDown)

   825 		{

   826 		return;

   827 		}

   828 	

   829 	// re-log and update parent position

   830 	TPoint parPos;

   831 	ReLogCurrentWindow(pointerEvent.iPosition,parPos,aForceInGroup);

   832 	pointerEvent.iParentPosition=parPos;

   833 	

   834 	// update state

   835 	switch(eventType)

   836 		{

   837 		case TPointerEvent::EButton1Down:

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

   839 				{

   840 				iGrabWindow=iCurrentWindow;

   841 				}

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

   843 				{

   844 				pointerEvent.iType=TPointerEvent::EMove;

   845 				ProcessEvent(aEvent, EFalse);

   846 				pointerEvent.iType=TPointerEvent::EButton1Down;

   847 				}

   848 			switch(iState)

   849 				{

   850 				case EPointerStateOutOfRange:

   851 					iState = EPointerStateDown;

   852 					SendEnterExitEvent(EEventPointerEnter);

   853 					// intentional lack of break statement

   854 				case EPointerStateUp:

   855 					iState = EPointerStateDown;

   856 					ProcessEvent(aEvent, aNatural);

   857 					if (iPressureProximity >= iEnterHighPressureThreshold)

   858 						{

   859 						iInHighPressure = ETrue;

   860 						pointerEvent.iType = TPointerEvent::EEnterHighPressure;

   861 						ProcessEvent(aEvent, EFalse);

   862 						}

   863 					else

   864 						{

   865 						iInHighPressure = EFalse;

   866 						}

   867 					break;

   868 				case EPointerStateDown:

   869 					if (iInHighPressure && iPressureProximity < iExitHighPressureThreshold) 

   870 						{

   871 						iInHighPressure = EFalse;

   872 						eventType = TPointerEvent::EExitHighPressure;

   873 						}

   874 					else if (!iInHighPressure && iPressureProximity >= iEnterHighPressureThreshold)

   875 						{

   876 						iInHighPressure = ETrue;

   877 						eventType = TPointerEvent::EEnterHighPressure;

   878 						}

   879 					ProcessEvent(aEvent, aNatural);

   880 					break;

   881 				}

   882 			break;

   883 		case TPointerEvent::EButton1Up:

   884 			iGrabWindow=NULL;

   885 			switch(iState)

   886 				{

   887 				case EPointerStateDown:

   888 					iState = EPointerStateUp;

   889 					ProcessEvent(aEvent, aNatural);

   890 					if (iPressureProximity < iExitCloseProximityThreshold)

   891 						{

   892 						pointerEvent.iType = TPointerEvent::EExitCloseProximity;

   893 						iInCloseProximity = EFalse;

   894 						ProcessEvent(aEvent, EFalse);

   895 						}

   896 					else

   897 						{

   898 						iInCloseProximity = ETrue;

   899 						}

   900 					break;

   901 				case EPointerStateOutOfRange:

   902 					iState = EPointerStateUp;

   903 					SendEnterExitEvent(EEventPointerEnter);

   904 					// intentional lack of break statement

   905 				case EPointerStateUp:

   906 					if (iInCloseProximity &&

   907 						iPressureProximity < iExitCloseProximityThreshold)

   908 						{

   909 						iInCloseProximity = EFalse;

   910 						pointerEvent.iType = TPointerEvent::EExitCloseProximity;

   911 						}

   912 					else if (!iInCloseProximity &&

   913 							 iPressureProximity >= iEnterCloseProximityThreshold)

   914 						{

   915 						iInCloseProximity = ETrue;

   916 						pointerEvent.iType = TPointerEvent::EEnterCloseProximity;

   917 						}

   918 					ProcessEvent(aEvent, aNatural);

   919 					break;

   920 				}

   921 			break;

   922 		case TPointerEvent::EMove:

   923 			switch(iState)

   924 				{

   925 				case EPointerStateDown:

   926 					if (iInHighPressure && 

   927 						iPressureProximity < iExitHighPressureThreshold) 

   928 						{

   929 						iInHighPressure = EFalse;

   930 						pointerEvent.iType = TPointerEvent::EExitHighPressure;

   931 						}

   932 					else if (!iInHighPressure &&

   933 							iPressureProximity >= iEnterHighPressureThreshold)

   934 						{

   935 						iInHighPressure = ETrue;

   936 						pointerEvent.iType = TPointerEvent::EEnterHighPressure;

   937 						}

   938 					else

   939 						{

   940 						pointerEvent.iType = TPointerEvent::EDrag;

   941 						}

   942 					break;

   943 				case EPointerStateUp:

   944 					if (iInCloseProximity &&

   945 						iPressureProximity < iExitCloseProximityThreshold)

   946 						{

   947 						iInCloseProximity = EFalse;

   948 						pointerEvent.iType = TPointerEvent::EExitCloseProximity;

   949 						}

   950 					else if (!iInCloseProximity &&

   951 							 iPressureProximity >= iEnterCloseProximityThreshold)

   952 						{

   953 						iInCloseProximity = ETrue;

   954 						pointerEvent.iType = TPointerEvent::EEnterCloseProximity;

   955 						}

   956 					break;

   957 				case EPointerStateOutOfRange:

   958 					iState = EPointerStateUp;

   959 					SendEnterExitEvent(EEventPointerEnter);

   960 					if (iPressureProximity >= iEnterCloseProximityThreshold)

   961 						{

   962 						iInCloseProximity = ETrue;

   963 						pointerEvent.iType = TPointerEvent::EEnterCloseProximity;

   964 						}

   965 					break;

   966 				}

   967 			ProcessEvent(aEvent, aNatural);

   968 			break;

   969 		default:

   970 			ProcessEvent(aEvent, aNatural);

   971 			break;

   972 		}

   973 	}

   974 

   975 /**

   976 Processes OutOfRange events:

   977 - injects event to key click plugin

   978 - directs event to the last current window

   979 - sends Exit event

   980 */

   981 void TWsPointer::ProcessOutOfRangeEvent(TWsEvent& aEvent,const CWsWindowGroup* aForceInGroup, TBool aNatural)

   982 	{

   983 	if (iState != EPointerStateOutOfRange)

   984 		{

   985 		// OutOfRange event generated by driver doesn't contain correct coordinates,

   986 		// we update them from last state in order to deliver event to the proper window.

   987 		SendEnterExitEvent(EEventPointerExit);

   988 		

   989 		iState = EPointerStateOutOfRange;

   990 		

   991 		TAdvancedPointerEventHelper::SetPointerNumber(aEvent, iNumber);

   992 		TAdvancedPointerEventHelper::SetZ(aEvent, iPressureProximity);

   993 		

   994 		TAdvancedPointerEvent& pointerEvent = *aEvent.Pointer();		

   995 		iCurrentWindow=iRootWindow->PointerWindow(iPos,&pointerEvent.iPosition,&pointerEvent.iParentPosition,iGrabWindow,

   996 			                   					  iActualWinPointerIsOver,aForceInGroup);

   997 		ProcessEvent(aEvent, aNatural);

   998 		}

   999 	}

  1000 

  1001 void TWsPointer::NotifyCClick(TAdvancedPointerEvent& aPointerEvent)

  1002 	{

  1003 	if (CClick::IsHandler())

  1004 		{

  1005 		CClick::PointerEvent(iPos,aPointerEvent);

  1006 		TPointerEventData params;

  1007 		params.iVersion=0;

  1008 		params.iCurrentPos=iPos;

  1009 		TAdvancedPointerEventHelper::Copy(aPointerEvent, params.iPointerEvent);

  1010 		params.iClientHandle=iCurrentWindow->ClientHandle();

  1011 		params.iWindowOrigin=iCurrentWindow->Origin();

  1012 		CWsWindowGroup* groupWin=iCurrentWindow->WinGroup();

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

  1014 		params.iSource=TPointerEventData::EUnspecified;

  1015 		CClick::OtherEvent(EEventPointer,&params);

  1016 		}

  1017 	}

  1018 

  1019 /*

  1020 Pointer Event Processing - stage 2 of 3:

  1021 - injecting events to key click plugin

  1022 - pointer filtering

  1023 - injection to event buffer

  1024 - injection to keyboard emulator

  1025 - clearing iCurrentWindow if going up and !MovesAvailable()

  1026 - updating pointer cursor

  1027 */

  1028 void TWsPointer::ProcessEvent(TWsEvent& aEvent, TBool aNatural)

  1029 	{

  1030 	if (aNatural)

  1031 		{

  1032 		NotifyCClick(*aEvent.Pointer());

  1033 		}

  1034 	

  1035 	TUint filter=iCurrentWindow->PointerFilter();

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

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

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

  1039 		{

  1040 		if (iNumber == iPrimaryPointer)

  1041 			{

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

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

  1044 				{

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

  1046 				}

  1047 			else if ((type==TPointerEvent::EEnterCloseProximity || type==TPointerEvent::EExitCloseProximity || 

  1048 					  type==TPointerEvent::EEnterHighPressure   || type==TPointerEvent::EExitHighPressure) && 

  1049 					 iCurrentWindow->UsingPointerBuffer())

  1050 				{

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

  1052 				ProcessPointerEvent(aEvent);

  1053 				}

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

  1055 				{

  1056 				ProcessPointerEvent(aEvent);

  1057 				}

  1058 			}

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

  1060 			{

  1061 			ProcessPointerEvent(aEvent);

  1062 			}

  1063 		}

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

  1065 			                  type==TPointerEvent::ESwitchOn  ||

  1066 			                  type==TPointerEvent::EOutOfRange))

  1067 		{

  1068 		iCurrentWindow=NULL;

  1069 		}

  1070 	if (iNumber == iPrimaryPointer)

  1071 		{

  1072 		PointerCursorUpdateCheck();

  1073 		}

  1074 	}

  1075 

  1076 void TWsPointer::TimerExpired()

  1077 	{

  1078 	WS_ASSERT_DEBUG(iTimerQueued, EWsPanicPointerTimer);

  1079 	if (iUpdateRequired)

  1080 		{

  1081 		UpdatePointerCursor();

  1082 		iUpdateRequired=EFalse;

  1083 		}

  1084 	else

  1085 		{

  1086 		iTimerQueued=EFalse;

  1087 		iPeriodicTimer->Cancel();

  1088 		}

  1089 	}

  1090 

  1091 void TWsPointer::GetDoubleClickSettings(TTimeIntervalMicroSeconds32 &aTime, TInt &aDistance)

  1092 	{

  1093 	aTime=iDoubleClickMaxInterval;

  1094 	aDistance=iDoubleClickMaxDistance;

  1095 	}

  1096 

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

  1098 	{

  1099 	iDoubleClickMaxInterval=aTime;

  1100 	iDoubleClickMaxDistance=aDistance;

  1101 	}

  1102 

  1103 void TWsPointer::PointerCursorUpdateCheck()

  1104 	{

  1105 	CWsPointerCursor* sprite=CalculatePointerCursor();

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

  1107 		{

  1108 		if (!iTimerQueued)

  1109 			{

  1110 			UpdatePointerCursorTo(sprite);

  1111 			iPeriodicTimer->Start(TTimeIntervalMicroSeconds32(EPointerUpdateGapInMicroSeconds),

  1112 									TTimeIntervalMicroSeconds32(EPointerUpdateGapInMicroSeconds),

  1113 									  TCallBack(PointerTimerCallBack,NULL));

  1114 			iTimerQueued=ETrue;

  1115 			}

  1116 		else

  1117 			{

  1118 			iUpdateRequired=ETrue;

  1119 			}

  1120 		}

  1121 	}

  1122 

  1123 void TWsPointer::UpdatePointerCursor()

  1124 	{

  1125 //__PROFILE_START(3);

  1126 	CWsPointerCursor* sprite=iPointers[iPrimaryPointer].CalculatePointerCursor();

  1127 	UpdatePointerCursorTo(sprite);

  1128 //__PROFILE_END(3);

  1129 	}

  1130 

  1131 void TWsPointer::UpdatePointerCursorTo(CWsPointerCursor* aNewCursor)

  1132 	{

  1133 	if (iCursorSprite!=aNewCursor)

  1134 		{