--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/graphicsdeviceinterface/bitgdi/tbit/TGDI.CPP Tue Feb 02 01:47:50 2010 +0200
@@ -0,0 +1,2782 @@
+// Copyright (c) 1997-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:
+// Test wrapper to bitgdi component of graphics.
+//
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+#include <tgdi.mbg>
+
+#include "TGDI.H"
+#include "TBMP.H"
+#include <bitdev.h>
+
+#define MAXCOLORS 255
+
+_LIT(KT23BitmapFileName,"z:\\system\\data\\tgdi.mbm");
+
+// TestGdi methods
+
+EXPORT_C TestGdi::TestGdi():
+ iDev(NULL),
+ iCon(NULL),
+ iSize(0,0),
+ iSection(NULL)
+ {}
+
+// This function is modified. contents are moved to below function
+EXPORT_C void TestGdi::Construct(CBitmapDevice* aDevice,CFbsBitGc* aContext,TDes& aFailureSection)
+ {
+ TRAP_IGNORE(ConstructL(aDevice, aContext, aFailureSection));
+ }
+
+// This is additional function with suffix L
+EXPORT_C void TestGdi::ConstructL(CBitmapDevice* aDevice,CFbsBitGc* aContext,TDes& aFailureSection)
+ {
+ __ASSERT_ALWAYS(aFailureSection.MaxLength() == KFailureSectionNameBufferLength,User::Panic(_L("TGDI"),KErrBadDescriptor));
+
+ iDev = aDevice;
+ iCon = aContext;
+ iSize = iDev->SizeInPixels();
+ iSection = &aFailureSection;
+
+ iCon->SetPenSize(TSize(1,1));
+ iCon->SetDrawMode(CGraphicsContext::EDrawModePEN);
+ iCon->SetPenColor(KRgbBlack);
+ iCon->SetPenStyle(CGraphicsContext::ESolidPen);
+ iCon->SetBrushColor(KRgbBlack);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+
+ iRect.iTl.iX=iSize.iWidth/3;
+ iRect.iTl.iY=iSize.iHeight/3;
+ iRect.iBr.iX=iSize.iWidth*2/3;
+ iRect.iBr.iY=iSize.iHeight*2/3;
+ iBitmapWidth=50;
+ iBitmapHeight=87;
+ iZeroRect.SetRect(iRect.iTl,iRect.iTl);
+ iUnitRect.SetRect(iRect.iTl,iRect.iTl+TPoint(1,1));
+ iUnNormRect.iTl=iRect.iBr;
+ iUnNormRect.iBr=iRect.iTl;
+ iLargeRect.SetRect(-iSize.iWidth,-iSize.iHeight,iSize.iWidth*2,iSize.iHeight*2);
+ iCentredRect.iTl=TPoint(0,0)-iRect.iTl;
+ iCentredRect.iBr=iRect.iTl;
+ for(TInt count=0;count<8;count++)
+ iOffScreenRects[count]=iRect;
+ iOffScreenRects[0].Move(-iSize.iWidth,-iSize.iHeight);
+ iOffScreenRects[1].Move(0,-iSize.iHeight);
+ iOffScreenRects[2].Move(iSize.iWidth,-iSize.iHeight);
+ iOffScreenRects[3].Move(iSize.iWidth,0);
+ iOffScreenRects[4].Move(iSize.iWidth,iSize.iHeight);
+ iOffScreenRects[5].Move(0,iSize.iHeight);
+ iOffScreenRects[6].Move(-iSize.iWidth,iSize.iHeight);
+ iOffScreenRects[7].Move(-iSize.iWidth,0);
+
+ TInt ret = iBitmap.Load(_L("z:\\system\\data\\tbmp.mbm"),EMbmTbmpTgdigen,EFalse);
+ User::LeaveIfError(ret);
+
+ ret = iBitmap2.Load(_L("z:\\system\\data\\tbmp.mbm"),EMbmTbmpTblank,EFalse);
+ User::LeaveIfError(ret);
+ }
+
+EXPORT_C TBool TestGdi::Test()
+ {
+ // Get FBSERV to create its long lived objects to avoid trigering memory leaks.
+ CFbsBitmap* srcBmp = new CFbsBitmap;
+ if (srcBmp==NULL || srcBmp->Create(iSize,EColor16MU)!=KErrNone)
+ {
+ return EFalse;
+ }
+ delete srcBmp;
+
+ CFbsBitmap* t23SrcBmp = new (ELeave) CFbsBitmap();
+ TInt ret = t23SrcBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_sourcebitmap);
+ delete t23SrcBmp;
+ if(ret != KErrNone)
+ {
+ return EFalse;
+ }
+
+ TRAPD(err,DoTestL());
+ if (err != KErrNone)
+ iSection->AppendFormat(_L(", error %d"), err);
+
+ iBitmap.Reset();
+ iBitmap2.Reset();
+
+ return err == KErrNone;
+ }
+
+void TestGdi::DoTestL()
+ {
+ *iSection = _L("Testing graphics functions");
+ CheckL(iSize!=TSize(0,0));
+ Clear();
+ TRgb col;
+ iDev->GetPixel(col,TPoint(iSize.iWidth/2,iSize.iHeight/2));
+ CheckL(col==KRgbWhite);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+ Clear();
+ CheckClearL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0001
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0001"));
+ DoArcL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0002
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0002"));
+ DoEllipseL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0003
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0003"));
+ DoRoundRectL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0004
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0004"));
+ DoPieL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0005
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0005"));
+ DoModeL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0006
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0006"));
+ DoColorL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0007
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0007"));
+ DoLineL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0008
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0008"));
+ DoWideLineL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0009
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0009"));
+ DoRectL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0010
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0010"));
+ DoPolygonArrayL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0011
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0011"));
+ DoPolygonPtrL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0012
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0012"));
+ DoPolygonPtr0();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0013
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0013"));
+ DoText();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0014
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0014"));
+ DoPaintL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0015
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0015"));
+ DoCopyL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0016
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0016"));
+ DoBltL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0017
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0017"));
+ DoBltMaskedL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0018
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0018"));
+ DoShadowL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0019
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0019"));
+ DoFadeL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0020
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0020"));
+ DoDrawBitmapSemiTransparentMaskedL();
+ RecordTestResultL();
+ // If DoDrawBitmapMaskedL causes a User Panic 21, it might be a positive failure of case #24.
+ SetTestStepID(_L("GRAPHICS-TestGdi-DoDrawBitmapMaskedL-0001"));
+ DoDrawBitmapMaskedL(ETrue);
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-TestGdi-DoDrawBitmapMaskedL-0001"));
+ DoDrawBitmapMaskedL(EFalse);
+ RecordTestResultL();
+ //test bitmap width 52 (wordalignable)
+ iBitmapWidth=52;
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0021
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0021"));
+ DoBltL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0022
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0022"));
+ DoBltMaskedL();
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-TestGdi-DoDrawBitmapMaskedL-0001"));
+ DoDrawBitmapMaskedL(ETrue);
+ RecordTestResultL();
+ SetTestStepID(_L("GRAPHICS-TestGdi-DoDrawBitmapMaskedL-0001"));
+ DoDrawBitmapMaskedL(EFalse);
+ RecordTestResultL();
+ //test with compressed bitmaps
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0023
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0023"));
+ DoBltCompressedL();
+ RecordTestResultL();
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-0024
+*/
+ SetTestStepID(_L("GRAPHICS-TestGdi-0024"));
+ DoBoxTextVertical();
+ RecordTestResultL();
+ }
+
+void TestGdi::CheckL(TBool aValue)
+ {
+ if (!aValue)
+ User::Leave(KErrGeneral);
+ }
+
+void TestGdi::Clear()
+ {
+ iCon->SetDrawMode(CGraphicsContext::EDrawModePEN);
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iCon->SetBrushColor(KRgbWhite);
+ iCon->DrawRect(TRect(TPoint(0,0),iSize));
+ iCon->SetPenStyle(CGraphicsContext::ESolidPen);
+ iCon->SetPenColor(KRgbBlack);
+ iCon->SetBrushColor(KRgbBlack);
+ }
+
+LOCAL_C void FreeAlloc(TAny* aPtr)
+ {
+ TRgb* scanline = reinterpret_cast <TRgb*> (aPtr);
+ User::Free(scanline);
+ }
+
+void TestGdi::ScanAreaL(TInt x,TInt y,TInt length,TInt height,TRgb Color)
+ {
+ if(x>iSize.iWidth)
+ return;
+ if(x<0)
+ {
+ length=length+x;
+ x=0;
+ }
+ if(x+length>iSize.iWidth)
+ length=iSize.iWidth-x;
+ if(length<=0)
+ return;
+ TRgb* scanline=(TRgb*)User::Alloc(sizeof(TRgb)*length);
+ CleanupStack::PushL(TCleanupItem(FreeAlloc, scanline));
+ TPtr8 scln((TUint8*)scanline,length*sizeof(TRgb));
+ for(TInt row=0;row<height;row++)
+ {
+ if(y+row>=0 && y+row<iSize.iHeight)
+ {
+ iDev->GetScanLine(scln,TPoint(x,y+row),length,ERgb);
+ for(TInt index=0;index<length;index++)
+ {
+ CheckL(scanline[index] == Color);
+ }
+
+ }
+ }
+ for(TInt i=0;i<height;i++)
+ {
+ scanline[i].~TRgb();
+ }
+ CleanupStack::PopAndDestroy(scanline);
+ }
+
+void TestGdi::CheckClearL()
+ {
+ TInt quarht=iSize.iHeight>>2;
+ TInt halfht=iSize.iHeight>>1;
+ TInt thrqht=quarht+halfht;
+ ScanAreaL(0,0,iSize.iWidth,1,KRgbWhite);
+ ScanAreaL(0,quarht,iSize.iWidth,quarht+1,KRgbWhite);
+ ScanAreaL(0,halfht,iSize.iWidth,halfht+1,KRgbWhite);
+ ScanAreaL(0,thrqht,iSize.iWidth,thrqht+1,KRgbWhite);
+ ScanAreaL(0,iSize.iHeight-1,iSize.iWidth,iSize.iHeight,KRgbWhite);
+ ScanAreaL(iRect.iTl.iX,iRect.iTl.iY,1,1,KRgbWhite);
+ }
+
+void TestGdi::CheckPlotL(const TPoint& pt)
+ {
+ ScanAreaL(pt.iX,pt.iY,1,1,KRgbBlack);
+ ScanAreaL(pt.iX-1,pt.iY-1,3,1,KRgbWhite);
+ ScanAreaL(pt.iX-1,pt.iY+1,3,1,KRgbWhite);
+ ScanAreaL(pt.iX-1,pt.iY,1,1,KRgbWhite);
+ ScanAreaL(pt.iX+1,pt.iY,1,1,KRgbWhite);
+ Clear();
+ }
+
+void TestGdi::CheckRectInsideL(const TRect& rect)
+ {
+ ScanAreaL(rect.iTl.iX,rect.iTl.iY,rect.iBr.iX-rect.iTl.iX,1,KRgbBlack);
+ ScanAreaL(rect.iTl.iX,rect.iBr.iY-1,rect.iBr.iX-rect.iTl.iX,1,KRgbBlack);
+ }
+
+void TestGdi::CheckRectOutsideL(const TRect& rect)
+ {
+ ScanAreaL(rect.iTl.iX-1,rect.iTl.iY-1,rect.iBr.iX-rect.iTl.iX,1,KRgbWhite);
+ ScanAreaL(rect.iTl.iX-1,rect.iBr.iY,rect.iBr.iX-rect.iTl.iX+1,1,KRgbWhite);
+ }
+
+void TestGdi::CheckQuadOutsideL(const TRect& rect)
+ {
+ ScanAreaL(rect.iTl.iX-1,rect.iTl.iY-6,rect.iBr.iX-rect.iTl.iX+1,1,KRgbWhite);
+ ScanAreaL(rect.iTl.iX-1,rect.iBr.iY-5,rect.iBr.iX-rect.iTl.iX+1,1,KRgbWhite);
+ }
+
+void TestGdi::CheckQuadInsideL(const TRect& rect)
+ {
+ if(rect.iBr.iX-rect.iTl.iX-11>0)
+ ScanAreaL(rect.iTl.iX+5,(rect.iTl.iY+rect.iBr.iY)/2,rect.iBr.iX-rect.iTl.iX-11,1,KRgbBlack);
+ }
+
+void TestGdi::DoModeL()
+ {
+ if(iDev->DisplayMode()==EGray2) return;
+ *iSection = _L("Drawing mode");
+ Clear();
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTPEN);
+ iCon->SetPenColor(KRgbWhite);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->SetPenColor(KRgbDarkGray);
+ iCon->Plot(iRect.iTl);
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeAND);
+ iCon->SetPenColor(KRgbGray);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->SetPenColor(KRgbGray);
+ iCon->Plot(iRect.iTl);
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeANDNOT);
+ iCon->SetPenColor(KRgbGray);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->Plot(iRect.iTl);
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeOR);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->Plot(iRect.iTl);
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeORNOT);
+ iCon->SetPenColor(KRgbWhite);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->SetPenColor(KRgbGray);
+ iCon->Plot(iRect.iTl);
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeXOR);
+ iCon->SetPenColor(KRgbGray);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->SetPenColor(KRgbDarkGray);
+ iCon->Plot(iRect.iTl);
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTXOR);
+ iCon->SetPenColor(KRgbGray);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTSCREEN);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTAND);
+ iCon->SetPenColor(KRgbWhite);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->Plot(iRect.iTl);
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTANDNOT);
+ iCon->SetPenColor(KRgbWhite);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTOR);
+ iCon->SetPenColor(KRgbBlack);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+
+ iCon->SetDrawMode(CGraphicsContext::EDrawModeNOTORNOT);
+ iCon->SetPenColor(KRgbWhite);
+ iCon->Plot(iRect.iTl);
+ CheckPlotL(iRect.iTl);
+ }
+
+void TestGdi::DoColorL()
+ {
+ *iSection = _L("Colors");
+ Clear();
+ for(TInt count=0;count<256;count++)
+ {
+ iCon->SetPenColor(TRgb::Gray256(count));
+ iCon->Plot(iRect.iTl);
+ TRgb screencolor;
+ iDev->GetPixel(screencolor,iRect.iTl);
+ switch(iDev->DisplayMode())
+ {
+ case EGray2:
+ CheckL(screencolor.Gray2()==count>>7);
+ break;
+ case EGray4:
+ CheckL(Abs(screencolor.Gray4()-(count>>6))<2);
+ break;
+ case EGray16:
+ if(screencolor.Gray16()!=(count>>4))
+ CheckL(Abs(screencolor.Gray4()-(count>>6))<2);
+ break;
+ case EGray256:
+ CheckL(screencolor.Gray256()==count);
+ break;
+ default:
+ break;
+ }
+ iCon->SetPenColor(KRgbWhite);
+ iCon->Plot(iRect.iTl);
+ iDev->GetPixel(screencolor,iRect.iTl);
+ CheckL(screencolor==KRgbWhite);
+ }
+ }
+
+void TestGdi::DoLineL()
+ {
+ *iSection = _L("Line drawing");
+ Clear();
+ iCon->DrawLine(iRect.iTl,iRect.iTl);
+ iCon->DrawLine(iRect.iTl,iRect.iTl+TPoint(1,1));
+ CheckPlotL(iRect.iTl);
+ Clear();
+ iCon->DrawLine(iRect.iTl,TPoint(iRect.iBr.iX,iRect.iTl.iY));
+ CheckRectInsideL(TRect(iRect.iTl,TPoint(iRect.iBr.iX,iRect.iTl.iY+1)));
+ CheckRectOutsideL(TRect(iRect.iTl,TPoint(iRect.iBr.iX,iRect.iTl.iY+1)));
+ Clear();
+ iCon->DrawLine(TPoint(-iRect.iTl.iX,iRect.iTl.iY),TPoint(iRect.iBr.iX*2,iRect.iTl.iY));
+ CheckRectInsideL(TRect(-iRect.iTl.iX,iRect.iTl.iY,iRect.iBr.iX*2,iRect.iTl.iY+1));
+ CheckRectOutsideL(TRect(-iRect.iTl.iX,iRect.iTl.iY,iRect.iBr.iX*2,iRect.iTl.iY+1));
+ Clear();
+ TInt y=iRect.iTl.iY;
+ for(;y<iRect.iBr.iY;y++)
+ iCon->DrawLine(TPoint(iRect.iTl.iX,y),TPoint(iRect.iBr.iX,y));
+ CheckRectInsideL(iRect);
+ CheckRectOutsideL(iRect);
+ Clear();
+ for(TInt count=0;count<8;count++)
+ for(y=iOffScreenRects[count].iBr.iY;y<iOffScreenRects[count].iTl.iY;y++)
+ iCon->DrawLine(TPoint(iOffScreenRects[count].iTl.iX,y),TPoint(iOffScreenRects[count].iBr.iX,y));
+ CheckClearL();
+ iCon->SetPenSize(TSize(100,100));
+ iCon->DrawLine(TPoint(iRect.iTl.iX,iRect.iTl.iY),TPoint(iRect.iBr.iX,iRect.iTl.iY));
+ CheckRectInsideL(TRect(iRect.iTl.iX+50,iRect.iTl.iY-49,iRect.iBr.iX-50,iRect.iTl.iY+50));
+ CheckRectOutsideL(TRect(iRect.iTl.iX,iRect.iTl.iY-49,iRect.iBr.iX,iRect.iTl.iY+51));
+ Clear();
+ iCon->DrawLine(TPoint(-iRect.iTl.iX,iRect.iTl.iY),TPoint(iRect.iBr.iX*2,iRect.iTl.iY));
+ CheckRectInsideL(TRect(-iRect.iTl.iX,iRect.iTl.iY-49,iRect.iBr.iX*2,iRect.iTl.iY+50));
+ CheckRectOutsideL(TRect(-iRect.iTl.iX,iRect.iTl.iY-49,iRect.iBr.iX*2,iRect.iTl.iY+51));
+ Clear();
+ iCon->SetPenSize(TSize(1,1));
+ }
+
+void TestGdi::DoWideLineL()
+ {
+ *iSection = _L("Wide Line drawing");
+
+ Clear();
+ iCon->SetPenStyle(CFbsBitGc::ESolidPen);
+ iCon->SetPenColor(KRgbBlack);
+ iCon->SetPenSize(TSize(4,4));
+ TPoint pos(-24,10);
+ TSize size(288,216);
+
+ // Black arrow, pointing up.
+ TPoint midLeft(pos.iX, size.iHeight / 2 + pos.iY);
+ TPoint midTop(pos.iX + size.iWidth / 2, pos.iY);
+ TPoint midRight(size.iWidth, size.iHeight / 2 + pos.iY);
+ TPoint midBottom(pos.iX + size.iWidth / 2, size.iHeight);
+ iCon->DrawLine(midLeft, midTop);
+ iCon->DrawLine(midTop, midRight);
+ iCon->DrawLine(midTop, midBottom);
+
+ // Check halfway along left side of arrowhead
+ TPoint checkPt(midLeft);
+ checkPt += midTop;
+ checkPt.iX /= 2;
+ checkPt.iY /= 2;
+ TRgb pixel;
+ iDev->GetPixel(pixel, checkPt);
+ if (pixel.Internal() != KRgbBlack.Internal())
+ {
+ User::Panic(_L("Line not found!"), 1);
+ }
+
+ Clear();
+ iCon->SetPenSize(TSize(1,1));
+ }
+
+void TestGdi::DoArcL()
+ {
+ *iSection = _L("Arcs");
+ Clear();
+ iCon->DrawArc(iRect,iRect.iTl,iRect.iTl);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->DrawArc(iLargeRect,iRect.iTl,iRect.iTl);
+ iCon->DrawArc(iUnNormRect,iRect.iTl,iRect.iTl);
+ CheckClearL();
+ iCon->DrawArc(iCentredRect,iCentredRect.iTl,iCentredRect.iTl);
+ Clear();
+ TInt count=0;
+ for(;count<8;count++)
+ iCon->DrawArc(iOffScreenRects[count],iOffScreenRects[count].iTl,iOffScreenRects[count].iTl);
+ CheckClearL();
+ #include "TGDIGEN.H"
+ for(count=0;count<numellipses;count++)
+ iCon->DrawArc(ellrect[count],ellrect[count].iTl,ellrect[count].iTl);
+ TSize size=iBitmap.SizeInPixels();
+ if(size.iWidth>iSize.iWidth)
+ size.iWidth=iSize.iWidth;
+ if(size.iHeight>iSize.iHeight)
+ size.iHeight=iSize.iHeight;
+ for(TInt yy=0;yy<size.iHeight>>1;yy++)
+ {
+ for(TInt xx=0;xx<size.iWidth>>1;xx++)
+ {
+ TPoint pt(xx,yy);
+ TRgb bmprgb,scrrgb;
+ iBitmap.GetPixel(bmprgb,pt);
+ iDev->GetPixel(scrrgb,pt);
+ if(bmprgb==KRgbBlack)
+ CheckL(scrrgb==KRgbBlack);
+ }
+ }
+ }
+
+void TestGdi::DoRectL()
+ {
+ *iSection = _L("Rectangles");
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawRect(iRect);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iCon->DrawRect(iRect);
+ CheckRectInsideL(iRect);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iCon->DrawRect(iRect);
+ CheckRectInsideL(iRect);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->DrawRect(iUnitRect);
+ CheckPlotL(iUnitRect.iTl);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawRect(iUnitRect);
+ CheckPlotL(iUnitRect.iTl);
+ Clear();
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->DrawRect(iUnitRect);
+ CheckPlotL(iUnitRect.iTl);
+ Clear();
+ iCon->DrawRect(iCentredRect);
+ CheckRectInsideL(iCentredRect);
+ CheckRectOutsideL(iCentredRect);
+ Clear();
+ iCon->DrawRect(iZeroRect);
+ iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iCon->DrawRect(iZeroRect);
+ iCon->DrawRect(iUnNormRect);
+ for(TInt count=0;count<8;count++)
+ iCon->DrawRect(iOffScreenRects[count]);
+ CheckClearL();
+ iCon->DrawRect(TRect(iRect.iTl.iX/2,iRect.iTl.iY,iRect.iTl.iX,iRect.iBr.iY));
+ iCon->CopyRect(TPoint(iSize.iWidth/2,iSize.iHeight/6),TRect(iRect.iTl.iX/2,iRect.iTl.iY,iRect.iTl.iX,iRect.iBr.iY));
+ CheckRectInsideL(TRect(iRect.iTl.iX/2+iSize.iWidth/2,iRect.iTl.iY+iSize.iHeight/6,iRect.iTl.iX+iSize.iWidth/2,iRect.iBr.iY+iSize.iHeight/6));
+ CheckRectOutsideL(TRect(iRect.iTl.iX/2+iSize.iWidth/2,iRect.iTl.iY+iSize.iHeight/6,iRect.iTl.iX+iSize.iWidth/2,iRect.iBr.iY+iSize.iHeight/6));
+ Clear();
+ }
+
+void TestGdi::DoEllipseL()
+ {
+ *iSection = _L("Ellipses");
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawEllipse(iRect);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->DrawEllipse(iRect);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->DrawEllipse(iRect);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->DrawEllipse(iLargeRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->DrawEllipse(iCentredRect);
+ CheckQuadInsideL(iCentredRect);
+ CheckRectOutsideL(iCentredRect);
+ Clear();
+ iCon->DrawEllipse(iUnNormRect);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawEllipse(iLargeRect);
+ TInt count=0;
+ for(;count<8;count++)
+ iCon->DrawEllipse(iOffScreenRects[count]);
+ CheckClearL();
+ #include "TGDIGEN.H"
+ for(count=0;count<numellipses;count++)
+ iCon->DrawEllipse(ellrect[count]);
+ TSize size=iBitmap.SizeInPixels();
+ if(size.iWidth>iSize.iWidth)
+ size.iWidth=iSize.iWidth;
+ if(size.iHeight>iSize.iHeight)
+ size.iHeight=iSize.iHeight;
+ for(TInt yy=0;yy<size.iHeight>>1;yy++)
+ {
+ for(TInt xx=0;xx<size.iWidth>>1;xx++)
+ {
+ TPoint pt(xx,yy);
+ TRgb bmprgb,scrrgb;
+ iBitmap.GetPixel(bmprgb,pt);
+ iDev->GetPixel(scrrgb,pt);
+ if(bmprgb==KRgbBlack)
+ CheckL(scrrgb==KRgbBlack);
+ }
+ }
+ }
+
+void TestGdi::DoPieL()
+ {
+ *iSection = _L("Pie segments");
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPie(iRect,iRect.iTl,iRect.iTl);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->DrawPie(iRect,iRect.iTl,iRect.iTl);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->DrawPie(iRect,iRect.iTl,iRect.iTl);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->DrawPie(iLargeRect,iRect.iTl,iRect.iTl);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->DrawPie(iCentredRect,iCentredRect.iTl,iCentredRect.iTl);
+ CheckQuadInsideL(iCentredRect);
+ CheckRectOutsideL(iCentredRect);
+ Clear();
+ iCon->DrawPie(iUnNormRect,iRect.iTl,iRect.iTl);
+ TInt count=0;
+ for(;count<8;count++)
+ iCon->DrawPie(iOffScreenRects[count],iOffScreenRects[count].iTl,iOffScreenRects[count].iTl);
+ CheckClearL();
+ #include "TGDIGEN.H"
+ for(count=0;count<numellipses;count++)
+ iCon->DrawPie(ellrect[count],ellrect[count].iTl,ellrect[count].iTl);
+ TSize size=iBitmap.SizeInPixels();
+ if(size.iWidth>iSize.iWidth)
+ size.iWidth=iSize.iWidth;
+ if(size.iHeight>iSize.iHeight)
+ size.iHeight=iSize.iHeight;
+ for(TInt yy=0;yy<size.iHeight>>1;yy++)
+ {
+ for(TInt xx=0;xx<size.iWidth>>1;xx++)
+ {
+ TPoint pt(xx,yy);
+ TRgb bmprgb,scrrgb;
+ iBitmap.GetPixel(bmprgb,pt);
+ iDev->GetPixel(scrrgb,pt);
+ if(bmprgb==KRgbBlack)
+ CheckL(scrrgb==KRgbBlack);
+ }
+ }
+ }
+
+void TestGdi::DoRoundRectL()
+ {
+ *iSection = _L("RoundRects");
+ TSize rrsize(20,10);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawRoundRect(iRect,rrsize);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->DrawRoundRect(iRect,rrsize);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->DrawRoundRect(iRect,rrsize);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->DrawRoundRect(iLargeRect,rrsize);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->DrawRoundRect(iCentredRect,rrsize);
+ CheckQuadInsideL(iCentredRect);
+ CheckRectOutsideL(iCentredRect);
+ Clear();
+ iCon->DrawRoundRect(iUnNormRect,rrsize);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawRoundRect(iLargeRect,rrsize);
+ TInt count=0;
+ for(;count<8;count++)
+ iCon->DrawRoundRect(iOffScreenRects[count],rrsize);
+ CheckClearL();
+ #include "TGDIGEN.H"
+ for(count=0;count<numellipses;count++)
+ iCon->DrawRoundRect(ellrect[count],TSize((ellrect[count].iBr.iX-ellrect[count].iTl.iX)>>1,(ellrect[count].iBr.iY-ellrect[count].iTl.iY)>>1));
+ TSize size=iBitmap.SizeInPixels();
+ if(size.iWidth>iSize.iWidth)
+ size.iWidth=iSize.iWidth;
+ if(size.iHeight>iSize.iHeight)
+ size.iHeight=iSize.iHeight;
+ for(TInt yy=0;yy<size.iHeight>>1;yy++)
+ {
+ for(TInt xx=0;xx<size.iWidth>>1;xx++)
+ {
+ TPoint pt(xx,yy);
+ TRgb bmprgb,scrrgb;
+ iDev->GetPixel(scrrgb,pt);
+ pt.iY+=size.iHeight>>1;
+ iBitmap.GetPixel(bmprgb,pt);
+ if(bmprgb==KRgbBlack)
+ CheckL(scrrgb==KRgbBlack);
+ }
+ }
+ }
+
+void TestGdi::DoPolygonArrayL()
+ {
+ *iSection = _L("Polygon array");
+
+ CArrayFixFlat<TPoint>* poly=new CArrayFixFlat<TPoint>(4);
+ poly->AppendL(iRect.iTl);
+ TPoint temp(iRect.iBr.iX-1,iRect.iTl.iY);
+ poly->AppendL(temp);
+ temp.SetXY(iRect.iBr.iX-1,iRect.iBr.iY-1);
+ poly->AppendL(temp);
+ temp.SetXY(iRect.iTl.iX,iRect.iBr.iY-1);
+ poly->AppendL(temp);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->DrawPolygon(poly);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->DrawPolygon(poly);
+ delete poly;
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+
+ poly=new CArrayFixFlat<TPoint>(4);
+ poly->AppendL(iLargeRect.iTl);
+ temp.SetXY(iLargeRect.iBr.iX-1,iLargeRect.iTl.iY);
+ poly->AppendL(temp);
+ temp.SetXY(iLargeRect.iBr.iX-1,iLargeRect.iBr.iY-1);
+ poly->AppendL(temp);
+ temp.SetXY(iLargeRect.iTl.iX,iLargeRect.iBr.iY-1);
+ poly->AppendL(temp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly);
+ CheckClearL();
+ Clear();
+ iCon->DrawPolygon(poly);
+ delete poly;
+ CheckQuadInsideL(iRect);
+ Clear();
+
+ poly=new CArrayFixFlat<TPoint>(4);
+ temp.SetXY(iUnNormRect.iTl.iX-1,iUnNormRect.iTl.iY-1);
+ poly->AppendL(temp);
+ temp.SetXY(iUnNormRect.iBr.iX,iUnNormRect.iTl.iY-1);
+ poly->AppendL(temp);
+ poly->AppendL(iUnNormRect.iBr);
+ temp.SetXY(iUnNormRect.iTl.iX-1,iUnNormRect.iBr.iY);
+ poly->AppendL(temp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->DrawPolygon(poly);
+ delete poly;
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+
+ poly=new CArrayFixFlat<TPoint>(4);
+ poly->AppendL(iCentredRect.iTl);
+ temp.SetXY(iCentredRect.iBr.iX-1,iCentredRect.iTl.iY);
+ poly->AppendL(temp);
+ temp.SetXY(iCentredRect.iBr.iX-1,iCentredRect.iBr.iY-1);
+ poly->AppendL(temp);
+ temp.SetXY(iCentredRect.iTl.iX,iCentredRect.iBr.iY-1);
+ poly->AppendL(temp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly);
+ CheckRectOutsideL(iCentredRect);
+ Clear();
+ iCon->DrawPolygon(poly);
+ delete poly;
+ CheckRectOutsideL(iCentredRect);
+ CheckQuadInsideL(iCentredRect);
+ Clear();
+
+ for(TInt count=0;count<8;count++)
+ {
+ poly=new CArrayFixFlat<TPoint>(4);
+ poly->AppendL(iOffScreenRects[count].iTl);
+ temp.SetXY(iOffScreenRects[count].iBr.iX,iOffScreenRects[count].iTl.iY);
+ poly->AppendL(temp);
+ poly->AppendL(iOffScreenRects[count].iBr);
+ temp.SetXY(iOffScreenRects[count].iTl.iX,iOffScreenRects[count].iBr.iY);
+ poly->AppendL(temp);
+ iCon->DrawPolygon(poly);
+ delete poly;
+ }
+
+ poly=new CArrayFixFlat<TPoint>(4);
+ const TInt offset = 10000;
+ const TInt size = 50;
+ TRect ppRect(0,0,size + 1,size + 1);
+ TPoint pp(offset,offset);
+ poly->AppendL(pp);
+ pp.iX += size;
+ poly->AppendL(pp);
+ pp.iY += size;
+ poly->AppendL(pp);
+ pp.iX -= size;
+ poly->AppendL(pp);
+ Clear();
+ iCon->SetOrigin(TPoint(-offset,-offset));
+ iCon->DrawPolygon(poly);
+ iCon->SetOrigin(TPoint(0,0));
+ delete poly;
+ CheckRectOutsideL(ppRect);
+ CheckQuadInsideL(ppRect);
+ Clear();
+
+ CheckClearL();
+ }
+
+void TestGdi::DoPolygonPtr0()
+ {
+ *iSection = _L("Polygon ptr 0 points");
+
+ TPoint poly[4];
+ poly[0] = iRect.iTl;
+ poly[1].SetXY(iRect.iBr.iX-1,iRect.iTl.iY);
+ poly[2].SetXY(iRect.iBr.iX-1,iRect.iBr.iY-1);
+ poly[3].SetXY(iRect.iTl.iX,iRect.iBr.iY-1);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly,0);
+ iCon->DrawPolygon(poly,0);
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->DrawPolygon(poly,0);
+
+ poly[0] = iLargeRect.iTl;
+ poly[1].SetXY(iLargeRect.iBr.iX-1,iLargeRect.iTl.iY);
+ poly[2].SetXY(iLargeRect.iBr.iX-1,iLargeRect.iBr.iY-1);
+ poly[3].SetXY(iLargeRect.iTl.iX,iLargeRect.iBr.iY-1);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly,0);
+ iCon->DrawPolygon(poly,0);
+
+ poly[0].SetXY(iUnNormRect.iTl.iX-1,iUnNormRect.iTl.iY-1);
+ poly[1].SetXY(iUnNormRect.iBr.iX,iUnNormRect.iTl.iY-1);
+ poly[2] = iUnNormRect.iBr;
+ poly[3].SetXY(iUnNormRect.iTl.iX-1,iUnNormRect.iBr.iY);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly,0);
+ iCon->DrawPolygon(poly,0);
+
+ poly[0] = iCentredRect.iTl;
+ poly[1].SetXY(iCentredRect.iBr.iX-1,iCentredRect.iTl.iY);
+ poly[2].SetXY(iCentredRect.iBr.iX-1,iCentredRect.iBr.iY-1);
+ poly[3].SetXY(iCentredRect.iTl.iX,iCentredRect.iBr.iY-1);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly,0);
+ iCon->DrawPolygon(poly,0);
+
+ for(TInt count=0;count<8;count++)
+ {
+ poly[0] = iOffScreenRects[count].iTl;
+ poly[1].SetXY(iOffScreenRects[count].iBr.iX,iOffScreenRects[count].iTl.iY);
+ poly[2] = iOffScreenRects[count].iBr;
+ poly[3].SetXY(iOffScreenRects[count].iTl.iX,iOffScreenRects[count].iBr.iY);
+ iCon->DrawPolygon(poly,0);
+ }
+
+ const TInt offset = 10000;
+ const TInt size = 50;
+ TPoint pp(offset,offset);
+ poly[0] = pp;
+ pp.iX += size;
+ poly[1] = pp;
+ pp.iY += size;
+ poly[2] = pp;
+ pp.iX -= size;
+ poly[3] = pp;
+ iCon->SetOrigin(TPoint(-offset,-offset));
+ iCon->DrawPolygon(poly,0);
+ iCon->SetOrigin(TPoint(0,0));
+
+ poly[0] = iRect.iTl;
+ poly[1].SetXY(iRect.iBr.iX-1,iRect.iTl.iY);
+ poly[2].SetXY(iRect.iBr.iX-1,iRect.iBr.iY-1);
+ poly[3].SetXY(iRect.iTl.iX,iRect.iBr.iY-1);
+ iCon->DrawPolygon(NULL,4);
+ iCon->DrawPolygon(poly,0);
+ iCon->DrawPolygon(NULL,0);
+ TPoint *ptr=(TPoint *)0x1111;
+ iCon->DrawPolygon(ptr,0);
+ iCon->DrawPolygon(NULL,4,CGraphicsContext::EWinding );
+ iCon->DrawPolygon(poly,0,CGraphicsContext::EWinding );
+ iCon->DrawPolygon(NULL,0,CGraphicsContext::EWinding );
+ iCon->DrawPolygon(ptr,0,CGraphicsContext::EWinding );
+ }
+
+void TestGdi::DoPolygonPtrL()
+ {
+ *iSection = _L("Polygon ptr");
+
+ TPoint poly[4];
+ poly[0] = iRect.iTl;
+ poly[1].SetXY(iRect.iBr.iX-1,iRect.iTl.iY);
+ poly[2].SetXY(iRect.iBr.iX-1,iRect.iBr.iY-1);
+ poly[3].SetXY(iRect.iTl.iX,iRect.iBr.iY-1);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly,4);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->DrawPolygon(poly,4);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->DrawPolygon(poly,4);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+
+ poly[0] = iLargeRect.iTl;
+ poly[1].SetXY(iLargeRect.iBr.iX-1,iLargeRect.iTl.iY);
+ poly[2].SetXY(iLargeRect.iBr.iX-1,iLargeRect.iBr.iY-1);
+ poly[3].SetXY(iLargeRect.iTl.iX,iLargeRect.iBr.iY-1);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly,4);
+ CheckClearL();
+ Clear();
+ iCon->DrawPolygon(poly,4);
+ CheckQuadInsideL(iRect);
+ Clear();
+
+ poly[0].SetXY(iUnNormRect.iTl.iX-1,iUnNormRect.iTl.iY-1);
+ poly[1].SetXY(iUnNormRect.iBr.iX,iUnNormRect.iTl.iY-1);
+ poly[2] = iUnNormRect.iBr;
+ poly[3].SetXY(iUnNormRect.iTl.iX-1,iUnNormRect.iBr.iY);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly,4);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->DrawPolygon(poly,4);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+
+ poly[0] = iCentredRect.iTl;
+ poly[1].SetXY(iCentredRect.iBr.iX-1,iCentredRect.iTl.iY);
+ poly[2].SetXY(iCentredRect.iBr.iX-1,iCentredRect.iBr.iY-1);
+ poly[3].SetXY(iCentredRect.iTl.iX,iCentredRect.iBr.iY-1);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawPolygon(poly,4);
+ CheckRectOutsideL(iCentredRect);
+ Clear();
+ iCon->DrawPolygon(poly,4);
+ CheckRectOutsideL(iCentredRect);
+ CheckQuadInsideL(iCentredRect);
+ Clear();
+
+ for(TInt count=0;count<8;count++)
+ {
+ poly[0] = iOffScreenRects[count].iTl;
+ poly[1].SetXY(iOffScreenRects[count].iBr.iX,iOffScreenRects[count].iTl.iY);
+ poly[2] = iOffScreenRects[count].iBr;
+ poly[3].SetXY(iOffScreenRects[count].iTl.iX,iOffScreenRects[count].iBr.iY);
+ iCon->DrawPolygon(poly,4);
+ }
+
+ const TInt offset = 10000;
+ const TInt size = 50;
+ TRect ppRect(0,0,size + 1,size + 1);
+ TPoint pp(offset,offset);
+ poly[0] = pp;
+ pp.iX += size;
+ poly[1] = pp;
+ pp.iY += size;
+ poly[2] = pp;
+ pp.iX -= size;
+ poly[3] = pp;
+ Clear();
+ iCon->SetOrigin(TPoint(-offset,-offset));
+ iCon->DrawPolygon(poly,4);
+ iCon->SetOrigin(TPoint(0,0));
+ CheckRectOutsideL(ppRect);
+ CheckQuadInsideL(ppRect);
+ Clear();
+
+ poly[0] = iRect.iTl;
+ poly[1].SetXY(iRect.iBr.iX-1,iRect.iTl.iY);
+ poly[2].SetXY(iRect.iBr.iX-1,iRect.iBr.iY-1);
+ poly[3].SetXY(iRect.iTl.iX,iRect.iBr.iY-1);
+ iCon->DrawPolygon(NULL,4);
+ Clear();
+ iCon->DrawPolygon(poly,0);
+ Clear();
+ iCon->DrawPolygon(NULL,0);
+ Clear();
+ TPoint *ptr=(TPoint *)0x1111;
+ iCon->DrawPolygon(ptr,0);
+ Clear();
+ iCon->DrawPolygon(NULL,4,CGraphicsContext::EWinding );
+ Clear();
+ iCon->DrawPolygon(poly,0,CGraphicsContext::EWinding );
+ Clear();
+ iCon->DrawPolygon(NULL,0,CGraphicsContext::EWinding );
+ Clear();
+ iCon->DrawPolygon(ptr,0,CGraphicsContext::EWinding );
+ Clear();
+
+ CheckClearL();
+ }
+
+void TestGdi::DoText()
+ {
+ *iSection = _L("Text");
+ Clear();
+ iCon->DrawText(_L("Text printing..."),TPoint(0,iRect.iTl.iY));
+ iCon->DrawText(_L("Text printing..."),TPoint(0,iRect.iBr.iY));
+ Clear();
+ iCon->DrawText(_L("Out of bounds checking"),TPoint(-50,iRect.iBr.iY>>1));
+ iCon->DrawText(_L("Out of bounds checking"),TPoint(0,0));
+ iCon->DrawText(_L("Out of bounds checking"),TPoint(0,iRect.iBr.iY));
+ iCon->DrawText(_L("Out of bounds checking"),TPoint(iRect.iBr.iX,iRect.iBr.iY>>1));
+ }
+
+void TestGdi::DoBoxTextVertical()
+ {
+ Clear();
+
+ // Creates a font large enough to notice the text on screen
+ _LIT(KMyFontName,"Swiss");
+ CFont* myFont = NULL;
+ TFontSpec myFontSpec(KMyFontName,15);
+ User::LeaveIfError(iDev->GetNearestFontInPixels(myFont,myFontSpec));
+ iCon->UseFont(myFont);
+
+ TInt boxWidth = iSize.iWidth/4;
+ TInt boxHeightOffset = iSize.iHeight-5;
+
+ TRect box1 (5, 5, boxWidth-5, boxHeightOffset);
+ TRect box2 (boxWidth+5, 5, 2*boxWidth-5, boxHeightOffset);
+ TRect box3 (2*boxWidth+5, 5, 3*boxWidth-5, boxHeightOffset);
+ TRect box4 (3*boxWidth+5, 5, iSize.iWidth-25-2*myFont->HeightInPixels(), boxHeightOffset);
+ TRect box5 (iSize.iWidth-15-2*myFont->HeightInPixels(), 5, iSize.iWidth-15-myFont->HeightInPixels(), boxHeightOffset);
+ TRect box6 (iSize.iWidth-5-myFont->HeightInPixels(), 5, iSize.iWidth-5, boxHeightOffset);
+
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->SetPenStyle(CGraphicsContext::ESolidPen);
+ iCon->DrawRect(box1);
+ iCon->DrawRect(box2);
+ iCon->DrawRect(box3);
+ iCon->DrawRect(box4);
+ iCon->DrawRect(box5);
+ iCon->DrawRect(box6);
+
+ /* Text drawn when baseline = font ascent.
+ Expected result: The top of the text will be aligned with the borders of the
+ box.
+ */
+ // Upper right corner of the box
+ iCon->SetPenColor(KRgbRed);
+ iCon->DrawTextVertical(_L("Testing"), box1, myFont->AscentInPixels() , EFalse, CGraphicsContext::ELeft);
+ // Lower right corner of the box
+ iCon->SetPenColor(KRgbBlue);
+ iCon->DrawTextVertical(_L("Testing"), box1, myFont->AscentInPixels() , EFalse, CGraphicsContext::ERight);
+ // Upper left corner of the box
+ iCon->SetPenColor(KRgbGreen);
+ iCon->DrawTextVertical(_L("Testing"), box1, myFont->AscentInPixels() , ETrue, CGraphicsContext::ERight);
+ // Lower right corner of the box
+ iCon->SetPenColor(KRgbBlack);
+ iCon->DrawTextVertical(_L("Testing"), box1, myFont->AscentInPixels() , ETrue, CGraphicsContext::ELeft);
+
+ /* Text drawn when baseline = 0.
+ Expected result: The text will be hidden in this case as it is drawn outside
+ the borders of the box. Only the parts in the font descent will be shown.
+ */
+ iCon->SetPenColor(KRgbRed);
+ iCon->DrawTextVertical(_L("Testing"), box2, 0, EFalse, CGraphicsContext::ELeft);
+ iCon->SetPenColor(KRgbBlue);
+ iCon->DrawTextVertical(_L("Testing"), box2, 0, EFalse, CGraphicsContext::ERight);
+ iCon->SetPenColor(KRgbGreen);
+ iCon->DrawTextVertical(_L("Testing"), box2, 0, ETrue, CGraphicsContext::ERight);
+ iCon->SetPenColor(KRgbBlack);
+ iCon->DrawTextVertical(_L("Testing"), box2, 0, ETrue, CGraphicsContext::ELeft);
+
+ /* Text drawn when baseline = box width.
+ Expected results: Text will be drawn on the side of the opposite edge and its
+ descent part will be hidden.
+ */
+ iCon->SetPenColor(KRgbRed);
+ iCon->DrawTextVertical(_L("Testing"), box3, box3.Width(), EFalse, CGraphicsContext::ELeft);
+ iCon->SetPenColor(KRgbBlue);
+ iCon->DrawTextVertical(_L("Testing"), box3, box3.Width(), EFalse, CGraphicsContext::ERight);
+ iCon->SetPenColor(KRgbGreen);
+ iCon->DrawTextVertical(_L("Testing"), box3, box3.Width(), ETrue, CGraphicsContext::ERight);
+ iCon->SetPenColor(KRgbBlack);
+ iCon->DrawTextVertical(_L("Testing"), box3, box3.Width(), ETrue, CGraphicsContext::ELeft);
+
+ /* Text drawn when baseline = box width + font ascent.
+ Expected result: text will not be shown at all as it lies outside the box totally.
+ */
+ iCon->SetPenColor(KRgbRed);
+ iCon->DrawTextVertical(_L("Testing"), box4, box4.Width() + myFont->AscentInPixels(), EFalse, CGraphicsContext::ELeft);
+ iCon->SetPenColor(KRgbBlue);
+ iCon->DrawTextVertical(_L("Testing"), box4, box4.Width() + myFont->AscentInPixels(), EFalse, CGraphicsContext::ERight);
+ iCon->SetPenColor(KRgbGreen);
+ iCon->DrawTextVertical(_L("Testing"), box4, box4.Width() + myFont->AscentInPixels(), ETrue, CGraphicsContext::ERight);
+ iCon->SetPenColor(KRgbBlack);
+ iCon->DrawTextVertical(_L("Testing"), box4, box4.Width() + myFont->AscentInPixels(), ETrue, CGraphicsContext::ELeft);
+
+ /* Text drawn when baseline = font ascent while the width of teh box = font height
+ Expected result: text will be aligned in the center of the box
+ */
+ iCon->SetPenColor(KRgbRed);
+ iCon->DrawTextVertical(_L("Testing"), box5, myFont->AscentInPixels(), EFalse, CGraphicsContext::ELeft);
+ iCon->SetPenColor(KRgbBlack);
+ iCon->DrawTextVertical(_L("Testing"), box5, myFont->AscentInPixels(), EFalse, CGraphicsContext::ERight);
+ iCon->SetPenColor(KRgbRed);
+ iCon->DrawTextVertical(_L("Testing"), box6, myFont->AscentInPixels(), ETrue, CGraphicsContext::ELeft);
+ iCon->SetPenColor(KRgbBlack);
+ iCon->DrawTextVertical(_L("Testing"), box6, myFont->AscentInPixels(), ETrue, CGraphicsContext::ERight);
+
+ iCon->DiscardFont();
+ iDev->ReleaseFont(myFont);
+ }
+
+void TestGdi::DoPaintL()
+ {
+ *iSection = _L("Painting");
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ iCon->DrawRect(iRect);
+ CheckRectInsideL(iRect);
+ CheckRectOutsideL(iRect);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ iCon->DrawRect(iCentredRect);
+ CheckRectInsideL(iCentredRect);
+ CheckRectOutsideL(iCentredRect);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ for(TInt count=0;count<8;count++)
+ iCon->DrawRect(iOffScreenRects[count]);
+ CheckClearL();
+ iCon->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ iCon->DrawEllipse(iRect);
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ iCon->DrawRoundRect(iRect,TSize(20,10));
+ CheckRectOutsideL(iRect);
+ CheckQuadInsideL(iRect);
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ iCon->DrawRect(iLargeRect);
+ CheckRectInsideL(TRect(TPoint(0,0),iSize));
+ CheckQuadInsideL(TRect(TPoint(0,0),iSize));
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ iCon->DrawEllipse(iLargeRect);
+ CheckQuadInsideL(TRect(TPoint(0,0),iSize));
+ Clear();
+ iCon->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ iCon->DrawRoundRect(iLargeRect,TSize(20,10));
+ CheckQuadInsideL(TRect(TPoint(0,0),iSize));
+ Clear();
+ }
+
+void TestGdi::DoCopyL()
+ {
+ *iSection = _L("Copying");
+ Clear();
+ TInt a=iSize.iWidth;
+ TInt b=iSize.iHeight;
+ TInt c=a>>1;
+ TInt d=b>>1;
+ iCon->CopyRect(TPoint(-100,-100),TRect(-100,-100,-50,-50));
+ iCon->CopyRect(TPoint(100,100),TRect(-100,-100,-50,-50));
+ iCon->CopyRect(TPoint(100,100),TRect(-50,-50,50,50));
+ iCon->CopyRect(TPoint(-100,-100),TRect(-50,-50,50,50));
+ iCon->CopyRect(TPoint(-50,-50),TRect(0,0,50,50));
+ iCon->CopyRect(TPoint(1000,1000),TRect(0,0,50,50));
+ Clear();
+
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->SetBrushStyle(CGraphicsContext::EPatternedBrush);
+ TRect center(c-10,d-10,c+10,d+10);
+ iCon->DrawRect(center);
+ iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);
+
+ iCon->CopyRect(TPoint(0,-25),center);
+ iCon->CopyRect(TPoint(25,-25),center);
+ iCon->CopyRect(TPoint(25,0),center);
+ iCon->CopyRect(TPoint(25,25),center);
+ iCon->CopyRect(TPoint(0,25),center);
+ iCon->CopyRect(TPoint(-25,25),center);
+ iCon->CopyRect(TPoint(-25,0),center);
+ iCon->CopyRect(TPoint(-25,-25),center);
+
+ for(TInt y=0;y<20;y++)
+ for(TInt x=0;x<20;x++)
+ {
+ TRgb pelcol;
+ iDev->GetPixel(pelcol,TPoint(c-10+x,d-10+y)); // centre
+ TRgb samplecol;
+ iDev->GetPixel(samplecol,TPoint(c-10+x,d-35+y)); // top
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(c+15+x,d-35+y)); // top right
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(c+15+x,d-10+y)); // right
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(c+15+x,d+15+y)); // bottom right
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(c-10+x,d+15+y)); // bottom
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(c-35+x,d+15+y)); // bottom left
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(c-35+x,d-10+y)); // left
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(c-35+x,d-35+y)); // top left
+ CheckL(samplecol==pelcol);
+ }
+ Clear();
+ }
+
+void TestGdi::DoBltL()
+ {
+ *iSection = _L("BitBlt");
+ TRect sample(0,0,8,8);
+ Clear();
+ TInt a=iSize.iWidth;
+ TInt b=iSize.iHeight;
+ TInt c=a>>1;
+ TInt d=b>>1;
+ iCon->BitBlt(TPoint(20,20),&iBitmap2,sample);
+ iCon->BitBlt(TPoint(c-20,20),&iBitmap2,sample);
+ iCon->BitBlt(TPoint(a-20,20),&iBitmap2,sample);
+ iCon->BitBlt(TPoint(a-20,d-20),&iBitmap2,sample);
+ iCon->BitBlt(TPoint(a-20,b-20),&iBitmap2,sample);
+ iCon->BitBlt(TPoint(c-20,b-20),&iBitmap2,sample);
+ iCon->BitBlt(TPoint(20,b-20),&iBitmap2,sample);
+ iCon->BitBlt(TPoint(20,d-20),&iBitmap2,sample);
+ iCon->SetBrushOrigin(TPoint(c-20,d-20));
+ iCon->DrawRect(TRect(c-20,d-20,c+20,d+20));
+ for(TInt y=0;y<8;y++)
+ for(TInt x=0;x<8;x++)
+ {
+ TRgb pelcol,samplecol;
+ iDev->GetPixel(pelcol,TPoint(c-20+x,d-20+y));
+ iDev->GetPixel(samplecol,TPoint(20+x,20+y));
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(c-20+x,20+y));
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(a-20+x,20+y));
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(a-20+x,d-20+y));
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(a-20+x,b-20+y));
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(c-20+x,b-20+y));
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(20+x,b-20+y));
+ CheckL(samplecol==pelcol);
+ iDev->GetPixel(samplecol,TPoint(20+x,d-20+y));
+ CheckL(samplecol==pelcol);
+ }
+ Clear();
+ for(TInt count=0;count<8;count++)
+ iCon->BitBlt(iOffScreenRects[count].iTl,&iBitmap2,sample);
+ CheckClearL();
+ }
+
+void TestGdi::DoBltMaskedL()
+ {
+ *iSection = _L("BitBltMasked");
+ TSize bmpsize(iBitmap.SizeInPixels());
+ TRect bmprect(bmpsize);
+ TInt x,y;
+ TRgb bmpcol,samplecol;
+
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ iCon->SetBrushColor(KRgbBlack);
+ iCon->Clear();
+ iCon->BitBltMasked(TPoint(0,0),&iBitmap,bmprect,&iBitmap,ETrue);
+ for(y=0;y<bmprect.iBr.iY;y++)
+ {
+ for(x=0;x<bmprect.iBr.iX;x++)
+ {
+ iBitmap.GetPixel(bmpcol,TPoint(x,y));
+ iDev->GetPixel(samplecol,TPoint(x,y));
+ if(bmpcol.Gray2())
+ CheckL(samplecol.Gray2()==0);
+ else
+ CheckL(samplecol.Gray2()==bmpcol.Gray2());
+ }
+ }
+ iCon->Clear();
+ iCon->BitBltMasked(TPoint(0,0),&iBitmap,bmprect,&iBitmap,EFalse);
+ for(y=0;y<bmprect.iBr.iY;y++)
+ {
+ for(x=0;x<bmprect.iBr.iX;x++)
+ {
+ iBitmap.GetPixel(bmpcol,TPoint(x,y));
+ iDev->GetPixel(samplecol,TPoint(x,y));
+ if(bmpcol.Gray2())
+ CheckL(samplecol.Gray2()==bmpcol.Gray2());
+ else
+ CheckL(samplecol.Gray2()==0);
+ }
+ }
+ iCon->SetBrushColor(KRgbWhite);
+ iCon->Clear();
+ iCon->BitBltMasked(TPoint(0,0),&iBitmap,bmprect,&iBitmap,ETrue);
+ for(y=0;y<bmprect.iBr.iY;y++)
+ {
+ for(x=0;x<bmprect.iBr.iX;x++)
+ {
+ iBitmap.GetPixel(bmpcol,TPoint(x,y));
+ iDev->GetPixel(samplecol,TPoint(x,y));
+ if(bmpcol.Gray2())
+ CheckL(samplecol.Gray2()==1);
+ else
+ CheckL(samplecol.Gray2()==bmpcol.Gray2());
+ }
+ }
+ iCon->Clear();
+ iCon->BitBltMasked(TPoint(0,0),&iBitmap,bmprect,&iBitmap,EFalse);
+ for(y=0;y<bmprect.iBr.iY;y++)
+ {
+ for(x=0;x<bmprect.iBr.iX;x++)
+ {
+ iBitmap.GetPixel(bmpcol,TPoint(x,y));
+ iDev->GetPixel(samplecol,TPoint(x,y));
+ if(bmpcol.Gray2())
+ CheckL(samplecol.Gray2()==bmpcol.Gray2());
+ else
+ CheckL(samplecol.Gray2()==1);
+ }
+ }
+ Clear();
+ CheckClearL();
+ TPoint offscreenpoint(0,iSize.iHeight<<1);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,EFalse);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,ETrue);
+ offscreenpoint.iX-=(bmpsize.iWidth<<1);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,EFalse);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,ETrue);
+ offscreenpoint.iX=(iSize.iWidth<<1);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,EFalse);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,ETrue);
+ offscreenpoint.SetXY(0,-(bmpsize.iHeight<<1));
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,EFalse);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,ETrue);
+ offscreenpoint.iX-=(bmpsize.iWidth<<1);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,EFalse);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,ETrue);
+ offscreenpoint.iX=(iSize.iWidth<<1);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,EFalse);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,ETrue);
+ offscreenpoint.SetXY(0,0);
+ offscreenpoint.iX-=(bmpsize.iWidth<<1);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,EFalse);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,ETrue);
+ offscreenpoint.iX=(iSize.iWidth<<1);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,EFalse);
+ iCon->BitBltMasked(offscreenpoint,&iBitmap,bmprect,&iBitmap,ETrue);
+ CheckClearL();
+ }
+
+void TestGdi::DoBltCompressedL()
+ {
+ //NOTE: max assumed screen size is 100x100 the same as EMbmTgdiDrawbitmap
+
+ *iSection = _L("DoBltCompressedL");
+ CFbsBitmap bitmap;
+ TInt ret = bitmap.Load(_L("z:\\system\\data\\tgdi.mbm"),EMbmTgdiDrawbitmap,EFalse);
+ CFbsBitmap compressedBitmap;
+ ret = compressedBitmap.LoadAndCompress(_L("z:\\system\\data\\tgdi.mbm"),EMbmTgdiDrawbitmap,EFalse);
+ User::LeaveIfError(ret);
+
+ //bitblt
+ *iSection = _L("DoBltCompressedL - bitblt first part of lines");
+ Clear();
+ TInt startx=20;
+ TInt starty=20;
+ TInt width=iSize.iWidth;
+ TInt height=iSize.iHeight;
+ TInt repeatx=width>>1;
+ TInt repeaty=height>>1;
+ TRect sample1(startx,0,repeatx-2*startx,repeaty);
+ TRgb pelcol,samplecol;
+ iCon->BitBlt(TPoint(startx,starty),&bitmap,sample1);
+ iCon->BitBlt(TPoint(repeatx-startx,starty),&compressedBitmap,sample1);
+ for(TInt y=0;y<repeaty;y++)
+ {
+ for(TInt x=startx;x<repeatx-2*startx;x++)
+ {
+ iDev->GetPixel(pelcol,TPoint(repeatx-startx+x,starty+y));
+ iDev->GetPixel(samplecol,TPoint(startx+x,starty+y));
+ CheckL(samplecol==pelcol);
+ }
+ }
+ *iSection = _L("DoBltCompressedL - bitblt multiple complete lines - columns");
+ Clear();
+ TRect sample2(0,0,bitmap.SizeInPixels().iWidth,50);
+ iCon->BitBlt(TPoint(0,0),&bitmap,sample2);
+ iCon->BitBlt(TPoint(0,50),&compressedBitmap,sample2);
+ for(TInt y=0;y<50;y++)
+ {
+ for(TInt x=0;x<bitmap.SizeInPixels().iWidth;x++)
+ {
+ iDev->GetPixel(pelcol,TPoint(x,y));
+ iDev->GetPixel(samplecol,TPoint(x,50+y));
+ CheckL(samplecol==pelcol);
+ }
+ }
+
+ *iSection = _L("DoBltCompressedL - bitblt final part of lines");
+ Clear();
+ TRect sample3(0,0,50,100);
+ iCon->BitBlt(TPoint(0,0),&bitmap,sample3);
+ iCon->BitBlt(TPoint(50,0),&compressedBitmap,sample3);
+ for(TInt y=0;y<100;y++)
+ {
+ for(TInt x=0;x<50;x++)
+ {
+ iDev->GetPixel(pelcol,TPoint(x,y));
+ iDev->GetPixel(samplecol,TPoint(50+x,y));
+ CheckL(samplecol==pelcol);
+ }
+ }
+
+ *iSection = _L("DoBltCompressedL - bitbltmasked flickerv2");
+ Clear();
+ TRect sample4(0,0,50,100);
+ // Due to inconsistent handling of solid brushes between different colour modes, the
+ // screen or a bitmap, accelerated or non-accelerated do this test with a null brush.
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->BitBltMasked(TPoint(0,0),&bitmap,sample4,&iBitmap,ETrue);
+ iCon->BitBltMasked(TPoint(50,0),&compressedBitmap,sample4,&iBitmap,ETrue);
+ for(TInt y=0;y<100;y++)
+ {
+ for(TInt x=0;x<50;x++)
+ {
+ iDev->GetPixel(pelcol,TPoint(x,y));
+ iDev->GetPixel(samplecol,TPoint(50+x,y));
+ CheckL(samplecol==pelcol);
+ }
+ }
+
+ *iSection = _L("DoBltCompressedL - bitbltmasked needbitmaps of same mode");
+ Clear();
+ TRect sample5(0,0,50,100);
+ iCon->BitBltMasked(TPoint(0,0),&bitmap,sample5,&compressedBitmap,ETrue);
+ iCon->BitBltMasked(TPoint(50,0),&compressedBitmap,sample5,&bitmap,ETrue);
+ for(TInt y=0;y<100;y++)
+ {
+ for(TInt x=0;x<50;x++)
+ {
+ iDev->GetPixel(pelcol,TPoint(x,y));
+ iDev->GetPixel(samplecol,TPoint(50+x,y));
+ CheckL(samplecol==pelcol);
+ }
+ }
+
+ *iSection = _L("DoBltCompressedL - bitbltmasked same bitmap as mask");
+ Clear();
+ TRect target6(0,0,50,100);
+ TRect sample6(0,0,50,100);
+ iCon->DrawBitmapMasked(target6,&bitmap,sample6,&bitmap,ETrue);
+ target6.Move(50,0);
+ iCon->DrawBitmapMasked(target6,&compressedBitmap,sample6,&compressedBitmap,ETrue);
+ for(TInt y=0;y<100;y++)
+ {
+ for(TInt x=0;x<50;x++)
+ {
+ iDev->GetPixel(pelcol,TPoint(x,y));
+ iDev->GetPixel(samplecol,TPoint(50+x,y));
+ CheckL(samplecol==pelcol);
+ }
+ }
+ }
+
+void TestGdi::DoShadowL()
+ {
+ *iSection = _L("Shadow");
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ TInt halfwidth=iSize.iWidth>>1;
+ TRect lhs(TSize(halfwidth,iSize.iHeight));
+ TRect rhs(TPoint(halfwidth,0),TSize(iSize.iWidth,iSize.iHeight));
+ TRegionFix<1> area(lhs);
+ TPoint lhspt(halfwidth>>1,iSize.iHeight>>1);
+ TPoint rhspt(halfwidth+(halfwidth>>1),iSize.iHeight>>1);
+ TRgb lhsrgb,rhsrgb;
+
+ for (TInt count = 0; count < 32; count++)
+ {
+ TRgb brushColor;
+ if (count < 16)
+ brushColor = TRgb::Gray16(count);
+ else
+ brushColor = TRgb::Color16(count - 16);
+
+ iCon->DrawRect(lhs);
+ iCon->ShadowArea(&area);
+ iCon->SetShadowMode(ETrue);
+ iCon->DrawRect(rhs);
+ iDev->GetPixel(lhsrgb,lhspt);
+ iDev->GetPixel(rhsrgb,rhspt);
+ CheckL(lhsrgb==rhsrgb);
+ iCon->SetShadowMode(EFalse);
+ }
+ Clear();
+ }
+
+/**
+ Auxiliary Fn to check the Pixel values
+
+ This method checks the pixel values with respective calculated values based on the call
+ from DoDrawBitmapMaskedL
+
+*/
+void TestGdi::CheckMaskedResultsL(CFbsBitmap* aBgBmp,CFbsBitmap* aSrcBmp,CFbsBitmap* aMaskBmp,TRect& aTarRect,TBool aInvertMask,TBool aAlphaBlend, TBool aSemiTransparentMask/*=EFalse*/)
+ {
+ TInt width=0;
+ TInt height=0;
+ TInt rowIndex=0;
+ TInt colIndex=0;
+ width=aTarRect.Width();
+ height=aTarRect.Height();
+ // Check the size of the target rectangle is negative or zero
+ if (width<0 || !width || height<0 || !height)
+ {
+ return;
+ }
+ // Check the size of the target rectangle falls out side the display screen size
+ if (width>iSize.iWidth)
+ {
+ width=iSize.iWidth;
+ }
+ if (height>iSize.iHeight)
+ {
+ height=iSize.iHeight;
+ }
+ // Rectangle used locally and it starts top left corner.(0,0)
+ TRect rect(0,0,width,height);
+ TSize size(rect.Size());
+ TDisplayMode devDisplayMode=iDev->DisplayMode();
+ //Create background bitmap with the size equal to target rectangle
+ CFbsBitmap* backgroundBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(backgroundBmp);
+ User::LeaveIfError(backgroundBmp->Create(size,devDisplayMode));
+ //Create src bitmap with the size equal to target rectangle
+ CFbsBitmap* srcBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(srcBmp);
+ User::LeaveIfError(srcBmp->Create(size,iDev->DisplayMode()));
+ //Create mask bitmap with the size equal to target rectangle
+ CFbsBitmap* maskBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(maskBmp);
+ TDisplayMode maskDisplayMode;
+ if (aSrcBmp==aMaskBmp) // When the source and target are same
+ {
+ maskDisplayMode=devDisplayMode;
+ }
+ else if (aAlphaBlend) // display mode based on the aAlphablend flag
+ {
+ maskDisplayMode=EGray256;
+ }
+ else
+ {
+ maskDisplayMode=aMaskBmp->DisplayMode();
+ }
+ User::LeaveIfError(maskBmp->Create(size,maskDisplayMode));
+ //Creating bitmap device for calculation and comparison
+ CFbsBitmapDevice *bgDevice=CFbsBitmapDevice::NewL(backgroundBmp);
+ CleanupStack::PushL(bgDevice);
+ CFbsBitGc* bgGc=NULL;
+ User::LeaveIfError(bgDevice->CreateContext(bgGc));
+ CleanupStack::PushL(bgGc);
+ if (width==iBitmapWidth && height==iBitmapHeight || aTarRect.Width()<=iSize.iWidth && aTarRect.Height()<=iSize.iHeight)
+ {
+ bgGc->DrawBitmap(rect,aBgBmp);
+ }
+ else
+ {
+ bgGc->DrawBitmap(aTarRect,aBgBmp);
+ }
+ CFbsBitmapDevice* maskDevice=CFbsBitmapDevice::NewL(maskBmp); //For masked bitmap
+ CleanupStack::PushL(maskDevice);
+ CFbsBitGc* maskGc=NULL;
+ User::LeaveIfError(maskDevice->CreateContext(maskGc));
+ CleanupStack::PushL(maskGc);
+ if (width==iBitmapWidth && height==iBitmapHeight || aTarRect.Width()<=iSize.iWidth && aTarRect.Height()<=iSize.iHeight)
+ {
+ maskGc->DrawBitmap(rect,aMaskBmp);
+ }
+ else
+ {
+ maskGc->DrawBitmap(aTarRect,aMaskBmp);
+ }
+ CFbsBitmapDevice* srcDevice=CFbsBitmapDevice::NewL(srcBmp); //For source bitmap
+ CleanupStack::PushL(srcDevice);
+ CFbsBitGc* srcGc=NULL;
+ User::LeaveIfError(srcDevice->CreateContext(srcGc));
+ CleanupStack::PushL(srcGc);
+ if (width==iBitmapWidth && height==iBitmapHeight || aTarRect.Width()<=iSize.iWidth && aTarRect.Height()<=iSize.iHeight)
+ {
+ srcGc->DrawBitmap(rect,aSrcBmp);
+ }
+ else
+ {
+ srcGc->DrawBitmap(aTarRect,aSrcBmp);
+ }
+
+ for (rowIndex=0;rowIndex<height;++rowIndex)
+ {
+ TInt redinversemask=0;
+ TInt redmaskvalue=0;
+ TInt greeninversemask=0;
+ TInt greenmaskvalue=0;
+ TInt blueinversemask=0;
+ TInt bluemaskvalue=0;
+ TRgb bmpcol;
+ TRgb samplecol;
+ TRgb maskcol;
+ for (colIndex=0;colIndex<width;++colIndex)
+ {
+ srcDevice->GetPixel(bmpcol,TPoint(colIndex,rowIndex));
+ iDev->GetPixel(samplecol,aTarRect.iTl+TPoint(colIndex,rowIndex));
+ TRgb backgroundcolor;
+ bgDevice->GetPixel(backgroundcolor,TPoint(colIndex,rowIndex));
+ maskDevice->GetPixel(maskcol,TPoint(colIndex,rowIndex));
+ if (aInvertMask && (maskDisplayMode!=EGray256 || aAlphaBlend))
+ {
+ redinversemask=maskcol.Red(); // green and blue should have the same value for gray-scale bitmap
+ redmaskvalue=MAXCOLORS-redinversemask;
+ blueinversemask=maskcol.Blue();
+ bluemaskvalue=MAXCOLORS-blueinversemask;
+ greeninversemask=maskcol.Green();
+ greenmaskvalue=MAXCOLORS-greeninversemask;
+ }
+ else
+ {
+ redmaskvalue=maskcol.Red();
+ redinversemask=MAXCOLORS-redmaskvalue;
+ bluemaskvalue=maskcol.Blue();
+ blueinversemask=MAXCOLORS-bluemaskvalue;
+ greenmaskvalue=maskcol.Green();
+ greeninversemask=MAXCOLORS-greenmaskvalue;
+ }
+ TInt red;
+ TInt green;
+ TInt blue;
+ if (aSemiTransparentMask && devDisplayMode!=EGray256)
+ {
+ if (devDisplayMode==EColor64K || devDisplayMode==EColor256 || devDisplayMode==EColor4K || devDisplayMode==EColor16M || aInvertMask)
+ {
+ red=(bmpcol.Red()*redmaskvalue+backgroundcolor.Red()*redinversemask)>>8;
+ green=(bmpcol.Green()*greenmaskvalue+backgroundcolor.Green()*greeninversemask)>>8;
+ blue=(bmpcol.Blue()*bluemaskvalue+backgroundcolor.Blue()*blueinversemask)>>8;
+ }
+ else
+ {
+ red=(bmpcol.Red()*(redmaskvalue+1))>>8;
+ red+=(backgroundcolor.Red()*(redinversemask+1))>>8;
+ green=(bmpcol.Green()*(greenmaskvalue+1))>>8;
+ green+=(backgroundcolor.Green()*(greeninversemask+1))>>8;
+ blue=(bmpcol.Blue()*(bluemaskvalue+1))>>8;
+ blue+=(backgroundcolor.Blue()*(blueinversemask+1))>>8;
+ }
+ }
+ else
+ {
+ red=((bmpcol.Red()*redmaskvalue)+(backgroundcolor.Red()*redinversemask));
+ green=((bmpcol.Green()*greenmaskvalue)+(backgroundcolor.Green()*greeninversemask));
+ blue=((bmpcol.Blue()*bluemaskvalue)+(backgroundcolor.Blue()*blueinversemask));
+ red = red / MAXCOLORS;
+ green = green / MAXCOLORS;
+ blue = blue / MAXCOLORS;
+ }
+
+ TRgb rgb(red,green,blue);
+ TRgb resultantColor;
+ TUint index;
+ switch(devDisplayMode)
+ {
+ case EGray2:
+ {
+ index = TRgb::Gray2(blue).Gray2();
+ resultantColor = TRgb::Gray2(index);
+ break;
+ }
+ case EGray256:
+ {
+ index = rgb.Gray256();
+ resultantColor = TRgb::Gray256(index);
+ break;
+ }
+ case EColor256:
+ {
+ index = rgb.Color256();
+ resultantColor = TRgb::Color256(index);
+ break;
+ }
+ case EColor4K:
+ {
+ index = rgb.Color4K();
+ resultantColor = TRgb::Color4K(index);
+ break;
+ }
+ case EColor64K:
+ {
+ index = rgb.Color64K();
+ resultantColor = TRgb::Color64K(index);
+ break;
+ }
+ case EColor16M:
+ {
+ index = rgb.Color16M();
+ resultantColor = TRgb::Color16M(index);
+ break;
+ }
+ case EColor16MU:
+ {
+ index = rgb.Color16MU();
+ resultantColor = TRgb::Color16MU(index);
+ break;
+ }
+ }
+ CheckL(samplecol.Red()==resultantColor.Red());
+ CheckL(samplecol.Green()==resultantColor.Green());
+ CheckL(samplecol.Blue()==resultantColor.Blue());
+ }
+ }
+ CleanupStack::PopAndDestroy(9,backgroundBmp);
+ }
+
+/**
+ @SYMTestCaseID GRAPHICS-TestGdi-DoDrawBitmapMaskedL-0001
+
+ @SYMPREQ 642
+
+ @SYMREQ
+
+ @SYMTestCaseDesc Test DrawMaskedBitmap (Transperency Stretched Bitmap).\n
+ Automated Tests to test DrawBitmapMasked with different display modes.
+
+ @SYMTestPriority High
+
+ @SYMTestStatus Implemented
+
+ @SYMTestActions Creates bitmaps programmatically and calls API DrawBitmapMasked() with respective parameters
+ Drawn pixels value with calculated pixels and verified using CheckL(), All the test cases specified in \n
+ test specifications are implemented(22 test cases).
+
+ @SYMTestExpectedResults KErrNone
+
+ */
+void TestGdi::DoDrawBitmapMaskedL(TBool aColorMask)
+ {
+ _LIT(KBitmapMasked,"DrawBitmapMasked - Test Case ");
+ *iSection = KBitmapMasked;
+ TInt rowIndex;
+ TInt colIndex;
+ TSize rectSize(iBitmapWidth,iBitmapHeight);
+ TRect srcRect;
+ TRect tarRect;
+
+ CFbsBitmap* backgroundBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(backgroundBmp);
+ User::LeaveIfError(backgroundBmp->Create(rectSize,iDev->DisplayMode()));
+ srcRect.SetSize(rectSize);
+ TBitmapUtil bmpUtil(backgroundBmp);
+ bmpUtil.Begin(TPoint(0,0));
+ for (rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+ {
+ TInt red=0;
+ TInt blue=255;
+ if(iDev->DisplayMode()==EGray2)
+ {
+ blue=0;
+ }
+ TInt green=0;
+ bmpUtil.SetPos(TPoint(0,rowIndex));
+ for (colIndex=0;colIndex<iBitmapWidth;++colIndex)
+ {
+ TRgb rgb(red,green,blue);
+ switch(iDev->DisplayMode())
+ {
+ case EGray2:
+ {
+ bmpUtil.SetPixel(TRgb::Gray2(blue).Gray2());
+ bmpUtil.IncXPos();
+ if (colIndex%4==0)
+ {
+ blue=255-blue;
+ }
+ continue;
+ }
+ case EGray256:
+ {
+ bmpUtil.SetPixel(rgb.Gray256());
+ break;
+ }
+ case EColor256:
+ {
+ bmpUtil.SetPixel(rgb.Color256());
+ break;
+ }
+ case EColor4K:
+ {
+ bmpUtil.SetPixel(rgb.Color4K());
+ break;
+ }
+ case EColor64K:
+ {
+ bmpUtil.SetPixel(rgb.Color64K());
+ break;
+ }
+ case EColor16M:
+ {
+ bmpUtil.SetPixel(rgb.Color16M());
+ break;
+ }
+ case EColor16MU:
+ {
+ bmpUtil.SetPixel(rgb.Color16MU());
+ break;
+ }
+ }
+ bmpUtil.IncXPos();
+ red+=10;
+ blue-=30;
+ green+=20;
+ if(red > 255)
+ {
+ red-=255;
+ green+=1;
+ }
+ if(green > 255)
+ {
+ green-=255;
+ blue-=1;
+ }
+ if(blue < 0)
+ {
+ blue+=255;
+ }
+ }
+ }
+ bmpUtil.End();
+ //Create source bitmap with various color scale
+ CFbsBitmap* srcBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(srcBmp);
+ User::LeaveIfError(srcBmp->Create(rectSize,iDev->DisplayMode()));
+ TBitmapUtil bmpUtil1(srcBmp);
+ bmpUtil1.Begin(TPoint(0,0));
+ TInt gray2=0;
+ for (rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+ {
+ TInt red=255;
+ TInt blue=0;
+ TInt green=255;
+ bmpUtil1.SetPos(TPoint(0,rowIndex));
+ gray2=!gray2?0:255;
+ for (colIndex=0;colIndex<iBitmapWidth;++colIndex)
+ {
+ TRgb rgb(red,green,blue);
+ switch(iDev->DisplayMode())
+ {
+ case EGray2:
+ {
+ bmpUtil1.SetPixel(TRgb::Gray2(gray2).Gray2());
+ bmpUtil1.IncXPos();
+ red=0;
+ green=0;
+ blue=!blue?255:0;
+ continue;
+ }
+ case EGray256:
+ {
+ bmpUtil1.SetPixel(rgb.Gray256());
+ break;
+ }
+ case EColor256:
+ {
+ bmpUtil1.SetPixel(rgb.Color256());
+ break;
+ }
+ case EColor4K:
+ {
+ bmpUtil1.SetPixel(rgb.Color4K());
+ break;
+ }
+ case EColor64K:
+ {
+ bmpUtil1.SetPixel(rgb.Color64K());
+ break;
+ }
+ case EColor16M:
+ {
+ bmpUtil1.SetPixel(rgb.Color16M());
+ break;
+ }
+ case EColor16MU:
+ {
+ bmpUtil1.SetPixel(rgb.Color16MU());
+ break;
+ }
+ }
+ bmpUtil1.IncXPos();
+ red-=10;
+ blue+=10;
+ green-=10;
+ if(red <= 0)
+ {
+ red+=255;
+ }
+ if(blue >= 255)
+ {
+ blue-=255;
+ }
+ if(green <= 0)
+ {
+ green+=255;
+ }
+ }
+ }
+ bmpUtil1.End();
+ //Masked bitmap with various color scale
+ CFbsBitmap* maskBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(maskBmp);
+ TBitmapUtil bmpUtil2(maskBmp);
+ if(iDev->DisplayMode() == EGray2)
+ {
+ User::LeaveIfError(maskBmp->Create(rectSize,EGray2));
+ bmpUtil2.Begin(TPoint(0,0));
+ for (rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+ {
+ bmpUtil2.SetPos(TPoint(0,rowIndex));
+ TInt blue=0;
+ for(colIndex=0;colIndex<iBitmapWidth;++colIndex)
+ {
+ bmpUtil2.SetPixel(blue);
+ bmpUtil2.IncXPos();
+ blue=!blue?255:0;
+ }
+ }
+ bmpUtil2.End();
+ }
+ else
+ {
+ User::LeaveIfError(maskBmp->Create(rectSize,aColorMask?EColor256:EGray256));
+ bmpUtil2.Begin(TPoint(0,0));
+ for (rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+ {
+ bmpUtil2.SetPos(TPoint(0,rowIndex));
+ TInt red=0;
+ TInt blue=0;
+ TInt green=0;
+ for(colIndex=0;colIndex<iBitmapWidth;++colIndex)
+ {
+ TRgb rgb(red,green,blue);
+ bmpUtil2.SetPixel(rgb.Color256());
+ bmpUtil2.IncXPos();
+ red=!red?255:0;
+ blue=!blue?255:0;
+ green=!green?255:0;
+ }
+ }
+ bmpUtil2.End();
+ }
+
+ //Masked bitmap with various gray scale (For Alphablending)
+ CFbsBitmap* maskblendBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(maskblendBmp);
+ if(iDev->DisplayMode() == EGray2)
+ {
+ User::LeaveIfError(maskblendBmp->Create(rectSize,EGray2));
+ TBitmapUtil bmpUtil3(maskblendBmp);
+ bmpUtil3.Begin(TPoint(0,0));
+ TInt blue=0;
+ for (rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+ {
+ bmpUtil3.SetPos(TPoint(0,rowIndex));
+ blue=0;
+ for(colIndex=0;colIndex<iBitmapWidth;++colIndex)
+ {
+ bmpUtil3.SetPixel(blue);
+ bmpUtil3.IncXPos();
+ blue=!blue?255:0;
+ }
+ }
+ bmpUtil3.End();
+ }
+ else
+ {
+ User::LeaveIfError(maskblendBmp->Create(rectSize,EGray256));
+ TBitmapUtil bmpUtil3(maskblendBmp);
+ bmpUtil3.Begin(TPoint(0,0));
+ for (rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+ {
+ bmpUtil3.SetPos(TPoint(0,rowIndex));
+ TInt red=0;
+ TInt blue=0;
+ TInt green=0;
+ for(colIndex=0;colIndex<iBitmapWidth;++colIndex)
+ {
+ TRgb rgb(red,green,blue);
+ bmpUtil3.SetPixel(rgb.Gray256());
+ bmpUtil3.IncXPos();
+ red=!red?255:0;
+ blue=!blue?255:0;
+ green=!green?255:0;
+ }
+ }
+ bmpUtil3.End();
+ }
+ /**
+ Test Cases 1 to 10 (AlphaBlending)
+
+ Test Case # 1
+
+ Desc : Test the functionality of DrawBitmapMasked() without
+ Stretching or compressing and with a normal mask.
+ */
+ iSection->AppendNum(1);
+ iCon->DrawBitmap(srcRect,backgroundBmp,srcRect);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(srcRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,srcRect,EFalse,ETrue);
+ /**
+ Test Case # 2
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ when it stretches the bitmap and with a normal mask.
+ */
+ iSection->Delete(iSection->Length() - 1, 1);
+ iSection->AppendNum(2);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(iBitmapWidth*2);
+ tarRect.SetHeight(iBitmapHeight*2);
+ if (iDev->SizeInPixels().iWidth>=tarRect.Width() && iDev->SizeInPixels().iHeight>=tarRect.Height())
+ {
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,tarRect,EFalse,ETrue);
+ }
+ /**
+ Test Case # 3
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ when it compresses the bitmap and with a normal mask.
+ */
+ iSection->Delete(iSection->Length() - 1, 1);
+ iSection->AppendNum(3);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(iBitmapWidth/2);
+ tarRect.SetHeight(iBitmapHeight/2);
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,tarRect,EFalse,ETrue);
+ /**
+ Test Case # 4
+
+ Desc : To test the functionality of DrawBitmapMasked() with Destination Rectangle as zero.
+ */
+ iSection->Delete(iSection->Length() - 1, 1);
+ iSection->AppendNum(4);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(0);
+ tarRect.SetHeight(0);
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,tarRect,EFalse,ETrue);
+ /**
+ Test Case # 5
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ with destination rectangle large in size. (more than test screen size)
+ */
+ iSection->Delete(iSection->Length() - 1, 1);
+ iSection->AppendNum(5);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(iBitmapWidth*5);
+ tarRect.SetHeight(iBitmapHeight*4);
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,tarRect,EFalse,ETrue);
+ /**
+ Test Case # 6
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ passing the target rectangle targeted to right top corner of the screen.
+ */
+ iSection->Delete(iSection->Length() - 1, 1);
+ iSection->AppendNum(6);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(iBitmapWidth);
+ tarRect.SetHeight(iBitmapHeight);
+ tarRect.Move(iSize.iWidth-iBitmapWidth,0);
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,tarRect,EFalse,ETrue);
+ /**
+ Test Case # 7
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ passing the target rectangle targeted to bottom left corner of the screen.
+ */
+ iSection->Delete(iSection->Length() - 1, 1);
+ iSection->AppendNum(7);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0); // Restoring rectangle back to the original position
+ tarRect.SetWidth(iBitmapWidth);
+ tarRect.SetHeight(iBitmapHeight);
+ tarRect.Move(0,(iSize.iHeight-iBitmapHeight));
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,tarRect,EFalse,ETrue);
+ /**
+ Test Case # 8
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ passing the target rectangle targeted to bottom right corner of the screen
+ */
+ iSection->Delete(iSection->Length() - 1, 1);
+ iSection->AppendNum(8);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0); // Restoring rectangle back to the original position
+ tarRect.SetWidth(iBitmapWidth);
+ tarRect.SetHeight(iBitmapHeight);
+ tarRect.Move((iSize.iWidth-iBitmapWidth),(iSize.iHeight-iBitmapHeight));
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,tarRect,EFalse,ETrue);
+ /**
+ Test Case # 9
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ passing the target rectangle has negative coordinates
+ */
+ iSection->Delete(iSection->Length() - 1, 1);
+ iSection->AppendNum(9);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0); // Restoring rectangle back to the original position
+ tarRect.SetWidth(-iBitmapWidth);
+ tarRect.SetHeight(-iBitmapHeight);
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,tarRect,EFalse,ETrue);
+ /**
+ Test Case # 10
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ passing the same bitmap for both the source and mask
+ */
+ if (iDev->DisplayMode()==EGray2 || iDev->DisplayMode()==EGray4 || iDev->DisplayMode()==EGray16)
+ {
+ iSection->Delete(iSection->Length() - 1, 1);
+ iSection->AppendNum(10);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0); // Restoring rectangle back to the original position
+ tarRect.SetWidth(iBitmapWidth);
+ tarRect.SetHeight(iBitmapHeight);
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,srcBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,srcBmp,tarRect,EFalse,EFalse);
+ }
+ /**
+ Test Cases: 11 - 22 (BitBltMasked)
+
+ Test Case # 11
+
+ Desc : Test the functionality of DrawBitmapMasked() without
+ Stretching or compressing and with a normal mask.
+ */
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(11);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(iBitmapWidth);
+ tarRect.SetHeight(iBitmapHeight);
+ iCon->DrawBitmap(srcRect,backgroundBmp,srcRect);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(srcRect,srcBmp,srcRect,maskBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,srcRect,EFalse,EFalse);
+ // Test Case # 12 with a reverse mask.
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(12);
+ iCon->Clear();
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,ETrue);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,ETrue,EFalse);
+ /**
+ Test Case # 13
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ when it stretches the bitmap and with a normal mask.
+ */
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(13);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(Min(iBitmapWidth*2,iSize.iWidth));
+ tarRect.SetHeight(Min(iBitmapHeight*2,iSize.iHeight));
+ if (iDev->SizeInPixels().iWidth>=tarRect.Width() && iDev->SizeInPixels().iHeight>=tarRect.Height())
+ {
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,EFalse,EFalse);
+ }
+ // Test Case # 14 with a reverse mask.
+ if (iDev->SizeInPixels().iWidth>=tarRect.Width() && iDev->SizeInPixels().iHeight>=tarRect.Height())
+ {
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(14);
+ iCon->Clear();
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,ETrue);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,ETrue,EFalse);
+ }
+ /**
+ Test Case # 15
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ when it compresses the bitmap and with a normal mask.
+ */
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(15);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(iBitmapWidth/2);
+ tarRect.SetHeight(iBitmapHeight/2);
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,EFalse,EFalse);
+ // Test Case # 16 with a reverse mask.
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(16);
+ iCon->Clear();
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,ETrue);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,ETrue,EFalse);
+ /**
+ Test Case # 17
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ with destination rectangle large in size. (more than test screen size)
+ */
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(17);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(iBitmapWidth*5);
+ tarRect.SetHeight(iBitmapHeight*4);
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,EFalse,EFalse);
+ // Test Case # 18 with a reverse mask.
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(18);
+ iCon->Clear();
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,ETrue);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,ETrue,EFalse);
+ /**
+ Test Case # 19
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ passing the target rectangle targeted to right top corner of the screen.
+ */
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(19);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(iBitmapWidth);
+ tarRect.SetHeight(iBitmapHeight);
+ tarRect.Move(iSize.iWidth-iBitmapWidth,0);
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,EFalse,EFalse);
+ // Test Case # 20 with a reverse mask.
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(20);
+ iCon->Clear();
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,ETrue);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,ETrue,EFalse);
+ /**
+ Test Case # 21
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ passing the target rectangle targeted to bottom right corner of the screen
+ */
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(21);
+ iCon->Clear();
+ tarRect.iTl.SetXY(0,0); // Restoring rectangle back to the original position
+ tarRect.SetWidth(iBitmapWidth);
+ tarRect.SetHeight(iBitmapHeight);
+ tarRect.Move((iSize.iWidth-iBitmapWidth),(iSize.iHeight-iBitmapHeight));
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,EFalse);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,EFalse,EFalse);
+ // Test Case # 22 with a reverse mask.
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(22);
+ iCon->Clear();
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskBmp,ETrue);
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskBmp,tarRect,ETrue,EFalse);
+
+ /**
+ Test Case # 23
+
+ Desc: To ensure that DEF064071 is fixed. Test that drawing a scaled
+ bitmap with a tiled mask gives the correct result.
+ */
+ if(iSize.iWidth > 100 && iDev->DisplayMode() > EGray4)
+ // Only do this test for screen devices
+ {
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(23);
+ Clear();
+ iCon->Clear();
+ // We need a bigger rect than the rect in other tests
+ TRect t23Rect(TSize(150,150));
+ // Open source bitmap and mask
+ CFbsBitmap* t23SrcBmp = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL(t23SrcBmp);
+ User::LeaveIfError(t23SrcBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_sourcebitmap));
+ CFbsBitmap* t23SrcBmpMask = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL(t23SrcBmpMask);
+ User::LeaveIfError(t23SrcBmpMask->Load(KT23BitmapFileName,EMbmTgdiDef064071_sourcebitmapmask));
+
+ // Open bitmap that contains the expected result
+ CFbsBitmap* t23ExpectedBmp = new (ELeave) CFbsBitmap();
+ CleanupStack::PushL(t23ExpectedBmp);
+ switch(iDev->DisplayMode())
+ {
+ case EGray16:
+ User::LeaveIfError(t23ExpectedBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_expected_egray16));
+ break;
+ case EGray256:
+ User::LeaveIfError(t23ExpectedBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_expected_egray256));
+ break;
+ case EColor16:
+ User::LeaveIfError(t23ExpectedBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_expected_ecolor16));
+ break;
+ case EColor256:
+ User::LeaveIfError(t23ExpectedBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_expected_ecolor256));
+ break;
+ case EColor4K:
+ User::LeaveIfError(t23ExpectedBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_expected_ecolor4k));
+ break;
+ case EColor64K:
+ User::LeaveIfError(t23ExpectedBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_expected_ecolor64k));
+ break;
+ case EColor16M:
+ User::LeaveIfError(t23ExpectedBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_expected_ecolor16m));
+ break;
+ case EColor16MU:
+ User::LeaveIfError(t23ExpectedBmp->Load(KT23BitmapFileName,EMbmTgdiDef064071_expected_ecolor16mu));
+ break;
+ }
+
+ // Draw masked bitmap to screen
+ iCon->DrawBitmapMasked(t23Rect,t23SrcBmp,t23SrcBmp->SizeInPixels(),t23SrcBmpMask,ETrue);
+ TRect miniTarRect(20,20,80,80);
+ // Draw small version of the bitmap
+ iCon->DrawBitmapMasked(miniTarRect,t23SrcBmp,t23SrcBmp->SizeInPixels(),t23SrcBmpMask,ETrue);
+ // Set the clipping region to draw either side of the small bitmap that we've just drawn
+ TRegionFix<2> t23Region;
+ t23Region.AddRect(TRect(t23Rect.iTl.iX,miniTarRect.iTl.iY,
+ miniTarRect.iTl.iX,miniTarRect.iBr.iY));
+ t23Region.AddRect(TRect(miniTarRect.iBr.iX,miniTarRect.iTl.iY,
+ t23Rect.iBr.iX,miniTarRect.iBr.iY));
+ iCon->SetClippingRegion(&t23Region);
+ iCon->Clear();
+ iCon->DrawBitmapMasked(t23Rect,t23SrcBmp,t23SrcBmp->SizeInPixels(),t23SrcBmpMask,ETrue);
+ iCon->SetClippingRect(iDev->SizeInPixels());
+
+ // Compare pixels on device with those from the expected bitmap
+ TPoint pixel;
+ TRgb deviceRgb;
+ TRgb expectedRgb;
+ TSize t23RectSize(t23Rect.Size());
+ CheckL(t23ExpectedBmp->SizeInPixels() == t23RectSize);
+ for(pixel.iY = t23Rect.iTl.iY; pixel.iY < t23RectSize.iHeight; ++pixel.iY)
+ {
+ for(pixel.iX = t23Rect.iTl.iX; pixel.iX < t23RectSize.iWidth; ++pixel.iX)
+ {
+ iDev->GetPixel(deviceRgb,pixel);
+ t23ExpectedBmp->GetPixel(expectedRgb,pixel);
+ CheckL(deviceRgb == expectedRgb);
+ }
+ }
+ iCon->CancelClippingRect();
+ iCon->CancelClippingRegion();
+
+ CleanupStack::PopAndDestroy(t23ExpectedBmp);
+ CleanupStack::PopAndDestroy(t23SrcBmpMask);
+ CleanupStack::PopAndDestroy(t23SrcBmp);
+ }
+
+ /**
+ Test Case # 24 (PDEF118404, INC115741)
+
+ Desc : To test the functionality of DrawBitmapMasked()
+ with destination rectangle multiple of 256.
+ INC115741 issue with boundary conditions. CFbsBitGc::DoDrawBitmapMasked has KScanLineLength = 256.
+ Tests fix for PDEF118404. If fix is not present, this test will fail with User Panic 21.
+ */
+ iSection->Delete(iSection->Length() - 2, 2);
+ iSection->AppendNum(24);
+ iCon->Clear();
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+
+ // This constant is associated to the value used in CFbsBitGc::DoDrawBitmapMasked.
+ // If that value is changed, then this one must be updated as well otherwise the test will no longer be valid.
+ const TInt KScanLineLength = 256;
+
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetHeight(2);
+ for (TInt ii = 1; ii < 5; ++ii)
+ {
+ tarRect.SetWidth(KScanLineLength * ii);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+ }
+
+ CleanupStack::PopAndDestroy(4,backgroundBmp);
+ }
+
+// Used to fill the bitmap with a given color for the current display mode.
+void TestGdi::FillBitmap(CFbsBitmap* aBitmap, TRgb aRgb)
+ {
+ TBitmapUtil bmpUtil(aBitmap);
+ bmpUtil.Begin(TPoint(0,0));
+ for (TInt rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+ {
+ bmpUtil.SetPos(TPoint(0,rowIndex));
+ for (TInt colIndex=0;colIndex<iBitmapWidth;++colIndex)
+ {
+ switch(iDev->DisplayMode())
+ {
+ case EGray2:
+ {
+ bmpUtil.SetPixel(TRgb::Gray2(aRgb.Blue()).Gray2());
+ break;
+ }
+ case EGray256:
+ {
+ bmpUtil.SetPixel(aRgb.Gray256());
+ break;
+ }
+ case EColor256:
+ {
+ bmpUtil.SetPixel(aRgb.Color256());
+ break;
+ }
+ case EColor4K:
+ {
+ bmpUtil.SetPixel(aRgb.Color4K());
+ break;
+ }
+ case EColor64K:
+ {
+ bmpUtil.SetPixel(aRgb.Color64K());
+ break;
+ }
+ case EColor16M:
+ {
+ bmpUtil.SetPixel(aRgb.Color16M());
+ break;
+ }
+ case EColor16MU:
+ {
+ bmpUtil.SetPixel(aRgb.Color16MU());
+ break;
+ }
+ }
+ bmpUtil.IncXPos();
+ }
+ }
+ bmpUtil.End();
+ }
+
+/**
+This test function is added to reproduce the defect INC097853
+(CFbsBitGc::DoDrawBitmapMasked function) in which it
+ was drawing the first scanline twice.
+ The steps to reproduce the defect are:
+ 1) Create a Black Background bitmap
+ 2) Create a White Source Bitmap and
+ 3) Create a Gray Masked Bitmap (50% white).
+ 4) Call the function DrawBitmap to draw the Background bitmap
+ 5) Call the function DrawBitmapMasked to draw the Source bitmap with Masked Bitmap
+ 6) Store the screen into a bitmap
+ */
+void TestGdi::DoDrawBitmapSemiTransparentMaskedL()
+ {
+ Clear();
+ iCon->Clear();
+ _LIT(KBitmapMasked,"DrawBitmapSemiTransparentMasked");
+ *iSection = KBitmapMasked;
+ TInt rowIndex;
+ TInt colIndex;
+ TSize rectSize(iBitmapWidth,iBitmapHeight);
+ TRect srcRect;
+ TRect tarRect;
+
+ // Create a Black background bitmap
+ CFbsBitmap* backgroundBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(backgroundBmp);
+ User::LeaveIfError(backgroundBmp->Create(rectSize,iDev->DisplayMode()));
+ srcRect.SetSize(rectSize);
+ FillBitmap(backgroundBmp, KRgbBlack);
+
+ //Create a White source bitmap
+ CFbsBitmap* srcBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(srcBmp);
+ User::LeaveIfError(srcBmp->Create(rectSize,iDev->DisplayMode()));
+ FillBitmap(srcBmp, KRgbWhite);
+
+ //Create a semi transparent Masked bitmap
+ CFbsBitmap* maskblendBmp = new (ELeave) CFbsBitmap;
+ CleanupStack::PushL(maskblendBmp);
+
+ if(iDev->DisplayMode() == EGray2)
+ {
+ User::LeaveIfError(maskblendBmp->Create(rectSize,EGray2));
+ TBitmapUtil bmpUtil(maskblendBmp);
+ bmpUtil.Begin(TPoint(0,0));
+ for (rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+ {
+ bmpUtil.SetPos(TPoint(0,rowIndex));
+ for(colIndex=0;colIndex<iBitmapWidth;++colIndex)
+ {
+ bmpUtil.SetPixel(128);
+ bmpUtil.IncXPos();
+ }
+ }
+ bmpUtil.End();
+ }
+ else
+ {
+ User::LeaveIfError(maskblendBmp->Create(rectSize,EGray256));
+ TRgb rgb(128,128,128);
+ TBitmapUtil bmpUtil(maskblendBmp);
+ bmpUtil.Begin(TPoint(0,0));
+ for (rowIndex=0;rowIndex<iBitmapHeight;++rowIndex)
+ {
+ bmpUtil.SetPos(TPoint(0,rowIndex));
+ for(colIndex=0;colIndex<iBitmapWidth;++colIndex)
+ {
+ bmpUtil.SetPixel(rgb.Gray256());
+ bmpUtil.IncXPos();
+ }
+ }
+ bmpUtil.End();
+ }
+
+ tarRect.iTl.SetXY(0,0);
+ tarRect.SetWidth(iBitmapWidth*2);
+ tarRect.SetHeight(iBitmapHeight*2);
+ if (iDev->SizeInPixels().iWidth>=tarRect.Width() && iDev->SizeInPixels().iHeight>=tarRect.Height())
+ {
+ iCon->DrawBitmap(tarRect,backgroundBmp);
+ iCon->SetBrushStyle(CGraphicsContext::ENullBrush);
+ iCon->DrawBitmapMasked(tarRect,srcBmp,srcRect,maskblendBmp,EFalse);
+
+ CheckMaskedResultsL(backgroundBmp,srcBmp,maskblendBmp,tarRect,EFalse,ETrue, ETrue);
+ }
+
+ CleanupStack::PopAndDestroy(3,backgroundBmp);
+ }
+
+void TestGdi::DoFadeL()
+ {
+ *iSection = _L("Fade");
+ iCon->SetPenStyle(CGraphicsContext::ENullPen);
+ iCon->SetBrushStyle(CGraphicsContext::ESolidBrush);
+ TInt halfwidth=iSize.iWidth>>1;
+ TRect lhs(TSize(halfwidth,iSize.iHeight));
+ TRect rhs(TPoint(halfwidth,0),TSize(iSize.iWidth,iSize.iHeight));
+ TRegionFix<1> area(lhs);
+ TPoint lhspt(halfwidth>>1,iSize.iHeight>>1);
+ TPoint rhspt(halfwidth+(halfwidth>>1),iSize.iHeight>>1);
+ TRgb lhsrgb,rhsrgb;
+
+ for(TInt count=0;count<32;count++)
+ {
+ TRgb brushColor;
+ if (count < 16)
+ brushColor = TRgb::Gray16(count);
+ else
+ brushColor = TRgb::Color16(count - 16);
+
+ if (iDev->DisplayMode() == EGray4)
+ {
+ brushColor = TRgb::Gray4(brushColor.Gray4());
+ iCon->SetFadingParameters(255,0);
+ }
+
+ iCon->SetBrushColor(brushColor);
+ iCon->DrawRect(lhs);
+ iCon->FadeArea(&area);
+ iCon->SetFadeMode(ETrue);
+ iCon->DrawRect(rhs);
+ iDev->GetPixel(lhsrgb,lhspt);
+ iDev->GetPixel(rhsrgb,rhspt);
+ CheckL(lhsrgb==rhsrgb);
+ iCon->SetFadeMode(EFalse);
+ }
+ Clear();
+ }
+