diff -r 000000000000 -r 15bf7259bb7c uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfapptestcaseselectionview.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uiacceltk/hitchcock/tsrc/alfperfapp/src/alfperfapptestcaseselectionview.cpp Tue Feb 02 07:56:43 2010 +0200 @@ -0,0 +1,1228 @@ +/* +* Copyright (c) 2008 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: CAlfPerfAppTestCaseSelectionView implementation. +* +*/ + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "alfperfapptestcaseselectionview.h" +#include "alfperfapp.hrh" +#include "alfperfappconstants.h" +#include "alfperfappmodel.h" + +// Execution ongoing +_LIT( KAlfPerfAppExecuting, "Executing..\n" ); + +// Print output path +_LIT( KAlfPerfAppPrintOutputFormat, "Result files are in %S\n" ); + +// Error message display +_LIT( KAlfPerfAppNoErrors, "No errors.\n\n" ); +_LIT( KAlfPerfAppErrorHeader, "Errors:\n" ); +_LIT( KAlfPerfappErrorItem, " %S\n" ); +_LIT( KAlfPerfAppErrorFooter, "\n" ); + +// Results display +_LIT( KAlfPerfAppInfoNote, "Program records results directly to two files, results are appended to the end of each file.\n\n"); +_LIT( KAlfPerfAppClearFilesQueryLine1, "Earlier results present."); +_LIT( KAlfPerfAppClearFilesQueryLine2, "Clear the result files?"); +_LIT( KAlfPerfAppResultsHeader, + "*** Field Guide ***\n- Time spend\n- Mem.usage of app,server and system\n- Frame count and fps\n"); +//_LIT( KAlfPerfAppResultsCaseStart, "%.2f s: Case: %x\n" ); +_LIT( KAlfPerfAppResultsCaseStart, "Started at: %.2f s\n"); +_LIT( KAlfPerfAppResultsCaseTitle, "\n=== %S / %S (0x%x) ===\n"); +_LIT( KAlfPerfAppResultsNone, "No results.\n\n" ); +_LIT( KAlfPerfAppSpecificResultFooter,"\n"); + +_LIT( KAlfPerfAppResultsPhaseTitle0,"\n*** Startup ***\n" ); +_LIT( KAlfPerfAppResultsPhaseTitle1,"\n*** Run ***\n" ); +_LIT( KAlfPerfAppResultsPhaseTitle2,"\n*** Teardown ***\n" ); +_LIT( KAlfPerfAppResultsCaseTotalTitle,"\n*** Case total ***\n" ); +_LIT( KAlfPerfAppResultsCaseItem, + "Time: %.2f s\nMem.usage: %d/%d/%d kb\nFrames: %d (%3.1f fps)\n" ); + +// Buffer full +const TInt KAlfPerfAppDisplayResultMaxChars = 35000; //increase is needed for Sequence test cases +_LIT( KAlfPerfAppDisplayBufferFull,"\n*** Display buffer full ***\n"); + + + + +/** + * CAlfPerfAppTestCaseSelectionView::CContainer container class. + */ +class CAlfPerfAppTestCaseSelectionView::CContainer : public CCoeControl, MCoeControlObserver, MEikScrollBarObserver + { + public: + CContainer(CAlfPerfAppModel* aModel); + void ConstructL(); + ~CContainer(); + + public: // New functions + TBool PrintText(const TDesC& aDes); + void ClearOutputWindowL(); + void UpdateVisualContentL(TBool aScrollToBottom); + + public: // From base classes + virtual TKeyResponse OfferKeyEventL( + const TKeyEvent& aKeyEvent, TEventCode aType ); + virtual void HandleResourceChange( TInt aType ); + virtual void Draw(const TRect& aRect) const; + virtual void HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType); + virtual void HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType); // From MEikScrollBarObserver + + private: + CEikScrollBarFrame* iScrollBarFrame; + HBufC* iText; + CFont* iFont; + HBufC* iWrapperString; + CArrayFix* iWrappedArray; + TInt iCurrentLine; + TInt iLineCount; + TInt iNumberOfLinesFitsScreen; + TInt iLeftDrawingPosition; + TReal iX_factor; + TReal iY_factor; + TBool iNotPrintedResultDisplayBufferExceeded; + CAlfPerfAppModel* iModel; + }; + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +// +CAlfPerfAppTestCaseSelectionView* CAlfPerfAppTestCaseSelectionView::NewLC( + CAlfPerfAppModel& aModel ) + { + CAlfPerfAppTestCaseSelectionView* self = + new (ELeave) CAlfPerfAppTestCaseSelectionView( aModel ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +// +CAlfPerfAppTestCaseSelectionView::~CAlfPerfAppTestCaseSelectionView() + { + } + +// ----------------------------------------------------------------------------- +// ----------------------------------------------------------------------------- +// +CAlfPerfAppTestCaseSelectionView::CAlfPerfAppTestCaseSelectionView( + CAlfPerfAppModel& aModel ) +: iModel( aModel ) + { + } + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::ConstructL() + { + BaseConstructL( R_ALFPERFAPP_TEST_CASE_SELECTION_VIEW ); + } + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CmdRunAllL() + { + // Run all test cases (that are not excluded from 'run all'). + iModel.ResetErrorArray(); + if (iContainer) + { + iContainer->ClearOutputWindowL(); + iContainer->PrintText( KAlfPerfAppExecuting ); + } + iModel.ResetExecuteArray(); + + const TInt suiteCount = iModel.SuiteCount(); + for ( TInt ii = 0; ii < suiteCount; ii++ ) + { + // If suite is not excluded from run all, + // add all test cases to execute array. + if ( !( iModel.SuiteFlags( ii ) & + EAlfPerfAppTestSuiteFlagExcludeFromRunAll ) ) + { + // Add all test cases to execute array. + const TInt testCount = iModel.TestCaseCount( ii ); + for ( TInt jj = 0; jj < testCount; jj++ ) + { + TPtrC testName; + TInt testCaseId; + TInt testCaseFlags; + TInt testCaseSequenceLength; + + iModel.GetTestCase( + ii, + jj, + testName, + testCaseId, + testCaseFlags, + testCaseSequenceLength); + + // Add the test case multiple times to fill the sequence (at least once though) + iModel.AddToExecuteArrayL( testCaseId ); + for(TInt index = 1; index < testCaseSequenceLength;index++) + { + iModel.AddToExecuteArrayL( testCaseId ); + } + } + } + + } + + AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId ); + } + + + + void CAlfPerfAppTestCaseSelectionView::CmdRunAllContinuouslyL() + { + // Run all test cases (that are not excluded from 'run all'). + iModel.ResetErrorArray(); + if (iContainer) + { + iContainer->ClearOutputWindowL(); + iContainer->PrintText( KAlfPerfAppExecuting ); + } + iModel.ResetExecuteArray(); + + const TInt suiteCount = iModel.SuiteCount(); + for ( TInt ii = 0; ii < suiteCount; ii++ ) + { + // If suite is not excluded from run all, + // add all test cases to execute array. + if ( !( iModel.SuiteFlags( ii ) & + EAlfPerfAppTestSuiteFlagExcludeFromRunAll ) ) + { + // Add all test cases to execute array. + const TInt testCount = iModel.TestCaseCount( ii ); + for ( TInt jj = 0; jj < testCount; jj++ ) + { + TPtrC testName; + TInt testCaseId; + TInt testCaseFlags; + TInt testCaseSequenceLength; + + iModel.GetTestCase( + ii, + jj, + testName, + testCaseId, + testCaseFlags, + testCaseSequenceLength); + + // Add the test case multiple times to fill the sequence (at least once though) + iModel.AddToExecuteArrayL( testCaseId ); + for(TInt index = 1; index < testCaseSequenceLength;index++) + { + iModel.AddToExecuteArrayL( testCaseId ); + } + } + } + + } + + // Finally tell ExecutionView to use Continuous Run + const TUid KCustomMessageUid = {2}; + TBuf8 customMessage; + customMessage.Copy(_L8("UseContinuousRun")); + AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId,KCustomMessageUid,customMessage); + } + + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CmdRunAllFromSuiteL( + TInt aSuiteIndex ) + { + // Run all test cases related to specific suite. + const TInt testCaseCount = iModel.TestCaseCount( aSuiteIndex ); + iModel.ResetErrorArray(); + + if (iContainer) + { + iContainer->ClearOutputWindowL(); + iContainer->PrintText( KAlfPerfAppExecuting ); + } + + iModel.ResetExecuteArray(); + + for ( TInt ii = 0; ii < testCaseCount; ii++ ) + { + TPtrC testCaseName; + TInt testCaseId; + TInt testCaseFlags; + TInt testCaseSequenceLength; + + iModel.GetTestCase( + aSuiteIndex, + ii, + testCaseName, + testCaseId, + testCaseFlags, + testCaseSequenceLength); + + // Add the test case multiple times to fill the sequence (at least once though) + iModel.AddToExecuteArrayL( testCaseId ); + for(TInt index = 1; index < testCaseSequenceLength;index++) + { + iModel.AddToExecuteArrayL( testCaseId ); + } + + AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId ); + } + } + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CmdRunTestCaseL( + TInt aSuiteIndex, TInt aTestCaseIndex ) + { + TPtrC testCaseName; + TInt testCaseId; + TInt testCaseFlags; + TInt testCaseSequenceLength; + + iModel.GetTestCase( + aSuiteIndex, + aTestCaseIndex, + testCaseName, + testCaseId, + testCaseFlags, + testCaseSequenceLength); + + iModel.ResetErrorArray(); + if (iContainer) + { + iContainer->ClearOutputWindowL(); + iContainer->PrintText( KAlfPerfAppExecuting ); + } + iModel.ResetExecuteArray(); + + // Add the test case multiple times to fill the sequence (at least once though) + iModel.AddToExecuteArrayL( testCaseId ); + for(TInt index = 1; index < testCaseSequenceLength;index++) + { + iModel.AddToExecuteArrayL( testCaseId ); + } + + AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId ); + } + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + TUid CAlfPerfAppTestCaseSelectionView::Id() const + { + return KAlfPerfAppTestCaseSelectionViewId; + } + + // ----------------------------------------------------------------------------- + // Handles view activation + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::DoActivateL( + const TVwsViewId& /*aPrevViewId*/, + TUid /*aCustomMessageId*/, + const TDesC8& /*aCustomMessage*/ ) + { + ResetContainerL(); + + DisplayResultsL(); + + // Pop up the "Clear result files?"-dialog if either of the files existed. + static TBool firstTime = ETrue; + if(firstTime) + { + if(iModel.TargetFilesExisted()) + { + if(CEikonEnv::Static()->QueryWinL(KAlfPerfAppClearFilesQueryLine1,KAlfPerfAppClearFilesQueryLine2)) + { + // Clear the files + iModel.OpenFilesL(true); + } + firstTime = EFalse; + } + } + } + + // ----------------------------------------------------------------------------- + // Handles view deactivation + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::DoDeactivate() + { + if ( iContainer ) + { + AppUi()->RemoveFromStack( iContainer ); + delete iContainer; + iContainer = NULL; + } + } + + + // ----------------------------------------------------------------------------- + // Display test results on screen. The text is wrapped. + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::DisplayResultsL() + { + if (iContainer) + { + TBuf line; + iContainer->ClearOutputWindowL(); + + const TInt errorCount = iModel.ErrorArrayCount(); + if ( !errorCount ) + { + iContainer->PrintText( KAlfPerfAppNoErrors ); + } + else + { + iContainer->PrintText( KAlfPerfAppErrorHeader ); + for ( TInt ii = 0; ii < errorCount; ii++ ) + { + TPtrC message; + iModel.GetFromErrorArray( ii, message ); + if ( message.Length() ) + { + line.Zero(); + TPtrC item = message.Left( 64 ); + line.Format( KAlfPerfappErrorItem, &item ); + iContainer->PrintText( line ); + } + } + iContainer->PrintText( KAlfPerfAppErrorFooter ); + } + + if (iModel.ResultsNotAddedToFile()) + { + iContainer->PrintText( KAlfPerfAppResultsNone ); + iContainer->PrintText( KAlfPerfAppInfoNote ); + } + else + { + line.Zero(); + line.Format( KAlfPerfAppResultsHeader ); + iContainer->PrintText(line); + + // Prepare to read lines + TFileText LineFromFile; + LineFromFile.Set(*iModel.ResultFile()); + LineFromFile.Seek(ESeekStart); + + // Read the first line and forget it (header info only) + line.Copy(getLineFromTargetFile()); + + TInt currentCase = 0; + TBool startTimeNotRecorded = ETrue; + TUint32 timeStampAtStart = 0; + TInt framesSinceCase = 0; + CAlfPerfAppModel::TTestCaseResultItem itemAtCase; + CAlfPerfAppModel::TTestCaseResultItem itemAtPhase; + TBuf8 specificResultStorage; + for(TInt i=0; ; i++) // i = line number in result file + { + line.Zero(); + + // Read a line from file and convert it to an TTestCaseResultItem + line.Copy(getLineFromTargetFile()); + if(line.Length() == 0) + { + // If the line is empty, end this loop + break; + } + CAlfPerfAppModel::TTestCaseResultItem item; + item = ResultItemFromLine(line); + line.Zero(); + + if(startTimeNotRecorded) + { + timeStampAtStart = item.iTimeStamp; + startTimeNotRecorded = EFalse; + } + + TUint32 timeFromStart = + DeltaFromCurrentToPrevious( + item.iTimeStamp, timeStampAtStart ); + + TBool changedCase = EFalse; + if ( !i || currentCase != item.iCaseId ) + { + currentCase = item.iCaseId; + itemAtCase = item; + framesSinceCase = 0; + changedCase = ETrue; + //specificResultStorage.Zero(); + } + + if(changedCase || itemAtPhase.iPhase != item.iPhase) + { + itemAtPhase = item; + } + + if ( changedCase ) + { + // Name + TBuf<100> suiteName; + suiteName.Copy(item.iSuiteName); + TBuf<100> caseName; + caseName.Copy(item.iCaseName); + line.Format( + KAlfPerfAppResultsCaseTitle, + &suiteName, + &caseName, + item.iCaseId); + if(!iContainer->PrintText(line))break; + line.Zero(); + + // Start time + line.AppendFormat( KAlfPerfAppResultsCaseStart, + ((TReal32)timeFromStart/1000)); + if(!iContainer->PrintText(line))break; + line.Zero(); + } + + if(item.specificResult8.Length() != 0) + { + specificResultStorage.Zero(); + specificResultStorage.Append(item.specificResult8); + } + + if(i&0x1) // Skip even lines + { + // Print phase data + if (item.iPhase == 0) + { + line.AppendFormat(KAlfPerfAppResultsPhaseTitle0); + } + else if (item.iPhase == 1) + { + line.AppendFormat(KAlfPerfAppResultsPhaseTitle1); + } + else + { + line.AppendFormat(KAlfPerfAppResultsPhaseTitle2); + } + + line.AppendFormat( KAlfPerfAppResultsCaseItem, + // duration + ((TReal32)item.imsSincePhase)/1000, + // memory consumption delta + ( item.iAppMemory - itemAtPhase.iAppMemory )/ 1024, + ( item.iServerMemory - itemAtPhase.iServerMemory )/ 1024, + ( item.iSystemMemory - itemAtPhase.iSystemMemory )/ 1024, + // frame info + item.iFrameCount, + item.iFPS ); + if(!iContainer->PrintText(line))break; + line.Zero(); + + // Testcase specific results + if(specificResultStorage.Length() != 0) + { + TBuf specificResult16; + specificResult16.Copy(specificResultStorage); + line.Append(specificResult16); + line.Append(KAlfPerfAppSpecificResultFooter); + if(!iContainer->PrintText(line))break; + specificResultStorage.Zero(); + line.Zero(); + } + + + framesSinceCase += item.iFrameCount; + if (item.iPhase == 2) + { + // Print case data + // need to be done like this because of fpsSinceCase is not + // recorded to file + TUint32 timeFromCase = item.imsSinceCase; + + TReal32 fpsSinceCase = 0.f; + if ( timeFromCase != 0 ) + { + fpsSinceCase = ((TReal32)framesSinceCase*1000)/timeFromCase; + } + + line.AppendFormat(KAlfPerfAppResultsCaseTotalTitle); + if(!iContainer->PrintText(line))break; + + line.Format( KAlfPerfAppResultsCaseItem, + // duration + ((TReal32)timeFromCase/1000), + // memory consumption delta + ( item.iAppMemory - itemAtCase.iAppMemory )/ 1024, + ( item.iServerMemory - itemAtCase.iServerMemory )/ 1024, + ( item.iSystemMemory - itemAtCase.iSystemMemory )/ 1024, + // frame info + framesSinceCase, + fpsSinceCase ); + + if(!iContainer->PrintText(line))break; + line.Zero(); + } + + } + } + } + + TBuf temp = iModel.TargetPath(); + line.Format( KAlfPerfAppPrintOutputFormat, &temp); + iContainer->PrintText(line); + + // Finally update results to screen + iContainer->UpdateVisualContentL(ETrue); + } + } + + + // ----------------------------------------------------------------------------- + // Handles test case selection view specific commands. + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::HandleCommandL( TInt aCommand ) + { + switch ( aCommand ) + { + case EAlfPerfAppCmdRunAll: + CmdRunAllL(); + break; + + case EAlfPerfAppCmdRunAllContinuously: + CmdRunAllContinuouslyL(); + break; + + case EAlfPerfAppCmdClearFiles: + + TBuf<1> empty; + if(CEikonEnv::Static()->QueryWinL(KAlfPerfAppClearFilesQueryLine2,empty)) + { + // Clear the files + iModel.OpenFilesL(true); + ResetContainerL(); + DisplayResultsL(); + } + + break; + + + default: + { + if ( ( aCommand & ~0xFFFF ) == EAlfPerfAppCmdTestCase ) + { + const TInt testSuiteIndex = ( aCommand & 0xFF00 ) >> 8; + TInt testCaseIndex = aCommand & 0xFF; + + if ( !testCaseIndex ) + { + CmdRunAllFromSuiteL( testSuiteIndex ); + } + else + { + // Run one specific test case + testCaseIndex--; + CmdRunTestCaseL( testSuiteIndex, testCaseIndex ); + } + } + else + { + AppUi()->HandleCommandL( aCommand ); + } + } + break; + } + } + + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::RestoreMenuL( + CCoeControl* aMenuControl, TInt aResourceId, TMenuType aType ) + { + // Override resource in case of test suite menu + iResourceId = 0; + + if ( ( aResourceId & ~0xFFFF ) == KAlfPerfAppMenuPaneResourceId ) + { + iResourceId = aResourceId; + aResourceId = R_ALFPERFAPP_TEST_CASE_SELECTION_SUITE_MENUPANE; + } + + CAknView::RestoreMenuL( + aMenuControl, + aResourceId, + aType ); + } + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::DynInitMenuPaneL( + TInt aResourceId, + CEikMenuPane* aMenuPane ) + { + if ( aResourceId == R_ALFPERFAPP_TEST_CASE_SELECTION_MENUPANE ) + { + // Add all suites to top level options menu. + const TInt suiteCount = iModel.SuiteCount(); + for ( TInt ii = suiteCount - 1; ii >= 0; ii-- ) + { + CEikMenuPaneItem::SData data; + data.iCommandId = 0; + data.iCascadeId = KAlfPerfAppMenuPaneResourceId + (ii << 8); + data.iFlags = 0; + data.iText.Copy( iModel.SuiteName( ii ) ); + data.iExtraText.Zero(); + + aMenuPane->AddMenuItemL( data, EAlfPerfAppCmdRunAllContinuously ); + } + } + + if ( aResourceId == R_ALFPERFAPP_TEST_CASE_SELECTION_SUITE_MENUPANE ) + { + const TInt suiteIndex = ( iResourceId & 0xFF00 ) >> 8; + const TInt testCaseCount = iModel.TestCaseCount( suiteIndex ); + + // Add 'Run All' option + HBufC* runAllText = StringLoader::LoadLC( R_ALFPERFAPP_TEXT_RUNALL ); + CEikMenuPaneItem::SData runAll; + runAll.iCommandId = EAlfPerfAppCmdTestCase + (suiteIndex << 8); + runAll.iCascadeId = 0; + runAll.iFlags = 0; + runAll.iText.Copy( *runAllText ); + runAll.iExtraText.Zero(); + aMenuPane->AddMenuItemL( runAll ); + CleanupStack::PopAndDestroy( runAllText ); + + // Add options menu items for all test cases of this suite + for ( TInt ii = 0; ii < testCaseCount; ii++ ) + { + CEikMenuPaneItem::SData data; + data.iCommandId = EAlfPerfAppCmdTestCase + (suiteIndex << 8) + ii + 1; + data.iCascadeId = 0; + data.iFlags = 0; + + TPtrC testCaseName; + TInt testCaseId; + TInt flags; + TInt sequenceLength; + + iModel.GetTestCase( + suiteIndex, + ii, + testCaseName, + testCaseId, + flags, + sequenceLength); + + data.iText.Copy( testCaseName ); + data.iExtraText.Zero(); + + aMenuPane->AddMenuItemL( data ); + } + } + } + + TBuf8 CAlfPerfAppTestCaseSelectionView::getLineFromTargetFile() + { + TBuf8 line; + TBuf8<1> character; + iModel.ResultFile()->Read(character,1); + if(character.Length() == 0) + { + // File was empty --> return empty line + return line; + } + while(character[0] != '\n') + { + line.Append(character); + iModel.ResultFile()->Read(character,1); + } + return line; + } + + void CAlfPerfAppTestCaseSelectionView::ResetContainerL() + { + // Reset the container + if ( iContainer ) + { + AppUi()->RemoveFromStack( iContainer ); + delete iContainer; + iContainer = NULL; + } + CContainer* container = new (ELeave) CContainer(&iModel); + CleanupStack::PushL( container ); + container->ConstructL(); + AppUi()->AddToStackL( *this, container ); + CleanupStack::Pop( container ); + iContainer = container; + } + + + // Let's create a function template for extracting items from lexer + TBuf& ProcessLexer(TLex& aLexer, TChar aSeparator,TBuf& aToken) + { + aToken.Zero(); + TChar ch; + aLexer.SkipAndMark(0); + while (!aLexer.Eos()) + { + ch = aLexer.Get(); + if(ch == aSeparator) + { + aLexer.UnGet(); + aToken.Append(aLexer.MarkedToken()); + aLexer.SkipAndMark(1); + break; + } + } + return aToken; + } + + CAlfPerfAppModel::TTestCaseResultItem CAlfPerfAppTestCaseSelectionView::ResultItemFromLine(TBuf& aLine) + { + CAlfPerfAppModel::TTestCaseResultItem item; + + TBuf temp; + TLex lexer(aLine); + TLex tempLex; + + item.iSuiteName.Copy(ProcessLexer(lexer,'/',temp)); + item.iSuiteName.Trim(); + item.iCaseName.Copy(ProcessLexer(lexer,',',temp)); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + item.iCaseName.Trim(); + tempLex.Val(item.iCaseId); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iPhase); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iTimeStamp,EDecimal); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iAppCells); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iAppMemory); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iAppFree); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iServerCells); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iServerMemory); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iServerFree); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iSystemMemory); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iSystemFree); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.iFrameCount,EDecimal); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.imsSinceCase,EDecimal); + tempLex.Assign(ProcessLexer(lexer,',',temp)); + tempLex.Val(item.imsSincePhase,EDecimal); + TBuf<15> fpsBuffer (ProcessLexer(lexer,',',temp)); + tempLex.Assign(fpsBuffer); + tempLex.Val(item.iFPS); + item.specificResult8.Copy(lexer.Remainder()); + item.specificResult8.Delete(item.specificResult8.Length()-1,1); + + return item; + } + + + + // Implementation of DeltaFromCurrentToPrevious + TUint32 CAlfPerfAppTestCaseSelectionView::DeltaFromCurrentToPrevious( + TUint32 aCurrent, TUint32 aPrevious ) + { + // It's expected that execution of all test suites take less + // than KMaxTInt ms (so that it fits to TInt). + + TUint64 delta = 0; + if ( aPrevious <= aCurrent ) + { + // aPrevious .. aCurrent + delta = aCurrent - aPrevious; + } + else + { + // Overflow has occurred. + // aPrevious .. 2**32 + aCurrent + + delta = 0xFFFFFFFF; + delta -= aPrevious; + delta++; + delta += aCurrent; + } + + if ( delta >= KMaxTInt ) + { + delta = KMaxTInt; + } + + return I64LOW( delta ); + } + + + // Implementation of CAlfPerfAppTestCaseSelectionView::CContainer: + // ----------------------------------------------------------------------------- + // + CAlfPerfAppTestCaseSelectionView::CContainer::CContainer(CAlfPerfAppModel* aModel) + { + iModel = aModel; + } + + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CContainer::ConstructL() + { + CreateWindowL(); + + TRect rect; + AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect ); + SetRect( rect ); + + iText = HBufC::NewL(KAlfPerfScreenTextBufferSize); + iCurrentLine = 0; + iLineCount = 0; + iNumberOfLinesFitsScreen = 0; + iX_factor = 1; + iY_factor = 1; + iLeftDrawingPosition = KAlfPerfAppLeftMargin; + + TFontSpec myFontSpec(KAlfPerfAppFontName,KAlfPerfAppFontSizeInTwips); + CGraphicsDevice* screenDevice=iCoeEnv->ScreenDevice(); + screenDevice->GetNearestFontInTwips(iFont,myFontSpec); + + iWrappedArray = new(ELeave) CArrayFixFlat(KAlfPerfScreenWrappedArraySize); + + iNotPrintedResultDisplayBufferExceeded = ETrue; + + ActivateL(); + } + + + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + CAlfPerfAppTestCaseSelectionView::CContainer::~CContainer() + { + // Destroy the font + iCoeEnv->ScreenDevice()->ReleaseFont(iFont); + + if (iWrappedArray) + { + iWrappedArray->Reset(); + delete iWrappedArray; + } + + if (iText) + delete iText; + + if (iScrollBarFrame) + delete iScrollBarFrame; + + if (iWrapperString) + delete iWrapperString; + } + + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + TKeyResponse CAlfPerfAppTestCaseSelectionView::CContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType) + { + if(aType != EEventKey) + return EKeyWasConsumed; + + if(aKeyEvent.iCode == EKeyUpArrow) + { + if (iCurrentLine > 0) + { + iCurrentLine--; + UpdateVisualContentL(EFalse); + } + + return EKeyWasConsumed; + } + + else if(aKeyEvent.iCode == EKeyDownArrow) + { + if (iCurrentLine < iLineCount - iNumberOfLinesFitsScreen) + { + iCurrentLine++; + UpdateVisualContentL(EFalse); + } + + return EKeyWasConsumed; + } + + return EKeyWasConsumed; + } + + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CContainer::HandleResourceChange(TInt aType) + { + if ( aType == KEikDynamicLayoutVariantSwitch ) + { + TRect mainPaneRect; + AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect); + SetRect(mainPaneRect); + + iCurrentLine = 0; // scroll to top + + // update font + // Discard and destroy the font + iCoeEnv->ScreenDevice()->ReleaseFont(iFont); + + // Create the font + TFontSpec myFontSpec(KAlfPerfAppFontName,KAlfPerfAppFontSizeInTwips); + CGraphicsDevice* screenDevice=iCoeEnv->ScreenDevice(); + screenDevice->GetNearestFontInTwips(iFont,myFontSpec); + + // delete the scroll and update screen + if (iScrollBarFrame) + { + delete iScrollBarFrame; + iScrollBarFrame = NULL; + } + TRAP_IGNORE(UpdateVisualContentL(EFalse)); + } + else + { + CCoeControl::HandleResourceChange(aType); + } + } + + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CContainer::HandleScrollEventL(CEikScrollBar* aScrollBar, TEikScrollEvent aEventType) + { + // only on page up/down,scroll up/down and drag events + if ((aEventType == EEikScrollPageDown) || (aEventType == EEikScrollPageUp) || + (aEventType == EEikScrollThumbDragVert) || (aEventType == EEikScrollUp) || + (aEventType == EEikScrollDown)) + { + // get the current position from the scroll bar + iCurrentLine = aScrollBar->ThumbPosition(); + + // refresh now + UpdateVisualContentL(EFalse); + } + } + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CContainer::HandleControlEventL( + CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/) + { + // TODO: Add your control event handler code here + } + + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CContainer::UpdateVisualContentL(TBool aScrollToBottom) + { + TSize rectSize; + AknLayoutUtils::LayoutMetricsSize(AknLayoutUtils::EMainPane, rectSize); + TRect rect(rectSize); + + // init scroll bar if not yet done + if (!iScrollBarFrame) + { + iScrollBarFrame = new(ELeave) CEikScrollBarFrame(this, this, ETrue); + + CAknAppUi* appUi = iAvkonAppUi; + + if (AknLayoutUtils::DefaultScrollBarType(appUi) == CEikScrollBarFrame::EDoubleSpan) + { + iScrollBarFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse); + iScrollBarFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EDoubleSpan); + } + else + { + iScrollBarFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EArrowHead); + } + iScrollBarFrame->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto); + } + + // drawing positions, needed for scalable ui + iX_factor = TReal(rect.Width()) / 176; + iY_factor = TReal(rect.Height()) / 144; + + iWrappedArray->Reset(); + + if (iWrapperString) + { + delete iWrapperString; + iWrapperString = NULL; + } + + // define drawing width, some extra space needed if using double span scrolling bar + TUint drawingWidth(0); + if (iScrollBarFrame->TypeOfVScrollBar() == CEikScrollBarFrame::EDoubleSpan) + { + if (AknLayoutUtils::LayoutMirrored()) // scroll bar on 'left' + { + iLeftDrawingPosition = KAlfPerfAppLeftMargin + 12; + drawingWidth = TInt( rect.Width() - iLeftDrawingPosition*iX_factor - (KAlfPerfAppRightMargin*iX_factor)); + } + else // scroll bar on 'right' + { + iLeftDrawingPosition = KAlfPerfAppLeftMargin; + drawingWidth = TInt( rect.Width() - iLeftDrawingPosition*iX_factor - (KAlfPerfAppRightMargin*iX_factor + 7*iX_factor)); + } + } + else + drawingWidth = TInt( rect.Width() - KAlfPerfAppLeftMargin*iX_factor - KAlfPerfAppRightMargin*iX_factor); + + // wrap the text + iWrapperString = AknBidiTextUtils::ConvertToVisualAndWrapToArrayL( + iText->Des(), + drawingWidth, + *iFont, + *iWrappedArray + ); + + iLineCount = iWrappedArray->Count(); + + // count amount of lines fits to screen + iNumberOfLinesFitsScreen = TInt(rect.Height() / (iFont->HeightInPixels())); + + // check if needed to scroll to the bottom + if (aScrollToBottom && iCurrentLine < iLineCount - iNumberOfLinesFitsScreen) + { + iCurrentLine = iLineCount-iNumberOfLinesFitsScreen; + } + + // update the scroll bars + TEikScrollBarModel horizontalBar; + TEikScrollBarModel verticalBar; + verticalBar.iThumbPosition = iCurrentLine; + verticalBar.iScrollSpan = iLineCount - iNumberOfLinesFitsScreen + 1; + verticalBar.iThumbSpan = 1; + + TEikScrollBarFrameLayout layout; + layout.iTilingMode = TEikScrollBarFrameLayout::EInclusiveRectConstant; + + if (iScrollBarFrame->TypeOfVScrollBar() == CEikScrollBarFrame::EDoubleSpan) + { + // do not let scrollbar values overflow + if (verticalBar.iThumbPosition + verticalBar.iThumbSpan > verticalBar.iScrollSpan) + verticalBar.iThumbPosition = verticalBar.iScrollSpan - verticalBar.iThumbSpan; + + TAknDoubleSpanScrollBarModel horizontalDSBar(horizontalBar); + TAknDoubleSpanScrollBarModel verticalDSBar(verticalBar); + + iScrollBarFrame->TileL(&horizontalDSBar, &verticalDSBar, rect, rect, layout); + iScrollBarFrame->SetVFocusPosToThumbPos(verticalDSBar.FocusPosition()); + } + else + { + iScrollBarFrame->TileL( &horizontalBar, &verticalBar, rect, rect, layout ); + iScrollBarFrame->SetVFocusPosToThumbPos( verticalBar.iThumbPosition ); + } + + + // update the screen + DrawNow(); + } + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + TBool CAlfPerfAppTestCaseSelectionView::CContainer::PrintText(const TDesC& aDes) + { + // This doesn't guarantee that iText length actually remains below KAlfPerfAppDisplayResultMaxChars + // but it won't exceed it that much. Approximation can be used for the limiting value. + if(iText->Length() < KAlfPerfAppDisplayResultMaxChars) + { + iText->Des().Append( aDes ); + return ETrue; + } + else + { + if(iNotPrintedResultDisplayBufferExceeded) + { + iText->Des().Append( KAlfPerfAppDisplayBufferFull); + TBuf line; + TBuf temp = iModel->TargetPath(); + line.Format(KAlfPerfAppPrintOutputFormat, &temp); + iText->Des().Append(line); + iNotPrintedResultDisplayBufferExceeded = EFalse; + } + return EFalse; + } + } + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CContainer::ClearOutputWindowL() + { + iText->Des().Zero(); + iNotPrintedResultDisplayBufferExceeded = ETrue; + UpdateVisualContentL(ETrue); + } + + + // ----------------------------------------------------------------------------- + // ----------------------------------------------------------------------------- + // + void CAlfPerfAppTestCaseSelectionView::CContainer::Draw( + const TRect& aRect ) const + { + CWindowGc& gc = SystemGc(); + gc.Clear(aRect); + gc.SetPenColor(KRgbBlack); + gc.UseFont(iFont); + + // draw the text + for (TInt i=0; iCount()) + gc.DrawText(iWrappedArray->At(i+iCurrentLine), + TPoint(TInt(iLeftDrawingPosition*iX_factor), TInt(iFont->HeightInPixels()*(i+1)))); + } + gc.DiscardFont(); + }