|
64
|
1 |
/*
|
|
|
2 |
* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies).
|
|
|
3 |
* All rights reserved.
|
|
|
4 |
* This component and the accompanying materials are made available
|
|
|
5 |
* under the terms of "Eclipse Public License v1.0"
|
|
|
6 |
* which accompanies this distribution, and is available
|
|
|
7 |
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
|
8 |
*
|
|
|
9 |
* Initial Contributors:
|
|
|
10 |
* Nokia Corporation - initial contribution.
|
|
|
11 |
*
|
|
|
12 |
* Contributors:
|
|
|
13 |
*
|
|
|
14 |
* Description: CAlfPerfAppTestCaseSelectionView implementation.
|
|
|
15 |
*
|
|
|
16 |
*/
|
|
|
17 |
|
|
|
18 |
|
|
|
19 |
#include <AknUtils.h>
|
|
|
20 |
#include <aknViewAppUi.h>
|
|
|
21 |
#include <alfperfapp.rsg>
|
|
|
22 |
#include <StringLoader.h>
|
|
|
23 |
#include <AknBidiTextUtils.h>
|
|
|
24 |
#include <aknutils.h>
|
|
|
25 |
#include <aknnotewrappers.h>
|
|
|
26 |
#include <eiksbfrm.h>
|
|
|
27 |
#include <akndef.h>
|
|
|
28 |
#include <bautils.h>
|
|
|
29 |
#include "alfperfapptestcaseselectionview.h"
|
|
|
30 |
#include "alfperfapp.hrh"
|
|
|
31 |
#include "alfperfappconstants.h"
|
|
|
32 |
#include "alfperfappmodel.h"
|
|
|
33 |
|
|
|
34 |
// Execution ongoing
|
|
|
35 |
_LIT( KAlfPerfAppExecuting, "Executing..\n" );
|
|
|
36 |
|
|
|
37 |
// Print output path
|
|
|
38 |
_LIT( KAlfPerfAppPrintOutputFormat, "Result files are in %S\n" );
|
|
|
39 |
|
|
|
40 |
// Error message display
|
|
|
41 |
_LIT( KAlfPerfAppNoErrors, "No errors.\n\n" );
|
|
|
42 |
_LIT( KAlfPerfAppErrorHeader, "Errors:\n" );
|
|
|
43 |
_LIT( KAlfPerfappErrorItem, " %S\n" );
|
|
|
44 |
_LIT( KAlfPerfAppErrorFooter, "\n" );
|
|
|
45 |
|
|
|
46 |
// Results display
|
|
|
47 |
_LIT( KAlfPerfAppInfoNote, "Program records results directly to two files, results are appended to the end of each file.\n\n");
|
|
|
48 |
_LIT( KAlfPerfAppClearFilesQueryLine1, "Earlier results present.");
|
|
|
49 |
_LIT( KAlfPerfAppClearFilesQueryLine2, "Clear the result files?");
|
|
|
50 |
_LIT( KAlfPerfAppResultsHeader,
|
|
|
51 |
"*** Field Guide ***\n- Time spend\n- Mem.usage of app,server and system\n- Frame count and fps\n");
|
|
|
52 |
//_LIT( KAlfPerfAppResultsCaseStart, "%.2f s: Case: %x\n" );
|
|
|
53 |
_LIT( KAlfPerfAppResultsCaseStart, "Started at: %.2f s\n");
|
|
|
54 |
_LIT( KAlfPerfAppResultsCaseTitle, "\n=== %S / %S (0x%x) ===\n");
|
|
|
55 |
_LIT( KAlfPerfAppResultsNone, "No results.\n\n" );
|
|
|
56 |
_LIT( KAlfPerfAppSpecificResultFooter,"\n");
|
|
|
57 |
|
|
|
58 |
_LIT( KAlfPerfAppResultsPhaseTitle0,"\n*** Startup ***\n" );
|
|
|
59 |
_LIT( KAlfPerfAppResultsPhaseTitle1,"\n*** Run ***\n" );
|
|
|
60 |
_LIT( KAlfPerfAppResultsPhaseTitle2,"\n*** Teardown ***\n" );
|
|
|
61 |
_LIT( KAlfPerfAppResultsCaseTotalTitle,"\n*** Case total ***\n" );
|
|
|
62 |
_LIT( KAlfPerfAppResultsCaseItem,
|
|
|
63 |
"Time: %.2f s\nMem.usage: %d/%d/%d kb\nFrames: %d (%3.1f fps)\n" );
|
|
|
64 |
|
|
|
65 |
// Buffer full
|
|
|
66 |
const TInt KAlfPerfAppDisplayResultMaxChars = 35000; //increase is needed for Sequence test cases
|
|
|
67 |
_LIT( KAlfPerfAppDisplayBufferFull,"\n*** Display buffer full ***\n");
|
|
|
68 |
|
|
|
69 |
|
|
|
70 |
|
|
|
71 |
|
|
|
72 |
/**
|
|
|
73 |
* CAlfPerfAppTestCaseSelectionView::CContainer container class.
|
|
|
74 |
*/
|
|
|
75 |
class CAlfPerfAppTestCaseSelectionView::CContainer : public CCoeControl, MCoeControlObserver, MEikScrollBarObserver
|
|
|
76 |
{
|
|
|
77 |
public:
|
|
|
78 |
CContainer(CAlfPerfAppModel* aModel);
|
|
|
79 |
void ConstructL();
|
|
|
80 |
~CContainer();
|
|
|
81 |
|
|
|
82 |
public: // New functions
|
|
|
83 |
TBool PrintText(const TDesC& aDes);
|
|
|
84 |
void ClearOutputWindowL();
|
|
|
85 |
void UpdateVisualContentL(TBool aScrollToBottom);
|
|
|
86 |
|
|
|
87 |
public: // From base classes
|
|
|
88 |
virtual TKeyResponse OfferKeyEventL(
|
|
|
89 |
const TKeyEvent& aKeyEvent, TEventCode aType );
|
|
|
90 |
virtual void HandleResourceChange( TInt aType );
|
|
|
91 |
virtual void Draw(const TRect& aRect) const;
|
|
|
92 |
virtual void HandleControlEventL(CCoeControl* aControl,TCoeEvent aEventType);
|
|
|
93 |
virtual void HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType); // From MEikScrollBarObserver
|
|
|
94 |
|
|
|
95 |
private:
|
|
|
96 |
CEikScrollBarFrame* iScrollBarFrame;
|
|
|
97 |
HBufC* iText;
|
|
|
98 |
CFont* iFont;
|
|
|
99 |
HBufC* iWrapperString;
|
|
|
100 |
CArrayFix<TPtrC>* iWrappedArray;
|
|
|
101 |
TInt iCurrentLine;
|
|
|
102 |
TInt iLineCount;
|
|
|
103 |
TInt iNumberOfLinesFitsScreen;
|
|
|
104 |
TInt iLeftDrawingPosition;
|
|
|
105 |
TReal iX_factor;
|
|
|
106 |
TReal iY_factor;
|
|
|
107 |
TBool iNotPrintedResultDisplayBufferExceeded;
|
|
|
108 |
CAlfPerfAppModel* iModel;
|
|
|
109 |
};
|
|
|
110 |
|
|
|
111 |
// ============================ MEMBER FUNCTIONS ===============================
|
|
|
112 |
|
|
|
113 |
// -----------------------------------------------------------------------------
|
|
|
114 |
// -----------------------------------------------------------------------------
|
|
|
115 |
//
|
|
|
116 |
CAlfPerfAppTestCaseSelectionView* CAlfPerfAppTestCaseSelectionView::NewLC(
|
|
|
117 |
CAlfPerfAppModel& aModel )
|
|
|
118 |
{
|
|
|
119 |
CAlfPerfAppTestCaseSelectionView* self =
|
|
|
120 |
new (ELeave) CAlfPerfAppTestCaseSelectionView( aModel );
|
|
|
121 |
CleanupStack::PushL( self );
|
|
|
122 |
self->ConstructL();
|
|
|
123 |
return self;
|
|
|
124 |
}
|
|
|
125 |
|
|
|
126 |
// -----------------------------------------------------------------------------
|
|
|
127 |
// -----------------------------------------------------------------------------
|
|
|
128 |
//
|
|
|
129 |
CAlfPerfAppTestCaseSelectionView::~CAlfPerfAppTestCaseSelectionView()
|
|
|
130 |
{
|
|
|
131 |
}
|
|
|
132 |
|
|
|
133 |
// -----------------------------------------------------------------------------
|
|
|
134 |
// -----------------------------------------------------------------------------
|
|
|
135 |
//
|
|
|
136 |
CAlfPerfAppTestCaseSelectionView::CAlfPerfAppTestCaseSelectionView(
|
|
|
137 |
CAlfPerfAppModel& aModel )
|
|
|
138 |
: iModel( aModel )
|
|
|
139 |
{
|
|
|
140 |
}
|
|
|
141 |
|
|
|
142 |
// -----------------------------------------------------------------------------
|
|
|
143 |
// -----------------------------------------------------------------------------
|
|
|
144 |
//
|
|
|
145 |
void CAlfPerfAppTestCaseSelectionView::ConstructL()
|
|
|
146 |
{
|
|
|
147 |
BaseConstructL( R_ALFPERFAPP_TEST_CASE_SELECTION_VIEW );
|
|
|
148 |
}
|
|
|
149 |
|
|
|
150 |
// -----------------------------------------------------------------------------
|
|
|
151 |
// -----------------------------------------------------------------------------
|
|
|
152 |
//
|
|
|
153 |
void CAlfPerfAppTestCaseSelectionView::CmdRunAllL()
|
|
|
154 |
{
|
|
|
155 |
// Run all test cases (that are not excluded from 'run all').
|
|
|
156 |
iModel.ResetErrorArray();
|
|
|
157 |
if (iContainer)
|
|
|
158 |
{
|
|
|
159 |
iContainer->ClearOutputWindowL();
|
|
|
160 |
iContainer->PrintText( KAlfPerfAppExecuting );
|
|
|
161 |
}
|
|
|
162 |
iModel.ResetExecuteArray();
|
|
|
163 |
|
|
|
164 |
const TInt suiteCount = iModel.SuiteCount();
|
|
|
165 |
for ( TInt ii = 0; ii < suiteCount; ii++ )
|
|
|
166 |
{
|
|
|
167 |
// If suite is not excluded from run all,
|
|
|
168 |
// add all test cases to execute array.
|
|
|
169 |
if ( !( iModel.SuiteFlags( ii ) &
|
|
|
170 |
EAlfPerfAppTestSuiteFlagExcludeFromRunAll ) )
|
|
|
171 |
{
|
|
|
172 |
// Add all test cases to execute array.
|
|
|
173 |
const TInt testCount = iModel.TestCaseCount( ii );
|
|
|
174 |
for ( TInt jj = 0; jj < testCount; jj++ )
|
|
|
175 |
{
|
|
|
176 |
TPtrC testName;
|
|
|
177 |
TInt testCaseId;
|
|
|
178 |
TInt testCaseFlags;
|
|
|
179 |
TInt testCaseSequenceLength;
|
|
|
180 |
|
|
|
181 |
iModel.GetTestCase(
|
|
|
182 |
ii,
|
|
|
183 |
jj,
|
|
|
184 |
testName,
|
|
|
185 |
testCaseId,
|
|
|
186 |
testCaseFlags,
|
|
|
187 |
testCaseSequenceLength);
|
|
|
188 |
|
|
|
189 |
// Add the test case multiple times to fill the sequence (at least once though)
|
|
|
190 |
iModel.AddToExecuteArrayL( testCaseId );
|
|
|
191 |
for(TInt index = 1; index < testCaseSequenceLength;index++)
|
|
|
192 |
{
|
|
|
193 |
iModel.AddToExecuteArrayL( testCaseId );
|
|
|
194 |
}
|
|
|
195 |
}
|
|
|
196 |
}
|
|
|
197 |
|
|
|
198 |
}
|
|
|
199 |
|
|
|
200 |
AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId );
|
|
|
201 |
}
|
|
|
202 |
|
|
|
203 |
|
|
|
204 |
|
|
|
205 |
void CAlfPerfAppTestCaseSelectionView::CmdRunAllContinuouslyL()
|
|
|
206 |
{
|
|
|
207 |
// Run all test cases (that are not excluded from 'run all').
|
|
|
208 |
iModel.ResetErrorArray();
|
|
|
209 |
if (iContainer)
|
|
|
210 |
{
|
|
|
211 |
iContainer->ClearOutputWindowL();
|
|
|
212 |
iContainer->PrintText( KAlfPerfAppExecuting );
|
|
|
213 |
}
|
|
|
214 |
iModel.ResetExecuteArray();
|
|
|
215 |
|
|
|
216 |
const TInt suiteCount = iModel.SuiteCount();
|
|
|
217 |
for ( TInt ii = 0; ii < suiteCount; ii++ )
|
|
|
218 |
{
|
|
|
219 |
// If suite is not excluded from run all,
|
|
|
220 |
// add all test cases to execute array.
|
|
|
221 |
if ( !( iModel.SuiteFlags( ii ) &
|
|
|
222 |
EAlfPerfAppTestSuiteFlagExcludeFromRunAll ) )
|
|
|
223 |
{
|
|
|
224 |
// Add all test cases to execute array.
|
|
|
225 |
const TInt testCount = iModel.TestCaseCount( ii );
|
|
|
226 |
for ( TInt jj = 0; jj < testCount; jj++ )
|
|
|
227 |
{
|
|
|
228 |
TPtrC testName;
|
|
|
229 |
TInt testCaseId;
|
|
|
230 |
TInt testCaseFlags;
|
|
|
231 |
TInt testCaseSequenceLength;
|
|
|
232 |
|
|
|
233 |
iModel.GetTestCase(
|
|
|
234 |
ii,
|
|
|
235 |
jj,
|
|
|
236 |
testName,
|
|
|
237 |
testCaseId,
|
|
|
238 |
testCaseFlags,
|
|
|
239 |
testCaseSequenceLength);
|
|
|
240 |
|
|
|
241 |
// Add the test case multiple times to fill the sequence (at least once though)
|
|
|
242 |
iModel.AddToExecuteArrayL( testCaseId );
|
|
|
243 |
for(TInt index = 1; index < testCaseSequenceLength;index++)
|
|
|
244 |
{
|
|
|
245 |
iModel.AddToExecuteArrayL( testCaseId );
|
|
|
246 |
}
|
|
|
247 |
}
|
|
|
248 |
}
|
|
|
249 |
|
|
|
250 |
}
|
|
|
251 |
|
|
|
252 |
// Finally tell ExecutionView to use Continuous Run
|
|
|
253 |
const TUid KCustomMessageUid = {2};
|
|
|
254 |
TBuf8<KAlfPerfAppMaxCharsInLine> customMessage;
|
|
|
255 |
customMessage.Copy(_L8("UseContinuousRun"));
|
|
|
256 |
AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId,KCustomMessageUid,customMessage);
|
|
|
257 |
}
|
|
|
258 |
|
|
|
259 |
|
|
|
260 |
// -----------------------------------------------------------------------------
|
|
|
261 |
// -----------------------------------------------------------------------------
|
|
|
262 |
//
|
|
|
263 |
void CAlfPerfAppTestCaseSelectionView::CmdRunAllFromSuiteL(
|
|
|
264 |
TInt aSuiteIndex )
|
|
|
265 |
{
|
|
|
266 |
// Run all test cases related to specific suite.
|
|
|
267 |
const TInt testCaseCount = iModel.TestCaseCount( aSuiteIndex );
|
|
|
268 |
iModel.ResetErrorArray();
|
|
|
269 |
|
|
|
270 |
if (iContainer)
|
|
|
271 |
{
|
|
|
272 |
iContainer->ClearOutputWindowL();
|
|
|
273 |
iContainer->PrintText( KAlfPerfAppExecuting );
|
|
|
274 |
}
|
|
|
275 |
|
|
|
276 |
iModel.ResetExecuteArray();
|
|
|
277 |
|
|
|
278 |
for ( TInt ii = 0; ii < testCaseCount; ii++ )
|
|
|
279 |
{
|
|
|
280 |
TPtrC testCaseName;
|
|
|
281 |
TInt testCaseId;
|
|
|
282 |
TInt testCaseFlags;
|
|
|
283 |
TInt testCaseSequenceLength;
|
|
|
284 |
|
|
|
285 |
iModel.GetTestCase(
|
|
|
286 |
aSuiteIndex,
|
|
|
287 |
ii,
|
|
|
288 |
testCaseName,
|
|
|
289 |
testCaseId,
|
|
|
290 |
testCaseFlags,
|
|
|
291 |
testCaseSequenceLength);
|
|
|
292 |
|
|
|
293 |
// Add the test case multiple times to fill the sequence (at least once though)
|
|
|
294 |
iModel.AddToExecuteArrayL( testCaseId );
|
|
|
295 |
for(TInt index = 1; index < testCaseSequenceLength;index++)
|
|
|
296 |
{
|
|
|
297 |
iModel.AddToExecuteArrayL( testCaseId );
|
|
|
298 |
}
|
|
|
299 |
|
|
|
300 |
AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId );
|
|
|
301 |
}
|
|
|
302 |
}
|
|
|
303 |
|
|
|
304 |
// -----------------------------------------------------------------------------
|
|
|
305 |
// -----------------------------------------------------------------------------
|
|
|
306 |
//
|
|
|
307 |
void CAlfPerfAppTestCaseSelectionView::CmdRunTestCaseL(
|
|
|
308 |
TInt aSuiteIndex, TInt aTestCaseIndex )
|
|
|
309 |
{
|
|
|
310 |
TPtrC testCaseName;
|
|
|
311 |
TInt testCaseId;
|
|
|
312 |
TInt testCaseFlags;
|
|
|
313 |
TInt testCaseSequenceLength;
|
|
|
314 |
|
|
|
315 |
iModel.GetTestCase(
|
|
|
316 |
aSuiteIndex,
|
|
|
317 |
aTestCaseIndex,
|
|
|
318 |
testCaseName,
|
|
|
319 |
testCaseId,
|
|
|
320 |
testCaseFlags,
|
|
|
321 |
testCaseSequenceLength);
|
|
|
322 |
|
|
|
323 |
iModel.ResetErrorArray();
|
|
|
324 |
if (iContainer)
|
|
|
325 |
{
|
|
|
326 |
iContainer->ClearOutputWindowL();
|
|
|
327 |
iContainer->PrintText( KAlfPerfAppExecuting );
|
|
|
328 |
}
|
|
|
329 |
iModel.ResetExecuteArray();
|
|
|
330 |
|
|
|
331 |
// Add the test case multiple times to fill the sequence (at least once though)
|
|
|
332 |
iModel.AddToExecuteArrayL( testCaseId );
|
|
|
333 |
for(TInt index = 1; index < testCaseSequenceLength;index++)
|
|
|
334 |
{
|
|
|
335 |
iModel.AddToExecuteArrayL( testCaseId );
|
|
|
336 |
}
|
|
|
337 |
|
|
|
338 |
AppUi()->ActivateLocalViewL( KAlfPerfAppTestCaseExecutionViewId );
|
|
|
339 |
}
|
|
|
340 |
|
|
|
341 |
// -----------------------------------------------------------------------------
|
|
|
342 |
// -----------------------------------------------------------------------------
|
|
|
343 |
//
|
|
|
344 |
TUid CAlfPerfAppTestCaseSelectionView::Id() const
|
|
|
345 |
{
|
|
|
346 |
return KAlfPerfAppTestCaseSelectionViewId;
|
|
|
347 |
}
|
|
|
348 |
|
|
|
349 |
// -----------------------------------------------------------------------------
|
|
|
350 |
// Handles view activation
|
|
|
351 |
// -----------------------------------------------------------------------------
|
|
|
352 |
//
|
|
|
353 |
void CAlfPerfAppTestCaseSelectionView::DoActivateL(
|
|
|
354 |
const TVwsViewId& /*aPrevViewId*/,
|
|
|
355 |
TUid /*aCustomMessageId*/,
|
|
|
356 |
const TDesC8& /*aCustomMessage*/ )
|
|
|
357 |
{
|
|
|
358 |
ResetContainerL();
|
|
|
359 |
|
|
|
360 |
DisplayResultsL();
|
|
|
361 |
|
|
|
362 |
// Pop up the "Clear result files?"-dialog if either of the files existed.
|
|
|
363 |
static TBool firstTime = ETrue;
|
|
|
364 |
if(firstTime)
|
|
|
365 |
{
|
|
|
366 |
if(iModel.TargetFilesExisted())
|
|
|
367 |
{
|
|
|
368 |
if(CEikonEnv::Static()->QueryWinL(KAlfPerfAppClearFilesQueryLine1,KAlfPerfAppClearFilesQueryLine2))
|
|
|
369 |
{
|
|
|
370 |
// Clear the files
|
|
|
371 |
iModel.OpenFilesL(true);
|
|
|
372 |
}
|
|
|
373 |
firstTime = EFalse;
|
|
|
374 |
}
|
|
|
375 |
}
|
|
|
376 |
}
|
|
|
377 |
|
|
|
378 |
// -----------------------------------------------------------------------------
|
|
|
379 |
// Handles view deactivation
|
|
|
380 |
// -----------------------------------------------------------------------------
|
|
|
381 |
//
|
|
|
382 |
void CAlfPerfAppTestCaseSelectionView::DoDeactivate()
|
|
|
383 |
{
|
|
|
384 |
if ( iContainer )
|
|
|
385 |
{
|
|
|
386 |
AppUi()->RemoveFromStack( iContainer );
|
|
|
387 |
delete iContainer;
|
|
|
388 |
iContainer = NULL;
|
|
|
389 |
}
|
|
|
390 |
}
|
|
|
391 |
|
|
|
392 |
|
|
|
393 |
// -----------------------------------------------------------------------------
|
|
|
394 |
// Display test results on screen. The text is wrapped.
|
|
|
395 |
// -----------------------------------------------------------------------------
|
|
|
396 |
//
|
|
|
397 |
void CAlfPerfAppTestCaseSelectionView::DisplayResultsL()
|
|
|
398 |
{
|
|
|
399 |
if (iContainer)
|
|
|
400 |
{
|
|
|
401 |
TBuf<KAlfPerfAppMaxCharsInLine> line;
|
|
|
402 |
iContainer->ClearOutputWindowL();
|
|
|
403 |
|
|
|
404 |
const TInt errorCount = iModel.ErrorArrayCount();
|
|
|
405 |
if ( !errorCount )
|
|
|
406 |
{
|
|
|
407 |
iContainer->PrintText( KAlfPerfAppNoErrors );
|
|
|
408 |
}
|
|
|
409 |
else
|
|
|
410 |
{
|
|
|
411 |
iContainer->PrintText( KAlfPerfAppErrorHeader );
|
|
|
412 |
for ( TInt ii = 0; ii < errorCount; ii++ )
|
|
|
413 |
{
|
|
|
414 |
TPtrC message;
|
|
|
415 |
iModel.GetFromErrorArray( ii, message );
|
|
|
416 |
if ( message.Length() )
|
|
|
417 |
{
|
|
|
418 |
line.Zero();
|
|
|
419 |
TPtrC item = message.Left( 64 );
|
|
|
420 |
line.Format( KAlfPerfappErrorItem, &item );
|
|
|
421 |
iContainer->PrintText( line );
|
|
|
422 |
}
|
|
|
423 |
}
|
|
|
424 |
iContainer->PrintText( KAlfPerfAppErrorFooter );
|
|
|
425 |
}
|
|
|
426 |
|
|
|
427 |
if (iModel.ResultsNotAddedToFile())
|
|
|
428 |
{
|
|
|
429 |
iContainer->PrintText( KAlfPerfAppResultsNone );
|
|
|
430 |
iContainer->PrintText( KAlfPerfAppInfoNote );
|
|
|
431 |
}
|
|
|
432 |
else
|
|
|
433 |
{
|
|
|
434 |
line.Zero();
|
|
|
435 |
line.Format( KAlfPerfAppResultsHeader );
|
|
|
436 |
iContainer->PrintText(line);
|
|
|
437 |
|
|
|
438 |
// Prepare to read lines
|
|
|
439 |
TFileText LineFromFile;
|
|
|
440 |
LineFromFile.Set(*iModel.ResultFile());
|
|
|
441 |
LineFromFile.Seek(ESeekStart);
|
|
|
442 |
|
|
|
443 |
// Read the first line and forget it (header info only)
|
|
|
444 |
line.Copy(getLineFromTargetFile());
|
|
|
445 |
|
|
|
446 |
TInt currentCase = 0;
|
|
|
447 |
TBool startTimeNotRecorded = ETrue;
|
|
|
448 |
TUint32 timeStampAtStart = 0;
|
|
|
449 |
TInt framesSinceCase = 0;
|
|
|
450 |
CAlfPerfAppModel::TTestCaseResultItem itemAtCase;
|
|
|
451 |
CAlfPerfAppModel::TTestCaseResultItem itemAtPhase;
|
|
|
452 |
TBuf8<KAlfPerfAppMaxCharsInSpecificResultText> specificResultStorage;
|
|
|
453 |
for(TInt i=0; ; i++) // i = line number in result file
|
|
|
454 |
{
|
|
|
455 |
line.Zero();
|
|
|
456 |
|
|
|
457 |
// Read a line from file and convert it to an TTestCaseResultItem
|
|
|
458 |
line.Copy(getLineFromTargetFile());
|
|
|
459 |
if(line.Length() == 0)
|
|
|
460 |
{
|
|
|
461 |
// If the line is empty, end this loop
|
|
|
462 |
break;
|
|
|
463 |
}
|
|
|
464 |
CAlfPerfAppModel::TTestCaseResultItem item;
|
|
|
465 |
item = ResultItemFromLine(line);
|
|
|
466 |
line.Zero();
|
|
|
467 |
|
|
|
468 |
if(startTimeNotRecorded)
|
|
|
469 |
{
|
|
|
470 |
timeStampAtStart = item.iTimeStamp;
|
|
|
471 |
startTimeNotRecorded = EFalse;
|
|
|
472 |
}
|
|
|
473 |
|
|
|
474 |
TUint32 timeFromStart =
|
|
|
475 |
DeltaFromCurrentToPrevious(
|
|
|
476 |
item.iTimeStamp, timeStampAtStart );
|
|
|
477 |
|
|
|
478 |
TBool changedCase = EFalse;
|
|
|
479 |
if ( !i || currentCase != item.iCaseId )
|
|
|
480 |
{
|
|
|
481 |
currentCase = item.iCaseId;
|
|
|
482 |
itemAtCase = item;
|
|
|
483 |
framesSinceCase = 0;
|
|
|
484 |
changedCase = ETrue;
|
|
|
485 |
//specificResultStorage.Zero();
|
|
|
486 |
}
|
|
|
487 |
|
|
|
488 |
if(changedCase || itemAtPhase.iPhase != item.iPhase)
|
|
|
489 |
{
|
|
|
490 |
itemAtPhase = item;
|
|
|
491 |
}
|
|
|
492 |
|
|
|
493 |
if ( changedCase )
|
|
|
494 |
{
|
|
|
495 |
// Name
|
|
|
496 |
TBuf<100> suiteName;
|
|
|
497 |
suiteName.Copy(item.iSuiteName);
|
|
|
498 |
TBuf<100> caseName;
|
|
|
499 |
caseName.Copy(item.iCaseName);
|
|
|
500 |
line.Format(
|
|
|
501 |
KAlfPerfAppResultsCaseTitle,
|
|
|
502 |
&suiteName,
|
|
|
503 |
&caseName,
|
|
|
504 |
item.iCaseId);
|
|
|
505 |
if(!iContainer->PrintText(line))break;
|
|
|
506 |
line.Zero();
|
|
|
507 |
|
|
|
508 |
// Start time
|
|
|
509 |
line.AppendFormat( KAlfPerfAppResultsCaseStart,
|
|
|
510 |
((TReal32)timeFromStart/1000));
|
|
|
511 |
if(!iContainer->PrintText(line))break;
|
|
|
512 |
line.Zero();
|
|
|
513 |
}
|
|
|
514 |
|
|
|
515 |
if(item.specificResult8.Length() != 0)
|
|
|
516 |
{
|
|
|
517 |
specificResultStorage.Zero();
|
|
|
518 |
specificResultStorage.Append(item.specificResult8);
|
|
|
519 |
}
|
|
|
520 |
|
|
|
521 |
if(i&0x1) // Skip even lines
|
|
|
522 |
{
|
|
|
523 |
// Print phase data
|
|
|
524 |
if (item.iPhase == 0)
|
|
|
525 |
{
|
|
|
526 |
line.AppendFormat(KAlfPerfAppResultsPhaseTitle0);
|
|
|
527 |
}
|
|
|
528 |
else if (item.iPhase == 1)
|
|
|
529 |
{
|
|
|
530 |
line.AppendFormat(KAlfPerfAppResultsPhaseTitle1);
|
|
|
531 |
}
|
|
|
532 |
else
|
|
|
533 |
{
|
|
|
534 |
line.AppendFormat(KAlfPerfAppResultsPhaseTitle2);
|
|
|
535 |
}
|
|
|
536 |
|
|
|
537 |
line.AppendFormat( KAlfPerfAppResultsCaseItem,
|
|
|
538 |
// duration
|
|
|
539 |
((TReal32)item.imsSincePhase)/1000,
|
|
|
540 |
// memory consumption delta
|
|
|
541 |
( item.iAppMemory - itemAtPhase.iAppMemory )/ 1024,
|
|
|
542 |
( item.iServerMemory - itemAtPhase.iServerMemory )/ 1024,
|
|
|
543 |
( item.iSystemMemory - itemAtPhase.iSystemMemory )/ 1024,
|
|
|
544 |
// frame info
|
|
|
545 |
item.iFrameCount,
|
|
|
546 |
item.iFPS );
|
|
|
547 |
if(!iContainer->PrintText(line))break;
|
|
|
548 |
line.Zero();
|
|
|
549 |
|
|
|
550 |
// Testcase specific results
|
|
|
551 |
if(specificResultStorage.Length() != 0)
|
|
|
552 |
{
|
|
|
553 |
TBuf<KAlfPerfAppMaxCharsInSpecificResultText> specificResult16;
|
|
|
554 |
specificResult16.Copy(specificResultStorage);
|
|
|
555 |
line.Append(specificResult16);
|
|
|
556 |
line.Append(KAlfPerfAppSpecificResultFooter);
|
|
|
557 |
if(!iContainer->PrintText(line))break;
|
|
|
558 |
specificResultStorage.Zero();
|
|
|
559 |
line.Zero();
|
|
|
560 |
}
|
|
|
561 |
|
|
|
562 |
|
|
|
563 |
framesSinceCase += item.iFrameCount;
|
|
|
564 |
if (item.iPhase == 2)
|
|
|
565 |
{
|
|
|
566 |
// Print case data
|
|
|
567 |
// need to be done like this because of fpsSinceCase is not
|
|
|
568 |
// recorded to file
|
|
|
569 |
TUint32 timeFromCase = item.imsSinceCase;
|
|
|
570 |
|
|
|
571 |
TReal32 fpsSinceCase = 0.f;
|
|
|
572 |
if ( timeFromCase != 0 )
|
|
|
573 |
{
|
|
|
574 |
fpsSinceCase = ((TReal32)framesSinceCase*1000)/timeFromCase;
|
|
|
575 |
}
|
|
|
576 |
|
|
|
577 |
line.AppendFormat(KAlfPerfAppResultsCaseTotalTitle);
|
|
|
578 |
if(!iContainer->PrintText(line))break;
|
|
|
579 |
|
|
|
580 |
line.Format( KAlfPerfAppResultsCaseItem,
|
|
|
581 |
// duration
|
|
|
582 |
((TReal32)timeFromCase/1000),
|
|
|
583 |
// memory consumption delta
|
|
|
584 |
( item.iAppMemory - itemAtCase.iAppMemory )/ 1024,
|
|
|
585 |
( item.iServerMemory - itemAtCase.iServerMemory )/ 1024,
|
|
|
586 |
( item.iSystemMemory - itemAtCase.iSystemMemory )/ 1024,
|
|
|
587 |
// frame info
|
|
|
588 |
framesSinceCase,
|
|
|
589 |
fpsSinceCase );
|
|
|
590 |
|
|
|
591 |
if(!iContainer->PrintText(line))break;
|
|
|
592 |
line.Zero();
|
|
|
593 |
}
|
|
|
594 |
|
|
|
595 |
}
|
|
|
596 |
}
|
|
|
597 |
}
|
|
|
598 |
|
|
|
599 |
TBuf<KAlfPerfAppMaxCharsInLine> temp = iModel.TargetPath();
|
|
|
600 |
line.Format( KAlfPerfAppPrintOutputFormat, &temp);
|
|
|
601 |
iContainer->PrintText(line);
|
|
|
602 |
|
|
|
603 |
// Finally update results to screen
|
|
|
604 |
iContainer->UpdateVisualContentL(ETrue);
|
|
|
605 |
}
|
|
|
606 |
}
|
|
|
607 |
|
|
|
608 |
|
|
|
609 |
// -----------------------------------------------------------------------------
|
|
|
610 |
// Handles test case selection view specific commands.
|
|
|
611 |
// -----------------------------------------------------------------------------
|
|
|
612 |
//
|
|
|
613 |
void CAlfPerfAppTestCaseSelectionView::HandleCommandL( TInt aCommand )
|
|
|
614 |
{
|
|
|
615 |
switch ( aCommand )
|
|
|
616 |
{
|
|
|
617 |
case EAlfPerfAppCmdRunAll:
|
|
|
618 |
CmdRunAllL();
|
|
|
619 |
break;
|
|
|
620 |
|
|
|
621 |
case EAlfPerfAppCmdRunAllContinuously:
|
|
|
622 |
CmdRunAllContinuouslyL();
|
|
|
623 |
break;
|
|
|
624 |
|
|
|
625 |
case EAlfPerfAppCmdClearFiles:
|
|
|
626 |
|
|
|
627 |
TBuf<1> empty;
|
|
|
628 |
if(CEikonEnv::Static()->QueryWinL(KAlfPerfAppClearFilesQueryLine2,empty))
|
|
|
629 |
{
|
|
|
630 |
// Clear the files
|
|
|
631 |
iModel.OpenFilesL(true);
|
|
|
632 |
ResetContainerL();
|
|
|
633 |
DisplayResultsL();
|
|
|
634 |
}
|
|
|
635 |
|
|
|
636 |
break;
|
|
|
637 |
|
|
|
638 |
|
|
|
639 |
default:
|
|
|
640 |
{
|
|
|
641 |
if ( ( aCommand & ~0xFFFF ) == EAlfPerfAppCmdTestCase )
|
|
|
642 |
{
|
|
|
643 |
const TInt testSuiteIndex = ( aCommand & 0xFF00 ) >> 8;
|
|
|
644 |
TInt testCaseIndex = aCommand & 0xFF;
|
|
|
645 |
|
|
|
646 |
if ( !testCaseIndex )
|
|
|
647 |
{
|
|
|
648 |
CmdRunAllFromSuiteL( testSuiteIndex );
|
|
|
649 |
}
|
|
|
650 |
else
|
|
|
651 |
{
|
|
|
652 |
// Run one specific test case
|
|
|
653 |
testCaseIndex--;
|
|
|
654 |
CmdRunTestCaseL( testSuiteIndex, testCaseIndex );
|
|
|
655 |
}
|
|
|
656 |
}
|
|
|
657 |
else
|
|
|
658 |
{
|
|
|
659 |
AppUi()->HandleCommandL( aCommand );
|
|
|
660 |
}
|
|
|
661 |
}
|
|
|
662 |
break;
|
|
|
663 |
}
|
|
|
664 |
}
|
|
|
665 |
|
|
|
666 |
|
|
|
667 |
// -----------------------------------------------------------------------------
|
|
|
668 |
// -----------------------------------------------------------------------------
|
|
|
669 |
//
|
|
|
670 |
void CAlfPerfAppTestCaseSelectionView::RestoreMenuL(
|
|
|
671 |
CCoeControl* aMenuControl, TInt aResourceId, TMenuType aType )
|
|
|
672 |
{
|
|
|
673 |
// Override resource in case of test suite menu
|
|
|
674 |
iResourceId = 0;
|
|
|
675 |
|
|
|
676 |
if ( ( aResourceId & ~0xFFFF ) == KAlfPerfAppMenuPaneResourceId )
|
|
|
677 |
{
|
|
|
678 |
iResourceId = aResourceId;
|
|
|
679 |
aResourceId = R_ALFPERFAPP_TEST_CASE_SELECTION_SUITE_MENUPANE;
|
|
|
680 |
}
|
|
|
681 |
|
|
|
682 |
CAknView::RestoreMenuL(
|
|
|
683 |
aMenuControl,
|
|
|
684 |
aResourceId,
|
|
|
685 |
aType );
|
|
|
686 |
}
|
|
|
687 |
|
|
|
688 |
// -----------------------------------------------------------------------------
|
|
|
689 |
// -----------------------------------------------------------------------------
|
|
|
690 |
//
|
|
|
691 |
void CAlfPerfAppTestCaseSelectionView::DynInitMenuPaneL(
|
|
|
692 |
TInt aResourceId,
|
|
|
693 |
CEikMenuPane* aMenuPane )
|
|
|
694 |
{
|
|
|
695 |
if ( aResourceId == R_ALFPERFAPP_TEST_CASE_SELECTION_MENUPANE )
|
|
|
696 |
{
|
|
|
697 |
// Add all suites to top level options menu.
|
|
|
698 |
const TInt suiteCount = iModel.SuiteCount();
|
|
|
699 |
for ( TInt ii = suiteCount - 1; ii >= 0; ii-- )
|
|
|
700 |
{
|
|
|
701 |
CEikMenuPaneItem::SData data;
|
|
|
702 |
data.iCommandId = 0;
|
|
|
703 |
data.iCascadeId = KAlfPerfAppMenuPaneResourceId + (ii << 8);
|
|
|
704 |
data.iFlags = 0;
|
|
|
705 |
data.iText.Copy( iModel.SuiteName( ii ) );
|
|
|
706 |
data.iExtraText.Zero();
|
|
|
707 |
|
|
|
708 |
aMenuPane->AddMenuItemL( data, EAlfPerfAppCmdRunAllContinuously );
|
|
|
709 |
}
|
|
|
710 |
}
|
|
|
711 |
|
|
|
712 |
if ( aResourceId == R_ALFPERFAPP_TEST_CASE_SELECTION_SUITE_MENUPANE )
|
|
|
713 |
{
|
|
|
714 |
const TInt suiteIndex = ( iResourceId & 0xFF00 ) >> 8;
|
|
|
715 |
const TInt testCaseCount = iModel.TestCaseCount( suiteIndex );
|
|
|
716 |
|
|
|
717 |
// Add 'Run All' option
|
|
|
718 |
HBufC* runAllText = StringLoader::LoadLC( R_ALFPERFAPP_TEXT_RUNALL );
|
|
|
719 |
CEikMenuPaneItem::SData runAll;
|
|
|
720 |
runAll.iCommandId = EAlfPerfAppCmdTestCase + (suiteIndex << 8);
|
|
|
721 |
runAll.iCascadeId = 0;
|
|
|
722 |
runAll.iFlags = 0;
|
|
|
723 |
runAll.iText.Copy( *runAllText );
|
|
|
724 |
runAll.iExtraText.Zero();
|
|
|
725 |
aMenuPane->AddMenuItemL( runAll );
|
|
|
726 |
CleanupStack::PopAndDestroy( runAllText );
|
|
|
727 |
|
|
|
728 |
// Add options menu items for all test cases of this suite
|
|
|
729 |
for ( TInt ii = 0; ii < testCaseCount; ii++ )
|
|
|
730 |
{
|
|
|
731 |
CEikMenuPaneItem::SData data;
|
|
|
732 |
data.iCommandId = EAlfPerfAppCmdTestCase + (suiteIndex << 8) + ii + 1;
|
|
|
733 |
data.iCascadeId = 0;
|
|
|
734 |
data.iFlags = 0;
|
|
|
735 |
|
|
|
736 |
TPtrC testCaseName;
|
|
|
737 |
TInt testCaseId;
|
|
|
738 |
TInt flags;
|
|
|
739 |
TInt sequenceLength;
|
|
|
740 |
|
|
|
741 |
iModel.GetTestCase(
|
|
|
742 |
suiteIndex,
|
|
|
743 |
ii,
|
|
|
744 |
testCaseName,
|
|
|
745 |
testCaseId,
|
|
|
746 |
flags,
|
|
|
747 |
sequenceLength);
|
|
|
748 |
|
|
|
749 |
data.iText.Copy( testCaseName );
|
|
|
750 |
data.iExtraText.Zero();
|
|
|
751 |
|
|
|
752 |
aMenuPane->AddMenuItemL( data );
|
|
|
753 |
}
|
|
|
754 |
}
|
|
|
755 |
}
|
|
|
756 |
|
|
|
757 |
TBuf8<KAlfPerfAppMaxCharsInLine> CAlfPerfAppTestCaseSelectionView::getLineFromTargetFile()
|
|
|
758 |
{
|
|
|
759 |
TBuf8<KAlfPerfAppMaxCharsInLine> line;
|
|
|
760 |
TBuf8<1> character;
|
|
|
761 |
iModel.ResultFile()->Read(character,1);
|
|
|
762 |
if(character.Length() == 0)
|
|
|
763 |
{
|
|
|
764 |
// File was empty --> return empty line
|
|
|
765 |
return line;
|
|
|
766 |
}
|
|
|
767 |
while(character[0] != '\n')
|
|
|
768 |
{
|
|
|
769 |
line.Append(character);
|
|
|
770 |
iModel.ResultFile()->Read(character,1);
|
|
|
771 |
}
|
|
|
772 |
return line;
|
|
|
773 |
}
|
|
|
774 |
|
|
|
775 |
void CAlfPerfAppTestCaseSelectionView::ResetContainerL()
|
|
|
776 |
{
|
|
|
777 |
// Reset the container
|
|
|
778 |
if ( iContainer )
|
|
|
779 |
{
|
|
|
780 |
AppUi()->RemoveFromStack( iContainer );
|
|
|
781 |
delete iContainer;
|
|
|
782 |
iContainer = NULL;
|
|
|
783 |
}
|
|
|
784 |
CContainer* container = new (ELeave) CContainer(&iModel);
|
|
|
785 |
CleanupStack::PushL( container );
|
|
|
786 |
container->ConstructL();
|
|
|
787 |
AppUi()->AddToStackL( *this, container );
|
|
|
788 |
CleanupStack::Pop( container );
|
|
|
789 |
iContainer = container;
|
|
|
790 |
}
|
|
|
791 |
|
|
|
792 |
|
|
|
793 |
// Let's create a function template for extracting items from lexer
|
|
|
794 |
TBuf<KAlfPerfAppMaxCharsInLine>& ProcessLexer(TLex& aLexer, TChar aSeparator,TBuf<KAlfPerfAppMaxCharsInLine>& aToken)
|
|
|
795 |
{
|
|
|
796 |
aToken.Zero();
|
|
|
797 |
TChar ch;
|
|
|
798 |
aLexer.SkipAndMark(0);
|
|
|
799 |
while (!aLexer.Eos())
|
|
|
800 |
{
|
|
|
801 |
ch = aLexer.Get();
|
|
|
802 |
if(ch == aSeparator)
|
|
|
803 |
{
|
|
|
804 |
aLexer.UnGet();
|
|
|
805 |
aToken.Append(aLexer.MarkedToken());
|
|
|
806 |
aLexer.SkipAndMark(1);
|
|
|
807 |
break;
|
|
|
808 |
}
|
|
|
809 |
}
|
|
|
810 |
return aToken;
|
|
|
811 |
}
|
|
|
812 |
|
|
|
813 |
CAlfPerfAppModel::TTestCaseResultItem CAlfPerfAppTestCaseSelectionView::ResultItemFromLine(TBuf<KAlfPerfAppMaxCharsInLine>& aLine)
|
|
|
814 |
{
|
|
|
815 |
CAlfPerfAppModel::TTestCaseResultItem item;
|
|
|
816 |
|
|
|
817 |
TBuf<KAlfPerfAppMaxCharsInLine> temp;
|
|
|
818 |
TLex lexer(aLine);
|
|
|
819 |
TLex tempLex;
|
|
|
820 |
|
|
|
821 |
item.iSuiteName.Copy(ProcessLexer(lexer,'/',temp));
|
|
|
822 |
item.iSuiteName.Trim();
|
|
|
823 |
item.iCaseName.Copy(ProcessLexer(lexer,',',temp));
|
|
|
824 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
825 |
item.iCaseName.Trim();
|
|
|
826 |
tempLex.Val(item.iCaseId);
|
|
|
827 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
828 |
tempLex.Val(item.iPhase);
|
|
|
829 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
830 |
tempLex.Val(item.iTimeStamp,EDecimal);
|
|
|
831 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
832 |
tempLex.Val(item.iAppCells);
|
|
|
833 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
834 |
tempLex.Val(item.iAppMemory);
|
|
|
835 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
836 |
tempLex.Val(item.iAppFree);
|
|
|
837 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
838 |
tempLex.Val(item.iServerCells);
|
|
|
839 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
840 |
tempLex.Val(item.iServerMemory);
|
|
|
841 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
842 |
tempLex.Val(item.iServerFree);
|
|
|
843 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
844 |
tempLex.Val(item.iSystemMemory);
|
|
|
845 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
846 |
tempLex.Val(item.iSystemFree);
|
|
|
847 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
848 |
tempLex.Val(item.iFrameCount,EDecimal);
|
|
|
849 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
850 |
tempLex.Val(item.imsSinceCase,EDecimal);
|
|
|
851 |
tempLex.Assign(ProcessLexer(lexer,',',temp));
|
|
|
852 |
tempLex.Val(item.imsSincePhase,EDecimal);
|
|
|
853 |
TBuf<15> fpsBuffer (ProcessLexer(lexer,',',temp));
|
|
|
854 |
tempLex.Assign(fpsBuffer);
|
|
|
855 |
tempLex.Val(item.iFPS);
|
|
|
856 |
item.specificResult8.Copy(lexer.Remainder());
|
|
|
857 |
item.specificResult8.Delete(item.specificResult8.Length()-1,1);
|
|
|
858 |
|
|
|
859 |
return item;
|
|
|
860 |
}
|
|
|
861 |
|
|
|
862 |
|
|
|
863 |
|
|
|
864 |
// Implementation of DeltaFromCurrentToPrevious
|
|
|
865 |
TUint32 CAlfPerfAppTestCaseSelectionView::DeltaFromCurrentToPrevious(
|
|
|
866 |
TUint32 aCurrent, TUint32 aPrevious )
|
|
|
867 |
{
|
|
|
868 |
// It's expected that execution of all test suites take less
|
|
|
869 |
// than KMaxTInt ms (so that it fits to TInt).
|
|
|
870 |
|
|
|
871 |
TUint64 delta = 0;
|
|
|
872 |
if ( aPrevious <= aCurrent )
|
|
|
873 |
{
|
|
|
874 |
// aPrevious .. aCurrent
|
|
|
875 |
delta = aCurrent - aPrevious;
|
|
|
876 |
}
|
|
|
877 |
else
|
|
|
878 |
{
|
|
|
879 |
// Overflow has occurred.
|
|
|
880 |
// aPrevious .. 2**32 + aCurrent
|
|
|
881 |
|
|
|
882 |
delta = 0xFFFFFFFF;
|
|
|
883 |
delta -= aPrevious;
|
|
|
884 |
delta++;
|
|
|
885 |
delta += aCurrent;
|
|
|
886 |
}
|
|
|
887 |
|
|
|
888 |
if ( delta >= KMaxTInt )
|
|
|
889 |
{
|
|
|
890 |
delta = KMaxTInt;
|
|
|
891 |
}
|
|
|
892 |
|
|
|
893 |
return I64LOW( delta );
|
|
|
894 |
}
|
|
|
895 |
|
|
|
896 |
|
|
|
897 |
// Implementation of CAlfPerfAppTestCaseSelectionView::CContainer:
|
|
|
898 |
// -----------------------------------------------------------------------------
|
|
|
899 |
//
|
|
|
900 |
CAlfPerfAppTestCaseSelectionView::CContainer::CContainer(CAlfPerfAppModel* aModel)
|
|
|
901 |
{
|
|
|
902 |
iModel = aModel;
|
|
|
903 |
}
|
|
|
904 |
|
|
|
905 |
// -----------------------------------------------------------------------------
|
|
|
906 |
//
|
|
|
907 |
void CAlfPerfAppTestCaseSelectionView::CContainer::ConstructL()
|
|
|
908 |
{
|
|
|
909 |
CreateWindowL();
|
|
|
910 |
|
|
|
911 |
TRect rect;
|
|
|
912 |
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, rect );
|
|
|
913 |
SetRect( rect );
|
|
|
914 |
|
|
|
915 |
iText = HBufC::NewL(KAlfPerfScreenTextBufferSize);
|
|
|
916 |
iCurrentLine = 0;
|
|
|
917 |
iLineCount = 0;
|
|
|
918 |
iNumberOfLinesFitsScreen = 0;
|
|
|
919 |
iX_factor = 1;
|
|
|
920 |
iY_factor = 1;
|
|
|
921 |
iLeftDrawingPosition = KAlfPerfAppLeftMargin;
|
|
|
922 |
|
|
|
923 |
TFontSpec myFontSpec(KAlfPerfAppFontName,KAlfPerfAppFontSizeInTwips);
|
|
|
924 |
CGraphicsDevice* screenDevice=iCoeEnv->ScreenDevice();
|
|
|
925 |
screenDevice->GetNearestFontInTwips(iFont,myFontSpec);
|
|
|
926 |
|
|
|
927 |
iWrappedArray = new(ELeave) CArrayFixFlat<TPtrC>(KAlfPerfScreenWrappedArraySize);
|
|
|
928 |
|
|
|
929 |
iNotPrintedResultDisplayBufferExceeded = ETrue;
|
|
|
930 |
|
|
|
931 |
ActivateL();
|
|
|
932 |
}
|
|
|
933 |
|
|
|
934 |
|
|
|
935 |
|
|
|
936 |
// -----------------------------------------------------------------------------
|
|
|
937 |
// -----------------------------------------------------------------------------
|
|
|
938 |
//
|
|
|
939 |
CAlfPerfAppTestCaseSelectionView::CContainer::~CContainer()
|
|
|
940 |
{
|
|
|
941 |
// Destroy the font
|
|
|
942 |
iCoeEnv->ScreenDevice()->ReleaseFont(iFont);
|
|
|
943 |
|
|
|
944 |
if (iWrappedArray)
|
|
|
945 |
{
|
|
|
946 |
iWrappedArray->Reset();
|
|
|
947 |
delete iWrappedArray;
|
|
|
948 |
}
|
|
|
949 |
|
|
|
950 |
if (iText)
|
|
|
951 |
delete iText;
|
|
|
952 |
|
|
|
953 |
if (iScrollBarFrame)
|
|
|
954 |
delete iScrollBarFrame;
|
|
|
955 |
|
|
|
956 |
if (iWrapperString)
|
|
|
957 |
delete iWrapperString;
|
|
|
958 |
}
|
|
|
959 |
|
|
|
960 |
|
|
|
961 |
// -----------------------------------------------------------------------------
|
|
|
962 |
// -----------------------------------------------------------------------------
|
|
|
963 |
//
|
|
|
964 |
TKeyResponse CAlfPerfAppTestCaseSelectionView::CContainer::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)
|
|
|
965 |
{
|
|
|
966 |
if(aType != EEventKey)
|
|
|
967 |
return EKeyWasConsumed;
|
|
|
968 |
|
|
|
969 |
if(aKeyEvent.iCode == EKeyUpArrow)
|
|
|
970 |
{
|
|
|
971 |
if (iCurrentLine > 0)
|
|
|
972 |
{
|
|
|
973 |
iCurrentLine--;
|
|
|
974 |
UpdateVisualContentL(EFalse);
|
|
|
975 |
}
|
|
|
976 |
|
|
|
977 |
return EKeyWasConsumed;
|
|
|
978 |
}
|
|
|
979 |
|
|
|
980 |
else if(aKeyEvent.iCode == EKeyDownArrow)
|
|
|
981 |
{
|
|
|
982 |
if (iCurrentLine < iLineCount - iNumberOfLinesFitsScreen)
|
|
|
983 |
{
|
|
|
984 |
iCurrentLine++;
|
|
|
985 |
UpdateVisualContentL(EFalse);
|
|
|
986 |
}
|
|
|
987 |
|
|
|
988 |
return EKeyWasConsumed;
|
|
|
989 |
}
|
|
|
990 |
|
|
|
991 |
return EKeyWasConsumed;
|
|
|
992 |
}
|
|
|
993 |
|
|
|
994 |
|
|
|
995 |
// -----------------------------------------------------------------------------
|
|
|
996 |
// -----------------------------------------------------------------------------
|
|
|
997 |
//
|
|
|
998 |
void CAlfPerfAppTestCaseSelectionView::CContainer::HandleResourceChange(TInt aType)
|
|
|
999 |
{
|
|
|
1000 |
if ( aType == KEikDynamicLayoutVariantSwitch )
|
|
|
1001 |
{
|
|
|
1002 |
TRect mainPaneRect;
|
|
|
1003 |
AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, mainPaneRect);
|
|
|
1004 |
SetRect(mainPaneRect);
|
|
|
1005 |
|
|
|
1006 |
iCurrentLine = 0; // scroll to top
|
|
|
1007 |
|
|
|
1008 |
// update font
|
|
|
1009 |
// Discard and destroy the font
|
|
|
1010 |
iCoeEnv->ScreenDevice()->ReleaseFont(iFont);
|
|
|
1011 |
|
|
|
1012 |
// Create the font
|
|
|
1013 |
TFontSpec myFontSpec(KAlfPerfAppFontName,KAlfPerfAppFontSizeInTwips);
|
|
|
1014 |
CGraphicsDevice* screenDevice=iCoeEnv->ScreenDevice();
|
|
|
1015 |
screenDevice->GetNearestFontInTwips(iFont,myFontSpec);
|
|
|
1016 |
|
|
|
1017 |
// delete the scroll and update screen
|
|
|
1018 |
if (iScrollBarFrame)
|
|
|
1019 |
{
|
|
|
1020 |
delete iScrollBarFrame;
|
|
|
1021 |
iScrollBarFrame = NULL;
|
|
|
1022 |
}
|
|
|
1023 |
TRAP_IGNORE(UpdateVisualContentL(EFalse));
|
|
|
1024 |
}
|
|
|
1025 |
else
|
|
|
1026 |
{
|
|
|
1027 |
CCoeControl::HandleResourceChange(aType);
|
|
|
1028 |
}
|
|
|
1029 |
}
|
|
|
1030 |
|
|
|
1031 |
|
|
|
1032 |
// -----------------------------------------------------------------------------
|
|
|
1033 |
// -----------------------------------------------------------------------------
|
|
|
1034 |
//
|
|
|
1035 |
void CAlfPerfAppTestCaseSelectionView::CContainer::HandleScrollEventL(CEikScrollBar* aScrollBar, TEikScrollEvent aEventType)
|
|
|
1036 |
{
|
|
|
1037 |
// only on page up/down,scroll up/down and drag events
|
|
|
1038 |
if ((aEventType == EEikScrollPageDown) || (aEventType == EEikScrollPageUp) ||
|
|
|
1039 |
(aEventType == EEikScrollThumbDragVert) || (aEventType == EEikScrollUp) ||
|
|
|
1040 |
(aEventType == EEikScrollDown))
|
|
|
1041 |
{
|
|
|
1042 |
// get the current position from the scroll bar
|
|
|
1043 |
iCurrentLine = aScrollBar->ThumbPosition();
|
|
|
1044 |
|
|
|
1045 |
// refresh now
|
|
|
1046 |
UpdateVisualContentL(EFalse);
|
|
|
1047 |
}
|
|
|
1048 |
}
|
|
|
1049 |
|
|
|
1050 |
// -----------------------------------------------------------------------------
|
|
|
1051 |
// -----------------------------------------------------------------------------
|
|
|
1052 |
//
|
|
|
1053 |
void CAlfPerfAppTestCaseSelectionView::CContainer::HandleControlEventL(
|
|
|
1054 |
CCoeControl* /*aControl*/,TCoeEvent /*aEventType*/)
|
|
|
1055 |
{
|
|
|
1056 |
// TODO: Add your control event handler code here
|
|
|
1057 |
}
|
|
|
1058 |
|
|
|
1059 |
|
|
|
1060 |
// -----------------------------------------------------------------------------
|
|
|
1061 |
// -----------------------------------------------------------------------------
|
|
|
1062 |
//
|
|
|
1063 |
void CAlfPerfAppTestCaseSelectionView::CContainer::UpdateVisualContentL(TBool aScrollToBottom)
|
|
|
1064 |
{
|
|
|
1065 |
TSize rectSize;
|
|
|
1066 |
AknLayoutUtils::LayoutMetricsSize(AknLayoutUtils::EMainPane, rectSize);
|
|
|
1067 |
TRect rect(rectSize);
|
|
|
1068 |
|
|
|
1069 |
// init scroll bar if not yet done
|
|
|
1070 |
if (!iScrollBarFrame)
|
|
|
1071 |
{
|
|
|
1072 |
iScrollBarFrame = new(ELeave) CEikScrollBarFrame(this, this, ETrue);
|
|
|
1073 |
|
|
|
1074 |
CAknAppUi* appUi = iAvkonAppUi;
|
|
|
1075 |
|
|
|
1076 |
if (AknLayoutUtils::DefaultScrollBarType(appUi) == CEikScrollBarFrame::EDoubleSpan)
|
|
|
1077 |
{
|
|
|
1078 |
iScrollBarFrame->CreateDoubleSpanScrollBarsL(ETrue, EFalse);
|
|
|
1079 |
iScrollBarFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EDoubleSpan);
|
|
|
1080 |
}
|
|
|
1081 |
else
|
|
|
1082 |
{
|
|
|
1083 |
iScrollBarFrame->SetTypeOfVScrollBar(CEikScrollBarFrame::EArrowHead);
|
|
|
1084 |
}
|
|
|
1085 |
iScrollBarFrame->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EAuto);
|
|
|
1086 |
}
|
|
|
1087 |
|
|
|
1088 |
// drawing positions, needed for scalable ui
|
|
|
1089 |
iX_factor = TReal(rect.Width()) / 176;
|
|
|
1090 |
iY_factor = TReal(rect.Height()) / 144;
|
|
|
1091 |
|
|
|
1092 |
iWrappedArray->Reset();
|
|
|
1093 |
|
|
|
1094 |
if (iWrapperString)
|
|
|
1095 |
{
|
|
|
1096 |
delete iWrapperString;
|
|
|
1097 |
iWrapperString = NULL;
|
|
|
1098 |
}
|
|
|
1099 |
|
|
|
1100 |
// define drawing width, some extra space needed if using double span scrolling bar
|
|
|
1101 |
TUint drawingWidth(0);
|
|
|
1102 |
if (iScrollBarFrame->TypeOfVScrollBar() == CEikScrollBarFrame::EDoubleSpan)
|
|
|
1103 |
{
|
|
|
1104 |
if (AknLayoutUtils::LayoutMirrored()) // scroll bar on 'left'
|
|
|
1105 |
{
|
|
|
1106 |
iLeftDrawingPosition = KAlfPerfAppLeftMargin + 12;
|
|
|
1107 |
drawingWidth = TInt( rect.Width() - iLeftDrawingPosition*iX_factor - (KAlfPerfAppRightMargin*iX_factor));
|
|
|
1108 |
}
|
|
|
1109 |
else // scroll bar on 'right'
|
|
|
1110 |
{
|
|
|
1111 |
iLeftDrawingPosition = KAlfPerfAppLeftMargin;
|
|
|
1112 |
drawingWidth = TInt( rect.Width() - iLeftDrawingPosition*iX_factor - (KAlfPerfAppRightMargin*iX_factor + 7*iX_factor));
|
|
|
1113 |
}
|
|
|
1114 |
}
|
|
|
1115 |
else
|
|
|
1116 |
drawingWidth = TInt( rect.Width() - KAlfPerfAppLeftMargin*iX_factor - KAlfPerfAppRightMargin*iX_factor);
|
|
|
1117 |
|
|
|
1118 |
// wrap the text
|
|
|
1119 |
iWrapperString = AknBidiTextUtils::ConvertToVisualAndWrapToArrayL(
|
|
|
1120 |
iText->Des(),
|
|
|
1121 |
drawingWidth,
|
|
|
1122 |
*iFont,
|
|
|
1123 |
*iWrappedArray
|
|
|
1124 |
);
|
|
|
1125 |
|
|
|
1126 |
iLineCount = iWrappedArray->Count();
|
|
|
1127 |
|
|
|
1128 |
// count amount of lines fits to screen
|
|
|
1129 |
iNumberOfLinesFitsScreen = TInt(rect.Height() / (iFont->HeightInPixels()));
|
|
|
1130 |
|
|
|
1131 |
// check if needed to scroll to the bottom
|
|
|
1132 |
if (aScrollToBottom && iCurrentLine < iLineCount - iNumberOfLinesFitsScreen)
|
|
|
1133 |
{
|
|
|
1134 |
iCurrentLine = iLineCount-iNumberOfLinesFitsScreen;
|
|
|
1135 |
}
|
|
|
1136 |
|
|
|
1137 |
// update the scroll bars
|
|
|
1138 |
TEikScrollBarModel horizontalBar;
|
|
|
1139 |
TEikScrollBarModel verticalBar;
|
|
|
1140 |
verticalBar.iThumbPosition = iCurrentLine;
|
|
|
1141 |
verticalBar.iScrollSpan = iLineCount - iNumberOfLinesFitsScreen + 1;
|
|
|
1142 |
verticalBar.iThumbSpan = 1;
|
|
|
1143 |
|
|
|
1144 |
TEikScrollBarFrameLayout layout;
|
|
|
1145 |
layout.iTilingMode = TEikScrollBarFrameLayout::EInclusiveRectConstant;
|
|
|
1146 |
|
|
|
1147 |
if (iScrollBarFrame->TypeOfVScrollBar() == CEikScrollBarFrame::EDoubleSpan)
|
|
|
1148 |
{
|
|
|
1149 |
// do not let scrollbar values overflow
|
|
|
1150 |
if (verticalBar.iThumbPosition + verticalBar.iThumbSpan > verticalBar.iScrollSpan)
|
|
|
1151 |
verticalBar.iThumbPosition = verticalBar.iScrollSpan - verticalBar.iThumbSpan;
|
|
|
1152 |
|
|
|
1153 |
TAknDoubleSpanScrollBarModel horizontalDSBar(horizontalBar);
|
|
|
1154 |
TAknDoubleSpanScrollBarModel verticalDSBar(verticalBar);
|
|
|
1155 |
|
|
|
1156 |
iScrollBarFrame->TileL(&horizontalDSBar, &verticalDSBar, rect, rect, layout);
|
|
|
1157 |
iScrollBarFrame->SetVFocusPosToThumbPos(verticalDSBar.FocusPosition());
|
|
|
1158 |
}
|
|
|
1159 |
else
|
|
|
1160 |
{
|
|
|
1161 |
iScrollBarFrame->TileL( &horizontalBar, &verticalBar, rect, rect, layout );
|
|
|
1162 |
iScrollBarFrame->SetVFocusPosToThumbPos( verticalBar.iThumbPosition );
|
|
|
1163 |
}
|
|
|
1164 |
|
|
|
1165 |
|
|
|
1166 |
// update the screen
|
|
|
1167 |
DrawNow();
|
|
|
1168 |
}
|
|
|
1169 |
|
|
|
1170 |
// -----------------------------------------------------------------------------
|
|
|
1171 |
// -----------------------------------------------------------------------------
|
|
|
1172 |
//
|
|
|
1173 |
TBool CAlfPerfAppTestCaseSelectionView::CContainer::PrintText(const TDesC& aDes)
|
|
|
1174 |
{
|
|
|
1175 |
// This doesn't guarantee that iText length actually remains below KAlfPerfAppDisplayResultMaxChars
|
|
|
1176 |
// but it won't exceed it that much. Approximation can be used for the limiting value.
|
|
|
1177 |
if(iText->Length() < KAlfPerfAppDisplayResultMaxChars)
|
|
|
1178 |
{
|
|
|
1179 |
iText->Des().Append( aDes );
|
|
|
1180 |
return ETrue;
|
|
|
1181 |
}
|
|
|
1182 |
else
|
|
|
1183 |
{
|
|
|
1184 |
if(iNotPrintedResultDisplayBufferExceeded)
|
|
|
1185 |
{
|
|
|
1186 |
iText->Des().Append( KAlfPerfAppDisplayBufferFull);
|
|
|
1187 |
TBuf<KAlfPerfAppMaxCharsInLine> line;
|
|
|
1188 |
TBuf<KAlfPerfAppMaxCharsInLine> temp = iModel->TargetPath();
|
|
|
1189 |
line.Format(KAlfPerfAppPrintOutputFormat, &temp);
|
|
|
1190 |
iText->Des().Append(line);
|
|
|
1191 |
iNotPrintedResultDisplayBufferExceeded = EFalse;
|
|
|
1192 |
}
|
|
|
1193 |
return EFalse;
|
|
|
1194 |
}
|
|
|
1195 |
}
|
|
|
1196 |
|
|
|
1197 |
// -----------------------------------------------------------------------------
|
|
|
1198 |
// -----------------------------------------------------------------------------
|
|
|
1199 |
//
|
|
|
1200 |
void CAlfPerfAppTestCaseSelectionView::CContainer::ClearOutputWindowL()
|
|
|
1201 |
{
|
|
|
1202 |
iText->Des().Zero();
|
|
|
1203 |
iNotPrintedResultDisplayBufferExceeded = ETrue;
|
|
|
1204 |
UpdateVisualContentL(ETrue);
|
|
|
1205 |
}
|
|
|
1206 |
|
|
|
1207 |
|
|
|
1208 |
// -----------------------------------------------------------------------------
|
|
|
1209 |
// -----------------------------------------------------------------------------
|
|
|
1210 |
//
|
|
|
1211 |
void CAlfPerfAppTestCaseSelectionView::CContainer::Draw(
|
|
|
1212 |
const TRect& aRect ) const
|
|
|
1213 |
{
|
|
|
1214 |
CWindowGc& gc = SystemGc();
|
|
|
1215 |
gc.Clear(aRect);
|
|
|
1216 |
gc.SetPenColor(KRgbBlack);
|
|
|
1217 |
gc.UseFont(iFont);
|
|
|
1218 |
|
|
|
1219 |
// draw the text
|
|
|
1220 |
for (TInt i=0; i<iNumberOfLinesFitsScreen; i++)
|
|
|
1221 |
{
|
|
|
1222 |
// index out of bounds check and then draw text
|
|
|
1223 |
if (i+iCurrentLine < iWrappedArray->Count())
|
|
|
1224 |
gc.DrawText(iWrappedArray->At(i+iCurrentLine),
|
|
|
1225 |
TPoint(TInt(iLeftDrawingPosition*iX_factor), TInt(iFont->HeightInPixels()*(i+1))));
|
|
|
1226 |
}
|
|
|
1227 |
gc.DiscardFont();
|
|
|
1228 |
}
|