diff -r 000000000000 -r bde4ae8d615e os/graphics/graphicstest/uibench/s60/src/tests_fonts/tfullscreentext.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/graphicstest/uibench/s60/src/tests_fonts/tfullscreentext.cpp Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,260 @@ + // 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 "tfullscreentext.h" +#include "fontdefs.h" +#include "twindow.h" + +#include +#include + + +const TInt KIterationsToTest = 25; // number of iterations + +_LIT(KSemaphore, "SemFullScreenTextSync"); // Name of the global semaphore +_LIT(KTestStep0009,"GRAPHICS-UI-BENCH-S60-0009"); + +// Literals for the ini file +_LIT(KSectNameOpenGLVGTest, "FullScreenFontTest"); +_LIT(KKeyNameVertical, "Vertical"); +_LIT(KKeyNameRightToLeft, "RightToLeft"); + + +CTFullScreenText::CTFullScreenText() + { + SetTestStepName(KFullScreenText); + } + +void CTFullScreenText::InitUIL(CCoeEnv* aCoeEnv) + { + CFullScreenTextAppUi* appUi = new(ELeave) CFullScreenTextAppUi(); + CleanupStack::PushL(appUi); + appUi->ConstructL(iDrawVertically, iRightToLeft); + aCoeEnv->SetAppUi(appUi); // CCoeEnv takes ownership + CleanupStack::Pop(appUi); + } + +/** + * Generates events to communicate with the control. Each time the control receives an event + * it redraws itself. That's necessary because the draw method can't be called directly from + * a different thread. + */ +void CTFullScreenText::GenerateEventL(TRawEvent::TType aEventType) + { + TRawEvent rawEvent; + rawEvent.Set(aEventType, 0, 0); + User::LeaveIfError(UserSvr::AddEvent(rawEvent)); + } + +TVerdict CTFullScreenText::doTestStepPreambleL() + { + // The semaphore has to be created before, otherwise the control can't open it. + TESTNOERRORL(iSemaphore.CreateGlobal(KSemaphore, 0)); + // read values from ini file, if keys not found default values apply + iDrawVertically = EFalse; + GetBoolFromConfig(KSectNameOpenGLVGTest, KKeyNameVertical, iDrawVertically); + iRightToLeft = EFalse; + GetBoolFromConfig(KSectNameOpenGLVGTest, KKeyNameRightToLeft, iRightToLeft); + // baseclass function needs to be called at the end, otherwise + // the values from the ini file would be read after InitUIL() + return CTe_ConeStepBase::doTestStepPreambleL();; + } + +TVerdict CTFullScreenText::doTestStepPostambleL() + { + iSemaphore.Close(); + // undo the button state change + GenerateEventL(TRawEvent::EButton1Up); + return CTe_ConeStepBase::doTestStepPostambleL(); + } + +TVerdict CTFullScreenText::doTestStepL() + { + SetTestStepID(KTestStep0009); + TRAPD(err, FullScreenTextL()); + if (err != KErrNone) + { + SetTestStepResult(EAbort); + } + return TestStepResult(); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-S60-0009 + +@SYMTestCaseDesc +Tests how long it takes to draw text on the full screen. The font is requested +for every redraw. + +@SYMTestActions +The control redraws itself everytime it receives a left button down event. +A semaphore is used to synchronise cone thread and test step thread. Depending on the +ini file the text is drawn from left to right, vertically or normal. + +@SYMTestExpectedResults +Test should pass and log the framerate. +*/ +void CTFullScreenText::FullScreenTextL() + { + iProfiler->InitResults(); + for(TInt i = KIterationsToTest; i > 0; --i) + { + GenerateEventL(TRawEvent::EButton1Down); + iSemaphore.Wait(); + } + iProfiler->MarkResultSetL(); + TSize screenSize = CTWindow::GetDisplaySizeInPixels(); + // todo: Define how to distinguish between tests with different ini files + iProfiler->ResultsAnalysisFrameRate(KTestStep0009, 0, 0, 0, KIterationsToTest, + screenSize.iWidth * screenSize.iHeight); + } + + +CGlobalTextControl* CGlobalTextControl::NewLC(const CCoeControl* aParent, TBool aDrawVertically, TBool aRightToLeft) + { + CGlobalTextControl* self; + self = new(ELeave) CGlobalTextControl(aDrawVertically, aRightToLeft); + CleanupStack::PushL(self); + self->ConstructL(aParent); + return self; + } + +CGlobalTextControl* CGlobalTextControl::NewL(const CCoeControl* aParent, TBool aDrawVertically, TBool aRightToLeft) + { + CGlobalTextControl* self; + self = CGlobalTextControl::NewLC(aParent, aDrawVertically, aRightToLeft); + CleanupStack::Pop(self); + return self; + } + +CGlobalTextControl::CGlobalTextControl(TBool aDrawVertically, TBool aRightToLeft) : + iDrawVertically(aDrawVertically), iRightToLeft(aRightToLeft), + iWsSession(CCoeEnv::Static()->WsSession()) + { + iMargin.SetAllValuesTo(EInsetMargin); + } + +void CGlobalTextControl::ConstructL(const CCoeControl* aParent) + { + User::LeaveIfError(iSemaphore.OpenGlobal(KSemaphore)); + iScreen = new(ELeave) CWsScreenDevice(ControlEnv()->WsSession()); + iScreen->Construct(); // default screen used + if (iRightToLeft) + { + iBidiText = TBidiText::NewL(KRightToLeftText, EMaximumTextLines, TBidiText::ERightToLeft); + } + else + { + iBidiText = TBidiText::NewL(KFullScreenSampleText, EMaximumTextLines, TBidiText::ELeftToRight); + } + if (aParent) + { + SetContainerWindowL(*aParent); + } + else + { + CreateWindowL(); + ActivateL(); + } + SetRect(TRect(TPoint(0,0), CTWindow::GetDisplaySizeInPixels())); + } + +CGlobalTextControl::~CGlobalTextControl() + { + delete iBidiText; + delete iScreen; + iSemaphore.Close(); + } + +void CGlobalTextControl::Draw(const TRect& aRect) const + { + CWindowGc& gc = SystemGc(); + gc.SetBrushColor(TRgb(EBackgroundColor)); + gc.Clear(Rect()); + + // it's recommended to create XCoeTextDrawer on the stack + XCoeTextDrawer textDrawer(TextDrawer()); + textDrawer->SetAlignment(TGulAlignment(EHCenterVCenter)); + textDrawer->SetTextColor(KRgbBlack); + textDrawer->SetMargins(iMargin); + textDrawer->SetLineGapInPixels(EGapBetweenTextLines); + textDrawer.SetClipRect(aRect); + + // request the font, could also be done during construction + CFont* font; + TFontSpec fontSpec; + fontSpec.iTypeface.iName = KNokiaSeries60Font; + fontSpec.iHeight=EDesiredFontHeight; + iScreen->GetNearestFontToDesignHeightInPixels((CFont*&)font, fontSpec); + + if (iDrawVertically) + { + iBidiText->WrapText(aRect.Height() - ESideBearingsAllowance, *font, NULL, EMaximumTextLines); + textDrawer.DrawTextVertical(gc, *iBidiText, aRect, *font); + } + else + { + // If you don't explicitly set the alignment for RightToLeft text, + // DrawText's default is to left align regardless of the text direction. + // Setting it explicitly to Left alignment tells DrawText to right align. + if (iRightToLeft) + { + TGulAlignment alignment(EHLeftVTop); + textDrawer.SetAlignment(alignment); + } + iBidiText->WrapText(aRect.Width() - ESideBearingsAllowance, *font, NULL, EMaximumTextLines); + textDrawer.DrawText(gc, *iBidiText, aRect, *font); + } + iScreen->ReleaseFont(font); // should be done every time the font is not needed anymore + } + +void CGlobalTextControl::HandlePointerEventL(const TPointerEvent& aPointerEvent) + { + // Process event generated from test step, forces a redraw. + if(aPointerEvent.iType == TPointerEvent::EButton1Down) + { + DrawNow(); + iWsSession.Flush(); + iWsSession.Finish(); + iSemaphore.Signal(); + } + } + + +CFullScreenTextAppUi::CFullScreenTextAppUi() + { + // empty + } + +void CFullScreenTextAppUi::ConstructL(TBool aDrawVertically, TBool aRightToLeft) + { + BaseConstructL(ENoAppResourceFile); + iGlobalTextControl = CGlobalTextControl::NewL(NULL, aDrawVertically, aRightToLeft); + AddToStackL(iGlobalTextControl); + } + +CFullScreenTextAppUi::~CFullScreenTextAppUi() + { + RemoveFromStack(iGlobalTextControl); + delete iGlobalTextControl; + }