// 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();
	}