|
1 /* |
|
2 * Copyright (c) 2009 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: This module contains implementation of CConsoleMain |
|
15 * and CModule class member functions. |
|
16 * |
|
17 */ |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include <e32base.h> |
|
21 #include <e32cons.h> |
|
22 #include <e32svr.h> |
|
23 #include <f32file.h> |
|
24 #include <hal.h> |
|
25 #include <hal_data.h> |
|
26 |
|
27 |
|
28 |
|
29 #include <stifinternal/UIStoreIf.h> |
|
30 |
|
31 #include "ConsoleUI.h" |
|
32 #include "ConsoleMenus.h" |
|
33 |
|
34 #include "StifTestInterface.h" |
|
35 |
|
36 // EXTERNAL DATA STRUCTURES |
|
37 |
|
38 // EXTERNAL FUNCTION PROTOTYPES |
|
39 |
|
40 // CONSTANTS |
|
41 _LIT(KNameTxt,"STIF"); |
|
42 _LIT( KConsoleMain, "CConsoleMain" ); |
|
43 |
|
44 // Commandline params |
|
45 _LIT( KTestModule, "-testmodule" ); |
|
46 _LIT( KTestModuleIni, "-testmoduleini" ); |
|
47 _LIT( KTestCaseFile, "-testcasefile" ); |
|
48 _LIT( KTestSet, "-testset" ); |
|
49 _LIT( KTestRun, "-run" ); |
|
50 _LIT( KTestRunAll, "all" ); |
|
51 _LIT( KTestRunSeq, "sequential" ); |
|
52 _LIT( KTestRunPar, "parallel" ); |
|
53 |
|
54 // MACROS |
|
55 |
|
56 // LOCAL CONSTANTS AND MACROS |
|
57 |
|
58 // MODULE DATA STRUCTURES |
|
59 |
|
60 // LOCAL FUNCTION PROTOTYPES |
|
61 |
|
62 // FORWARD DECLARATIONS |
|
63 LOCAL_C void MainL(); |
|
64 |
|
65 |
|
66 |
|
67 // ==================== LOCAL FUNCTIONS ======================================= |
|
68 |
|
69 // None |
|
70 |
|
71 |
|
72 // ================= MEMBER FUNCTIONS ========================================= |
|
73 |
|
74 |
|
75 |
|
76 /* |
|
77 ------------------------------------------------------------------------------- |
|
78 |
|
79 Class: CConsoleMain |
|
80 |
|
81 Method: NewL |
|
82 |
|
83 Description: Construct the console main class |
|
84 |
|
85 Parameters: None |
|
86 |
|
87 Return Values: CConsoleMain* New object |
|
88 |
|
89 Errors/Exceptions: Leaves if memory allocation fails or |
|
90 ConstructL leaves. |
|
91 |
|
92 Status: Draft |
|
93 |
|
94 ------------------------------------------------------------------------------- |
|
95 */ |
|
96 CConsoleMain* CConsoleMain::NewL( ) |
|
97 { |
|
98 |
|
99 CConsoleMain* self = new ( ELeave ) CConsoleMain(); |
|
100 CleanupStack::PushL( self ); |
|
101 self->ConstructL(); |
|
102 CleanupStack::Pop( self ); |
|
103 return self; |
|
104 |
|
105 } |
|
106 |
|
107 |
|
108 /* |
|
109 ------------------------------------------------------------------------------- |
|
110 |
|
111 Class: CConsoleMain |
|
112 |
|
113 Method: ConstructL |
|
114 |
|
115 Description: Second level constructor. |
|
116 |
|
117 Construct the console |
|
118 Construct module and case containers |
|
119 Retrieve command line parameters |
|
120 Connect to test engine |
|
121 |
|
122 Parameters: None |
|
123 |
|
124 Return Values: None |
|
125 |
|
126 Errors/Exceptions: Leaves if memory allocation fails or fileserver or |
|
127 test engine can't be connected. |
|
128 |
|
129 Status: Draft |
|
130 |
|
131 ------------------------------------------------------------------------------- |
|
132 */ |
|
133 void CConsoleMain::ConstructL( ) |
|
134 { |
|
135 _LIT( KEnableMaximised, "+Maximised" ); |
|
136 //_LIT( KDisableMaximised, "-Maximised" ); |
|
137 _LIT( KEnableInform, "+Inform" ); |
|
138 //_LIT( KDisableInform, "-Inform" ); |
|
139 _LIT( KEnableRaw, "+Raw" ); |
|
140 //_LIT( KDisableRaw, "-Raw" ); |
|
141 _LIT( KEnablePointer, "+Pointer" ); |
|
142 //_LIT( KDisablePointer, "-Pointer" ); |
|
143 //_LIT( KDescription, "-Pointer" ); |
|
144 |
|
145 CUIStoreIf::ConstructL(); |
|
146 |
|
147 rConsoleCreated = false; |
|
148 // Construct the console |
|
149 //iConsole = Console::NewL( KNameTxt, |
|
150 // TSize( KConsFullScreen, KConsFullScreen ) ); |
|
151 |
|
152 TInt ret = iConsole.Create(); |
|
153 |
|
154 if(ret != KErrNone) |
|
155 { |
|
156 RDebug::Print(_L("Could not create console, err = (%d)"), ret); |
|
157 User::Leave(ret); |
|
158 } |
|
159 |
|
160 rConsoleCreated = true; |
|
161 |
|
162 ret = iConsole.Init(KNameTxt, TSize( KConsFullScreen, KConsFullScreen )); |
|
163 if(ret != KErrNone) |
|
164 { |
|
165 RDebug::Print(_L("Could not initialize console, err = (%d)"), ret); |
|
166 User::Leave(ret); |
|
167 } |
|
168 |
|
169 ret = iConsole.Control( KEnableMaximised ); |
|
170 if(ret != KErrNone) |
|
171 { |
|
172 RDebug::Print(_L("Could not initialize console controls(+Maximised), err = (%d)"), ret); |
|
173 User::Leave(ret); |
|
174 } |
|
175 ret = iConsole.Control( KEnableInform ); |
|
176 if(ret != KErrNone) |
|
177 { |
|
178 RDebug::Print(_L("Could not initialize console controls(+Inform), err = (%d)"), ret); |
|
179 User::Leave(ret); |
|
180 } |
|
181 ret = iConsole.Control( KEnablePointer ); |
|
182 if(ret != KErrNone) |
|
183 { |
|
184 RDebug::Print(_L("Could not initialize console controls(+Pointer), err = (%d)"), ret); |
|
185 User::Leave(ret); |
|
186 } |
|
187 ret = iConsole.Control( KEnableRaw ); |
|
188 if(ret != KErrNone) |
|
189 { |
|
190 RDebug::Print(_L("Could not initialize console controls(+Raw), err = (%d)"), ret); |
|
191 User::Leave(ret); |
|
192 } |
|
193 |
|
194 |
|
195 |
|
196 RDebug::Print(_L("Creating module list object")); |
|
197 TRAPD(err, iModuleList = CTestModuleList::NewL(NULL)); |
|
198 if(err != KErrNone) |
|
199 { |
|
200 RDebug::Print(_L("Could not create module list (%d)"), err); |
|
201 UiError(_L("Could not create module list (err)")); |
|
202 User::Leave(err); |
|
203 } |
|
204 if(!iModuleList) |
|
205 { |
|
206 RDebug::Print(_L("Could not create module list (NULL)")); |
|
207 UiError(_L("Could not create module list (NULL)")); |
|
208 User::Leave(KErrGeneral); |
|
209 } |
|
210 |
|
211 // Get command line parameters |
|
212 TFileName iniFile; // TestFramework initialization file |
|
213 |
|
214 ProcessCommandlineL( iniFile ); |
|
215 |
|
216 if(iTestModule) |
|
217 { |
|
218 // Add to module list info about module taken from command line |
|
219 RDebug::Print(_L("Adding command line module to list")); |
|
220 TName moduleName; |
|
221 moduleName.Copy(iTestModule->Des()); |
|
222 moduleName.LowerCase(); |
|
223 err = iModuleList->AddTestModule(moduleName); |
|
224 if(err != KErrNone && err != KErrAlreadyExists) |
|
225 { |
|
226 RDebug::Print(_L("Could not add module to list of modules (%d)"), err); |
|
227 UiError(_L("Could not add module to list of modules (err)")); |
|
228 User::Leave(err); |
|
229 } |
|
230 |
|
231 //Get added module |
|
232 CTestModuleInfo* moduleInfo = iModuleList->GetModule(moduleName); |
|
233 if(!moduleInfo) |
|
234 { |
|
235 RDebug::Print(_L("Could not add get module info from list")); |
|
236 UiError(_L("Could not add get module info from list")); |
|
237 User::Leave(KErrGeneral); |
|
238 } |
|
239 |
|
240 //Add ini file if given |
|
241 if(iTestModuleIni && iTestModuleIni->Length() > 0) |
|
242 { |
|
243 TFileName filename; |
|
244 filename.Copy(iTestModuleIni->Des()); |
|
245 filename.LowerCase(); |
|
246 moduleInfo->SetIniFile(filename); |
|
247 } |
|
248 |
|
249 //Add config file if given |
|
250 if(iTestCaseFile && iTestCaseFile->Length() > 0) |
|
251 { |
|
252 TFileName filename; |
|
253 filename.Copy(iTestCaseFile->Des()); |
|
254 filename.LowerCase(); |
|
255 moduleInfo->AddCfgFile(filename); |
|
256 } |
|
257 |
|
258 //Now check all config files if there are included modules |
|
259 _LIT(KIncludeModuleStart, "[New_Include_Module]"); |
|
260 _LIT(KIncludeModuleEnd, "[End_Include_Module]"); |
|
261 |
|
262 RDebug::Print(_L("Start parsing included modules")); |
|
263 CTestCaseFileInfo* finfo = iModuleList->GetUncheckedCfgFile(); |
|
264 while(finfo) |
|
265 { |
|
266 TFileName fname; |
|
267 finfo->GetCfgFileName(fname); |
|
268 |
|
269 RDebug::Print(_L("Checking file: '%S'"), &fname); |
|
270 finfo->SetChecked(); |
|
271 |
|
272 CStifParser* parser = NULL; |
|
273 |
|
274 TRAP(err, parser = CStifParser::NewL(_L(""), fname)); |
|
275 if(err != KErrNone) |
|
276 { |
|
277 RDebug::Print(_L("Could not create parser to read content of config file (%d)"), err); |
|
278 UiError(_L("Could not create parser to read content of config file (err)")); |
|
279 User::Leave(err); |
|
280 } |
|
281 CleanupStack::PushL(parser); |
|
282 |
|
283 ParseTestModulesL(parser, iModuleList, KIncludeModuleStart, KIncludeModuleEnd); |
|
284 |
|
285 CleanupStack::PopAndDestroy(parser); |
|
286 finfo = iModuleList->GetUncheckedCfgFile(); |
|
287 } |
|
288 RDebug::Print(_L("End parsing included modules")); |
|
289 } |
|
290 |
|
291 //iConsole->Printf(_L("\nTest Framework starting\n")); |
|
292 iConsole.Write(_L("\nTest Framework starting\n")); |
|
293 |
|
294 // CUIStore open |
|
295 User::LeaveIfError( UIStore().Open( iniFile ) ); |
|
296 |
|
297 } |
|
298 |
|
299 /* |
|
300 ------------------------------------------------------------------------------- |
|
301 |
|
302 Class: CConsoleMain |
|
303 |
|
304 Method: CConsoleMain |
|
305 |
|
306 Description: Constructor. |
|
307 Initialize non-zero member variables. |
|
308 |
|
309 Parameters: None |
|
310 |
|
311 Return Values: None |
|
312 |
|
313 Errors/Exceptions: None |
|
314 |
|
315 Status: Draft |
|
316 |
|
317 ------------------------------------------------------------------------------- |
|
318 */ |
|
319 CConsoleMain::CConsoleMain( ):iStartCases( EStartCaseNo ) |
|
320 { |
|
321 } |
|
322 |
|
323 |
|
324 /* |
|
325 ------------------------------------------------------------------------------- |
|
326 |
|
327 Class: CConsoleMain |
|
328 |
|
329 Method: ~CConsoleMain |
|
330 |
|
331 Description: Destructor |
|
332 |
|
333 Parameters: None |
|
334 |
|
335 Return Values: None |
|
336 |
|
337 Errors/Exceptions: None |
|
338 |
|
339 Status: Draft |
|
340 |
|
341 ------------------------------------------------------------------------------- |
|
342 */ |
|
343 CConsoleMain::~CConsoleMain( ) |
|
344 { |
|
345 |
|
346 iDialogs.ResetAndDestroy(); |
|
347 iDialogs.Close(); |
|
348 |
|
349 // CUIStore close |
|
350 UIStore().Close(); |
|
351 |
|
352 delete iReader; |
|
353 iReader = NULL; |
|
354 |
|
355 delete iScroller; |
|
356 iScroller = NULL; |
|
357 |
|
358 //delete iConsole; |
|
359 //iConsole = NULL; |
|
360 if(rConsoleCreated){ |
|
361 iConsole.Destroy(); |
|
362 } |
|
363 delete iMainMenu; |
|
364 iMainMenu = NULL; |
|
365 |
|
366 delete iTestModule; |
|
367 iTestModule = 0; |
|
368 |
|
369 delete iTestModuleIni; |
|
370 iTestModuleIni = 0; |
|
371 |
|
372 delete iTestCaseFile; |
|
373 iTestCaseFile = 0; |
|
374 |
|
375 delete iTestSetName; |
|
376 iTestSetName = 0; |
|
377 |
|
378 delete iModuleList; |
|
379 iModuleList = 0; |
|
380 |
|
381 iFilters.ResetAndDestroy(); |
|
382 iFilters.Close(); |
|
383 } |
|
384 |
|
385 /* |
|
386 ------------------------------------------------------------------------------- |
|
387 |
|
388 Class: CConsoleMain |
|
389 |
|
390 Method: ProcessCommandlineL |
|
391 |
|
392 Description: Process commandline parameters. |
|
393 |
|
394 Parameters: None |
|
395 |
|
396 Return Values: None |
|
397 |
|
398 Errors/Exceptions: Leaves on error. |
|
399 |
|
400 Status: Draft |
|
401 |
|
402 ------------------------------------------------------------------------------- |
|
403 */ |
|
404 void CConsoleMain::ProcessCommandlineL( TFileName& aIniFile ) |
|
405 { |
|
406 |
|
407 User me; |
|
408 TInt lineLength = me.CommandLineLength(); |
|
409 HBufC* lineBuf = HBufC::NewLC( lineLength ); |
|
410 TPtr line( lineBuf->Des() ); |
|
411 TBool firstTime = ETrue; |
|
412 TInt offset = 0; |
|
413 TPtrC param; |
|
414 TChar c; |
|
415 |
|
416 me.CommandLine( line ); |
|
417 TLex lex( line ); |
|
418 |
|
419 while( offset < lineLength ) |
|
420 { |
|
421 // Get first charecter of the parameter |
|
422 lex.SkipSpace(); |
|
423 c = lex.Peek(); |
|
424 if( c == 0 ) |
|
425 { |
|
426 // End of line |
|
427 break; |
|
428 } |
|
429 |
|
430 // Get the whole parameter |
|
431 param.Set( lex.NextToken() ); |
|
432 if( firstTime ) |
|
433 { |
|
434 // Filebrowser workaround. It gives the exe name as command line param |
|
435 // verify that it is not the same as the executable name |
|
436 //@spe TFileName exePath = me.FileName(); |
|
437 TFileName exePath = RProcess().FileName(); |
|
438 if ( param == exePath ) |
|
439 { |
|
440 // Discard command line parameters when using filebrowser |
|
441 break; |
|
442 } |
|
443 |
|
444 firstTime = EFalse; |
|
445 } |
|
446 // Check if -param option |
|
447 if( c == '-' ) |
|
448 { |
|
449 // This is option |
|
450 if( param == KTestModule ) |
|
451 { |
|
452 // Get test module name |
|
453 param.Set( lex.NextToken() ); |
|
454 if( param.Length() == 0 ) |
|
455 { |
|
456 UiError( _L("Test module name not given")); |
|
457 break; |
|
458 } |
|
459 if( param.Length() > KMaxName ) |
|
460 { |
|
461 UiError( _L("Test module name too long")); |
|
462 break; |
|
463 } |
|
464 iTestModule = param.AllocL(); |
|
465 } |
|
466 else if( param == KTestModuleIni ) |
|
467 { |
|
468 // Get test module initialization file |
|
469 param.Set( lex.NextToken() ); |
|
470 if( param.Length() == 0 ) |
|
471 { |
|
472 UiError( _L("Test module initialization file name not given")); |
|
473 break; |
|
474 } |
|
475 if( param.Length() > KMaxFileName ) |
|
476 { |
|
477 UiError( _L("Test module initialization file name too long")); |
|
478 break; |
|
479 } |
|
480 TFileName tmpTestModuleIni( param ); |
|
481 TStifUtil::CorrectFilePathL( tmpTestModuleIni ); |
|
482 iTestModuleIni = tmpTestModuleIni.AllocL(); |
|
483 } |
|
484 else if( param == KTestCaseFile ) |
|
485 { |
|
486 // Get test case file name |
|
487 param.Set( lex.NextToken() ); |
|
488 if( param.Length() == 0 ) |
|
489 { |
|
490 UiError( _L("Test case file name not given")); |
|
491 break; |
|
492 } |
|
493 if( param.Length() > KMaxFileName ) |
|
494 { |
|
495 UiError( _L("Test case file name too long")); |
|
496 break; |
|
497 } |
|
498 TFileName tmpTestCaseFile( param ); |
|
499 TStifUtil::CorrectFilePathL( tmpTestCaseFile ); |
|
500 iTestCaseFile = tmpTestCaseFile.AllocL(); |
|
501 } |
|
502 else if( param == KTestSet ) |
|
503 { |
|
504 // Get test set name |
|
505 param.Set( lex.NextToken() ); |
|
506 if( param.Length() == 0 ) |
|
507 { |
|
508 UiError( _L("Test set name not given")); |
|
509 break; |
|
510 } |
|
511 if( param.Length() > KMaxFileName ) |
|
512 { |
|
513 UiError( _L("Test set name too long")); |
|
514 |
|
515 break; |
|
516 } |
|
517 iTestSetName = param.AllocL(); |
|
518 } |
|
519 else if( param == KTestRun ) |
|
520 { |
|
521 if( iStartCases ) |
|
522 { |
|
523 UiError( _L("Only one -run option allowed") ); |
|
524 // Do not start anything |
|
525 iStartCases = EStartCaseNo; |
|
526 break; |
|
527 } |
|
528 // Get run type |
|
529 lex.Mark(); |
|
530 param.Set( lex.NextToken() ); |
|
531 if( param.Length() == 0 ) |
|
532 { |
|
533 UiError( _L("Test set name not given")); |
|
534 break; |
|
535 } |
|
536 if( ( param == KTestRunAll ) || |
|
537 ( param == KTestRunSeq ) ) |
|
538 { |
|
539 iStartCases = EStartCasesSeq; |
|
540 } |
|
541 else if( param == KTestRunPar ) |
|
542 { |
|
543 iStartCases = EStartCasesPar; |
|
544 } |
|
545 else |
|
546 { |
|
547 lex.UnGetToMark(); |
|
548 lex.SkipSpace(); |
|
549 if( lex.Val( iTestCaseNum ) != KErrNone ) |
|
550 { |
|
551 UiError( _L("Unknown run type given, valid values are all/sequential/parallel/test case number")); |
|
552 } |
|
553 else |
|
554 { |
|
555 iStartCases = EStartSingleCase; |
|
556 } |
|
557 break; |
|
558 } |
|
559 } |
|
560 } |
|
561 else |
|
562 { |
|
563 // This is Test Framework ini file |
|
564 aIniFile = param; |
|
565 TStifUtil::CorrectFilePathL( aIniFile ); |
|
566 // ini file is last option |
|
567 break; |
|
568 } |
|
569 |
|
570 } |
|
571 |
|
572 CleanupStack::PopAndDestroy( lineBuf ); |
|
573 |
|
574 } |
|
575 |
|
576 |
|
577 /* |
|
578 ------------------------------------------------------------------------------- |
|
579 |
|
580 Class: CConsoleMain |
|
581 |
|
582 Method: Panic |
|
583 |
|
584 Description: Console UI panic function |
|
585 |
|
586 Parameters: TInt |
|
587 |
|
588 Return Values: |
|
589 |
|
590 Errors/Exceptions: Does not return. |
|
591 |
|
592 Status: Draft |
|
593 |
|
594 ------------------------------------------------------------------------------- |
|
595 */ |
|
596 void CConsoleMain::Panic(TConsoleUIPanic aPanic ) |
|
597 { |
|
598 |
|
599 User::Panic (_L("STIF TestFramework Console UI panic"), aPanic ); |
|
600 |
|
601 } |
|
602 |
|
603 |
|
604 /* |
|
605 ------------------------------------------------------------------------------- |
|
606 |
|
607 Class: CConsoleMain |
|
608 |
|
609 Method: StartL |
|
610 |
|
611 Description: Construct menu objects and start the menu handling |
|
612 |
|
613 Parameters: None |
|
614 |
|
615 Return Values: None |
|
616 |
|
617 Errors/Exceptions: |
|
618 |
|
619 Status: Draft |
|
620 |
|
621 ------------------------------------------------------------------------------- |
|
622 */ |
|
623 TInt CConsoleMain::StartL() |
|
624 { |
|
625 |
|
626 // Construct keystroke reader |
|
627 iReader = CConsoleReader::NewL( this, &iConsole ); |
|
628 |
|
629 // Construct the main menu |
|
630 TInt majorV; |
|
631 TInt minorV; |
|
632 TInt buildV; |
|
633 TBuf<30> relDate; |
|
634 TStifUtil::STIFVersion(majorV, minorV, buildV, relDate); |
|
635 |
|
636 TBuf<128> version; |
|
637 version.Format(_L("STIF v%d.%d.%d - "), majorV, minorV, buildV); |
|
638 version.Append(relDate); |
|
639 version.Append(_L("\n")); |
|
640 iMainMenu = CMainMenu::NewL( this, NULL, _L("Main menu"), version ); |
|
641 |
|
642 // Add the case menu |
|
643 CMenu* caseMenu = CMenu::NewL( this, iMainMenu, _L("Case menu") ); |
|
644 iMainMenu->AddItemL ( caseMenu ); |
|
645 |
|
646 // Add the module menu |
|
647 CMenu* moduleMenu = CModuleListView::NewL( this, iMainMenu, _L("Module menu") ); |
|
648 iMainMenu->AddItemL ( moduleMenu ); |
|
649 |
|
650 // Add test set menu |
|
651 CTestSetMenu* testSetMenu = CTestSetMenu::NewL( this, iMainMenu, _L("Test set menu") ); |
|
652 iMainMenu->AddItemL ( testSetMenu ); |
|
653 |
|
654 // Construct the case menus |
|
655 CMenu* casestart = NULL; |
|
656 CMenu* casestartshow = NULL; |
|
657 |
|
658 // Load filters |
|
659 UIStore().ReadFiltersL(iFilters); |
|
660 |
|
661 // If there are no filters defined, then construct menu without filter's menu |
|
662 if(iFilters.Count() == 0) |
|
663 { |
|
664 casestart = CCaseStartMenu::NewL(this, caseMenu, _L("Start new case")); |
|
665 caseMenu->AddItemL(casestart); |
|
666 CMenu* casestartshow = NULL; |
|
667 casestartshow = CCaseStartMenu::NewL(this, caseMenu, _L("Start & show output"), ETrue); |
|
668 caseMenu->AddItemL(casestartshow); |
|
669 } |
|
670 else // if there are filters defined, create also filter's menu |
|
671 { |
|
672 CFilterMenu* filtercasestart = NULL; |
|
673 CFilterMenu* filtercasestartshow = NULL; |
|
674 |
|
675 filtercasestart = CFilterMenu::NewL(this, caseMenu, _L("Start new case (filter)")); |
|
676 caseMenu->AddItemL(filtercasestart); |
|
677 casestart = CCaseStartMenu::NewL(this, caseMenu, _L("Start new case")); |
|
678 filtercasestart->SetTestCaseMenu(casestart); |
|
679 |
|
680 filtercasestartshow = CFilterMenu::NewL(this, caseMenu, _L("Start & show output (filter)")); |
|
681 caseMenu->AddItemL(filtercasestartshow); |
|
682 casestartshow = CCaseStartMenu::NewL(this, caseMenu, _L("Start & show output"), ETrue); |
|
683 filtercasestartshow->SetTestCaseMenu(casestartshow); |
|
684 } |
|
685 |
|
686 CMultipleCaseMenu* multicasestart = |
|
687 CMultipleCaseMenu::NewL (this, caseMenu, _L("Run multiple tests") ); |
|
688 caseMenu->AddItemL( multicasestart ); |
|
689 casestart = CCaseMenu::NewL ( this, caseMenu, _L("Ongoing cases"), |
|
690 CUIStoreIf::EStatusRunning ); |
|
691 caseMenu->AddItemL( casestart ); |
|
692 casestart = CCaseMenu::NewL ( this, caseMenu, _L("Executed cases"), |
|
693 CUIStoreIf::EStatusExecuted ); |
|
694 caseMenu->AddItemL( casestart ); |
|
695 casestart = CCaseMenu::NewL ( this, caseMenu, _L("Passed cases"), |
|
696 CUIStoreIf::EStatusPassed ); |
|
697 caseMenu->AddItemL( casestart ); |
|
698 casestart = CCaseMenu::NewL ( this, caseMenu, _L("Failed cases"), |
|
699 CUIStoreIf::EStatusFailed ); |
|
700 caseMenu->AddItemL( casestart ); |
|
701 casestart = CCaseMenu::NewL ( this, caseMenu, _L("Aborted/Crashed cases"), |
|
702 ( CUIStoreIf::EStatusAborted | CUIStoreIf::EStatusCrashed) ); |
|
703 caseMenu->AddItemL( casestart ); |
|
704 //Add "test set choice" menu |
|
705 CTestSetChoiceMenu* testChoiceMenu = CTestSetChoiceMenu::NewL( this, testSetMenu, _L("Load test set") ); |
|
706 testSetMenu->AddItemL( testChoiceMenu ); |
|
707 |
|
708 // Start stuff according to command line parameters |
|
709 if( iTestSetName ) |
|
710 { |
|
711 // Set test set name |
|
712 testSetMenu->SetTestSetFileName( iTestSetName->Des() ); |
|
713 |
|
714 // Load test set |
|
715 if( UIStore().LoadTestSet( iTestSetName->Des() ) != KErrNone ) |
|
716 { |
|
717 UiError( _L("Test set loading failed")); |
|
718 } |
|
719 else |
|
720 { |
|
721 // Inform test set menu that set is loaded |
|
722 testSetMenu->SetCreated(); |
|
723 |
|
724 // Check if test set should be started |
|
725 if( ( iStartCases == EStartCasesPar ) || |
|
726 ( iStartCases == EStartCasesSeq )) |
|
727 { |
|
728 |
|
729 // Check set starting type |
|
730 CStartedTestSet::TSetType setType = |
|
731 CStartedTestSet::ESetSequential; |
|
732 |
|
733 if( iStartCases == EStartCasesPar ) |
|
734 { |
|
735 setType = |
|
736 CStartedTestSet::ESetParallel; |
|
737 } |
|
738 |
|
739 // Start test set |
|
740 RRefArray<CTestSetInfo> setInfos; |
|
741 TInt ret = UIStore().TestSets( setInfos ); |
|
742 if( ( ret != KErrNone ) || |
|
743 ( setInfos.Count() != 1 ) ) |
|
744 { |
|
745 // Should never ever happen |
|
746 User::Panic( KConsoleMain, KErrGeneral ); |
|
747 } |
|
748 |
|
749 const CTestSetInfo& set = setInfos[0]; |
|
750 setInfos.Reset(); |
|
751 setInfos.Close(); |
|
752 |
|
753 TInt index; |
|
754 ret = UIStore().StartTestSet( set, index, setType ); |
|
755 if( ret != KErrNone ) |
|
756 { |
|
757 UiError( _L("Test set starting failed") ); |
|
758 } |
|
759 } |
|
760 } |
|
761 delete iTestSetName; |
|
762 iTestSetName = 0; |
|
763 } |
|
764 if( iTestModule ) |
|
765 { |
|
766 TPtrC module( iTestModule->Des() ); |
|
767 |
|
768 // Add all test modules and config files |
|
769 RDebug::Print(_L("Start creating test modules")); |
|
770 CTestModuleInfo* moduleInfo = NULL; |
|
771 TInt i; |
|
772 TInt modCnt = iModuleList->Count(); |
|
773 TInt ret; |
|
774 |
|
775 for(i = 0; i < modCnt; i++) |
|
776 { |
|
777 RDebug::Print(_L("Processing module")); |
|
778 // Get module |
|
779 moduleInfo = iModuleList->GetModule(i); |
|
780 if(!moduleInfo) |
|
781 { |
|
782 RDebug::Print(_L("Could not get module info at index %d"), i); |
|
783 continue; |
|
784 } |
|
785 |
|
786 // Get module name |
|
787 TName moduleName; |
|
788 moduleInfo->GetModuleName(moduleName); |
|
789 RDebug::Print(_L("module name: '%S'"), &moduleName); |
|
790 |
|
791 // Get ini file, if exists |
|
792 TFileName ini; |
|
793 moduleInfo->GetIniFileName(ini); |
|
794 if(ini.Length() == 0) |
|
795 { |
|
796 RDebug::Print(_L("ini file not found")); |
|
797 } |
|
798 else |
|
799 { |
|
800 RDebug::Print(_L("ini file: '%S'"), &ini); |
|
801 } |
|
802 |
|
803 // Create test module |
|
804 RDebug::Print(_L("Adding module to UI store")); |
|
805 ret = UIStore().AddTestModule(moduleName, ini); |
|
806 if(ret != KErrNone && ret != KErrAlreadyExists) |
|
807 { |
|
808 RDebug::Print(_L("Test module adding failed (%d)"), ret); |
|
809 UiError(_L("Test module adding failed")); |
|
810 continue; |
|
811 } |
|
812 |
|
813 //Add test case files |
|
814 TInt cfgCnt = moduleInfo->CountCfgFiles(); |
|
815 TInt j; |
|
816 TFileName cfgFile; |
|
817 for(j = 0; j < cfgCnt; j++) |
|
818 { |
|
819 moduleInfo->GetCfgFileName(j, cfgFile); |
|
820 if(cfgFile.Length() > 0) |
|
821 { |
|
822 RDebug::Print(_L("config file: '%S'"), &cfgFile); |
|
823 |
|
824 ret = UIStore().AddTestCaseFile(moduleName, cfgFile); |
|
825 if(ret != KErrNone) |
|
826 { |
|
827 // Log error |
|
828 RDebug::Print(_L("Test case file adding failed (%d)"), ret); |
|
829 UiError(_L("Test case file adding failed")); |
|
830 continue; |
|
831 } |
|
832 } |
|
833 else |
|
834 { |
|
835 RDebug::Print(_L("Got empty cfg file")); |
|
836 } |
|
837 } |
|
838 if(cfgCnt == 0) |
|
839 { |
|
840 RDebug::Print(_L("cfg file not found")); |
|
841 } |
|
842 |
|
843 RDebug::Print(_L("Module '%S' processed correctly"), &moduleName); |
|
844 } |
|
845 |
|
846 RDebug::Print(_L("End creating test modules")); |
|
847 |
|
848 if( ( iStartCases == EStartCasesPar ) || |
|
849 ( iStartCases == EStartCasesSeq ) ) |
|
850 { |
|
851 // Start running |
|
852 CMultipleBaseMenu::TRunType runType = |
|
853 CMultipleBaseMenu::ERunSequential; |
|
854 if( iStartCases == EStartCasesPar ) |
|
855 { |
|
856 runType = CMultipleBaseMenu::ERunParallel; |
|
857 } |
|
858 TRAPD( err, |
|
859 //multicasestart->StartRunningL( runType, module, file ); |
|
860 multicasestart->StartRunningL(runType, KNullDesC, KNullDesC); |
|
861 ); |
|
862 if( err != KErrNone ) |
|
863 { |
|
864 UiError( _L("Stating test cases failed") ); |
|
865 } |
|
866 } |
|
867 else if( iStartCases == EStartSingleCase ) |
|
868 { |
|
869 // Get test case |
|
870 RRefArray<CTestInfo> testCases; |
|
871 //ret = UIStore().TestCases( testCases, module, file ); |
|
872 ret = UIStore().TestCases(testCases, KNullDesC, KNullDesC); |
|
873 if( ret == KErrNone ) |
|
874 { |
|
875 if( ( iTestCaseNum < 0 ) || |
|
876 ( iTestCaseNum >= testCases.Count() ) ) |
|
877 { |
|
878 ret = KErrNotFound; |
|
879 } |
|
880 else |
|
881 { |
|
882 TInt index; |
|
883 // Start single test case |
|
884 ret = UIStore().StartTestCase( testCases[iTestCaseNum], index ); |
|
885 } |
|
886 } |
|
887 testCases.Reset(); |
|
888 testCases.Close(); |
|
889 if( ret != KErrNone ) |
|
890 { |
|
891 UiError( _L("Starting test case failed")); |
|
892 } |
|
893 } |
|
894 |
|
895 delete iTestCaseFile; |
|
896 iTestCaseFile = 0; |
|
897 delete iTestModuleIni; |
|
898 iTestModuleIni = 0; |
|
899 delete iTestModule; |
|
900 iTestModule = 0; |
|
901 } |
|
902 |
|
903 iStartCases = EStartCaseNo; |
|
904 |
|
905 // Load testcase if some stored |
|
906 UIStore().LoadSavedTestCases(); |
|
907 |
|
908 iScroller = CScrollerTimer::NewL ( this ); |
|
909 iScroller->StartL(); |
|
910 |
|
911 // Print the main menu |
|
912 iCurrentMenu = iMainMenu; |
|
913 iCurrentMenu->PrintMenuL( CMenu::EMenuPrint ); |
|
914 |
|
915 // Start to process keyboard events |
|
916 iReader->StartL(); |
|
917 |
|
918 return KErrNone; |
|
919 |
|
920 } |
|
921 |
|
922 |
|
923 /* |
|
924 ------------------------------------------------------------------------------- |
|
925 |
|
926 Class: CConsoleMain |
|
927 |
|
928 Method: KeyPressed |
|
929 |
|
930 Description: Process keyboard events. Print new menu |
|
931 |
|
932 Parameters: None |
|
933 |
|
934 Return Values: None |
|
935 |
|
936 Errors/Exceptions: Leaves if SelectL leaves |
|
937 |
|
938 Status: Draft |
|
939 |
|
940 ------------------------------------------------------------------------------- |
|
941 */ |
|
942 void CConsoleMain::KeyPressed() |
|
943 { |
|
944 |
|
945 TBool cont = ETrue; |
|
946 |
|
947 // Read the key |
|
948 // TKeyCode key = iConsole->KeyCode(); |
|
949 |
|
950 TKeyCode key = mapKey(); |
|
951 if(key == EKeyNull) |
|
952 { |
|
953 iReader->StartL(); |
|
954 return; |
|
955 } |
|
956 // TKeyCode key = EKeyDownArrow; //TODO |
|
957 CMenu* tmp = iCurrentMenu; |
|
958 |
|
959 // Let the menu handle the key press |
|
960 TRAPD( err, |
|
961 iCurrentMenu = iCurrentMenu->SelectL( key, cont ); |
|
962 ); |
|
963 if( err != KErrNone ) |
|
964 { |
|
965 User::InfoPrint( |
|
966 _L("Processing keystroke failed") ); |
|
967 } |
|
968 |
|
969 if ( iCurrentMenu == NULL ) |
|
970 { |
|
971 iCurrentMenu = tmp; |
|
972 } |
|
973 |
|
974 // If "not-exit" key pressed, continue |
|
975 if ( cont ) |
|
976 { |
|
977 |
|
978 // Either only update old menu or new menu. |
|
979 if ( tmp == iCurrentMenu ) |
|
980 { |
|
981 TRAP( err, iCurrentMenu->PrintMenuL( CMenu::EMenuRefresh ); ); |
|
982 } |
|
983 else |
|
984 { |
|
985 TRAP( err, iCurrentMenu->PrintMenuL( CMenu::EMenuPrint ); ) |
|
986 } |
|
987 |
|
988 if( err != KErrNone ) |
|
989 { |
|
990 if ( err == KErrNoMemory ) |
|
991 { |
|
992 ExitWithNoMemoryErrorMessage(); |
|
993 } |
|
994 else |
|
995 { |
|
996 User::InfoPrint( |
|
997 _L("Printing menu failed") ); |
|
998 } |
|
999 } |
|
1000 |
|
1001 // Enable keystrokes |
|
1002 iReader->StartL(); |
|
1003 |
|
1004 } |
|
1005 else |
|
1006 { |
|
1007 // "Exit", stop scheduler and exit |
|
1008 CActiveScheduler::Stop(); |
|
1009 } |
|
1010 |
|
1011 } |
|
1012 |
|
1013 |
|
1014 TKeyCode CConsoleMain::mapKey() |
|
1015 { |
|
1016 TInt event = key.Type(); |
|
1017 TInt keyCode = key.Code(); |
|
1018 |
|
1019 if( event == TRawEvent::EButton1Down ) |
|
1020 { |
|
1021 TInt ret; |
|
1022 //displayXPixels contains X of screen resolution |
|
1023 TInt displayXPixels; |
|
1024 //retrieve EDisplayXPixels value of this phone |
|
1025 ret = HAL::Get( HALData::EDisplayXPixels, displayXPixels ); |
|
1026 |
|
1027 //displayYPixelscontains Y of screen resolution |
|
1028 TInt displayYPixels; |
|
1029 //retrieve EDisplayYPixels value of this phone |
|
1030 ret =HAL::Get( HALData::EDisplayYPixels, displayYPixels ); |
|
1031 |
|
1032 if(ret != KErrNone) |
|
1033 { |
|
1034 UiError( _L("Unable to get screen resolution")); |
|
1035 } |
|
1036 |
|
1037 //if(keyCode ==EKeyEnter ) |
|
1038 TPoint currPos = key.MousePos(); |
|
1039 if(currPos.iY < ((displayYPixels/2)-(displayYPixels*0.3)) && currPos.iX < (displayXPixels -(displayXPixels*0.2)) && currPos.iX >(displayXPixels*0.3) ) |
|
1040 { |
|
1041 return EKeyUpArrow; |
|
1042 } |
|
1043 else if(currPos.iY > (displayYPixels/2+(displayYPixels*0.3))&& currPos.iX < (displayXPixels -(displayXPixels*0.2)) && currPos.iX >(displayXPixels*0.3)) |
|
1044 { |
|
1045 return EKeyDownArrow; |
|
1046 } |
|
1047 if(currPos.iX < ((displayXPixels/2)-(displayXPixels*0.3)) && currPos.iY < (displayYPixels -(displayYPixels*0.2)) && currPos.iY >(displayYPixels*0.3) ) |
|
1048 { |
|
1049 return EKeyLeftArrow; |
|
1050 } |
|
1051 else if(currPos.iX > (displayXPixels/2+(displayXPixels*0.3))&& currPos.iY < (displayYPixels -(displayYPixels*0.2)) && currPos.iY >(displayYPixels*0.3)) |
|
1052 { |
|
1053 return EKeyRightArrow; |
|
1054 } |
|
1055 |
|
1056 |
|
1057 } |
|
1058 else if (event == TRawEvent::EKeyDown) |
|
1059 { |
|
1060 switch (keyCode) |
|
1061 { |
|
1062 case 16: |
|
1063 return EKeyUpArrow; |
|
1064 case 17: |
|
1065 return EKeyDownArrow; |
|
1066 case 15: |
|
1067 return EKeyRightArrow; |
|
1068 case 14: |
|
1069 return EKeyLeftArrow; |
|
1070 case 851971: |
|
1071 return EKeyEnter; |
|
1072 case 4: |
|
1073 return EKeyEscape; |
|
1074 |
|
1075 // Additional keys |
|
1076 case 180: |
|
1077 return EKeyHome; |
|
1078 |
|
1079 default: |
|
1080 return EKeyNull; |
|
1081 |
|
1082 } |
|
1083 } |
|
1084 return EKeyNull; |
|
1085 } |
|
1086 |
|
1087 |
|
1088 /* |
|
1089 ------------------------------------------------------------------------------- |
|
1090 |
|
1091 Class: CConsoleMain |
|
1092 |
|
1093 Method: ExitWithNoMemoryErrorMessage |
|
1094 |
|
1095 Description: Displays no memory error message and closes ConsoleUI |
|
1096 |
|
1097 Parameters: None |
|
1098 |
|
1099 Return Values: None |
|
1100 |
|
1101 Errors/Exceptions: None |
|
1102 |
|
1103 Status: Approved |
|
1104 |
|
1105 ------------------------------------------------------------------------------- |
|
1106 */ |
|
1107 void CConsoleMain::ExitWithNoMemoryErrorMessage() |
|
1108 { |
|
1109 // "Exit", stop scheduler and exit |
|
1110 CActiveScheduler::Stop(); |
|
1111 |
|
1112 _LIT( KErrorTitle, "Error:\n" ); |
|
1113 _LIT( KErrorMessage, "Test cases execution have been stopped. ConsoleUI does not have enough memory to store information about executed test cases. Results of executed test cases can be found in TestReport file. ConsoleUI will be closed now." ); |
|
1114 _LIT( KErrorPressAnyKey, "\n\nPress any key" ); |
|
1115 |
|
1116 // TSize size = GetConsole()->ScreenSize(); |
|
1117 TSize size; |
|
1118 GetConsole()->Size(size); |
|
1119 size.iWidth = Min( size.iWidth - KMenuOverhead, |
|
1120 KErrorMessage().Length() ); |
|
1121 size.iHeight = ( KErrorTitle().Length() + KErrorMessage().Length() + |
|
1122 KErrorPressAnyKey().Length() ) / size.iWidth + 3; |
|
1123 |
|
1124 CConsoleBase* console = NULL; |
|
1125 TRAPD( err, console = Console::NewL( _L("Error note"), size ) ); |
|
1126 if ( err != KErrNone ) |
|
1127 { |
|
1128 // We can't create console, exit without displaying error message |
|
1129 return; |
|
1130 } |
|
1131 |
|
1132 console->Printf( KErrorTitle ); |
|
1133 console->Printf( KErrorMessage ); |
|
1134 console->Printf( KErrorPressAnyKey ); |
|
1135 |
|
1136 console->Getch(); |
|
1137 |
|
1138 delete console; |
|
1139 } |
|
1140 |
|
1141 /* |
|
1142 ------------------------------------------------------------------------------- |
|
1143 |
|
1144 Class: CConsoleMain |
|
1145 |
|
1146 Method: UiError |
|
1147 |
|
1148 Description: Function is called when UI hit an error. |
|
1149 |
|
1150 Parameters: const TDesC& aInfo: in: information |
|
1151 |
|
1152 Return Values: None |
|
1153 |
|
1154 Errors/Exceptions: None |
|
1155 |
|
1156 Status: Draft |
|
1157 |
|
1158 ------------------------------------------------------------------------------- |
|
1159 */ |
|
1160 |
|
1161 void CConsoleMain::UiError( const TDesC& aInfo ) |
|
1162 { |
|
1163 |
|
1164 // Error note deletes itself when it completes |
|
1165 CMenuNotifier::NewL( aInfo, this ); |
|
1166 |
|
1167 } |
|
1168 |
|
1169 /* |
|
1170 ------------------------------------------------------------------------------- |
|
1171 |
|
1172 Class: CConsoleMain |
|
1173 |
|
1174 Method: Update |
|
1175 |
|
1176 Description: Receives output update notification from CUIStore. |
|
1177 |
|
1178 Parameters: CStartedTestCase* aTestCase: in: Test case information |
|
1179 TInt aFlags: in: Update reason flags |
|
1180 |
|
1181 Return Values: None |
|
1182 |
|
1183 Errors/Exceptions: None |
|
1184 |
|
1185 Status: Draft |
|
1186 |
|
1187 ------------------------------------------------------------------------------- |
|
1188 */ |
|
1189 void CConsoleMain::Update( CStartedTestCase* aTestCase, TInt aFlags ) |
|
1190 { |
|
1191 |
|
1192 TInt err( KErrNone ); |
|
1193 |
|
1194 // First check if some menu should be signaled |
|
1195 if( ( aFlags & CUIStoreIf::EStatusExecuted ) && |
|
1196 ( aTestCase->iBackPtr ) ) |
|
1197 { |
|
1198 CMenu* menu = ( CMenu* )aTestCase->iBackPtr; |
|
1199 TRAP( err, |
|
1200 menu->SignalL( aTestCase ); |
|
1201 ); |
|
1202 } |
|
1203 |
|
1204 // Update console if needed |
|
1205 if( iCurrentMenu && ( iCurrentMenu->Type() & aFlags ) ) |
|
1206 { |
|
1207 if( aFlags & CUIStoreIf::EPrintUpdate ) |
|
1208 { |
|
1209 CCaseExecutionView* view = |
|
1210 ( CCaseExecutionView* )iCurrentMenu; |
|
1211 if( view->TestCase() == aTestCase ) |
|
1212 { |
|
1213 TRAP( err, iCurrentMenu->PrintMenuL( CMenu::EMenuRefresh ) ); |
|
1214 } |
|
1215 } |
|
1216 else |
|
1217 { |
|
1218 TRAP( err, iCurrentMenu->PrintMenuL( CMenu::EMenuRefresh ); ) |
|
1219 } |
|
1220 } |
|
1221 |
|
1222 if ( err != KErrNone ) |
|
1223 { |
|
1224 if ( err == KErrNoMemory ) |
|
1225 { |
|
1226 ExitWithNoMemoryErrorMessage(); |
|
1227 } |
|
1228 } |
|
1229 |
|
1230 } |
|
1231 |
|
1232 |
|
1233 |
|
1234 /* |
|
1235 ------------------------------------------------------------------------------- |
|
1236 |
|
1237 Class: CConsoleMain |
|
1238 |
|
1239 Method: Error |
|
1240 |
|
1241 Description: Function is called when test framework prints error. |
|
1242 |
|
1243 Parameters: TErrorNotification& aError: in: Error description |
|
1244 |
|
1245 Return Values: None |
|
1246 |
|
1247 Errors/Exceptions: None |
|
1248 |
|
1249 Status: Draft |
|
1250 |
|
1251 ------------------------------------------------------------------------------- |
|
1252 */ |
|
1253 |
|
1254 void CConsoleMain::Error( TErrorNotification& aError ) |
|
1255 { |
|
1256 |
|
1257 // Error note deletes itself when it completes |
|
1258 CMenuNotifier::NewL( aError.iText, this ); |
|
1259 |
|
1260 } |
|
1261 |
|
1262 /* |
|
1263 ------------------------------------------------------------------------------- |
|
1264 |
|
1265 Class: CConsoleMain |
|
1266 |
|
1267 Method: PopupMsg |
|
1268 |
|
1269 Description: Function is called when testframework |
|
1270 wants to print a popup window. |
|
1271 |
|
1272 Parameters: TDesC& aMsg: in: message |
|
1273 |
|
1274 |
|
1275 Return Values: Symbian OS error code |
|
1276 |
|
1277 Errors/Exceptions: None |
|
1278 |
|
1279 Status: Draft |
|
1280 |
|
1281 ------------------------------------------------------------------------------- |
|
1282 */ |
|
1283 |
|
1284 TInt CConsoleMain::PopupMsg( const TDesC& aLine1, |
|
1285 const TDesC& aLine2, |
|
1286 TInt aTimeInSecs ) |
|
1287 { |
|
1288 |
|
1289 TInt ret = KErrNone; |
|
1290 |
|
1291 CMenuDialog* dialog = NULL; |
|
1292 |
|
1293 TRAP( ret, dialog = CMenuDialog::NewL( this, aLine1, aLine2, aTimeInSecs ); ); |
|
1294 |
|
1295 if( ret == KErrNone ) |
|
1296 { |
|
1297 iDialogs.Append( dialog ); |
|
1298 return (TInt)dialog; |
|
1299 } |
|
1300 |
|
1301 return ret; |
|
1302 |
|
1303 } |
|
1304 |
|
1305 /* |
|
1306 ------------------------------------------------------------------------------- |
|
1307 |
|
1308 Class: CConsoleMain |
|
1309 |
|
1310 Method: PopupMsg |
|
1311 |
|
1312 Description: Function is called when testframework |
|
1313 wants to print a popup window. |
|
1314 |
|
1315 Parameters: TDesC& aMsg: in: message |
|
1316 |
|
1317 |
|
1318 Return Values: Symbian OS error code |
|
1319 |
|
1320 Errors/Exceptions: None |
|
1321 |
|
1322 Status: Draft |
|
1323 |
|
1324 ------------------------------------------------------------------------------- |
|
1325 */ |
|
1326 |
|
1327 TInt CConsoleMain::PopupMsg( const TDesC& aLine1, |
|
1328 const TDesC& aLine2, |
|
1329 TInt aTimeInSecs, |
|
1330 TKeyCode& aKey, |
|
1331 TRequestStatus& aStatus ) |
|
1332 { |
|
1333 |
|
1334 TInt ret = PopupMsg( aLine1, aLine2, aTimeInSecs ); |
|
1335 if( ret < 0 ) |
|
1336 { |
|
1337 return ret; |
|
1338 } |
|
1339 |
|
1340 CMenuDialog* dialog = (CMenuDialog*) ret; |
|
1341 ret = dialog->WaitForKeypress( aKey, aStatus ); |
|
1342 |
|
1343 return (TInt) dialog; |
|
1344 |
|
1345 } |
|
1346 /* |
|
1347 ------------------------------------------------------------------------------- |
|
1348 |
|
1349 Class: CConsoleMain |
|
1350 |
|
1351 Method: Close |
|
1352 |
|
1353 Description: Close instance. |
|
1354 |
|
1355 Parameters: TInt aHandle: in: handle to open instance. |
|
1356 |
|
1357 Return Values: Symbian OS error code |
|
1358 |
|
1359 Errors/Exceptions: None |
|
1360 |
|
1361 Status: Draft |
|
1362 |
|
1363 ------------------------------------------------------------------------------- |
|
1364 */ |
|
1365 void CConsoleMain::Close( TInt aHandle ) |
|
1366 { |
|
1367 |
|
1368 if( aHandle < 0 ) |
|
1369 { |
|
1370 return; |
|
1371 } |
|
1372 CMenuDialog* dialog = (CMenuDialog*) aHandle; |
|
1373 TInt index = iDialogs.Find( dialog ); |
|
1374 if( index >= 0 ) |
|
1375 { |
|
1376 delete dialog; |
|
1377 iDialogs.Remove( index ); |
|
1378 } |
|
1379 |
|
1380 } |
|
1381 |
|
1382 /* |
|
1383 ------------------------------------------------------------------------------- |
|
1384 |
|
1385 Class: CConsoleMain |
|
1386 |
|
1387 Method: GetConsole |
|
1388 |
|
1389 Description: Returns the console |
|
1390 |
|
1391 Parameters: None |
|
1392 |
|
1393 Return Values: CConsoleBase* Console |
|
1394 |
|
1395 Errors/Exceptions: None |
|
1396 |
|
1397 Status: Draft |
|
1398 |
|
1399 ------------------------------------------------------------------------------- |
|
1400 */ |
|
1401 //CConsoleBase* CConsoleMain::GetConsole() |
|
1402 RConsole* CConsoleMain::GetConsole() |
|
1403 { |
|
1404 |
|
1405 return &iConsole; |
|
1406 |
|
1407 } |
|
1408 |
|
1409 /* |
|
1410 ------------------------------------------------------------------------------- |
|
1411 |
|
1412 Class: CConsoleMain |
|
1413 |
|
1414 Method: TimerUpdate |
|
1415 |
|
1416 Description: Updates current menu from timer |
|
1417 |
|
1418 Parameters: None |
|
1419 |
|
1420 Return Values: None |
|
1421 |
|
1422 Errors/Exceptions: None |
|
1423 |
|
1424 Status: Draft |
|
1425 |
|
1426 ------------------------------------------------------------------------------- |
|
1427 */ |
|
1428 void CConsoleMain::TimerUpdate() |
|
1429 { |
|
1430 |
|
1431 iCurrentMenu->TimerUpdate(); |
|
1432 |
|
1433 } |
|
1434 |
|
1435 /* |
|
1436 ------------------------------------------------------------------------------- |
|
1437 |
|
1438 Class: CConsoleMain |
|
1439 |
|
1440 Method: ParseTestModulesL |
|
1441 |
|
1442 Description: Parse and search for module info and fill list of modules. |
|
1443 |
|
1444 Parameters: CStifParser* aParser: in: CStifParser object |
|
1445 CTestModuleList* aModuleList: in: list of modules |
|
1446 TPtrC& aSectionStart: in: descriptor with start of section string |
|
1447 TPTrC& aSectionEnd: in: descriptor with end of section string |
|
1448 |
|
1449 Return Values: None |
|
1450 |
|
1451 Errors/Exceptions: Leaves if some of called leaving methods leaves |
|
1452 |
|
1453 Status: Approved |
|
1454 |
|
1455 ------------------------------------------------------------------------------- |
|
1456 */ |
|
1457 void CConsoleMain::ParseTestModulesL(CStifParser* aParser, CTestModuleList* aModuleList, const TDesC& aSectionStart, const TDesC& aSectionEnd) |
|
1458 { |
|
1459 //First let's find all modules given in Stif's ini file and store that info in CTestModuleList object |
|
1460 CStifSectionParser* sectionParser = NULL; |
|
1461 CStifItemParser* item = NULL; |
|
1462 |
|
1463 sectionParser = aParser->SectionL(aSectionStart, aSectionEnd); |
|
1464 |
|
1465 while(sectionParser) |
|
1466 { |
|
1467 RDebug::Print(_L("Found '%S' and '%S' sections"), &aSectionStart, &aSectionEnd); |
|
1468 CleanupStack::PushL(sectionParser); |
|
1469 RDebug::Print(_L("Starting to read module information")); |
|
1470 |
|
1471 // Get name of module |
|
1472 _LIT(KModuleName, "ModuleName="); |
|
1473 item = sectionParser->GetItemLineL(KModuleName); |
|
1474 CleanupStack::PushL(item); |
|
1475 if(!item) |
|
1476 { |
|
1477 CleanupStack::PopAndDestroy(item); |
|
1478 UiError(_L("Line not found from module section")); |
|
1479 User::Leave(KErrGeneral); |
|
1480 } |
|
1481 else |
|
1482 { |
|
1483 RDebug::Print(_L("'%S' found"), &KModuleName); |
|
1484 } |
|
1485 |
|
1486 TPtrC name; |
|
1487 TName moduleName; |
|
1488 TInt ret(KErrNone); |
|
1489 ret = item->GetString(KModuleName, name); |
|
1490 if(ret != KErrNone) |
|
1491 { |
|
1492 CleanupStack::PopAndDestroy(item); |
|
1493 RDebug::Print(_L("Module name parsing left with error (%d)"), ret); |
|
1494 UiError(_L("Module name parsing left with error (err)")); |
|
1495 User::Leave(ret); |
|
1496 } |
|
1497 else |
|
1498 { |
|
1499 RDebug::Print(_L("Module '%S' found from ini-file"), &name); |
|
1500 moduleName.Copy(name); |
|
1501 moduleName.LowerCase(); |
|
1502 ret = aModuleList->AddTestModule(moduleName); |
|
1503 if(ret != KErrNone && ret != KErrAlreadyExists) |
|
1504 { |
|
1505 RDebug::Print(_L("Could not add module to list of modules (%d)"), ret); |
|
1506 UiError(_L("Could not add module to list of modules (err)")); |
|
1507 User::Leave(ret); |
|
1508 } |
|
1509 } |
|
1510 CleanupStack::PopAndDestroy(item); |
|
1511 |
|
1512 //Get pointer to added module |
|
1513 CTestModuleInfo* moduleInfo = aModuleList->GetModule(moduleName); |
|
1514 if(!moduleInfo) |
|
1515 { |
|
1516 RDebug::Print(_L("Could not add get module info from list")); |
|
1517 UiError(_L("Could not add get module info from list")); |
|
1518 User::Leave(KErrNotFound); |
|
1519 } |
|
1520 |
|
1521 // Get ini file, if it exists |
|
1522 RDebug::Print(_L("Start parsing ini file")); |
|
1523 _LIT(KIniFile, "IniFile="); |
|
1524 item = sectionParser->GetItemLineL(KIniFile); |
|
1525 if(item) |
|
1526 { |
|
1527 RDebug::Print(_L("'%S' found"), &KIniFile); |
|
1528 CleanupStack::PushL(item); |
|
1529 TPtrC iniFile; |
|
1530 ret = item->GetString(KIniFile, iniFile); |
|
1531 if(ret == KErrNone) |
|
1532 { |
|
1533 RDebug::Print(_L("Initialization file '%S' found, file can be empty"), &iniFile); |
|
1534 TFileName filename; |
|
1535 filename.Copy(iniFile); |
|
1536 TStifUtil::CorrectFilePathL(filename); |
|
1537 filename.LowerCase(); |
|
1538 moduleInfo->SetIniFile(filename); |
|
1539 } |
|
1540 else |
|
1541 { |
|
1542 RDebug::Print(_L("Initialization file not found")); |
|
1543 } |
|
1544 CleanupStack::PopAndDestroy(item); |
|
1545 } |
|
1546 else |
|
1547 { |
|
1548 RDebug::Print(_L("'%S' not found"), &KIniFile); |
|
1549 } |
|
1550 |
|
1551 // Get config (testcase) file |
|
1552 RDebug::Print(_L("Start parsing cfg files")); |
|
1553 TPtrC cfgTag; |
|
1554 for(TInt i = 0; i < 2; i++) |
|
1555 { |
|
1556 //Set tag for config files |
|
1557 if(i == 0) |
|
1558 { |
|
1559 cfgTag.Set(_L("ConfigFile=")); |
|
1560 } |
|
1561 else |
|
1562 { |
|
1563 cfgTag.Set(_L("TestCaseFile=")); |
|
1564 } |
|
1565 //Read data |
|
1566 item = sectionParser->GetItemLineL(cfgTag); |
|
1567 while(item) |
|
1568 { |
|
1569 CleanupStack::PushL(item); |
|
1570 RDebug::Print(_L("Item '%S' found"), &cfgTag); |
|
1571 TPtrC cfgFile; |
|
1572 ret = item->GetString(cfgTag, cfgFile); |
|
1573 if(ret == KErrNone) |
|
1574 { |
|
1575 RDebug::Print(_L("Configuration file '%S' found"), &cfgFile); |
|
1576 TFileName ifile; |
|
1577 ifile.Copy(cfgFile); |
|
1578 TStifUtil::CorrectFilePathL(ifile); |
|
1579 ifile.LowerCase(); |
|
1580 moduleInfo->AddCfgFile(ifile); |
|
1581 } |
|
1582 else |
|
1583 { |
|
1584 RDebug::Print(_L("Configuration file not found")); |
|
1585 } |
|
1586 CleanupStack::PopAndDestroy(item); |
|
1587 item = sectionParser->GetNextItemLineL(cfgTag); |
|
1588 } |
|
1589 } |
|
1590 |
|
1591 RDebug::Print(_L("Module '%S' information read correctly"), &moduleName); |
|
1592 |
|
1593 // Get next section |
|
1594 CleanupStack::PopAndDestroy(sectionParser); |
|
1595 sectionParser = aParser->NextSectionL(aSectionStart, aSectionEnd); |
|
1596 } |
|
1597 } |
|
1598 |
|
1599 /* |
|
1600 ------------------------------------------------------------------------------- |
|
1601 |
|
1602 Class: CConsoleMain |
|
1603 |
|
1604 Method: GetMainMenu |
|
1605 |
|
1606 Description: Return main menu of console. |
|
1607 |
|
1608 Parameters: None |
|
1609 |
|
1610 Return Values: CMainMenu* pointer to main menu |
|
1611 |
|
1612 Errors/Exceptions: None |
|
1613 |
|
1614 Status: Approved |
|
1615 |
|
1616 ------------------------------------------------------------------------------- |
|
1617 */ |
|
1618 CMainMenu* CConsoleMain::GetMainMenu() |
|
1619 { |
|
1620 return dynamic_cast<CMainMenu*>(iMainMenu); |
|
1621 } |
|
1622 |
|
1623 /* |
|
1624 ------------------------------------------------------------------------------- |
|
1625 |
|
1626 Class: CConsoleMain |
|
1627 |
|
1628 Method: GetFilterArray |
|
1629 |
|
1630 Description: Get filter array for reading purposes |
|
1631 |
|
1632 Parameters: None |
|
1633 |
|
1634 Return Values: const RPointerArray<TDesC>& array with filters |
|
1635 |
|
1636 Errors/Exceptions: None |
|
1637 |
|
1638 Status: Approved |
|
1639 |
|
1640 ------------------------------------------------------------------------------- |
|
1641 */ |
|
1642 const RPointerArray<TDesC>& CConsoleMain::GetFilterArray(void) const |
|
1643 { |
|
1644 return iFilters; |
|
1645 } |
|
1646 |
|
1647 /* |
|
1648 ------------------------------------------------------------------------------- |
|
1649 |
|
1650 Class: CConsoleMain |
|
1651 |
|
1652 Method: SetFilterIndex |
|
1653 |
|
1654 Description: Set info about which index filter is used |
|
1655 |
|
1656 Parameters: TInt aFilterIndex: filter index selected by user |
|
1657 |
|
1658 Return Values: None |
|
1659 |
|
1660 Errors/Exceptions: None |
|
1661 |
|
1662 Status: Approved |
|
1663 |
|
1664 ------------------------------------------------------------------------------- |
|
1665 */ |
|
1666 void CConsoleMain::SetFilterIndex(TInt aFilterIndex) |
|
1667 { |
|
1668 iChosenFilterIndex = aFilterIndex; |
|
1669 } |
|
1670 |
|
1671 /* |
|
1672 ------------------------------------------------------------------------------- |
|
1673 |
|
1674 Class: CConsoleMain |
|
1675 |
|
1676 Method: GetFilterIndex |
|
1677 |
|
1678 Description: Get info about which index filter is used |
|
1679 |
|
1680 Parameters: None |
|
1681 |
|
1682 Return Values: TInt: filter index selected by user |
|
1683 |
|
1684 Errors/Exceptions: None |
|
1685 |
|
1686 Status: Approved |
|
1687 |
|
1688 ------------------------------------------------------------------------------- |
|
1689 */ |
|
1690 TInt CConsoleMain::GetFilterIndex(void) |
|
1691 { |
|
1692 return iChosenFilterIndex; |
|
1693 } |
|
1694 |
|
1695 /* |
|
1696 ------------------------------------------------------------------------------- |
|
1697 |
|
1698 Class: CScrollerTimer |
|
1699 |
|
1700 Method: NewL |
|
1701 |
|
1702 Description: Construct a new CScrollerTimer object |
|
1703 |
|
1704 Parameters: CConsoleMain* :in: Pointer to main console |
|
1705 |
|
1706 Return Values: CScrollerTimer* New CScrollerTimer object |
|
1707 |
|
1708 Errors/Exceptions: Leaves if memory allocation or ConstructL leaves |
|
1709 |
|
1710 Status: Draft |
|
1711 |
|
1712 ------------------------------------------------------------------------------- |
|
1713 */ |
|
1714 CScrollerTimer* CScrollerTimer::NewL( CConsoleMain* aMain ) |
|
1715 { |
|
1716 |
|
1717 CScrollerTimer* self = new ( ELeave ) CScrollerTimer(); |
|
1718 CleanupStack::PushL( self ); |
|
1719 self->ConstructL( aMain ); |
|
1720 CleanupStack::Pop( self ); |
|
1721 return self; |
|
1722 |
|
1723 } |
|
1724 |
|
1725 /* |
|
1726 ------------------------------------------------------------------------------- |
|
1727 |
|
1728 Class: CScrollerTimer |
|
1729 |
|
1730 Method: ConstructL |
|
1731 |
|
1732 Description: Second level constructor |
|
1733 |
|
1734 Parameters: CConsoleMain* :in: Pointer to main console |
|
1735 |
|
1736 Return Values: None |
|
1737 |
|
1738 Errors/Exceptions: None |
|
1739 |
|
1740 Status: Draft |
|
1741 |
|
1742 ------------------------------------------------------------------------------- |
|
1743 */ |
|
1744 void CScrollerTimer::ConstructL( CConsoleMain* aMain ) |
|
1745 { |
|
1746 |
|
1747 // Store module information |
|
1748 iMain = aMain; |
|
1749 iTimer.CreateLocal(); |
|
1750 |
|
1751 CActiveScheduler::Add ( this ); |
|
1752 |
|
1753 } |
|
1754 |
|
1755 /* |
|
1756 ------------------------------------------------------------------------------- |
|
1757 |
|
1758 Class: CScrollerTimer |
|
1759 |
|
1760 Method: CScrollerTimer |
|
1761 |
|
1762 Description: Constructor. |
|
1763 |
|
1764 Parameters: None |
|
1765 |
|
1766 Return Values: None |
|
1767 |
|
1768 Errors/Exceptions: None |
|
1769 |
|
1770 Status: Draft |
|
1771 |
|
1772 ------------------------------------------------------------------------------- |
|
1773 */ |
|
1774 CScrollerTimer::CScrollerTimer() : CActive (CActive::EPriorityStandard) |
|
1775 { |
|
1776 |
|
1777 } |
|
1778 |
|
1779 |
|
1780 /* |
|
1781 ------------------------------------------------------------------------------- |
|
1782 |
|
1783 Class: CScrollerTimer |
|
1784 |
|
1785 Method: ~CScrollerTimer |
|
1786 |
|
1787 Description: None |
|
1788 |
|
1789 Parameters: None |
|
1790 |
|
1791 Return Values: None |
|
1792 |
|
1793 Errors/Exceptions: None |
|
1794 |
|
1795 Status: Draft |
|
1796 |
|
1797 ------------------------------------------------------------------------------- |
|
1798 */ |
|
1799 CScrollerTimer::~CScrollerTimer( ) |
|
1800 { |
|
1801 |
|
1802 Cancel(); |
|
1803 iTimer.Close(); |
|
1804 |
|
1805 } |
|
1806 |
|
1807 /* |
|
1808 ------------------------------------------------------------------------------- |
|
1809 |
|
1810 Class: CScrollerTimer |
|
1811 |
|
1812 Method: StartL |
|
1813 |
|
1814 Description: None |
|
1815 |
|
1816 Parameters: None |
|
1817 |
|
1818 Return Values: None |
|
1819 |
|
1820 Errors/Exceptions: None |
|
1821 |
|
1822 Status: Draft |
|
1823 |
|
1824 ------------------------------------------------------------------------------- |
|
1825 */ |
|
1826 void CScrollerTimer::StartL( ) |
|
1827 { |
|
1828 |
|
1829 SetActive(); |
|
1830 iTimer.After ( iStatus, KScrollPeriod ); |
|
1831 |
|
1832 } |
|
1833 |
|
1834 /* |
|
1835 ------------------------------------------------------------------------------- |
|
1836 |
|
1837 Class: CScrollerTimer |
|
1838 |
|
1839 Method: RunL |
|
1840 |
|
1841 Description: None |
|
1842 |
|
1843 Parameters: None |
|
1844 |
|
1845 Return Values: None |
|
1846 |
|
1847 Errors/Exceptions: None |
|
1848 |
|
1849 Status: Draft |
|
1850 |
|
1851 ------------------------------------------------------------------------------- |
|
1852 */ |
|
1853 void CScrollerTimer::RunL( ) |
|
1854 { |
|
1855 |
|
1856 iMain->TimerUpdate(); |
|
1857 |
|
1858 // Restart request |
|
1859 SetActive(); |
|
1860 iTimer.After ( iStatus, KScrollPeriod ); |
|
1861 |
|
1862 } |
|
1863 |
|
1864 /* |
|
1865 ------------------------------------------------------------------------------- |
|
1866 |
|
1867 Class: CScrollerTimer |
|
1868 |
|
1869 Method: DoCancel |
|
1870 |
|
1871 Description: None |
|
1872 |
|
1873 Parameters: None |
|
1874 |
|
1875 Return Values: None |
|
1876 |
|
1877 Errors/Exceptions: None |
|
1878 |
|
1879 Status: Draft |
|
1880 |
|
1881 ------------------------------------------------------------------------------- |
|
1882 */ |
|
1883 void CScrollerTimer::DoCancel( ) |
|
1884 { |
|
1885 |
|
1886 iTimer.Cancel(); |
|
1887 |
|
1888 } |
|
1889 |
|
1890 /* |
|
1891 ------------------------------------------------------------------------------- |
|
1892 |
|
1893 Class: CScrollerTimer |
|
1894 |
|
1895 Method: RunError |
|
1896 |
|
1897 Description: None |
|
1898 |
|
1899 Parameters: None |
|
1900 |
|
1901 Return Values: None |
|
1902 |
|
1903 Errors/Exceptions: None |
|
1904 |
|
1905 Status: Draft |
|
1906 |
|
1907 ------------------------------------------------------------------------------- |
|
1908 */ |
|
1909 TInt CScrollerTimer::RunError( TInt aError) |
|
1910 { |
|
1911 if ( aError == KErrNoMemory ) |
|
1912 { |
|
1913 iMain->ExitWithNoMemoryErrorMessage(); |
|
1914 } |
|
1915 |
|
1916 return aError; |
|
1917 } |
|
1918 |
|
1919 /* |
|
1920 ------------------------------------------------------------------------------- |
|
1921 |
|
1922 DESCRIPTION |
|
1923 |
|
1924 This module contains implementation of CConsoleReader class. |
|
1925 |
|
1926 ------------------------------------------------------------------------------- |
|
1927 */ |
|
1928 |
|
1929 // ================= MEMBER FUNCTIONS ========================================= |
|
1930 |
|
1931 |
|
1932 |
|
1933 /* |
|
1934 ------------------------------------------------------------------------------- |
|
1935 |
|
1936 Class: CConsoleReader |
|
1937 |
|
1938 Method: NewL |
|
1939 |
|
1940 Description: Construct the console main class |
|
1941 |
|
1942 Parameters: CConsoleMain* aMain: in: Pointer to main console |
|
1943 CConsoleBase* aConsole: in: Console pointer |
|
1944 |
|
1945 Return Values: CConsoleReader* New object |
|
1946 |
|
1947 Errors/Exceptions: Leaves if memory allocation fails or |
|
1948 ConstructL leaves. |
|
1949 |
|
1950 Status: Draft |
|
1951 |
|
1952 ------------------------------------------------------------------------------- |
|
1953 */ |
|
1954 CConsoleReader* CConsoleReader::NewL( CConsoleMain* aMain, |
|
1955 //CConsoleBase* aConsole ) |
|
1956 RConsole* aConsole ) |
|
1957 { |
|
1958 |
|
1959 CConsoleReader* self = |
|
1960 new ( ELeave ) CConsoleReader( aMain, aConsole ); |
|
1961 CleanupStack::PushL( self ); |
|
1962 self->ConstructL(); |
|
1963 CleanupStack::Pop( self ); |
|
1964 return self; |
|
1965 |
|
1966 } |
|
1967 |
|
1968 |
|
1969 /* |
|
1970 ------------------------------------------------------------------------------- |
|
1971 |
|
1972 Class: CConsoleReader |
|
1973 |
|
1974 Method: ConstructL |
|
1975 |
|
1976 Description: Second level constructor. |
|
1977 |
|
1978 Parameters: None |
|
1979 |
|
1980 Return Values: None |
|
1981 |
|
1982 Errors/Exceptions: |
|
1983 |
|
1984 Status: Draft |
|
1985 |
|
1986 ------------------------------------------------------------------------------- |
|
1987 */ |
|
1988 void CConsoleReader::ConstructL( ) |
|
1989 { |
|
1990 } |
|
1991 |
|
1992 |
|
1993 /* |
|
1994 ------------------------------------------------------------------------------- |
|
1995 |
|
1996 Class: CConsoleReader |
|
1997 |
|
1998 Method: CConsoleReader |
|
1999 |
|
2000 Description: Constructor. |
|
2001 |
|
2002 Parameters: CConsoleMain* aMain: in: Pointer to main console |
|
2003 CConsoleBase* aConsole: in: Console pointer |
|
2004 |
|
2005 Return Values: None |
|
2006 |
|
2007 Errors/Exceptions: None |
|
2008 |
|
2009 Status: Draft |
|
2010 |
|
2011 ------------------------------------------------------------------------------- |
|
2012 */ |
|
2013 CConsoleReader::CConsoleReader( CConsoleMain* aMain, |
|
2014 //CConsoleBase* aConsole ): |
|
2015 RConsole* aConsole ): |
|
2016 CActive( EPriorityStandard ) |
|
2017 { |
|
2018 |
|
2019 iMain = aMain; |
|
2020 iConsole = aConsole; |
|
2021 |
|
2022 CActiveScheduler::Add( this ); |
|
2023 |
|
2024 } |
|
2025 |
|
2026 |
|
2027 /* |
|
2028 ------------------------------------------------------------------------------- |
|
2029 |
|
2030 Class: CConsoleReader |
|
2031 |
|
2032 Method: ~CConsoleReader |
|
2033 |
|
2034 Description: Destructor |
|
2035 |
|
2036 Parameters: None |
|
2037 |
|
2038 Return Values: None |
|
2039 |
|
2040 Errors/Exceptions: None |
|
2041 |
|
2042 Status: Draft |
|
2043 |
|
2044 ------------------------------------------------------------------------------- |
|
2045 */ |
|
2046 CConsoleReader::~CConsoleReader( ) |
|
2047 { |
|
2048 |
|
2049 Cancel(); |
|
2050 |
|
2051 } |
|
2052 |
|
2053 /* |
|
2054 ------------------------------------------------------------------------------- |
|
2055 |
|
2056 Class: CConsoleReader |
|
2057 |
|
2058 Method: StartL |
|
2059 |
|
2060 Description: Construct menu objects and start the menu handling |
|
2061 |
|
2062 Parameters: None |
|
2063 |
|
2064 Return Values: None |
|
2065 |
|
2066 Errors/Exceptions: |
|
2067 |
|
2068 Status: Draft |
|
2069 |
|
2070 ------------------------------------------------------------------------------- |
|
2071 */ |
|
2072 void CConsoleReader::StartL( ) |
|
2073 { |
|
2074 |
|
2075 // Start to process keyboard events |
|
2076 SetActive(); |
|
2077 //iConsole->Read(iStatus); |
|
2078 iConsole->Read(iMain->key, iStatus); |
|
2079 |
|
2080 } |
|
2081 /* |
|
2082 ------------------------------------------------------------------------------- |
|
2083 |
|
2084 Class: CConsoleReader |
|
2085 |
|
2086 Method: RunError |
|
2087 |
|
2088 Description: None |
|
2089 |
|
2090 Parameters: TInt aError |
|
2091 |
|
2092 Return Values: Error code |
|
2093 |
|
2094 Errors/Exceptions: None |
|
2095 |
|
2096 Status: Draft |
|
2097 |
|
2098 ------------------------------------------------------------------------------- |
|
2099 */ |
|
2100 TInt CConsoleReader::RunError(TInt aError) |
|
2101 { |
|
2102 return aError; |
|
2103 } |
|
2104 |
|
2105 |
|
2106 /* |
|
2107 ------------------------------------------------------------------------------- |
|
2108 |
|
2109 Class: CConsoleReader |
|
2110 |
|
2111 Method: RunL |
|
2112 |
|
2113 Description: Process keyboard events. Print new menu |
|
2114 |
|
2115 Parameters: None |
|
2116 |
|
2117 Return Values: None |
|
2118 |
|
2119 Errors/Exceptions: Leaves if SelectL leaves |
|
2120 |
|
2121 Status: Draft |
|
2122 |
|
2123 ------------------------------------------------------------------------------- |
|
2124 */ |
|
2125 void CConsoleReader::RunL() |
|
2126 { |
|
2127 |
|
2128 iMain->KeyPressed(); |
|
2129 |
|
2130 } |
|
2131 |
|
2132 |
|
2133 /* |
|
2134 ------------------------------------------------------------------------------- |
|
2135 |
|
2136 Class: CConsoleReader |
|
2137 |
|
2138 Method: DoCancel |
|
2139 |
|
2140 Description: Cancel request |
|
2141 |
|
2142 Parameters: None |
|
2143 |
|
2144 Return Values: None |
|
2145 |
|
2146 Errors/Exceptions: None |
|
2147 |
|
2148 Status: Draft |
|
2149 |
|
2150 ------------------------------------------------------------------------------- |
|
2151 */ |
|
2152 void CConsoleReader::DoCancel() |
|
2153 { |
|
2154 |
|
2155 iConsole->ReadCancel(); |
|
2156 |
|
2157 } |
|
2158 |
|
2159 |
|
2160 // ================= OTHER EXPORTED FUNCTIONS ================================= |
|
2161 |
|
2162 /* |
|
2163 ------------------------------------------------------------------------------- |
|
2164 |
|
2165 Class: - |
|
2166 |
|
2167 Method: MainL |
|
2168 |
|
2169 Description: The main function that can leave. |
|
2170 Create the CMainConsole object and create, initialise and |
|
2171 start active scheduler. |
|
2172 |
|
2173 When active scheduler is stopped, clean up memory and exit. |
|
2174 |
|
2175 Parameters: None |
|
2176 |
|
2177 Return Values: None |
|
2178 |
|
2179 Errors/Exceptions: Leaves if memory allocation or CConsoleMain construction |
|
2180 leaves. |
|
2181 |
|
2182 Status: Draft |
|
2183 |
|
2184 ------------------------------------------------------------------------------- |
|
2185 */ |
|
2186 LOCAL_C void MainL() |
|
2187 { |
|
2188 |
|
2189 // Construct and install active scheduler |
|
2190 CActiveScheduler* scheduler=new ( ELeave ) CActiveScheduler; |
|
2191 CleanupStack::PushL( scheduler ); |
|
2192 CActiveScheduler::Install( scheduler ); |
|
2193 |
|
2194 // Construct the console |
|
2195 CConsoleMain* mainConsole = CConsoleMain::NewL(); |
|
2196 CleanupStack::PushL( mainConsole ); |
|
2197 |
|
2198 // Start the console |
|
2199 mainConsole->StartL(); |
|
2200 |
|
2201 // Start handling requests |
|
2202 CActiveScheduler::Start(); |
|
2203 // Execution continues from here after CActiveScheduler::Stop() |
|
2204 |
|
2205 // Clean-up |
|
2206 CleanupStack::PopAndDestroy( mainConsole ); |
|
2207 CleanupStack::PopAndDestroy( scheduler ); |
|
2208 |
|
2209 } |
|
2210 |
|
2211 |
|
2212 /* |
|
2213 ------------------------------------------------------------------------------- |
|
2214 |
|
2215 Class: - |
|
2216 |
|
2217 Method: E32Main |
|
2218 |
|
2219 Description: The main function. Execution starts from here. |
|
2220 Create clean-up stack and trap the MainL function which does the |
|
2221 real work. |
|
2222 |
|
2223 Parameters: None |
|
2224 |
|
2225 Return Values: TInt Error code |
|
2226 |
|
2227 Errors/Exceptions: None |
|
2228 |
|
2229 Status: Draft |
|
2230 |
|
2231 ------------------------------------------------------------------------------- |
|
2232 */ |
|
2233 GLDEF_C TInt E32Main() |
|
2234 { |
|
2235 |
|
2236 __UHEAP_MARK; |
|
2237 |
|
2238 // Get clean-up stack |
|
2239 CTrapCleanup* cleanup=CTrapCleanup::New(); |
|
2240 |
|
2241 // Call the main function |
|
2242 TRAPD( error, MainL() ); |
|
2243 |
|
2244 // Clean-up |
|
2245 delete cleanup; |
|
2246 cleanup = NULL; |
|
2247 |
|
2248 __UHEAP_MARKEND; |
|
2249 |
|
2250 return error; |
|
2251 |
|
2252 } |
|
2253 |
|
2254 #if defined(__WINS__) |
|
2255 /* |
|
2256 ------------------------------------------------------------------------------- |
|
2257 |
|
2258 Class: - |
|
2259 |
|
2260 Method: WinsMain |
|
2261 |
|
2262 Description: The WinsMain function. |
|
2263 |
|
2264 Parameters: None |
|
2265 |
|
2266 Return Values: TInt Error code |
|
2267 |
|
2268 Errors/Exceptions: None |
|
2269 |
|
2270 Status: Draft |
|
2271 |
|
2272 ------------------------------------------------------------------------------- |
|
2273 */ |
|
2274 EXPORT_C TInt WinsMain() |
|
2275 { |
|
2276 E32Main(); |
|
2277 return KErrNone; |
|
2278 } |
|
2279 |
|
2280 #endif // __WINS__ |
|
2281 |
|
2282 // End of File |