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

 //

 /**

  @file

  @test

  @internalComponent - Internal Symbian test code 

 */

 #include "ttranslucent.h"

 const TInt KIterationsToTest = 100;

 //

 // CTTranslucent

 //

 CTTranslucent::CTTranslucent()

 	{

 	SetTestStepName(KTTranslucent);

 	}

 CTTranslucent::~CTTranslucent()

 	{

 	iWindowArray.ResetAndDestroy();

 	iWindowArray.Close();

     delete iTopWindow;

     delete iBottomWindow;

     delete iBitmap; 

     delete iGc;

     delete iScreen;

 	iWindowGroup.Close();

 	iWsSession.Close();

 	}	

 /**

 Override of base class virtual

 @return - TVerdict code

 */

 TVerdict CTTranslucent::doTestStepPreambleL()

 	{	

 	CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();	

 	SetScreenModeL(EColor16MU);

 	return TestStepResult();

 	}

 TVerdict CTTranslucent::doTestStepL()

 	{

     User::LeaveIfError(iWsSession.Connect());

     iWindowGroup=RWindowGroup(iWsSession);

     User::LeaveIfError(iWindowGroup.Construct(2, ETrue)); // meaningless handle; enable focus

     // construct screen device and graphics context

     iScreen=new (ELeave) CWsScreenDevice(iWsSession); // make device for this session

     User::LeaveIfError(iScreen->Construct()); // and complete its construction

     User::LeaveIfError(iScreen->CreateContext(iGc)); // create graphics context

     iScreenRect = TRect(0,0,iScreen->SizeInPixels().iWidth, iScreen->SizeInPixels().iHeight);

     // Construct a gradient bitmap for use by bitmap test

 	CFbsBitmap* bitmap = new (ELeave) CFbsBitmap;

 	CleanupStack::PushL(bitmap);

 	User::LeaveIfError(bitmap->Create(TSize(80,80), EColor16MA));

 	CTe_graphicsperformanceSuiteStepBase::VerticalGradientAlphaL(bitmap, TRgb(0x000000ff), TRgb(0xff000000));

 	delete iBitmap;

 	iBitmap = bitmap;

 	CleanupStack::Pop(bitmap);

 	/**

 	@SYMTestCaseID GRAPHICS-UI-BENCH-0132

 	@SYMPREQ PREQ1841

 	@SYMTestCaseDesc Measures time taken to redraw 2, 8, 32 and 144 blank translucent

 					 partially overlapping windows.

 	@SYMTestActions

 	1. Create blank translucent partially overlapping windows.

 	2. Cover them all with an "ontop" window.

 	3. Hide the "ontop" window and measure time taken to redraw all overlapping windows underneath.

 	4. Repeat KIterationsToTest times and calculate average time per iteration.

 	@SYMTestExpectedResults

 	As the number of windows increases, so should the time taken to redraw them.

 	*/	

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0132"));

 	RunTestCaseL(_L("Redraw-BlankWindows2"), EBlankWindows, 2, 1);

 	RunTestCaseL(_L("Redraw-BlankWindows8"), EBlankWindows, 2, 4);

 	RunTestCaseL(_L("Redraw-BlankWindows32"), EBlankWindows, 4, 8);

 	RunTestCaseL(_L("Redraw-BlankWindows144"), EBlankWindows, 12, 12);

 	RecordTestResultL();

 	/**

 	@SYMTestCaseID GRAPHICS-UI-BENCH-0133

 	@SYMPREQ PREQ1841

 	@SYMTestCaseDesc Measures time taken to redraw 2, 8, 32 and 144 translucent

 					 partially overlapping windows containing drawn text.

 	@SYMTestActions

 	1. Create translucent partially overlapping windows.

 	2. Cover them all with an "ontop" window.

 	3. Hide the "ontop" window and measure time taken to redraw all overlapping windows underneath.

 	4. Repeat KIterationsToTest times and calculate average time per iteration.

 	@SYMTestExpectedResults

 	As the number of windows increases, so should the time taken to redraw them.

 	*/	

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0133"));

 	RunTestCaseL(_L("Redraw-TextWindows2"), ETextWindows, 2, 1);

 	RunTestCaseL(_L("Redraw-TextWindows8"), ETextWindows, 2, 4);

 	RunTestCaseL(_L("Redraw-TextWindows32"), ETextWindows, 4, 8);

 	RunTestCaseL(_L("Redraw-TextWindows144"), ETextWindows, 12, 12);

 	RecordTestResultL();

 	/**

 	@SYMTestCaseID GRAPHICS-UI-BENCH-0134

 	@SYMPREQ PREQ1841

 	@SYMTestCaseDesc Measures time taken to redraw 2, 8, 32 and 144 translucent

 					 partially overlapping windows containing drawn ellipsis.

 	@SYMTestActions

 	1. Create translucent partially overlapping windows.

 	2. Cover them all with an "ontop" window.

 	3. Hide the "ontop" window and measure time taken to redraw all overlapping windows underneath.

 	4. Repeat KIterationsToTest times and calculate average time per iteration.

 	@SYMTestExpectedResults

 	As the number of windows increases, so should the time taken to redraw them.

 	*/	

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0134"));

 	RunTestCaseL(_L("Redraw-EllipseWindows2"), EEllipseWindows, 2, 1);

 	RunTestCaseL(_L("Redraw-EllipseWindows8"), EEllipseWindows, 2, 4);

 	RunTestCaseL(_L("Redraw-EllipseWindows32"), EEllipseWindows, 4, 8);

 	RunTestCaseL(_L("Redraw-EllipseWindows144"), EEllipseWindows, 12, 12);

 	RecordTestResultL();

 	/**

 	@SYMTestCaseID GRAPHICS-UI-BENCH-0135

 	@SYMPREQ PREQ1841

 	@SYMTestCaseDesc Measures time taken to redraw 2, 8, 32 and 144 translucent

 					 partially overlapping windows containing bitmaps.

 	@SYMTestActions

 	1. Create translucent partially overlapping windows.

 	2. Cover them all with an "ontop" window.

 	3. Hide the "ontop" window and measure time taken to redraw all overlapping windows underneath.

 	4. Repeat KIterationsToTest times and calculate average time per iteration.

 	@SYMTestExpectedResults

 	As the number of windows increases, so should the time taken to redraw them.

 	*/	

 	SetTestStepID(_L("GRAPHICS-UI-BENCH-0135"));

 	RunTestCaseL(_L("Redraw-BitmapWindows2"), EBitmapWindows, 2, 1);

 	RunTestCaseL(_L("Redraw-BitmapWindows8"), EBitmapWindows, 2, 4);

 	RunTestCaseL(_L("Redraw-BitmapWindows32"), EBitmapWindows, 4, 8);

 	RunTestCaseL(_L("Redraw-BitmapWindows144"), EBitmapWindows, 12, 12);

 	RecordTestResultL();

 	return TestStepResult();

 	}

 void CTTranslucent::RunTestCaseL(const TDesC& aTestName, TTestCase aTestCase, TInt aHorizontalWindows, TInt aVerticalWindows)

 	{

 	iTestCase = aTestCase;

 	ConstructWindowsL(aHorizontalWindows, aVerticalWindows);

 	iWsSession.Finish(); // Make sure all windows are drawn in their initial state/positions

 	iProfiler->InitResults();

 	// Measure time taken to redraw all overlapping translucent windows

 	// and repeat KIterationsToTest times

 	for (int i = 0; i < KIterationsToTest; i++)

 		{

 		iProfiler->StartTimer();

 		iTopWindow->Window().SetVisible(EFalse); // hide ontop window to cause overlapping translucent windows to be redrawn

 		iWsSession.Finish();

 		iProfiler->MarkResultSetL();

 		iTopWindow->Window().SetVisible(ETrue); // show ontop window

 		iWsSession.Finish();

 		}

 	iProfiler->ResultsAnalysis(aTestName, 0, 0, ScreenDevice()->BitmapDevice().DisplayMode(), KIterationsToTest);

 	DestroyWindows();

 	}

 void CTTranslucent::ConstructWindowsL(TInt aHorizontalWindows, TInt aVerticalWindows)

 	{

 	// Create a yellow opaque window to use as the background for the translucent windows

     iBottomWindow = new (ELeave) CWin(iWsSession, iWindowGroup);

     iBottomWindow->ConstructL(iScreenRect);

     iBottomWindow->Window().SetBackgroundColor(TRgb(255, 255, 0));

     iBottomWindow->Window().SetOrdinalPosition(-1);

     iBottomWindow->Window().Invalidate();

     iBottomWindow->Window().BeginRedraw();

     iBottomWindow->Window().EndRedraw();

     iBottomWindow->Window().Activate();

 	// Create some green partially overlapping translucent windows.

 	// Each window has roughly the same aspect ratio as the screen.

 	// Each window is the same size for every test, regardless of how many windows are being created.

     // Maximum number of windows horizontally and vertically that we want to be able to fit onto

     // the screen. Window size is calculated based on screen width/height and number of windows we want

     // to fit in with the desired overlap.

     // KMaxWindows * KMaxWindows gives the total maximum number of windows that will fit on screen without

     // being clipped.

 	const TInt KMaxWindows = 12;

 	// Calculate 1/4 width of each window

 	const TInt KQuarterWidth = iScreenRect.Width() / (KMaxWindows + 3);

 	// Calculate 1/4 height of each window

 	const TInt KQuarterHeight = iScreenRect.Height() / (KMaxWindows + 3);

 	TRect rect(0, 0, 0, 0);

 	TInt x = 0;

 	TInt y = 0;

 	// Calculate size used for all translucent windows

 	TSize size(KQuarterWidth*4, KQuarterHeight*4);

 	TInt hCount = 0;

 	TInt vCount = 0;

 	for (hCount = 0; hCount < aHorizontalWindows; hCount++)

 		{

 		y = 0;

 		for (vCount = 0; vCount < aVerticalWindows; vCount++)

 			{

 			// Construct a vertical column of windows

 			CWin* win = new(ELeave) CWin(iWsSession, iWindowGroup);

 			CleanupStack::PushL(win);

 			iWindowArray.AppendL(win);

 			CleanupStack::Pop(win);

 			rect.iTl = TPoint(x, y);

 			rect.SetSize(size);

 			win->ConstructL(rect);

 			User::LeaveIfError(win->Window().SetTransparencyAlphaChannel());

 			win->Window().SetBackgroundColor(TRgb(0, 255, 0, 16));

 			TRect clipRect(size);

 			DrawWindowL(win, clipRect);

 			win->Window().Activate();

 			y+=KQuarterHeight;

 			}

 		x+=KQuarterWidth;

 		}

 	// Create a red opaque window ontop of all the others

 	iTopWindow = new (ELeave) CWin(iWsSession, iWindowGroup);

 	iTopWindow->ConstructL(iScreenRect);

 	iTopWindow->Window().SetBackgroundColor(TRgb(255, 0, 0));

 	iTopWindow->Window().SetOrdinalPosition(0);

 	iTopWindow->Window().Invalidate();

 	iTopWindow->Window().BeginRedraw();

 	iTopWindow->Window().EndRedraw();

 	iTopWindow->Window().Activate();

 	}

 void CTTranslucent::DestroyWindows()

 	{

 	iWindowArray.ResetAndDestroy();

     delete iTopWindow;

     iTopWindow = NULL;

     delete iBottomWindow;

 	iBottomWindow = NULL;

 	}

 void CTTranslucent::DrawWindowL(CWin* aWindow, const TRect& aRect)

 	{

 	iGc->Activate(aWindow->Window());

     iGc->SetClippingRect(aRect);

 	aWindow->Window().Invalidate();

 	aWindow->Window().BeginRedraw();

 	// Draw the whole window

     switch(iTestCase)

     	{

     	case EBlankWindows:

     		break; // Don't draw anything on the blank windows

     	case ETextWindows:

     		{

     		CFont* font;

     		TFontSpec fontSpec;

     		fontSpec.iHeight = 300;

     		User::LeaveIfError(iGc->Device()->GetNearestFontToDesignHeightInTwips(font, fontSpec));

     		iGc->UseFont(font);

     		iGc->DrawText(_L("Text"), TPoint(0,20));

     		iGc->DrawText(_L("window"), TPoint(0,40));

     		iGc->DiscardFont();

     		iGc->Device()->ReleaseFont(font);

     		break;

     		}

     	case EEllipseWindows:

     		iGc->SetPenColor(TRgb(0, 0, 0, 255));

     		iGc->SetBrushColor(TRgb(128, 128, 255, 128));

     		iGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

     		iGc->DrawEllipse(TRect(0,0,79,79));

     		iGc->DrawEllipse(TRect(10,10,69,69));

     		iGc->DrawEllipse(TRect(20,20,59,59));

     		iGc->DrawEllipse(TRect(30,30,49,49));

     		iGc->SetBrushColor(TRgb(255, 0, 0, 150));

     		iGc->SetBrushStyle(CGraphicsContext::EDiamondCrossHatchBrush);

     		iGc->DrawEllipse(TRect(0,0,20,15));

     		iGc->DrawEllipse(TRect(30,10,50,30));

     		break;

     	case EBitmapWindows:

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

     		break;

     	}

 	aWindow->Window().EndRedraw();

 	iGc->Deactivate();

 	}

 //

 // CWin

 //

 CTTranslucent::CWin::CWin(RWsSession& aWsSession, RWindowGroup& aWindowGroup)

 	:iWsSession(aWsSession), iWindowGroup(aWindowGroup)

     {

     }

 CTTranslucent::CWin::~CWin()

     {

     iWindow.Close();

     }

 void CTTranslucent::CWin::ConstructL (const TRect& aRect)

     {

     iWindow=RWindow(iWsSession);

     User::LeaveIfError(iWindow.Construct(iWindowGroup, (TUint32)this));

     iRect = aRect;

     iWindow.SetExtent(iRect.iTl, iRect.Size());

     }

 RWindow& CTTranslucent::CWin::Window()

 	{

 	return iWindow;

 	}