diff -r 000000000000 -r 2f259fa3e83a lafagnosticuifoundation/cone/tef/TConeZoomFont.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/lafagnosticuifoundation/cone/tef/TConeZoomFont.cpp Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,446 @@ +// Copyright (c) 2005-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 + @internalComponent - Internal Symbian test code +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "TConeZoomFont.h" + +_LIT(KConeZoomFontText, "Zoom text!"); + + +class CConeZoomFontControl : public CCoeControl + { +public: + static CConeZoomFontControl* NewL(const TRect& aRect); + CConeZoomFontControl(); + ~CConeZoomFontControl(); + void ConstructL(const TRect& aRect); + TZoomFactor AccZoom(); +private: + // Inherited from CCoeControl + void Draw(const TRect& /*aRect*/) const; + +private: + HBufC* iConeZoomFontText; + TCoeFont iFont; + }; + +class CConeZoomFontView : public CCoeControl + { +public: + static CConeZoomFontView* NewL(); + CConeZoomFontView(); + ~CConeZoomFontView(); + void ConstructL(); + + void Test1L(); + void Test2L(); + void Test3L(); + + TInt CountComponentControls() const; + CCoeControl* ComponentControl(TInt aIndex) const; + +private: + // Inherited from CCoeControl + void Draw(const TRect& /*aRect*/) const; + void SizeChanged(); + +private: + CConeZoomFontControl* iControl; + }; + + +// +// +// CConeZoomFontControl +// +// +CConeZoomFontControl::CConeZoomFontControl(): +iFont(TCoeFont::NormalFont()) + { + } + +CConeZoomFontControl* CConeZoomFontControl::NewL(const TRect& aRect) + { + CConeZoomFontControl* self = new(ELeave) CConeZoomFontControl(); + CleanupStack::PushL(self); + self->ConstructL(aRect); + CleanupStack::Pop(self); + return self; + } + +CConeZoomFontControl::~CConeZoomFontControl() + { + delete iConeZoomFontText; + } + +void CConeZoomFontControl::ConstructL(const TRect& /*aRect*/) + { + iConeZoomFontText = KConeZoomFontText().AllocL(); + } + +void CConeZoomFontControl::Draw(const TRect& /*aRect*/) const + { + CWindowGc& gc = SystemGc(); + TRect drawRect = Rect(); + gc.Clear(); + drawRect.Shrink(10,10); + gc.DrawRect(drawRect); + + // Testing bit - get the correct font based on the current zoom factor. + // NB, the Font() function takes a non-const reference to a TZoomFactor as + // its second argument, so we can't pass the direct return from AccumulatedZoom() + // as might seem to be the natural thing to do. + TZoomFactor junk = AccumulatedZoom(); + const CFont& fontUsed = FindFontProvider().Font(TCoeFont::TitleFont(), junk); + gc.UseFont(&fontUsed); + TInt baselineOffset=(drawRect.Height() + fontUsed.HeightInPixels())/2; + gc.DrawText(*iConeZoomFontText,drawRect,baselineOffset,CGraphicsContext::ECenter, 0); + gc.DiscardFont(); + } + +TZoomFactor CConeZoomFontControl::AccZoom() + { + return AccumulatedZoom(); + } + +// +// +// CConeZoomFontView +// +// +CConeZoomFontView::CConeZoomFontView() + { + } + +CConeZoomFontView* CConeZoomFontView::NewL() + { + CConeZoomFontView* self = new(ELeave) CConeZoomFontView(); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CConeZoomFontView::~CConeZoomFontView() + { + delete iControl; + } + +TInt CConeZoomFontView::CountComponentControls() const + { + return 1; + } + +/** + @SYMTestCaseID UIF-TConeZoomFont-Test1L + + @SYMPREQ 857 + + @SYMTestCaseDesc + The parent is set to have relative zoom factor of 1000, and the child a relative zoom + of 500 using the CCoeControl:: SetZoomFactorL. This should give a cumulative zoom + factor of 500. The child will draw text in its rectangle based this cumulative zoom factor. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Set the zoom factors of the parent and child objects + Chect the accumulated zoom is calculated correctly + finally call draw now to display zoomed text + + @SYMTestExpectedResults + Will leave if accumulated zoom factor is incorrect, zoomed text is displayed. + + */ +void CConeZoomFontView::Test1L() + { + TInt viewZoom = 1000; + TInt controlZoom = 500; + + SetZoomFactorL(viewZoom, ERelativeZoom); + iControl->SetZoomFactorL(controlZoom, ERelativeZoom); + TZoomFactor viewZoomFactor = AccumulatedZoom(); + TZoomFactor controlZoomFactor = iControl->AccZoom(); + + //Check to see if the AccumulatedZoom returns the correct values + if ((viewZoomFactor.ZoomFactor() != viewZoom) || + (controlZoomFactor.ZoomFactor() != ((viewZoom * controlZoom) /1000))) + { + User::Leave(-1); + } + + DrawNow(); + } + +/** + @SYMTestCaseID UIF-TConeZoomFont-Test2L + + @SYMPREQ 857 + + @SYMTestCaseDesc + The parent is set to have relative zoom factor of 500, and the child a absolute + zoom of 1000. This should give a cumulative zoom factor of 1000 (because the + child's zoom is absolute). The child will draw text in its rectangle based this + cumulative zoom factor. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Set the zoom factors of the parent and child objects + Chect the accumulated zoom is calculated correctly + finally call draw now to display zoomed text + + @SYMTestExpectedResults + Will leave if accumulated zoom factor is incorrect, zoomed text is displayed. + + */ +void CConeZoomFontView::Test2L() + { + TInt viewZoom = 500; + TInt controlZoom = 1000; + + SetZoomFactorL(viewZoom, ERelativeZoom); + iControl->SetZoomFactorL(controlZoom, EAbsoluteZoom); + TZoomFactor viewZoomFactor = AccumulatedZoom(); + TZoomFactor controlZoomFactor = iControl->AccZoom(); + + //Check to see if the AccumulatedZoom returns the correct values + if ((viewZoomFactor.ZoomFactor() != viewZoom) || + (controlZoomFactor.ZoomFactor() != (controlZoom))) + { + User::Leave(-1); + } + + DrawNow(); + } + +/** + @SYMTestCaseID UIF-TConeZoomFont-Test3L + + @SYMPREQ 857 + + @SYMTestCaseDesc + The parent is set to have absolute zoom factor of 1500, and the child + a relative zoom of 1500. This should give a cumulative zoom factor of + 2250. The child will draw text in its rectangle based this cumulative + zoom factor. + + @SYMTestPriority High + + @SYMTestStatus Implemented + + @SYMTestActions + Set the zoom factors of the parent and child objects + Chect the accumulated zoom is calculated correctly + finally call draw now to display zoomed text + + @SYMTestExpectedResults + Will leave if accumulated zoom factor is incorrect, zoomed text is displayed. + + */ +void CConeZoomFontView::Test3L() + { + + TInt viewZoom = 1500; + TInt controlZoom = 1500; + + SetZoomFactorL(viewZoom, EAbsoluteZoom); + iControl->SetZoomFactorL(controlZoom, ERelativeZoom); + TZoomFactor viewZoomFactor = AccumulatedZoom(); + TZoomFactor controlZoomFactor = iControl->AccZoom(); + + //Check to see if the AccumulatedZoom returns the correct values + if ((viewZoomFactor.ZoomFactor() != viewZoom) || + (controlZoomFactor.ZoomFactor() != ((viewZoom * controlZoom) /1000))) + { + User::Leave(-1); + } + + DrawNow(); + } + +CCoeControl* CConeZoomFontView::ComponentControl(TInt /*aIndex*/) const + { + return iControl; + } + +void CConeZoomFontView::ConstructL() + { + CreateWindowL(); + + iControl = CConeZoomFontControl::NewL(Rect()); + iControl->SetContainerWindowL(*this); + iControl->SetParent(this); + + SetExtent( TPoint(20,20),TSize(600,200) ); + + SetZoomFactorL(1000); + iControl->SetZoomFactorL(1000, EAbsoluteZoom); + + ActivateL(); + } + +void CConeZoomFontView::Draw(const TRect& /*aRect*/) const + { + + CWindowGc& gc = SystemGc(); + TRect drawRect = Rect(); + gc.Clear(); + drawRect.Shrink(10,10); + gc.DrawRect(drawRect); + + } + +void CConeZoomFontView::SizeChanged() + { + ComponentControl(1)->SetRect( TRect(TPoint(20,20),TSize(560,160))) ; + } + +// +// +// CConeZoomFontAppUi +// +// +CConeZoomFontAppUi::CConeZoomFontAppUi(CTmsTestStep* aStep) : +CTestCoeAppUi(aStep) +{} + +CConeZoomFontAppUi::~CConeZoomFontAppUi() + { + delete iView; + } + + +void CConeZoomFontAppUi::ConstructL() + { + CTestCoeAppUi::ConstructL(); + + iView = CConeZoomFontView::NewL(); + + AutoTestManager().StartAutoTest(); + } + +void CConeZoomFontAppUi::RunTestStepL(TInt aStepNum) + { + + User::After(TTimeIntervalMicroSeconds32(1000000)); + + TInt err; + + switch(aStepNum) + { + case 1: + SetTestStepID(_L("UIF-TConeZoomFont-Test1L")); + _LIT(KTest1, "Zoom Relative 0.5"); + INFO_PRINTF1(KTest1); + TRAP(err, iView->Test1L()); + RecordTestResultL(); + break; + case 2: + SetTestStepID(_L("UIF-TConeZoomFont-Test2L")); + _LIT(KTest2, "Zoom Absolute 2.0"); + INFO_PRINTF1(KTest2); + TRAP(err, iView->Test2L()); + RecordTestResultL(); + break; + case 3: + SetTestStepID(_L("UIF-TConeZoomFont-Test3L")); + _LIT(KTest3, "Zoom Relative 1.5*1.5"); + INFO_PRINTF1(KTest3); + TRAP(err, iView->Test3L()); + RecordTestResultL(); + CloseTMSGraphicsStep(); + break; + case 4: + AutoTestManager().FinishAllTestCases(CAutoTestManager::EPass); + break; + + } + } + +// +// +// CConeZoomFontStep +// +// +void CTConeZoomFontStep::ConstructAppL(CCoeEnv* aCoe) + { // runs inside a TRAP harness + aCoe->ConstructL(); + CConeZoomFontAppUi* appUi= new (ELeave) CConeZoomFontAppUi(this); + aCoe->SetAppUi(appUi); + appUi->ConstructL(); + } + +CTConeZoomFontStep::CTConeZoomFontStep() + { + SetTestStepName(KTConeZoomFontStep); + } + +CTConeZoomFontStep::~CTConeZoomFontStep() +{} + + +TVerdict CTConeZoomFontStep::doTestStepL() // main function called by E32 + { + _LIT(KTestStart, "Test Started"); + INFO_PRINTF1(KTestStart); + + PreallocateHALBuffer(); + + __UHEAP_MARK; + + CCoeEnv* coe=new(ELeave) CCoeEnv; + TRAPD(err,ConstructAppL(coe)); + + if (!err) + coe->ExecuteD(); + else + { + SetTestStepResult(EFail); + delete coe; + } + + REComSession::FinalClose(); + + __UHEAP_MARKEND; + + _LIT(KTestFinished, "Test Finished"); + INFO_PRINTF1(KTestFinished); + return TestStepResult(); + } + + + + + +