diff -r bf7481649c98 -r 7f25ef56562d windowing/windowserver/test/tauto/tdrawresource.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/test/tauto/tdrawresource.cpp Wed Jun 23 19:41:15 2010 +0300 @@ -0,0 +1,1144 @@ +// 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 "tdrawresource.h" +#include +#include +#include +#include +#include + + +__WS_CONSTRUCT_STEP__(DrawResource); + + +#if defined(__X86GCC__) +extern "C" TInt atexit(void (*function)(void)) + { + return KErrNone; + } +#endif + +// +// class CTestWsGraphicsContext +// +CTestWsGraphicsContext* CTestWsGraphicsContext::NewL(RDirectGdiImageTarget& aTarget) + { + CTestWsGraphicsContext* self = new(ELeave) CTestWsGraphicsContext; + CleanupStack::PushL(self); + self->ConstructL(aTarget); + CleanupStack::Pop(self); + return self; + } + +void CTestWsGraphicsContext::ConstructL(RDirectGdiImageTarget& aTarget) + { + CDirectGdiDriver* driver = CDirectGdiDriver::Static(); + User::LeaveIfNull(driver); + iContext = CDirectGdiContext::NewL(*driver); + TInt err = iContext->Activate(aTarget); + User::LeaveIfError(err); + } + +CTestWsGraphicsContext::~CTestWsGraphicsContext() + { + delete iContext; + } + +TAny* CTestWsGraphicsContext::ResolveObjectInterface(TUint aTypeId) + { + switch(aTypeId) + { + case MWsDrawableSourceProvider::EWsObjectInterfaceId: + return static_cast(this); + } + return NULL; + + } + +TInt CTestWsGraphicsContext::CreateDrawableSource(const TSgDrawableId& aDrawableId, TAny*& aSource) + { + TRAPD(err, DoCreateDrawableSourceL(aDrawableId, aSource)); + return err; + } + +void CTestWsGraphicsContext::DoCreateDrawableSourceL(const TSgDrawableId& aDrawableId, TAny*& aSource) + { + CDirectGdiDriver* driver = CDirectGdiDriver::Static(); + if (!driver) + { + User::Leave(KErrNotReady); + } + RDirectGdiDrawableSource* drawableSource = new(ELeave) RDirectGdiDrawableSource(*driver); + CleanupStack::PushL(drawableSource); + RSgDrawable drawable; + User::LeaveIfError(drawable.Open(aDrawableId, ESgDoNotRestrictUsage)); + CleanupClosePushL(drawable); + User::LeaveIfError(drawableSource->Create(drawable)); + CleanupStack::PopAndDestroy(); + CleanupStack::Pop(drawableSource); + aSource = drawableSource; + } + +void CTestWsGraphicsContext::CloseDrawableSource(TAny* aSource) + { + RDirectGdiDrawableSource* drawableSource = static_cast(aSource); + drawableSource->Close(); + delete drawableSource; + } + +void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TPoint& aPos, CWindowGc::TGraphicsRotation aRotation) + { + const RDirectGdiDrawableSource* drawableSource = static_cast(aSource); + iContext->DrawResource(aPos, *drawableSource, (DirectGdi::TGraphicsRotation)aRotation); + iPos = aPos; + iRotation = (DirectGdi::TGraphicsRotation)aRotation; + } + +void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TRect& aRect, CWindowGc::TGraphicsRotation aRotation) + { + const RDirectGdiDrawableSource* drawableSource = static_cast(aSource); + iContext->DrawResource(aRect, *drawableSource, (DirectGdi::TGraphicsRotation)aRotation); + iDestRect = aRect; + iRotation = (DirectGdi::TGraphicsRotation)aRotation; + } + +void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TRect& aRectDest, const TRect& aRectSrc, CWindowGc::TGraphicsRotation aRotation) + { + const RDirectGdiDrawableSource* drawableSource = static_cast(aSource); + iContext->DrawResource(aRectDest, *drawableSource, aRectSrc, (DirectGdi::TGraphicsRotation)aRotation); + iDestRect = aRectDest; + iSrcRect = aRectSrc; + iRotation = (DirectGdi::TGraphicsRotation)aRotation; + } + +void CTestWsGraphicsContext::DrawResource(const TAny* aSource, const TRect& aRect, const TDesC8& aParam) + { + const RDirectGdiDrawableSource* drawableSource = static_cast(aSource); + iContext->DrawResource(aRect, *drawableSource, aParam); + iDestRect = aRect; + } + + +void CTestWsGraphicsContext::Clear() + { + iContext->Clear(); + } + +// +// class CTDrawResource +// + +CTDrawResource::CTDrawResource(CTestStep* aStep) + : CTWsGraphicsBase(aStep) + { + } + +CTDrawResource::~CTDrawResource() + { + iWindow.Close(); + delete iRefBitmap; + delete iRotatedRefBitmap; + delete iScaledBitmap; + delete iScaledCroppedBitmap; + delete iCopyBitmap; + delete iBitmapWrongScreenNumber; + + delete iWsGrapicResolver; + delete iGraphicsCon; + + iWsDrawableSource.Close(); + iImage.Close(); + iImageTarget.Close(); + iImageCollection.Close(); + + CDirectGdiDriver* dGdiDriver = CDirectGdiDriver::Static(); + if(dGdiDriver) + { + dGdiDriver->Close(); + } + SgDriver::Close(); + } + +void CTDrawResource::ConstructL() + { + //Constrcut and setup window to be drawn to + iWindow = RWindow(TheClient->iWs); + User::LeaveIfError(iWindow.Construct(*TheClient->iGroup->GroupWin(),ENullWsHandle)); + TSize iWinSize=TSize(TheClient->iScreen->SizeInPixels()); + iWindow.SetExtent(TPoint(0,0),iWinSize); + iWindow.Activate(); + iWindow.BeginRedraw(); + iWindow.EndRedraw(); + + //Creates all reference and copy bitmaps required for all tests + CreateReferenceAndCopyBitmapsL(); + + TInt err = CDirectGdiDriver::Open(); + User::LeaveIfError(err); + err = SgDriver::Open(); + User::LeaveIfError(err); + + //create image target + CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static(); + if(!theDGdiDriver) + { + User::Leave(KErrNotReady); + } + TSgImageInfo info; + info.iUsage = ESgUsageDirectGdiTarget | ESgUsageDirectGdiSource | ESgUsageCompositionSource; + info.iPixelFormat = EUidPixelFormatRGB_565; + info.iSizeInPixels = TSize(200, 200); + info.iShareable = ETrue; + const TInt KImageCount = 1; + err = iImageCollection.Create(info, KImageCount); + User::LeaveIfError(err); + + err = iImageCollection.OpenImage(0, iImage); + User::LeaveIfError(err); + iImageTarget = RDirectGdiImageTarget(*theDGdiDriver); + err = iImageTarget.Create(iImage); + User::LeaveIfError(err); + + // construction of image source + RSgImage sgImage; + CreateSgImageFromBitmapL(sgImage); + CleanupClosePushL(sgImage); + iWsDrawableSource = RWsDrawableSource(TheClient->iWs); + User::LeaveIfError(iWsDrawableSource.Create(sgImage, TheClient->iScreen->GetScreenNumber())); + + //Create dummy MWsGraphicResolver - required RemoteGc testing + iWsGrapicResolver = new (ELeave) CWSGraphicsRes(); + + //Create dummy MWsGraphicsContext - required RemoteGc testing + iGraphicsCon = CTestWsGraphicsContext::NewL(iImageTarget); + + CleanupStack::PopAndDestroy(&sgImage); + } + +void CTDrawResource::RunTestCaseL(TInt aCurTestCase) + { + ((CTDrawResourceStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(aCurTestCase) + { + case 1: + ((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0001")); + INFO_PRINTF1(_L("DrawResourcePos Test")); + TestDrawResourcePos(); + break; + case 2: + ((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0002")); + INFO_PRINTF1(_L("DrawResourceRect Test")); + TestDrawResourceRect(); + break; + case 3: + ((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0003")); + INFO_PRINTF1(_L("DrawResourceScale Test")); + TestDrawResourceScale(); + break; + case 4: + ((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0004")); + INFO_PRINTF1(_L("RWsDrawableSource Reference Counting Test")); + TestRWsDrawableSourceReferenceCountingL(); + break; + case 5: + ((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0005")); + INFO_PRINTF1(_L("RemoteGcDrawResourcePos Test")); + TestRemoteGcDrawResourcePosL(); + break; + case 6: + ((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0006")); + INFO_PRINTF1(_L("RemoteGcDrawResourceRect Test")); + TestRemoteGcDrawResourceRectL(); + break; + case 7: + ((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0007")); + INFO_PRINTF1(_L("RemoteGcDrawResourceScale Test")); + TestRemoteGcDrawResourceScaleL(); + break; + case 8: + ((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-DRAWRESOURCE-0008")); + INFO_PRINTF1(_L("DrawResourceScreens Test")); + TestDrawResourceScreensL(); + break; + case 9: + ((CTDrawResourceStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-TestCopyScreenToBitmapWithDifferentDisplayModes-0001")); + INFO_PRINTF1(_L("CopyScreenToBitmapWithDifferentDisplayModes Test\n")); + TestCopyScreenToBitmapWithDifferentDisplayModesL(); + break; + case 10: + ((CTDrawResourceStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTDrawResourceStep*)iStep)->CloseTMSGraphicsStep(); + INFO_PRINTF1(_L("Test complete\n")); + TestComplete(); + break; + } + ((CTDrawResourceStep*)iStep)->RecordTestResultL(); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-DRAWRESOURCE-0001 +@SYMPREQ PREQ2095 +@SYMTestPriority High +@SYMTestCaseDesc Draw RSgImage using DrawResource(const TPoint&, const RWsDrawableSource&, TGraphicsRotation) +@SYMTestActions Draw to position (0,0) with default rotation (none) + Draw to position (10,10) with 90 degrees rotation +@SYMTestExpectedResults Drawn images should match reference CFbsBitmap +*/ +void CTDrawResource::TestDrawResourcePos() + { + // Draw to TPoint(0,0) with EGraphicsRotationNone + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + MWsDrawResource* dr = static_cast(TheGc->Interface(KMWsDrawResourceInterfaceUid)); + TEST(dr != NULL); + dr->DrawResource(KDestPoint, iWsDrawableSource, CWindowGc::EGraphicsRotationNone); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect); + + //Compare the bitmaps + INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone")); + TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iRefBitmap); + TEST(compRes); + + /*** Draw to position (10,10) with 90 degrees rotation ***/ + TPoint const KDestPoint2(10,10); + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + dr->DrawResource(KDestPoint2, iWsDrawableSource, KTestRotation); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, TRect(KDestPoint2, KSourceSize)); + + //Compare the bitmaps + INFO_PRINTF1(_L("Draw to position (10,10) with 90 degrees rotation")); + compRes = CompareBitmapsByPixel(iCopyBitmap, iRotatedRefBitmap); + TEST(compRes); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-DRAWRESOURCE-0002 +@SYMPREQ PREQ2095 +@SYMTestPriority High +@SYMTestCaseDesc Draw RSgImage using DrawResource(const TRect& , const RWsDrawableSource&, TGraphicsRotation aRotation) +@SYMTestActions Draw to rect pos (10,10), rect size (60,60) with 90 degrees rotation +@SYMTestExpectedResults Drawn images should match the reference CFbsBitmap +*/ +void CTDrawResource::TestDrawResourceRect() + { + //Use DrawResource + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + MWsDrawResource* dr = static_cast(TheGc->Interface(KMWsDrawResourceInterfaceUid)); + TEST(dr != NULL); + dr->DrawResource(KDestRect, iWsDrawableSource, KTestRotation); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect); + + //Compare the bitmaps + INFO_PRINTF1(_L("Draw to rect pos (10,10), rect size (60,60) with 90 degrees rotation")); + TInt compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledBitmap); + TEST(compRes); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-DRAWRESOURCE-0003 +@SYMPREQ PREQ2095 +@SYMTestPriority High +@SYMTestCaseDesc Draw RSgImage using DrawResource(const TRect& , const RWsDrawableSource&, const TRect&, TGraphicsRotation aRotation) +@SYMTestActions Draw the part of the source image (rect Pos (0,0), rect size(50,50)) + to rect pos(10,10), rect size(60,60) and and 90 degrees rotation +@SYMTestExpectedResults Drawn images should match the reference CFbsBitmap +*/ +void CTDrawResource::TestDrawResourceScale() + { + //Use DrawResource + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + MWsDrawResource* dr = static_cast(TheGc->Interface(KMWsDrawResourceInterfaceUid)); + TEST(dr != NULL); + dr->DrawResource(KDestRect, iWsDrawableSource, KSourceRect, KTestRotation); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect); + + //Compare the bitmaps + INFO_PRINTF1(_L("Draw the part of the source image to rect pos(10,10), rect size(60,60) and and 90 degrees rotation")); + TInt compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledCroppedBitmap); + TEST(compRes); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-DRAWRESOURCE-0004 +@SYMPREQ PREQ2095 +@SYMTestPriority High +@SYMTestCaseDesc Draw RSgImage using DrawResource(const TPoint&, const RWsDrawableSource&, TGraphicsRotation) after closing the image source +@SYMTestActions Draw to position (0,0) with default rotation (none) after closing the image source +@SYMTestExpectedResults Drawn image should match reference CFbsBitmap +*/ +void CTDrawResource::TestRWsDrawableSourceReferenceCountingL() + { + // construction of image source + RSgImage sgImage; + CreateSgImageFromBitmapL(sgImage); + CleanupClosePushL(sgImage); + RWsDrawableSource drawableSource(TheClient->iWs); + CleanupClosePushL(drawableSource); + User::LeaveIfError(drawableSource.Create(sgImage, TheClient->iScreen->GetScreenNumber())); + + //Draw using DrawResource + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + MWsDrawResource* dr = static_cast(TheGc->Interface(KMWsDrawResourceInterfaceUid)); + TEST(dr != NULL); + dr->DrawResource(KDestPoint, drawableSource, CWindowGc::EGraphicsRotationNone); + TheGc->Deactivate(); + iWindow.EndRedraw(); + + //Close the image source but this should not stop the source from being drawn + drawableSource.Close(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect); + + //Compare the bitmaps + INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone")); + TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iRefBitmap); + TEST(compRes); + + CleanupStack::PopAndDestroy(2, &sgImage); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-DRAWRESOURCE-0005 +@SYMPREQ PREQ2095 +@SYMTestPriority High +@SYMTestCaseDesc Draw RSgImage using RemotGc->DrawResource(const TPoint&, const RWsDrawableSource&, TGraphicsRotation) +@SYMTestActions Record the draw resource commands using CRemoteGc and play the recorded commands on a window using + Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) and then play the recorded commands using . + Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&). +@SYMTestExpectedResults Drawn images should match reference CFbsBitmap and also values received by MWsGraphicsContext should + match what was originally sent to DrawResource. +*/ +void CTDrawResource::TestRemoteGcDrawResourcePosL() + { + const TRect KRemotGcSourceRect(0, 0, iWindow.Size().iWidth, iWindow.Size().iHeight); + const TRegionFix<1> KClippingRegion(KRemotGcSourceRect); + CWindowGc::TGraphicsRotation testRotation= CWindowGc::EGraphicsRotationNone; + + //Create remote gc - required RemoteGc testing + CRemoteGc* remoteGc = CRemoteGc::NewL(TheClient->iScreen); + CleanupStack::PushL(remoteGc); + + //Record draw messages + remoteGc->ResetCommandBuffer(); + remoteGc->BeginDraw(KRemotGcSourceRect); + MWsDrawResource* dr = static_cast(remoteGc->Interface(KMWsDrawResourceInterfaceUid)); + TEST(dr != NULL); + dr->DrawResource(KDestPoint, iWsDrawableSource, CWindowGc::EGraphicsRotationNone); + remoteGc->EndDraw(); + + RWsGraphicMsgBuf msgBuf; + CleanupClosePushL(msgBuf); + //Externalize the captured commands from remote gc in to a buffer + remoteGc->ExternalizeL(msgBuf, ETrue); + //Create command buffer - required RemoteGc testing + CCommandBuffer* cmdBuffer = CCommandBuffer::NewL(); + CleanupStack::PushL(cmdBuffer); + //Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer + cmdBuffer->InternalizeL(msgBuf.Pckg()); + + // Play stored commands using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) + remoteGc->ResetCommandBuffer(); + iWindow.Invalidate(); + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + cmdBuffer->Play(KPlayOffset, &KClippingRegion, KRemotGcSourceRect, TheClient->iWs, *TheGc); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect); + + //Compare the bitmaps + INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&)")); + TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iRefBitmap); + TEST(compRes); + + // Play stored commands using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&) + remoteGc->ResetCommandBuffer(); + iWindow.Invalidate(); + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + cmdBuffer->Play(KPlayOffset,&KClippingRegion,KRemotGcSourceRect,*iWsGrapicResolver,*iGraphicsCon); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + + //Compare the values received by CTestWsGraphicsContext and the values sent to it + INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&)")); + TBool valuesSame = EFalse; + CFbsBitmap* bmp; + BitmapLC(bmp); + compRes = CompareBitmapsByPixel(bmp, iRefBitmap); + CleanupStack::PopAndDestroy(bmp); + + if((iGraphicsCon->iPos == KDestPoint) && (compRes) + && (reinterpret_cast(iGraphicsCon->iRotation)==reinterpret_cast(testRotation))) + valuesSame = ETrue; + TEST(valuesSame); + CleanupStack::PopAndDestroy(3, remoteGc); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-DRAWRESOURCE-0006 +@SYMPREQ PREQ2095 +@SYMTestPriority High +@SYMTestCaseDesc Draw RSgImage using RemotGc->DrawResource(const TRect&, const RWsDrawableSource&, TGraphicsRotation) +@SYMTestActions Record the draw resource commands using CRemoteGc and play the recorded commands on a window using + Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) and then play the recorded commands using . + Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&). +@SYMTestExpectedResults Drawn images should match reference CFbsBitmap and also values received by MWsGraphicsContext should + match what was originally sent to DrawResource. +*/ +void CTDrawResource::TestRemoteGcDrawResourceRectL() + { + const TRect KRemotGcSourceRect(0, 0, iWindow.Size().iWidth, iWindow.Size().iHeight); + const TRegionFix<1> KClippingRegion(KRemotGcSourceRect); + + //Create remote gc - required RemoteGc testing + CRemoteGc* remoteGc = CRemoteGc::NewL(TheClient->iScreen); + CleanupStack::PushL(remoteGc); + + //Record draw messages + remoteGc->BeginDraw(KRemotGcSourceRect); + MWsDrawResource* dr = static_cast(remoteGc->Interface(KMWsDrawResourceInterfaceUid)); + TEST(dr != NULL); + dr->DrawResource(KDestRect, iWsDrawableSource, KTestRotation); + remoteGc->EndDraw(); + + RWsGraphicMsgBuf msgBuf; + CleanupClosePushL(msgBuf); + //Externalize the captured commands from remote gc in to a buffer + remoteGc->ExternalizeL(msgBuf, ETrue); + + //Create command buffer - required RemoteGc testing + CCommandBuffer* cmdBuffer = CCommandBuffer::NewL(); + CleanupStack::PushL(cmdBuffer); + //Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer + cmdBuffer->InternalizeL(msgBuf.Pckg()); + + // Play stored commands using Play(const TRect&, const TRect&, RWsSession&, CWindowGc&) + iWindow.Invalidate(); + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + cmdBuffer->Play(KPlayOffset, &KClippingRegion, KRemotGcSourceRect, TheClient->iWs, *TheGc); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect); + + //Compare the bitmaps + INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&)")); + TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledBitmap); + TEST(compRes); + + // Play stored commands using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&) + iWindow.Invalidate(); + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + iGraphicsCon->Clear(); + cmdBuffer->Play(KPlayOffset,&KClippingRegion,KRemotGcSourceRect,*iWsGrapicResolver,*iGraphicsCon); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Compare the values received by CTestWsGraphicsContext and the values sent to it + INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&)")); + TBool valuesSame = EFalse; + + CFbsBitmap* bmp; + BitmapLC(bmp); + compRes = CompareBitmapsByPixel(bmp, iScaledBitmap); + CleanupStack::PopAndDestroy(bmp); + + if((iGraphicsCon->iDestRect == KDestRect) && (compRes) + && (reinterpret_cast(iGraphicsCon->iRotation)==reinterpret_cast(KTestRotation))) + valuesSame = ETrue; + TEST(valuesSame); + CleanupStack::PopAndDestroy(3, remoteGc); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-DRAWRESOURCE-0007 +@SYMPREQ PREQ2095 +@SYMTestPriority High +@SYMTestCaseDesc Draw RSgImage using RemotGc->DrawResource(const TRect&, const RWsDrawableSource&, const TRect&, TGraphicsRotation) +@SYMTestActions Record the draw resource commands using CRemoteGc and play the recorded commands on a window using + Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&) and then play the recorded commands using . + Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&). +@SYMTestExpectedResults Drawn images should match reference CFbsBitmap and also values received by MWsGraphicsContext should + match what was originally sent to DrawResource. +*/ +void CTDrawResource::TestRemoteGcDrawResourceScaleL() + { + const TRect KRemotGcSourceRect(0, 0, iWindow.Size().iWidth, iWindow.Size().iHeight); + const TRegionFix<1> KClippingRegion(KRemotGcSourceRect); + + //Create remote gc - required RemoteGc testing + CRemoteGc* remoteGc = CRemoteGc::NewL(TheClient->iScreen); + CleanupStack::PushL(remoteGc); + + //Record draw messages + remoteGc->BeginDraw(KRemotGcSourceRect); + MWsDrawResource* dr = static_cast(remoteGc->Interface(KMWsDrawResourceInterfaceUid)); + TEST(dr != NULL); + dr->DrawResource(KDestRect, iWsDrawableSource, KSourceRect, KTestRotation); + remoteGc->EndDraw(); + + RWsGraphicMsgBuf msgBuf; + CleanupClosePushL(msgBuf); + //Externalize the captured commands from remote gc in to a buffer + remoteGc->ExternalizeL(msgBuf, ETrue); + + //Create command buffer - required RemoteGc testing + CCommandBuffer* cmdBuffer = CCommandBuffer::NewL(); + CleanupStack::PushL(cmdBuffer); + //Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer + cmdBuffer->InternalizeL(msgBuf.Pckg()); + + // Play the stored commands using Play(const TRect&, const TRect&, RWsSession&, CWindowGc&) + remoteGc->ResetCommandBuffer(); + iWindow.Invalidate(); + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + cmdBuffer->Play(KPlayOffset, &KClippingRegion, KRemotGcSourceRect, TheClient->iWs, *TheGc); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect); + + //Compare the bitmaps + INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, RWsSession&, CWindowGc&)")); + TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iScaledCroppedBitmap); + TEST(compRes); + + // Play the stored commands using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&) + iWindow.Invalidate(); + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + iGraphicsCon->Clear(); + cmdBuffer->Play(KPlayOffset,&KClippingRegion,KRemotGcSourceRect,*iWsGrapicResolver,*iGraphicsCon); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Compare the values received by CTestWsGraphicsContext and the values sent to it + INFO_PRINTF1(_L("Using Play(const TPoint&, const TRect&, const MWsGraphicResolver&, MWsGraphicsContext&)")); + TBool valuesSame = EFalse; + + CFbsBitmap* bmp; + BitmapLC(bmp); + compRes = CompareBitmapsByPixel(bmp, iScaledCroppedBitmap); + CleanupStack::PopAndDestroy(bmp); + + if((iGraphicsCon->iDestRect == KDestRect) && (compRes) && (iGraphicsCon->iSrcRect == KSourceRect) + && (reinterpret_cast(iGraphicsCon->iRotation)==reinterpret_cast(KTestRotation))) + valuesSame = ETrue; + TEST(valuesSame); + CleanupStack::PopAndDestroy(3, remoteGc); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-DRAWRESOURCE-0008 +@SYMPREQ PREQ2095 +@SYMTestPriority High +@SYMTestCaseDesc Negative testing. Draw graphics recourses which associated with different screens. +@SYMTestActions Open RWsDrawableSource associated with the screen which doesn’ exist. + Open RWsDrawableSource associated with the screen which exists but differes from drawing target. + Draw Rectangle and Resource to the screen via CWindowGc + Draw Rectangle and Resource to the screen via CRemoteGc +@SYMTestExpectedResults Opening drawable resource on the screen which doesn’t exist must fail with error code KErrArgument + Drawing primitives will result only rectangles be drawn as drawable recourses get associated with different screen +*/ +void CTDrawResource::TestDrawResourceScreensL() + { + TInt numOfScreens = TheClient->iWs.NumberOfScreens(); + if(numOfScreens < 2) + { + INFO_PRINTF2(_L("This test case will be running if the number of available screens more than 1, current number is %d"), numOfScreens); + return; + } + TInt screenNumber = TheClient->iScreen->GetScreenNumber(); + TInt differentScreen = (screenNumber == 0) ? 1 : 0; + + RSgImage sgImage; + CreateSgImageFromBitmapL(sgImage); + CleanupClosePushL(sgImage); + + RWsDrawableSource drawableSource(TheClient->iWs); + TInt res = drawableSource.Create(sgImage, differentScreen + 200); //wrong screen number + TEST(res == KErrArgument); + + res = drawableSource.Create(iImage, differentScreen); + TEST(res == KErrNotSupported); //in order to succeed the image must be created with flag usage ESgUsageWindowGcSource + + TSgImageInfo info; + User::LeaveIfError(sgImage.GetInfo(info)); + + res = drawableSource.Create(sgImage, differentScreen); + if(res == KErrNotSupported) + { + INFO_PRINTF1(_L("The second screen is not supports drawable source. This test case terminates now.")); + CleanupStack::PopAndDestroy(&sgImage); + return; + } + TEST(res == KErrNone); + User::LeaveIfError(res); + CleanupClosePushL(drawableSource); + + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + TheGc->SetBrushStyle(CFbsBitGc::ESolidBrush); + TheGc->SetPenStyle(CFbsBitGc::ENullPen); + TheGc->SetBrushColor(KRgbGreen); + TheGc->DrawRect(TRect(KDestPoint, info.iSizeInPixels)); + // Draw to TPoint(0,0) with EGraphicsRotationNone but to the different screen + MWsDrawResource* winDr = static_cast(TheGc->Interface(KMWsDrawResourceInterfaceUid)); + TEST(winDr != NULL); + winDr->DrawResource(KDestPoint, drawableSource, CWindowGc::EGraphicsRotationNone); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect); + + //Compare the bitmaps + INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone but to different screen")); + TBool compRes = CompareBitmapsByPixel(iCopyBitmap, iBitmapWrongScreenNumber); + TEST(compRes); + + //--------------------------- remoteGc + const TRect KRemotGcSourceRect(0, 0, iWindow.Size().iWidth, iWindow.Size().iHeight); + const TRegionFix<1> KClippingRegion(KRemotGcSourceRect); + + //Create remote gc - required RemoteGc testing + CRemoteGc* remoteGc = CRemoteGc::NewL(TheClient->iScreen); + CleanupStack::PushL(remoteGc); + + //Record draw messages + remoteGc->BeginDraw(KRemotGcSourceRect); + remoteGc->SetBrushStyle(CFbsBitGc::ESolidBrush); + remoteGc->SetPenStyle(CFbsBitGc::ENullPen); + remoteGc->SetBrushColor(KRgbGreen); + remoteGc->DrawRect(TRect(KDestPoint, info.iSizeInPixels)); + MWsDrawResource* remDr = static_cast(remoteGc->Interface(KMWsDrawResourceInterfaceUid)); + TEST(remDr != NULL); + remDr->DrawResource(KDestRect, drawableSource, CWindowGc::EGraphicsRotationNone); + remoteGc->EndDraw(); + + RWsGraphicMsgBuf msgBuf; + CleanupClosePushL(msgBuf); + //Externalize the captured commands from remote gc in to a buffer + remoteGc->ExternalizeL(msgBuf, ETrue); + + //Create command buffer - required RemoteGc testing + CCommandBuffer* cmdBuffer = CCommandBuffer::NewL(); + CleanupStack::PushL(cmdBuffer); + //Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer + cmdBuffer->InternalizeL(msgBuf.Pckg()); + + // Play stored commands using Play(const TRect&, const TRect&, RWsSession&, CWindowGc&) + iWindow.Invalidate(); + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->Clear(); + cmdBuffer->Play(KPlayOffset, &KClippingRegion, KRemotGcSourceRect, TheClient->iWs, *TheGc); + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Copy the screen to the copy bitmap + TheClient->iScreen->CopyScreenToBitmap(iCopyBitmap, KCopyTestRect); + + INFO_PRINTF1(_L("Draw to TPoint(0,0) with EGraphicsRotationNone but to different screen")); + TBool compRes1 = CompareBitmapsByPixel(iCopyBitmap, iBitmapWrongScreenNumber); + TEST(compRes1); + + CleanupStack::PopAndDestroy(5, &sgImage); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-TestCopyScreenToBitmapWithDifferentDisplayModes-0001 +@SYMPREQ PREQ2095 +@SYMTestPriority High +@SYMTestCaseDesc Get bitmap and scanline from the screen. +@SYMTestActions Draw bitmap in various display modes to the screen. + Retrieve scan line and bitmap from the screen using standard WSERV API. + +@SYMTestExpectedResults Checks that obtained bitmap matches with the reference bitmap. +*/ +void CTDrawResource::TestCopyScreenToBitmapWithDifferentDisplayModesL() + { + TDisplayMode mode = TheClient->iScreen->DisplayMode(); + INFO_PRINTF2(_L("Screen display mode %d"), mode); + CFbsBitmap* bitmap = NULL; + + TSize bitmapSize(163, 120); + CreateBitmapLC(bitmap, bitmapSize, mode); + + iWindow.BeginRedraw(); + TheGc->Activate(iWindow); + TheGc->SetBrushStyle(CWindowGc::ESolidBrush); + TheGc->SetBrushColor(KRgbYellow); + TheGc->Clear(); + const TPoint ptOffset(10, 15); + TheGc->BitBlt(KDestPoint + ptOffset, bitmap); + + TheGc->Deactivate(); + iWindow.EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + const TInt length = bitmapSize.iWidth; + const TInt height = bitmapSize.iHeight; + const TInt buffersSize = length * 4; + TUint8 *screenData = (TUint8*) User::AllocL(buffersSize); + CleanupStack::PushL(screenData); + TUint8 *bitmapData = (TUint8*) User::AllocL(buffersSize); + CleanupStack::PushL(bitmapData); + TPtr8 ptrScreen (screenData, buffersSize, buffersSize); + TPtr8 ptrBitmap (bitmapData, buffersSize, buffersSize); + + //EGray mode uses dithering in BitGdi, wserv doesnt support this, thus skipping the first mode + for(TInt ii =2; ; ii++) + { + TDisplayMode dispMode = (TDisplayMode)ii; + if(dispMode >= EColorLast) + break; + if(dispMode == ERgb) + continue; + + INFO_PRINTF2(_L("Copy Screen to bitmap, destination mode %d"), dispMode); + + CFbsBitmap *bmp = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmp); + User::LeaveIfError(bmp->Create(bitmapSize, dispMode)); + TUidPixelFormat pixelFormat = SgUtils::DisplayModeToPixelFormat(dispMode); + const TInt minStride = SgUtils::MinDataStride(length, pixelFormat); + const TInt bitmapStride = bmp->DataStride(); + TEST(minStride <= bitmapStride); + + //Copy the screen to the copy bitmap + TRect rc = bitmapSize; + rc.Move(ptOffset); + TheClient->iScreen->CopyScreenToBitmap(bmp, rc); + CFbsBitmap *bmpRef = NULL; + CreateReferenceBitmapLC(bmpRef, bitmap, dispMode); + TEST(bmpRef->DisplayMode() == dispMode); + + //Compare the bitmaps + TBool compRes = CompareBitmapsByPixel(bmp, bmpRef); + TEST(compRes); + + for(TInt jj = 0; jj < height; jj++) + { + TPoint pt(0, jj); + TPoint ptScreen = pt + ptOffset; + + Mem::Fill(screenData, bitmapStride, 0xff); + Mem::Fill(bitmapData, bitmapStride, 0xff); + + TheClient->iScreen->GetScanLine(ptrScreen, ptScreen, length, dispMode); + bitmap->GetScanLine(ptrBitmap, pt, length, dispMode); + TInt length1 = ptrScreen.Length(); + + TInt res = Mem::Compare(screenData, length1, bitmapData, length1); + TEST(res == 0); + } + CleanupStack::PopAndDestroy(2, bmp); + }//screen modes; + + CleanupStack::PopAndDestroy(3, bitmap); + } + +//Helper function: Creates reference bitmap with specified display mode +void CTDrawResource::CreateReferenceBitmapLC(CFbsBitmap*& aBmpTarget, CFbsBitmap* aBmpSrc, TDisplayMode aDestMode) + { + TSize size = aBmpSrc->SizeInPixels(); + aBmpTarget = new (ELeave) CFbsBitmap; + CleanupStack::PushL(aBmpTarget); + User::LeaveIfError(aBmpTarget->Create(size, aDestMode)); + CFbsBitmapDevice *refBitmapDev = CFbsBitmapDevice::NewL(aBmpTarget); + CleanupStack::PushL(refBitmapDev); + CFbsBitGc *originalBitGc; + User::LeaveIfError(refBitmapDev->CreateContext(originalBitGc)); + CleanupStack::PushL(originalBitGc); + originalBitGc->BitBlt(TPoint(0,0), aBmpSrc); + CleanupStack::PopAndDestroy(2, refBitmapDev); + } + +//Helper function: Creates reference bitmap with specified display mode +void CTDrawResource::CreateBitmapLC(CFbsBitmap*& aBmpTarget, const TSize& aSize, TDisplayMode aDispMode) const + { + aBmpTarget = new (ELeave) CFbsBitmap; + CleanupStack::PushL(aBmpTarget); + User::LeaveIfError(aBmpTarget->Create(aSize, aDispMode)); + CFbsBitmapDevice *refBitmapDev = CFbsBitmapDevice::NewL(aBmpTarget); + CleanupStack::PushL(refBitmapDev); + CFbsBitGc *originalBitGc; + User::LeaveIfError(refBitmapDev->CreateContext(originalBitGc)); + CleanupStack::PushL(originalBitGc); + + TRect rect = TRect(aSize); + rect.Shrink(21, 15); + + originalBitGc->SetBrushStyle(CFbsBitGc::ESolidBrush); + originalBitGc->SetBrushColor(TRgb(0,150,150)); + originalBitGc->DrawRect(TRect(TPoint(0,0), TSize(aSize.iWidth, aSize.iHeight / 2))); + originalBitGc->SetBrushColor(TRgb(150,100,150)); + originalBitGc->DrawRect(TRect(TPoint(0,aSize.iHeight / 2), TSize(aSize.iWidth, aSize.iHeight))); + + originalBitGc->SetBrushColor(TRgb(0,0,128)); + originalBitGc->DrawRect(rect); + + + CleanupStack::PopAndDestroy(2, refBitmapDev); + } + +//Helper function: Creates a RSgImage from a bitmap +void CTDrawResource::CreateSgImageFromBitmapL(RSgImage& aSgImage) + { + TUint32* data = iRefBitmap->DataAddress(); + TInt stride = iRefBitmap->DataStride(); + TSize size = iRefBitmap->SizeInPixels(); + + TSgImageInfo info; + info.iSizeInPixels = size; + info.iScreenId = TheClient->iScreen->CurrentScreenMode(); + info.iShareable = ETrue; //must be shareable since wserv is in other process + info.iUsage = ESgUsageWindowGcSource; + info.iPixelFormat = SgUtils::DisplayModeToPixelFormat(iRefBitmap->DisplayMode()); + + User::LeaveIfError(aSgImage.Create(info, data, stride)); + } + +//Helper function: Creates all reference bitmaps required for all tests +void CTDrawResource::CreateReferenceAndCopyBitmapsL() + { + //Create reference bitmap + iRefBitmap = new (ELeave) CFbsBitmap(); + User::LeaveIfError(iRefBitmap->Create(TSize(160,120),EColor64K)); + + //Setup to draw to original reference bitmap + CFbsBitmapDevice *refBitmapDev = CFbsBitmapDevice::NewL(iRefBitmap); + CleanupStack::PushL(refBitmapDev); + CFbsBitGc *originalBitGc; + User::LeaveIfError(refBitmapDev->CreateContext(originalBitGc)); + CleanupStack::PushL(originalBitGc); + + //Draw to reference bitmap + originalBitGc->SetBrushStyle(CFbsBitGc::ESolidBrush); + originalBitGc->SetBrushColor(TRgb(0,150,150)); + originalBitGc->DrawRect(TRect(TPoint(0,0), TSize(160,60))); + originalBitGc->SetBrushColor(TRgb(150,100,150)); + originalBitGc->DrawRect(TRect(TPoint(0,60), TSize(160,60))); + + //create a rotated version of the reference bitmap + iRotatedRefBitmap = new (ELeave) CFbsBitmap(); + User::LeaveIfError(iRotatedRefBitmap->Create(TSize(120,160),EColor64K)); + + //Setup to draw to rotated reference bitmap + CFbsBitmapDevice *rotRefBitmapDev = CFbsBitmapDevice::NewL(iRotatedRefBitmap); + CleanupStack::PushL(rotRefBitmapDev); + CFbsBitGc *rotatedBitGc; + User::LeaveIfError(rotRefBitmapDev->CreateContext(rotatedBitGc)); + CleanupStack::PushL(rotatedBitGc); + + //Draw to rotated reference bitmap + rotatedBitGc->SetBrushStyle(CFbsBitGc::ESolidBrush); + rotatedBitGc->SetBrushColor(TRgb(0,150,150)); + rotatedBitGc->DrawRect(TRect(TPoint(60,0), TSize(60,160))); + rotatedBitGc->SetBrushColor(TRgb(150,100,150)); + rotatedBitGc->DrawRect(TRect(TPoint(0,0), TSize(60,160))); + + //Prepare a scaled version of the rotated reference bitmap to later compare against + iScaledBitmap = new (ELeave) CFbsBitmap(); + User::LeaveIfError(iScaledBitmap->Create(TSize(160,120),EColor64K)); + //Setup to draw to bitmap + CFbsBitmapDevice *scaledBitDev = CFbsBitmapDevice::NewL(iScaledBitmap); + CleanupStack::PushL(scaledBitDev); + CFbsBitGc *scaledBitGc; + User::LeaveIfError(scaledBitDev->CreateContext(scaledBitGc)); + CleanupStack::PushL(scaledBitGc); + //Draw the rotated reference bitmap scaled + scaledBitGc->DrawBitmap(KDestRect, iRotatedRefBitmap); + + //Prepare a scaled version of the rotated reference bitmap to later compare against + iScaledCroppedBitmap = new (ELeave) CFbsBitmap(); + User::LeaveIfError(iScaledCroppedBitmap->Create(TSize(160,120),EColor64K)); + + //Setup to draw to bitmap + CFbsBitmapDevice *scaledCroppedBitDev = CFbsBitmapDevice::NewL(iScaledCroppedBitmap); + CleanupStack::PushL(scaledCroppedBitDev); + CFbsBitGc *scaledCroppedBitGc; + User::LeaveIfError(scaledCroppedBitDev->CreateContext(scaledCroppedBitGc)); + CleanupStack::PushL(scaledCroppedBitGc); + + //Draw the rotated reference bitmap scaled + TInt width = iRotatedRefBitmap->SizeInPixels().iWidth; + TInt height = iRotatedRefBitmap->SizeInPixels().iHeight; + + TRect rectSrc; + rectSrc.iTl.iX= width - KSourceRect.Height(); + rectSrc.iTl.iY= 0; + rectSrc.iBr.iX= width; + rectSrc.iBr.iY= KSourceRect.Width(); + + scaledCroppedBitGc->DrawBitmap(KDestRect, iRotatedRefBitmap, rectSrc); + + //Prepare bitmap for testing drawable which opened with different screen number + iBitmapWrongScreenNumber = new (ELeave) CFbsBitmap(); + User::LeaveIfError(iBitmapWrongScreenNumber->Create(TSize(160,120),EColor64K)); + //Setup to draw to bitmap + CFbsBitmapDevice *wrongScreenNumberBitDev = CFbsBitmapDevice::NewL(iBitmapWrongScreenNumber); + CleanupStack::PushL(wrongScreenNumberBitDev); + CFbsBitGc *wrongScreenNumberBitGc; + User::LeaveIfError(wrongScreenNumberBitDev->CreateContext(wrongScreenNumberBitGc)); + CleanupStack::PushL(wrongScreenNumberBitGc); + //Draw the rotated reference bitmap scaled + wrongScreenNumberBitGc->SetBrushColor(KRgbGreen); + wrongScreenNumberBitGc->SetBrushStyle(CFbsBitGc::ESolidBrush); + wrongScreenNumberBitGc->SetPenStyle(CFbsBitGc::ENullPen); + wrongScreenNumberBitGc->DrawRect(TRect(0, 0, 160, 120)); // + + //Create a bitmap to copy to with the same display mode as the reference bitmap + iCopyBitmap = new (ELeave) CFbsBitmap(); + User::LeaveIfError(iCopyBitmap->Create(TSize(640,240),EColor64K)); + + CleanupStack::PopAndDestroy(10, refBitmapDev); + } + +//Helper function: This function compares two bitmaps on a pixel by pixel basis */ +TBool CTDrawResource::CompareBitmapsByPixel(CFbsBitmap* aCandidateBitmap, CFbsBitmap* aReferenceBitmap) + { + TBool result = ETrue; + + TSize candidateSize = aCandidateBitmap->SizeInPixels(); + TSize referenceSize = aReferenceBitmap->SizeInPixels(); + + TInt mismatchedPixels = 0; + + TRgb nativePixel; + TRgb referencePixel; + for (TInt x = 0; x < referenceSize.iWidth; x++) + { + for (TInt y = 0; y < referenceSize.iHeight; y++) + { + TPoint point(x,y); + nativePixel = TRgb(0,0,0,0); + referencePixel = TRgb(0,0,0,0); + aCandidateBitmap->GetPixel(nativePixel, point); + aReferenceBitmap->GetPixel(referencePixel, point); + + if (nativePixel != referencePixel) + { + mismatchedPixels++; + result = EFalse; + } + } + } + + INFO_PRINTF2(_L("Number of different pixels: %i"), mismatchedPixels); + return result; + } +//Helper function: This function extracts content of the image associated with the image target and copies it into bitmap +void CTDrawResource::BitmapLC(CFbsBitmap*& aBmp) + { + aBmp = new(ELeave) CFbsBitmap; + CleanupStack::PushL(aBmp); + + TSgImageInfo info; + TInt res = iImage.GetInfo(info); + User::LeaveIfError(res); + + res = aBmp ->Create(info.iSizeInPixels, SgUtils::PixelFormatToDisplayMode(info.iPixelFormat)); + User::LeaveIfError(res); + TUint32* dataAddressDest = aBmp->DataAddress(); + + RSgImage image; + info.iUsage = ESgUsageNone; + info.iCpuAccess = ESgCpuAccessReadOnly; + res = image.Create(info, iImage); + User::LeaveIfError(res); + CleanupClosePushL(image); + const TAny* dataAddress = NULL; + TInt dataStride; + res = image.MapReadOnly(dataAddress, dataStride); + User::LeaveIfError(res); + Mem::Copy(dataAddressDest, dataAddress, dataStride * info.iSizeInPixels.iHeight); + image.Unmap(); + CleanupStack::PopAndDestroy(&image); + }