// 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:
// Tests for various pointer cursors on different windows
// 
//

#include <e32std.h>
#include <hal.h>
#include "W32STD.H"
#include "../tlib/testbase.h"
#include "TMAN.H"

class CPointerCursorWindow : public CTWin
	{
public:
	~CPointerCursorWindow();
	void SetChild(CPointerCursorWindow* aChild);
	inline CPointerCursorWindow* Child() {return iChild;}
	inline void SetBitmap(CFbsBitmap* aBitmap,TBool aTop=ETrue) {iBitmap=aBitmap;iTop=aTop;}
	void SetPointerCursor(CTPointerCursor* aCursor);
	//Virtual function from CTBaseWin
	void SetUpL(TPoint aPos,TSize aSize,CTWinBase *aParent,CWindowGc &aGc);
	void Draw();
	void PointerL(const TPointerEvent &aPointer,const TTime &aTime);
private:
	CPointerCursorWindow* iChild;
	CFbsBitmap* iBitmap;
	TBool iTop;
	};

class CPointerCursorWindowGroup : public CTWindowGroup
	{
public:
	CPointerCursorWindowGroup(CTClient *aClient);
	void SetPointerCursor(CTPointerCursor* aCursor);
	void ConstructL();
	};

class CStatusWindow : public CTTitledWindow
	{
public:
	~CStatusWindow();
	void Construct(CTestBase* aTest);
	void DoDraw();
	//virtual functions from CTWinBase overridden by CTBaseWin
	void WinKeyL(const TKeyEvent &aKey,const TTime &aTime);
	//virtual functions from CTBaseWin
	void SetUpL(TPoint pos,TSize size,CTWinBase *parent, CWindowGc &aGc);
	void PointerL(const TPointerEvent &aPointer,const TTime &aTime);
	//virtual function from CTBaseWin overridden by CTTitledWindow
	void Draw();
private:
	void UpdateString1();
	void UpdateString2();
	void UpdateString3();
	void ChangeXyInputType();
	void ChangePointerCursorMode();
private:
	CTestBase* iTest;
	TBuf<16> iString1;
	TBuf<16> iString2;
	TBuf<16> iString3;
	TBuf<32> iString4;
	TRect iRect1;
	TRect iRect2;
	TRect iRect3;
	TRect iRect4;
	TXYInputType iXyInputType;
	TXYInputType iOriginalXyInputType;
	TPointerCursorMode iMode;
	TPointerCursorMode iOriginalMode;
	TBool iSimulatedPenDown;
	TBool iUpdateNeeded;
	TBool iExit;
	};

class CPointerCursorTest : public CTestBase
	{
	enum {eWindowGap=3,eChildWindowGap=2};
	enum {eNumPointerCursors=7};
public:
	CPointerCursorTest();
	~CPointerCursorTest();
	TestState DoTestL();
	void ConstructL();
private:
	CPointerCursorWindow *CreateWindowL(TInt aNum,TRect aLocation,CTWinBase *aGroup);
	void CreatePointerCursorsL();
	void CreateWindowsL(TSize aArea);
private:
	TSize iWinSize;
	TInt iState;
	CStatusWindow *iInfoWindow;
	CPointerCursorWindowGroup *iGroup1;
	CPointerCursorWindowGroup *iGroup2;
	CPointerCursorWindow *iWindows[6];
	CTPointerCursor *iCursors[eNumPointerCursors];
	CFbsBitmap *iBitmaps[eNumPointerCursors];
	};


/*CPointerCursorWindow*/

CPointerCursorWindow::~CPointerCursorWindow()
	{
	delete iChild;
	}

void CPointerCursorWindow::SetChild(CPointerCursorWindow* aChild)
	{
	iChild=aChild;
	iWin.SetShadowDisabled(ETrue);
	}

void CPointerCursorWindow::SetPointerCursor(CTPointerCursor* aCursor)
	{
	iWin.SetCustomPointerCursor(aCursor->PointerCursor());
	}

void CPointerCursorWindow::SetUpL(TPoint aPos,TSize aSize,CTWinBase *aParent,CWindowGc &aGc)
	{
	CTWin::SetUpL(aPos,aSize,aParent,aGc);
	iWin.SetShadowDisabled(ETrue);
	iWin.SetPointerGrab(EFalse);
	}

void CPointerCursorWindow::Draw()
	{
	iGc->Reset();
	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	iGc->DrawRect(Size());
	if (iBitmap)
		{
		TPoint point(3,3);
		if (!iTop)
			point.iY=Size().iHeight-iBitmap->SizeInPixels().iHeight-3;
		iGc->BitBlt(point,iBitmap);
		}
	}

void CPointerCursorWindow::PointerL(const TPointerEvent&,const TTime&)
	{
	}


/*CPointerCursorWindowGroup*/

CPointerCursorWindowGroup::CPointerCursorWindowGroup(CTClient *aClient)
	:CTWindowGroup(aClient)
	{}

void CPointerCursorWindowGroup::ConstructL()
	{
	CTWindowGroup::ConstructL();
	iGroupWin.EnableReceiptOfFocus(EFalse);
	}

void CPointerCursorWindowGroup::SetPointerCursor(CTPointerCursor* aCursor)
	{
	iGroupWin.SetCustomPointerCursor(aCursor->PointerCursor());
	}


/*CStatusWindow*/

CStatusWindow::~CStatusWindow()
	{
	Client()->iWs.SetPointerCursorMode(iOriginalMode);
#if defined(__WINS__)
	Client()->iWs.SimulateXyInputType(iOriginalXyInputType);
#endif
	}

void CStatusWindow::Construct(CTestBase* aTest)
	{
	_LIT(Title,"StatusWindow");
	_LIT(String4,"Click here to finish");
	iTest=aTest;
	TWindowTitle title(Title);
	SetTitle(title);
	TInt yy=iTitleHeight+iFont->HeightInPixels()+7;
	iRect1.SetRect(3,iTitleHeight+5,iSize.iWidth-1,yy);
	TInt yy1=yy+iFont->HeightInPixels()+2;
	iRect2.SetRect(3,yy+3,iSize.iWidth-1,yy1);
	TInt yy2=yy1+iFont->HeightInPixels()+2;
	iRect3.SetRect(3,yy1+3,iSize.iWidth-1,yy2);
	iRect4.SetRect(3,yy2+3,iSize.iWidth-1,yy2+iFont->HeightInPixels()+2);
	TMachineInfoV1Buf machineInfo;
	UserHal::MachineInfo(machineInfo);
	iXyInputType=machineInfo().iXYInputType;
	iOriginalXyInputType=iXyInputType;
	iSimulatedPenDown=EFalse;
	//
	iString3.Copy(KNullDesC);
	if (iXyInputType==EXYInputDeltaMouse)
		{
		if (HAL::Get(HALData::EMouseState,iSimulatedPenDown)==KErrNone)
			UpdateString3();
		}
	UpdateString1();
	iMode=Client()->iWs.PointerCursorMode();
	iOriginalMode=iMode;
	UpdateString2();
	iUpdateNeeded=EFalse;
	iString4.Copy(String4);
	iExit=EFalse;
	}

void CStatusWindow::SetUpL(TPoint aPos,TSize aSize,CTWinBase *aParent,CWindowGc &aGc)
	{
	CTTitledWindow::SetUpL(aPos,aSize,aParent,aGc);
	}

void CStatusWindow::WinKeyL(const TKeyEvent &aKey,const TTime&)
	{
	switch(aKey.iCode)
		{
		case EKeyEscape:
			iTest->Request();
			break;
		case 'M':
		case 'm':
			if (iXyInputType==EXYInputDeltaMouse)
				{
				if (HAL::Set(HALData::EMouseState,!iSimulatedPenDown)==KErrNone)
					{
					iSimulatedPenDown=!iSimulatedPenDown;
					UpdateString3();
					DoDraw();
					}
				}
			break;
	#if defined(__WINS__)
		case 'I':
		case 'i':
		case '1':
			ChangeXyInputType();
			Client()->iWs.SimulateXyInputType(iXyInputType);
			break;
	#endif
		case 'C':
		case 'c':
		case '2':
			ChangePointerCursorMode();
			Client()->iWs.SetPointerCursorMode(iMode);
			break;
		default:;
		}
	}

void CStatusWindow::PointerL(const TPointerEvent &aPointer,const TTime &aTime)
	{
#if defined(__WINS__)
	if (iRect1.Contains(aPointer.iPosition))
		{
		if (aPointer.iType==TPointerEvent::EButton1Down)
			ChangeXyInputType();
		}
	else
#endif
        if (iRect2.Contains(aPointer.iPosition))
		{
		if (aPointer.iType==TPointerEvent::EButton1Down)
			ChangePointerCursorMode();
		}
	else if (iRect4.Contains(aPointer.iPosition))
		iExit=ETrue;
	else
		CTTitledWindow::PointerL(aPointer,aTime);
	if ((iUpdateNeeded || iExit) && aPointer.iType==TPointerEvent::EButton1Up)
		{
		if (iExit)
			iTest->Request();
		else
			{
			Client()->iWs.SetPointerCursorMode(iMode);
		#if defined(__WINS__)
			Client()->iWs.SimulateXyInputType(iXyInputType);
		#endif
			Client()->iWs.Flush();
			iUpdateNeeded=EFalse;
			}
		}
	}

void CStatusWindow::Draw()
	{
	CTTitledWindow::Draw();
	TInt ascent=iFont->AscentInPixels()+1;
	iGc->DrawText(iString1,iRect1,ascent,CGraphicsContext::ELeft);
	iGc->DrawText(iString2,iRect2,ascent,CGraphicsContext::ELeft);
	iGc->DrawText(iString3,iRect3,ascent,CGraphicsContext::ELeft);
	iGc->DrawText(iString4,iRect4,ascent,CGraphicsContext::ELeft);
	}

void CStatusWindow::DoDraw()
	{
	iGc->Activate(iWin);
	iGc->UseFont((CFont *)iFont);
	Draw();
	iGc->Deactivate();
	}

void CStatusWindow::UpdateString1()
	{
	_LIT(Text0,"No Pointer");
	_LIT(Text1,"Pen");
	_LIT(Text2,"Mouse");
	_LIT(Text3,"Relative Mouse");
	switch (iXyInputType)
		{
	case EXYInputNone:
		iString1.Copy(Text0);
		break;
	case EXYInputPointer:
		iString1.Copy(Text1);
		break;
	case EXYInputMouse:
		iString1.Copy(Text2);
		break;
	case EXYInputDeltaMouse:
		iString1.Copy(Text3);
		break;
		}
	}

void CStatusWindow::UpdateString2()
	{
	_LIT(Text0,"None");
	_LIT(Text1,"Fixed");
	_LIT(Text2,"Normal");
	_LIT(Text3,"Window");
	switch (iMode)
		{
	case EPointerCursorNone:
		iString2.Copy(Text0);
		break;
	case EPointerCursorFixed:
		iString2.Copy(Text1);
		break;
	case EPointerCursorNormal:
		iString2.Copy(Text2);
		break;
	case EPointerCursorWindow:
		iString2.Copy(Text3);
		break;
		}
	}

void CStatusWindow::UpdateString3()
	{
	if (iSimulatedPenDown)
		{
		_LIT(TextD,"Sim Pen Down");
		iString3.Copy(TextD);
		}
	else
		{
		_LIT(TextU,"Sim Pen Up");
		iString3.Copy(TextU);
		}
	}

void CStatusWindow::ChangeXyInputType()
	{
	if (iXyInputType==EXYInputMouse)
		iXyInputType=EXYInputPointer;
	else if (iXyInputType==EXYInputPointer)
		iXyInputType=EXYInputMouse;
	UpdateString1();
	DoDraw();
	iUpdateNeeded=ETrue;
	}

void CStatusWindow::ChangePointerCursorMode()
	{
	TInt mode=(iMode+1)%(EPointerCursorLastMode+1);
	iMode=STATIC_CAST(TPointerCursorMode,mode);
	UpdateString2();
	DoDraw();
	iUpdateNeeded=ETrue;
	}


/*Sprite Drawing Functions*/

#if defined(__WINS__)
	#define DRAW_COLOR 1
#else
	#define DRAW_COLOR 0
#endif

void DrawCross(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *aLineWidth)
	{
	TInt halfLineWidth=(*STATIC_CAST(TInt*,aLineWidth)+1)/2;
	TInt lineWidth=2*halfLineWidth+1;		//Must be odd
	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 3));
	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	aGc->SetPenStyle(CGraphicsContext::ENullPen);
	aGc->DrawRect(TRect(aSize));
	aGc->SetPenStyle(CGraphicsContext::ESolidPen);
	aGc->SetPenColor(TRgb::Gray4(aDoMask ? 3 : 0));
	aGc->SetPenSize(TSize(lineWidth,lineWidth));
	aGc->DrawLine(TPoint(halfLineWidth,halfLineWidth),TPoint(aSize.iWidth-lineWidth,aSize.iHeight-lineWidth));
	aGc->DrawLine(TPoint(halfLineWidth,aSize.iHeight-lineWidth),TPoint(aSize.iWidth-lineWidth,halfLineWidth));
	}

void DrawArrow(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *aLineWidth)
	{
	TInt lineWidth=*STATIC_CAST(TInt*,aLineWidth);
	TInt halfLineWidth=(lineWidth-1)/2;
	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 3));
	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	aGc->SetPenStyle(CGraphicsContext::ENullPen);
	aGc->DrawRect(TRect(aSize));
	aGc->SetPenStyle(CGraphicsContext::ESolidPen);
	aGc->SetPenColor(TRgb::Gray4(aDoMask ? 3 : 0));
	aGc->SetPenSize(TSize(1,1));
	aGc->DrawLine(TPoint(0,0),TPoint(lineWidth,0));
	aGc->DrawLine(TPoint(0,0),TPoint(0,lineWidth));
	aGc->SetPenSize(TSize(lineWidth,lineWidth));
	aGc->DrawLine(TPoint(halfLineWidth,halfLineWidth),TPoint(aSize.iWidth-halfLineWidth-1,aSize.iHeight-halfLineWidth-1));
	aGc->DrawLine(TPoint(halfLineWidth,halfLineWidth),TPoint(aSize.iWidth/2,halfLineWidth));
	aGc->DrawLine(TPoint(halfLineWidth,halfLineWidth),TPoint(halfLineWidth,aSize.iHeight/2));
	}

void DrawSquare(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *)
	{
	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 3));
	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	aGc->SetPenStyle(CGraphicsContext::ENullPen);
	aGc->DrawRect(TRect(aSize));
	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 3 : DRAW_COLOR));
	aGc->DrawRect(TRect(1,1,aSize.iWidth-1,aSize.iHeight-1));
	}

void DrawCircle(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *)
	{
	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 3));
	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	aGc->SetPenStyle(CGraphicsContext::ENullPen);
	aGc->DrawRect(TRect(aSize));
	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 3 : 1));
	aGc->DrawEllipse(TRect(1,1,aSize.iWidth-1,aSize.iHeight-1));
	}

void DrawTriangle(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *)
	{
	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 3));
	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	aGc->SetPenStyle(CGraphicsContext::ENullPen);
	aGc->DrawRect(TRect(aSize));
	aGc->SetPenStyle(CGraphicsContext::ESolidPen);
	aGc->SetPenColor(TRgb::Gray4(aDoMask ? 3 : DRAW_COLOR));
	aGc->SetPenSize(TSize(1,1));
	for(TInt y=0;y<aSize.iHeight;y++)
		{
		TInt xfact=aSize.iWidth*y/aSize.iHeight;
		aGc->DrawLine(TPoint(aSize.iWidth-xfact-1,y),TPoint(aSize.iWidth-1,y));
		}
	}

void DrawOpenSquare(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *aLineWidth)
	{
	TInt halfLineWidth=*STATIC_CAST(TInt*,aLineWidth)/2;
	TInt lineWidth=2*halfLineWidth+1;		//Must be odd
	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 3));
	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	aGc->SetPenStyle(CGraphicsContext::ENullPen);
	aGc->DrawRect(TRect(aSize));
	aGc->SetBrushStyle(CGraphicsContext::ENullBrush);
	aGc->SetPenStyle(CGraphicsContext::ESolidPen);
	aGc->SetPenColor(TRgb::Gray4(aDoMask ? 3 : DRAW_COLOR));
	aGc->SetPenSize(TSize(lineWidth,lineWidth));
	TPoint botRig(aSize.iWidth-aSize.iWidth/4-1,aSize.iHeight-aSize.iHeight/4-1);
	aGc->DrawRect(TRect(aSize.iWidth/4,aSize.iHeight/4,botRig.iX+1,botRig.iY+1));
	aGc->DrawLine(TPoint(halfLineWidth,halfLineWidth),TPoint(aSize.iWidth/4-halfLineWidth,aSize.iHeight/4-halfLineWidth));
	aGc->DrawLine(TPoint(aSize.iWidth-1-halfLineWidth,halfLineWidth),TPoint(botRig.iX+halfLineWidth,aSize.iHeight/4-halfLineWidth));
	aGc->DrawLine(TPoint(aSize.iWidth-1-halfLineWidth,aSize.iHeight-1-halfLineWidth),TPoint(botRig.iX+halfLineWidth,botRig.iY+halfLineWidth));
	aGc->DrawLine(TPoint(halfLineWidth,aSize.iHeight-1-halfLineWidth),TPoint(aSize.iWidth/4-halfLineWidth,botRig.iY+halfLineWidth));
	}

void DrawOpenCircle(CBitmapContext *aGc,TInt , const TSize &aSize, TBool aDoMask, TAny *aLineWidth)
	{
	TInt halfLineWidth=*STATIC_CAST(TInt*,aLineWidth)/2;
	TInt lineWidth=2*halfLineWidth+1;		//Must be odd
	aGc->SetBrushColor(TRgb::Gray4(aDoMask ? 0 : 3));
	aGc->SetBrushStyle(CGraphicsContext::ESolidBrush);
	aGc->SetPenStyle(CGraphicsContext::ENullPen);
	aGc->DrawRect(TRect(aSize));
	aGc->SetBrushStyle(CGraphicsContext::ENullBrush);
	aGc->SetPenStyle(CGraphicsContext::ESolidPen);
	aGc->SetPenColor(TRgb::Gray4(aDoMask ? 3 : DRAW_COLOR));
	aGc->SetPenSize(TSize(lineWidth,lineWidth));
	TPoint botRig(aSize.iWidth-aSize.iWidth/4-1,aSize.iHeight-aSize.iHeight/4-1);
	aGc->DrawEllipse(TRect(aSize.iWidth/4+1,aSize.iHeight/4+1,botRig.iX+1,botRig.iY+1));
	aGc->DrawLine(TPoint(aSize.iWidth/2,1+halfLineWidth),TPoint(aSize.iWidth/2,aSize.iHeight/4+1-halfLineWidth));
	aGc->DrawLine(TPoint(aSize.iWidth/2,aSize.iHeight-1-halfLineWidth),TPoint(aSize.iWidth/2,botRig.iY+halfLineWidth));
	aGc->DrawLine(TPoint(1+halfLineWidth,aSize.iWidth/2),TPoint(aSize.iWidth/4+1-halfLineWidth,aSize.iHeight/2));
	aGc->DrawLine(TPoint(aSize.iWidth-1-halfLineWidth,aSize.iHeight/2),TPoint(botRig.iX+halfLineWidth,aSize.iWidth/2));
	}


/*CPointerCursorTest*/

GLDEF_C CTestBase *CreatePointerCursorTest()
	{
	return(new(ELeave) CPointerCursorTest());
	}

CPointerCursorTest::CPointerCursorTest() : CTestBase(_L("PointerCursor"))
	{}

CPointerCursorTest::~CPointerCursorTest()
	{
	TInt ii;
	Client()->iGroup->SetCurrentWindow(NULL);
	delete iInfoWindow;
	for(ii=0;ii<6;++ii)
		{
		delete iWindows[ii];
		}
	for(ii=0;ii<eNumPointerCursors;++ii)
		{
		delete iCursors[ii];
		delete iBitmaps[ii];
		}
	delete iGroup1;
	delete iGroup2;
	}

void CPointerCursorTest::ConstructL()
	{
	TSize size=Client()->iScreen->SizeInPixels();
	TInt infoWidth=Min(210,5*size.iWidth/12);
	size.iWidth=Max(Min(415,size.iWidth-infoWidth),85);
	iInfoWindow=new(ELeave) CStatusWindow();
	iInfoWindow->SetUpL(TPoint(size.iWidth,50),TSize(infoWidth,180),Client()->iGroup,*Client()->iGc);
	Client()->iGroup->SetCurrentWindow(iInfoWindow);
	iInfoWindow->Construct(this);
	iGroup1=new(ELeave) CPointerCursorWindowGroup(Client());
	iGroup1->ConstructL();
	iGroup2=new(ELeave) CPointerCursorWindowGroup(Client());
	iGroup2->ConstructL();
	size.iWidth-=5;
	CreateWindowsL(size);
	CreatePointerCursorsL();
	iGroup1->SetPointerCursor(iCursors[0]);
	iWindows[1]->SetBitmap(iBitmaps[0],EFalse);
	iWindows[0]->SetPointerCursor(iCursors[1]);
	iWindows[0]->SetBitmap(iBitmaps[1]);
	iWindows[0]->Child()->SetPointerCursor(iCursors[2]);
	iWindows[0]->Child()->SetBitmap(iBitmaps[2]);
	iWindows[2]->SetPointerCursor(iCursors[3]);
	iWindows[2]->SetBitmap(iBitmaps[3]);
	iWindows[2]->Child()->Child()->SetPointerCursor(iCursors[4]);
	iWindows[2]->Child()->Child()->SetBitmap(iBitmaps[4]);
	iWindows[3]->Child()->SetPointerCursor(iCursors[5]);
	iWindows[3]->Child()->SetBitmap(iBitmaps[5]);
	iWindows[4]->SetPointerCursor(iCursors[6]);
	iWindows[4]->SetBitmap(iBitmaps[6]);
	}

void CPointerCursorTest::CreateWindowsL(TSize aArea)
	{
	//TSize screenSize=Client()->iScreen->SizeInPixels();
	TInt height=eWindowGap+(aArea.iHeight-5*eWindowGap)/4;
	TInt halfWidth=aArea.iWidth/2;
	TRect rect(5,eWindowGap,halfWidth,height);
	iWindows[0]=CreateWindowL(2,rect,iGroup1);
	rect.Move(halfWidth,0);
	iWindows[1]=CreateWindowL(2,rect,iGroup1);
	rect.Move(-halfWidth,height);
	rect.iBr.iX=aArea.iWidth;
	iWindows[2]=CreateWindowL(4,rect,iGroup2);
	rect.Move(0,height);
	rect.iBr.iX=aArea.iWidth-11;
	iWindows[3]=CreateWindowL(3,rect,iGroup2);
	rect.Move(0,height);
	rect.iBr.iX=halfWidth;
	iWindows[4]=CreateWindowL(2,rect,iGroup2);
	rect.Move(halfWidth,0);
	iWindows[5]=CreateWindowL(2,rect,iGroup2);
	}

CPointerCursorWindow* CPointerCursorTest::CreateWindowL(TInt aNum,TRect aLocation,CTWinBase *aGroup)
	{
	CPointerCursorWindow* firstWin=NULL;
	CPointerCursorWindow* parent=NULL;
	CPointerCursorWindow* win;
	TInt xInc=aLocation.Width()/aNum-eChildWindowGap;
	TInt ii;
	for (ii=aNum;ii>0;ii--)
		{
		win=new(ELeave) CPointerCursorWindow();
		CleanupStack::PushL(win);
		win->SetUpL(aLocation.iTl,aLocation.Size(),aGroup,*Client()->iGc);
		if (!parent)
			firstWin=win;
		else
			{
			parent->SetChild(win);
			CleanupStack::Pop();
			}
		aLocation.iBr=TPoint(-eChildWindowGap,-eChildWindowGap)+aLocation.Size();
		aLocation.iTl.iX=xInc;
		aLocation.iTl.iY=eChildWindowGap;
		aGroup=win;
		parent=win;
		}
	CleanupStack::Pop();
	return firstWin;
	}

void CPointerCursorTest::CreatePointerCursorsL()
	{
	const TSize size(32,32);
	TSpriteCreateParams params(size,TPoint(-16,-16),DrawSquare);
	TSpriteCreateParams paramarray[eNumPointerCursors];
	TInt lineWidth1=3;
	TInt lineWidth2=5;
	paramarray[2]=params;
	params.iDrawFunc=DrawCircle;
	paramarray[3]=params;
	params.iDrawFunc=DrawOpenSquare;
	params.iDrawFuncParam=&lineWidth1;
	paramarray[5]=params;
	params.iDrawFunc=DrawOpenCircle;
	paramarray[6]=params;
	params.iOffset=TPoint(0,0);
	params.iDrawFunc=DrawArrow;
	params.iDrawFuncParam=&lineWidth2;
	paramarray[1]=params;
	params.iOffset.iX=-31;
	params.iDrawFunc=DrawTriangle;
	paramarray[4]=params;
	params.iOffset=TPoint(-15,-15);
	params.iDrawFunc=DrawCross;
	paramarray[0]=params;
	CFbsBitmap *bitmap;
	TInt ii,jj;
	TDisplayMode mode=Client()->iWs.GetDefModeMaxNumColors(ii,jj);
	for (ii=0;ii<eNumPointerCursors;++ii)
		{
		bitmap=NULL;
		iBitmaps[ii]=new(ELeave) CFbsBitmap();
		User::LeaveIfError(iBitmaps[ii]->Create(size,mode));
		iCursors[ii]=new(ELeave) CTPointerCursor(Client()->iWs);
		iCursors[ii]->ConstructL(1,&paramarray[ii],0,iBitmaps[ii],bitmap);
		delete bitmap;
		}
	}

TestState CPointerCursorTest::DoTestL()
	{
	switch(iState)
		{
		case 0:
			LogSubTest(_L("Pointer Cursor"),1);
			TestL(ETrue);
			iState++;
			return(EContinue);
		default:
			return(EFinished);
		}
	}