diff -r 000000000000 -r 5d03bc08d59c windowing/windowserver/test/HANDANIM.CPP
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/windowing/windowserver/test/HANDANIM.CPP	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,413 @@
+// Copyright (c) 1999-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:
+// Anim DLL to deal with handwriting
+// 
+//
+
+#include "HANDANIM.H"
+
+#define DEFAUlT_LINE_WIDTH 4
+#define DEFAUlT_MASK_WIDTH_FACTOR 3
+#define DEFAUlT_END_POINT_FACTOR 2
+#define BLACK TRgb::Gray2(0)
+#define WHITE TRgb::Gray2(1)
+
+#define leavescan_needs_to_see_some_brackets_here	{	}
+EXPORT_C CAnimDll *CreateCAnimDllL()
+	{
+	return(new(ELeave) CHandWritingAnimDll());
+	}
+
+
+/*CHandWritingAnimDll*/
+
+CAnim *CHandWritingAnimDll::CreateInstanceL(TInt /*aType*/)
+	{
+	return new(ELeave) CHandWritingAnim();
+	}
+
+
+/*CHandWritingAnim*/
+
+CHandWritingAnim::~CHandWritingAnim()
+	{
+	iFunctions->GetRawEvents(EFalse);
+	delete iBitmapDevice;
+	delete iMaskBitmapDevice;
+	}
+
+void CHandWritingAnim::Activate()
+	{
+	if (iState==EHwStateDeactive)
+		{
+		iState=EHwStateInactive;
+		iFunctions->GetRawEvents(ETrue);
+		}
+	}
+
+void CHandWritingAnim::Deactivate()
+	{
+	if (iState!=EHwStateDeactive)
+		{
+		iState=EHwStateDeactive;
+		iFunctions->GetRawEvents(EFalse);
+		iSpriteFunctions->Activate(EFalse);
+		ClearSprite();
+		}
+	}
+
+void CHandWritingAnim::SpriteChangeL(TBool aUsingSeparateMask)
+	{
+	if (aUsingSeparateMask)
+		{
+		TSpriteMember *spriteMember=iSpriteFunctions->GetSpriteMember(0);
+		iMaskBitmapDevice=CFbsBitmapDevice::NewL(spriteMember->iMaskBitmap);		//If this leaves the error value will be returned to the client side
+		}
+	else
+		{
+		delete iMaskBitmapDevice;
+		iMaskBitmapDevice=NULL;
+		iDrawData.iLineColor=BLACK;		//Must use black ink when there is no mask
+		iDrawData.iInitialBitmapColor=WHITE;		//Must have white background when there is no mask
+		}
+	iIsMask=aUsingSeparateMask;
+	}
+
+void CHandWritingAnim::SetDrawData(THandwritingDrawData *aDrawData)
+	{
+	iDrawData=*aDrawData;
+	if (!iIsMask)
+		{
+		iDrawData.iLineColor=BLACK;		//Must use black ink when there is no mask
+		iDrawData.iInitialBitmapColor=WHITE;		//Must have white background when there is no mask
+		}
+	}
+
+TBool CHandWritingAnim::HandlePointerDown(TPoint aPoint)
+	{
+	if (iState==EHwStateWaitingMove)
+		return EFalse;
+	iCurrentDrawPoint=aPoint;
+	if (iState==EHwStateInactive)
+		{
+		iState=EHwStateWaitingMove;
+		StartTimer();
+		return ETrue;
+		}
+	iState=EHwStateDrawing;
+	DrawPoint();
+	UpdateSprite();
+	return ETrue;
+	}
+
+TBool CHandWritingAnim::HandlePointerMove(TPoint aPoint)
+	{
+	switch (iState)
+		{
+	case EHwStateWaitingMove:
+		{
+		TPoint moved=aPoint-iCurrentDrawPoint;
+		if (Abs(moved.iX)<5 && Abs(moved.iY)<5)			//Need to do something with these constants
+			return ETrue;
+		iSpriteFunctions->Activate(ETrue);
+		DrawPoint();
+		iState=EHwStateDrawing;
+		}
+	case EHwStateDrawing:
+		break;
+	default:
+		return EFalse;
+		}
+	DrawLine(aPoint);
+	UpdateSprite();
+	return ETrue;
+	}
+
+TBool CHandWritingAnim::HandlePointerUp(TPoint aPoint)
+	{
+	if (iState==EHwStateInactive)
+		return EFalse;
+	else if (iState==EHwStateWaitingMove)
+		{
+		TPoint moved=aPoint-iCurrentDrawPoint;
+		if (Abs(moved.iX)<5 && Abs(moved.iY)<5)			//Need to do something with these constants
+			{
+			SendEatenDownEvent();
+			return EFalse;
+			}
+		iSpriteFunctions->Activate(ETrue);
+		DrawPoint();
+		}
+	DrawLine(aPoint);
+	DrawPoint();
+	UpdateSprite();
+	iState=EHwStateWaitingStroke;
+	StartTimer();
+	return ETrue;
+	}
+
+void CHandWritingAnim::DrawPoint()
+	{
+	iSpriteGc->Activate(iBitmapDevice);
+	iSpriteGc->SetPenSize(TSize(iDrawData.iEndPontWidth,iDrawData.iEndPontWidth));
+	iSpriteGc->SetPenColor(iDrawData.iLineColor);
+	iSpriteGc->Plot(iCurrentDrawPoint);
+	if (iMaskBitmapDevice)
+		{
+		iSpriteGc->Activate(iMaskBitmapDevice);
+		iSpriteGc->SetPenSize(TSize(iDrawData.iMaskLineWidth,iDrawData.iMaskLineWidth));
+		iSpriteGc->SetPenColor(BLACK);		//Mask must be drawn in black
+		iSpriteGc->Plot(iCurrentDrawPoint);
+		}
+	iPointStore->AddPoint(iCurrentDrawPoint);
+	}
+
+void CHandWritingAnim::DrawLine(TPoint aEndPoint)
+	{
+	iSpriteGc->Activate(iBitmapDevice);
+	iSpriteGc->SetPenSize(TSize(iDrawData.iLineWidth,iDrawData.iLineWidth));
+	iSpriteGc->SetPenColor(iDrawData.iLineColor);
+	iSpriteGc->MoveTo(iCurrentDrawPoint);
+	iSpriteGc->DrawLineTo(aEndPoint);
+	if (iMaskBitmapDevice)
+		{
+		iSpriteGc->Activate(iMaskBitmapDevice);
+		iSpriteGc->SetPenSize(TSize(iDrawData.iMaskLineWidth,iDrawData.iMaskLineWidth));
+		iSpriteGc->SetPenColor(BLACK);		//Mask must be drawn in black
+		iSpriteGc->MoveTo(iCurrentDrawPoint);
+		iSpriteGc->DrawLineTo(aEndPoint);
+		}
+	iCurrentDrawPoint=aEndPoint;
+	iPointStore->AddPoint(aEndPoint);
+	}
+
+void CHandWritingAnim::UpdateSprite()
+	{
+	TRect drawTo;
+	iSpriteGc->RectDrawnTo(drawTo);
+	iSpriteFunctions->UpdateMember(0,drawTo,EFalse);
+	}
+
+void CHandWritingAnim::StartTimer()
+	{
+	iFunctions->SetNextInterval(2);
+	}
+
+void CHandWritingAnim::SendEatenDownEvent()
+	{
+	TRawEvent rawEvent;
+	rawEvent.Set(TRawEvent::EButton1Down,iCurrentDrawPoint.iX,iCurrentDrawPoint.iY);
+	iFunctions->PostRawEvent(rawEvent);
+	iState=EHwStateInactive;
+	}
+
+void CHandWritingAnim::CharacterFinished()
+	{		
+	iState=EHwStateInactive;
+	iLastGeneratedCharacter=iPointStore->GetChar();
+	/*TRawEvent rawEvent;
+	rawEvent.Set(TRawEvent::EKeyDown,iLastGeneratedCharacter);
+	iFunctions->PostKeyEvent(rawEvent);*/
+    TKeyEvent keyEvent;
+    keyEvent.iCode=keyEvent.iScanCode=iLastGeneratedCharacter;
+    keyEvent.iModifiers=keyEvent.iRepeats=0;
+	iFunctions->PostKeyEvent(keyEvent);
+	iPointStore->ClearPoints();
+	iSpriteFunctions->Activate(EFalse);
+	ClearSprite();
+	}
+
+void CHandWritingAnim::ClearSprite()
+	{
+	iSpriteGc->Activate(iBitmapDevice);
+	iSpriteGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
+	iSpriteGc->SetBrushColor(iDrawData.iInitialBitmapColor);
+	iSpriteGc->Clear();
+	if (iMaskBitmapDevice)
+		{
+		iSpriteGc->Activate(iMaskBitmapDevice);
+		iSpriteGc->SetBrushColor(WHITE);		//Mask must be cleared in white
+		iSpriteGc->Clear();
+		}
+    TRect drawnTo;
+	iSpriteGc->RectDrawnTo(drawnTo);		//Clear the drawnTo rect.
+	}
+
+TBool CHandWritingAnim::OfferRawEvent(const TRawEvent &aRawEvent)
+	{
+	if (iState==EHwStateDeactive)
+		return EFalse;
+	switch (aRawEvent.Type())
+		{
+	case TRawEvent::EButton1Down:
+		{
+		iDownTime.HomeTime();		
+		return HandlePointerDown(aRawEvent.Pos());
+		}
+	case TRawEvent::EPointerMove:
+		return HandlePointerMove(aRawEvent.Pos());
+	case TRawEvent::EButton1Up:
+		return HandlePointerUp(aRawEvent.Pos());
+	default:
+		return EFalse;
+		}
+	}
+
+void CHandWritingAnim::ConstructL(TAny *)
+	{
+	TSpriteMember *spriteMember=iSpriteFunctions->GetSpriteMember(0);
+	iIsMask=(spriteMember->iBitmap->Handle() != spriteMember->iMaskBitmap->Handle());
+	iBitmapDevice=CFbsBitmapDevice::NewL(spriteMember->iBitmap);
+	if (iIsMask)
+		iMaskBitmapDevice=CFbsBitmapDevice::NewL(spriteMember->iMaskBitmap);
+	iState=EHwStateDeactive;
+	iSpriteGc=CFbsBitGc::NewL();
+	iSpriteGc->Reset();
+	iDrawData.iLineColor=BLACK;
+	iDrawData.iInitialBitmapColor=WHITE;
+	iDrawData.iLineWidth=DEFAUlT_LINE_WIDTH;
+	iDrawData.iMaskLineWidth=DEFAUlT_MASK_WIDTH_FACTOR*DEFAUlT_LINE_WIDTH;
+	iDrawData.iEndPontWidth=DEFAUlT_END_POINT_FACTOR*DEFAUlT_LINE_WIDTH;
+	iSpriteFunctions->SizeChangedL();
+	iPointStore=new(ELeave) CPointStore();
+	iPointStore->ConstructL();
+	}
+
+void CHandWritingAnim::Animate(TDateTime* /*aDateTime*/)
+	{
+	iFunctions->SetInterval(0);
+	if (iState==EHwStateWaitingMove)
+		SendEatenDownEvent();
+	else if (iState==EHwStateWaitingStroke)
+		CharacterFinished();
+	}
+
+void CHandWritingAnim::Redraw()
+	{
+	}
+
+void CHandWritingAnim::Command(TInt aOpcode,TAny *aParams)
+	{
+	switch (aOpcode)
+		{
+		case EHwOpActivate:
+			Activate();
+			break;
+		case EHwOpDeactivate:
+			Deactivate();
+			break;
+		case EHwOpSetDrawData:;
+			SetDrawData(STATIC_CAST(THandwritingDrawData*,aParams));
+			break;
+		default:
+			iFunctions->Panic();
+		}
+	}
+
+void CHandWritingAnim::FocusChanged(TBool )
+	{
+	}
+
+TInt CHandWritingAnim::CommandReplyL(TInt aOpcode,TAny *aParams)
+	{
+	switch (aOpcode)
+		{
+		case EHwOpSpriteMask:
+			SpriteChangeL(*STATIC_CAST(TBool*,aParams));
+			break;
+		case EHwOpGetLastChar:
+			return iLastGeneratedCharacter;
+		default:
+			iFunctions->Panic();
+		}
+	return KErrNone;
+	}
+
+
+/*CPointStore*/
+
+CPointStore::CPointStore()
+	{}
+
+void CPointStore::ConstructL()
+	{
+	iPoints=new(ELeave) CArrayFixFlat<TPoint>(16);
+	iPoints->ResizeL(256);
+	}
+
+void CPointStore::AddPoint(TPoint aPoint)
+	{
+	if (iNumPoints<256)
+		(*iPoints)[iNumPoints++]=aPoint;
+	}
+
+TInt CPointStore::GetChar()
+	{
+	TPoint oldPoint=(*iPoints)[0];
+	TPoint newPoint;
+	TPoint totalPoint=oldPoint;
+	TInt xInc=0,xDec=0,yInc=0,yDec=0;
+	TInt yState=0,xState=0;
+	TInt ii;
+	for (ii=1;ii<iNumPoints;++ii)
+		{
+		newPoint=(*iPoints)[ii];
+		totalPoint+=newPoint;
+		if (newPoint.iX>oldPoint.iX)
+			++xInc;
+		if (newPoint.iX<oldPoint.iX)
+			++xDec;
+		if (newPoint.iY>oldPoint.iY)
+			++yInc;
+		if (newPoint.iY<oldPoint.iY)
+			++yDec;
+		oldPoint=newPoint;
+		}
+	newPoint-=(*iPoints)[0];
+	if (10*yInc<yDec)
+		yState=-1;
+	else if (yInc>10*yDec)
+		yState=1;
+	if (10*xInc<xDec)
+		xState=-1;
+	else if (xInc>10*xDec)
+		xState=1;
+	if (xState!=0 && yState!=0)
+		{
+		if (Abs(newPoint.iY)<Abs(newPoint.iX))
+			yState=0;
+		else
+			xState=0;
+		}
+	if (xState!=0)
+		return xState>0 ? EKeyRightArrow:EKeyLeftArrow;
+	if (yState!=0)
+		return yState>0 ? EKeyDownArrow:EKeyUpArrow;
+	TInt firstChar='a';
+	TInt numChars=26;
+	TInt type=(totalPoint.iY/10)%10;
+	if (type>5)
+		firstChar='A';
+	else if (type==0)
+		{
+		firstChar='0';
+		numChars=10;
+		}
+	return firstChar+((totalPoint.iX/10)%numChars);
+	}
+
+void CPointStore::ClearPoints()
+	{
+	iNumPoints=0;
+	}