// Copyright (c) 2006-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 "tredrawing.h"

const TInt KIconSeparationInPixels = 18;

const TInt KIconSizePlusSeparation = 34;

// Test bitmap files

_LIT(KAlphaTestBitmap,"z:\\system\\data\\uibench_24bit.mbm");

_LIT(K12BitBitmap, "z:\\system\\data\\uibench_12bit.mbm");

_LIT(K16x16Icon,"z:\\system\\data\\16x16icon.mbm");

const TInt KIterationsToTest = 500;

//

// CRedrawingTest

//

CRedrawingTest::CRedrawingTest()

	{

	SetTestStepName(KRedrawingTest);

	}

CRedrawingTest::~CRedrawingTest()

	{

	delete iWsClient;		

	}	

inline CTProfiler& CRedrawingTest::Profiler() const

    {

    return *iProfiler;

    }

/**

Override of base class virtual

@return - TVerdict code

*/

TVerdict CRedrawingTest::doTestStepPreambleL()

	{	

	CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL();	

	SetScreenModeL(EColor16MU);

	return TestStepResult();

	}

TVerdict CRedrawingTest::doTestStepL()

	{

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0060

@SYMTestType UT

@SYMTestPriority Critical

@SYMDEF DEF100017

@SYMTestCaseDesc Measures performance of redraws with bitblt

@SYMTestActions

1. Create a background window with an opaque bitmap.

2. Create two test windows both transparent with bitmaps bitblt masked to the windows.

3. Repeatly swap the order of the two test windows in a loop and measure the average performance after many iterations.

@SYMTestExpectedResults

Measure the performance of swapping the windows so that front window goes behind the back window.

*/	

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

	RunRedrawWindowTestCaseL(_L("Redraw-Bitblt"), ETwoWindowBitblt);

	RecordTestResultL();

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0061

@SYMTestType UT

@SYMTestPriority Critical

@SYMDEF DEF100017

@SYMTestCaseDesc Measures performance of redraws with bitblt masked

@SYMTestActions

1. Create a background window with an opaque bitmap.

2. Create two test windows both transparent with bitmaps bitblt masked to the windows.

3. Repeatly swap the order of the two test windows in a loop and measure the average performance after many iterations.

@SYMTestExpectedResults

Measure the performance of swapping the windows so that front window goes behind the back window.

*/	

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

	RunRedrawWindowTestCaseL(_L("Redraw-BitbltMasked"), ETwoWindowBitbltMasked);

	RecordTestResultL();

/**

@SYMTestCaseID GRAPHICS-UI-BENCH-0062

@SYMTestType UT

@SYMTestPriority Critical

@SYMDEF DEF100017

@SYMTestCaseDesc Measures performance of redraws of window with many small bitmaps

@SYMTestActions

1. Create a background window with an opaque bitmap.

2. Create two test windows both transparent with many small bitmaps bitblt to the windows.

3. Repeatly invalidate a small region of the window in a loop and measure performance.

@SYMTestExpectedResults

Measure the performance of invalidating a small region of the window.

*/	

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

	RunRedrawWindowTestCaseL(_L("Redraw-ManyBitmapsBitblt"), ETwoWindowManyBitmapsBitblt);

	RecordTestResultL();

	return TestStepResult();

	}

/**

This method runs the actual test case given the test name and test case Enum

@param aTestName is the test case name to be displayed in the log file - must be unique for each test case

@param aTestCase the test case to run

*/

void CRedrawingTest::RunRedrawWindowTestCaseL(const TDesC& aTestName, TRedrawTestCase aTestCase)

	{

	iWsClient = new(ELeave) CWsClient(*this, aTestCase);

	iProfiler->StartTimer();

	iWsClient->ConstructL();	

	CActiveScheduler::Start(); 	// Starts the active schedule that starts the test

	iProfiler->MarkResultSetL();			// Returns here once the test has completed.

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

	delete iWsClient;

	iWsClient=NULL;

	}

//

// CWsRedrawer

//

CWsRedrawer::CWsRedrawer() : CActive(CActive::EPriorityLow)

    {

    }

void CWsRedrawer::ConstructL(CWsClient* aClient)

    {

    iClient = aClient;

    CActiveScheduler::Add(this);

    IssueRequest();

    }

CWsRedrawer::~CWsRedrawer()

    {

    Cancel();

    }

void CWsRedrawer::IssueRequest()

    {

    iClient->WsSession().RedrawReady(&iStatus);

    SetActive();

    }

void CWsRedrawer::DoCancel()

    {

    iClient->WsSession().RedrawReadyCancel();

    }

void CWsRedrawer::RunL()

    {

    // find out what needs to be done

    TWsRedrawEvent redrawEvent;

    iClient->WsSession().GetRedraw(redrawEvent); // get event

    CWindow* window=(CWindow*)(redrawEvent.Handle()); // get window

    if (window)

        {

        TRect rect=redrawEvent.Rect(); // and rectangle that needs redrawing

        // now do drawing

        iClient->Gc().Activate(window->Window());

        window->Window().BeginRedraw(rect);

        window->Draw(rect);

        window->Window().EndRedraw();

        iClient->Gc().Deactivate();

        }

    // maintain outstanding request

    IssueRequest();

    }

//

// CWindow

//

CWindow::CWindow(CWsClient* aClient, TRedrawTestCase aTestCase)

    : iClient(aClient), iTestCase(aTestCase)

    {

    }

void CWindow::ConstructL (const TRect& aRect, CWindow* aParent)

    {

    // If a parent window was specified, use it; if not, use the window group

    // (aParent defaults to 0).

    RWindowTreeNode* parent= aParent ? (RWindowTreeNode*) &(aParent->Window()) : &(iClient->WindowGroup());

    iWindow=RWindow(iClient->WsSession()); // use app's session to window server

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

    iRect = aRect;

    iWindow.SetExtent(iRect.iTl, iRect.Size()); // set extent relative to group coords    

    }

CWindow::~CWindow()

    {

    iWindow.Close();

    }

RWindow& CWindow::Window()

    {

    return iWindow;

    }

void CWindow::Activate()

	{

	iWindow.Activate();

	}

CWindowGc& CWindow::SystemGc()

    {

    return iClient->Gc();

    }

//

// CMainWindow

//

CMainWindow::CMainWindow(CWsClient* aClient, TRedrawTestCase aTestCase) : CWindow (aClient, aTestCase)

    {

    }

void CMainWindow::ConstructL(const TRect& aRect, CWindow* aParent)

	{	

	CWindow::ConstructL(aRect,aParent);

	iBitmapImage = iClient->TestSuite().LoadBitmapL(KAlphaTestBitmap,0);

	}

CMainWindow::~CMainWindow()

    {

    delete iBitmapImage;

    }

void CMainWindow::Draw(const TRect& aRect)

    {    

    CWindowGc& gc=SystemGc();

    gc.SetClippingRect(aRect);

    gc.BitBlt(TPoint(0,0), iBitmapImage);

    }

//

// CTestWindow

//

CTestWindow::CTestWindow(CWsClient* aClient, TRedrawTestCase aTestCase) : CWindow (aClient, aTestCase)

    {

    }

void CTestWindow::ConstructL(const TRect& aRect, CWindow* aParent)

	{	

	CWindow::ConstructL(aRect,aParent);

	// Load all bitmaps

	iBitmapImage = iClient->TestSuite().LoadBitmapL(KAlphaTestBitmap,0);

	iBitmap12bit = iClient->TestSuite().LoadBitmapL(K12BitBitmap, 0);

	iAlpha8bitMask = iClient->TestSuite().CopyIntoNewBitmapL(iBitmap12bit, EGray256);

	i16x16Icon = iClient->TestSuite().LoadBitmapL(K16x16Icon, 0);	

	i16x16IconMonochrome = iClient->TestSuite().LoadBitmapL(K16x16Icon, 1);	

	}

CTestWindow::~CTestWindow()

    {

    delete iBitmapImage;

    delete iBitmap12bit;

    delete iAlpha8bitMask;

    delete i16x16Icon;

    delete i16x16IconMonochrome;

    iWindow.Close();

    }

void CTestWindow::Draw(const TRect& aRect)

    {

    CWindowGc& gc=SystemGc();

    gc.SetClippingRect(aRect);

    // -*-* Add new test cases here for drawing to test window

    switch(iTestCase)

    	{

    	case ETwoWindowBitblt:     		    		

    		gc.BitBlt(TPoint(0,0), iBitmapImage);

    		break;

    	case ETwoWindowBitbltMasked:

    		{

    		TRect cropTo(0,0,300,300);

    		gc.BitBltMasked(TPoint(0,0), iBitmapImage, cropTo, iAlpha8bitMask, EFalse);

    		break;

    		}

    	case ETwoWindowManyBitmapsBitblt:

			{			

			// Draw a matrix of bitmaps in the window

			for (TInt y=10;y>=0;--y)

				{				

				for (TInt x=10;x>=0;--x)

					{

					if (!iBitmapFlag)

						gc.BitBlt(TPoint(x*KIconSeparationInPixels, y*KIconSeparationInPixels), i16x16Icon);

					else

						gc.BitBlt(TPoint(x*KIconSeparationInPixels, y*KIconSeparationInPixels), i16x16IconMonochrome);

					}

				}

			iBitmapFlag=!iBitmapFlag;

			break;

			}    		

    	}

    }

/** 

Create an application initiated draw by drawing doign a bitblt in a small area of the window

*/

void CTestWindow::AppInitiatedDraw()

	{

	TRect rect(KIconSeparationInPixels,KIconSeparationInPixels,KIconSizePlusSeparation,KIconSizePlusSeparation);

	CWindowGc& gc=SystemGc();

	gc.Activate(iWindow);

	iWindow.BeginRedraw(rect);

	if (!iBitmapFlag)

		gc.BitBlt(TPoint(KIconSeparationInPixels,KIconSeparationInPixels), i16x16IconMonochrome);

	else

		gc.BitBlt(TPoint(KIconSeparationInPixels,KIconSeparationInPixels), i16x16Icon);

	iWindow.EndRedraw();

	gc.Deactivate();

	iBitmapFlag=!iBitmapFlag;

	}

//

// CWsClient

//

CWsClient::CWsClient(CRedrawingTest& aTestSuite, TRedrawTestCase aTestCase) : CActive(CActive::EPriorityHigh), iTestCase(aTestCase), iTestSuite(aTestSuite)

    {

    }

void CWsClient::ConstructL()

    {    

    CActiveScheduler::Add(this);

    // Connect to windows server

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

    // construct our one and only window group

    iGroup=RWindowGroup(iWs);

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

    // construct screen device and graphics context

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

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

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

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

    // construct redrawer

    iRedrawer=new (ELeave) CWsRedrawer;

    iRedrawer->ConstructL(this);

    // construct main window

    ConstructMainWindowL();

    // request first event and start scheduler

    IssueRequest();

    }

CWsClient::~CWsClient()

    {

    Cancel();

    delete iGc;

    delete iScreen;

    delete iRedrawer;

    delete iMainWindow;

    delete iTestWindow;

    delete iTestWindow2;

	delete iTestActive;	

    iGroup.Close();

    iWs.Close();

    }

void CWsClient::IssueRequest()

    {

    iWs.EventReady(&iStatus); // request an event for standard events. i.e. All events except redraws and pointer priority key events

    SetActive();

    }

void CWsClient::DoCancel()

    {

    iWs.EventReadyCancel(); // cancel event request

    }

void CWsClient::ConstructMainWindowL()

    {	                

    iTestActive = new(ELeave)CWsClient::CRedrawingTestActive(*this);    

	iTestActive->ConstructL();

	// -*-* Add new windows for test cases here

	switch (iTestCase)	

		{

		case ETwoWindowBitblt:

		case ETwoWindowBitbltMasked:

			{

			// Create the main background window with a bitmap image. This window is not transparent.

		    iMainWindow=new (ELeave) CMainWindow(this, iTestCase);

		    iMainWindow->ConstructL(iRect);

		    iMainWindow->Activate();

			// Create the first test window. This window is transparent.

		    iTestWindow = new(ELeave) CTestWindow(this, iTestCase);

		    iTestWindow->ConstructL(TRect (TPoint (10, 10), TSize (200, 200)), iMainWindow);

		    TInt ret = iTestWindow->Window().SetTransparencyFactor(TRgb(0xbbbbbb,128));

		    User::LeaveIfError(ret);

		    iTestWindow->Activate();    

		    // Create the second test window. This window is also transparent.

		    iTestWindow2 = new(ELeave) CTestWindow(this, iTestCase);

		    iTestWindow2->ConstructL(TRect (TPoint (30, 30), TSize (250, 200)), iMainWindow);	    

		    ret = iTestWindow2->Window().SetTransparencyFactor(TRgb(0xddaa55,200));

		    User::LeaveIfError(ret);    

		    iTestWindow2->Activate();

		    break;

			}

		case ETwoWindowManyBitmapsBitblt:

			{

			// Create the main background window with a bitmap image. This window is not transparent.

		    iMainWindow=new (ELeave) CMainWindow(this, iTestCase);

		    iMainWindow->ConstructL(iRect);

		    iMainWindow->Activate();

			// Create the first test window. This window is transparent.

		    iTestWindow = new(ELeave) CTestWindow(this, iTestCase);

		    iTestWindow->ConstructL(TRect (TPoint (10, 10), TSize (200, 200)), iMainWindow);

		    TInt ret = iTestWindow->Window().SetTransparencyFactor(TRgb(0xbbbbbb,128));

		    User::LeaveIfError(ret);

		    iTestWindow->Activate(); 

			// Create the second test window. This window is also transparent.

		    iTestWindow2 = new(ELeave) CTestWindow(this, iTestCase);

		    iTestWindow2->ConstructL(TRect (TPoint (10, 10), TSize (250, 200)), iMainWindow);	    

		    ret = iTestWindow2->Window().SetTransparencyFactor(TRgb(0xddaa55,200));

		    User::LeaveIfError(ret);    

		    iTestWindow2->Activate();   				

			}

			break;

		}

    }

// Handle standard events from the window server.

// Standard events include all events except redraws and priority key events.

void CWsClient::RunL()

	{

	}

//

// CWsClient::CRedrawingTestActive inner class

// Set to low priority to avoid starving other active objects from being executed.

//

CWsClient::CRedrawingTestActive::CRedrawingTestActive(CWsClient& aClient) : CActive(CActive::EPriorityLow), iClient(aClient)

	{	

	CActiveScheduler::Add(this);

	}

CWsClient::CRedrawingTestActive::~CRedrawingTestActive()

	{

	Cancel();

	}

void CWsClient::CRedrawingTestActive::ConstructL()

	{

	iClient.iTestSuite.Profiler().InitResults();

	// Start active object and run tests

	RequestComplete();

	}

void CWsClient::CRedrawingTestActive::DoCancel()

	{

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrCancel);

	}

void CWsClient::CRedrawingTestActive::RequestComplete()

	{		

	SetActive();

    TRequestStatus* status = &iStatus;

    User::RequestComplete(status, KErrNone);

	}

/**

The test iterates KIterationsToTest times, after which the active scheduler is stopped

which passes control back to CRedrawingTest.

*/	

void CWsClient::CRedrawingTestActive::RunL()

	{

	TInt status = iStatus.Int();

	if (status==KErrNone)	

		{	

		switch(iClient.iTestCase)

			{

			// -*-* Add test cases here

			case ETwoWindowBitblt:

			case ETwoWindowBitbltMasked:

				TestTwoWindowsBitBlt();

				break;

			case ETwoWindowManyBitmapsBitblt:

				TestInvalidateSmallArea();

				break;

			}

		if (++iIterationCount > KIterationsToTest)	// If we reached last iteration then stop the active scheduler

			{		

			CActiveScheduler::Stop();

			}

		}		

	RequestComplete();

	}

/**

This flips the window ordinals around each time it is called

*/

void CWsClient::CRedrawingTestActive::TestTwoWindowsBitBlt()

	{

	if (iFlipWindow)

		{		

		iClient.iTestWindow->Window().SetOrdinalPosition(0);

		iClient.iTestWindow2->Window().SetOrdinalPosition(1);

		iFlipWindow=EFalse;

		} 

	else 

		{

		iClient.iTestWindow->Window().SetOrdinalPosition(1);

		iClient.iTestWindow2->Window().SetOrdinalPosition(0);		

		iFlipWindow=ETrue;

		}

	iClient.iWs.Flush();

	}

/**

This invalidates a small area of the window and causes an appication initiated draw

*/

void CWsClient::CRedrawingTestActive::TestInvalidateSmallArea()

	{

	iClient.iTestWindow->Window().Invalidate(TRect(KIconSeparationInPixels,KIconSeparationInPixels,KIconSizePlusSeparation,KIconSizePlusSeparation));

	// Application inititated draw

	iClient.iTestWindow->AppInitiatedDraw();

	iClient.iWs.Flush();

	}