diff -r bbf46f59e123 -r 25ffed67c7ef windowing/windowserver/tauto/tgc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/tauto/tgc.cpp Wed Sep 01 12:39:21 2010 +0100 @@ -0,0 +1,1869 @@ +// Copyright (c) 2007-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 "tgc.h" +#include "RemoteGc.h" +#include "CommandBuffer.h" +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA +#include "directgdigcwrapper.h" +#include +#include +#include +#endif + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA +GLDEF_C void CopyImageToBitmapL(CFbsBitmap* aBitmap, const RSgImage& aImage, const TRect& aRect); +GLDEF_C void CopyImageToDestination(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, + TAny* aDataAddressSrc, TInt aDataStrideSrc, TDisplayMode aDisplayModeSrc, const TRect& aRect); +GLDEF_C void CopyImageToDestination64K(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, + TUint16* aDataAddressSrc, TInt aDataStrideSrc, const TRect& aRect); + +GLDEF_C void CopyImageToBitmapL(CFbsBitmap* aBitmap, const RSgImage& aImage, const TRect& aRect) + { + TSgImageInfo info; + TInt res = aImage.GetInfo(info); + if(res == KErrNone) + { + info.iUsage = ESgUsageNone; + info.iCpuAccess = ESgCpuAccessReadOnly; + RSgImage image; + res = image.Create(info, aImage); + if(res == KErrNone) + { + const TAny* dataAddressSrc = NULL; + TInt dataStrideSrc = 0; + res = image.MapReadOnly(dataAddressSrc, dataStrideSrc); + if(res == KErrNone) + { + const TDisplayMode displayModeDest = aBitmap->DisplayMode(); + const TDisplayMode displayModeSrc = SgUtils::PixelFormatToDisplayMode(info.iPixelFormat); + TUint32* dataAddressDest = aBitmap->DataAddress(); + const TInt dataStrideDest = aBitmap -> DataStride(); + TSize bitmapSize = aBitmap->SizeInPixels(); + TRect rect = aRect; + TRect rectDest = info.iSizeInPixels; + rect.Intersection(rectDest); + if(rect.Height() > bitmapSize.iHeight) + { + rect.SetHeight(bitmapSize.iHeight); + } + if(rect.Width() > bitmapSize.iWidth) + { + rect.SetWidth(bitmapSize.iWidth); + } + CopyImageToDestination((TAny*)dataAddressDest, dataStrideDest, displayModeDest, (TAny*)dataAddressSrc, + dataStrideSrc, displayModeSrc, rect); + + image.Unmap(); + } + image.Close(); + } + } + } + +GLDEF_C void CopyImageToDestination(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, + TAny* aDataAddressSrc, TInt aDataStrideSrc, TDisplayMode aDisplayModeSrc, const TRect& aRect) + { + if(aRect.IsEmpty()) + return; + + if((aDisplayModeDest == aDisplayModeSrc) && (aDataStrideSrc == aDataStrideDest)) + { + Mem::Copy(aDataAddressDest, aDataAddressSrc, aDataStrideDest * aRect.Height()); + return; + } + + switch(aDisplayModeSrc) + { + case EColor64K: + { + CopyImageToDestination64K(aDataAddressDest, aDataStrideDest, aDisplayModeDest, + (TUint16*)aDataAddressSrc, aDataStrideSrc, aRect); + break; + } + default: + break; + } + } + +GLDEF_C void CopyImageToDestination64K(TAny* aDataAddressDest, TInt aDataStrideDest, TDisplayMode aDisplayModeDest, + TUint16* aDataAddressSrc, TInt aDataStrideSrc, const TRect& aRect) + { + const TInt bppSrc = 2; + const TInt width = aRect.Width(); + const TInt height = aRect.Height(); + const TInt dataStrideLengthSrc = aDataStrideSrc / bppSrc; + TUint16* dataAddressSrc = aDataAddressSrc + aRect.iTl.iY * dataStrideLengthSrc + aRect.iTl.iX; + const TUint16* dataAddressSrcEnd = dataAddressSrc + dataStrideLengthSrc * height; + + switch(aDisplayModeDest) + { + case EColor64K: + { + TUint16* dataAddressDest = static_cast (aDataAddressDest); + const TInt dataStrideLengthDest = aDataStrideDest / bppSrc; + while(dataAddressSrcEnd > dataAddressSrc) + { + Mem::Copy(dataAddressDest, dataAddressSrc, width * bppSrc); + dataAddressSrc += dataStrideLengthSrc; + dataAddressDest += dataStrideLengthDest; + } + break; + } + case EColor16MU: + { + const TInt bppDest = 4; + TUint32* dataAddressDest = static_cast (aDataAddressDest); + const TInt dataStrideLengthDest = aDataStrideDest / bppDest; + + while(dataAddressSrcEnd > dataAddressSrc) + { + const TUint16* dataAddressSrcLineEnd = dataAddressSrc + width; + TUint32* dataAddressDestCur = dataAddressDest; + TUint16* dataAddressSrcCur = dataAddressSrc; + + while(dataAddressSrcLineEnd > dataAddressSrcCur) + { + *dataAddressDestCur = TRgb::Color64K(*dataAddressSrcCur).Color16MU(); + dataAddressDestCur++; + dataAddressSrcCur++; + } + dataAddressSrc += dataStrideLengthSrc; + dataAddressDest += dataStrideLengthDest; + } + break; + } + case EGray4: + { + TUint8* dataAddressDest = static_cast (aDataAddressDest); + const TInt dataStrideLengthDest = aDataStrideDest; + + while(dataAddressSrcEnd > dataAddressSrc) + { + const TUint8* dataAddressDstLineEnd = dataAddressDest + aDataStrideDest; + TUint8* dataAddressDestCur = dataAddressDest; + TUint16* dataAddressSrcCur = dataAddressSrc; + + while(dataAddressDstLineEnd > dataAddressDestCur) + { + *dataAddressDestCur = 0; + for(TInt index = 0; index < 8; index +=2) + { + TInt col = TRgb::Color64K(*dataAddressSrcCur).Gray4(); + col <<= index; + *dataAddressDestCur |= col; + dataAddressSrcCur++; + } + dataAddressDestCur++; + } + dataAddressSrc += dataStrideLengthSrc; + dataAddressDest += dataStrideLengthDest; + } + break; + } + case EColor256: + { + TUint8* dataAddressDest = static_cast (aDataAddressDest); + const TInt dataStrideLengthDest = aDataStrideDest; + + while(dataAddressSrcEnd > dataAddressSrc) + { + const TUint8* dataAddressDstLineEnd = dataAddressDest + aDataStrideDest; + TUint8* dataAddressDestCur = dataAddressDest; + TUint16* dataAddressSrcCur = dataAddressSrc; + + while(dataAddressDstLineEnd > dataAddressDestCur) + { + *dataAddressDestCur = TRgb::Color64K(*dataAddressSrcCur).Color256(); + dataAddressSrcCur++; + dataAddressDestCur++; + } + dataAddressSrc += dataStrideLengthSrc; + dataAddressDest += dataStrideLengthDest; + } + break; + } + default: + break; + } + } + +TDisplayMode DisplayModeFromPixelFormat(TUidPixelFormat aPixelFormat) + { + switch(aPixelFormat) + { + case EUidPixelFormatARGB_8888_PRE: + return EColor16MAP; + case EUidPixelFormatARGB_8888: + return EColor16MA; + case EUidPixelFormatRGB_565: + return EColor64K; + default: + break; + } + return ENone; + } + +TUidPixelFormat PixelFormatFromDisplayMode(TDisplayMode aDisplayMode) + { + switch (aDisplayMode) + { + case EGray2: + case EGray4: + case EGray16: + case EGray256: + case EColor16: + case EColor256: + case EColor16M: + case EColor16MU: + { + return EUidPixelFormatXRGB_8888; + } + case EColor4K: + { + return EUidPixelFormatXRGB_4444; + } + case EColor64K: + { + return EUidPixelFormatRGB_565; + } + case EColor16MA: + { + return EUidPixelFormatARGB_8888; + } + case EColor16MAP: + { + return EUidPixelFormatARGB_8888_PRE; + } + default: + { + return EUidPixelFormatUnknown; + } + } + } +#endif + +CTGc::CTGc(CTestStep* aStep) : CTWsGraphicsBase(aStep) + { + } + +CTGc::~CTGc() + { + delete iTest; +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + SgDriver::Close(); + CDirectGdiDriver *directGdiDriver = CDirectGdiDriver::Static(); + if(directGdiDriver) + { + directGdiDriver->Close(); + } +#endif + } + +void CTGc::ConstructL() + { + _LIT(KTestName,"GC Test"); + iTest=new(ELeave) CTestBase(KTestName,this); + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + TInt err = CDirectGdiDriver::Open(); + User::LeaveIfError(err); + err = SgDriver::Open(); + if(err != KErrNone) + { + CDirectGdiDriver *directGdiDriver = CDirectGdiDriver::Static(); + if(directGdiDriver) + { + directGdiDriver->Close(); + } + User::Leave(err); + } +#endif + } + +//Class derived from MWsGraphicResolver. Used for playing the commands from command buffer +class CWSGraphicsRes: public CBase, public MWsGraphicResolver + { +public: + void DrawWsGraphic(TInt /*aId*/, TBool /*aIsUid*/, const TRect& /*aRect*/, const TDesC8& /*aData*/) const + { + //Orveriding by giving empty implemention + } + }; + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA +// +//Class CDrawTextInContextTest +// + +CDrawTextInContextTest::CDrawTextInContextTest(){} + +CDrawTextInContextTest::~CDrawTextInContextTest() + { + delete iRefBitmap; + delete iRefDevice; + delete iRefBitGc; + delete iRemoteGc; + iMsgBuf.Close(); + delete iCommandBuffer; + delete iWsGraphicRes; + + TheClient->iScreen->ReleaseFont(iFont); + + delete iDirectGdiGcWrapper; + if(iWrapperImageTarget) + { + iWrapperImageTarget->Close(); + } + delete iWrapperImageTarget; + iWrapperImage.Close(); + iWrapperImageCollection.Close(); + } + +void CDrawTextInContextTest::BaseConstructL() + { + //Initialise font settings + TFontSpec fsp; + fsp.iTypeface.iName=_L("Series 60 Sans"); + fsp.iHeight=430; + User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInTwips((CFont*&)iFont,fsp)); + + //Initialise TTextParameter + iParam.iStart = 27; + iParam.iEnd = 60; + + //Text to draw + iText.Set(_L("This text will not be drawnK.,!\"\x00A3$%^&*()_+-=;'#:@~/<>? Latin This text will not be drawn")); + + //For reference bitmap + iRefBitmap = new(ELeave) CFbsBitmap(); + User::LeaveIfError(iRefBitmap->Create(KBitmapSize, EColor64K)); + iRefDevice = CFbsBitmapDevice::NewL(iRefBitmap); + User::LeaveIfError(iRefDevice->CreateContext(iRefBitGc)); + + CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static(); + User::LeaveIfNull(theDGdiDriver); + + TSgImageInfo info; + info.iUsage = ESgUsageDirectGdiTarget | ESgUsageDirectGdiSource | ESgUsageCompositionSource; + info.iSizeInPixels = KBitmapSize; + info.iPixelFormat = EUidPixelFormatRGB_565; + + TInt res = iWrapperImageCollection.Create(info, 1); + User::LeaveIfError(res); + res = iWrapperImageCollection.OpenImage(0, iWrapperImage); + User::LeaveIfError(res); + iWrapperImageTarget = new (ELeave) RDirectGdiImageTarget(*theDGdiDriver); + res = iWrapperImageTarget->Create(iWrapperImage); + User::LeaveIfError(res); + iDirectGdiGcWrapper = CDirectGdiGcWrapper::NewL(*iWrapperImageTarget); + + //clean image----------------- + CDirectGdiGcWrapper* directGdiGcWrapper = CDirectGdiGcWrapper::NewL(*iWrapperImageTarget); + CleanupStack::PushL(directGdiGcWrapper); + + directGdiGcWrapper->SetDrawMode(MWsGraphicsContext::EDrawModeWriteAlpha); + directGdiGcWrapper->SetBrushColor(KRgbWhite); + directGdiGcWrapper->Clear(); + + CleanupStack::PopAndDestroy(1, directGdiGcWrapper); + //------------------ + + //Used to record draw commands + iRemoteGc = CRemoteGc::NewL(TheClient->iScreen); + + //Used to play recorded draw commands + iCommandBuffer = CCommandBuffer::NewL(); + + //Dummy class created required for CCommandBuffer::Play + iWsGraphicRes = new (ELeave) CWSGraphicsRes(); + + //Offset for CCommandBuffer::Play + iOffset = TPoint(0,0); + + //Result of doing the test + iHasPassedTest = EFalse; + } + +void CDrawTextInContextTest::Test() + { + /* Create reference bitmap by drawing using bitgc */ + iRefBitGc->UseFont(iFont); + DoDrawTextBitGc(); + iRefBitGc->DiscardFont(); + + /* Drawing using CBitGcWrapper via CRemotGc*/ + + //Capturing the commands in remote gc + iRemoteGc->BeginDraw(KBitmapRect); + iRemoteGc->UseFont(iFont); + DoDrawTextRemoteGc(); + iRemoteGc->DiscardFont(); + iRemoteGc->EndDraw(); + + //Externalize the captured commands from remote gc in to a buffer + iRemoteGc->ExternalizeL(iMsgBuf, ETrue); + + //Internalize the buffer with captured commands (from CRemoteGC) in to CCommandBuffer + iCommandBuffer->InternalizeL(iMsgBuf.Pckg()); + + //Play the commands on test window using command buffer + iCommandBuffer->Play(iOffset,&KBitmapRegion,KBitmapRect,*iWsGraphicRes,*iDirectGdiGcWrapper); + + //Test to see if the bitmap drawn to using CRemoteGc is the same as the reference bitmap + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + + TSgImageInfo info; + iWrapperImage.GetInfo(info); + TDisplayMode displayMode = DisplayModeFromPixelFormat(info.iPixelFormat); + bitmap->Create(info.iSizeInPixels, displayMode); + TRect rect(info.iSizeInPixels); + CopyImageToBitmapL(bitmap, iWrapperImage, rect); + + iHasPassedTest = LossyCompareBitmap(*iRefBitmap, *bitmap, KBitmapRect, EFalse); + + CleanupStack::PopAndDestroy(bitmap); + } + +TBool CDrawTextInContextTest::HasPassedTest() + { + return iHasPassedTest; + } + +// +// Class DrawTextInContextTestPoint +// + +CDrawTextInContextTestPoint::CDrawTextInContextTestPoint(){} + +CDrawTextInContextTestPoint::~CDrawTextInContextTestPoint(){} + +CDrawTextInContextTestPoint* CDrawTextInContextTestPoint::NewL() + { + CDrawTextInContextTestPoint* self = new(ELeave) CDrawTextInContextTestPoint; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CDrawTextInContextTestPoint::ConstructL() + { + BaseConstructL(); + iPosition = TPoint(0,0); + } + +void CDrawTextInContextTestPoint::DoDrawTextBitGc() + { + iRefBitGc->DrawText(iText,&iParam,iPosition); + } + +void CDrawTextInContextTestPoint::DoDrawTextRemoteGc() + { + iRemoteGc->DrawText(iText,&iParam,iPosition); + } + +// +// Class DrawTextInContextTestBox +// + +CDrawTextInContextTestBox::CDrawTextInContextTestBox(){} + +CDrawTextInContextTestBox::~CDrawTextInContextTestBox(){} + +CDrawTextInContextTestBox* CDrawTextInContextTestBox::NewL() + { + CDrawTextInContextTestBox* self = new(ELeave) CDrawTextInContextTestBox; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CDrawTextInContextTestBox::ConstructL() + { + BaseConstructL(); + iClipFillRect = TRect(10,50,640,120); + iBaselineOffset = 40; + iTTextAlign = CGraphicsContext::ELeft; + } + +void CDrawTextInContextTestBox::DoDrawTextBitGc() + { + iRefBitGc->DrawText(iText,&iParam,iClipFillRect,iBaselineOffset,iTTextAlign); + } + +void CDrawTextInContextTestBox::DoDrawTextRemoteGc() + { + iRemoteGc->DrawText(iText,&iParam,iClipFillRect,iBaselineOffset,iTTextAlign); + } + +// +// Class CDrawTextInContextTestPointVertical +// + +CDrawTextInContextTestPointVertical::CDrawTextInContextTestPointVertical(){} + +CDrawTextInContextTestPointVertical::~CDrawTextInContextTestPointVertical(){} + +CDrawTextInContextTestPointVertical* CDrawTextInContextTestPointVertical::NewL() + { + CDrawTextInContextTestPointVertical* self = new(ELeave) CDrawTextInContextTestPointVertical; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CDrawTextInContextTestPointVertical::ConstructL() + { + BaseConstructL(); + iPosition = TPoint(0,0); + iUp = EFalse; + } + +void CDrawTextInContextTestPointVertical::DoDrawTextBitGc() + { + iRefBitGc->DrawTextVertical(iText,&iParam,iPosition,iUp); + } + +void CDrawTextInContextTestPointVertical::DoDrawTextRemoteGc() + { + iRemoteGc->DrawTextVertical(iText,&iParam,iPosition,iUp); + } + +// +// Class CDrawTextInContextTestBoxVertical +// + +CDrawTextInContextTestBoxVertical::CDrawTextInContextTestBoxVertical(){} + +CDrawTextInContextTestBoxVertical::~CDrawTextInContextTestBoxVertical(){} + +CDrawTextInContextTestBoxVertical* CDrawTextInContextTestBoxVertical::NewL() + { + CDrawTextInContextTestBoxVertical* self = new(ELeave) CDrawTextInContextTestBoxVertical; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +void CDrawTextInContextTestBoxVertical::ConstructL() + { + BaseConstructL(); + iClipFillRect = TRect(10,50,640,120); + iBaselineOffset = 40; + iUp = EFalse; + iTTextAlign = CGraphicsContext::ELeft; + } + +void CDrawTextInContextTestBoxVertical::DoDrawTextBitGc() + { + iRefBitGc->DrawTextVertical(iText,&iParam,iClipFillRect,iBaselineOffset,iUp,iTTextAlign); + } + +void CDrawTextInContextTestBoxVertical::DoDrawTextRemoteGc() + { + iRemoteGc->DrawTextVertical(iText,&iParam,iClipFillRect,iBaselineOffset,iUp,iTTextAlign); + } +#endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + +void CleanUpFont(TAny* aFont) + { + //Will be called in case of a leave to release the font + CFont* font= static_cast(aFont); + TheClient->iScreen->ReleaseFont(font); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0437 +@SYMPREQ PREQ1543 +@SYMTestCaseDesc Draw text using CWindowGc and CRemoteGc with both outline and shadow +effect on. +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Create a font with both outline and shadow effects. Record the commands +(like setting colours,drawing text etc) using CRemoteGc and play the recorded commands on a window. Use the same +commands in CWindowGc and draw text on a different window +@SYMTestExpectedResults Text drawn using CWindowGc and CRemoteGc should be same +*/ +void CTGc::TestOutlineAndShadowL() + { + TRect sourceRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight); + TRegionFix<1> clippingRegion(sourceRect); + + CWsScreenDevice* device = TheClient->iScreen; + + _LIT(KText,"Outline and shadow"); + TFontSpec fSpec(KTestFontTypefaceName,23); + fSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + fSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue); + fSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue); + + CFont *font; + User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont *&)font, fSpec)); + CleanupStack::PushL(TCleanupItem(CleanUpFont, font)); + + CRemoteGc* remoteGc = CRemoteGc::NewL(device); + CleanupStack::PushL(remoteGc); + remoteGc->BeginDraw(sourceRect); + //Capturing the commands in remote gc + remoteGc->SetBrushColor(KRgbGreen); + remoteGc->SetShadowColor(KRgbDarkRed); + remoteGc->SetPenColor(KRgbBlack); + remoteGc->UseFont(font); + remoteGc->DrawText(KText, TPoint(2,40)); + remoteGc->DiscardFont(); + remoteGc->EndDraw(); + + RWsGraphicMsgBuf msgBuf; + CleanupClosePushL(msgBuf); + //Externalize the captured commands from remote gc in to a buffer + remoteGc->ExternalizeL(msgBuf, ETrue); + + CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes(); + CleanupStack::PushL(wsGrap); + + CCommandBuffer* cmdBuf = CCommandBuffer::NewL(); + CleanupStack::PushL(cmdBuf); + //Internalize the buffer with captured commands (from CRemoteGC) + //in to CCommandBuffer + cmdBuf->InternalizeL(msgBuf.Pckg()); + + TestWin->Win()->Invalidate(); + TestWin->Win()->BeginRedraw(); + TheGc->Activate(*TestWin->Win()); + TheGc->Clear(); + //Play the commands on test window using command buffer +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + cmdBuf->Play(TPoint(0, 0), &clippingRegion, sourceRect, TheClient->iWs, *TheGc); +#else + cmdBuf->Play(TPoint(),TRect(TestWin->Size()),*wsGrap,*TheGc); +#endif + TheGc->Deactivate(); + TestWin->Win()->EndRedraw(); + + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + TheGc->Clear(); + TheGc->SetBrushColor(KRgbGreen); + TheGc->SetShadowColor(KRgbDarkRed); + TheGc->SetPenColor(KRgbBlack); + TheGc->UseFont(font); + //Draw the text on base window using CWindowGC + TheGc->DrawText(KText, TPoint(2, 40)); + TheGc->DiscardFont(); + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Check the text drawn on base and test windows. + CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestOutlineAndShadowL()")); + + CleanupStack::PopAndDestroy(4, remoteGc); //cmdBuf, wsGrap, msgBuf and remoteGc + CleanupStack::Pop();//font + TheClient->iScreen->ReleaseFont(font); + } + +void CTGc::TestGcClipRectOrigin_DrawContent(TestWindow& aWindow, TBool bActivateBeforeRedraw /*= ETrue*/) + { + TSize winSize = aWindow.Size(); + TPoint gcOrigin(winSize.iWidth >> 3, winSize.iWidth >> 3); + TRect gcClipRect(0, 0, (winSize.iWidth * 3) >> 2, (winSize.iHeight * 3) >> 2); + TRect ellipseRect(gcClipRect); + // Shrink the ellipse for better visibility and to fit well within the clip area. + ellipseRect.Shrink(3, 3); + TSize penSize(1, 1); + + aWindow.Win()->SetBackgroundColor(KRgbGreen); + aWindow.ClearWin(); + aWindow.Win()->Invalidate(); + + if(!bActivateBeforeRedraw) + { + aWindow.Win()->BeginRedraw(); + } + + TheGc->Activate(*(aWindow.Win())); + TheGc->SetOrigin(gcOrigin); + TheGc->SetClippingRect(gcClipRect); + + if(bActivateBeforeRedraw) + { + aWindow.Win()->BeginRedraw(); + } + + TheGc->SetBrushColor(KRgbDarkRed); + TheGc->SetPenColor(KRgbDarkRed); + TheGc->SetPenSize(penSize); + TheGc->SetPenStyle(CGraphicsContext::ESolidPen); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->DrawEllipse(ellipseRect); + TheGc->SetBrushStyle(CGraphicsContext::ENullBrush); + TheGc->SetPenColor(KRgbYellow); + TheGc->SetPenStyle(CGraphicsContext::EDashedPen); + TheGc->DrawRect(gcClipRect); + + aWindow.Win()->EndRedraw(); + TheGc->Deactivate(); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0471 +@SYMTestCaseDesc This test is to verify that the GC correctly applies the clip rect and + origin attributes irrespective of whether the GC is activated on the + window before or after the BeginRedraw. +@SYMDEF PDEF120091 +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions The test has following steps: + 1. For the Test window follow the steps: + A. Activate the GC on Test window. + B. Set the Origin of the GC to centre of the window. + C. Set the Clipping rectangle of the GC to half the size of the window. + D. In the BeginDraw and EndDraw call bracket perform the following: + a. Draw an ellipse with the rectangle smaller by 5 pixels than the clip rectangle. + b. Draw a rectangle that is size of the clip rectangle. + E. Deactivate the GC. + 2. For the Base window follow the steps: + A. In the BeginDraw and EndDraw call bracket perform the following: + a. Activate the GC on Base window. + b. Set the Origin of the GC to centre of the window. + c. Set the Clipping rectangle of the GC to half the size of the window. + d. Draw an ellipse with the rectangle smaller by 5 pixels than the clip rectangle. + e. Draw a rectangle that is size of the clip rectangle. + f. Deactivate the GC. + 3. Compare Test and Base window. +@SYMTestExpectedResults Both the Test and Base window should have the complete + non-clipped ellipse completely encapsulated within the rectangle. +*/ +void CTGc::TestGcClipRectOrigin() + { + TestGcClipRectOrigin_DrawContent(*BaseWin, EFalse); + TestGcClipRectOrigin_DrawContent(*TestWin, ETrue); + + TheClient->Flush(); + + CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestGcClipRectOriginL()")); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0469 +@SYMDEF INC116406 +@SYMTestCaseDesc Try playback on MWsGraphicsContext and CWindowGc to check that the background colour is +set correctly. +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions +@SYMTestExpectedResults Text drawn using CWindowGc should use the background colour of +the window, and MWsGraphicsContext should use transparent white. +*/ +void CTGc::TestResetWithBackgroundColorL() + { + const TRect KSourceRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight); + const TRegionFix<1> KClippingRegion(KSourceRect); + + CWsScreenDevice* device = TheClient->iScreen; + + CRemoteGc* remoteGc = CRemoteGc::NewL(device); + CleanupStack::PushL(remoteGc); + + //note this remote GC has not been activated on any window + remoteGc->BeginDraw(KSourceRect); + + //Draw the commands in remote gc + remoteGc->SetBrushColor(KRgbGreen); //nothing green is seen in this test + + remoteGc->Reset(); //This resets the brush colour to the background colour of the window + //where playback is, in the case of playing back to a window + //however with a CFbsBitGc the color is transparent white, as there is no window. + remoteGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + remoteGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha); + remoteGc->DrawRect(KSourceRect); + remoteGc->EndDraw(); + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static(); + User::LeaveIfNull(theDGdiDriver); + + TSgImageInfo info; + info.iUsage = ESgUsageDirectGdiTarget | ESgUsageCompositionSource; + info.iSizeInPixels = TSize(TestWin->Size().iWidth, TestWin->Size().iHeight); + info.iPixelFormat = EUidPixelFormatXRGB_8888;//among display modes with alpha channel only pre-multiply alpha is supported in directGDI currently + + RSgImageCollection imageCollection; + CleanupClosePushL(imageCollection); + TInt res = imageCollection.Create(info, 1); + User::LeaveIfError(res); + RSgImage image; + CleanupClosePushL(image); + res = imageCollection.OpenImage(0, image); + User::LeaveIfError(res); + RDirectGdiImageTarget imageTarget(*theDGdiDriver); + CleanupClosePushL(imageTarget); + res = imageTarget.Create(image); + User::LeaveIfError(res); +#endif +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + //create a bitmap + CFbsBitmap *bitmap = new (ELeave) CFbsBitmap(); + User::LeaveIfError(bitmap->Create(TSize(TestWin->Size().iWidth, TestWin->Size().iHeight), EColor16MA)); + CleanupStack::PushL(bitmap); + + CFbsBitmapDevice *fbsDevice = CFbsBitmapDevice::NewL(bitmap); + CleanupStack::PushL(fbsDevice); +#endif + + //prepare the command buffer for playback + RWsGraphicMsgBuf msgBuf; + CleanupClosePushL(msgBuf); + + //Externalize the captured commands from remote gc in to a buffer + remoteGc->ExternalizeL(msgBuf, ETrue); + + CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes(); + CleanupStack::PushL(wsGrap); + + CCommandBuffer* cmdBuf = CCommandBuffer::NewL(); + CleanupStack::PushL(cmdBuf); + cmdBuf->InternalizeL(msgBuf.Pckg()); + + TRgb color; + TRgb testColor(KRgbWhite); +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + CDirectGdiGcWrapper* directGdiGcWrapper=CDirectGdiGcWrapper::NewL(imageTarget); + CleanupStack::PushL(directGdiGcWrapper); + cmdBuf->Play(TPoint(),&KClippingRegion,KSourceRect,*wsGrap,*directGdiGcWrapper); + + //check that the background has been cleared to transparent white. + image.GetInfo(info); + info.iUsage = ESgUsageNone; + info.iCpuAccess = ESgCpuAccessReadOnly; + RSgImage image1; + CleanupClosePushL(image1); + res = image1.Create(info, image); + const TAny* data; + TInt stride = 0; + res = image1.MapReadOnly(data, stride); + User::LeaveIfError(res); + TPoint pixel(10,10); + TInt offset = pixel.iY * stride + pixel.iX * 4; + TAny* non_const_data = const_cast (data); + TUint8* pointData = static_cast (non_const_data) + offset; + color = *(reinterpret_cast (pointData)); + image1.Unmap(); +#endif +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + CFbsBitGc* fbsBitGc=NULL; + User::LeaveIfError(fbsDevice->CreateContext(fbsBitGc)); + CleanupStack::PushL(fbsBitGc); + fbsBitGc->Activate(fbsDevice); + cmdBuf->Play(TPoint(0, 0), KSourceRect, *wsGrap, *fbsBitGc); + bitmap->GetPixel(color, TPoint(10,10)); + testColor.SetAlpha(0); +#endif + iStep->TEST(color==testColor); + + //now test drawing to a window to ensure that the brush colour is + //the window background colour + + //display a blue window + BaseWin->Win()->SetBackgroundColor(KRgbBlue); + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + TheGc->Clear(); + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //start drawing the display commands with a green background + + BaseWin->Win()->SetBackgroundColor(KRgbYellow); + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + + //Play the commands on test window using command buffer +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + cmdBuf->Play(TPoint(0, 0), &KClippingRegion, KSourceRect, TheClient->iWs, *TheGc); +#else + cmdBuf->Play(TPoint(0, 0), KSourceRect, *wsGrap, *TheGc); +#endif + + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //check that the background has been cleared to yellow, using brush colour + TPoint position = BaseWin->Win()->InquireOffset(*TheClient->iGroup->WinTreeNode()); + position.iX+=10; + position.iY+=10; + TheClient->iScreen->GetPixel(color, position); + iStep->TEST(color==KRgbYellow); + + BaseWin->Win()->SetBackgroundColor(KRgbGreen); //set back to original backgroundcolor + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + CleanupStack::PopAndDestroy(9, remoteGc); +#else + CleanupStack::PopAndDestroy(7, remoteGc); +#endif + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0481 +@SYMPREQ 1841 +@SYMTestCaseDesc Create font and graphics with various effect effects. Record the commands +(like setting colours,drawing text etc) using CRemoteGc and play the recorded commands on a window. Use the same +commands in CWindowGc and draw text on a different window +@SYMTestPriority Medium +@SYMTestStatus Implemented +@SYMTestActions +@SYMTestExpectedResults Text/graphics drawn using CWindowGc and CRemoteGc should be same +*/ +void CTGc::TestCommandBufferL() + { + CWsScreenDevice* device = TheClient->iScreen; + + _LIT(KBuffText,"Command Buffer"); + TFontSpec fSpec(KTestFontTypefaceName,23); + fSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + fSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue); + fSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue); + + CFont *font; + User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont *&)font, fSpec)); + CleanupStack::PushL(TCleanupItem(CleanUpFont, font)); + + CRemoteGc* remoteGc = CRemoteGc::NewL(device); + CleanupStack::PushL(remoteGc); + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + //-------create image--------- + CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static(); + User::LeaveIfNull(theDGdiDriver); + const TSize KImageSize = TSize(2, 2); + TSgImageInfo info; + info.iUsage = ESgUsageWindowGcSource; + info.iSizeInPixels = KImageSize; + info.iPixelFormat = EUidPixelFormatRGB_565; + info.iShareable = ETrue; + const TInt stride = KImageSize.iWidth * 2; + TUint8* buf = (TUint8*) (User::AllocL(KImageSize.iHeight * stride)); + CleanupStack::PushL(buf); + TUint16* bufCur = ((TUint16*)buf); + *bufCur = KRgbRed.Color64K(); + *(bufCur + 1) = KRgbRed.Color64K(); + *(bufCur + 2) = KRgbRed.Color64K(); + *(bufCur + 3) = KRgbRed.Color64K(); + + RSgImage image; + TInt res = image.Create(info, buf, stride); + User::LeaveIfError(res); + CleanupClosePushL(image); + RWsDrawableSource drawableSource(TheClient->iWs); + res = drawableSource.Create(image, TheClient->iScreen->GetScreenNumber()); + if(res == KErrNotSupported) + { + INFO_PRINTF1(_L("The current screen is not supports drawable source. This test case terminates now.")); + CleanupStack::PopAndDestroy(3, remoteGc); + CleanupStack::Pop();//font + TheClient->iScreen->ReleaseFont(font); + return; + } + User::LeaveIfError(res); + CleanupClosePushL(drawableSource); + //-------end create image--------- +#endif + remoteGc->ResetCommandBuffer(); + remoteGc->BeginDraw(TRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight)); + //Capturing the commands in remote gc + remoteGc->Clear(); + remoteGc->DrawRect(TRect(10,10,30,30)); + remoteGc->Clear(TRect(10,10,11,11)); + remoteGc->CopyRect(TPoint(5,5), TRect(25,25,30,30)); + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CFbsBitmap* bitmapMask = new (ELeave) CFbsBitmap; + User::LeaveIfError(bitmap->Load(_L("Z:\\WSTEST\\WSAUTOTEST.MBM"), EMbmWsautotestCircles24b)); + User::LeaveIfError(bitmapMask->Load(_L("Z:\\WSTEST\\WSAUTOTEST.MBM"), EMbmWsautotestCircles_mask2b)); + remoteGc->BitBlt(TPoint(100,100), bitmap); + remoteGc->BitBlt(TPoint(0,0), bitmap, TRect(0,0,1,1)); + remoteGc->BitBltMasked(TPoint(0,5), bitmap, TRect(0,0,1,1), bitmapMask, EFalse); + CWsBitmap* bitmapWs = new (ELeave) CWsBitmap(TheClient->iWs); + CWsBitmap* bitmapWsMask = new (ELeave) CWsBitmap(TheClient->iWs); + User::LeaveIfError(bitmapWs->Load(_L("Z:\\WSTEST\\TEST.MBM"), 0)); + remoteGc->BitBlt(TPoint(110,110), bitmapWs); + remoteGc->BitBlt(TPoint(5,0), bitmapWs, TRect(0,0,1,1)); + remoteGc->BitBltMasked(TPoint(10,0), bitmap, TRect(0,0,1,1), bitmapWsMask, EFalse); + remoteGc->SetFadingParameters(128,128); + remoteGc->SetFaded(EFalse); + remoteGc->AlphaBlendBitmaps(TPoint(2,2), bitmap, TRect(0,0,1,1), bitmapMask, TPoint(2,2)); + remoteGc->AlphaBlendBitmaps(TPoint(3,3), bitmapWs, TRect(0,0,1,1), bitmapWsMask, TPoint(2,2)); + remoteGc->SetOrigin(TPoint(0,30)); + remoteGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + remoteGc->SetClippingRect(TRect(0,0,10,10)); + remoteGc->SetPenStyle(CGraphicsContext::ESolidPen); + remoteGc->SetPenSize(TSize(1,2)); + remoteGc->UseBrushPattern(bitmap); + remoteGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + remoteGc->SetBrushOrigin(TPoint(0,0)); + remoteGc->DrawPie(TRect(0,0,15,15),TPoint(0,8),TPoint(15,8)); + remoteGc->CancelClippingRect(); + remoteGc->DiscardBrushPattern(); + remoteGc->CancelClippingRegion(); + remoteGc->Reset(); + remoteGc->SetOrigin(TPoint(0,0)); + remoteGc->SetUnderlineStyle(EUnderlineOff); + remoteGc->SetStrikethroughStyle(EStrikethroughOff); + remoteGc->SetWordJustification(1,2); + remoteGc->SetCharJustification(1,2); + remoteGc->UseFont(font); + remoteGc->DrawText(KBuffText,TRect(50,0,100,50),10,CGraphicsContext::ELeft,0); + remoteGc->DrawTextVertical(KBuffText,TPoint(170,20),EFalse); + remoteGc->DrawTextVertical(KBuffText,TRect(120,20,150,100),5,EFalse,CGraphicsContext::ELeft,0); + remoteGc->MoveTo(TPoint(25,150)); + remoteGc->MoveBy(TPoint(5,5)); + remoteGc->DrawLineTo(TPoint(35,160)); + remoteGc->DrawLine(TPoint(35,160),TPoint(25,150)); + remoteGc->DrawLineBy(TPoint(15,6)); + remoteGc->Plot(TPoint(5,5)); + remoteGc->DrawArc(TRect(0,80,10,90),TPoint(0,85),TPoint(10,85)); + remoteGc->DrawEllipse(TRect(0,90,10,100)); + remoteGc->DrawRoundRect(TRect(30,80,50,100),TSize(5,5)); + remoteGc->DrawBitmap(TPoint(150,150),bitmap); + remoteGc->DrawBitmap(TRect(160,160,170,170), bitmap); + remoteGc->DrawBitmap(TRect(175,175,180,180), bitmap, TRect(0,5,5,10)); + remoteGc->DrawBitmapMasked(TRect(185,185,190,190), bitmap, TRect(0,50,5,55),bitmapMask,EFalse); + remoteGc->DrawBitmapMasked(TRect(195,195,200,200), bitmapWs, TRect(0,50,5,55),bitmapWsMask,EFalse); + CArrayFixFlat* polyPoints = new(ELeave) CArrayFixFlat(3); //CArrayFixFlat + CleanupStack::PushL(polyPoints); + TRect rect (200,0,200,100); + polyPoints->AppendL(rect.iTl); + polyPoints->AppendL(rect.Center()); + polyPoints->AppendL(TPoint(rect.iBr.iX, rect.iTl.iY)); + remoteGc->DrawPolyLine(polyPoints); + remoteGc->DrawPolyLine(&polyPoints->At(0), 3); + remoteGc->DrawPolygon(polyPoints, CGraphicsContext::EWinding); + remoteGc->DrawPolygon(&polyPoints->At(0), 3, CGraphicsContext::EAlternate); +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + MWsDrawResource* dr = static_cast(remoteGc->Interface(KMWsDrawResourceInterfaceUid)); + if(dr) + dr->DrawResource(TPoint(30, 40), drawableSource); +#endif + RRegion region; + remoteGc->SetClippingRegion(region); + remoteGc->DiscardFont(); + remoteGc->EndDraw(); + + RWsGraphicMsgBuf msgBuf; + CleanupClosePushL(msgBuf); + //Externalize the captured commands from remote gc in to a buffer + remoteGc->ExternalizeL(msgBuf, EFalse); + + CCommandBuffer* cmdBuf = CCommandBuffer::NewL(); + CleanupStack::PushL(cmdBuf); + const CCommandBuffer* testCmdBuf = CCommandBuffer::NewL(); + if(cmdBuf->IsIdentical(*testCmdBuf)==EFalse) + { + User::Panic(_L("TestCommandBufferL"), KErrGeneral); + } + delete testCmdBuf; + //Internalize the buffer with captured commands (from CRemoteGC) + //in to CCommandBuffer + cmdBuf->InternalizeL(msgBuf.Pckg()); + + TheGc->Activate(*TestWin->Win()); + TestWin->Win()->Invalidate(); + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + /* + * Make sure anything that can leave is done outside the + * BeginRedraw/EndRedraw bracket. + */ + CWSGraphicsRes* wsGrap=new(ELeave) CWSGraphicsRes(); + CleanupStack::PushL(wsGrap); +#endif + /* + * Note we need to still do BeginRedraw/EndRedraw for the TestWin Window + * even though the CRemoteGc we are going to Play into TestWin already has + * BeginRedraw/EndRedraw commands issued into it. Those commands just allow + * for replacement of draw ops already in the CRemoteGc to be replaced by + * new draw ops covering the same area. The BeginRedraw/EndRedraws never + * get Play()'ed into TestWin. + */ + TestWin->Win()->BeginRedraw(); + TheGc->Clear(); + //Play the commands on test window using command buffer +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + cmdBuf->Play(TPoint(), NULL, TRect(TestWin->Size()), TheClient->iWs, *TheGc); +#endif +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + cmdBuf->Play(TPoint(),TRect(TestWin->Size()),*wsGrap,*TheGc); + CleanupStack::PopAndDestroy(wsGrap); +#endif + TheGc->Deactivate(); + TestWin->Win()->EndRedraw(); + remoteGc->ResetCommandBuffer(); + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + TheGc->Clear(); + TheGc->DrawRect(TRect(10,10,30,30)); + TheGc->Clear(TRect(10,10,11,11)); + TheGc->CopyRect(TPoint(5,5), TRect(25,25,30,30)); + TheGc->BitBlt(TPoint(100,100), bitmap); + TheGc->BitBlt(TPoint(0,0), bitmap, TRect(0,0,1,1)); + TheGc->BitBltMasked(TPoint(0,5), bitmap, TRect(0,0,1,1), bitmapMask, EFalse); + TheGc->BitBlt(TPoint(110,110), bitmapWs); + TheGc->BitBlt(TPoint(5,0), bitmapWs, TRect(0,0,1,1)); + TheGc->BitBltMasked(TPoint(10,0), bitmap, TRect(0,0,1,1), bitmapWsMask, EFalse); + TheGc->SetFadingParameters(128,128); + TheGc->SetFaded(EFalse); + TheGc->AlphaBlendBitmaps(TPoint(2,2), bitmap, TRect(0,0,1,1), bitmapMask, TPoint(2,2)); + TheGc->AlphaBlendBitmaps(TPoint(3,3), bitmapWs, TRect(0,0,1,1), bitmapWsMask, TPoint(2,2)); + TheGc->SetOrigin(TPoint(0,30)); + TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + TheGc->SetClippingRect(TRect(0,0,10,10)); + TheGc->SetPenStyle(CGraphicsContext::ESolidPen); + TheGc->SetPenSize(TSize(1,2)); + TheGc->UseBrushPattern(bitmap); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetBrushOrigin(TPoint(0,0)); + TheGc->DrawPie(TRect(0,0,15,15),TPoint(0,8),TPoint(15,8)); + TheGc->CancelClippingRect(); + TheGc->DiscardBrushPattern(); + TheGc->CancelClippingRegion(); + TheGc->Reset(); + TheGc->SetOrigin(TPoint(0,0)); + TheGc->SetUnderlineStyle(EUnderlineOff); + TheGc->SetStrikethroughStyle(EStrikethroughOff); + TheGc->SetWordJustification(1,2); + TheGc->SetCharJustification(1,2); + TheGc->UseFont(font); + TheGc->DrawText(KBuffText,TRect(50,0,100,50),10,CGraphicsContext::ELeft,0); + TheGc->DrawTextVertical(KBuffText,TPoint(170,20),EFalse); + TheGc->DrawTextVertical(KBuffText,TRect(120,20,150,100),5,EFalse,CGraphicsContext::ELeft,0); + TheGc->MoveTo(TPoint(25,150)); + TheGc->MoveBy(TPoint(5,5)); + TheGc->DrawLineTo(TPoint(35,160)); + TheGc->DrawLine(TPoint(35,160),TPoint(25,150)); + TheGc->DrawLineBy(TPoint(15,6)); + TheGc->Plot(TPoint(5,5)); + TheGc->DrawArc(TRect(0,80,10,90),TPoint(0,85),TPoint(10,85)); + TheGc->DrawEllipse(TRect(0,90,10,100)); + TheGc->DrawRoundRect(TRect(30,80,50,100),TSize(5,5)); + TheGc->DrawBitmap(TPoint(150,150),bitmap); + TheGc->DrawBitmap(TRect(160,160,170,170), bitmap); + TheGc->DrawBitmap(TRect(175,175,180,180), bitmap, TRect(0,5,5,10)); + TheGc->DrawBitmapMasked(TRect(185,185,190,190), bitmap, TRect(0,50,5,55),bitmapMask,EFalse); + TheGc->DrawBitmapMasked(TRect(195,195,200,200), bitmapWs, TRect(0,50,5,55),bitmapWsMask,EFalse); + TheGc->DrawPolyLine(polyPoints); + TheGc->DrawPolyLine(&polyPoints->At(0), 3); + TheGc->DrawPolygon(polyPoints, CGraphicsContext::EWinding); + TheGc->DrawPolygon(&polyPoints->At(0), 3, CGraphicsContext::EAlternate); +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetBrushColor(KRgbRed); + TheGc->SetPenColor(KRgbRed); + TheGc->DrawRect(TRect(30, 40, 32, 42)); +#endif + TheGc->DiscardFont(); + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + TheClient->Flush(); + TheClient->WaitForRedrawsToFinish(); + + //Check the text drawn on base and test windows. + TBool err = CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestCommandBufferL()")); + if (err) + { + INFO_PRINTF1(_L("The CheckRect function returned error.")); + } + delete bitmap; + INFO_PRINTF1(_L("bitmap deleted.")); + delete bitmapMask; + INFO_PRINTF1(_L("bitmapMask deleted.")); + delete bitmapWs; + INFO_PRINTF1(_L("bitmapWs deleted.")); + delete bitmapWsMask; + INFO_PRINTF1(_L("bitmapWsMask deleted.")); + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + CleanupStack::PopAndDestroy(7, remoteGc); +#else + CleanupStack::PopAndDestroy(4, remoteGc); +#endif + CleanupStack::Pop();//font + INFO_PRINTF1(_L("CleanupStack popped.")); + TheClient->iScreen->ReleaseFont(font); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0482 +@SYMPREQ 1841 +@SYMTestCaseDesc Play empty command buffer. +@SYMTestPriority Medium +@SYMTestStatus Implemented +@SYMTestActions +@SYMTestExpectedResults return KErrEof error +*/ +void CTGc::TestEmptyCommandBufferL() + { +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes(); + CleanupStack::PushL(wsGrap); +#endif + + CCommandBuffer* cmdBuf = CCommandBuffer::NewL(); + CleanupStack::PushL(cmdBuf); + + TheGc->Activate(*TestWin->Win()); + TheGc->Clear(); + //Play the commands on test window using command buffer +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + TInt err = cmdBuf->Play(TPoint(),TRect(TestWin->Size()),*wsGrap,*TheGc); +#else + TInt err = cmdBuf->Play(TPoint(),NULL,TRect(TestWin->Size()),TheClient->iWs,*TheGc); +#endif + if(err!=KErrEof) + { + User::Panic(_L("TestEmptyCommandBufferL"), KErrGeneral); + } + TheGc->Deactivate(); +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NONNGA + CleanupStack::PopAndDestroy(2, wsGrap); //cmdBuf, wsGrap, msgBuf and remoteGc +#else + CleanupStack::PopAndDestroy(cmdBuf); +#endif + } + +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA +/** +@SYMTestCaseID GRAPHICS-WSERV-0486 +@SYMPREQ PREQ2095 +@SYMTestCaseDesc Draw text using CWindowGc and CRemoteGc with both outline and shadow +effect on. +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Create a font with both outline and shadow effects, also use ClippingRect +and ClippingRegion. Record the commands using CRemoteGc and play the recorded commands on a +bitmap using MWsGraphicsContext. Use the same commands in CWindowGc and draw text on a +different window +@SYMTestExpectedResults Text drawn using CWindowGc and CRemoteGc(MWsGraphicsContext) should be same +*/ +void CTGc::TestCRemoteGcAndMWsGraphicsContextClippingRectL() + { + const TRect KTestRect(0, 0, TestWin->Size().iWidth, TestWin->Size().iHeight); + const TRegionFix<1> KTestRegion(KTestRect); + const TRect KClippingRect1(5, 5, TestWin->Size().iWidth-10, 90); + const TRegionFix<1> KClippingRegion(KClippingRect1); + const TRect KClippingRect2(15, 15, TestWin->Size().iWidth-10, TestWin->Size().iHeight-10); + + CWsScreenDevice* device = TheClient->iScreen; + /* + * On hardware, the first screen runs in 64K colors, but the second screen (TV OUT) + * cannot run in this mode, it instead falls back to 16M colors. We need to ensure + * that we use matching color depths for our off-screen bitmaps so that accuracy is + * not lost since we compare bitmaps from the screen versus off-screen. + */ + + TDisplayMode displayMode = device->DisplayMode(); + if (TDisplayModeUtils::NumDisplayModeBitsPerPixel(displayMode) == 32) + { + displayMode = EColor16MAP; + } + + _LIT(KText,"RemoteGc & MWsGraphicsContext"); + TFontSpec fSpec(KTestFontTypefaceName,23); + fSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + fSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, ETrue); + fSpec.iFontStyle.SetEffects(FontEffect::EOutline, ETrue); + + CFont *font; + User::LeaveIfError(TheClient->iScreen->GetNearestFontToDesignHeightInPixels((CFont *&)font, fSpec)); + CleanupStack::PushL(TCleanupItem(CleanUpFont, font)); + + //Record the commands using CRemoteGc + CRemoteGc* remoteGc = CRemoteGc::NewL(device); + CleanupStack::PushL(remoteGc); + remoteGc->BeginDraw(KTestRect); + //fill background with white + remoteGc->SetPenStyle(CFbsBitGc::ENullPen); + remoteGc->SetBrushStyle(CFbsBitGc::ESolidBrush); + remoteGc->SetBrushColor(KRgbWhite); + remoteGc->DrawRect(TRect(TPoint(0,0), TestWin->Size())); + remoteGc->SetPenStyle(CFbsBitGc::ESolidPen); + //Capturing the commands in remote gc + remoteGc->SetClippingRect(KClippingRect2); + remoteGc->SetClippingRegion(KClippingRegion); + remoteGc->SetBrushStyle(CFbsBitGc::ESolidBrush); + remoteGc->SetBrushColor(TRgb(0,150,150)); + remoteGc->DrawRect(TRect(TPoint(0,0), TSize(160,60))); + remoteGc->SetBrushColor(TRgb(150,100,150)); + remoteGc->DrawRect(TRect(TPoint(0,60), TSize(160,60))); + remoteGc->SetBrushColor(KRgbGreen); + remoteGc->SetShadowColor(KRgbDarkRed); + remoteGc->SetPenColor(KRgbBlack); + remoteGc->UseFont(font); + remoteGc->DrawText(KText, TPoint(2,40)); + remoteGc->DiscardFont(); + remoteGc->EndDraw(); + + RWsGraphicMsgBuf msgBuf; + CleanupClosePushL(msgBuf); + //Externalize the captured commands from remote gc in to a buffer + remoteGc->ExternalizeL(msgBuf, ETrue); + + CCommandBuffer* cmdBuf = CCommandBuffer::NewL(); + CleanupStack::PushL(cmdBuf); + //Internalize the buffer with captured commands (from CRemoteGC) + //in to CCommandBuffer + cmdBuf->InternalizeL(msgBuf.Pckg()); + + CDirectGdiDriver* theDGdiDriver = CDirectGdiDriver::Static(); + User::LeaveIfNull(theDGdiDriver); + + TSgImageInfo info; + info.iUsage = ESgUsageDirectGdiTarget | ESgUsageDirectGdiSource | ESgUsageCompositionSource; + info.iSizeInPixels = TestWin->Size(); + info.iPixelFormat = PixelFormatFromDisplayMode(displayMode); + + RSgImageCollection imageCollection; + CleanupClosePushL(imageCollection); + TInt res = imageCollection.Create(info, 1); + User::LeaveIfError(res); + RSgImage image; + CleanupClosePushL(image); + res = imageCollection.OpenImage(0, image); + User::LeaveIfError(res); + RDirectGdiImageTarget imageTarget(*theDGdiDriver); + CleanupClosePushL(imageTarget); + + res = imageTarget.Create(image); + User::LeaveIfError(res); + + CDirectGdiGcWrapper* directGdiGcWrapper = CDirectGdiGcWrapper::NewL(imageTarget); + CleanupStack::PushL(directGdiGcWrapper); + + //Dummy class created + CWSGraphicsRes* wsGrap = new (ELeave) CWSGraphicsRes(); + CleanupStack::PushL(wsGrap); + + //Play the commands on test window using command buffer + cmdBuf->Play(TPoint(),&KTestRegion,KTestRect,*wsGrap,*directGdiGcWrapper); + + //Set window back to same as test bitmap background + BaseWin->Win()->SetBackgroundColor(KRgbWhite); + + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + TheGc->Clear(); + TheGc->SetClippingRect(KClippingRect2); + TheGc->SetClippingRegion(KClippingRegion); + TheGc->SetBrushStyle(CFbsBitGc::ESolidBrush); + TheGc->SetBrushColor(TRgb(0,150,150)); + TheGc->DrawRect(TRect(TPoint(0,0), TSize(160,60))); + TheGc->SetBrushColor(TRgb(150,100,150)); + TheGc->DrawRect(TRect(TPoint(0,60), TSize(160,60))); + TheGc->SetBrushColor(KRgbGreen); + TheGc->SetShadowColor(KRgbDarkRed); + TheGc->SetPenColor(KRgbBlack); + TheGc->UseFont(font); + //Draw the text on base window using CWindowGC + TheGc->DrawText(KText, TPoint(2, 40)); + TheGc->DiscardFont(); + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + TheClient->iWs.Finish(); + TheClient->WaitForRedrawsToFinish(); + + //Create a bitmap and then copy the screen to it + TRect rc(TRect(BaseWin->Win()->AbsPosition(), BaseWin->Win()->Size())); + CFbsBitmap *screenBitmap = new (ELeave) CFbsBitmap(); + User::LeaveIfError(screenBitmap->Create(rc.Size(), displayMode)); + CleanupStack::PushL(screenBitmap); + TheClient->iScreen->CopyScreenToBitmap(screenBitmap, rc); + + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + + image.GetInfo(info); + bitmap->Create(info.iSizeInPixels, displayMode); + TRect rect(info.iSizeInPixels); + CopyImageToBitmapL(bitmap, image, rect); + + //Test to see if the bitmap drawn to using CRemoteGc is the same as the screen copy bitmap + TInt differentPixels = 0; + res = LossyCompareBitmapRecord(*bitmap, *screenBitmap, KTestRect, EFalse, differentPixels, Logger()); + if (differentPixels != 0) + { + INFO_PRINTF2(_L(" Pixels different %d"), differentPixels); + } + TEST(res); + CleanupStack::PopAndDestroy(10, remoteGc); //screenBitmap, imageCollection, image, imageTarget, directGdiGcWrapper, cmdBuf, wsGrap, msgBuf, remoteGc, bitmap + CleanupStack::Pop();//font + TheClient->iScreen->ReleaseFont(font); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0487 +@SYMPREQ PREQ2095 +@SYMTestCaseDesc Draw text using CRemoteGc and DrawText(const TDesC&,const TTextParameters*,const TPoint&) +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Create a font. Draw text to a bitmap with the font using CFbsBitGc::DrawText. Draw text with the font using CFbsBitGc::DrawText. +Record the same DrawText commands using CRemoteGc and play the recorded commands on a +bitmap using MWsGraphicsContext. Compare the two bitmaps. +@SYMTestExpectedResults Text drawn using CFbsBitGc and CRemoteGc(MWsGraphicsContext) should be the same +*/ +void CTGc::TestCRemoteGcDrawTextInContextPointL() + { + CDrawTextInContextTestPoint* test = CDrawTextInContextTestPoint::NewL(); + CleanupStack::PushL(test); + test->Test(); + TEST(test->HasPassedTest()); + CleanupStack::PopAndDestroy(); //test + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0488 +@SYMPREQ PREQ2095 +@SYMTestCaseDesc Draw text using CRemoteGc and DrawText(const TDesC&,const TTextParameters*,const TRect&,TInt,TTextAlign,TInt) +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Create a font. Draw text to a bitmap with the font using CFbsBitGc::DrawText. Draw text with the font using CFbsBitGc::DrawText. +Record the same DrawText commands using CRemoteGc and play the recorded commands on a +bitmap using MWsGraphicsContext. Compare the two bitmaps. +@SYMTestExpectedResults Text drawn using CFbsBitGc and CRemoteGc(MWsGraphicsContext) should be the same +*/ +void CTGc::TestCRemoteGcDrawTextInContextBoxL() + { + CDrawTextInContextTestBox* test = CDrawTextInContextTestBox::NewL(); + CleanupStack::PushL(test); + test->Test(); + TEST(test->HasPassedTest()); + CleanupStack::PopAndDestroy(); //test + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0489 +@SYMPREQ PREQ2095 +@SYMTestCaseDesc Draw text using CRemoteGc and DrawTextVertical(const TDesC&,const TTextParameters*,const TPoint&) +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Create a font. Draw text to a bitmap with the font using CFbsBitGc::DrawTextVertical. Draw text with the font using CFbsBitGc::DrawText. +Record the same DrawText commands using CRemoteGc and play the recorded commands on a +bitmap using MWsGraphicsContext. Compare the two bitmaps. +@SYMTestExpectedResults Text drawn using CFbsBitGc and CRemoteGc(MWsGraphicsContext) should be the same +*/ +void CTGc::TestCRemoteGcDrawTextInContextPointVerticalL() + { + CDrawTextInContextTestPointVertical* test = CDrawTextInContextTestPointVertical::NewL(); + CleanupStack::PushL(test); + test->Test(); + TEST(test->HasPassedTest()); + CleanupStack::PopAndDestroy(); //test + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0490 +@SYMPREQ PREQ2095 +@SYMTestCaseDesc Draw text using CRemoteGc and DrawTextVertical(const TDesC&,const TTextParameters*,const TRect&,TInt,TTextAlign,TInt) +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Create a font. Draw text to a bitmap with the font using CFbsBitGc::DrawTextVertical. Draw text with the font using CFbsBitGc::DrawText. +Record the same DrawText commands using CRemoteGc and play the recorded commands on a +bitmap using MWsGraphicsContext. Compare the two bitmaps. +@SYMTestExpectedResults Text drawn using CFbsBitGc and CRemoteGc(MWsGraphicsContext) should be the same +*/ +void CTGc::TestCRemoteGcDrawTextInContextBoxVerticalL() + { + CDrawTextInContextTestBoxVertical* test = CDrawTextInContextTestBoxVertical::NewL(); + CleanupStack::PushL(test); + test->Test(); + TEST(test->HasPassedTest()); + CleanupStack::PopAndDestroy(); //test + } +#endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + +/** +@SYMTestCaseID GRAPHICS-WSERV-0494 +@SYMDEF DEF131255 +@SYMTestCaseDesc Negative test to show that using SetBrushStyle() will not panic WServ with different + brush bitmaps. +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions Four seperate panic situations are tested: + 1) + Create a regular CFbsBitmap, set as brush pattern, and set brush style to EPatternedBrush. + Draw a line to force the playback to occur. + Call Finish on the GC. + Destroy the brush bitmap. + 2) + Create a regular CFbsBitmap, set as brush pattern, and set brush style to EPatternedBrush. + Draw a line to force the playback to occur. + Destroy the brush bitmap. + Call Finish on the GC. + 3+4) + Create an extended bitmap, set as the brush pattern, and set the brush style to EPatternedBrush. + Draw a line to force the playback to occur. + Set the brush bitmap and style again. + Call Finish on the GC. + Destroy the brush bitmap. +@SYMTestExpectedResults The calls to SetBrushStyle() should not cause WServ to panic when Finish() is called. +*/ +void CTGc::TestGcSetBrushPatternL() + { + // Extended bitmap test data. + const TUint8 KTestData[] = "TEST DATA"; + const TInt KTestDataSize = sizeof(KTestData); + const TUid KTestExtendedBitmapUid = TUid::Uid(0xFFFFFFFF); + + // First try using a regular bitmap as the brush pattern. + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + CFbsBitmap* bitmapRegular = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmapRegular); + TInt res = bitmapRegular->Create(TSize(10,10), EColor64K); + TEST(res == KErrNone); + //Record the commands using CWindowGc. + TheGc->UseBrushPattern(bitmapRegular); + TheGc->SetBrushStyle(CGraphicsContext::EPatternedBrush); + // DrawLine() is only used here to force playback of the commands. + TheGc->DrawLine(TPoint(0,0), TPoint(1,1)); + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + TheClient->iWs.Finish(); + CleanupStack::PopAndDestroy(1, bitmapRegular); + + // Secondly, try using a regular bitmap as the brush pattern, but deleting the bitmap + // before calling Finish(). + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + bitmapRegular = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmapRegular); + res = bitmapRegular->Create(TSize(10,10), EColor64K); + TEST(res == KErrNone); + //Record the commands using CWindowGc. + TheGc->UseBrushPattern(bitmapRegular); + TheGc->SetBrushStyle(CGraphicsContext::EPatternedBrush); + TheGc->DrawLine(TPoint(0,0), TPoint(1,1)); + CleanupStack::PopAndDestroy(1, bitmapRegular); + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + TheClient->iWs.Finish(); + + // Thirdly, try using an extended bitmap (which is unsupported by DirectGDI) as + // the brush pattern. + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + // Create a dummy extended bitmap to use as a brush bitmap. + // This is unsupported by the default implementation of DirectGDI. + CFbsBitmap* bitmapExtended = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmapExtended); + res = bitmapExtended->CreateExtendedBitmap(TSize(10,10), EColor64K, KTestExtendedBitmapUid, KTestData, KTestDataSize); + TEST(res == KErrNone); + //Record the commands using CWindowGc. + TheGc->UseBrushPattern(bitmapExtended); + TheGc->SetBrushStyle(CGraphicsContext::EPatternedBrush); + TheGc->DrawLine(TPoint(0,0), TPoint(100,100)); + TheGc->UseBrushPattern(bitmapExtended); + // Forth, do it twice so that we test the state commands and the drawops commands. + TheGc->SetBrushStyle(CGraphicsContext::EPatternedBrush); + TheGc->DrawLine(TPoint(0,0), TPoint(100,100)); + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + TheClient->iWs.Finish(); + CleanupStack::PopAndDestroy(1, bitmapExtended); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0576 +@SYMDEF +@SYMTestCaseDesc Checks window server is still able to draw a bitmap, even after the client has released its handle to the bitmap. +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions - Draw the bitmap to TestWin (keeping the window hidden) + - Delete the bitmap + - Show TestWin to cause it to be drawn on screen (after the bitmap has been deleted) + - Draw the same bitmap (same image, different bitmap object instance) to BaseWin + - Compare contents of TestWin with BaseWin +@SYMTestExpectedResults TestWin and BaseWin should both show the bitmap. +*/ +void CTGc::TestGcDeleteBitmap1L() + { + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + TInt ret = bitmap->Load(TEST_BITMAP_NAME,0); + TEST(ret == KErrNone); + + // send drawing to hidden window + TestWin->SetVisible(EFalse); + TestWin->Win()->Invalidate(); + TestWin->Win()->BeginRedraw(); + TheGc->Activate(*TestWin->Win()); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + TheGc->SetBrushColor(TRgb(255, 0, 0)); + TheGc->Clear(); + TheGc->BitBlt(TPoint(0,0), bitmap); + CleanupStack::PopAndDestroy(bitmap); // before the bitmap is actually deleted, WsFbsDestroyCallBack flushes the command buffer to ensure the bitmap is duplicated in the window server thread + bitmap = NULL; + TheGc->Deactivate(); + TestWin->Win()->EndRedraw(); + TheClient->iWs.Flush(); // calling Flush rather than Finish, as we don't need to wait for any drawing to happen (as the window is currently hidden) + + // make window visible (forcing it to draw) + TestWin->SetVisible(ETrue); + TheClient->iWs.Finish(); // ensure the bitmap has been drawn on test win + + // window server should have duplicated the bitmap when the BitBlt was added to the redraw store, so drawing + // the window now (by making it visible above) should display the bitmap on screen, even + // though we've deleted it in this thread + + // now create the bitmap again, and draw it to the base win (for comparison with test win) + bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + ret = bitmap->Load(TEST_BITMAP_NAME,0); + TEST(ret == KErrNone); + BaseWin->SetVisible(ETrue); + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + TheGc->SetBrushColor(TRgb(255, 0, 0)); + TheGc->Clear(); + TheGc->BitBlt(TPoint(0,0), bitmap); + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + TheClient->iWs.Finish(); // ensure the bitmap has been drawn on base win + + CleanupStack::PopAndDestroy(bitmap); + + // the test bitmap should be shown in both base win and test win, so we now check that the + // contents of base win and test win are the same + CheckRect(BaseWin, TestWin, TRect(0, 0, BaseWin->Size().iWidth, BaseWin->Size().iHeight), _L("CTGc::TestGcDeleteBitmap1L()")); + } + +/** +@SYMTestCaseID GRAPHICS-WSERV-0577 +@SYMDEF +@SYMTestCaseDesc Check window server is still able to use a bitmap required by window drawing, even + after the client has released its handle to the bitmap. Also check window server + releases the bitmap, when it's no longer used by window drawing. +@SYMTestPriority High +@SYMTestStatus Implemented +@SYMTestActions - Clean BaseWin and TestWin from content that has been left over from previous test + - Draw test bitmap to TestWin + - Delete the bitmap + - Using a different bitmap object instance, duplicate bitmap (the bitmap is still used by window drawing) + - Delete the bitmap + - Draw new content to TestWin, so that previously drawn bitmap is covered + - Duplicate bitmap (the bitmap is no longer used by window drawing) +@SYMTestExpectedResults Bitmap duplication succeeds, when the bitmap used by window drawing, whereas + bitmap duplication fails, when the bitmap is no longer used by window drawing. +*/ +void CTGc::TestGcDeleteBitmap2L() + { + //send new drawing to test and base windows, in order to cover + //any content has been left on them (through previous test) + BaseWin->SetVisible(ETrue); + BaseWin->Win()->Invalidate(); + BaseWin->Win()->BeginRedraw(); + TheGc->Activate(*BaseWin->Win()); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + TheGc->SetBrushColor(TRgb(0, 0, 255)); + TheGc->Clear(); + TheGc->Deactivate(); + BaseWin->Win()->EndRedraw(); + + TestWin->SetVisible(ETrue); + TestWin->Win()->Invalidate(); + TestWin->Win()->BeginRedraw(); + TheGc->Activate(*TestWin->Win()); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + TheGc->SetBrushColor(TRgb(0, 0, 255)); + TheGc->Clear(); + TheGc->Deactivate(); + TestWin->Win()->EndRedraw(); + + TheClient->iWs.Flush(); + TheClient->iWs.Finish(); + + //load test bitmap + CFbsBitmap* bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + TInt ret = bitmap->Load(_L("Z:\\WSTEST\\TESTCIRCLES.MBM"),0); + TEST(ret == KErrNone); + TInt bitmapHandle = bitmap->Handle(); + + //send bitmap drawing to test window + TestWin->Win()->Invalidate(); + TestWin->Win()->BeginRedraw(); + TheGc->Activate(*TestWin->Win()); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + TheGc->SetBrushColor(TRgb(0, 255, 0)); + TheGc->Clear(); + TheGc->BitBlt(TPoint(0,0), bitmap); + TheGc->Deactivate(); + TestWin->Win()->EndRedraw(); + + CleanupStack::PopAndDestroy(bitmap); + + TheClient->iWs.Flush(); + TheClient->iWs.Finish(); + + //using a new bitmap object instance check that wserv can still duplicate test bitmap (even though + //the initial bitmap object is deleted) , since there is a window segment using it + bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + ret = bitmap->Duplicate(bitmapHandle); + TEST(ret == KErrNone); + CleanupStack::PopAndDestroy(bitmap); + + //send new drawing to test window, in order to cover the bitmap that was previously drawn + TestWin->Win()->Invalidate(); + TestWin->Win()->BeginRedraw(); + TheGc->Activate(*TestWin->Win()); + TheGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + TheGc->SetDrawMode(CGraphicsContext::EDrawModePEN); + TheGc->SetBrushColor(TRgb(0, 0, 255)); + TheGc->Clear(); + TheGc->Deactivate(); + TestWin->Win()->EndRedraw(); + + TheClient->iWs.Flush(); + TheClient->iWs.Finish(); + + //check that wserv can't duplicate test bitmap, since no window segment uses it any more + bitmap = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bitmap); + ret = bitmap->Duplicate(bitmapHandle); + TEST(ret != KErrNone); + CleanupStack::PopAndDestroy(bitmap); + } + +void CTGc::RunTestCaseL(TInt /*aCurTestCase*/) + { + ((CTGcStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch(++iTest->iState) + { + case 1: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0437")); + iTest->LogSubTest(_L("CRemoteGc&CWindowGc, outline and shadow text")); + TestOutlineAndShadowL(); + break; + case 2: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0471")); + iTest->LogSubTest(_L("Test GC clip rect and origin attributes.")); + TestGcClipRectOrigin(); + break; + case 3: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0469")); + iTest->LogSubTest(_L("CRemoteGc&CWindowGc, reset with background colour")); + TestResetWithBackgroundColorL(); + break; + case 4: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0481")); + iTest->LogSubTest(_L("CRemoteGc&CCommandBuffer, coverage tests")); + TestCommandBufferL(); + break; + case 5: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0482")); + iTest->LogSubTest(_L("CCommandBuffer, coverage tests")); + TestEmptyCommandBufferL(); + break; + case 6: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0494")); + iTest->LogSubTest(_L("CWindowGc, Brush Pattern test")); + TestGcSetBrushPatternL(); + break; + case 7: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0576")); + iTest->LogSubTest(_L("CWindowGc, delete bitmap 1")); + TestGcDeleteBitmap1L(); + break; + case 8: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0577")); + iTest->LogSubTest(_L("CWindowGc, delete bitmap 2")); + TestGcDeleteBitmap2L(); + break; +#ifdef TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + case 9: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0471")); + iTest->LogSubTest(_L("Test GC clip rect and origin attributes.")); + TestGcClipRectOrigin(); + break; + case 10: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0469")); + iTest->LogSubTest(_L("CRemoteGc&CWindowGc, reset with background colour")); + TestResetWithBackgroundColorL(); + break; + case 11: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0486")); + iTest->LogSubTest(_L("CRemoteGc&MWsGraphicsContext, clipping rect test")); + TestCRemoteGcAndMWsGraphicsContextClippingRectL(); + break; + case 12: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0487")); + iTest->LogSubTest(_L("CRemoteGc, DrawTextInContext Position test")); + TestCRemoteGcDrawTextInContextPointL(); + break; + case 13: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0488")); + iTest->LogSubTest(_L("CRemoteGc, DrawTextInContext ClipRect test")); + TestCRemoteGcDrawTextInContextBoxL(); + break; + case 14: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0489")); + iTest->LogSubTest(_L("CRemoteGc, DrawTextInContext Pos Vertical test")); + TestCRemoteGcDrawTextInContextPointVerticalL(); + break; + case 15: + ((CTGcStep*)iStep)->SetTestStepID(_L("GRAPHICS-WSERV-0490")); + iTest->LogSubTest(_L("CRemoteGc, DrawTextInContext ClipRect Vert test")); + TestCRemoteGcDrawTextInContextBoxVerticalL(); + break; +#endif //TEST_GRAPHICS_WSERV_TAUTOSERVER_NGA + default: + ((CTGcStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTGcStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + } + ((CTGcStep*)iStep)->RecordTestResultL(); + } + +__CONSTRUCT_STEP__(Gc)