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