diff -r 000000000000 -r 5d03bc08d59c graphicsdeviceinterface/bitgdi/tbit/toutlineandshadowfonts.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicsdeviceinterface/bitgdi/tbit/toutlineandshadowfonts.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,1075 @@ +// Copyright (c) 2006-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#include "toutlineandshadowfonts.h" +#include +#include +#include +#include +#include "fbsmessage.h" + +//Note: This test should run with a rasterizer which supports EFourColourBlendGlyphBitmap (e.g. iType) +//otherwise the tests will fail. + +//Path where reference mbm files get created, these reference bitmaps are useful when debugging. +_LIT(KPath, "c:\\bitgditest\\%S.mbm"); + +// Constructor +CTOutlineAndShadowFonts::CTOutlineAndShadowFonts(CTestStep* aStep):CTGraphicsBase(aStep),iStep(aStep) { } + +void CTOutlineAndShadowFonts::ConstructL() + { + if (RFbsSession::Connect() != KErrNone) + { + FbsStartup(); + TInt conret = RFbsSession::Connect(); + TEST2(conret, KErrNone); + } + iFbs = RFbsSession::GetSession(); + iHashUtil = CTHashReferenceImages::NewL(iStep,iFbs,&KPath); + } + +// Destructor +CTOutlineAndShadowFonts::~CTOutlineAndShadowFonts() + { + FreeScreenDevice(); + RFbsSession::Disconnect(); + delete iHashUtil; + } + + +/** +Creates screen device for the given display mode if supported +@param aMode display mode for which device has to be created +*/ +void CTOutlineAndShadowFonts::CreateScreenDeviceL(TDisplayMode aMode) + { + iBitmap = new(ELeave) CFbsBitmap; + //Considering the intersection of the screen size for both hw and emulator so that same + //baselined hash can be used to test for both + iBitmap->Create(TSize(KScreenWidth, KScreenHeight), aMode); + iBitmapDevice = CFbsBitmapDevice::NewL(iBitmap); + User::LeaveIfError(iBitmapDevice->CreateContext((CGraphicsContext*&)iGc)); + iHashUtil->SetScreenDeviceAndBitmap(iBitmapDevice,iBitmap,iGc); + } + +/** +Delete the devices created and gc. +*/ +void CTOutlineAndShadowFonts::FreeScreenDevice() + { + delete iBitmapDevice; + delete iBitmap; + delete iGc; + iBitmapDevice = NULL; + iBitmap = NULL; + iGc = NULL; + } + + +/** +Auxilary function will be called in case of a leave to release the font +@param aCleanFont font to be released +*/ +void CleanUpFont(TAny* aCleanFont) + { + SCleanFont* cleanFont= static_cast(aCleanFont); + (cleanFont->device)->ReleaseFont(cleanFont->font); + } + +TBool CTOutlineAndShadowFonts::CheckMonoTypeInstalledL() + { + CreateScreenDeviceL(EColor16MU); +// + TFontSpec fontSpec; + fontSpec.iTypeface.iName = KFontFace[0]; + fontSpec.iHeight = KHeight; + fontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + fontSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, EDropShadowOn); + fontSpec.iFontStyle.SetEffects(FontEffect::EOutline, EOutlineOn); + CFont* font; + User::LeaveIfError(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font,fontSpec)); + TBool monoTypeInstalled=font->FontSpecInTwips().iFontStyle.BitmapType()==EFourColourBlendGlyphBitmap; + iBitmapDevice->ReleaseFont(font); + if (!monoTypeInstalled) + { + INFO_PRINTF1(_L("Monotype fonts not installed, Run iType\\binaries\\ityperast.cmd to install them")); + TEST(EFalse); + TestComplete(); + } + return(monoTypeInstalled); + } + +/** +@SYMTestCaseID GRAPHICS-BITGDI-OUTLINESHA-0008 + +@SYMPREQ PREQ1543 + +@SYMTestCaseDesc Checks the fonts metrics. Tests the metrics with and without outline and shadow effects +for different typefaces and screen modes + +@SYMTestPriority Critical + +@SYMTestStatus Implemented + +@SYMTestActions Create two fonts, one with and without shadow and outline effects on. +Get the font metrics using GetNearestFontToDesignHeightInPixels +Compare the different font metrics for both the fonts. +API Calls: +CTOutlineAndShadowFonts::DoOutlineandShadowFontsMetrics() + +@SYMTestExpectedResults font metrics with and without outline and shadow effects should not vary by more than 3. +*/ +void CTOutlineAndShadowFonts::TestOutlineandShadowFontsMetricsL() + { + INFO_PRINTF1(_L("TestOutlineandShadowFontsMetricsL()")); + FreeScreenDevice(); + CreateScreenDeviceL(EColor16MU); //Create device for EColor16MU + for (TInt fontFaceIndex = 0; fontFaceIndex < KNumOfFontFaces; fontFaceIndex++) + { + for (TInt numOfSubTests = 0; numOfSubTests < KNumberOfSubTestsInTest0008; numOfSubTests++) + { + DoOutlineandShadowFontsMetrics(KTestSettingsToTestFontMetrics[numOfSubTests], fontFaceIndex); + } + } + } + +/** +Utility function to determine whether a specified value lies within a defined range of values. +@param aMin The lower value of the range. +@param aValue The value to be compared. +@param aMax The higher value of the range. +@return ETrue, if the specified value lies within the range; EFalse, otherwise. +*/ +TBool CTOutlineAndShadowFonts::TestRange(TInt aMin, TInt aValue, TInt aMax) + { + if (Rng(aMin, aValue, aMax)) + { + return ETrue; + } + else + { + INFO_PRINTF4(_L("TestRange: !(%i !<= %i !<= %i)"), aMin, aValue, aMax); + return EFalse; + } + } + +/** +Utility function to determine whether a specified value is below a certain value. +@param aValue The value to be compared. +@param aMax The highest permitted value. +@return ETrue, if the specified value is below the maximum; EFalse, otherwise. +*/ +TBool CTOutlineAndShadowFonts::TestLessThanOrEqual(TInt aValue, TInt aMax) + { + if (aValue <= aMax) + { + return ETrue; + } + else + { + INFO_PRINTF3(_L("TestLessThanOrEqual: !(%i !<= %i)"), aValue, aMax); + return EFalse; + } + } + +/** +Auxilary function called from TestOutlineandShadowFontsMetricsL +@param aSettings holds the effects settings (outline, shadow etc...) +@param aFontIndex holds the font index +*/ +void CTOutlineAndShadowFonts::DoOutlineandShadowFontsMetrics(const STestFontParameters &aSettings, TInt aFontIndex) + { + TFontSpec fontSpecWithOutEffects; + //Create fontspec without shadow and outline effects on + PrepareTestEnvironment(fontSpecWithOutEffects, aSettings , aFontIndex, EFalse, EFalse); + CFbsFont* font1 = NULL; + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font1,fontSpecWithOutEffects) == KErrNone); + TEST(font1 != NULL); + + TFontSpec fontSpecWithEffects; + //Create fontspec with shadow and outline effects on if asked for + PrepareTestEnvironment(fontSpecWithEffects, aSettings, aFontIndex, ETrue, EFalse); + CFbsFont* font2 = NULL; + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font2,fontSpecWithEffects) == KErrNone); + TEST(font2 != NULL); + + //get the name of the fonts + TOpenFontFaceAttrib font1Attrib; + TBool haveFont1Attrib; + haveFont1Attrib = font1->GetFaceAttrib(font1Attrib); + INFO_PRINTF1(_L("Font names")); + if (haveFont1Attrib) + { + INFO_PRINTF1(font1Attrib.FullName()); + } + TOpenFontFaceAttrib font2Attrib; + TBool haveFont2Attrib; + haveFont2Attrib = font2->GetFaceAttrib(font2Attrib); + if (haveFont2Attrib) + { + INFO_PRINTF1(font2Attrib.FullName()); + } + + //Check different font metrics with and without outline and shadow effects + TUid uid1 = font1->TypeUid(); + TUid uid2 = font2->TypeUid(); + ASSERT_EQUALS(KCFbsFontUid, uid1); + ASSERT_EQUALS(KCFbsFontUid, uid2); + TInt valueFontWithoutEffects = font1->AscentInPixels(); + TInt valueFontWithEffects = font2->AscentInPixels(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + valueFontWithoutEffects = font1->BaselineOffsetInPixels(); + valueFontWithEffects = font2->BaselineOffsetInPixels(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + for (TInt c=0;c<256;c++) + { + valueFontWithoutEffects = font1->CharWidthInPixels(c); + valueFontWithEffects = font2->CharWidthInPixels(c); + TEST(valueFontWithoutEffects == valueFontWithEffects); + } + //CharactersJoin + valueFontWithoutEffects = font1->DescentInPixels(); + valueFontWithEffects = font2->DescentInPixels(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + //Extended function + valueFontWithoutEffects = font1->FontCapitalAscent(); + valueFontWithEffects = font2->FontCapitalAscent(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + valueFontWithoutEffects = font1->FontLineGap(); + valueFontWithEffects = font2->FontLineGap(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + valueFontWithoutEffects = font1->FontMaxAscent(); + valueFontWithEffects = font2->FontMaxAscent(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + valueFontWithoutEffects = font1->FontMaxDescent(); + valueFontWithEffects = font2->FontMaxDescent(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + valueFontWithoutEffects = font1->FontMaxHeight(); + valueFontWithEffects = font2->FontMaxHeight(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + //FontSpecInTwips - will be different + TFontSpec spec = font1->FontSpecInTwips(); + TFontSpec spec2 = font2->FontSpecInTwips(); + TEST(spec.iHeight == spec2.iHeight); + valueFontWithoutEffects = font1->FontStandardDescent(); + valueFontWithEffects = font2->FontStandardDescent(); + TEST(valueFontWithoutEffects+KDifferByOne >= valueFontWithEffects); + + valueFontWithoutEffects = font1->HeightInPixels(); + valueFontWithEffects = font2->HeightInPixels(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + valueFontWithoutEffects = font1->MaxCharWidthInPixels(); + valueFontWithEffects = font2->MaxCharWidthInPixels(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + valueFontWithoutEffects = font1->MaxNormalCharWidthInPixels(); + valueFontWithEffects = font2->MaxNormalCharWidthInPixels(); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + _LIT(KMeasureText,"ABCdef456"); + CFont::TMeasureTextOutput out1; + CFont::TMeasureTextOutput out2; + valueFontWithoutEffects = font1->MeasureText(KMeasureText,NULL,&out1); + valueFontWithEffects = font2->MeasureText(KMeasureText,NULL,&out2); + TEST(valueFontWithoutEffects == valueFontWithEffects); + TEST(out1.iChars == out2.iChars); + TEST(out1.iGlyphs == out2.iGlyphs); + TEST(out1.iGroups == out2.iGroups); + TEST(out1.iSpaces == out2.iSpaces); + TEST(TestLessThanOrEqual(out1.iBounds.iTl.iX-KDifferByOne, out2.iBounds.iTl.iX)); + TEST(TestLessThanOrEqual(out1.iBounds.iTl.iY-KDifferByOne, out2.iBounds.iTl.iY)); + TEST(TestLessThanOrEqual(out1.iBounds.iBr.iX-KDifferByOne, out2.iBounds.iBr.iX)); + TEST(TestLessThanOrEqual(out1.iBounds.iBr.iY-KDifferByOne, out2.iBounds.iBr.iY)); + TEST(TestLessThanOrEqual(out1.iMaxGlyphSize.iHeight-KDifferByOne, out2.iMaxGlyphSize.iHeight)); + TEST(TestLessThanOrEqual(out1.iMaxGlyphSize.iWidth-KDifferByOne, out2.iMaxGlyphSize.iWidth)); + valueFontWithoutEffects = font1->TextCount(KMeasureText, 30); + valueFontWithEffects = font2->TextCount(KMeasureText, 30); + TEST(valueFontWithoutEffects == valueFontWithEffects); + TInt val3; + TInt val4; + valueFontWithoutEffects = font1->TextCount(KMeasureText, 30, val3); + valueFontWithEffects = font2->TextCount(KMeasureText, 30, val4); + TEST(val3 == val4); + TEST(valueFontWithoutEffects == valueFontWithEffects); + valueFontWithoutEffects = font1->TextWidthInPixels(KMeasureText); + valueFontWithEffects = font2->TextWidthInPixels(KMeasureText); + TEST(TestRange(valueFontWithoutEffects, valueFontWithEffects, valueFontWithoutEffects+KDifferByThree)); + uid1 = font1->TypeUid(); + uid2 = font2->TypeUid(); + TEST(uid1 == uid2); + for (TInt c=0;c<256;c++) + { + const TUint8 *p1 = NULL; + const TUint8 *p2 = NULL; + TCharacterMetrics m1 = font1->CharacterMetrics(c, p1); + TCharacterMetrics m2 = font2->CharacterMetrics(c, p2); + TEST(TestLessThanOrEqual(m1.iAscentInPixels-KDifferByOne, m2.iAscentInPixels)); + TEST(TestLessThanOrEqual(m1.iHeightInPixels-KDifferByOne, m2.iHeightInPixels)); + TEST(TestLessThanOrEqual(m1.iLeftAdjustInPixels-KDifferByTwo, m2.iLeftAdjustInPixels)); + TEST(m1.iMoveInPixels == m2.iMoveInPixels); + TEST(TestLessThanOrEqual(m1.iRightAdjustInPixels-KDifferByTwo, m2.iRightAdjustInPixels)); + } + TOpenFontMetrics ofm1; + TOpenFontMetrics ofm2; + TBool r1 = font1->GetFontMetrics(ofm1); + TBool r2 = font2->GetFontMetrics(ofm2); + TEST(ofm1.Size() == ofm2.Size()); + TEST(ofm1.Ascent() == ofm2.Ascent()); + TEST(ofm1.Descent() == ofm2.Descent()); + TEST(ofm1.MaxHeight() == ofm2.MaxHeight()); + TEST(ofm1.MaxDepth() == ofm2.MaxDepth()); + TEST(ofm1.MaxWidth() == ofm2.MaxWidth()); + + valueFontWithoutEffects = font1->RawTextWidthInPixels(KMeasureText); + valueFontWithEffects = font2->RawTextWidthInPixels(KMeasureText); + TEST(valueFontWithoutEffects == valueFontWithEffects); + + valueFontWithoutEffects = font1->TextWidthInPixels(KMeasureText); + valueFontWithEffects = font2->TextWidthInPixels(KMeasureText); + TEST(TestLessThanOrEqual(valueFontWithoutEffects, valueFontWithEffects)); + + SCharWidth scw1; + SCharWidth scw2; + font1->TextWidthInPixels(KMeasureText,scw1); + font2->TextWidthInPixels(KMeasureText,scw2); + TEST(TestLessThanOrEqual(scw1.iLeftAdjust-KDifferByOne, scw2.iLeftAdjust)); + TEST(scw1.iMove == scw2.iMove); + TEST(TestLessThanOrEqual(scw1.iRightAdjust-KDifferByTwo, scw2.iRightAdjust)); + TEST(TestLessThanOrEqual(scw1.iWidth-KDifferByOne, scw2.iWidth)); + iBitmapDevice->ReleaseFont(font2); + iBitmapDevice->ReleaseFont(font1); + } + +/** +@SYMTestCaseID GRAPHICS-BITGDI-OUTLINESHA-0009 + +@SYMPREQ PREQ1543 + +@SYMTestCaseDesc Test the setter and getters for pen colour, brush colour and shadow colour. + +@SYMTestPriority Critical + +@SYMTestStatus Implemented + +@SYMTestActions Set colors to pen, brush and shadow call SetPenColor(), SetBrushColor(), SetShadowColor() respectively +Get colors of pen, brush and shadow using PenColor(), BrushColor() and GetShadowColor() respectively + +@SYMTestExpectedResults pen, brush and shadow colour should return default colours if not set, +else should return the colour set using SetPenColor(), SetBrushColor() and SetShadowColor() respectively +*/ +void CTOutlineAndShadowFonts::TestOutlinePenAndShadowColorL() + { + INFO_PRINTF1(_L("TestOutlinePenAndShadowColorL()")); + for(TInt displayMode = ENone; displayMode < KNumOfDisplayModes; displayMode++) + { + FreeScreenDevice(); + CreateScreenDeviceL(KDisplayModes[displayMode]); + DoOutlinePenAndShadowColor(); + } + } + +/** +Auxilary function called from TestOutlinePenAndShadowColorL +API Calls: +CFbsBitGc::PenColor() +CFbsBitGc::SetPenColor() +CFbsBitGc::BrushColor() +CFbsBitGc::SetBrushColor() +CFbsBitGc::GetShadowColor() +CFbsBitGc::SetShadowColor() +*/ +void CTOutlineAndShadowFonts::DoOutlinePenAndShadowColor() + { + //iGc->Reset(); + TRgb color; + color = iGc->PenColor(); + + //Pen colour is used for drawing outline + TEST(color == KDefaultOutlinePenColor); + color = iGc->BrushColor(); + + //Brush colour is used as fill colour + TEST(color == KDefaultFillColor); + iGc->GetShadowColor(color); + TEST(color == KDefaultShadowColor); + iGc->SetShadowColor(KRgbGreen); + iGc->GetShadowColor(color); + TEST(color == KRgbGreen); + iGc->SetPenColor(KRgbYellow); + color = iGc->PenColor(); + TEST(color == KRgbYellow); + iGc->SetBrushColor(KRgbRed); + color = iGc->BrushColor(); + TEST(color == KRgbRed); + } + +/** +@SYMTestCaseID GRAPHICS-BITGDI-OUTLINESHA-0010 + +@SYMPREQ PREQ1543 + +@SYMTestCaseDesc Tests the text drawn using DrawTextVertical and DrawText with shadow and outline effects on +with different display modes and orientations. + +@SYMTestPriority Critical + +@SYMTestStatus Implemented + +@SYMTestActions Call DrawTextVertical and DrawText with different effect on, display modes and orientations. +API Calls: +CFbsBitGc::DrawTextVertical() +CFbsBitGc::DrawText() +CTOutlineAndShadowFonts::CompareHashValuesL() + +@SYMTestExpectedResults Hash generated for the drawn text should be same with the baselined hash value. +*/ +void CTOutlineAndShadowFonts::TestDrawTextWithOutlineAndShadowL() + { + INFO_PRINTF1(_L("TestDrawTextWithOutlineAndShadowL()")); + for(TInt displayMode = 0; displayMode < KNumOfDisplayModes; displayMode++) + { + FreeScreenDevice(); + CreateScreenDeviceL(KDisplayModes[displayMode]); + INFO_PRINTF2(_L("Display mode: %S"), &KDisplayModeNames[displayMode]); + for (TInt orient = CFbsBitGc::EGraphicsOrientationNormal; orient <= CFbsBitGc::EGraphicsOrientationRotated270; orient++) + { + iGc->SetOrientation((CFbsBitGc::TGraphicsOrientation)orient); + for (TInt fontFaceIndex = 0; fontFaceIndex < KNumOfFontFaces; fontFaceIndex++) + { + for (TInt numOfSubTests = 0; numOfSubTests < KNumberOfSubTestsInTest0010; numOfSubTests++) + { + //Test with only one display mode i.e. EColor16MU for EMonochromeGlyphBitmap to reduce test execution time + if ((KTestSettingsToTestOutlineAndShadow[numOfSubTests].fSpecAndGcSettings & ESetMonochromeGlyphBitmap) && (displayMode != EColor16MU)) + { + continue; + } + + //Test transparency for display mode EColor64K and above as it is not supported in other display modes + if (KTestSettingsToTestOutlineAndShadow[numOfSubTests].penColor.Alpha() < 255 && displayMode < 6) + { + continue; + } + HBufC* hashIdString = iHashUtil->GenerateHashIdStringLC(KTestName0010, numOfSubTests, KFontFaceShortName, fontFaceIndex, displayMode, orient); + DoDrawTextWithOutlineAndShadowL(KTestSettingsToTestOutlineAndShadow[numOfSubTests], *hashIdString, fontFaceIndex); + CleanupStack::PopAndDestroy(hashIdString); + } + } + } + } + iGc->SetOrientation(CFbsBitGc::EGraphicsOrientationNormal); + } + +/** +Auxilary function called TestDrawTextWithOutlineAndShadowL. +@param aSettings holds the effects settings (Outline, Shadow, Bitmap type etc...) +@param aHashIdString holds the HashID string +@param aFontIndex holds the font index +*/ +void CTOutlineAndShadowFonts::DoDrawTextWithOutlineAndShadowL(const STestFontParameters &aSettings, const TDesC& aHashIdString, const TInt aFontIndex) + { + TFontSpec fontSpec; + PrepareTestEnvironment(fontSpec, aSettings, aFontIndex, ETrue, ETrue); + CFont* font; + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font, fontSpec) == KErrNone); + SCleanFont cleanupFont = {iBitmapDevice, font}; + CleanupStack::PushL(TCleanupItem(CleanUpFont, &cleanupFont)); + iGc->UseFont(font); + if(EVerticalDraw & aSettings.fSpecAndGcSettings) + { + iGc->DrawTextVertical(KTextPhrase, TPoint(20,60), ERotate90Degrees & aSettings.fSpecAndGcSettings); + } + else + { + iGc->DrawText(KTextPhrase, KPoint); + } + iHashUtil->CompareHashValuesL(aHashIdString); + CleanupStack::Pop();//font + iBitmapDevice->ReleaseFont(font); + iGc->DiscardFont(); + } + +/** +@SYMTestCaseID GRAPHICS-BITGDI-OUTLINESHA-0011 + +@SYMPREQ PREQ1543 + +@SYMTestCaseDesc Tests outline and shadow effects with strikethrough, softedge and underLine +for different orientations. + +@SYMTestPriority Critical + +@SYMTestStatus Implemented + +@SYMTestActions Draw text with different effects on +Repeat the same with all supported display modes and orientations. Generate hash key for the drawn text. +API Calls: +CFbsBitGc::DrawText() +CTHashReferenceImages::CompareHashValuesL() + +@SYMTestExpectedResults Hash generated for the drawn text should be same with the baselined hash value. +*/ +void CTOutlineAndShadowFonts::TestDrawTextWithStrikeThroughL() + { + INFO_PRINTF1(_L("TestDrawTextWithStrikeThroughL()")); + for(TInt displayMode = 0; displayMode < KNumOfDisplayModes; displayMode++) + { + INFO_PRINTF2(_L("Display mode: %S"), &KDisplayModeNames[displayMode]); + FreeScreenDevice(); + CreateScreenDeviceL(KDisplayModes[displayMode]); + + for (TInt numOfSubTests = 0; numOfSubTests < KNumberOfSubTestsInTest0011; numOfSubTests++) + { + HBufC* hashIdString = iHashUtil->GenerateHashIdStringLC(KTestName0011, numOfSubTests, &(KFontFace[0]), 0, displayMode, 0); + DoSetStrikeThroughAndDrawTestL(KTestSettingsToTestStrikeAndUnderline[numOfSubTests], *hashIdString); + CleanupStack::PopAndDestroy(hashIdString); + } + } + } + +/** +Auxilary function called from TestDrawTextWithStrikeThroughL API +@SYMTestCaseDesc Tests drawn text with different effects like +strikethrough, softedge, underLine etc for different orientations. +@param aSettings holds font settings +@param aHashIdString holds HashID +*/ +void CTOutlineAndShadowFonts::DoSetStrikeThroughAndDrawTestL(const STestFontParameters &aSettings, const TDesC& aHashIdString) + { + TFontSpec fontSpec; + //Passing 0 as font index as testing with one typeface is sufficient in this case + PrepareTestEnvironment(fontSpec, aSettings, 0, ETrue, EFalse); + + CFont* font; + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font, fontSpec) == KErrNone); + SCleanFont cleanupFont = {iBitmapDevice, font}; + CleanupStack::PushL(TCleanupItem(CleanUpFont, &cleanupFont)); + iGc->UseFont(font); + iGc->DrawText(KTextPhrase,KPoint); + iHashUtil->CompareHashValuesL(aHashIdString); + CleanupStack::Pop();//font + iBitmapDevice->ReleaseFont(font); + iGc->DiscardFont(); + } + +/** +@SYMTestCaseID GRAPHICS-BITGDI-OUTLINESHA-0012 + +@SYMTestCaseDesc Negative tests. + +@SYMTestPriority Critical + +@SYMTestStatus Implemented + +@SYMTestActions Create font spec with different -ve scenarios. +Like pass bitmap type other than valid on, -ve pen size etc. + +API Calls: +CFbsBitGc::GetNearestFontToDesignHeightInPixels() +TFontStyle::SetEffects() + +@SYMTestExpectedResults Tests should not panic. +*/ +void CTOutlineAndShadowFonts::NegativeRastTestL() + { + INFO_PRINTF1(_L("NegativeRastTestL()")); + FreeScreenDevice(); + CreateScreenDeviceL(KDisplayModes[9]); //Create device for EColor16MU + + TFontSpec fsp; + STestFontParameters settings; + + INFO_PRINTF1(_L("Drawing empty text")); + settings.fSpecAndGcSettings = EDropShadowOn | EOutlineOn | ESetAntiAliasedGlyphBitmap; + PrepareTestEnvironment(fsp, settings, 0); + iGc->SetPenSize(TSize(10,10)); + NegativeRastTestDrawText(fsp); + + INFO_PRINTF1(_L("Drawing empty text with unknown typeface")); + fsp.iTypeface.iName=_L("ERROR FONT"); //Typeface which does not exist + iGc->SetPenSize(TSize(3,3)); + NegativeRastTestDrawText(fsp); + + INFO_PRINTF1(_L("Drawing empty text with invalid glyph bitmap type")); + fsp.iFontStyle.SetBitmapType((TGlyphBitmapType)KInvalidBitmapType); //Invalid glyph bitmap type + CFont* font; + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font, fsp) == KErrNone); + iGc->UseFont(font); + iGc->DrawText(KTextPhrase,KPoint); + TEST(font->FontSpecInTwips().iFontStyle.BitmapType() == EMonochromeGlyphBitmap); + iBitmapDevice->ReleaseFont(font); + iGc->DiscardFont(); + + INFO_PRINTF1(_L("Drawing text with brush style ENullBrush")); + iGc->SetBrushStyle(CGraphicsContext::ENullBrush); + settings.fSpecAndGcSettings = EDropShadowOn | EOutlineOn | ESetAntiAliasedGlyphBitmap; + PrepareTestEnvironment(fsp, settings, 0); + NegativeRastTestDrawText(fsp); + + INFO_PRINTF1(_L("Drawing text with brush style ESolidBrush")); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + NegativeRastTestDrawText(fsp); + + INFO_PRINTF1(_L("Drawing text with large pen size")); + iGc->SetPenSize(TSize(1000,1000)); + NegativeRastTestDrawText(fsp); + + INFO_PRINTF1(_L("Drawing text with -ve pen size")); + settings.fSpecAndGcSettings = EDropShadowOn | ESetAntiAliasedGlyphBitmap; + PrepareTestEnvironment(fsp, settings, 0); + iGc->SetPenSize(TSize(-1,-1)); + NegativeRastTestDrawText(fsp); + } + +/** +Auxilary function called from NegativeRastTestL +@param aFontSpec holds fonts specifications +*/ +void CTOutlineAndShadowFonts::NegativeRastTestDrawText(const TFontSpec &aFontSpec) + { + CFont* font; + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font, aFontSpec) == KErrNone); + iGc->UseFont(font); + iGc->DrawText(KTextPhrase, KPoint); + iGc->DrawTextVertical(KTextPhrase, KPoint, EFalse); + iGc->DiscardFont(); + iBitmapDevice->ReleaseFont(font); + } + +/** +@SYMTestCaseID GRAPHICS-BITGDI-OUTLINESHA-0013 + +@SYMPREQ PREQ1543 + +@SYMTestCaseDesc Test glyph bitmap types with outline and shadow effects on and off + +@SYMTestPriority Critical + +@SYMTestStatus Implemented + +@SYMTestActions Create fonts with and without specifying the bitmap type +API Calls: +TFontStyle::BitmapType() + +@SYMTestExpectedResults Glyph bitmap type should be EFourColourBlendGlyphBitmap when either of outline or shadow effect on and EAntiAliasedGlyphBitmap set in fontspec +*/ +void CTOutlineAndShadowFonts::TestCheckBitmapTypesL() + { + INFO_PRINTF1(_L("TestCheckBitmapTypesL()")); + FreeScreenDevice(); + CreateScreenDeviceL(KDisplayModes[9]); //Create device for EColor16MU + + CFont* font; + TFontSpec fontSpec; + STestFontParameters settings; + + PrepareTestEnvironment(fontSpec, settings, 0); + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font,fontSpec) == KErrNone); + //Check for the bitmap type to be EMonochromeGlyphBitmap when no bitmap type is set. + TEST(font->FontSpecInTwips().iFontStyle.BitmapType() == EMonochromeGlyphBitmap); + iBitmapDevice->ReleaseFont(font); + + settings.fSpecAndGcSettings = EDropShadowOn | EOutlineOn | ESetAntiAliasedGlyphBitmap; + PrepareTestEnvironment(fontSpec, settings, 0); + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font,fontSpec) == KErrNone); + //Check for the bitmap type to be EFourColourBlendGlyphBitmap when either or both the + //EDropShadow or EOutline effects are on. + TEST(font->FontSpecInTwips().iFontStyle.BitmapType() == EFourColourBlendGlyphBitmap); + iBitmapDevice->ReleaseFont(font); + + settings.fSpecAndGcSettings = EDropShadowOn | ESetAntiAliasedGlyphBitmap; + PrepareTestEnvironment(fontSpec, settings, 0); + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font,fontSpec) == KErrNone); + //Check for the bitmap type to be EFourColourBlendGlyphBitmap when either or both the + //EDropShadow or EOutline effects are on. + TEST(font->FontSpecInTwips().iFontStyle.BitmapType() == EFourColourBlendGlyphBitmap); + iBitmapDevice->ReleaseFont(font); + + settings.fSpecAndGcSettings = EOutlineOn | ESetAntiAliasedGlyphBitmap; + PrepareTestEnvironment(fontSpec, settings, 0); + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font,fontSpec) == KErrNone); + //Check for the bitmap type to be EFourColourBlendGlyphBitmap when either or both the + //EDropShadow or EOutline effects are on. + TEST(font->FontSpecInTwips().iFontStyle.BitmapType() == EFourColourBlendGlyphBitmap); + iBitmapDevice->ReleaseFont(font); + } + +/** +@SYMTestCaseID GRAPHICS-BITGDI-OUTLINESHA-0014 + +@SYMPREQ PREQ1543 + +@SYMTestCaseDesc OOM tests, checks OOM condition for GetNearestFontToDesignHeightInPixels. + +@SYMTestPriority Critical + +@SYMTestStatus Implemented + +@SYMTestActions +API Calls: +CFbsBitGc::GetNearestFontToDesignHeightInPixels() +TFontStyle::SetEffects() + +@SYMTestExpectedResults Checks the OOM condition and finds if it takes care of OOM cases for GetNearestFontToDesignHeightInPixels +*/ +void CTOutlineAndShadowFonts::TestOOML() + { + INFO_PRINTF1(_L("TestOOML()")); + FreeScreenDevice(); + CreateScreenDeviceL(KDisplayModes[9]); //Create device for EColor16MU + + //OOM for normal text + for(TInt fontFaceIndex = 0; fontFaceIndex < KNumOfFontFaces; fontFaceIndex++) + { + DoOOM(fontFaceIndex, EFalse); + } + } + +/** +Auxilary function called from TestOOML API +@SYMTestCaseDesc checks OOM condition for DrawText() and DrawTextVertical(). +@param aFontSpec holds font specifications +@param aDrawVerticalText holds bool, if true calls DrawTextVertical else calls DrawText api's +*/ +void CTOutlineAndShadowFonts::DoOOM(TInt aFontIndex, TBool aDrawVerticalText) + { + __UHEAP_RESET; + TFontSpec fSpec; + STestFontParameters settings; + settings.fSpecAndGcSettings = EDropShadowOn | EOutlineOn | ESetAntiAliasedGlyphBitmap; + PrepareTestEnvironment(fSpec, settings, aFontIndex); + + //GetNearestFontToDesignHeightInPixels + iFbs->SendCommand(EFbsMessDefaultAllocFail,0); + CFont* font = NULL; + TEST(iBitmapDevice->GetNearestFontToDesignHeightInPixels(font,fSpec) == KErrNone); + TInt ret; + iBitmapDevice->ReleaseFont(font); + for (TInt count = 1; ; count++) + { + __UHEAP_SETFAIL(RHeap::EDeterministic,count); + __UHEAP_MARK; + font=NULL; + ret = iBitmapDevice->GetNearestFontToDesignHeightInPixels(font,fSpec); + if (ret == KErrNoMemory) + { + ASSERT(!font); + __UHEAP_MARKEND; + } + else if (ret == KErrNone) + { + ASSERT(font); + iBitmapDevice->ReleaseFont(font); + __UHEAP_MARKEND; + break; + } + else + { + __UHEAP_MARKEND; + TEST(ret == KErrNone); + } + iBitmapDevice->ReleaseFont(font); + } + + //DrawText and DrawTextVertical with EDropShadow effect on and EOutline effect off + settings.fSpecAndGcSettings = EDropShadowOn | ESetAntiAliasedGlyphBitmap; + settings.brushColor = KRgbBlack; + settings.penColor = KRgbGreen; + settings.shadowColor = KRgbRed; + PrepareTestEnvironment(fSpec, settings, aFontIndex, ETrue, ETrue); + GetFontAndDrawOOM(fSpec, aDrawVerticalText); + + //DrawText and DrawTextVertical with EDropShadow effect off and EOutline effect on + settings.fSpecAndGcSettings = EOutlineOn | ESetAntiAliasedGlyphBitmap; + PrepareTestEnvironment(fSpec, settings, aFontIndex, ETrue, ETrue); + GetFontAndDrawOOM(fSpec, aDrawVerticalText); + + //DrawText and DrawTextVertical with EDropShadow effect on and EOutline effect on + settings.fSpecAndGcSettings = EDropShadowOn | EOutlineOn | ESetAntiAliasedGlyphBitmap; + PrepareTestEnvironment(fSpec, settings, aFontIndex, ETrue, ETrue); + GetFontAndDrawOOM(fSpec, aDrawVerticalText); + + __UHEAP_RESET; + } + +/** +Auxilary function called from DoOOM API +@SYMTestCaseDesc checks OOM condition for DrawText() and DrawTextVertical(). +@param aFontSpec holds font specifications +@param aDrawVerticalText holds bool value, if true calls DrawTextVertical else calls DrawText api's +*/ +void CTOutlineAndShadowFonts::GetFontAndDrawOOM(TFontSpec aFontSpec, TBool aDrawVerticalText) + { + __UHEAP_RESET; + _LIT(KDRAWME,"Outline and Shadow"); + CFont* font = NULL; + iFbs->SendCommand(EFbsMessDefaultAllocFail,0); + TInt ret= iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)font, aFontSpec); + TEST(ret == KErrNone); + for (TInt count = 1; ; count++) + { + __UHEAP_SETFAIL(RHeap::EDeterministic,count); + __UHEAP_MARK; + iGc->UseFont(font); + if (aDrawVerticalText) + { + iGc->DrawTextVertical(KDRAWME, TPoint(3, 4), EFalse); + } + else + { + iGc->DrawText(KDRAWME, TPoint(3, 4)); + } + if (ret == KErrNoMemory) + { + iGc->DrawTextVertical(KDRAWME, TPoint(3, 4), EFalse); + __UHEAP_MARKEND; + } + else if (ret == KErrNone) + { + ASSERT(font); + iBitmapDevice->ReleaseFont(font); + iGc->DiscardFont(); + __UHEAP_MARKEND; + break; + } + else + { + __UHEAP_MARKEND; + TEST(ret == KErrNone); + } + } + } + +/** +@SYMTestCaseID GRAPHICS-BITGDI-OUTLINESHA-0015 + +@SYMPREQ PREQ2555 + +@SYMTestCaseDesc Check bitmaptype EAntiAliasedOrMonochromeGlyphBitmap returns the correct actual + bitmap type. This test uses the "Series 60 Sans SemiBold" font. + Sizes 0-7:monochrome; 8-16:anti-aliased; 16 and above:monochrome. + +@SYMTestPriority Normal + +@SYMTestStatus Implemented + +@SYMTestActions +Set the font size of the test font to 6, 12, 20 respectively and the bitmap type to EAntiAliasedOrMonochromeGlyphBitmap. +Then call CFbsDevice::GetNearestFontToDesignHeightInPixels() to return the font and draw a text string on the left side of +the bitmap. Draw the same string using the reference font on the right side of the bitmap. Use CFbsDevice::RectCompare() +to compare the two halves of the bitmap. + +@SYMTestExpectedResults The two halves should be the same. +*/ +void CTOutlineAndShadowFonts::TestAntiAliasedOrMonochromeGlyphBitmapL() + { + iGc->Reset(); + FreeScreenDevice(); + CreateScreenDeviceL(EColor64K); + _LIT(KGaspTypefaceName, "Series 60 Sans SemiBold"); + TFontSpec testFontSpec; + testFontSpec.iTypeface.iName = KGaspTypefaceName; + testFontSpec.iFontStyle.SetBitmapType(EAntiAliasedOrMonochromeGlyphBitmap); + TFontSpec refFontSpec; + refFontSpec.iTypeface.iName = KGaspTypefaceName; + + TInt fontsizes[3] = {6, 12, 20}; + CFont* testFont; + CFont* refFont; + TPoint leftMidPoint = TPoint(KScreenWidth/4, KScreenHeight/2); + TPoint rightMidPoint = TPoint(KScreenWidth*3/4, KScreenHeight/2); + _LIT(KTestString, "Abcde"); + + //anti-aliased + testFontSpec.iHeight = fontsizes[0]; + refFontSpec.iHeight = fontsizes[0]; + refFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + User::LeaveIfError(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)testFont,testFontSpec)); + iGc->UseFont(testFont); + iGc->DrawText(KTestString, leftMidPoint); + User::LeaveIfError(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)refFont,refFontSpec)); + iGc->UseFont(refFont); + iGc->DrawText(KTestString, rightMidPoint); + TEST(iBitmapDevice->RectCompare(TRect(0,0,KScreenWidth>>1,KScreenHeight), *iBitmapDevice, TRect(KScreenWidth>>1,0,KScreenWidth,KScreenHeight))); + iBitmapDevice->ReleaseFont(testFont); + iBitmapDevice->ReleaseFont(refFont); + + //monochrome + iGc->Clear(); + testFontSpec.iHeight = fontsizes[1]; + refFontSpec.iHeight = fontsizes[1]; + refFontSpec.iFontStyle.SetBitmapType(EMonochromeGlyphBitmap); + User::LeaveIfError(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)testFont,testFontSpec)); + iGc->UseFont(testFont); + iGc->DrawText(KTestString, leftMidPoint); + User::LeaveIfError(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)refFont,refFontSpec)); + iGc->UseFont(refFont); + iGc->DrawText(KTestString, rightMidPoint); + TEST(iBitmapDevice->RectCompare(TRect(0,0,KScreenWidth>>1,KScreenHeight), *iBitmapDevice, TRect(KScreenWidth>>1,0,KScreenWidth,KScreenHeight))); + iBitmapDevice->ReleaseFont(testFont); + iBitmapDevice->ReleaseFont(refFont); + + //anti-aliased + iGc->Clear(); + testFontSpec.iHeight = fontsizes[2]; + refFontSpec.iHeight = fontsizes[2]; + refFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + User::LeaveIfError(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)testFont,testFontSpec)); + iGc->UseFont(testFont); + iGc->DrawText(KTestString, leftMidPoint); + User::LeaveIfError(iBitmapDevice->GetNearestFontToDesignHeightInPixels((CFont*&)refFont,refFontSpec)); + iGc->UseFont(refFont); + iGc->DrawText(KTestString, rightMidPoint); + TEST(iBitmapDevice->RectCompare(TRect(0,0,KScreenWidth>>1,KScreenHeight), *iBitmapDevice, TRect(KScreenWidth>>1,0,KScreenWidth,KScreenHeight))); + iBitmapDevice->ReleaseFont(testFont); + iBitmapDevice->ReleaseFont(refFont); + } +/** +Sets the fontspec and gc attributes according to the flags set in STestFontParameters for the test. +Before setting gc attributes it is cleared and reset. +@param aFontSpec holds all effective font settings +@param aSettings holds the flags for setting the fontspec and gc +@param aFontIndex the fonts index of KFontFace to be set as typeface +@param aSetEffects ETrue will set the effects on in fontspec if their flags are enabled. By default it is ETrue. +@param aSetColors ETrue will set the colours in gc from STestFontParameters. By default it is EFalse. +*/ +void CTOutlineAndShadowFonts::PrepareTestEnvironment(TFontSpec &aFontSpec, const STestFontParameters &aSettings, const TInt aFontIndex, TBool aSetEffects, TBool aSetColors) + { + //Set the typeface from the font face array + aFontSpec.iTypeface.iName = KFontFace[aFontIndex]; + aFontSpec.iHeight = KHeight; + + //Set the effects on if any of flags for the effects are set in aSettings and aSetEffects is ETrue + if(aSetEffects) + { + aFontSpec.iFontStyle.SetEffects(FontEffect::EDropShadow, EDropShadowOn & aSettings.fSpecAndGcSettings); + aFontSpec.iFontStyle.SetEffects(FontEffect::EOutline, EOutlineOn & aSettings.fSpecAndGcSettings); + aFontSpec.iFontStyle.SetEffects(FontEffect::ESoftEdge, ESoftEdgeOn & aSettings.fSpecAndGcSettings); + aFontSpec.iFontStyle.SetEffects(FontEffect::EAlgorithmicBold, EAlgorithmicBoldOn & aSettings.fSpecAndGcSettings); + } + + iGc->Reset(); + iGc->Clear(); + iGc->SetStrikethroughStyle((EIsStrikethroughOn & aSettings.fSpecAndGcSettings) ? EStrikethroughOn : EStrikethroughOff); + iGc->SetUnderlineStyle((EIsUnderlineOn & aSettings.fSpecAndGcSettings) ? EUnderlineOn : EUnderlineOff); + + //Set the glyph bitmap type + if(ESetMonochromeGlyphBitmap & aSettings.fSpecAndGcSettings) + { + aFontSpec.iFontStyle.SetBitmapType(EMonochromeGlyphBitmap); + } + else if(ESetAntiAliasedGlyphBitmap & aSettings.fSpecAndGcSettings) + { + aFontSpec.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + } + + //Set the colours in gc if asked for + if(aSetColors) + { + iGc->SetBrushColor(aSettings.brushColor); + iGc->SetPenColor(aSettings.penColor); + iGc->SetShadowColor(aSettings.shadowColor); + } + } + +void CTOutlineAndShadowFonts::RunTestCaseL(TInt aCurTestCase) + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName); + switch (aCurTestCase) + { + case 1: + { +/** +@SYMTestCaseID GRAPHICS-BITGDI-OUTLINESHA-0007 +*/ + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-OUTLINESHA-0007")); + CheckMonoTypeInstalledL(); + break; + } + case 2: + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-OUTLINESHA-0008")); + TestOutlineandShadowFontsMetricsL(); + break; + } + case 3: + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-OUTLINESHA-0009")); + TestOutlinePenAndShadowColorL(); + break; + } + case 4: + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-OUTLINESHA-0010")); + TestDrawTextWithOutlineAndShadowL(); + break; + } + case 5: + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-OUTLINESHA-0011")); + TestDrawTextWithStrikeThroughL(); + break; + } + case 6: + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-OUTLINESHA-0012")); + NegativeRastTestL(); + break; + } + case 7: + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-OUTLINESHA-0013")); + TestCheckBitmapTypesL(); + break; + } + case 8: + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-OUTLINESHA-0015")); + TestAntiAliasedOrMonochromeGlyphBitmapL(); + break; + } + case 9: + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(_L("GRAPHICS-BITGDI-OUTLINESHA-0014")); + TestOOML(); + break; + } + default: + { + ((CTOutlineAndShadowFontsStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName); + ((CTOutlineAndShadowFontsStep*)iStep)->CloseTMSGraphicsStep(); + TestComplete(); + break; + } + } + ((CTOutlineAndShadowFontsStep*)iStep)->RecordTestResultL(); + } + +//-------------- +__CONSTRUCT_STEP__(OutlineAndShadowFonts)