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

// used for timing graphics

// 

//

#include "TTIME.H"

#define TEST_BITMAP_NAME _L("Z:\\WSTEST\\TEST.MBM")

GLREF_C void Panic(TInt aPanic);

enum TFuncType

	{

	EBitmapTest,

	EXorTest,

	ESmallClearTest,

	ERectCompareTest,

	EUseFontTest,

	EBitBltTest,

	EFullScreenBitBltTest,

	EMaskedBitBltTest,

	EFillPatternTest,

	EBackupWindowDrawingTest,

	};

class TGraphicsTest : public CBase

	{

public:

	void DoTestL(TInt aOwningGroup, TFuncType aFunc, TInt aParam1, TAny *aParam2);

	void DrawBitmapTestL(TInt aParam1, TAny *aParam2);

	void XorTest(TInt aParam1, TAny *aParam2);

	void SmallClearTest(TInt , TAny *);

	void RectCompareTest(TInt , TAny *);

	void UseFontTestL(TInt , TAny *);

	void BitBltTestL(TInt , TAny *);

	void FullScreenBitBltTestL(TInt , TAny *);

	void MaskedBitBltTestL(TInt , TAny *);

	void FillPatternTestL(TInt , TAny *);

	void BackedUpWindowDrawingL(TInt aMode, TAny *);

private:

	RWsSession iWs;

	CWsScreenDevice *iDevice;

	RWindowGroup iGroup;

	RWindow iWindow;

	RBackedUpWindow iBackedUpWindow;

	RDrawableWindow *iWindowPtr;

	CWindowGc *iGc;

	};

TInt CreateGraphicsTest(TInt aOwningGroup, TFuncType aFunc, TInt aParam1, TAny *aParam2)

	{

	TGraphicsTest *iTest=NULL;

	TRAPD(err,iTest=new(ELeave) TGraphicsTest());

	if (err==KErrNone)

		{

		TRAP(err,iTest->DoTestL(aOwningGroup, aFunc, aParam1, aParam2));

		delete iTest;

		}

	return(err);

	}

void TGraphicsTest::DoTestL(TInt aOwningGroup, TFuncType aFunc, TInt aParam1, TAny *aParam2)

	{

	iWs.Connect();

	iDevice=new(ELeave) CWsScreenDevice(iWs);

	iDevice->Construct();

	iGroup=RWindowGroup(iWs);

	iGroup.Construct(ENullWsHandle);

	iGroup.SetOwningWindowGroup(aOwningGroup);

//

	if (aFunc==EBackupWindowDrawingTest)

		{

		iBackedUpWindow=RBackedUpWindow(iWs);

		iWindowPtr=&iBackedUpWindow;

		iBackedUpWindow.Construct(iGroup,EGray4,ENullWsHandle);

		}

	else

		{

		iWindow=RWindow(iWs);

		iWindowPtr=&iWindow;

		iWindow.Construct(iGroup,ENullWsHandle);

		}

	User::LeaveIfError(iWindowPtr->SetExtentErr(TPoint(), iDevice->SizeInPixels()));

	iWindowPtr->Activate();

	//

	iDevice->CreateContext(iGc);

	iGc->Activate(*iWindowPtr);

	if (iWindowPtr==&iWindow)

		{

		iWindow.BeginRedraw();

		iGc->Clear();

		iWindow.EndRedraw();

		}

	switch(aFunc)

		{

		case EBitmapTest:

			DrawBitmapTestL(aParam1, aParam2);

			break;

		case EXorTest:

			XorTest(aParam1, aParam2);

			break;

		case ESmallClearTest:

			SmallClearTest(aParam1, aParam2);

			break;

		case ERectCompareTest:

			RectCompareTest(aParam1, aParam2);

			break;

		case EUseFontTest:

			UseFontTestL(aParam1, aParam2);

			break;

		case EBitBltTest:

			BitBltTestL(aParam1, aParam2);

			break;

		case EFullScreenBitBltTest:

			FullScreenBitBltTestL(aParam1, aParam2);

			break;

		case EMaskedBitBltTest:

			MaskedBitBltTestL(aParam1, aParam2);

			break;

		case EFillPatternTest:

			FillPatternTestL(aParam1, aParam2);

			break;

		case EBackupWindowDrawingTest:

			BackedUpWindowDrawingL(aParam1, aParam2);

			break;

		default:;

		}

//

	delete iGc;

	iWindowPtr->Close();

	iGroup.Close();

	delete iDevice;

	iWs.Close();

	}

// Draw bitmap //

void TGraphicsTest::DrawBitmapTestL(TInt , TAny *)

	{

	CFbsBitmap *bitmap=new(ELeave) CFbsBitmap;

	User::LeaveIfError(bitmap->Load(TEST_BITMAP_NAME,0));

	for(TInt nTimes=0;nTimes<10;nTimes++)

		{

		iGc->Clear();

		TSize size(iDevice->SizeInPixels());

		iGc->DrawBitmap(TRect(-size.iWidth,-size.iHeight,size.iWidth<<1,size.iHeight<<1),bitmap);

		iWs.Flush();

		}

	delete bitmap;

	}

TInt DrawBitmapTestFunc(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, EBitmapTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader DrawBitmapTest={_S("Draw bitmap"),DrawBitmapTestFunc};

// XOR Test //

void TGraphicsTest::XorTest(TInt , TAny *)

	{

	iGc->SetDrawMode(CGraphicsContext::EDrawModeXOR);

	iGc->SetBrushColor(TRgb::Gray256(255));

	iGc->SetPenStyle(CGraphicsContext::ENullPen);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	for(TInt count=0;count<10;count++)

		{

		for(TInt wid=1;wid<320;wid+=3)

			{

			iGc->DrawRect(TRect(10,10,10+wid,150));

	//		iWs.Flush();

			}

		}

	}

TInt XorIngTestFunc(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, EXorTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader XorIngTest={_S("Xor'ing"),XorIngTestFunc};

// XOR Test //

void TGraphicsTest::SmallClearTest(TInt , TAny *)

	{

	iGc->SetBrushColor(TRgb::Gray256(255));

	iGc->SetPenStyle(CGraphicsContext::ENullPen);

	iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	for(TInt count=0;count<500;count++)

		{

		for(TInt wid=1;wid<30;wid++)

			{

			iGc->DrawRect(TRect(1,0,10+wid,100));

//			iWs.Flush();

			}

		}

	}

TInt SmallClearTestFunc(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, ESmallClearTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader SmallClearTest={_S("Small clear rect"),SmallClearTestFunc};

// XOR Test //

enum {EMaxWidth=100};

void TGraphicsTest::RectCompareTest(TInt , TAny *)

	{

	TSize size(iDevice->SizeInPixels());

	for(TInt count=0;count<10;count++)

		iDevice->RectCompare(TRect(0,0,size.iWidth>>1,size.iHeight),TRect(size.iWidth>>1,0,size.iWidth,size.iHeight));

	}

TInt RectCompareTestFunc(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, ERectCompareTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader RectCompareTest={_S("RectCompare"),RectCompareTestFunc};

// Use Font //

void TGraphicsTest::UseFontTestL(TInt , TAny *)

	{

	CFbsFont *font;

	TFontSpec fspec(KTestFontTypefaceName,200);

	User::LeaveIfError(iDevice->GetNearestFontToDesignHeightInTwips((CFont *&)font, fspec));

	for(TInt count=0;count<1000;count++)

		iGc->UseFont(font);

	iDevice->ReleaseFont(font);

	}

TInt UseFontTestFunc(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, EUseFontTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader UseFontTest={_S("UseFont(x1000)"),UseFontTestFunc};

// Small BitBlt //

void TGraphicsTest::BitBltTestL(TInt , TAny *)

	{

	CWsBitmap *bitmap=new(ELeave) CWsBitmap(iWs);

	TSize size(25,50);

	bitmap->Create(size,EGray4);

	CFbsDevice *bitmapDevice=CFbsBitmapDevice::NewL(bitmap);

	CFbsBitGc *gc=CFbsBitGc::NewL();

	gc->Activate(bitmapDevice);

	gc->DrawEllipse(TRect(size));

	delete gc;

	delete bitmapDevice;

	for(TInt count=0;count<10;count++)

		{

		iGc->Clear();

		TPoint pos(0,0);

		for(TInt xcount=0;xcount<25;xcount++,pos.iX+=size.iWidth)

			{

			pos.iY=0;

			for(TInt ycount=0;ycount<4;ycount++,pos.iY+=size.iHeight)

				iGc->BitBlt(pos,bitmap);

			}

		}

	delete bitmap;

	}

TInt BitBltTestFunc(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, EBitBltTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader BitBltTest={_S("BitBlt"),BitBltTestFunc};

// Full Screen BitBlt //

void TGraphicsTest::FullScreenBitBltTestL(TInt , TAny *)

	{

	CWsBitmap *bitmap=new(ELeave) CWsBitmap(iWs);

	TSize size(640,240);

	User::LeaveIfError(bitmap->Create(size,EGray4));

	CFbsDevice *bitmapDevice=CFbsBitmapDevice::NewL(bitmap);

	CFbsBitGc *gc=CFbsBitGc::NewL();

	gc->Activate(bitmapDevice);

	for(TInt pos=0;pos<size.iWidth;pos+=8)

		{

		gc->DrawRect(TRect(pos,0,pos+16,size.iHeight));

		iGc->BitBlt(TPoint(0,0),bitmap);

		iWs.Flush();

		}

	delete gc;

	delete bitmapDevice;

	delete bitmap;

	}

TInt FullScreenBitBltTestFunc(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, EFullScreenBitBltTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader FullScreenBitBltTest={_S("FullScreenBitBlt"),FullScreenBitBltTestFunc};

// Masked BitBlt //

void TGraphicsTest::MaskedBitBltTestL(TInt , TAny *)

	{

	TSize size(24,48);

	CWsBitmap *bitmap=new(ELeave) CWsBitmap(iWs);

	bitmap->Create(size,EGray4);

	CFbsDevice *bitmapDevice=CFbsBitmapDevice::NewL(bitmap);

	CFbsBitGc *gc=CFbsBitGc::NewL();

	gc->Activate(bitmapDevice);

	gc->DrawEllipse(TRect(size));

	delete bitmapDevice;

// Now do the mask

	CWsBitmap *mask=new(ELeave) CWsBitmap(iWs);

	mask->Create(size,EGray4);

	bitmapDevice=CFbsBitmapDevice::NewL(mask);

	gc->Activate(bitmapDevice);

	gc->SetPenColor(TRgb::Gray4(3));

	gc->DrawEllipse(TRect(size));

	delete bitmapDevice;

//

	delete gc;

	for(TInt count=0;count<10;count++)

		{

		iGc->Clear();

		TPoint pos(0,0);

		for(TInt xcount=0;xcount<25;xcount++,pos.iX+=size.iWidth+1)

			{

			pos.iY=0;

			for(TInt ycount=0;ycount<4;ycount++,pos.iY+=size.iHeight)

				iGc->BitBltMasked(pos,bitmap,TRect(size),mask,EFalse);

			}

		}

	delete bitmap;

	delete mask;

	}

TInt MaskedBitBltTestFunc(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, EMaskedBitBltTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader MaskedBitBltTest={_S("MaskedBitBlt"),MaskedBitBltTestFunc};

// Fill Pattern //

void TGraphicsTest::FillPatternTestL(TInt , TAny *)

	{

	TSize scrSize(iDevice->SizeInPixels());

	TSize rectSize(scrSize.iWidth/5-1,scrSize.iHeight/2);

	CWsBitmap *bitmap=new(ELeave) CWsBitmap(iWs);

	TSize bitmapSize(50,40);

	bitmap->Create(bitmapSize,EGray4);

	CFbsDevice *bitmapDevice=CFbsBitmapDevice::NewL(bitmap);

	CFbsBitGc *gc=CFbsBitGc::NewL();

	gc->Activate(bitmapDevice);

	gc->SetBrushColor(TRgb::Gray4(2));

	gc->SetBrushStyle(CGraphicsContext::ESolidBrush);

	gc->DrawEllipse(TRect(bitmapSize));

	delete bitmapDevice;

	delete gc;

//

	iGc->UseBrushPattern(bitmap);

	iGc->SetBrushStyle(CGraphicsContext::EPatternedBrush);

	iGc->SetPenStyle(CGraphicsContext::ESolidPen);

	for(TInt count=0;count<50;count++)

		{

		iGc->Clear();

		TPoint pos(0,0);

		for(TInt xcount=0;xcount<5;xcount++,pos.iX+=rectSize.iWidth)

			{

			pos.iY=0;

			for(TInt ycount=0;ycount<2;ycount++,pos.iY+=rectSize.iHeight)

				iGc->DrawRect(TRect(pos,rectSize));

			}

		}

	delete bitmap;

	}

TInt FillPatternTestFunc(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, EFillPatternTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader FillPatternTest={_S("FillPattern"),FillPatternTestFunc};

// Backup Window Drawing //

void TGraphicsTest::BackedUpWindowDrawingL(TInt aMode, TAny *)

	{

	TSize scrSize(iDevice->SizeInPixels());

	CFbsFont *font=NULL;

	if (aMode==1)

		{

		TFontSpec fspec(KTestFontTypefaceName,200);

		User::LeaveIfError(iDevice->GetNearestFontToDesignHeightInTwips((CFont *&)font, fspec));

		iGc->UseFont(font);

		}

	iGc->SetPenStyle(CGraphicsContext::ESolidPen);

	TPoint pos;

	for(TInt count=0;count<10;count++)

		{

		iGc->Clear();

		for(pos.iY=0;pos.iY<scrSize.iHeight;pos.iY++)

			iGc->DrawLine(pos,pos+TSize(scrSize.iWidth,0));

		}

	if (aMode==1)

		iDevice->ReleaseFont(font);

	}

TInt BackupWindowDrawingFunc1(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, EBackupWindowDrawingTest, 0, NULL));

	}

GLDEF_D TTimeTestHeader BackupWindowDrawingCreate1={_S("BackupWindowDrawing 1"),BackupWindowDrawingFunc1};

TInt BackupWindowDrawingFunc2(TInt aOwningGroup)

	{

	return(CreateGraphicsTest(aOwningGroup, EBackupWindowDrawingTest, 1, NULL));

	}

GLDEF_D TTimeTestHeader BackupWindowDrawingCreate2={_S("BackupWindowDrawing 2"),BackupWindowDrawingFunc2};