diff -r 000000000000 -r 5d03bc08d59c graphicstest/uibench/src/tredrawing.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicstest/uibench/src/tredrawing.cpp	Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,560 @@
+// 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();
+	}