|
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 |
|
15 * CMenu-derived classes. |
|
16 * |
|
17 */ |
|
18 |
|
19 // INCLUDE FILES |
|
20 #include <e32base.h> |
|
21 #include <e32cons.h> |
|
22 #include <e32svr.h> |
|
23 |
|
24 #include <f32file.h> |
|
25 #include <stifinternal/UIEngineContainer.h> |
|
26 |
|
27 #include "ConsoleUI.h" |
|
28 #include "ConsoleMenus.h" |
|
29 |
|
30 // EXTERNAL DATA STRUCTURES |
|
31 |
|
32 // EXTERNAL FUNCTION PROTOTYPES |
|
33 |
|
34 // CONSTANTS |
|
35 |
|
36 // MACROS |
|
37 |
|
38 // LOCAL CONSTANTS AND MACROS |
|
39 |
|
40 // MODULE DATA STRUCTURES |
|
41 |
|
42 // LOCAL FUNCTION PROTOTYPES |
|
43 LOCAL_C void LimitedAppend( TDes& aOriginal, const TDesC& aAppend); |
|
44 |
|
45 // FORWARD DECLARATIONS |
|
46 |
|
47 // ==================== LOCAL FUNCTIONS ======================================= |
|
48 |
|
49 LOCAL_C void LimitedAppend( TDes& aOriginal, const TDesC& aAppend) |
|
50 { |
|
51 |
|
52 TInt spaceLeft = aOriginal.MaxLength() - aOriginal.Length(); |
|
53 |
|
54 if (spaceLeft > aAppend.Length()) |
|
55 { |
|
56 aOriginal.Append ( aAppend ); |
|
57 } |
|
58 else |
|
59 { |
|
60 aOriginal.Append ( aAppend.Left ( spaceLeft ) ); |
|
61 } |
|
62 |
|
63 } |
|
64 |
|
65 // None |
|
66 |
|
67 // ================= MEMBER FUNCTIONS ========================================= |
|
68 |
|
69 |
|
70 /* |
|
71 ------------------------------------------------------------------------------- |
|
72 |
|
73 Class: CMenu |
|
74 |
|
75 Method: NewL |
|
76 |
|
77 Description: Constructs new menu. |
|
78 |
|
79 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
80 CMenu* aParent :in: Parent menu |
|
81 const TDesC& aName :in: Menu name |
|
82 |
|
83 Return Values: CMenu* New menu |
|
84 |
|
85 Errors/Exceptions: Leaves if memory allocation fails |
|
86 Leaves if ConstructL leaves. |
|
87 |
|
88 Status: Draft |
|
89 |
|
90 ------------------------------------------------------------------------------- |
|
91 */ |
|
92 CMenu* CMenu::NewL( CConsoleMain* aConsole, |
|
93 CMenu* aParent, |
|
94 const TDesC& aName |
|
95 ) |
|
96 { |
|
97 |
|
98 CMenu* self = new ( ELeave ) CMenu(); |
|
99 CleanupStack::PushL( self ); |
|
100 self->ConstructL( aConsole, aParent, aName ); |
|
101 CleanupStack::Pop( self ); |
|
102 return self; |
|
103 |
|
104 } |
|
105 |
|
106 /* |
|
107 ------------------------------------------------------------------------------- |
|
108 |
|
109 Class: CMenu |
|
110 |
|
111 Method: ConstructL |
|
112 |
|
113 Description: Second level constructor. |
|
114 |
|
115 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
116 CMenu* aParent :in: Parent menu |
|
117 const TDesC& aName :in: Menu name |
|
118 const TDesC& aHeader :in: Text containing STIF version info |
|
119 |
|
120 Return Values: None |
|
121 |
|
122 Errors/Exceptions: None |
|
123 |
|
124 Status: Draft |
|
125 |
|
126 ------------------------------------------------------------------------------- |
|
127 */ |
|
128 void CMenu::ConstructL( CConsoleMain* aConsole, |
|
129 CMenu* aParent, |
|
130 const TDesC& aName, |
|
131 const TDesC& aHeader |
|
132 ) |
|
133 { |
|
134 |
|
135 // Store the parameters |
|
136 iMain = aConsole; |
|
137 iConsole = aConsole->GetConsole(); |
|
138 iParent = aParent; |
|
139 iName = aName; |
|
140 iHeader = aHeader; |
|
141 |
|
142 // Get display size |
|
143 const TInt KOverHead = 5; |
|
144 iSize = iConsole->ScreenSize(); |
|
145 iScreenSize = iSize.iHeight - KOverHead; // Size available for menus |
|
146 |
|
147 } |
|
148 |
|
149 /* |
|
150 ------------------------------------------------------------------------------- |
|
151 |
|
152 Class: CMenu |
|
153 |
|
154 Method: CMenu |
|
155 |
|
156 Description: Constructor |
|
157 |
|
158 Parameters: None |
|
159 |
|
160 Return Values: None |
|
161 |
|
162 Errors/Exceptions: None |
|
163 |
|
164 Status: Draft |
|
165 |
|
166 ------------------------------------------------------------------------------- |
|
167 */ |
|
168 CMenu::CMenu() |
|
169 { |
|
170 iDirection = 1; |
|
171 iPrevPos = -1; // Invalid starting value |
|
172 } |
|
173 |
|
174 /* |
|
175 ------------------------------------------------------------------------------- |
|
176 |
|
177 Class: CMenu |
|
178 |
|
179 Method: ~CMenu |
|
180 |
|
181 Description: Destructor |
|
182 |
|
183 Parameters: None |
|
184 |
|
185 Return Values: None |
|
186 |
|
187 Errors/Exceptions: None |
|
188 |
|
189 Status: Draft |
|
190 |
|
191 ------------------------------------------------------------------------------- |
|
192 */ |
|
193 CMenu::~CMenu() |
|
194 { |
|
195 |
|
196 iItems.ResetAndDestroy(); |
|
197 |
|
198 } |
|
199 |
|
200 /* |
|
201 ------------------------------------------------------------------------------- |
|
202 |
|
203 Class: CMenu |
|
204 |
|
205 Method: TimerUpdate |
|
206 |
|
207 Description: TimerUpdate |
|
208 |
|
209 Parameters: None |
|
210 |
|
211 Return Values: None |
|
212 |
|
213 Errors/Exceptions: None |
|
214 |
|
215 Status: Draft |
|
216 |
|
217 ------------------------------------------------------------------------------- |
|
218 */ |
|
219 void CMenu::TimerUpdate() |
|
220 { |
|
221 |
|
222 RRefArray<TDesC> texts; |
|
223 User::LeaveIfError( ItemTexts( texts ) ); |
|
224 |
|
225 TInt count = texts.Count(); |
|
226 // If list is empty, do not scroll. |
|
227 if ( count < 1 ) |
|
228 { |
|
229 texts.Close(); |
|
230 return; |
|
231 } |
|
232 |
|
233 // Recalculate visible part of menu |
|
234 Recalculate( count ); |
|
235 |
|
236 // If menu selection is updated, then restart scrolling |
|
237 if (iPrevPos != iFirst + iPosOnScreen) |
|
238 { |
|
239 iPrevPos = iFirst + iPosOnScreen; |
|
240 iStart = 0; |
|
241 iDirection = 1; |
|
242 } |
|
243 |
|
244 |
|
245 // If menu item have not been changed after last timer, then |
|
246 // start scrolling |
|
247 const TDesC& name = texts[ iFirst + iPosOnScreen ]; |
|
248 if ( name.Length() > ( iSize.iWidth - KMenuOverhead ) ) |
|
249 { |
|
250 |
|
251 TInt y = iConsole->WhereY(); |
|
252 TInt x = iConsole->WhereX(); |
|
253 TBuf<80> iTmp; |
|
254 |
|
255 iStart = iStart + iDirection; |
|
256 |
|
257 // "Right end" |
|
258 if ( iStart + iSize.iWidth > name.Length() + KMenuOverhead ) |
|
259 { |
|
260 iStart--; |
|
261 iDirection = -1; |
|
262 } |
|
263 |
|
264 // "Left end" |
|
265 if ( iStart == -1 ) |
|
266 { |
|
267 iStart++; |
|
268 iDirection = 1; |
|
269 } |
|
270 |
|
271 if( iStart > name.Length() ) |
|
272 { |
|
273 iStart = 0; |
|
274 } |
|
275 |
|
276 iTmp=_L(" *"); |
|
277 LimitedAppend( iTmp, name.Mid ( iStart ) ); |
|
278 |
|
279 iConsole->SetPos( 0, iPosOnScreen+1); |
|
280 iConsole->Printf ( iTmp.Left( iSize.iWidth -2 ) ); |
|
281 |
|
282 iConsole->SetPos(x,y); |
|
283 } |
|
284 texts.Close(); |
|
285 |
|
286 } |
|
287 |
|
288 |
|
289 /* |
|
290 ------------------------------------------------------------------------------- |
|
291 Class: CMenu |
|
292 |
|
293 Method: AppendBefore |
|
294 |
|
295 Description: Append text before line. |
|
296 |
|
297 Parameters: TInt aLine: in: line number |
|
298 TDes& aLine: in: line text |
|
299 |
|
300 Return Values: None |
|
301 |
|
302 Errors/Exceptions: None |
|
303 |
|
304 Status: Draft |
|
305 |
|
306 ------------------------------------------------------------------------------- |
|
307 */ |
|
308 void CMenu::AppendBefore( TInt aLineNum, TDes& aLine ) |
|
309 { |
|
310 |
|
311 if( ( aLine.MaxLength() - aLine.Length() ) < 2 ) |
|
312 { |
|
313 return; |
|
314 } |
|
315 |
|
316 // If printing active line, print the marker |
|
317 if ( aLineNum == iPosOnScreen + iFirst ) |
|
318 { |
|
319 aLine.Append( _L(" *") ); |
|
320 } |
|
321 else |
|
322 { |
|
323 aLine.Append( _L(" ") ); |
|
324 } |
|
325 |
|
326 } |
|
327 |
|
328 /* |
|
329 ------------------------------------------------------------------------------- |
|
330 Class: CMenu |
|
331 |
|
332 Method: PrintMenuL |
|
333 |
|
334 Description: Prints the menu |
|
335 |
|
336 Parameters: None |
|
337 |
|
338 Return Values: None |
|
339 |
|
340 Errors/Exceptions: None |
|
341 |
|
342 Status: Draft |
|
343 |
|
344 ------------------------------------------------------------------------------- |
|
345 */ |
|
346 void CMenu::PrintMenuL( TUpdateType aType ) |
|
347 { |
|
348 |
|
349 iUpdateType = aType; |
|
350 |
|
351 TBuf<KMaxLineLength> line; |
|
352 |
|
353 //if we are moving between items located on the same page clearing screen is not needed |
|
354 if(!iPreventClearScreen) |
|
355 { |
|
356 // Clear display |
|
357 iConsole->ClearScreen(); |
|
358 |
|
359 //Print STIF version information, only when defined (i.e. in main menu) |
|
360 if(iHeader != _L("")) |
|
361 Print(iHeader); |
|
362 |
|
363 // Print menu title |
|
364 Print( Name() ); |
|
365 |
|
366 RRefArray<TDesC> texts; |
|
367 User::LeaveIfError( ItemTexts( texts ) ); |
|
368 |
|
369 // Recalculate visible part of menu |
|
370 Recalculate( texts.Count() ); |
|
371 |
|
372 //needed for setting cursor at correct line |
|
373 iMenuItemsListStartIndex = iConsole->CursorPos().iY; |
|
374 |
|
375 // Print items |
|
376 for ( TInt i = iFirst; i <= iLast; i++ ) |
|
377 { |
|
378 line.Zero(); |
|
379 |
|
380 // Append text before line |
|
381 AppendBefore( i, line ); |
|
382 |
|
383 // Get the menu line |
|
384 LimitedAppend ( line, texts[i] ); |
|
385 |
|
386 // Print the line |
|
387 Print(line); |
|
388 } |
|
389 texts.Close(); |
|
390 |
|
391 //needed for setting cursor at correct line |
|
392 iMenuItemsListEndIndex = iConsole->CursorPos().iY; |
|
393 } |
|
394 else |
|
395 { |
|
396 //removing "*" sign from the previous cursor position |
|
397 iConsole->SetPos(0, iPrevPosOnScreen + iMenuItemsListStartIndex); |
|
398 line.Append( _L(" ") ); |
|
399 iConsole->Printf(line); |
|
400 iConsole->SetPos(0, iPosOnScreen + iMenuItemsListStartIndex); |
|
401 line.Zero(); |
|
402 |
|
403 //writing "*" sign before the currently selected line |
|
404 line.Append( _L(" *") ); |
|
405 iConsole->Printf(line); |
|
406 iConsole->SetPos(0, iMenuItemsListEndIndex); |
|
407 iPreventClearScreen = EFalse; |
|
408 } |
|
409 } |
|
410 |
|
411 |
|
412 /* |
|
413 ------------------------------------------------------------------------------- |
|
414 |
|
415 Class: CMenu |
|
416 |
|
417 Method: SelectL |
|
418 |
|
419 Description: Process keypresses in menu. Either updates position in |
|
420 menu or returns new menu. |
|
421 |
|
422 Parameters: TKeyCode aSelection :in: Key |
|
423 TBool& aContinue :out: Has user pressed "Quit" |
|
424 |
|
425 Return Values: CMenu* New menu |
|
426 |
|
427 Errors/Exceptions: None |
|
428 |
|
429 Status: Draft |
|
430 |
|
431 ------------------------------------------------------------------------------- |
|
432 */ |
|
433 CMenu* CMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
434 { |
|
435 |
|
436 MapKeyCode(aSelection); |
|
437 |
|
438 switch ( (TInt) aSelection ) |
|
439 { |
|
440 |
|
441 // Exit |
|
442 case EKeyEscape: |
|
443 aContinue = EFalse; |
|
444 return this; |
|
445 // SelectL item |
|
446 case EKeyEnter: |
|
447 case EKeyRightArrow: |
|
448 return iItems[iPosOnScreen]; |
|
449 |
|
450 // Going back |
|
451 case EKeyLeftArrow: |
|
452 return iParent; |
|
453 |
|
454 // Go down |
|
455 case EKeyDownArrow: |
|
456 { |
|
457 if ( iFirst + iPosOnScreen == iItemCount - 1 ) |
|
458 { |
|
459 // If end of the list, go to beginning |
|
460 iPosOnScreen = 0; |
|
461 iFirst = 0; |
|
462 iLast = iScreenSize; |
|
463 if ( iLast > iItemCount - 1 ) |
|
464 { |
|
465 iLast = iItemCount - 1; |
|
466 } |
|
467 } |
|
468 else |
|
469 { |
|
470 if ( iPosOnScreen == iScreenSize ) |
|
471 { |
|
472 iPosOnScreen = 0; |
|
473 iFirst += iScreenSize + 1; |
|
474 iLast += iScreenSize + 1; |
|
475 } |
|
476 else |
|
477 { |
|
478 // Going down "in-screen", no need to update items |
|
479 iPrevPosOnScreen = iPosOnScreen; |
|
480 iPreventClearScreen = EFalse; |
|
481 if (iItemCount > 0) |
|
482 { |
|
483 iPosOnScreen++; |
|
484 iPreventClearScreen = ETrue; |
|
485 } |
|
486 } |
|
487 } |
|
488 break; |
|
489 } |
|
490 |
|
491 // Go Up |
|
492 case EKeyUpArrow: |
|
493 { |
|
494 // The second condition is needed for the cursor not to go to "next" page (if it does not exist) |
|
495 if ( iFirst + iPosOnScreen == 0 ) |
|
496 { |
|
497 // If in the beginning of the list |
|
498 if (iItemCount == iScreenSize + 1 || iItemCount == iScreenSize) |
|
499 { |
|
500 iPosOnScreen = iItemCount - 1; |
|
501 } |
|
502 else |
|
503 { |
|
504 iFirst = (iItemCount / iScreenSize) * iScreenSize; |
|
505 iLast = iItemCount - 1; |
|
506 iPosOnScreen = iItemCount % iScreenSize - 1; |
|
507 if (iItemCount > iScreenSize) |
|
508 { |
|
509 iFirst++; |
|
510 iPosOnScreen--; |
|
511 } |
|
512 } |
|
513 } |
|
514 else if ( iPosOnScreen == 0 ) |
|
515 { |
|
516 iPosOnScreen = iScreenSize; |
|
517 iLast -= iScreenSize + 1; |
|
518 iFirst -= iScreenSize + 1; |
|
519 } |
|
520 else |
|
521 { |
|
522 iPrevPosOnScreen = iPosOnScreen; |
|
523 iPosOnScreen--; |
|
524 iPreventClearScreen = ETrue; |
|
525 } |
|
526 |
|
527 break; |
|
528 } |
|
529 |
|
530 // Additional keys |
|
531 case EKeyHome: |
|
532 case '3': |
|
533 iPosOnScreen = 0; |
|
534 iFirst = 0; |
|
535 iLast = iScreenSize; |
|
536 |
|
537 if ( iLast > iItemCount - 1 ) |
|
538 { |
|
539 iLast = iItemCount - 1; |
|
540 } |
|
541 break; |
|
542 |
|
543 case EKeyEnd: |
|
544 case '9': |
|
545 iLast = iItemCount - 1; |
|
546 iFirst = iLast - iScreenSize; |
|
547 |
|
548 if ( iFirst < 0 ) |
|
549 { |
|
550 iFirst = 0; |
|
551 } |
|
552 iPosOnScreen = iLast - iFirst; |
|
553 break; |
|
554 |
|
555 case EKeyPageUp: |
|
556 case '1': |
|
557 |
|
558 iFirst = iFirst - iScreenSize; |
|
559 iLast = iLast - iScreenSize; |
|
560 |
|
561 if ( iFirst < 0 ) |
|
562 { |
|
563 iFirst = 0; |
|
564 iPosOnScreen = 0; |
|
565 iLast = iScreenSize; |
|
566 if ( iLast > iItemCount - 1 ) |
|
567 { |
|
568 iLast = iItemCount - 1; |
|
569 } |
|
570 } |
|
571 break; |
|
572 |
|
573 case EKeyPageDown: |
|
574 case '7': |
|
575 iFirst = iFirst + iScreenSize; |
|
576 iLast = iLast + iScreenSize; |
|
577 |
|
578 // Going too far |
|
579 if ( iLast > iItemCount - 1 ) |
|
580 { |
|
581 iLast = iItemCount - 1; |
|
582 iFirst = iLast - iScreenSize; |
|
583 if ( iFirst < 0 ) |
|
584 { |
|
585 iFirst = 0; |
|
586 } |
|
587 } |
|
588 iPosOnScreen = iLast - iFirst; |
|
589 break; |
|
590 default: // Bypass the keypress |
|
591 break; |
|
592 } |
|
593 |
|
594 // Continue normally and keep in the same menu |
|
595 aContinue = ETrue; |
|
596 return this; |
|
597 |
|
598 } |
|
599 |
|
600 /* |
|
601 ------------------------------------------------------------------------------- |
|
602 |
|
603 Class: CMenu |
|
604 |
|
605 Method: ItemText |
|
606 |
|
607 Description: Returns menu item text |
|
608 |
|
609 Parameters: const TInt :in: Menu index |
|
610 |
|
611 Return Values: const TDesC& Menu line text |
|
612 |
|
613 Errors/Exceptions: None |
|
614 |
|
615 Status: Draft |
|
616 |
|
617 ------------------------------------------------------------------------------- |
|
618 */ |
|
619 TInt CMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
620 { |
|
621 |
|
622 TInt count = iItems.Count(); |
|
623 for( TInt i=0; i<count; i++ ) |
|
624 { |
|
625 if( aArray.Append( iItems[i]->Name() ) != KErrNone ) |
|
626 { |
|
627 return KErrNoMemory; |
|
628 } |
|
629 } |
|
630 |
|
631 return KErrNone; |
|
632 |
|
633 } |
|
634 |
|
635 /* |
|
636 ------------------------------------------------------------------------------- |
|
637 |
|
638 Class: CMenu |
|
639 |
|
640 Method: SetParent |
|
641 |
|
642 Description: Sets menu parent menu. |
|
643 |
|
644 Parameters: CMenu* aMenu :in: Menu parent |
|
645 |
|
646 Return Values: None |
|
647 |
|
648 Errors/Exceptions: None |
|
649 |
|
650 Status: Draft |
|
651 |
|
652 ------------------------------------------------------------------------------- |
|
653 */ |
|
654 void CMenu::SetParent ( CMenu* aMenu ) |
|
655 { |
|
656 |
|
657 iParent = aMenu; |
|
658 |
|
659 } |
|
660 |
|
661 /* |
|
662 ------------------------------------------------------------------------------- |
|
663 |
|
664 Class: CMenu |
|
665 |
|
666 Method: Print |
|
667 |
|
668 Description: Prints one line text and changes to next line. If line is |
|
669 too long, overhead is not printed.. |
|
670 |
|
671 Parameters: None |
|
672 |
|
673 Return Values: None |
|
674 |
|
675 Errors/Exceptions: None |
|
676 |
|
677 Status: Draft |
|
678 |
|
679 ------------------------------------------------------------------------------- |
|
680 */ |
|
681 void CMenu::Print( const TDesC& aPrint ) |
|
682 { |
|
683 |
|
684 iConsole->Printf ( aPrint.Left( iSize.iWidth - KMenuOverhead ) ); |
|
685 iConsole->Printf(_L("\n")); |
|
686 |
|
687 } |
|
688 |
|
689 /* |
|
690 ------------------------------------------------------------------------------- |
|
691 |
|
692 Class: CMenu |
|
693 |
|
694 Method: PrintMulti |
|
695 |
|
696 Description: Prints text. If line is too long, it will be continued to |
|
697 following lines. |
|
698 |
|
699 Parameters: const TDesC& aPrint :in: Text to print |
|
700 |
|
701 Return Values: None |
|
702 |
|
703 Errors/Exceptions: None |
|
704 |
|
705 Status: Draft |
|
706 |
|
707 ------------------------------------------------------------------------------- |
|
708 */ |
|
709 void CMenu::PrintMulti( const TDesC& aPrint ) |
|
710 { |
|
711 |
|
712 // Get current line |
|
713 const TInt KMenuOverHead = 2; |
|
714 TInt y = iConsole->WhereY(); |
|
715 |
|
716 const TInt KLineLen =iSize.iWidth -4; |
|
717 TBuf<KMaxLineLength+1> oneLine; |
|
718 |
|
719 // Loop through the line |
|
720 for (TInt i = 0; i < aPrint.Length(); i++) |
|
721 { |
|
722 oneLine.Append( aPrint[i] ); |
|
723 |
|
724 // Print one line |
|
725 if (oneLine.Length() == KLineLen ) |
|
726 { |
|
727 oneLine.Append (_L("\n")); |
|
728 iConsole->Printf(oneLine); |
|
729 oneLine=_L(""); |
|
730 y++; |
|
731 } |
|
732 |
|
733 // Prevent display scrolling |
|
734 if ( y == iScreenSize + KMenuOverHead ) |
|
735 { |
|
736 oneLine=_L(""); |
|
737 break; |
|
738 } |
|
739 } |
|
740 |
|
741 // Print last part if required |
|
742 if ( oneLine.Length() != 0 ) |
|
743 { |
|
744 oneLine.Append (_L("\n")); |
|
745 iConsole->Printf(oneLine); |
|
746 } |
|
747 |
|
748 } |
|
749 |
|
750 /* |
|
751 ------------------------------------------------------------------------------- |
|
752 |
|
753 Class: CMenu |
|
754 |
|
755 Method: AddItem |
|
756 |
|
757 Description: Add new item to menu |
|
758 |
|
759 Parameters: CMenu* aMenu :in: Menu to be added |
|
760 |
|
761 Return Values: None |
|
762 |
|
763 Errors/Exceptions: Leaves if can't add item to menu |
|
764 |
|
765 Status: Draft |
|
766 |
|
767 ------------------------------------------------------------------------------- |
|
768 */ |
|
769 void CMenu::AddItemL( CMenu* aMenu ) |
|
770 { |
|
771 |
|
772 User::LeaveIfError ( iItems.Append (aMenu) ); |
|
773 |
|
774 } |
|
775 |
|
776 |
|
777 /* |
|
778 ------------------------------------------------------------------------------- |
|
779 |
|
780 Class: CMenu |
|
781 |
|
782 Method: Name |
|
783 |
|
784 Description: Returns menu name |
|
785 |
|
786 Parameters: None |
|
787 |
|
788 Return Values: const TDesC& Menu name |
|
789 |
|
790 Errors/Exceptions: None |
|
791 |
|
792 Status: Draft |
|
793 |
|
794 ------------------------------------------------------------------------------- |
|
795 */ |
|
796 const TDesC& CMenu::Name( ) const |
|
797 { |
|
798 |
|
799 return iName; |
|
800 |
|
801 } |
|
802 |
|
803 /* |
|
804 ------------------------------------------------------------------------------- |
|
805 |
|
806 Class: CMenu |
|
807 |
|
808 Method: MapKeyCode |
|
809 |
|
810 Description: Maps numeric keycodes to proper TKeyCode values |
|
811 |
|
812 Parameters: TKeyCode |
|
813 |
|
814 Return Values: None |
|
815 |
|
816 Errors/Exceptions: None |
|
817 |
|
818 Status: Draft |
|
819 |
|
820 ------------------------------------------------------------------------------- |
|
821 */ |
|
822 |
|
823 void CMenu::MapKeyCode(TKeyCode &aSelection) |
|
824 { |
|
825 |
|
826 TInt asciiCode = (TInt) aSelection; |
|
827 |
|
828 // Handling numeric keys 2,4,6 and 8 |
|
829 |
|
830 if(asciiCode == KMyKeyUpAsciiCode) |
|
831 { |
|
832 aSelection = EKeyUpArrow; |
|
833 } |
|
834 |
|
835 if(asciiCode == KMyKeyLeftAsciiCode) |
|
836 { |
|
837 aSelection = EKeyLeftArrow; |
|
838 } |
|
839 |
|
840 if(asciiCode == KMyKeyRightAsciiCode) |
|
841 { |
|
842 aSelection = EKeyEnter; |
|
843 } |
|
844 |
|
845 if(asciiCode == KMyKeyDownAsciiCode) |
|
846 { |
|
847 aSelection = EKeyDownArrow; |
|
848 } |
|
849 } |
|
850 |
|
851 /* |
|
852 ------------------------------------------------------------------------------- |
|
853 |
|
854 Class: CMenu |
|
855 |
|
856 Method: Recalculate |
|
857 |
|
858 Description: Recalculates visible menu elements |
|
859 |
|
860 Parameters: TInt aItemCount :in: Menu items count |
|
861 |
|
862 Return Values: None |
|
863 |
|
864 Errors/Exceptions: None |
|
865 |
|
866 Status: Approved |
|
867 |
|
868 ------------------------------------------------------------------------------- |
|
869 */ |
|
870 void CMenu::Recalculate( TInt aItemCount ) |
|
871 { |
|
872 TInt oldItemCount = iItemCount; |
|
873 |
|
874 iItemCount = aItemCount; |
|
875 |
|
876 // If first time in menu, update start and end positions |
|
877 if ( ( iFirst == 0 ) && ( iLast == 0 ) || (iItemCount == 0)) //if there are no items, update start and end positions too |
|
878 { |
|
879 if ( iItemCount - 1 > iScreenSize ) |
|
880 { |
|
881 iLast = iScreenSize; |
|
882 } |
|
883 else |
|
884 { |
|
885 iLast = iItemCount - 1; |
|
886 } |
|
887 iPosOnScreen = 0; |
|
888 } |
|
889 // New menu entry added, update last visible element if needed |
|
890 else if ( oldItemCount < iItemCount ) |
|
891 { |
|
892 if ( iFirst + iScreenSize < iItemCount ) |
|
893 { |
|
894 iLast = iFirst + iScreenSize; |
|
895 } |
|
896 else |
|
897 { |
|
898 iLast = iItemCount - 1; |
|
899 } |
|
900 } |
|
901 // Menu entry removed, update last visible element if needed |
|
902 else if ( oldItemCount > iItemCount ) |
|
903 { |
|
904 if ( iFirst + iScreenSize < iItemCount ) |
|
905 { |
|
906 iLast = iFirst + iScreenSize; |
|
907 } |
|
908 else if ( iFirst > iItemCount - 1 ) |
|
909 { |
|
910 iFirst = iItemCount - 1 - iScreenSize; |
|
911 if ( iFirst < 0 ) |
|
912 { |
|
913 iFirst = 0; |
|
914 } |
|
915 iLast = iItemCount - 1; |
|
916 iPosOnScreen = iFirst - iLast; |
|
917 } |
|
918 else |
|
919 { |
|
920 iLast = iItemCount - 1; |
|
921 } |
|
922 |
|
923 if ( iFirst + iPosOnScreen > iLast ) |
|
924 { |
|
925 iPosOnScreen = iLast - iFirst; |
|
926 } |
|
927 } |
|
928 |
|
929 if (iFirst < 0) |
|
930 { |
|
931 iFirst = 0; |
|
932 } |
|
933 if (iLast > iItemCount) |
|
934 { |
|
935 iLast = iItemCount - 1; |
|
936 } |
|
937 if ( iFirst + iScreenSize < iItemCount ) |
|
938 { |
|
939 iLast = iFirst + iScreenSize; |
|
940 } |
|
941 } |
|
942 |
|
943 /* |
|
944 ------------------------------------------------------------------------------- |
|
945 |
|
946 Class: CFileNameQueryView |
|
947 |
|
948 Method: NewL |
|
949 |
|
950 Description: Constructs new menu. |
|
951 |
|
952 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
953 CMenu* aParent :in: Parent menu |
|
954 const TDesC& aName :in: Menu name |
|
955 |
|
956 Return Values: CMenu* New menu |
|
957 |
|
958 Errors/Exceptions: Leaves if memory allocation fails |
|
959 Leaves if ConstructL leaves. |
|
960 |
|
961 Status: Draft |
|
962 |
|
963 ------------------------------------------------------------------------------- |
|
964 */ |
|
965 CFileNameQueryView* CFileNameQueryView::NewL( CConsoleMain* aConsole, |
|
966 CMenu* aParent, |
|
967 const TDesC& aName ) |
|
968 { |
|
969 |
|
970 CFileNameQueryView* self = new ( ELeave ) CFileNameQueryView(); |
|
971 CleanupStack::PushL( self ); |
|
972 self->ConstructL( aConsole, aParent, aName ); |
|
973 CleanupStack::Pop( self ); |
|
974 return self; |
|
975 |
|
976 } |
|
977 |
|
978 /* |
|
979 ------------------------------------------------------------------------------- |
|
980 |
|
981 Class: CFileNameQueryView |
|
982 |
|
983 Method: ConstructL |
|
984 |
|
985 Description: Second level constructor. |
|
986 |
|
987 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
988 CMenu* aParent :in: Parent menu |
|
989 const TDesC& aName :in: Menu name |
|
990 |
|
991 Return Values: None |
|
992 |
|
993 Errors/Exceptions: None |
|
994 |
|
995 Status: Draft |
|
996 |
|
997 ------------------------------------------------------------------------------- |
|
998 */ |
|
999 void CFileNameQueryView::ConstructL( CConsoleMain* aConsole, |
|
1000 CMenu* aParent, |
|
1001 const TDesC& aName |
|
1002 ) |
|
1003 { |
|
1004 |
|
1005 CMenu::ConstructL( aConsole, aParent, aName); |
|
1006 |
|
1007 } |
|
1008 |
|
1009 /* |
|
1010 ------------------------------------------------------------------------------- |
|
1011 |
|
1012 Class: CFileNameQueryView |
|
1013 |
|
1014 Method: ~CFileNameQueryView |
|
1015 |
|
1016 Description: Destructor |
|
1017 |
|
1018 Parameters: None |
|
1019 |
|
1020 Return Values: None |
|
1021 |
|
1022 Errors/Exceptions: None |
|
1023 |
|
1024 Status: Draft |
|
1025 |
|
1026 ------------------------------------------------------------------------------- |
|
1027 */ |
|
1028 CFileNameQueryView::~CFileNameQueryView() |
|
1029 { |
|
1030 |
|
1031 iTestModuleNames.ResetAndDestroy(); |
|
1032 iTestModuleNames.Close(); |
|
1033 |
|
1034 } |
|
1035 |
|
1036 /* |
|
1037 ------------------------------------------------------------------------------- |
|
1038 |
|
1039 Class: CFileNameQueryView |
|
1040 |
|
1041 Method: ItemText |
|
1042 |
|
1043 Description: Returns menu item text. |
|
1044 |
|
1045 Parameters: const TInt :in: Menu index |
|
1046 |
|
1047 Return Values: const TDesC& Menu line text |
|
1048 |
|
1049 Errors/Exceptions: None |
|
1050 |
|
1051 Status: Draft |
|
1052 |
|
1053 ------------------------------------------------------------------------------- |
|
1054 */ |
|
1055 TInt CFileNameQueryView::ItemTexts( RRefArray<TDesC>& aArray ) |
|
1056 { |
|
1057 |
|
1058 iTestModuleNames.ResetAndDestroy(); |
|
1059 |
|
1060 // Add loaded module names to menu |
|
1061 TInt ret = iMain->UIStore().ListAllModules( iTestModuleNames ); |
|
1062 |
|
1063 if( ret != KErrNone ) |
|
1064 { |
|
1065 return ret; |
|
1066 } |
|
1067 |
|
1068 TInt count = iTestModuleNames.Count(); |
|
1069 for( TInt i=0; i<count; i++ ) |
|
1070 { |
|
1071 if( aArray.Append( *iTestModuleNames[i] ) != KErrNone ) |
|
1072 { |
|
1073 return KErrNoMemory; |
|
1074 } |
|
1075 } |
|
1076 |
|
1077 return KErrNone; |
|
1078 |
|
1079 } |
|
1080 |
|
1081 /* |
|
1082 ------------------------------------------------------------------------------- |
|
1083 |
|
1084 Class: CFileNameQueryView |
|
1085 |
|
1086 Method: SelectL |
|
1087 |
|
1088 Description: Process keypresses in menu. Just return the parent menu |
|
1089 |
|
1090 Parameters: TKeyCode aSelection :in: Not used |
|
1091 TBool& aContinue :out: Has user pressed "Quit"? |
|
1092 |
|
1093 Return Values: CMenu* New menu |
|
1094 |
|
1095 Errors/Exceptions: None |
|
1096 |
|
1097 Status: Draft |
|
1098 |
|
1099 ------------------------------------------------------------------------------- |
|
1100 */ |
|
1101 CMenu* CFileNameQueryView::SelectL( TKeyCode aSelection, |
|
1102 TBool& aContinue ) |
|
1103 { |
|
1104 |
|
1105 MapKeyCode(aSelection); |
|
1106 |
|
1107 if (aSelection == EKeyEnter || aSelection == EKeyRightArrow ) |
|
1108 { |
|
1109 if( iPosOnScreen < iTestModuleNames.Count() ) |
|
1110 { |
|
1111 TInt ret = |
|
1112 iMain->UIStore().AddTestModule( *iTestModuleNames[iPosOnScreen] ); |
|
1113 if( ret != KErrNone ) |
|
1114 { |
|
1115 TErrorNotification error; |
|
1116 error.iModule.Copy( _L("ConsoleUI") ); |
|
1117 error.iText.Copy( _L("Failed to load test module ") ); |
|
1118 error.iText.Append( *iTestModuleNames[iPosOnScreen] ); |
|
1119 error.iText.Append( _L(" error ")); |
|
1120 error.iText.AppendNum( ret ); |
|
1121 iMain->Error( error ); |
|
1122 } |
|
1123 return iParent; |
|
1124 } |
|
1125 else |
|
1126 { |
|
1127 return this; |
|
1128 } |
|
1129 } |
|
1130 |
|
1131 return CMenu::SelectL( aSelection, aContinue ); |
|
1132 |
|
1133 } |
|
1134 |
|
1135 |
|
1136 /* |
|
1137 ------------------------------------------------------------------------------- |
|
1138 |
|
1139 Class: CMainMenu |
|
1140 |
|
1141 Method: NewL |
|
1142 |
|
1143 Description: Constructs new menu. |
|
1144 |
|
1145 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
1146 CMenu* aParent :in: Parent menu |
|
1147 const TDesC& aName :in: Menu name |
|
1148 const TDesC& aHeader :in: Text containing STIF version information |
|
1149 |
|
1150 Return Values: CMenu* New menu |
|
1151 |
|
1152 Errors/Exceptions: Leaves if memory allocation fails |
|
1153 Leaves if ConstructL leaves. |
|
1154 |
|
1155 Status: Draft |
|
1156 |
|
1157 ------------------------------------------------------------------------------- |
|
1158 */ |
|
1159 CMainMenu* CMainMenu::NewL( CConsoleMain* aConsole, |
|
1160 CMenu* aParent, |
|
1161 const TDesC& aName, |
|
1162 const TDesC& aHeader) |
|
1163 { |
|
1164 |
|
1165 CMainMenu* self = new ( ELeave ) CMainMenu(); |
|
1166 CleanupStack::PushL( self ); |
|
1167 self->ConstructL( aConsole, aParent, aName, aHeader ); |
|
1168 CleanupStack::Pop( self ); |
|
1169 return self; |
|
1170 |
|
1171 } |
|
1172 |
|
1173 /* |
|
1174 ------------------------------------------------------------------------------- |
|
1175 |
|
1176 CMainMenu |
|
1177 |
|
1178 Method: ~CMainMenu |
|
1179 |
|
1180 Description: Destructor |
|
1181 |
|
1182 Parameters: None |
|
1183 |
|
1184 Return Values: None |
|
1185 |
|
1186 Errors/Exceptions: None |
|
1187 |
|
1188 Status: Draft |
|
1189 |
|
1190 ------------------------------------------------------------------------------- |
|
1191 */ |
|
1192 CMainMenu::~CMainMenu() |
|
1193 { |
|
1194 delete iOutputView; |
|
1195 iOutputView = NULL; |
|
1196 delete iOperationMenu; |
|
1197 iOperationMenu = NULL; |
|
1198 } |
|
1199 |
|
1200 /* |
|
1201 ------------------------------------------------------------------------------- |
|
1202 |
|
1203 Class: CMainMenu |
|
1204 |
|
1205 Method: ItemText |
|
1206 |
|
1207 Description: Returns menu item text. Add "Exit" to normal SelectLion |
|
1208 |
|
1209 Parameters: const TInt :in: Menu index |
|
1210 |
|
1211 Return Values: const TDesC& Menu line text |
|
1212 |
|
1213 Errors/Exceptions: None |
|
1214 |
|
1215 Status: Draft |
|
1216 |
|
1217 ------------------------------------------------------------------------------- |
|
1218 */ |
|
1219 TInt CMainMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
1220 { |
|
1221 |
|
1222 TInt ret = CMenu::ItemTexts( aArray ); |
|
1223 if ( ret != KErrNone ) |
|
1224 { |
|
1225 return ret; |
|
1226 } |
|
1227 // Add Exit to last one in menu |
|
1228 if( aArray.Append( KExitTxt ) != KErrNone ) |
|
1229 { |
|
1230 return KErrNoMemory; |
|
1231 } |
|
1232 |
|
1233 return KErrNone; |
|
1234 } |
|
1235 |
|
1236 /* |
|
1237 ------------------------------------------------------------------------------- |
|
1238 |
|
1239 Class: CMainMenu |
|
1240 |
|
1241 Method: ConstructL |
|
1242 |
|
1243 Description: Second level constructor. |
|
1244 |
|
1245 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
1246 CMenu* aParent :in: Parent menu |
|
1247 const TDesC& aName :in: Menu name |
|
1248 const TDesC& aHeader :in: Text containing STIF version information |
|
1249 |
|
1250 Return Values: None |
|
1251 |
|
1252 Errors/Exceptions: None |
|
1253 |
|
1254 Status: Draft |
|
1255 |
|
1256 ------------------------------------------------------------------------------- |
|
1257 */ |
|
1258 void CMainMenu::ConstructL( CConsoleMain* aConsole, |
|
1259 CMenu* aParent, |
|
1260 const TDesC& aName, |
|
1261 const TDesC& aHeader |
|
1262 ) |
|
1263 { |
|
1264 CMenu::ConstructL( aConsole, aParent, aName, aHeader); |
|
1265 iOutputView = NULL; |
|
1266 iOperationMenu = NULL; |
|
1267 } |
|
1268 |
|
1269 /* |
|
1270 ------------------------------------------------------------------------------- |
|
1271 |
|
1272 Class: CMainMenu |
|
1273 |
|
1274 Method: SelectL |
|
1275 |
|
1276 Description: Process keypresses in menu. Handle SelectLion in this |
|
1277 method, other keys are handles in CMenu class. |
|
1278 |
|
1279 Parameters: TKeyCode aSelection :in: Key |
|
1280 TBool& aContinue :out: Has user pressed "Quit" |
|
1281 |
|
1282 Return Values: CMenu* New menu |
|
1283 |
|
1284 Errors/Exceptions: None |
|
1285 |
|
1286 Status: Draft |
|
1287 |
|
1288 ------------------------------------------------------------------------------- |
|
1289 */ |
|
1290 CMenu* CMainMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
1291 { |
|
1292 |
|
1293 MapKeyCode(aSelection); |
|
1294 |
|
1295 // If SelectLion == "exit" and right or enter |
|
1296 if (aSelection == EKeyEnter || aSelection == EKeyRightArrow ) |
|
1297 { |
|
1298 if ( iPosOnScreen == iItemCount-1 ) |
|
1299 { |
|
1300 // Exit |
|
1301 aContinue = EFalse; |
|
1302 return this; |
|
1303 } |
|
1304 } |
|
1305 |
|
1306 // Normal menu handling |
|
1307 CMenu* tmp = CMenu::SelectL(aSelection, aContinue); |
|
1308 return tmp; |
|
1309 |
|
1310 } |
|
1311 |
|
1312 /* |
|
1313 ------------------------------------------------------------------------------- |
|
1314 |
|
1315 Class: CMainMenu |
|
1316 |
|
1317 Method: CreateOutputViewL |
|
1318 |
|
1319 Description: Creates test case output view. |
|
1320 |
|
1321 Parameters: CMenu* aParent: parent menu for case operation menu |
|
1322 |
|
1323 Return Values: CMenu* New menu |
|
1324 |
|
1325 Errors/Exceptions: Leaves is CCaseExecutionView menu leaves during creation |
|
1326 |
|
1327 Status: Draft |
|
1328 |
|
1329 ------------------------------------------------------------------------------- |
|
1330 */ |
|
1331 CMenu* CMainMenu::CreateOutputViewL(CMenu* aParent) |
|
1332 { |
|
1333 // Get test cases that have been run |
|
1334 RRefArray<CStartedTestCase> startedTestCases; |
|
1335 CleanupClosePushL(startedTestCases); |
|
1336 CMenu* res = NULL; |
|
1337 |
|
1338 startedTestCases.Reset(); |
|
1339 if(iMain->UIStore().StartedTestCases(startedTestCases, CUIStoreIf::EStatusAll) == KErrNone) |
|
1340 { |
|
1341 TInt count = startedTestCases.Count(); |
|
1342 if(count > 0) |
|
1343 { |
|
1344 // Create menu with execution info |
|
1345 const CStartedTestCase* caseContainer = &startedTestCases[count - 1]; |
|
1346 delete iOutputView; |
|
1347 iOutputView = NULL; |
|
1348 delete iOperationMenu; |
|
1349 iOperationMenu = NULL; |
|
1350 |
|
1351 iOperationMenu = CCaseOperationMenu::NewL(iMain, |
|
1352 aParent, //back to parent menu |
|
1353 caseContainer->TestInfo().TestCaseTitle(), |
|
1354 caseContainer |
|
1355 ); |
|
1356 |
|
1357 iOutputView = CCaseExecutionView::NewL(iMain, |
|
1358 iOperationMenu, //back to Case Operation Menu |
|
1359 caseContainer->TestInfo().TestCaseTitle(), |
|
1360 caseContainer |
|
1361 ); |
|
1362 res = iOutputView; |
|
1363 } |
|
1364 } |
|
1365 |
|
1366 CleanupStack::PopAndDestroy(&startedTestCases); |
|
1367 return res; |
|
1368 } |
|
1369 |
|
1370 /* |
|
1371 ------------------------------------------------------------------------------- |
|
1372 |
|
1373 Class: CModuleListView |
|
1374 |
|
1375 Method: NewL |
|
1376 |
|
1377 Description: Constructs new menu. |
|
1378 |
|
1379 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
1380 CMenu* aParent :in: Parent menu |
|
1381 const TDesC& aName :in: Menu name |
|
1382 |
|
1383 Return Values: CMenu* New menu |
|
1384 |
|
1385 Errors/Exceptions: Leaves if memory allocation fails |
|
1386 Leaves if ConstructL leaves. |
|
1387 |
|
1388 Status: Draft |
|
1389 |
|
1390 ------------------------------------------------------------------------------- |
|
1391 */ |
|
1392 CModuleListView* CModuleListView::NewL( CConsoleMain* aConsole, |
|
1393 CMenu* aParent, |
|
1394 const TDesC& aName ) |
|
1395 { |
|
1396 |
|
1397 CModuleListView* self = new ( ELeave ) CModuleListView(); |
|
1398 CleanupStack::PushL( self ); |
|
1399 self->ConstructL( aConsole, aParent, aName ); |
|
1400 CleanupStack::Pop( self ); |
|
1401 return self; |
|
1402 |
|
1403 } |
|
1404 /* |
|
1405 ------------------------------------------------------------------------------- |
|
1406 |
|
1407 Class: CModuleListView |
|
1408 |
|
1409 Method: ~CModuleListView |
|
1410 |
|
1411 Description: Destructor |
|
1412 |
|
1413 Parameters: None |
|
1414 |
|
1415 Return Values: None |
|
1416 |
|
1417 Errors/Exceptions: None |
|
1418 |
|
1419 Status: Draft |
|
1420 |
|
1421 ------------------------------------------------------------------------------- |
|
1422 */ |
|
1423 CModuleListView::~CModuleListView() |
|
1424 { |
|
1425 delete iModuleAdd; |
|
1426 } |
|
1427 |
|
1428 /* |
|
1429 ------------------------------------------------------------------------------- |
|
1430 |
|
1431 Class: CModuleListView |
|
1432 |
|
1433 Method: ConstructL |
|
1434 |
|
1435 Description: Second level constructor. |
|
1436 |
|
1437 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
1438 CMenu* aParent :in: Parent menu |
|
1439 const TDesC& aName :in: Menu name |
|
1440 |
|
1441 Return Values: None |
|
1442 |
|
1443 Errors/Exceptions: Leaves if parent class ConstructL leaves |
|
1444 Leaves if module can't be appended to list |
|
1445 |
|
1446 Status: Draft |
|
1447 |
|
1448 ------------------------------------------------------------------------------- |
|
1449 */ |
|
1450 void CModuleListView::ConstructL( CConsoleMain* aConsole, |
|
1451 CMenu* aParent, |
|
1452 const TDesC& aName |
|
1453 ) |
|
1454 { |
|
1455 |
|
1456 CMenu::ConstructL( aConsole, aParent, aName); |
|
1457 |
|
1458 // Construct module menu |
|
1459 iModuleAdd = CFileNameQueryView::NewL ( iMain, this, KSelectMenuTxt ); |
|
1460 |
|
1461 } |
|
1462 |
|
1463 /* |
|
1464 ------------------------------------------------------------------------------- |
|
1465 |
|
1466 Class: CModuleListView |
|
1467 |
|
1468 Method: ItemText |
|
1469 |
|
1470 Description: Returns menu item text. |
|
1471 |
|
1472 Parameters: const TInt :in: Menu index |
|
1473 |
|
1474 Return Values: const TDesC& Menu line text |
|
1475 |
|
1476 Errors/Exceptions: None |
|
1477 |
|
1478 Status: Draft |
|
1479 |
|
1480 ------------------------------------------------------------------------------- |
|
1481 */ |
|
1482 TInt CModuleListView::ItemTexts( RRefArray<TDesC>& aArray ) |
|
1483 { |
|
1484 // Add also "Add module" text |
|
1485 if( aArray.Append( KAddMenuTxt ) != KErrNone ) |
|
1486 { |
|
1487 return KErrNoMemory; |
|
1488 } |
|
1489 if( aArray.Append( KLoadMenuTxt ) != KErrNone ) |
|
1490 { |
|
1491 return KErrNoMemory; |
|
1492 } |
|
1493 |
|
1494 return KErrNone; |
|
1495 |
|
1496 } |
|
1497 |
|
1498 /* |
|
1499 ------------------------------------------------------------------------------- |
|
1500 Class: CModuleListView |
|
1501 |
|
1502 Method: PrintMenuL |
|
1503 |
|
1504 Description: Prints the menu |
|
1505 |
|
1506 Parameters: None |
|
1507 |
|
1508 Return Values: None |
|
1509 |
|
1510 Errors/Exceptions: None |
|
1511 |
|
1512 Status: Draft |
|
1513 |
|
1514 ------------------------------------------------------------------------------- |
|
1515 */ |
|
1516 void CModuleListView::PrintMenuL( TUpdateType aType ) |
|
1517 { |
|
1518 |
|
1519 // Get module names |
|
1520 RRefArray<TDesC> modules; |
|
1521 TInt ret = iMain->UIStore().Modules( modules ); |
|
1522 |
|
1523 CMenu::PrintMenuL( aType ); |
|
1524 |
|
1525 // Add loaded module names to menu |
|
1526 if( ret != KErrNone ) |
|
1527 { |
|
1528 modules.Reset(); |
|
1529 modules.Close(); |
|
1530 return; |
|
1531 } |
|
1532 |
|
1533 TBuf<KMaxLineLength> line; |
|
1534 TInt count = modules.Count(); |
|
1535 for( TInt i=0; i<count; i++ ) |
|
1536 { |
|
1537 line = _L(" "); |
|
1538 LimitedAppend ( line, modules[i] ); |
|
1539 |
|
1540 // Print the line |
|
1541 Print(line); |
|
1542 } |
|
1543 modules.Reset(); |
|
1544 modules.Close(); |
|
1545 |
|
1546 } |
|
1547 |
|
1548 /* |
|
1549 ------------------------------------------------------------------------------- |
|
1550 |
|
1551 Class: CModuleListView |
|
1552 |
|
1553 Method: SelectL |
|
1554 |
|
1555 Description: Process keypresses in menu. Handle right arrow and enter |
|
1556 here, others in parent menu. |
|
1557 |
|
1558 Parameters: TKeyCode aSelection :in: Key |
|
1559 TBool& aContinue :out: Has user pressed "Quit" |
|
1560 |
|
1561 Return Values: CMenu* New menu |
|
1562 |
|
1563 Errors/Exceptions: None |
|
1564 |
|
1565 Status: Draft |
|
1566 |
|
1567 ------------------------------------------------------------------------------- |
|
1568 */ |
|
1569 CMenu* CModuleListView::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
1570 { |
|
1571 |
|
1572 MapKeyCode(aSelection); |
|
1573 |
|
1574 if( ( aSelection == EKeyRightArrow || |
|
1575 aSelection == EKeyEnter ) ) |
|
1576 { |
|
1577 if( iPosOnScreen == EAddMenuTxtItem ) |
|
1578 { |
|
1579 return iModuleAdd; |
|
1580 } |
|
1581 else if( iPosOnScreen == ELoadMenuTxtItem ) |
|
1582 { |
|
1583 iMain->UIStore().LoadAllModules(); |
|
1584 return this; |
|
1585 } |
|
1586 else |
|
1587 { |
|
1588 return this; |
|
1589 } |
|
1590 } |
|
1591 |
|
1592 return CMenu::SelectL( aSelection, aContinue ); |
|
1593 |
|
1594 } |
|
1595 |
|
1596 /* |
|
1597 ------------------------------------------------------------------------------- |
|
1598 |
|
1599 Class: CCaseStartMenu |
|
1600 |
|
1601 Method: NewL |
|
1602 |
|
1603 Description: Constructs new menu. |
|
1604 |
|
1605 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
1606 CMenu* aParent :in: Parent menu |
|
1607 const TDesC& aName :in: Menu name |
|
1608 TBool aShowOutput :in: Show output after test case is run |
|
1609 |
|
1610 Return Values: CMenu* New menu |
|
1611 |
|
1612 Errors/Exceptions: Leaves if memory allocation fails |
|
1613 Leaves if ConstructL leaves. |
|
1614 |
|
1615 Status: Draft |
|
1616 |
|
1617 ------------------------------------------------------------------------------- |
|
1618 */ |
|
1619 CCaseStartMenu* CCaseStartMenu::NewL( CConsoleMain* aConsole, |
|
1620 CMenu* aParent, |
|
1621 const TDesC& aName, |
|
1622 TBool aShowOutput) |
|
1623 { |
|
1624 |
|
1625 CCaseStartMenu* self = new ( ELeave ) CCaseStartMenu(); |
|
1626 CleanupStack::PushL( self ); |
|
1627 self->ConstructL( aConsole, aParent, aName, aShowOutput ); |
|
1628 CleanupStack::Pop( self ); |
|
1629 return self; |
|
1630 |
|
1631 } |
|
1632 |
|
1633 /* |
|
1634 ------------------------------------------------------------------------------- |
|
1635 |
|
1636 Class: CCaseStartMenu |
|
1637 |
|
1638 Method: ConstructL |
|
1639 |
|
1640 Description: Second level constructor. |
|
1641 |
|
1642 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
1643 CMenu* aParent :in: Parent menu |
|
1644 const TDesC& aName :in: Menu name |
|
1645 |
|
1646 Return Values: None |
|
1647 |
|
1648 Errors/Exceptions: None |
|
1649 |
|
1650 Status: Draft |
|
1651 |
|
1652 ------------------------------------------------------------------------------- |
|
1653 */ |
|
1654 void CCaseStartMenu::ConstructL( CConsoleMain* aConsole, |
|
1655 CMenu* aParent, |
|
1656 const TDesC& aName, |
|
1657 TBool aShowOutput |
|
1658 ) |
|
1659 { |
|
1660 |
|
1661 iShowOutput = aShowOutput; |
|
1662 CMenu::ConstructL( aConsole, aParent, aName); |
|
1663 |
|
1664 } |
|
1665 |
|
1666 /* |
|
1667 ------------------------------------------------------------------------------- |
|
1668 |
|
1669 CCaseStartMenu |
|
1670 |
|
1671 Method: ~CCaseStartMenu |
|
1672 |
|
1673 Description: Destructor |
|
1674 |
|
1675 Parameters: None |
|
1676 |
|
1677 Return Values: None |
|
1678 |
|
1679 Errors/Exceptions: None |
|
1680 |
|
1681 Status: Draft |
|
1682 |
|
1683 ------------------------------------------------------------------------------- |
|
1684 */ |
|
1685 CCaseStartMenu::~CCaseStartMenu() |
|
1686 { |
|
1687 iTestCases.Close(); |
|
1688 |
|
1689 iMapFilteredToAll.Reset(); |
|
1690 iMapFilteredToAll.Close(); |
|
1691 } |
|
1692 |
|
1693 /* |
|
1694 ------------------------------------------------------------------------------- |
|
1695 |
|
1696 Class: CCaseStartMenu |
|
1697 |
|
1698 Method: ItemText |
|
1699 |
|
1700 Description: Returns menu item text |
|
1701 |
|
1702 Parameters: const TInt :in: Menu index |
|
1703 |
|
1704 Return Values: const TDesC& Menu line text |
|
1705 |
|
1706 Errors/Exceptions: None |
|
1707 |
|
1708 Status: Draft |
|
1709 |
|
1710 ------------------------------------------------------------------------------- |
|
1711 */ |
|
1712 TInt CCaseStartMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
1713 { |
|
1714 |
|
1715 iTestCases.Reset(); |
|
1716 TInt ret = iMain->UIStore().TestCases( iTestCases ); |
|
1717 if( ret != KErrNone ) |
|
1718 { |
|
1719 return ret; |
|
1720 } |
|
1721 |
|
1722 const RPointerArray<TDesC> &filters = iMain->GetFilterArray(); |
|
1723 const TInt filterindex = iMain->GetFilterIndex(); |
|
1724 iMapFilteredToAll.Reset(); |
|
1725 |
|
1726 TInt count = iTestCases.Count(); |
|
1727 for( TInt i = 0; i < count; i++ ) |
|
1728 { |
|
1729 //If user has chosen filter, let's apply it |
|
1730 if(filterindex > 0) //skip the first filter which always is "No filter" |
|
1731 { |
|
1732 //Check whether test title is matching the applied filter |
|
1733 iTitleLowerCase.Copy(iTestCases[i].TestCaseTitle()); |
|
1734 iTitleLowerCase.LowerCase(); |
|
1735 iFilterLowerCase.Copy(*filters[filterindex]); |
|
1736 iFilterLowerCase.LowerCase(); |
|
1737 |
|
1738 if(iTitleLowerCase.Match(iFilterLowerCase) != KErrNotFound) |
|
1739 { |
|
1740 ret = aArray.Append(iTestCases[i].TestCaseTitle()); |
|
1741 if(ret != KErrNone) |
|
1742 { |
|
1743 return ret; |
|
1744 } |
|
1745 ret = iMapFilteredToAll.Append(i); |
|
1746 if(ret != KErrNone) |
|
1747 { |
|
1748 return ret; |
|
1749 } |
|
1750 } |
|
1751 } |
|
1752 else |
|
1753 { |
|
1754 ret = aArray.Append( iTestCases[i].TestCaseTitle() ); |
|
1755 if(ret != KErrNone) |
|
1756 { |
|
1757 return ret; |
|
1758 } |
|
1759 ret = iMapFilteredToAll.Append(i); |
|
1760 if(ret != KErrNone) |
|
1761 { |
|
1762 return ret; |
|
1763 } |
|
1764 } |
|
1765 } |
|
1766 |
|
1767 return KErrNone; |
|
1768 } |
|
1769 |
|
1770 /* |
|
1771 ------------------------------------------------------------------------------- |
|
1772 |
|
1773 Class: CCaseStartMenu |
|
1774 |
|
1775 Method: SelectL |
|
1776 |
|
1777 Description: Process keypresses in menu. Handle enter and right arrow here, |
|
1778 others in CMenu::SelectL. |
|
1779 |
|
1780 Parameters: TKeyCode aSelection :in: Key |
|
1781 TBool& aContinue :out: Has user pressed "Quit" |
|
1782 |
|
1783 Return Values: CMenu* New menu |
|
1784 |
|
1785 Errors/Exceptions: None |
|
1786 |
|
1787 Status: Draft |
|
1788 |
|
1789 ------------------------------------------------------------------------------- |
|
1790 */ |
|
1791 CMenu* CCaseStartMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
1792 { |
|
1793 |
|
1794 MapKeyCode(aSelection); |
|
1795 |
|
1796 switch ( aSelection ) |
|
1797 { |
|
1798 case EKeyEnter: |
|
1799 case EKeyRightArrow: |
|
1800 { |
|
1801 // Start the case |
|
1802 if ( (iFirst + iPosOnScreen) < iMapFilteredToAll.Count() ) //changed from iTestCases to iMapFilteredToAll, because first table keeps info about all test cases, and second one about filtered cases |
|
1803 { |
|
1804 TInt index; |
|
1805 User::LeaveIfError( |
|
1806 iMain->UIStore().StartTestCase( |
|
1807 iTestCases[iMapFilteredToAll[iFirst + iPosOnScreen]], index ) ); |
|
1808 // Create output screen (menu) if needed |
|
1809 if(iShowOutput) |
|
1810 { |
|
1811 CMenu* m = iMain->GetMainMenu()->CreateOutputViewL(iParent); |
|
1812 if(m) |
|
1813 return m; |
|
1814 } |
|
1815 return iParent; |
|
1816 } |
|
1817 else |
|
1818 { |
|
1819 return this; |
|
1820 } |
|
1821 } |
|
1822 |
|
1823 default: |
|
1824 return CMenu::SelectL( aSelection, aContinue); |
|
1825 } |
|
1826 |
|
1827 } |
|
1828 |
|
1829 /* |
|
1830 ------------------------------------------------------------------------------- |
|
1831 |
|
1832 CMultipleBaseMenu |
|
1833 |
|
1834 Method: NewL |
|
1835 |
|
1836 Description: Constructs new menu. |
|
1837 |
|
1838 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
1839 CMenu* aParent :in: Parent menu |
|
1840 const TDesC& aName :in: Menu name |
|
1841 |
|
1842 Return Values: CMenu* New menu |
|
1843 |
|
1844 Errors/Exceptions: Leaves if memory allocation fails |
|
1845 Leaves if ConstructL leaves. |
|
1846 |
|
1847 Status: Draft |
|
1848 |
|
1849 ------------------------------------------------------------------------------- |
|
1850 */ |
|
1851 CMultipleBaseMenu* CMultipleBaseMenu::NewL( CConsoleMain* aConsole, |
|
1852 CMenu* aParent, |
|
1853 const TDesC& aName ) |
|
1854 { |
|
1855 |
|
1856 CMultipleBaseMenu* self = new ( ELeave ) CMultipleBaseMenu(); |
|
1857 CleanupStack::PushL( self ); |
|
1858 self->ConstructL( aConsole, aParent, aName ); |
|
1859 CleanupStack::Pop( self ); |
|
1860 return self; |
|
1861 |
|
1862 } |
|
1863 |
|
1864 /* |
|
1865 ------------------------------------------------------------------------------- |
|
1866 |
|
1867 CMultipleBaseMenu |
|
1868 |
|
1869 Method: CMultipleBaseMenu |
|
1870 |
|
1871 Description: Constructor |
|
1872 |
|
1873 Parameters: None |
|
1874 |
|
1875 Return Values: None |
|
1876 |
|
1877 Errors/Exceptions: None |
|
1878 |
|
1879 Status: Draft |
|
1880 |
|
1881 ------------------------------------------------------------------------------- |
|
1882 */ |
|
1883 CMultipleBaseMenu::CMultipleBaseMenu(): |
|
1884 iSetFinished( ETrue ), |
|
1885 iRunType( ERunSequential ), |
|
1886 iMenuTotCount( 0 ), |
|
1887 iMenuCount( 0 ) |
|
1888 { |
|
1889 |
|
1890 iMenuCount = EChangeAll + 1; |
|
1891 iMenuTotCount = iMenuCount; |
|
1892 |
|
1893 } |
|
1894 |
|
1895 /* |
|
1896 ------------------------------------------------------------------------------- |
|
1897 |
|
1898 CMultipleBaseMenu |
|
1899 |
|
1900 Method: ~CMultipleBaseMenu |
|
1901 |
|
1902 Description: Destructor |
|
1903 |
|
1904 Parameters: None |
|
1905 |
|
1906 Return Values: None |
|
1907 |
|
1908 Errors/Exceptions: None |
|
1909 |
|
1910 Status: Draft |
|
1911 |
|
1912 ------------------------------------------------------------------------------- |
|
1913 */ |
|
1914 CMultipleBaseMenu::~CMultipleBaseMenu() |
|
1915 { |
|
1916 |
|
1917 iSetState.Close(); |
|
1918 |
|
1919 } |
|
1920 |
|
1921 /* |
|
1922 ------------------------------------------------------------------------------- |
|
1923 |
|
1924 Class: CMultipleBaseMenu |
|
1925 |
|
1926 Method: ConstructL |
|
1927 |
|
1928 Description: Second level constructor. |
|
1929 |
|
1930 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
1931 CMenu* aParent :in: Parent menu |
|
1932 const TDesC& aName :in: Menu name |
|
1933 |
|
1934 Return Values: None |
|
1935 |
|
1936 Errors/Exceptions: None |
|
1937 |
|
1938 Status: Draft |
|
1939 |
|
1940 ------------------------------------------------------------------------------- |
|
1941 */ |
|
1942 void CMultipleBaseMenu::ConstructL( CConsoleMain* aConsole, |
|
1943 CMenu* aParent, |
|
1944 const TDesC& aName |
|
1945 ) |
|
1946 { |
|
1947 |
|
1948 CCaseStartMenu::ConstructL( aConsole, aParent, aName ); |
|
1949 |
|
1950 } |
|
1951 |
|
1952 |
|
1953 /* |
|
1954 ------------------------------------------------------------------------------- |
|
1955 |
|
1956 Class: CMultipleBaseMenu |
|
1957 |
|
1958 Method: ItemText |
|
1959 |
|
1960 Description: Returns menu item text |
|
1961 |
|
1962 Parameters: const TInt :in: Menu index |
|
1963 |
|
1964 Return Values: const TDesC& Menu line text |
|
1965 |
|
1966 Errors/Exceptions: None |
|
1967 |
|
1968 Status: Draft |
|
1969 |
|
1970 ------------------------------------------------------------------------------- |
|
1971 */ |
|
1972 TInt CMultipleBaseMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
1973 { |
|
1974 |
|
1975 if ( iSetFinished ) |
|
1976 { |
|
1977 if( aArray.Append( KChangeAll ) != KErrNone ) |
|
1978 { |
|
1979 return KErrNoMemory; |
|
1980 } |
|
1981 |
|
1982 if( iUpdateType == EMenuPrint ) |
|
1983 { |
|
1984 TInt ret = UpdateTestCases(); |
|
1985 if( ret != KErrNone ) |
|
1986 { |
|
1987 return ret; |
|
1988 } |
|
1989 } |
|
1990 TInt count = iTestCases.Count(); |
|
1991 for( TInt j=0; j<count; j++ ) |
|
1992 { |
|
1993 if( aArray.Append( iTestCases[j].TestCaseTitle() ) |
|
1994 != KErrNone ) |
|
1995 { |
|
1996 return KErrNoMemory; |
|
1997 } |
|
1998 if( aArray.Count() > iSetState.Count()) |
|
1999 { |
|
2000 // Appends iSetState only if aArray's size is bigger @js |
|
2001 if( iSetState.Append(EFalse) != KErrNone ) |
|
2002 { |
|
2003 return KErrNoMemory; |
|
2004 } |
|
2005 } |
|
2006 } |
|
2007 } |
|
2008 else |
|
2009 { |
|
2010 if( aArray.Append( KCancelSet ) != KErrNone ) |
|
2011 { |
|
2012 return KErrNoMemory; |
|
2013 } |
|
2014 } |
|
2015 |
|
2016 return KErrNone; |
|
2017 |
|
2018 } |
|
2019 |
|
2020 /* |
|
2021 ------------------------------------------------------------------------------- |
|
2022 Class: CMultipleBaseMenu |
|
2023 |
|
2024 Method: AppendBefore |
|
2025 |
|
2026 Description: Append text before line. |
|
2027 |
|
2028 Parameters: TInt aLine: in: line number |
|
2029 TDes& aLine: in: line text |
|
2030 |
|
2031 Return Values: None |
|
2032 |
|
2033 Errors/Exceptions: None |
|
2034 |
|
2035 Status: Draft |
|
2036 |
|
2037 ------------------------------------------------------------------------------- |
|
2038 */ |
|
2039 void CMultipleBaseMenu::AppendBefore( TInt aLineNum, TDes& aLine ) |
|
2040 { |
|
2041 |
|
2042 CMenu::AppendBefore( aLineNum, aLine ); |
|
2043 if( ( aLine.MaxLength() - aLine.Length() ) < 2 ) |
|
2044 { |
|
2045 return; |
|
2046 } |
|
2047 |
|
2048 if( aLineNum >= iMenuTotCount ) |
|
2049 { |
|
2050 if ( iSetState[ aLineNum - iMenuTotCount ] ) |
|
2051 { |
|
2052 aLine.Append(_L("S ")); |
|
2053 } |
|
2054 else |
|
2055 { |
|
2056 aLine.Append(_L(" ")); |
|
2057 } |
|
2058 } |
|
2059 |
|
2060 } |
|
2061 |
|
2062 /* |
|
2063 ------------------------------------------------------------------------------- |
|
2064 |
|
2065 Class: CMultipleBaseMenu |
|
2066 |
|
2067 Method: SelectL |
|
2068 |
|
2069 Description: Process keypresses in menu. Handle enter and right arrow here, |
|
2070 others in CMenu::SelectL. |
|
2071 |
|
2072 Parameters: TKeyCode aSelection :in: Key |
|
2073 TBool& aContinue :out: Has user pressed "Quit" |
|
2074 |
|
2075 Return Values: CMenu* New menu |
|
2076 |
|
2077 Errors/Exceptions: None |
|
2078 |
|
2079 Status: Draft |
|
2080 |
|
2081 ------------------------------------------------------------------------------- |
|
2082 */ |
|
2083 CMenu* CMultipleBaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
2084 { |
|
2085 |
|
2086 MapKeyCode(aSelection); |
|
2087 |
|
2088 if ( iSetFinished ) |
|
2089 { |
|
2090 |
|
2091 if ( ( aSelection == EKeyEnter ) || ( aSelection == EKeyRightArrow ) ) |
|
2092 { |
|
2093 // CMultipleBaseMenu relative position |
|
2094 TInt pos = iFirst + iPosOnScreen - iMenuTotCount + iMenuCount; |
|
2095 if( pos == EChangeAll ) |
|
2096 { |
|
2097 TInt count = iTestCases.Count(); |
|
2098 |
|
2099 // Change all |
|
2100 for (TInt i = 0; i < count; i++) |
|
2101 { |
|
2102 iSetState[i] = !iSetState[i]; |
|
2103 } |
|
2104 |
|
2105 return this; |
|
2106 } |
|
2107 else |
|
2108 { |
|
2109 // Normal item, change state... |
|
2110 iSetState[ iFirst + iPosOnScreen - iMenuTotCount ] = |
|
2111 !iSetState[ iFirst + iPosOnScreen - iMenuTotCount ]; |
|
2112 return this; |
|
2113 } |
|
2114 |
|
2115 } |
|
2116 |
|
2117 return CMenu::SelectL( aSelection, aContinue ); |
|
2118 } |
|
2119 else |
|
2120 { |
|
2121 |
|
2122 switch ( aSelection ) |
|
2123 { |
|
2124 case EKeyEnter: |
|
2125 case EKeyRightArrow: |
|
2126 { |
|
2127 if ( iOngoingCaseContainer != NULL ) |
|
2128 { |
|
2129 iOngoingCaseContainer->UIEngineContainer().CancelTest(); |
|
2130 } |
|
2131 iSetFinished = ETrue; |
|
2132 iFirst = 0; |
|
2133 iLast = 0; |
|
2134 return this; |
|
2135 } |
|
2136 default: |
|
2137 return CMenu::SelectL( aSelection, aContinue ); |
|
2138 } |
|
2139 |
|
2140 |
|
2141 |
|
2142 } |
|
2143 |
|
2144 } |
|
2145 |
|
2146 /* |
|
2147 ------------------------------------------------------------------------------- |
|
2148 |
|
2149 Class: CMultipleBaseMenu |
|
2150 |
|
2151 Method: CheckIfAnyCaseIsSelected |
|
2152 |
|
2153 Description: Checks if any of testcases was selected in multiple selection menu |
|
2154 |
|
2155 Parameters: TInt aCount number of testcases in multiple selection menu |
|
2156 |
|
2157 Return Values: ETrue if any testcase was selected, EFalse if none of testcases was selected |
|
2158 |
|
2159 Errors/Exceptions: None |
|
2160 |
|
2161 Status: Proposal |
|
2162 |
|
2163 ------------------------------------------------------------------------------- |
|
2164 */ |
|
2165 TBool CMultipleBaseMenu::CheckIfAnyCaseIsSelected(TInt aCount) |
|
2166 { |
|
2167 TInt currentPos = 0; |
|
2168 for(; currentPos<aCount; currentPos++) |
|
2169 { |
|
2170 //if any of testcases was selected then return true |
|
2171 if (iSetState[currentPos]) |
|
2172 return ETrue; |
|
2173 } |
|
2174 //if none of testcases was selected then return false |
|
2175 return EFalse; |
|
2176 } |
|
2177 |
|
2178 /* |
|
2179 ------------------------------------------------------------------------------- |
|
2180 |
|
2181 Class: CMultipleBaseMenu |
|
2182 |
|
2183 Method: SignalL |
|
2184 |
|
2185 Description: Handle test case starts |
|
2186 |
|
2187 Parameters: CStartedTestCase* aContainer: in: CStartedTestCase container |
|
2188 |
|
2189 Return Values: None |
|
2190 |
|
2191 Errors/Exceptions: None |
|
2192 |
|
2193 Status: Approved |
|
2194 |
|
2195 ------------------------------------------------------------------------------- |
|
2196 */ |
|
2197 void CMultipleBaseMenu::SignalL( CStartedTestCase* /*aContainer*/ ) |
|
2198 { |
|
2199 |
|
2200 TInt count = iTestCases.Count(); |
|
2201 |
|
2202 TBool started = EFalse; |
|
2203 TInt index; |
|
2204 TInt err = KErrNone; |
|
2205 |
|
2206 // Counter to prevent infinite loop when cases can't be started at all |
|
2207 // when running cases in repeat mode. |
|
2208 TInt casesChecked = 0; |
|
2209 |
|
2210 // If cases are not aborted or not in last case and at least one test |
|
2211 // case was selected, start a new one |
|
2212 if ( !iSetFinished && iCurrentRunPos != count && CheckIfAnyCaseIsSelected(count) ) |
|
2213 { |
|
2214 // Search next case from set and execute it. |
|
2215 while( iCurrentRunPos < count ) |
|
2216 { |
|
2217 if ( iSetState[iCurrentRunPos] ) |
|
2218 { |
|
2219 err = iMain->UIStore().StartTestCase( |
|
2220 iTestCases[ iCurrentRunPos ], |
|
2221 index ); |
|
2222 |
|
2223 iCurrentRunPos++; |
|
2224 casesChecked++; |
|
2225 |
|
2226 // Go to start of list, if running cases in repeat mode. |
|
2227 // In other modes, just get out from the main loop |
|
2228 if( ( iRunType == ERunRepeatSequential ) && |
|
2229 ( iCurrentRunPos >= count ) ) |
|
2230 { |
|
2231 // Restart from first one on next time. |
|
2232 iCurrentRunPos = 0; |
|
2233 } |
|
2234 |
|
2235 // Handle out of memory error separately, because there is |
|
2236 // always new test case result display constructed when |
|
2237 // starting case => Starting more new cases uses more memory |
|
2238 // and it will not work, so stop starting new cases. |
|
2239 if( err == KErrNoMemory ) |
|
2240 { |
|
2241 iSetFinished = ETrue; |
|
2242 break; |
|
2243 } |
|
2244 |
|
2245 // Get pointer to ongoing case in case that user wants to |
|
2246 // cancel it. |
|
2247 iOngoingCaseContainer = |
|
2248 &iMain->UIStore().StartedTestCaseL( index ); |
|
2249 |
|
2250 // Store pointer to this object to allow |
|
2251 // SignalL call when test case is completed |
|
2252 iOngoingCaseContainer->iBackPtr = (TAny*)this; |
|
2253 |
|
2254 if( err != KErrNone ) |
|
2255 { |
|
2256 TFullTestResult result; |
|
2257 result.iTestResult.iResult = err; |
|
2258 result.iTestResult.iResultDes.Copy( |
|
2259 _L("Failed to start testcase") ); |
|
2260 // Prevent infinite loop in case, where |
|
2261 // ERunRepeatSequential and ALL cases fail to start. |
|
2262 if ( iRunType == ERunRepeatSequential && |
|
2263 casesChecked == count ) |
|
2264 { |
|
2265 // In this state, started = EFalse so final check |
|
2266 // stops running |
|
2267 break; |
|
2268 } |
|
2269 } |
|
2270 else if( ( iRunType == ERunSequential ) || |
|
2271 ( iRunType == ERunRepeatSequential ) ) |
|
2272 { |
|
2273 started = ETrue; |
|
2274 break; |
|
2275 } |
|
2276 } |
|
2277 else |
|
2278 { |
|
2279 iCurrentRunPos++; |
|
2280 casesChecked++; |
|
2281 |
|
2282 // Go to start of list, if running cases in repeat mode. |
|
2283 // In other modes, just get out from the main loop |
|
2284 if( ( iRunType == ERunRepeatSequential ) && |
|
2285 ( iCurrentRunPos >= count ) ) |
|
2286 { |
|
2287 // Restart from first one |
|
2288 iCurrentRunPos = 0; |
|
2289 } |
|
2290 } |
|
2291 } |
|
2292 } |
|
2293 |
|
2294 if ( err == KErrNoMemory ) |
|
2295 { |
|
2296 iMain->ExitWithNoMemoryErrorMessage(); |
|
2297 } |
|
2298 |
|
2299 // If nothing was selected, then mark set as finished. |
|
2300 // Or running cases at same time, so all have been started. |
|
2301 if ( started == EFalse ) |
|
2302 { |
|
2303 iFirst = 0; |
|
2304 iLast = 0; |
|
2305 iSetFinished = ETrue; |
|
2306 iCurrentRunPos = 0; |
|
2307 } |
|
2308 |
|
2309 } |
|
2310 |
|
2311 /* |
|
2312 ------------------------------------------------------------------------------- |
|
2313 |
|
2314 Class: CMultipleBaseMenu |
|
2315 |
|
2316 Method: UpdateTestCases |
|
2317 |
|
2318 Description: |
|
2319 |
|
2320 Parameters: |
|
2321 |
|
2322 Return Values: |
|
2323 |
|
2324 Errors/Exceptions: None |
|
2325 |
|
2326 Status: Draft |
|
2327 |
|
2328 ------------------------------------------------------------------------------- |
|
2329 */ |
|
2330 TInt CMultipleBaseMenu::UpdateTestCases() |
|
2331 { |
|
2332 |
|
2333 // Update test cases |
|
2334 iTestCases.Reset(); |
|
2335 iSetState.Reset(); |
|
2336 return iMain->UIStore().TestCases( iTestCases ); |
|
2337 |
|
2338 } |
|
2339 |
|
2340 /* |
|
2341 ------------------------------------------------------------------------------- |
|
2342 |
|
2343 CMultipleCaseMenu |
|
2344 |
|
2345 Method: NewL |
|
2346 |
|
2347 Description: Constructs new menu. |
|
2348 |
|
2349 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
2350 CMenu* aParent :in: Parent menu |
|
2351 const TDesC& aName :in: Menu name |
|
2352 |
|
2353 Return Values: CMenu* New menu |
|
2354 |
|
2355 Errors/Exceptions: Leaves if memory allocation fails |
|
2356 Leaves if ConstructL leaves. |
|
2357 |
|
2358 Status: Draft |
|
2359 |
|
2360 ------------------------------------------------------------------------------- |
|
2361 */ |
|
2362 CMultipleCaseMenu* CMultipleCaseMenu::NewL( CConsoleMain* aConsole, |
|
2363 CMenu* aParent, |
|
2364 const TDesC& aName ) |
|
2365 { |
|
2366 |
|
2367 CMultipleCaseMenu* self = new ( ELeave ) CMultipleCaseMenu(); |
|
2368 CleanupStack::PushL( self ); |
|
2369 self->ConstructL( aConsole, aParent, aName ); |
|
2370 CleanupStack::Pop( self ); |
|
2371 return self; |
|
2372 |
|
2373 } |
|
2374 |
|
2375 /* |
|
2376 ------------------------------------------------------------------------------- |
|
2377 |
|
2378 CMultipleCaseMenu |
|
2379 |
|
2380 Method: CMultipleCaseMenu |
|
2381 |
|
2382 Description: Constructor |
|
2383 |
|
2384 Parameters: None |
|
2385 |
|
2386 Return Values: None |
|
2387 |
|
2388 Errors/Exceptions: None |
|
2389 |
|
2390 Status: Draft |
|
2391 |
|
2392 ------------------------------------------------------------------------------- |
|
2393 */ |
|
2394 CMultipleCaseMenu::CMultipleCaseMenu() |
|
2395 { |
|
2396 |
|
2397 iMenuItemsCount = ERepeatRunSelection + 1; |
|
2398 iMenuItemsCount++; //Select all between already selected |
|
2399 iMenuTotCount += iMenuItemsCount; |
|
2400 |
|
2401 } |
|
2402 |
|
2403 /* |
|
2404 ------------------------------------------------------------------------------- |
|
2405 |
|
2406 CMultipleCaseMenu |
|
2407 |
|
2408 Method: ~CMultipleCaseMenu |
|
2409 |
|
2410 Description: Destructor |
|
2411 |
|
2412 Parameters: None |
|
2413 |
|
2414 Return Values: None |
|
2415 |
|
2416 Errors/Exceptions: None |
|
2417 |
|
2418 Status: Draft |
|
2419 |
|
2420 ------------------------------------------------------------------------------- |
|
2421 */ |
|
2422 CMultipleCaseMenu::~CMultipleCaseMenu() |
|
2423 { |
|
2424 } |
|
2425 |
|
2426 /* |
|
2427 ------------------------------------------------------------------------------- |
|
2428 |
|
2429 Class: CMultipleCaseMenu |
|
2430 |
|
2431 Method: ConstructL |
|
2432 |
|
2433 Description: Second level constructor. |
|
2434 |
|
2435 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
2436 CMenu* aParent :in: Parent menu |
|
2437 const TDesC& aName :in: Menu name |
|
2438 |
|
2439 Return Values: None |
|
2440 |
|
2441 Errors/Exceptions: None |
|
2442 |
|
2443 Status: Draft |
|
2444 |
|
2445 ------------------------------------------------------------------------------- |
|
2446 */ |
|
2447 void CMultipleCaseMenu::ConstructL( CConsoleMain* aConsole, |
|
2448 CMenu* aParent, |
|
2449 const TDesC& aName |
|
2450 ) |
|
2451 { |
|
2452 |
|
2453 CCaseStartMenu::ConstructL( aConsole, aParent, aName ); |
|
2454 |
|
2455 } |
|
2456 |
|
2457 /* |
|
2458 ------------------------------------------------------------------------------- |
|
2459 |
|
2460 Class: CMultipleCaseMenu |
|
2461 |
|
2462 Method: StartRunningL |
|
2463 |
|
2464 Description: Start running multiple cases. |
|
2465 |
|
2466 Parameters: TRunType aRunType: in: Running type |
|
2467 const TDesC& aModule: in: module name |
|
2468 const TDesC& aTestCaseFile: in: test case file name |
|
2469 |
|
2470 Return Values: None |
|
2471 |
|
2472 Errors/Exceptions: Leaves on error |
|
2473 |
|
2474 Status: Draft |
|
2475 |
|
2476 ------------------------------------------------------------------------------- |
|
2477 */ |
|
2478 void CMultipleCaseMenu::StartRunningL( TRunType aRunType, |
|
2479 const TDesC& aModule, |
|
2480 const TDesC& aTestCaseFile ) |
|
2481 { |
|
2482 |
|
2483 // Update test cases |
|
2484 iTestCases.Reset(); |
|
2485 iSetState.Reset(); |
|
2486 User::LeaveIfError( |
|
2487 iMain->UIStore().TestCases( iTestCases, aModule, aTestCaseFile ) ); |
|
2488 |
|
2489 // Select all for running |
|
2490 TInt count = iTestCases.Count(); |
|
2491 for( TInt j=0; j<count; j++ ) |
|
2492 { |
|
2493 User::LeaveIfError( iSetState.Append(ETrue) ); |
|
2494 } |
|
2495 |
|
2496 // Start running |
|
2497 iCurrentRunPos = 0; |
|
2498 iSetFinished = EFalse; |
|
2499 iRunType = aRunType; |
|
2500 SignalL ( NULL ); |
|
2501 |
|
2502 } |
|
2503 |
|
2504 /* |
|
2505 ------------------------------------------------------------------------------- |
|
2506 |
|
2507 Class: CMultipleCaseMenu |
|
2508 |
|
2509 Method: ItemText |
|
2510 |
|
2511 Description: Returns menu item text |
|
2512 |
|
2513 Parameters: const TInt :in: Menu index |
|
2514 |
|
2515 Return Values: const TDesC& Menu line text |
|
2516 |
|
2517 Errors/Exceptions: None |
|
2518 |
|
2519 Status: Draft |
|
2520 |
|
2521 ------------------------------------------------------------------------------- |
|
2522 */ |
|
2523 TInt CMultipleCaseMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
2524 { |
|
2525 |
|
2526 if ( iSetFinished ) |
|
2527 { |
|
2528 if( aArray.Append( KRunSequentially ) != KErrNone ) |
|
2529 { |
|
2530 return KErrNoMemory; |
|
2531 } |
|
2532 if( aArray.Append( KRunParallel ) != KErrNone ) |
|
2533 { |
|
2534 return KErrNoMemory; |
|
2535 } |
|
2536 if( aArray.Append( KRepeatRunSequentially ) != KErrNone ) |
|
2537 { |
|
2538 return KErrNoMemory; |
|
2539 } |
|
2540 if(aArray.Append(KSelectFromTo) != KErrNone) |
|
2541 { |
|
2542 return KErrNoMemory; |
|
2543 } |
|
2544 } |
|
2545 |
|
2546 TInt ret = CMultipleBaseMenu::ItemTexts(aArray); |
|
2547 if(ret != KErrNone) |
|
2548 { |
|
2549 return ret; |
|
2550 } |
|
2551 |
|
2552 return KErrNone; |
|
2553 } |
|
2554 |
|
2555 /* |
|
2556 ------------------------------------------------------------------------------- |
|
2557 |
|
2558 Class: CMultipleCaseMenu |
|
2559 |
|
2560 Method: SelectL |
|
2561 |
|
2562 Description: Process keypresses in menu. Handle enter and right arrow here, |
|
2563 others in CMenu::SelectL. |
|
2564 |
|
2565 Parameters: TKeyCode aSelection :in: Key |
|
2566 TBool& aContinue :out: Has user pressed "Quit" |
|
2567 |
|
2568 Return Values: CMenu* New menu |
|
2569 |
|
2570 Errors/Exceptions: None |
|
2571 |
|
2572 Status: Draft |
|
2573 |
|
2574 ------------------------------------------------------------------------------- |
|
2575 */ |
|
2576 CMenu* CMultipleCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
2577 { |
|
2578 |
|
2579 MapKeyCode(aSelection); |
|
2580 |
|
2581 if ( iSetFinished ) |
|
2582 { |
|
2583 switch ( aSelection ) |
|
2584 { |
|
2585 case EKeyEnter: |
|
2586 case EKeyRightArrow: |
|
2587 { |
|
2588 |
|
2589 if ( iFirst + iPosOnScreen == ERunSelection ) |
|
2590 { |
|
2591 // Start the first one |
|
2592 iCurrentRunPos = 0; |
|
2593 iSetFinished = EFalse; |
|
2594 iRunType = ERunSequential; |
|
2595 SignalL ( NULL ); |
|
2596 |
|
2597 return iParent; |
|
2598 } |
|
2599 else if ( iFirst + iPosOnScreen == ERunSelectionParaller ) |
|
2600 { |
|
2601 // Start the first one |
|
2602 iCurrentRunPos = 0; |
|
2603 iSetFinished = EFalse; |
|
2604 iRunType = ERunParallel; |
|
2605 SignalL ( NULL ); |
|
2606 |
|
2607 return iParent; |
|
2608 } |
|
2609 else if ( iFirst + iPosOnScreen == ERepeatRunSelection ) |
|
2610 { |
|
2611 // Start the first one |
|
2612 iCurrentRunPos = 0; |
|
2613 iSetFinished = EFalse; |
|
2614 iRunType = ERunRepeatSequential; |
|
2615 SignalL ( NULL ); |
|
2616 |
|
2617 return iParent; |
|
2618 } |
|
2619 else if(iFirst + iPosOnScreen == ESelectFromTo) |
|
2620 { |
|
2621 TInt count = iTestCases.Count(); |
|
2622 TInt indexFirst = count; |
|
2623 TInt indexLast = count - 1; |
|
2624 TInt i; |
|
2625 |
|
2626 // Find first test case which is set |
|
2627 for(i = 0; i < count; i++) |
|
2628 { |
|
2629 if(iSetState[i]) |
|
2630 { |
|
2631 indexFirst = i; |
|
2632 break; |
|
2633 } |
|
2634 } |
|
2635 |
|
2636 // Find last test case which is set |
|
2637 if(indexFirst < count) |
|
2638 { |
|
2639 for(i = count - 1; i > indexFirst; i--) |
|
2640 { |
|
2641 if(iSetState[i]) |
|
2642 { |
|
2643 indexLast = i; |
|
2644 break; |
|
2645 } |
|
2646 } |
|
2647 |
|
2648 // Set test cases between first and last |
|
2649 for(i = indexFirst; i <= indexLast; i++) |
|
2650 { |
|
2651 iSetState[i] = ETrue; |
|
2652 } |
|
2653 } |
|
2654 |
|
2655 return this; |
|
2656 } |
|
2657 } |
|
2658 break; |
|
2659 default: |
|
2660 break; |
|
2661 } |
|
2662 } |
|
2663 |
|
2664 return CMultipleBaseMenu::SelectL( aSelection, aContinue ); |
|
2665 |
|
2666 } |
|
2667 |
|
2668 /* |
|
2669 ------------------------------------------------------------------------------- |
|
2670 |
|
2671 Class: CCaseMenu |
|
2672 |
|
2673 Method: NewL |
|
2674 |
|
2675 Description: Constructs new menu. |
|
2676 |
|
2677 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
2678 CMenu* aParent :in: Parent menu |
|
2679 const TDesC& aName :in: Menu name |
|
2680 TCaseState aType :in: Case state |
|
2681 |
|
2682 Return Values: CMenu* New menu |
|
2683 |
|
2684 Errors/Exceptions: Leaves if memory allocation fails |
|
2685 Leaves if ConstructL leaves. |
|
2686 |
|
2687 Status: Draft |
|
2688 |
|
2689 ------------------------------------------------------------------------------- |
|
2690 */ |
|
2691 CCaseMenu* CCaseMenu::NewL( CConsoleMain* aConsole, |
|
2692 CMenu* aParent, |
|
2693 const TDesC& aName, |
|
2694 TInt aType ) |
|
2695 { |
|
2696 |
|
2697 CCaseMenu* self = new ( ELeave ) CCaseMenu(); |
|
2698 CleanupStack::PushL( self ); |
|
2699 self->ConstructL( aConsole, aParent, aName, aType ); |
|
2700 CleanupStack::Pop( self ); |
|
2701 return self; |
|
2702 |
|
2703 } |
|
2704 |
|
2705 /* |
|
2706 ------------------------------------------------------------------------------- |
|
2707 |
|
2708 Class: CCaseMenu |
|
2709 |
|
2710 Method: ConstructL |
|
2711 |
|
2712 Description: Second level constructor. |
|
2713 |
|
2714 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
2715 CMenu* aParent :in: Parent menu |
|
2716 const TDesC& aName :in: Menu name |
|
2717 TCaseState aType :in: Case state |
|
2718 |
|
2719 Return Values: None |
|
2720 |
|
2721 Errors/Exceptions: Leaves if parent class ConstructL leaves |
|
2722 Leaves if memory allocation fails |
|
2723 Leaves if CCaseOperation menu NewL leaves |
|
2724 Leaves if UpcateCaseListL leaves |
|
2725 |
|
2726 Status: Draft |
|
2727 |
|
2728 ------------------------------------------------------------------------------- |
|
2729 */ |
|
2730 void CCaseMenu::ConstructL( CConsoleMain* aConsole, |
|
2731 CMenu* aParent, |
|
2732 const TDesC& aName, |
|
2733 TInt aType |
|
2734 ) |
|
2735 { |
|
2736 |
|
2737 CMenu::ConstructL( aConsole, aParent, aName); |
|
2738 iType = aType; |
|
2739 |
|
2740 } |
|
2741 |
|
2742 |
|
2743 |
|
2744 /* |
|
2745 ------------------------------------------------------------------------------- |
|
2746 |
|
2747 Class: CCaseMenu |
|
2748 |
|
2749 Method: ~CCaseMenu |
|
2750 |
|
2751 Description: Destructor |
|
2752 |
|
2753 Parameters: None |
|
2754 |
|
2755 Return Values: None |
|
2756 |
|
2757 Errors/Exceptions: None |
|
2758 |
|
2759 Status: Draft |
|
2760 |
|
2761 ------------------------------------------------------------------------------- |
|
2762 */ |
|
2763 CCaseMenu::~CCaseMenu() |
|
2764 { |
|
2765 |
|
2766 delete iCaseOperationMenu; |
|
2767 iCaseOperationMenu = 0; |
|
2768 |
|
2769 iTestCases.Close(); |
|
2770 |
|
2771 } |
|
2772 |
|
2773 |
|
2774 /* |
|
2775 ------------------------------------------------------------------------------- |
|
2776 |
|
2777 Class: CCaseMenu |
|
2778 |
|
2779 Method: ItemText |
|
2780 |
|
2781 Description: Returns menu item text |
|
2782 |
|
2783 Parameters: const TInt :in: Menu index |
|
2784 |
|
2785 Return Values: const TDesC& Menu line text |
|
2786 |
|
2787 Errors/Exceptions: None |
|
2788 |
|
2789 Status: Draft |
|
2790 |
|
2791 ------------------------------------------------------------------------------- |
|
2792 */ |
|
2793 TInt CCaseMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
2794 { |
|
2795 |
|
2796 iTestCases.Reset(); |
|
2797 |
|
2798 TInt ret = iMain->UIStore().StartedTestCases( iTestCases, iType ); |
|
2799 if ( ret != KErrNone ) |
|
2800 { |
|
2801 return ret; |
|
2802 } |
|
2803 |
|
2804 TInt count = iTestCases.Count(); |
|
2805 for( TInt i=0; i<count; i++ ) |
|
2806 { |
|
2807 if( aArray.Append( iTestCases[i].TestInfo().TestCaseTitle() ) != KErrNone ) |
|
2808 { |
|
2809 return KErrNoMemory; |
|
2810 } |
|
2811 } |
|
2812 |
|
2813 return KErrNone; |
|
2814 } |
|
2815 |
|
2816 /* |
|
2817 ------------------------------------------------------------------------------- |
|
2818 Class: CCaseMenu |
|
2819 |
|
2820 Method: AppendBefore |
|
2821 |
|
2822 Description: Append text before line. |
|
2823 |
|
2824 Parameters: TInt aLine: in: line number |
|
2825 TDes& aLine: in: line text |
|
2826 |
|
2827 Return Values: None |
|
2828 |
|
2829 Errors/Exceptions: None |
|
2830 |
|
2831 Status: Draft |
|
2832 |
|
2833 ------------------------------------------------------------------------------- |
|
2834 */ |
|
2835 void CCaseMenu::AppendBefore(TInt aLineNum, TDes& aLine) |
|
2836 { |
|
2837 CMenu::AppendBefore(aLineNum, aLine); |
|
2838 |
|
2839 //START of --Add number to the test case title-- |
|
2840 //First check how much space we need |
|
2841 TInt additionalSpace = 0; |
|
2842 TInt currentCount = aLineNum + 1; |
|
2843 |
|
2844 if(currentCount >= 10000) additionalSpace = 10; //f.e. "10157521. " |
|
2845 else if(currentCount >= 1000) additionalSpace = 6; //f.e. "1157. " |
|
2846 else if(currentCount >= 100) additionalSpace = 5; //f.e. "101. " |
|
2847 else if(currentCount >= 10) additionalSpace = 4; //f.e. "15. " |
|
2848 else additionalSpace = 3; //f.e. "1. " |
|
2849 |
|
2850 //Create descriptor, add content to it, and finally append to line |
|
2851 TBuf<20> num; |
|
2852 |
|
2853 if(iTestCases[aLineNum].Status() == CUIStoreIf::EStatusRunning ) |
|
2854 { |
|
2855 if( iTestCases[aLineNum].UIEngineContainer().State() == CUIEngineContainer::EPaused) |
|
2856 { |
|
2857 //If not enough space, return |
|
2858 if((aLine.MaxLength() - aLine.Length()) < additionalSpace + 4) |
|
2859 { |
|
2860 return; |
|
2861 } |
|
2862 num.Format(_L("%d.(P) "), currentCount); |
|
2863 } |
|
2864 else |
|
2865 { |
|
2866 //If not enough space, return |
|
2867 if((aLine.MaxLength() - aLine.Length()) < additionalSpace) |
|
2868 { |
|
2869 return; |
|
2870 } |
|
2871 num.Format(_L("%d."), currentCount); |
|
2872 } |
|
2873 } |
|
2874 aLine.Append(num); |
|
2875 } |
|
2876 //END of --Add number to test case title-- |
|
2877 |
|
2878 |
|
2879 /* |
|
2880 ------------------------------------------------------------------------------- |
|
2881 |
|
2882 Class: CCaseMenu |
|
2883 |
|
2884 Method: SelectL |
|
2885 |
|
2886 Description: Process keypresses in menu. Handle Enter and Right Arrow |
|
2887 here, other will be handled in CMenu::SelectL |
|
2888 |
|
2889 Parameters: TKeyCode aSelection :in: Key |
|
2890 TBool& aContinue :out: Has user pressed "Quit" |
|
2891 |
|
2892 Return Values: CMenu* New menu |
|
2893 |
|
2894 Errors/Exceptions: None |
|
2895 |
|
2896 Status: Draft |
|
2897 |
|
2898 ------------------------------------------------------------------------------- |
|
2899 */ |
|
2900 CMenu* CCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
2901 { |
|
2902 |
|
2903 MapKeyCode(aSelection); |
|
2904 |
|
2905 switch (aSelection) |
|
2906 { |
|
2907 case EKeyEnter: |
|
2908 case EKeyRightArrow: |
|
2909 { |
|
2910 if ( iFirst + iPosOnScreen < iTestCases.Count() ) |
|
2911 { |
|
2912 delete iCaseOperationMenu; |
|
2913 iCaseOperationMenu = 0; |
|
2914 iCaseOperationMenu = CCaseOperationMenu::NewL( |
|
2915 iMain, |
|
2916 this, |
|
2917 iTestCases[iFirst + iPosOnScreen].TestInfo().TestCaseTitle(), |
|
2918 &iTestCases[iFirst + iPosOnScreen] ); |
|
2919 |
|
2920 return iCaseOperationMenu; |
|
2921 } |
|
2922 } |
|
2923 return this; |
|
2924 default: |
|
2925 // Let the parent class handle rest |
|
2926 return CMenu::SelectL(aSelection, aContinue); |
|
2927 } |
|
2928 |
|
2929 } |
|
2930 |
|
2931 |
|
2932 /* |
|
2933 ------------------------------------------------------------------------------- |
|
2934 |
|
2935 Class: CCaseOperationMenu |
|
2936 |
|
2937 Method: NewL |
|
2938 |
|
2939 Description: Constructs new menu. |
|
2940 |
|
2941 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
2942 CMenu* aParent :in: Parent menu |
|
2943 const TDesC& aName :in: Menu name |
|
2944 CStartedTestCase* aCaseContainer:in: Case container |
|
2945 |
|
2946 Return Values: CMenu* New menu |
|
2947 |
|
2948 Errors/Exceptions: Leaves if memory allocation fails |
|
2949 Leaves if ConstructL leaves. |
|
2950 |
|
2951 Status: Draft |
|
2952 |
|
2953 ------------------------------------------------------------------------------- |
|
2954 */ |
|
2955 CCaseOperationMenu* CCaseOperationMenu::NewL( CConsoleMain* aConsole, |
|
2956 CMenu* aParent, |
|
2957 const TDesC& aName, |
|
2958 const CStartedTestCase* aCaseContainer |
|
2959 ) |
|
2960 { |
|
2961 |
|
2962 CCaseOperationMenu* self = new ( ELeave ) CCaseOperationMenu(); |
|
2963 CleanupStack::PushL( self ); |
|
2964 self->ConstructL( aConsole, aParent, aName, aCaseContainer ); |
|
2965 CleanupStack::Pop( self ); |
|
2966 return self; |
|
2967 |
|
2968 } |
|
2969 |
|
2970 /* |
|
2971 ------------------------------------------------------------------------------- |
|
2972 |
|
2973 Class: CCaseOperationMenu |
|
2974 |
|
2975 Method: ConstructL |
|
2976 |
|
2977 Description: Second level constructor. |
|
2978 |
|
2979 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
2980 CMenu* aParent :in: Parent menu |
|
2981 const TDesC& aName :in: Menu name |
|
2982 CStartedTestCase* aCaseContainer:in: Case container |
|
2983 |
|
2984 Return Values: None |
|
2985 |
|
2986 Errors/Exceptions: None |
|
2987 |
|
2988 Status: Draft |
|
2989 |
|
2990 ------------------------------------------------------------------------------- |
|
2991 */ |
|
2992 void CCaseOperationMenu::ConstructL( CConsoleMain* aConsole, |
|
2993 CMenu* aParent, |
|
2994 const TDesC& aName, |
|
2995 const CStartedTestCase* aCaseContainer |
|
2996 ) |
|
2997 { |
|
2998 |
|
2999 CMenu::ConstructL( aConsole, aParent, aName); |
|
3000 iCaseContainer = aCaseContainer; |
|
3001 |
|
3002 // Indicate that this menu contains prints, update when needed |
|
3003 iType = CUIStoreIf::EStatusExecuted; |
|
3004 |
|
3005 } |
|
3006 |
|
3007 |
|
3008 /* |
|
3009 ------------------------------------------------------------------------------- |
|
3010 |
|
3011 Class: CMenu |
|
3012 |
|
3013 Method: ~CMenu |
|
3014 |
|
3015 Description: Destructor |
|
3016 |
|
3017 Parameters: None |
|
3018 |
|
3019 Return Values: None |
|
3020 |
|
3021 Errors/Exceptions: None |
|
3022 |
|
3023 Status: Draft |
|
3024 |
|
3025 ------------------------------------------------------------------------------- |
|
3026 */ |
|
3027 CCaseOperationMenu::~CCaseOperationMenu() |
|
3028 { |
|
3029 delete iView; |
|
3030 iView = 0; |
|
3031 } |
|
3032 |
|
3033 /* |
|
3034 ------------------------------------------------------------------------------- |
|
3035 |
|
3036 Class: CCaseOperationMenu |
|
3037 |
|
3038 Method: ItemText |
|
3039 |
|
3040 Description: Returns menu item text |
|
3041 |
|
3042 Parameters: const TInt :in: Menu index |
|
3043 |
|
3044 Return Values: const TDesC& Menu line text |
|
3045 |
|
3046 Errors/Exceptions: None |
|
3047 |
|
3048 Status: Draft |
|
3049 |
|
3050 ------------------------------------------------------------------------------- |
|
3051 */ |
|
3052 TInt CCaseOperationMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
3053 { |
|
3054 |
|
3055 if( iCaseContainer->Status() & CUIStoreIf::EStatusRunning ) |
|
3056 { |
|
3057 if( aArray.Append( KOutputViewDes ) != KErrNone ) |
|
3058 { |
|
3059 return KErrNoMemory; |
|
3060 } |
|
3061 |
|
3062 // Set resume/pause text |
|
3063 if( iCaseContainer->UIEngineContainer().State() == |
|
3064 CUIEngineContainer::EPaused ) |
|
3065 { |
|
3066 if( aArray.Append( KResumeCaseDes ) != KErrNone ) |
|
3067 { |
|
3068 return KErrNoMemory; |
|
3069 } |
|
3070 } |
|
3071 else |
|
3072 { |
|
3073 if( aArray.Append( KPauseCaseDes ) != KErrNone ) |
|
3074 { |
|
3075 return KErrNoMemory; |
|
3076 } |
|
3077 } |
|
3078 if( aArray.Append( KAbortCaseDes ) != KErrNone ) |
|
3079 { |
|
3080 return KErrNoMemory; |
|
3081 } |
|
3082 } |
|
3083 else |
|
3084 { |
|
3085 if(aArray.Append(KRestartCaseDes) != KErrNone) |
|
3086 { |
|
3087 return KErrNoMemory; |
|
3088 } |
|
3089 if( aArray.Append( KOutputViewDes ) != KErrNone ) |
|
3090 { |
|
3091 return KErrNoMemory; |
|
3092 } |
|
3093 } |
|
3094 |
|
3095 return KErrNone; |
|
3096 |
|
3097 } |
|
3098 |
|
3099 /* |
|
3100 ------------------------------------------------------------------------------- |
|
3101 Class: CMenu |
|
3102 |
|
3103 Method: PrintMenuL |
|
3104 |
|
3105 Description: Prints the menu and test case specific information after that. |
|
3106 |
|
3107 Parameters: None |
|
3108 |
|
3109 Return Values: None |
|
3110 |
|
3111 Errors/Exceptions: Leaves if FormatL leaves |
|
3112 |
|
3113 Status: Draft |
|
3114 |
|
3115 ------------------------------------------------------------------------------- |
|
3116 */ |
|
3117 void CCaseOperationMenu::PrintMenuL( TUpdateType aType ) |
|
3118 { |
|
3119 |
|
3120 // Print menu |
|
3121 CMenu::PrintMenuL( aType ); |
|
3122 |
|
3123 // Print the result description + result code |
|
3124 // If case is finished, print also result string |
|
3125 TInt state = iCaseContainer->Status(); |
|
3126 if ( ! ( state & CUIStoreIf::EStatusRunning ) ) |
|
3127 { |
|
3128 |
|
3129 TName resultLine; |
|
3130 |
|
3131 Print (_L("")); |
|
3132 resultLine.Append(_L("Result info: ") ); |
|
3133 |
|
3134 if( state & CUIStoreIf::EStatusPassed ) |
|
3135 { |
|
3136 resultLine.Append( _L("Passed" ) ); |
|
3137 } |
|
3138 else if( state & CUIStoreIf::EStatusFailed ) |
|
3139 { |
|
3140 resultLine.Append( _L("Failed" ) ); |
|
3141 } |
|
3142 else if( state & CUIStoreIf::EStatusAborted ) |
|
3143 { |
|
3144 resultLine.Append( _L("Aborted" ) ); |
|
3145 } |
|
3146 else if( state & CUIStoreIf::EStatusCrashed ) |
|
3147 { |
|
3148 resultLine.Append( _L("Crashed" ) ); |
|
3149 } |
|
3150 PrintMulti( resultLine ); |
|
3151 resultLine.Zero(); |
|
3152 |
|
3153 // Print test results |
|
3154 if( !( ( state & CUIStoreIf::EStatusAborted ) || |
|
3155 ( state & CUIStoreIf::EStatusCrashed ) || |
|
3156 ( state & CUIStoreIf::EStatusPassed ) ) ) |
|
3157 { |
|
3158 |
|
3159 resultLine.Format(_L("Result code %d"), |
|
3160 iCaseContainer->Result().iTestResult.iResult ); |
|
3161 PrintMulti ( resultLine ); |
|
3162 } |
|
3163 |
|
3164 if( iCaseContainer->Result().iCaseExecutionResultType == |
|
3165 TFullTestResult::ECaseErrorFromModule ) |
|
3166 { |
|
3167 PrintMulti ( _L("Error from RunTestCase():")); |
|
3168 } |
|
3169 |
|
3170 // Print result descriptor if that is available |
|
3171 const TDesC& des = iCaseContainer->Result().iTestResult.iResultDes; |
|
3172 if ( des.Length() >0 ) |
|
3173 { |
|
3174 PrintMulti(des); |
|
3175 } |
|
3176 |
|
3177 // Print abort code if that is available |
|
3178 if( ( state & CUIStoreIf::EStatusAborted ) || |
|
3179 ( state & CUIStoreIf::EStatusCrashed ) ) |
|
3180 { |
|
3181 // Print abort type, if that is available |
|
3182 TFullTestResult::TCaseExecutionResult res = |
|
3183 iCaseContainer->Result().iCaseExecutionResultType; |
|
3184 |
|
3185 if ( res == TFullTestResult::ECaseLeave || |
|
3186 res == TFullTestResult::ECasePanic || |
|
3187 res == TFullTestResult::ECaseException || |
|
3188 res == TFullTestResult::ECaseErrorFromModule || |
|
3189 res == TFullTestResult::ECaseSuicided ) |
|
3190 { |
|
3191 TInt code = iCaseContainer->Result().iCaseExecutionResultCode; |
|
3192 resultLine.Format(_L("Code %d (0x%x)"), code, code ); |
|
3193 PrintMulti ( resultLine ); |
|
3194 } |
|
3195 } |
|
3196 |
|
3197 // Print start and end times |
|
3198 const TInt KTimeFieldLength = 30; |
|
3199 TBuf<KTimeFieldLength> time; |
|
3200 _LIT(KDateString,"%-B%:0%J%:1%T%:2%S%.%*C4%:3%+B"); |
|
3201 |
|
3202 resultLine = _L("Started:"); |
|
3203 iCaseContainer->Result().iStartTime.FormatL(time,KDateString); |
|
3204 resultLine.Append(time); |
|
3205 PrintMulti (resultLine); |
|
3206 |
|
3207 resultLine = _L("Completed:"); |
|
3208 iCaseContainer->Result().iEndTime.FormatL(time,KDateString); |
|
3209 |
|
3210 resultLine.Append(time); |
|
3211 PrintMulti (resultLine); |
|
3212 |
|
3213 } |
|
3214 |
|
3215 } |
|
3216 |
|
3217 /* |
|
3218 ------------------------------------------------------------------------------- |
|
3219 |
|
3220 Class: CCaseOperationMenu |
|
3221 |
|
3222 Method: SelectL |
|
3223 |
|
3224 Description: Process keypresses in menu. Handle Enter and right arrow |
|
3225 here, others are handled in parent menu. |
|
3226 |
|
3227 Parameters: TKeyCode aSelection :in: Key |
|
3228 TBool& aContinue :out: Has user pressed "Quit" |
|
3229 |
|
3230 Return Values: CMenu* New menu |
|
3231 |
|
3232 Errors/Exceptions: None |
|
3233 |
|
3234 Status: Draft |
|
3235 |
|
3236 ------------------------------------------------------------------------------- |
|
3237 */ |
|
3238 CMenu* CCaseOperationMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
3239 { |
|
3240 |
|
3241 MapKeyCode(aSelection); |
|
3242 |
|
3243 if (aSelection == EKeyEnter || aSelection == EKeyRightArrow ) |
|
3244 { |
|
3245 // restartOptionModifier is used because when test case is running |
|
3246 // restart option is not available (and visible) and that's why |
|
3247 // we need to modify switch by 1. |
|
3248 // When test case is finished, restart option becomes available |
|
3249 // and is put at the first place. |
|
3250 TInt restartOptionModifier = 0; |
|
3251 if(iCaseContainer->Status() & CUIStoreIf::EStatusRunning) |
|
3252 restartOptionModifier = 1; |
|
3253 |
|
3254 switch (iPosOnScreen + iFirst + restartOptionModifier) |
|
3255 { |
|
3256 case ERestartCase: |
|
3257 { |
|
3258 TInt index; |
|
3259 User::LeaveIfError(iMain->UIStore().StartTestCase(iCaseContainer->TestInfo(), index)); |
|
3260 // Create output screen |
|
3261 CMenu* m = iMain->GetMainMenu()->CreateOutputViewL(iParent); |
|
3262 return m; |
|
3263 } |
|
3264 case EOutputView: |
|
3265 { |
|
3266 delete iView; |
|
3267 iView = 0; |
|
3268 iView = CCaseExecutionView::NewL( |
|
3269 iMain, |
|
3270 this, |
|
3271 iCaseContainer->TestInfo().TestCaseTitle(), |
|
3272 iCaseContainer ); |
|
3273 |
|
3274 return iView; |
|
3275 } |
|
3276 |
|
3277 case EPauseResume: |
|
3278 |
|
3279 if( iCaseContainer->UIEngineContainer().State() == |
|
3280 CUIEngineContainer::ERunning ) |
|
3281 { |
|
3282 // Pausing a running case |
|
3283 iCaseContainer->UIEngineContainer().PauseTest(); |
|
3284 |
|
3285 } |
|
3286 else if( iCaseContainer->UIEngineContainer().State() == |
|
3287 CUIEngineContainer::EPaused ) |
|
3288 { |
|
3289 // Resuming a paused case |
|
3290 iCaseContainer->UIEngineContainer().ResumeTest(); |
|
3291 |
|
3292 } |
|
3293 // No other possibilities |
|
3294 return this; |
|
3295 |
|
3296 case EAbortCase: |
|
3297 iCaseContainer->UIEngineContainer().CancelTest(); |
|
3298 break; |
|
3299 |
|
3300 } |
|
3301 |
|
3302 return this; |
|
3303 } |
|
3304 else |
|
3305 { |
|
3306 return CMenu::SelectL(aSelection, aContinue); |
|
3307 } |
|
3308 |
|
3309 } |
|
3310 |
|
3311 |
|
3312 |
|
3313 /* |
|
3314 ------------------------------------------------------------------------------- |
|
3315 |
|
3316 Class: CCaseExecutionView |
|
3317 |
|
3318 Method: NewL |
|
3319 |
|
3320 Description: Constructs new menu. |
|
3321 |
|
3322 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
3323 CMenu* aParent :in: Parent menu |
|
3324 const TDesC& aName :in: Menu name |
|
3325 CStartedTestCase* aCase :in: Case container |
|
3326 |
|
3327 Return Values: CMenu* New menu |
|
3328 |
|
3329 Errors/Exceptions: Leaves if memory allocation fails |
|
3330 Leaves if ConstructL leaves. |
|
3331 |
|
3332 Status: Draft |
|
3333 |
|
3334 ------------------------------------------------------------------------------- |
|
3335 */ |
|
3336 CCaseExecutionView* CCaseExecutionView::NewL( CConsoleMain* aConsole, |
|
3337 CMenu* aParent, |
|
3338 const TDesC& aName, |
|
3339 const CStartedTestCase* aCase ) |
|
3340 { |
|
3341 |
|
3342 CCaseExecutionView* self = new ( ELeave ) CCaseExecutionView(); |
|
3343 CleanupStack::PushL( self ); |
|
3344 self->ConstructL( aConsole, aParent, aName, aCase ); |
|
3345 CleanupStack::Pop( self ); |
|
3346 return self; |
|
3347 |
|
3348 } |
|
3349 |
|
3350 /* |
|
3351 ------------------------------------------------------------------------------- |
|
3352 |
|
3353 Class: CCaseExecutionView |
|
3354 |
|
3355 Method: ConstructL |
|
3356 |
|
3357 Description: Second level constructor. |
|
3358 |
|
3359 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
3360 CMenu* aParent :in: Parent menu |
|
3361 const TDesC& aName :in: Menu name |
|
3362 CStartedTestCase* aCase :in: Case container |
|
3363 |
|
3364 Return Values: None |
|
3365 |
|
3366 Errors/Exceptions: Leaves if parent class ConstructL leaves |
|
3367 |
|
3368 Status: Draft |
|
3369 |
|
3370 ------------------------------------------------------------------------------- |
|
3371 */ |
|
3372 void CCaseExecutionView::ConstructL( CConsoleMain* aConsole, |
|
3373 CMenu* aParent, |
|
3374 const TDesC& aName, |
|
3375 const CStartedTestCase* aCase |
|
3376 ) |
|
3377 { |
|
3378 |
|
3379 CMenu::ConstructL( aConsole, aParent, aName ); |
|
3380 |
|
3381 iCase = aCase; |
|
3382 |
|
3383 // Indicate that this menu contains prints, update when needed |
|
3384 iType = CUIStoreIf::EPrintUpdate; |
|
3385 |
|
3386 iLine = 0; |
|
3387 |
|
3388 } |
|
3389 |
|
3390 /* |
|
3391 ------------------------------------------------------------------------------- |
|
3392 |
|
3393 CCaseExecutionView |
|
3394 |
|
3395 Method: ~CCaseExecutionView |
|
3396 |
|
3397 Description: Destructor |
|
3398 |
|
3399 Parameters: None |
|
3400 |
|
3401 Return Values: None |
|
3402 |
|
3403 Errors/Exceptions: None |
|
3404 |
|
3405 Status: Draft |
|
3406 |
|
3407 ------------------------------------------------------------------------------- |
|
3408 */ |
|
3409 CCaseExecutionView::~CCaseExecutionView() |
|
3410 { |
|
3411 delete iLineTextBuf; |
|
3412 |
|
3413 } |
|
3414 |
|
3415 /* |
|
3416 ------------------------------------------------------------------------------- |
|
3417 Class: CMenu |
|
3418 |
|
3419 Method: PrintMenuL |
|
3420 |
|
3421 Description: Prints the menu. Show the test status and the test case |
|
3422 print statements. |
|
3423 |
|
3424 Parameters: None |
|
3425 |
|
3426 Return Values: None |
|
3427 |
|
3428 Errors/Exceptions: None |
|
3429 |
|
3430 Status: Draft |
|
3431 |
|
3432 ------------------------------------------------------------------------------- |
|
3433 */ |
|
3434 void CCaseExecutionView::PrintMenuL( TUpdateType /*aType*/ ) |
|
3435 { |
|
3436 |
|
3437 if( iShowLine ) |
|
3438 { |
|
3439 // User want to see whole line |
|
3440 iConsole->ClearScreen(); |
|
3441 this->PrintMulti( iLineTextBuf->Des() ); |
|
3442 return; |
|
3443 } |
|
3444 |
|
3445 // Print the status |
|
3446 TName tmp; |
|
3447 TInt state = iCase->Status(); |
|
3448 if( state & CUIStoreIf::EStatusRunning ) |
|
3449 { |
|
3450 if( iCase->UIEngineContainer().State() == |
|
3451 CUIEngineContainer::EPaused ) |
|
3452 { |
|
3453 tmp = _L("Paused"); |
|
3454 } |
|
3455 else |
|
3456 { |
|
3457 tmp = _L("Running"); |
|
3458 } |
|
3459 } |
|
3460 else if( state & CUIStoreIf::EStatusPassed ) |
|
3461 { |
|
3462 tmp = _L("Passed"); |
|
3463 } |
|
3464 else if( state & CUIStoreIf::EStatusFailed ) |
|
3465 { |
|
3466 tmp = _L("Failed"); |
|
3467 } |
|
3468 else if( state & CUIStoreIf::EStatusAborted ) |
|
3469 { |
|
3470 tmp = _L("Aborted"); |
|
3471 } |
|
3472 else if( state & CUIStoreIf::EStatusCrashed ) |
|
3473 { |
|
3474 tmp = _L("Aborted"); |
|
3475 } |
|
3476 else |
|
3477 { |
|
3478 tmp = _L("Unknown"); |
|
3479 } |
|
3480 |
|
3481 // Clear screen. |
|
3482 iConsole->ClearScreen(); |
|
3483 TBuf<KMaxLineLength> line; |
|
3484 |
|
3485 line.Append(_L(" : ")); |
|
3486 LimitedAppend(line, iCase->TestInfo().TestCaseTitle() ); |
|
3487 Print( line ); |
|
3488 |
|
3489 const RPointerArray<CTestProgress>& prints = iCase->PrintArray(); |
|
3490 |
|
3491 Recalculate( prints.Count() ); |
|
3492 |
|
3493 // Print the print statements. |
|
3494 for ( TInt i = iFirst; i <= iLast; i++ ) |
|
3495 { |
|
3496 line.Zero(); |
|
3497 if( iLine == i ) |
|
3498 { |
|
3499 line = _L( "*" ); // For indicating current line |
|
3500 } |
|
3501 line.Append( prints[i]->iDescription ); |
|
3502 line.Append(_L(" : ")); |
|
3503 LimitedAppend(line, prints[i]->iText ); |
|
3504 |
|
3505 // Print the line |
|
3506 TSize screenSize; |
|
3507 screenSize = iConsole->ScreenSize(); |
|
3508 Print ( line.Left(screenSize.iWidth ) ); |
|
3509 } |
|
3510 |
|
3511 } |
|
3512 |
|
3513 /* |
|
3514 ------------------------------------------------------------------------------- |
|
3515 |
|
3516 Class: CCaseExecutionView |
|
3517 |
|
3518 Method: SelectL |
|
3519 |
|
3520 Description: Process keypresses in menu. Either updates position in |
|
3521 menu or returns new menu. |
|
3522 |
|
3523 Parameters: TKeyCode aSelection: in: Key |
|
3524 TBool& aContinue: out: Has user pressed "Quit" |
|
3525 |
|
3526 Return Values: CMenu* New menu |
|
3527 |
|
3528 Errors/Exceptions: None |
|
3529 |
|
3530 Status: Draft |
|
3531 |
|
3532 ------------------------------------------------------------------------------- |
|
3533 */ |
|
3534 CMenu* CCaseExecutionView::SelectL( TKeyCode aSelection, TBool& /*aContinue*/ ) |
|
3535 { |
|
3536 iShowLine = EFalse; |
|
3537 MapKeyCode(aSelection); |
|
3538 |
|
3539 // Take prints |
|
3540 const RPointerArray<CTestProgress>& prints = iCase->PrintArray(); |
|
3541 |
|
3542 switch( aSelection ) |
|
3543 { |
|
3544 case EKeyEnter: |
|
3545 case EKeyRightArrow: |
|
3546 { |
|
3547 // Check that not out of range(too many EKeyUpArrow or EKeyDownArrow) |
|
3548 if( iLine >= prints.Count() || iLine < 0) |
|
3549 { |
|
3550 // do nothing |
|
3551 break; |
|
3552 } |
|
3553 TInt extra = 3; // ' : ' |
|
3554 TInt length( 0 ); |
|
3555 length = length + prints[iLine]->iDescription.Length(); |
|
3556 length = length + prints[iLine]->iText.Length(); |
|
3557 // Selected print line in seperate(operation will do in |
|
3558 // CCaseExecutionView::PrintMenuL() method ) |
|
3559 delete iLineTextBuf; |
|
3560 iLineTextBuf = NULL; |
|
3561 TRAPD( ret, iLineTextBuf = HBufC::NewL( length + extra ) ); |
|
3562 if( ret != KErrNone ) |
|
3563 { |
|
3564 User::InfoPrint( _L("Line show failed, maybe out of memory!!!") ); |
|
3565 break; |
|
3566 } |
|
3567 TPtr ptr = iLineTextBuf->Des(); |
|
3568 ptr.Copy( prints[iLine]->iDescription ); |
|
3569 ptr.Append( _L( " : " ) ); |
|
3570 ptr.Append( prints[iLine]->iText ); |
|
3571 iShowLine = ETrue; |
|
3572 break; |
|
3573 } |
|
3574 case EKeyLeftArrow: |
|
3575 { |
|
3576 return iParent; |
|
3577 } |
|
3578 // Go down |
|
3579 case EKeyDownArrow: |
|
3580 { |
|
3581 if ( iFirst + iPosOnScreen == iItemCount - 1 ) |
|
3582 { |
|
3583 // If end of the list, go to beginning |
|
3584 iPosOnScreen = 0; |
|
3585 iFirst = 0; |
|
3586 iLast = iScreenSize; |
|
3587 if ( iLast > iItemCount - 1 ) |
|
3588 { |
|
3589 iLast = iItemCount - 1; |
|
3590 } |
|
3591 iLine = 0; |
|
3592 } |
|
3593 else |
|
3594 { |
|
3595 if ( iPosOnScreen == iScreenSize ) |
|
3596 { |
|
3597 iLast++; |
|
3598 iFirst++; |
|
3599 } |
|
3600 else |
|
3601 { |
|
3602 // Going down "in-screen", no need to update items |
|
3603 iPosOnScreen++; |
|
3604 } |
|
3605 iLine++; |
|
3606 } |
|
3607 break; |
|
3608 } |
|
3609 |
|
3610 // Go Up |
|
3611 case EKeyUpArrow: |
|
3612 { |
|
3613 if ( iFirst + iPosOnScreen == 0 ) |
|
3614 { |
|
3615 // If in the beginning of the list |
|
3616 |
|
3617 iLast = iItemCount - 1; |
|
3618 iFirst = iLast - iScreenSize; |
|
3619 if ( iFirst < 0 ) |
|
3620 { |
|
3621 iFirst = 0; |
|
3622 } |
|
3623 iPosOnScreen = iLast - iFirst; |
|
3624 iLine = iItemCount - 1; |
|
3625 } |
|
3626 else |
|
3627 { |
|
3628 if ( iPosOnScreen == 0 ) |
|
3629 { |
|
3630 iLast--; |
|
3631 iFirst--; |
|
3632 } |
|
3633 else |
|
3634 { |
|
3635 iPosOnScreen--; |
|
3636 } |
|
3637 iLine--; |
|
3638 } |
|
3639 break; |
|
3640 } |
|
3641 // Additional keys |
|
3642 case EKeyHome: |
|
3643 case '3': |
|
3644 iPosOnScreen = 0; |
|
3645 iLine = 0; |
|
3646 iFirst = 0; |
|
3647 iLast = iScreenSize; |
|
3648 |
|
3649 if ( iLast > iItemCount - 1 ) |
|
3650 { |
|
3651 iLast = iItemCount - 1; |
|
3652 } |
|
3653 break; |
|
3654 |
|
3655 case EKeyEnd: |
|
3656 case '9': |
|
3657 iLast = iItemCount - 1; |
|
3658 iFirst = iLast - iScreenSize; |
|
3659 iLine = iItemCount - 1; |
|
3660 |
|
3661 if ( iFirst < 0 ) |
|
3662 { |
|
3663 iFirst = 0; |
|
3664 } |
|
3665 iPosOnScreen = iLast - iFirst; |
|
3666 break; |
|
3667 |
|
3668 case EKeyPageUp: |
|
3669 case '1': |
|
3670 iFirst = iFirst - iScreenSize; |
|
3671 iLast = iLast - iScreenSize; |
|
3672 |
|
3673 if ( iFirst < 0 ) |
|
3674 { |
|
3675 iFirst = 0; |
|
3676 iLast = iScreenSize; |
|
3677 if ( iLast > iItemCount - 1 ) |
|
3678 { |
|
3679 iLast = iItemCount - 1; |
|
3680 } |
|
3681 iPosOnScreen = 0; |
|
3682 } |
|
3683 |
|
3684 iLine = iLine - iScreenSize; |
|
3685 if ( iLine < 0 ) |
|
3686 { |
|
3687 iLine = 0; |
|
3688 } |
|
3689 break; |
|
3690 |
|
3691 case EKeyPageDown: |
|
3692 case '7': |
|
3693 iFirst = iFirst + iScreenSize; |
|
3694 iLast = iLast + iScreenSize; |
|
3695 |
|
3696 // Going too far |
|
3697 if ( iLast > iItemCount - 1 ) |
|
3698 { |
|
3699 iLast = iItemCount - 1; |
|
3700 iFirst = iLast - iScreenSize; |
|
3701 if ( iFirst < 0 ) |
|
3702 { |
|
3703 iFirst = 0; |
|
3704 } |
|
3705 iPosOnScreen = iLast - iFirst; |
|
3706 } |
|
3707 |
|
3708 iLine = iLine + iScreenSize; |
|
3709 if ( iLine > iItemCount - 1 ) |
|
3710 { |
|
3711 iLine = iItemCount - 1; |
|
3712 } |
|
3713 break; |
|
3714 default: |
|
3715 { |
|
3716 break; |
|
3717 } |
|
3718 } |
|
3719 |
|
3720 return this; |
|
3721 |
|
3722 } |
|
3723 |
|
3724 /* |
|
3725 ------------------------------------------------------------------------------- |
|
3726 |
|
3727 Class: CTestSetMenu |
|
3728 |
|
3729 Method: NewL |
|
3730 |
|
3731 Description: Constructs new menu. |
|
3732 |
|
3733 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
3734 CMenu* aParent :in: Parent menu |
|
3735 const TDesC& aName :in: Menu name |
|
3736 |
|
3737 Return Values: CMenu* New menu |
|
3738 |
|
3739 Errors/Exceptions: Leaves if memory allocation fails |
|
3740 Leaves if ConstructL leaves. |
|
3741 |
|
3742 Status: Draft |
|
3743 |
|
3744 ------------------------------------------------------------------------------- |
|
3745 */ |
|
3746 CTestSetMenu* CTestSetMenu::NewL( CConsoleMain* aConsole, |
|
3747 CMenu* aParent, |
|
3748 const TDesC& aName ) |
|
3749 { |
|
3750 |
|
3751 CTestSetMenu* self = new ( ELeave ) CTestSetMenu(); |
|
3752 CleanupStack::PushL( self ); |
|
3753 self->ConstructL( aConsole, aParent, aName ); |
|
3754 CleanupStack::Pop( self ); |
|
3755 return self; |
|
3756 |
|
3757 } |
|
3758 |
|
3759 /* |
|
3760 ------------------------------------------------------------------------------- |
|
3761 |
|
3762 Class: CTestSetMenu |
|
3763 |
|
3764 Method: CTestSetMenu |
|
3765 |
|
3766 Description: Constructor |
|
3767 |
|
3768 Parameters: None |
|
3769 |
|
3770 Return Values: None |
|
3771 |
|
3772 Errors/Exceptions: None |
|
3773 |
|
3774 Status: Draft |
|
3775 |
|
3776 ------------------------------------------------------------------------------- |
|
3777 */ |
|
3778 CTestSetMenu::CTestSetMenu(): |
|
3779 iTestSetCreated( EFalse ) |
|
3780 { |
|
3781 |
|
3782 iTestSetName.Copy( KDefaultSetName ); |
|
3783 |
|
3784 } |
|
3785 |
|
3786 /* |
|
3787 ------------------------------------------------------------------------------- |
|
3788 |
|
3789 Class: CTestSetMenu |
|
3790 |
|
3791 Method: ~CTestSetMenu |
|
3792 |
|
3793 Description: Destructor |
|
3794 |
|
3795 Parameters: None |
|
3796 |
|
3797 Return Values: None |
|
3798 |
|
3799 Errors/Exceptions: None |
|
3800 |
|
3801 Status: Draft |
|
3802 |
|
3803 ------------------------------------------------------------------------------- |
|
3804 */ |
|
3805 CTestSetMenu::~CTestSetMenu() |
|
3806 { |
|
3807 |
|
3808 delete iSubMenu; |
|
3809 iSubMenu = 0; |
|
3810 |
|
3811 } |
|
3812 |
|
3813 /* |
|
3814 ------------------------------------------------------------------------------- |
|
3815 |
|
3816 Class: CTestSetMenu |
|
3817 |
|
3818 Method: ConstructL |
|
3819 |
|
3820 Description: Second level constructor. |
|
3821 |
|
3822 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
3823 CMenu* aParent :in: Parent menu |
|
3824 const TDesC& aName :in: Menu name |
|
3825 |
|
3826 Return Values: None |
|
3827 |
|
3828 Errors/Exceptions: Leaves if parent class ConstructL leaves |
|
3829 Leaves if module can't be appended to list |
|
3830 |
|
3831 Status: Draft |
|
3832 |
|
3833 ------------------------------------------------------------------------------- |
|
3834 */ |
|
3835 void CTestSetMenu::ConstructL( CConsoleMain* aConsole, |
|
3836 CMenu* aParent, |
|
3837 const TDesC& aName |
|
3838 ) |
|
3839 { |
|
3840 |
|
3841 CMenu::ConstructL( aConsole, aParent, aName); |
|
3842 |
|
3843 } |
|
3844 |
|
3845 /* |
|
3846 ------------------------------------------------------------------------------- |
|
3847 |
|
3848 Class: CTestSetMenu |
|
3849 |
|
3850 Method: SetTestSetName |
|
3851 |
|
3852 Description: Set test set name. |
|
3853 |
|
3854 Parameters: const TFileName& aTestSetName: in: Test set name |
|
3855 |
|
3856 Return Values: None |
|
3857 |
|
3858 Errors/Exceptions: None |
|
3859 |
|
3860 Status: Draft |
|
3861 |
|
3862 ------------------------------------------------------------------------------- |
|
3863 */ |
|
3864 void CTestSetMenu::SetTestSetFileName( const TFileName& aTestSetName ) |
|
3865 { |
|
3866 |
|
3867 iTestSetName.Copy( aTestSetName ); |
|
3868 |
|
3869 } |
|
3870 |
|
3871 /* |
|
3872 ------------------------------------------------------------------------------- |
|
3873 |
|
3874 Class: CTestSetMenu |
|
3875 |
|
3876 Method: ItemText |
|
3877 |
|
3878 Description: Returns menu item text. |
|
3879 |
|
3880 Parameters: const TInt :in: Menu index |
|
3881 |
|
3882 Return Values: const TDesC& Menu line text |
|
3883 |
|
3884 Errors/Exceptions: None |
|
3885 |
|
3886 Status: Draft |
|
3887 |
|
3888 ------------------------------------------------------------------------------- |
|
3889 */ |
|
3890 TInt CTestSetMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
3891 { |
|
3892 |
|
3893 if( !iTestSetCreated ) |
|
3894 { |
|
3895 if( aArray.Append( KSetCreate ) != KErrNone ) |
|
3896 { |
|
3897 return KErrNoMemory; |
|
3898 } |
|
3899 if( aArray.Append( KSetLoad ) != KErrNone ) |
|
3900 { |
|
3901 return KErrNoMemory; |
|
3902 } |
|
3903 } |
|
3904 else |
|
3905 { |
|
3906 if( aArray.Append( KSetShow ) != KErrNone ) |
|
3907 { |
|
3908 return KErrNoMemory; |
|
3909 } |
|
3910 if( aArray.Append( KSetStartSeq ) != KErrNone ) |
|
3911 { |
|
3912 return KErrNoMemory; |
|
3913 } |
|
3914 if( aArray.Append( KSetStartPar ) != KErrNone ) |
|
3915 { |
|
3916 return KErrNoMemory; |
|
3917 } |
|
3918 if( aArray.Append( KSetRemove ) != KErrNone ) |
|
3919 { |
|
3920 return KErrNoMemory; |
|
3921 } |
|
3922 if( aArray.Append( KSetSave ) != KErrNone ) |
|
3923 { |
|
3924 return KErrNoMemory; |
|
3925 } |
|
3926 if( aArray.Append( KSetCaseAdd ) != KErrNone ) |
|
3927 { |
|
3928 return KErrNoMemory; |
|
3929 } |
|
3930 if( aArray.Append( KSetCaseRemove ) != KErrNone ) |
|
3931 { |
|
3932 return KErrNoMemory; |
|
3933 } |
|
3934 if( aArray.Append( KSetStartSeqNotRun ) != KErrNone ) |
|
3935 { |
|
3936 return KErrNoMemory; |
|
3937 } |
|
3938 } |
|
3939 |
|
3940 return KErrNone; |
|
3941 |
|
3942 } |
|
3943 |
|
3944 /* |
|
3945 ------------------------------------------------------------------------------- |
|
3946 Class: CTestSetMenu |
|
3947 |
|
3948 Method: PrintMenuL |
|
3949 |
|
3950 Description: Prints the menu |
|
3951 |
|
3952 Parameters: None |
|
3953 |
|
3954 Return Values: None |
|
3955 |
|
3956 Errors/Exceptions: None |
|
3957 |
|
3958 Status: Draft |
|
3959 |
|
3960 ------------------------------------------------------------------------------- |
|
3961 */ |
|
3962 void CTestSetMenu::PrintMenuL( TUpdateType aType ) |
|
3963 { |
|
3964 |
|
3965 if( iTestSetCreated ) |
|
3966 { |
|
3967 RRefArray<CTestSetInfo> setInfos; |
|
3968 TInt ret = iMain->UIStore().TestSets( setInfos ); |
|
3969 |
|
3970 CMenu::PrintMenuL( aType ); |
|
3971 |
|
3972 if( ( ret != KErrNone ) || |
|
3973 ( setInfos.Count() != 1 ) ) |
|
3974 { |
|
3975 // Should never ever happen |
|
3976 User::Panic( KTestSetMenu, KErrGeneral ); |
|
3977 return; |
|
3978 } |
|
3979 const CTestSetInfo& set = setInfos[0]; |
|
3980 setInfos.Reset(); |
|
3981 setInfos.Close(); |
|
3982 |
|
3983 const RRefArray<const CTestInfo> testCases = set.TestCases(); |
|
3984 |
|
3985 TBuf<KMaxLineLength> line; |
|
3986 TInt count = testCases.Count(); |
|
3987 for(TInt i = 0; i < count && i + ESetLAST <= iScreenSize; i++) |
|
3988 { |
|
3989 line = _L(" "); |
|
3990 LimitedAppend ( line, testCases[i].TestCaseTitle() ); |
|
3991 |
|
3992 // Print the line |
|
3993 Print(line); |
|
3994 } |
|
3995 } |
|
3996 else |
|
3997 { |
|
3998 CMenu::PrintMenuL( aType ); |
|
3999 } |
|
4000 |
|
4001 } |
|
4002 |
|
4003 /* |
|
4004 ------------------------------------------------------------------------------- |
|
4005 |
|
4006 Class: CTestSetMenu |
|
4007 |
|
4008 Method: SelectL |
|
4009 |
|
4010 Description: Process keypresses in menu. Handle right arrow and enter |
|
4011 here, others in parent menu. |
|
4012 |
|
4013 Parameters: TKeyCode aSelection :in: Key |
|
4014 TBool& aContinue :out: Has user pressed "Quit" |
|
4015 |
|
4016 Return Values: CMenu* New menu |
|
4017 |
|
4018 Errors/Exceptions: None |
|
4019 |
|
4020 Status: Draft |
|
4021 |
|
4022 ------------------------------------------------------------------------------- |
|
4023 */ |
|
4024 CMenu* CTestSetMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
4025 { |
|
4026 TBuf<32> currSetName; |
|
4027 MapKeyCode(aSelection); |
|
4028 |
|
4029 if( ( aSelection != EKeyRightArrow ) && |
|
4030 ( aSelection != EKeyEnter ) ) |
|
4031 { |
|
4032 return CMenu::SelectL( aSelection, aContinue ); |
|
4033 } |
|
4034 |
|
4035 TInt ret = KErrNone; |
|
4036 if( !iTestSetCreated ) |
|
4037 { |
|
4038 switch( iPosOnScreen ) |
|
4039 { |
|
4040 case ESetCreate: |
|
4041 ret = iMain->UIStore().CreateTestSet( iTestSetName ); |
|
4042 if( ret != KErrNone ) |
|
4043 { |
|
4044 User::InfoPrint( _L("Test set creation failed") ); |
|
4045 } |
|
4046 break; |
|
4047 case ESetLoad: |
|
4048 |
|
4049 return iItems[0]; |
|
4050 } |
|
4051 if( ret == KErrNone ) |
|
4052 { |
|
4053 iTestSetCreated = ETrue; |
|
4054 } |
|
4055 } |
|
4056 else |
|
4057 { |
|
4058 CStartedTestSet::TSetType setType = CStartedTestSet::ESetSequential; |
|
4059 switch( iPosOnScreen ) |
|
4060 { |
|
4061 case ESetShow: |
|
4062 // Add the test sets menu |
|
4063 delete iSubMenu; |
|
4064 iSubMenu = 0; |
|
4065 iSubMenu = CStartedTestSetMenu::NewL( iMain, |
|
4066 this, |
|
4067 _L("Started test sets menu")); |
|
4068 return iSubMenu; |
|
4069 case ESetRemove: |
|
4070 ret = iMain->UIStore().RemoveTestSet( iTestSetName ); |
|
4071 if( ret != KErrNone ) |
|
4072 { |
|
4073 User::InfoPrint( _L("Test set creation failed") ); |
|
4074 } |
|
4075 iTestSetCreated = EFalse; |
|
4076 break; |
|
4077 case ESetCaseAdd: |
|
4078 delete iSubMenu; |
|
4079 iSubMenu = 0; |
|
4080 iSubMenu = CTestSetAddCaseMenu::NewL( |
|
4081 iMain, |
|
4082 this, |
|
4083 _L("Add test cases to test set"), |
|
4084 iTestSetName ); |
|
4085 |
|
4086 return iSubMenu; |
|
4087 case ESetCaseRemove: |
|
4088 delete iSubMenu; |
|
4089 iSubMenu = 0; |
|
4090 iSubMenu = CTestSetRemoveCaseMenu::NewL( |
|
4091 iMain, |
|
4092 this, |
|
4093 _L("Remove test cases from test set"), |
|
4094 iTestSetName ); |
|
4095 |
|
4096 |
|
4097 return iSubMenu; |
|
4098 case ESetSave: |
|
4099 // during the save operation default set name (ConsoleUI.set) is replaced with |
|
4100 // new name created base on current date. |
|
4101 // Set is the reloaded to make sure that |
|
4102 // old test set with default name will not affect test execution |
|
4103 currSetName.Copy( iTestSetName ); |
|
4104 ret = iMain->UIStore().SaveTestSet2( iTestSetName ); |
|
4105 if( ret != KErrNone ) |
|
4106 { |
|
4107 User::InfoPrint( _L("Test set saving failed at saving test set") ); |
|
4108 } |
|
4109 |
|
4110 ret = iMain->UIStore().RemoveTestSet( currSetName ); |
|
4111 if( ret != KErrNone ) |
|
4112 { |
|
4113 User::InfoPrint( _L("Test set saving failed at removing old test set") ); |
|
4114 } |
|
4115 |
|
4116 ret = iMain->UIStore().LoadTestSet( iTestSetName ); |
|
4117 if( ret != KErrNone ) |
|
4118 { |
|
4119 User::InfoPrint( _L("Test set saving failed at reloding test set") ); |
|
4120 } |
|
4121 break; |
|
4122 |
|
4123 default: |
|
4124 // case ESetStartPar: |
|
4125 // setType = CStartedTestSet::ESetParallel; |
|
4126 // case ESetStartSeq: |
|
4127 //case ESetStartRep: |
|
4128 if( iPosOnScreen == ESetStartPar ) |
|
4129 { |
|
4130 setType = CStartedTestSet::ESetParallel; |
|
4131 } |
|
4132 if( iPosOnScreen == ESetStartSeq || iPosOnScreen == ESetStartSeqNotRun) |
|
4133 { |
|
4134 RRefArray<CTestSetInfo> setInfos; |
|
4135 ret = iMain->UIStore().TestSets( setInfos ); |
|
4136 if( ( ret != KErrNone ) || |
|
4137 ( setInfos.Count() != 1 ) ) |
|
4138 { |
|
4139 // Should never ever happen |
|
4140 User::Panic( KTestSetMenu, KErrGeneral ); |
|
4141 } |
|
4142 const CTestSetInfo& set = setInfos[0]; |
|
4143 setInfos.Reset(); |
|
4144 setInfos.Close(); |
|
4145 |
|
4146 TInt index; |
|
4147 ret = KErrGeneral; |
|
4148 if(iPosOnScreen == ESetStartSeq) |
|
4149 { |
|
4150 ret = iMain->UIStore().StartTestSet(set, index, setType); |
|
4151 } |
|
4152 else if(iPosOnScreen == ESetStartSeqNotRun) |
|
4153 { |
|
4154 ret = iMain->UIStore().StartTestSet(set, index, setType, ETrue); |
|
4155 } |
|
4156 if( ret != KErrNone ) |
|
4157 { |
|
4158 User::InfoPrint( _L("Test set starting failed") ); |
|
4159 } |
|
4160 } |
|
4161 break; |
|
4162 } |
|
4163 } |
|
4164 |
|
4165 return this; |
|
4166 |
|
4167 } |
|
4168 /** |
|
4169 ------------------------------------------------------------------------------- |
|
4170 |
|
4171 Class: CTestSetChoiceMenu |
|
4172 |
|
4173 Method: NewL |
|
4174 |
|
4175 Description: Constructs new menu. |
|
4176 |
|
4177 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
4178 CMenu* aParent :in: Parent menu |
|
4179 const TDesC& aName :in: Menu name |
|
4180 |
|
4181 Return Values: CMenu* New menu |
|
4182 |
|
4183 Errors/Exceptions: Leaves if memory allocation fails |
|
4184 Leaves if ConstructL leaves. |
|
4185 |
|
4186 Status: Draft |
|
4187 |
|
4188 ------------------------------------------------------------------------------- |
|
4189 */ |
|
4190 CTestSetChoiceMenu* CTestSetChoiceMenu::NewL( CConsoleMain* aConsole, |
|
4191 CMenu* aParent, |
|
4192 const TDesC& aName ) |
|
4193 { |
|
4194 |
|
4195 CTestSetChoiceMenu* self = new ( ELeave ) CTestSetChoiceMenu(); |
|
4196 CleanupStack::PushL( self ); |
|
4197 self->ConstructL( aConsole, aParent, aName ); |
|
4198 CleanupStack::Pop( self ); |
|
4199 return self; |
|
4200 |
|
4201 } |
|
4202 /* |
|
4203 ------------------------------------------------------------------------------- |
|
4204 |
|
4205 Class: CTestSetChoiceMenu |
|
4206 |
|
4207 Method: CTestSetChoiceMenu |
|
4208 |
|
4209 Description: Constructor |
|
4210 |
|
4211 Parameters: None |
|
4212 |
|
4213 Return Values: None |
|
4214 |
|
4215 Errors/Exceptions: None |
|
4216 |
|
4217 Status: Draft |
|
4218 |
|
4219 ------------------------------------------------------------------------------- |
|
4220 */ |
|
4221 CTestSetChoiceMenu::CTestSetChoiceMenu() |
|
4222 |
|
4223 { |
|
4224 |
|
4225 } |
|
4226 |
|
4227 /* |
|
4228 ------------------------------------------------------------------------------- |
|
4229 |
|
4230 Class: CTestSetChoiceMenu |
|
4231 |
|
4232 Method: ~CTestSetChoiceMenu |
|
4233 |
|
4234 Description: Destructor |
|
4235 |
|
4236 Parameters: None |
|
4237 |
|
4238 Return Values: None |
|
4239 |
|
4240 Errors/Exceptions: None |
|
4241 |
|
4242 Status: Draft |
|
4243 |
|
4244 ------------------------------------------------------------------------------- |
|
4245 */ |
|
4246 CTestSetChoiceMenu::~CTestSetChoiceMenu() |
|
4247 { |
|
4248 |
|
4249 |
|
4250 |
|
4251 iFileList.ResetAndDestroy(); |
|
4252 iFileList.Close(); |
|
4253 |
|
4254 |
|
4255 } |
|
4256 |
|
4257 /* |
|
4258 ------------------------------------------------------------------------------- |
|
4259 |
|
4260 Class: CTestSetChoiceMenu |
|
4261 |
|
4262 Method: ConstructL |
|
4263 |
|
4264 Description: Second level constructor. |
|
4265 |
|
4266 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
4267 CMenu* aParent :in: Parent menu |
|
4268 const TDesC& aName :in: Menu name |
|
4269 |
|
4270 Return Values: None |
|
4271 |
|
4272 Errors/Exceptions: Leaves if parent class ConstructL leaves |
|
4273 Leaves if module can't be appended to list |
|
4274 |
|
4275 Status: Draft |
|
4276 |
|
4277 ------------------------------------------------------------------------------- |
|
4278 */ |
|
4279 void CTestSetChoiceMenu::ConstructL( CConsoleMain* aConsole, |
|
4280 CMenu* aParent, |
|
4281 const TDesC& aName |
|
4282 ) |
|
4283 { |
|
4284 |
|
4285 CMenu::ConstructL( aConsole, aParent, aName); |
|
4286 } |
|
4287 |
|
4288 /* |
|
4289 ------------------------------------------------------------------------------- |
|
4290 |
|
4291 Class: CTestSetChoiceMenu |
|
4292 |
|
4293 Method: ItemText |
|
4294 |
|
4295 Description: Returns menu item text. |
|
4296 |
|
4297 Parameters: const TInt :in: Menu index |
|
4298 |
|
4299 Return Values: const TDesC& Menu line text |
|
4300 |
|
4301 Errors/Exceptions: None |
|
4302 |
|
4303 Status: Draft |
|
4304 |
|
4305 ------------------------------------------------------------------------------- |
|
4306 */ |
|
4307 TInt CTestSetChoiceMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
4308 { |
|
4309 |
|
4310 TInt ret = iMain->UIStore().GetTestSetsList( aArray ); |
|
4311 |
|
4312 iFileList.ResetAndDestroy(); |
|
4313 TRAPD( err, |
|
4314 //Assign aArray to iFileList, it is used in LoadTestSet |
|
4315 for( TInt i=0 ; i < aArray.Count(); i++) |
|
4316 { |
|
4317 iFileList.AppendL(aArray[i].AllocL()); |
|
4318 } |
|
4319 ); // TRAPD |
|
4320 return err; |
|
4321 } |
|
4322 |
|
4323 /* |
|
4324 ------------------------------------------------------------------------------- |
|
4325 Class: CTestSetChoiceMenu |
|
4326 |
|
4327 Method: PrintMenuL |
|
4328 |
|
4329 Description: Prints the menu |
|
4330 |
|
4331 Parameters: None |
|
4332 |
|
4333 Return Values: None |
|
4334 |
|
4335 Errors/Exceptions: None |
|
4336 |
|
4337 Status: Draft |
|
4338 |
|
4339 ------------------------------------------------------------------------------- |
|
4340 */ |
|
4341 void CTestSetChoiceMenu::PrintMenuL( TUpdateType aType ) |
|
4342 { |
|
4343 |
|
4344 iUpdateType = aType; |
|
4345 |
|
4346 TBuf<KMaxLineLength> line; |
|
4347 |
|
4348 // Clear display |
|
4349 iConsole->ClearScreen(); |
|
4350 |
|
4351 // Print menu title |
|
4352 Print( Name() ); |
|
4353 |
|
4354 RRefArray<TDesC> texts; |
|
4355 if( iMain->UIStore().GetTestSetsList( texts ) != KErrNone ) |
|
4356 { |
|
4357 return; |
|
4358 } |
|
4359 |
|
4360 TInt oldItemCount = iItemCount; |
|
4361 |
|
4362 iItemCount = texts.Count(); |
|
4363 |
|
4364 // If first time in menu, update start and end positions |
|
4365 if( (iFirst == iLast) || // First time here.. |
|
4366 ( iLast >= iItemCount ) || |
|
4367 ( oldItemCount != iItemCount ) ) // Menu size changed |
|
4368 { |
|
4369 iLast = iItemCount - 1; |
|
4370 iPosOnScreen = 0; |
|
4371 |
|
4372 // If "overflow", then adjust the end |
|
4373 if (iLast > iScreenSize ) |
|
4374 { |
|
4375 iLast = iScreenSize; |
|
4376 } |
|
4377 } |
|
4378 |
|
4379 // Print items |
|
4380 for ( TInt i = iFirst; i <= iLast; i++ ) |
|
4381 { |
|
4382 line.Zero(); |
|
4383 |
|
4384 // Append text before line |
|
4385 AppendBefore( i, line ); |
|
4386 |
|
4387 // Get the menu line |
|
4388 LimitedAppend ( line, texts[i] ); |
|
4389 |
|
4390 // Print the line |
|
4391 Print(line); |
|
4392 |
|
4393 } |
|
4394 texts.Close(); |
|
4395 |
|
4396 } |
|
4397 |
|
4398 /* |
|
4399 ------------------------------------------------------------------------------- |
|
4400 |
|
4401 Class: CTestSetChoiceMenu |
|
4402 |
|
4403 Method: SelectL |
|
4404 |
|
4405 Description: Process keypresses in menu. Handle right arrow and enter |
|
4406 here, others in parent menu. |
|
4407 |
|
4408 Parameters: TKeyCode aSelection :in: Key |
|
4409 TBool& aContinue :out: Has user pressed "Quit" |
|
4410 |
|
4411 Return Values: CMenu* New menu |
|
4412 |
|
4413 Errors/Exceptions: None |
|
4414 |
|
4415 Status: Draft |
|
4416 |
|
4417 ------------------------------------------------------------------------------- |
|
4418 */ |
|
4419 CMenu* CTestSetChoiceMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
4420 { |
|
4421 |
|
4422 //return CMenu::SelectL( aSelection, aContinue ); |
|
4423 //return iParent; |
|
4424 MapKeyCode(aSelection); |
|
4425 TInt ret = 0; |
|
4426 |
|
4427 switch ( aSelection ) |
|
4428 { |
|
4429 case EKeyEnter: |
|
4430 case EKeyRightArrow: |
|
4431 { |
|
4432 |
|
4433 const TDesC& aSetName = iFileList.operator [](iPosOnScreen)->Des(); |
|
4434 |
|
4435 ret = iMain->UIStore().LoadTestSet( iFileList.operator [](iPosOnScreen)->Des() ); |
|
4436 if (ret == KErrNone) |
|
4437 { |
|
4438 ((CTestSetMenu*)iParent)->SetCreated(); |
|
4439 ((CTestSetMenu*)iParent)->SetTestSetFileName(iFileList.operator [](iPosOnScreen)->Des()); |
|
4440 } |
|
4441 return iParent; |
|
4442 } |
|
4443 default: |
|
4444 break; |
|
4445 } |
|
4446 |
|
4447 return CMenu::SelectL( aSelection, aContinue ); |
|
4448 |
|
4449 } |
|
4450 |
|
4451 |
|
4452 |
|
4453 |
|
4454 |
|
4455 |
|
4456 /* |
|
4457 ------------------------------------------------------------------------------- |
|
4458 |
|
4459 CTestSetAddCaseMenu |
|
4460 |
|
4461 Method: NewL |
|
4462 |
|
4463 Description: Constructs new menu. |
|
4464 |
|
4465 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
4466 CMenu* aParent :in: Parent menu |
|
4467 const TDesC& aName :in: Menu name |
|
4468 |
|
4469 Return Values: CMenu* New menu |
|
4470 |
|
4471 Errors/Exceptions: Leaves if memory allocation fails |
|
4472 Leaves if ConstructL leaves. |
|
4473 |
|
4474 Status: Draft |
|
4475 |
|
4476 ------------------------------------------------------------------------------- |
|
4477 */ |
|
4478 CTestSetAddCaseMenu* CTestSetAddCaseMenu::NewL( CConsoleMain* aConsole, |
|
4479 CMenu* aParent, |
|
4480 const TDesC& aName, |
|
4481 TDesC& aTestSetName ) |
|
4482 { |
|
4483 |
|
4484 CTestSetAddCaseMenu* self = |
|
4485 new ( ELeave ) CTestSetAddCaseMenu( aTestSetName ); |
|
4486 CleanupStack::PushL( self ); |
|
4487 self->ConstructL( aConsole, aParent, aName ); |
|
4488 CleanupStack::Pop( self ); |
|
4489 return self; |
|
4490 |
|
4491 } |
|
4492 |
|
4493 /* |
|
4494 ------------------------------------------------------------------------------- |
|
4495 |
|
4496 CTestSetAddCaseMenu |
|
4497 |
|
4498 Method: CTestSetAddCaseMenu |
|
4499 |
|
4500 Description: Constructor |
|
4501 |
|
4502 Parameters: None |
|
4503 |
|
4504 Return Values: None |
|
4505 |
|
4506 Errors/Exceptions: None |
|
4507 |
|
4508 Status: Draft |
|
4509 |
|
4510 ------------------------------------------------------------------------------- |
|
4511 */ |
|
4512 CTestSetAddCaseMenu::CTestSetAddCaseMenu( TDesC& aTestSetName ): |
|
4513 iTestSetName( aTestSetName ) |
|
4514 { |
|
4515 |
|
4516 iMenuItemsCount = EAddSelected + 1; |
|
4517 iMenuTotCount += iMenuItemsCount; |
|
4518 |
|
4519 } |
|
4520 |
|
4521 /* |
|
4522 ------------------------------------------------------------------------------- |
|
4523 |
|
4524 CTestSetAddCaseMenu |
|
4525 |
|
4526 Method: ~CTestSetAddCaseMenu |
|
4527 |
|
4528 Description: Destructor |
|
4529 |
|
4530 Parameters: None |
|
4531 |
|
4532 Return Values: None |
|
4533 |
|
4534 Errors/Exceptions: None |
|
4535 |
|
4536 Status: Draft |
|
4537 |
|
4538 ------------------------------------------------------------------------------- |
|
4539 */ |
|
4540 CTestSetAddCaseMenu::~CTestSetAddCaseMenu() |
|
4541 { |
|
4542 } |
|
4543 |
|
4544 /* |
|
4545 ------------------------------------------------------------------------------- |
|
4546 |
|
4547 Class: CTestSetAddCaseMenu |
|
4548 |
|
4549 Method: ConstructL |
|
4550 |
|
4551 Description: Second level constructor. |
|
4552 |
|
4553 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
4554 CMenu* aParent :in: Parent menu |
|
4555 const TDesC& aName :in: Menu name |
|
4556 |
|
4557 Return Values: None |
|
4558 |
|
4559 Errors/Exceptions: None |
|
4560 |
|
4561 Status: Draft |
|
4562 |
|
4563 ------------------------------------------------------------------------------- |
|
4564 */ |
|
4565 void CTestSetAddCaseMenu::ConstructL( CConsoleMain* aConsole, |
|
4566 CMenu* aParent, |
|
4567 const TDesC& aName ) |
|
4568 { |
|
4569 |
|
4570 CCaseStartMenu::ConstructL( aConsole, aParent, aName ); |
|
4571 |
|
4572 } |
|
4573 |
|
4574 |
|
4575 /* |
|
4576 ------------------------------------------------------------------------------- |
|
4577 |
|
4578 Class: CTestSetAddCaseMenu |
|
4579 |
|
4580 Method: ItemText |
|
4581 |
|
4582 Description: Returns menu item text |
|
4583 |
|
4584 Parameters: const TInt :in: Menu index |
|
4585 |
|
4586 Return Values: const TDesC& Menu line text |
|
4587 |
|
4588 Errors/Exceptions: None |
|
4589 |
|
4590 Status: Draft |
|
4591 |
|
4592 ------------------------------------------------------------------------------- |
|
4593 */ |
|
4594 TInt CTestSetAddCaseMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
4595 { |
|
4596 |
|
4597 if ( iSetFinished ) |
|
4598 { |
|
4599 if( aArray.Append( KAddSelected ) != KErrNone ) |
|
4600 { |
|
4601 return KErrNoMemory; |
|
4602 } |
|
4603 } |
|
4604 |
|
4605 return CMultipleBaseMenu::ItemTexts( aArray ); |
|
4606 |
|
4607 } |
|
4608 |
|
4609 /* |
|
4610 ------------------------------------------------------------------------------- |
|
4611 |
|
4612 Class: CTestSetAddCaseMenu |
|
4613 |
|
4614 Method: SelectL |
|
4615 |
|
4616 Description: Process keypresses in menu. Handle enter and right arrow here, |
|
4617 others in CMenu::SelectL. |
|
4618 |
|
4619 Parameters: TKeyCode aSelection :in: Key |
|
4620 TBool& aContinue :out: Has user pressed "Quit" |
|
4621 |
|
4622 Return Values: CMenu* New menu |
|
4623 |
|
4624 Errors/Exceptions: None |
|
4625 |
|
4626 Status: Draft |
|
4627 |
|
4628 ------------------------------------------------------------------------------- |
|
4629 */ |
|
4630 CMenu* CTestSetAddCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
4631 { |
|
4632 |
|
4633 MapKeyCode(aSelection); |
|
4634 |
|
4635 if ( iSetFinished ) |
|
4636 { |
|
4637 switch ( aSelection ) |
|
4638 { |
|
4639 case EKeyEnter: |
|
4640 case EKeyRightArrow: |
|
4641 { |
|
4642 |
|
4643 if ( iFirst + iPosOnScreen == EAddSelected ) |
|
4644 { |
|
4645 TInt count = iTestCases.Count(); |
|
4646 for( TInt i=0; i<count; i++ ) |
|
4647 { |
|
4648 if ( iSetState[i] ) |
|
4649 { |
|
4650 TInt ret = |
|
4651 iMain->UIStore().AddToTestSet( iTestSetName, |
|
4652 iTestCases[i] ); |
|
4653 if( ret != KErrNone ) |
|
4654 { |
|
4655 User::InfoPrint( _L("Test case adding failed") ); |
|
4656 } |
|
4657 } |
|
4658 } |
|
4659 return iParent; |
|
4660 } |
|
4661 } |
|
4662 break; |
|
4663 default: |
|
4664 break; |
|
4665 } |
|
4666 } |
|
4667 |
|
4668 return CMultipleBaseMenu::SelectL( aSelection, aContinue ); |
|
4669 |
|
4670 } |
|
4671 |
|
4672 /* |
|
4673 ------------------------------------------------------------------------------- |
|
4674 |
|
4675 CTestSetAddCaseMenu |
|
4676 |
|
4677 Method: NewL |
|
4678 |
|
4679 Description: Constructs new menu. |
|
4680 |
|
4681 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
4682 CMenu* aParent :in: Parent menu |
|
4683 const TDesC& aName :in: Menu name |
|
4684 |
|
4685 Return Values: CMenu* New menu |
|
4686 |
|
4687 Errors/Exceptions: Leaves if memory allocation fails |
|
4688 Leaves if ConstructL leaves. |
|
4689 |
|
4690 Status: Draft |
|
4691 |
|
4692 ------------------------------------------------------------------------------- |
|
4693 */ |
|
4694 CTestSetRemoveCaseMenu* CTestSetRemoveCaseMenu::NewL( CConsoleMain* aConsole, |
|
4695 CMenu* aParent, |
|
4696 const TDesC& aName, |
|
4697 TDesC& aTestSetName ) |
|
4698 { |
|
4699 |
|
4700 CTestSetRemoveCaseMenu* self = |
|
4701 new ( ELeave ) CTestSetRemoveCaseMenu( aTestSetName ); |
|
4702 CleanupStack::PushL( self ); |
|
4703 self->ConstructL( aConsole, aParent, aName ); |
|
4704 CleanupStack::Pop( self ); |
|
4705 return self; |
|
4706 |
|
4707 } |
|
4708 |
|
4709 /* |
|
4710 ------------------------------------------------------------------------------- |
|
4711 |
|
4712 CTestSetRemoveCaseMenu |
|
4713 |
|
4714 Method: CTestSetRemoveCaseMenu |
|
4715 |
|
4716 Description: Constructor |
|
4717 |
|
4718 Parameters: None |
|
4719 |
|
4720 Return Values: None |
|
4721 |
|
4722 Errors/Exceptions: None |
|
4723 |
|
4724 Status: Draft |
|
4725 |
|
4726 ------------------------------------------------------------------------------- |
|
4727 */ |
|
4728 CTestSetRemoveCaseMenu::CTestSetRemoveCaseMenu( TDesC& aTestSetName ): |
|
4729 iTestSetName( aTestSetName ) |
|
4730 { |
|
4731 |
|
4732 iMenuItemsCount = ERemoveSelected + 1; |
|
4733 iMenuTotCount += iMenuItemsCount; |
|
4734 |
|
4735 } |
|
4736 |
|
4737 /* |
|
4738 ------------------------------------------------------------------------------- |
|
4739 |
|
4740 CTestSetRemoveCaseMenu |
|
4741 |
|
4742 Method: ~CTestSetRemoveCaseMenu |
|
4743 |
|
4744 Description: Destructor |
|
4745 |
|
4746 Parameters: None |
|
4747 |
|
4748 Return Values: None |
|
4749 |
|
4750 Errors/Exceptions: None |
|
4751 |
|
4752 Status: Draft |
|
4753 |
|
4754 ------------------------------------------------------------------------------- |
|
4755 */ |
|
4756 CTestSetRemoveCaseMenu::~CTestSetRemoveCaseMenu() |
|
4757 { |
|
4758 } |
|
4759 |
|
4760 /* |
|
4761 ------------------------------------------------------------------------------- |
|
4762 |
|
4763 Class: CTestSetRemoveCaseMenu |
|
4764 |
|
4765 Method: ConstructL |
|
4766 |
|
4767 Description: Second level constructor. |
|
4768 |
|
4769 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
4770 CMenu* aParent :in: Parent menu |
|
4771 const TDesC& aName :in: Menu name |
|
4772 |
|
4773 Return Values: None |
|
4774 |
|
4775 Errors/Exceptions: None |
|
4776 |
|
4777 Status: Draft |
|
4778 |
|
4779 ------------------------------------------------------------------------------- |
|
4780 */ |
|
4781 void CTestSetRemoveCaseMenu::ConstructL( CConsoleMain* aConsole, |
|
4782 CMenu* aParent, |
|
4783 const TDesC& aName ) |
|
4784 { |
|
4785 |
|
4786 CCaseStartMenu::ConstructL( aConsole, aParent, aName ); |
|
4787 |
|
4788 } |
|
4789 |
|
4790 |
|
4791 /* |
|
4792 ------------------------------------------------------------------------------- |
|
4793 |
|
4794 Class: CTestSetRemoveCaseMenu |
|
4795 |
|
4796 Method: ItemText |
|
4797 |
|
4798 Description: Returns menu item text |
|
4799 |
|
4800 Parameters: const TInt :in: Menu index |
|
4801 |
|
4802 Return Values: const TDesC& Menu line text |
|
4803 |
|
4804 Errors/Exceptions: None |
|
4805 |
|
4806 Status: Draft |
|
4807 |
|
4808 ------------------------------------------------------------------------------- |
|
4809 */ |
|
4810 TInt CTestSetRemoveCaseMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
4811 { |
|
4812 |
|
4813 if ( iSetFinished ) |
|
4814 { |
|
4815 if( aArray.Append( KRemoveSelected ) != KErrNone ) |
|
4816 { |
|
4817 return KErrNoMemory; |
|
4818 } |
|
4819 } |
|
4820 |
|
4821 return CMultipleBaseMenu::ItemTexts( aArray ); |
|
4822 |
|
4823 } |
|
4824 |
|
4825 /* |
|
4826 ------------------------------------------------------------------------------- |
|
4827 |
|
4828 Class: CTestSetRemoveCaseMenu |
|
4829 |
|
4830 Method: SelectL |
|
4831 |
|
4832 Description: Process keypresses in menu. Handle enter and right arrow here, |
|
4833 others in CMenu::SelectL. |
|
4834 |
|
4835 Parameters: TKeyCode aSelection :in: Key |
|
4836 TBool& aContinue :out: Has user pressed "Quit" |
|
4837 |
|
4838 Return Values: CMenu* New menu |
|
4839 |
|
4840 Errors/Exceptions: None |
|
4841 |
|
4842 Status: Draft |
|
4843 |
|
4844 ------------------------------------------------------------------------------- |
|
4845 */ |
|
4846 CMenu* CTestSetRemoveCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
4847 { |
|
4848 |
|
4849 MapKeyCode(aSelection); |
|
4850 |
|
4851 if ( iSetFinished ) |
|
4852 { |
|
4853 switch ( aSelection ) |
|
4854 { |
|
4855 case EKeyEnter: |
|
4856 case EKeyRightArrow: |
|
4857 { |
|
4858 |
|
4859 if ( iFirst + iPosOnScreen == ERemoveSelected ) |
|
4860 { |
|
4861 TInt count = iTestCases.Count(); |
|
4862 for( TInt i=0; i<count; i++ ) |
|
4863 { |
|
4864 if ( iSetState[i] ) |
|
4865 { |
|
4866 TInt ret = |
|
4867 iMain->UIStore().RemoveFromTestSet( iTestSetName, |
|
4868 iTestCases[i] ); |
|
4869 if( ret != KErrNone ) |
|
4870 { |
|
4871 User::InfoPrint( _L("Test case adding failed") ); |
|
4872 } |
|
4873 } |
|
4874 } |
|
4875 return iParent; |
|
4876 } |
|
4877 } |
|
4878 break; |
|
4879 default: |
|
4880 break; |
|
4881 } |
|
4882 } |
|
4883 |
|
4884 return CMultipleBaseMenu::SelectL( aSelection, aContinue ); |
|
4885 |
|
4886 } |
|
4887 |
|
4888 /* |
|
4889 ------------------------------------------------------------------------------- |
|
4890 |
|
4891 Class: CTestSetRemoveCaseMenu |
|
4892 |
|
4893 Method: UpdateTestCases |
|
4894 |
|
4895 Description: |
|
4896 |
|
4897 Parameters: |
|
4898 |
|
4899 Return Values: |
|
4900 |
|
4901 Errors/Exceptions: None |
|
4902 |
|
4903 Status: Draft |
|
4904 |
|
4905 ------------------------------------------------------------------------------- |
|
4906 */ |
|
4907 TInt CTestSetRemoveCaseMenu::UpdateTestCases() |
|
4908 { |
|
4909 |
|
4910 TRAPD( err, |
|
4911 const CTestSetInfo& set = iMain->UIStore().TestSetL( iTestSetName ); |
|
4912 const RRefArray<const CTestInfo>& testCases = set.TestCases(); |
|
4913 |
|
4914 // Update test cases |
|
4915 iTestCases.Reset(); |
|
4916 iSetState.Reset(); |
|
4917 |
|
4918 TInt count = testCases.Count(); |
|
4919 for( TInt i=0; i<count; i++ ) |
|
4920 { |
|
4921 err = iTestCases.Append( testCases[i] ); |
|
4922 if( err != KErrNone ) |
|
4923 { |
|
4924 break; |
|
4925 } |
|
4926 } |
|
4927 |
|
4928 ); // TRAPD |
|
4929 |
|
4930 return err; |
|
4931 |
|
4932 } |
|
4933 |
|
4934 /* |
|
4935 ------------------------------------------------------------------------------- |
|
4936 |
|
4937 Class: CCaseMenu |
|
4938 |
|
4939 Method: NewL |
|
4940 |
|
4941 Description: Constructs new menu. |
|
4942 |
|
4943 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
4944 CMenu* aParent :in: Parent menu |
|
4945 const TDesC& aName :in: Menu name |
|
4946 TCaseState aType :in: Case state |
|
4947 |
|
4948 Return Values: CMenu* New menu |
|
4949 |
|
4950 Errors/Exceptions: Leaves if memory allocation fails |
|
4951 Leaves if ConstructL leaves. |
|
4952 |
|
4953 Status: Draft |
|
4954 |
|
4955 ------------------------------------------------------------------------------- |
|
4956 */ |
|
4957 CStartedTestSetMenu* CStartedTestSetMenu::NewL( CConsoleMain* aConsole, |
|
4958 CMenu* aParent, |
|
4959 const TDesC& aName ) |
|
4960 { |
|
4961 |
|
4962 CStartedTestSetMenu* self = new ( ELeave ) CStartedTestSetMenu(); |
|
4963 CleanupStack::PushL( self ); |
|
4964 self->ConstructL( aConsole, aParent, aName ); |
|
4965 CleanupStack::Pop( self ); |
|
4966 return self; |
|
4967 |
|
4968 } |
|
4969 |
|
4970 /* |
|
4971 ------------------------------------------------------------------------------- |
|
4972 |
|
4973 Class: CStartedTestSetMenu |
|
4974 |
|
4975 Method: CStartedTestSetMenu |
|
4976 |
|
4977 Description: Constructor |
|
4978 |
|
4979 Parameters: None |
|
4980 |
|
4981 Return Values: None |
|
4982 |
|
4983 Errors/Exceptions: None |
|
4984 |
|
4985 Status: Draft |
|
4986 |
|
4987 ------------------------------------------------------------------------------- |
|
4988 */ |
|
4989 CStartedTestSetMenu::CStartedTestSetMenu() |
|
4990 { |
|
4991 iType = CUIStoreIf::ESetAll; |
|
4992 } |
|
4993 |
|
4994 /* |
|
4995 ------------------------------------------------------------------------------- |
|
4996 |
|
4997 Class: CStartedTestSetMenu |
|
4998 |
|
4999 Method: ConstructL |
|
5000 |
|
5001 Description: Second level constructor. |
|
5002 |
|
5003 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
5004 CMenu* aParent :in: Parent menu |
|
5005 const TDesC& aName :in: Menu name |
|
5006 TCaseState aType :in: Case state |
|
5007 |
|
5008 Return Values: None |
|
5009 |
|
5010 Errors/Exceptions: Leaves if parent class ConstructL leaves |
|
5011 Leaves if memory allocation fails |
|
5012 Leaves if CCaseOperation menu NewL leaves |
|
5013 Leaves if UpcateCaseListL leaves |
|
5014 |
|
5015 Status: Draft |
|
5016 |
|
5017 ------------------------------------------------------------------------------- |
|
5018 */ |
|
5019 void CStartedTestSetMenu::ConstructL( CConsoleMain* aConsole, |
|
5020 CMenu* aParent, |
|
5021 const TDesC& aName ) |
|
5022 { |
|
5023 |
|
5024 CMenu::ConstructL( aConsole, aParent, aName); |
|
5025 |
|
5026 } |
|
5027 |
|
5028 |
|
5029 |
|
5030 /* |
|
5031 ------------------------------------------------------------------------------- |
|
5032 |
|
5033 Class: CStartedTestSetMenu |
|
5034 |
|
5035 Method: ~CStartedTestSetMenu |
|
5036 |
|
5037 Description: Destructor |
|
5038 |
|
5039 Parameters: None |
|
5040 |
|
5041 Return Values: None |
|
5042 |
|
5043 Errors/Exceptions: None |
|
5044 |
|
5045 Status: Draft |
|
5046 |
|
5047 ------------------------------------------------------------------------------- |
|
5048 */ |
|
5049 CStartedTestSetMenu::~CStartedTestSetMenu() |
|
5050 { |
|
5051 |
|
5052 delete iCaseMenu; |
|
5053 iCaseMenu = 0; |
|
5054 |
|
5055 iTestSets.Reset(); |
|
5056 iTestSets.Close(); |
|
5057 |
|
5058 } |
|
5059 |
|
5060 |
|
5061 /* |
|
5062 ------------------------------------------------------------------------------- |
|
5063 |
|
5064 Class: CStartedTestSetMenu |
|
5065 |
|
5066 Method: ItemText |
|
5067 |
|
5068 Description: Returns menu item text |
|
5069 |
|
5070 Parameters: const TInt :in: Menu index |
|
5071 |
|
5072 Return Values: const TDesC& Menu line text |
|
5073 |
|
5074 Errors/Exceptions: None |
|
5075 |
|
5076 Status: Draft |
|
5077 |
|
5078 ------------------------------------------------------------------------------- |
|
5079 */ |
|
5080 TInt CStartedTestSetMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
5081 { |
|
5082 |
|
5083 iTestSets.Reset(); |
|
5084 |
|
5085 TInt ret = iMain->UIStore().StartedTestSets( iTestSets, iType ); |
|
5086 if ( ret != KErrNone ) |
|
5087 { |
|
5088 return ret; |
|
5089 } |
|
5090 |
|
5091 TInt count = iTestSets.Count(); |
|
5092 for( TInt i=0; i<count; i++ ) |
|
5093 { |
|
5094 if( aArray.Append( iTestSets[i].TestSetInfo().Name() ) != KErrNone ) |
|
5095 { |
|
5096 return KErrNoMemory; |
|
5097 } |
|
5098 } |
|
5099 |
|
5100 return KErrNone; |
|
5101 } |
|
5102 |
|
5103 /* |
|
5104 ------------------------------------------------------------------------------- |
|
5105 Class: CStartedTestSetMenu |
|
5106 |
|
5107 Method: AppendBefore |
|
5108 |
|
5109 Description: Append text before line. |
|
5110 |
|
5111 Parameters: TInt aLine: in: line number |
|
5112 TDes& aLine: in: line text |
|
5113 |
|
5114 Return Values: None |
|
5115 |
|
5116 Errors/Exceptions: None |
|
5117 |
|
5118 Status: Draft |
|
5119 |
|
5120 ------------------------------------------------------------------------------- |
|
5121 */ |
|
5122 void CStartedTestSetMenu::AppendBefore( TInt aLineNum, TDes& aLine ) |
|
5123 { |
|
5124 |
|
5125 CMenu::AppendBefore( aLineNum, aLine ); |
|
5126 |
|
5127 if( ( aLine.MaxLength() - aLine.Length() ) < 2 ) |
|
5128 { |
|
5129 return; |
|
5130 } |
|
5131 if( iTestSets[aLineNum].Status() & CUIStoreIf::ESetRunning ) |
|
5132 { |
|
5133 aLine.Append( _L("O ") ); |
|
5134 } |
|
5135 else if( iTestSets[aLineNum].Status() & CUIStoreIf::ESetPassed ) |
|
5136 { |
|
5137 aLine.Append( _L("P ") ); |
|
5138 } |
|
5139 else if( iTestSets[aLineNum].Status() & CUIStoreIf::ESetFailed ) |
|
5140 { |
|
5141 aLine.Append( _L("F ") ); |
|
5142 } |
|
5143 |
|
5144 } |
|
5145 |
|
5146 /* |
|
5147 ------------------------------------------------------------------------------- |
|
5148 |
|
5149 Class: CStartedTestSetMenu |
|
5150 |
|
5151 Method: SelectL |
|
5152 |
|
5153 Description: Process keypresses in menu. Handle Enter and Right Arrow |
|
5154 here, other will be handled in CMenu::SelectL |
|
5155 |
|
5156 Parameters: TKeyCode aSelection :in: Key |
|
5157 TBool& aContinue :out: Has user pressed "Quit" |
|
5158 |
|
5159 Return Values: CMenu* New menu |
|
5160 |
|
5161 Errors/Exceptions: None |
|
5162 |
|
5163 Status: Draft |
|
5164 |
|
5165 ------------------------------------------------------------------------------- |
|
5166 */ |
|
5167 CMenu* CStartedTestSetMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
5168 { |
|
5169 |
|
5170 MapKeyCode(aSelection); |
|
5171 |
|
5172 switch (aSelection) |
|
5173 { |
|
5174 case EKeyEnter: |
|
5175 case EKeyRightArrow: |
|
5176 { |
|
5177 if ( iFirst + iPosOnScreen < iTestSets.Count() ) |
|
5178 { |
|
5179 delete iCaseMenu; |
|
5180 iCaseMenu = 0; |
|
5181 iCaseMenu = CTestSetCaseMenu::NewL( |
|
5182 iMain, |
|
5183 this, |
|
5184 iTestSets[iFirst + iPosOnScreen].TestSetInfo().Name(), |
|
5185 iTestSets[iFirst + iPosOnScreen] ); |
|
5186 |
|
5187 return iCaseMenu; |
|
5188 } |
|
5189 } |
|
5190 return this; |
|
5191 default: |
|
5192 break; |
|
5193 } |
|
5194 |
|
5195 // Let the parent class handle rest |
|
5196 return CMenu::SelectL(aSelection, aContinue); |
|
5197 |
|
5198 } |
|
5199 |
|
5200 |
|
5201 /* |
|
5202 ------------------------------------------------------------------------------- |
|
5203 |
|
5204 Class: CTestSetCaseMenu |
|
5205 |
|
5206 Method: NewL |
|
5207 |
|
5208 Description: Constructs new menu. |
|
5209 |
|
5210 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
5211 CMenu* aParent :in: Parent menu |
|
5212 const TDesC& aName :in: Menu name |
|
5213 TCaseState aType :in: Case state |
|
5214 |
|
5215 Return Values: CMenu* New menu |
|
5216 |
|
5217 Errors/Exceptions: Leaves if memory allocation fails |
|
5218 Leaves if ConstructL leaves. |
|
5219 |
|
5220 Status: Draft |
|
5221 |
|
5222 ------------------------------------------------------------------------------- |
|
5223 */ |
|
5224 CTestSetCaseMenu* CTestSetCaseMenu::NewL( CConsoleMain* aConsole, |
|
5225 CMenu* aParent, |
|
5226 const TDesC& aName, |
|
5227 CStartedTestSet& aTestSet ) |
|
5228 { |
|
5229 |
|
5230 CTestSetCaseMenu* self = new ( ELeave ) CTestSetCaseMenu( aTestSet ); |
|
5231 CleanupStack::PushL( self ); |
|
5232 self->ConstructL( aConsole, aParent, aName ); |
|
5233 CleanupStack::Pop( self ); |
|
5234 return self; |
|
5235 |
|
5236 } |
|
5237 |
|
5238 /* |
|
5239 ------------------------------------------------------------------------------- |
|
5240 |
|
5241 Class: CTestSetCaseMenu |
|
5242 |
|
5243 Method: CTestSetCaseMenu |
|
5244 |
|
5245 Description: Constructor |
|
5246 |
|
5247 Parameters: None |
|
5248 |
|
5249 Return Values: None |
|
5250 |
|
5251 Errors/Exceptions: None |
|
5252 |
|
5253 Status: Draft |
|
5254 |
|
5255 ------------------------------------------------------------------------------- |
|
5256 */ |
|
5257 CTestSetCaseMenu::CTestSetCaseMenu( CStartedTestSet& aTestSet ): |
|
5258 iTestSet( aTestSet ) |
|
5259 { |
|
5260 } |
|
5261 |
|
5262 /* |
|
5263 ------------------------------------------------------------------------------- |
|
5264 |
|
5265 Class: CTestSetCaseMenu |
|
5266 |
|
5267 Method: ConstructL |
|
5268 |
|
5269 Description: Second level constructor. |
|
5270 |
|
5271 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
5272 CMenu* aParent :in: Parent menu |
|
5273 const TDesC& aName :in: Menu name |
|
5274 TCaseState aType :in: Case state |
|
5275 |
|
5276 Return Values: None |
|
5277 |
|
5278 Errors/Exceptions: Leaves if parent class ConstructL leaves |
|
5279 Leaves if memory allocation fails |
|
5280 Leaves if CCaseOperation menu NewL leaves |
|
5281 Leaves if UpcateCaseListL leaves |
|
5282 |
|
5283 Status: Draft |
|
5284 |
|
5285 ------------------------------------------------------------------------------- |
|
5286 */ |
|
5287 void CTestSetCaseMenu::ConstructL( CConsoleMain* aConsole, |
|
5288 CMenu* aParent, |
|
5289 const TDesC& aName ) |
|
5290 { |
|
5291 |
|
5292 CCaseMenu::ConstructL( aConsole, aParent, aName, |
|
5293 CUIStoreIf::EStatusAll ); |
|
5294 |
|
5295 } |
|
5296 |
|
5297 |
|
5298 |
|
5299 /* |
|
5300 ------------------------------------------------------------------------------- |
|
5301 |
|
5302 Class: CTestSetCaseMenu |
|
5303 |
|
5304 Method: ~CTestSetCaseMenu |
|
5305 |
|
5306 Description: Destructor |
|
5307 |
|
5308 Parameters: None |
|
5309 |
|
5310 Return Values: None |
|
5311 |
|
5312 Errors/Exceptions: None |
|
5313 |
|
5314 Status: Draft |
|
5315 |
|
5316 ------------------------------------------------------------------------------- |
|
5317 */ |
|
5318 CTestSetCaseMenu::~CTestSetCaseMenu() |
|
5319 { |
|
5320 } |
|
5321 |
|
5322 |
|
5323 /* |
|
5324 ------------------------------------------------------------------------------- |
|
5325 |
|
5326 Class: CTestSetCaseMenu |
|
5327 |
|
5328 Method: ItemText |
|
5329 |
|
5330 Description: Returns menu item text |
|
5331 |
|
5332 Parameters: const TInt :in: Menu index |
|
5333 |
|
5334 Return Values: const TDesC& Menu line text |
|
5335 |
|
5336 Errors/Exceptions: None |
|
5337 |
|
5338 Status: Draft |
|
5339 |
|
5340 ------------------------------------------------------------------------------- |
|
5341 */ |
|
5342 TInt CTestSetCaseMenu::ItemTexts( RRefArray<TDesC>& aArray ) |
|
5343 { |
|
5344 |
|
5345 if ( iTestSet.Status() & CUIStoreIf::ESetRunning ) |
|
5346 { |
|
5347 if( aArray.Append( KCancelTestSet ) != KErrNone ) |
|
5348 { |
|
5349 return KErrNoMemory; |
|
5350 } |
|
5351 } |
|
5352 |
|
5353 const RRefArray<CStartedTestCase>& testCases = iTestSet.TestCases(); |
|
5354 |
|
5355 iTestCases.Reset(); |
|
5356 |
|
5357 TInt count = testCases.Count(); |
|
5358 for( TInt i=0; i<count; i++ ) |
|
5359 { |
|
5360 if( iTestCases.Append( testCases[i] ) != KErrNone ) |
|
5361 { |
|
5362 return KErrNoMemory; |
|
5363 } |
|
5364 if( aArray.Append( testCases[i].TestInfo().TestCaseTitle() ) != KErrNone ) |
|
5365 { |
|
5366 return KErrNoMemory; |
|
5367 } |
|
5368 } |
|
5369 |
|
5370 return KErrNone; |
|
5371 |
|
5372 } |
|
5373 |
|
5374 /* |
|
5375 ------------------------------------------------------------------------------- |
|
5376 Class: CTestSetCaseMenu |
|
5377 |
|
5378 Method: AppendBefore |
|
5379 |
|
5380 Description: Append text before line. |
|
5381 |
|
5382 Parameters: TInt aLine: in: line number |
|
5383 TDes& aLine: in: line text |
|
5384 |
|
5385 Return Values: None |
|
5386 |
|
5387 Errors/Exceptions: None |
|
5388 |
|
5389 Status: Draft |
|
5390 |
|
5391 ------------------------------------------------------------------------------- |
|
5392 */ |
|
5393 void CTestSetCaseMenu::AppendBefore( TInt aLineNum, TDes& aLine ) |
|
5394 { |
|
5395 |
|
5396 CMenu::AppendBefore( aLineNum, aLine ); |
|
5397 |
|
5398 TInt testCaseNum = aLineNum; |
|
5399 if( iTestSet.Status() & CUIStoreIf::ESetRunning ) |
|
5400 { |
|
5401 if( aLineNum == 0 ) |
|
5402 { |
|
5403 // "Cancel test set" row |
|
5404 return; |
|
5405 } |
|
5406 testCaseNum--; |
|
5407 } |
|
5408 |
|
5409 if( ( aLine.MaxLength() - aLine.Length() ) < 2 ) |
|
5410 { |
|
5411 return; |
|
5412 } |
|
5413 |
|
5414 if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusRunning ) |
|
5415 { |
|
5416 aLine.Append( _L("O ") ); |
|
5417 } |
|
5418 else if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusPassed ) |
|
5419 { |
|
5420 aLine.Append( _L("P ") ); |
|
5421 } |
|
5422 else if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusFailed ) |
|
5423 { |
|
5424 aLine.Append( _L("F ") ); |
|
5425 } |
|
5426 else if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusAborted ) |
|
5427 { |
|
5428 aLine.Append( _L("A ") ); |
|
5429 } |
|
5430 else if( iTestCases[testCaseNum].Status() & CUIStoreIf::EStatusCrashed ) |
|
5431 { |
|
5432 aLine.Append( _L("C ") ); |
|
5433 } |
|
5434 |
|
5435 } |
|
5436 |
|
5437 /* |
|
5438 ------------------------------------------------------------------------------- |
|
5439 |
|
5440 Class: CTestSetCaseMenu |
|
5441 |
|
5442 Method: SelectL |
|
5443 |
|
5444 Description: Process keypresses in menu. Handle enter and right arrow here, |
|
5445 others in CMenu::SelectL. |
|
5446 |
|
5447 Parameters: TKeyCode aSelection :in: Key |
|
5448 TBool& aContinue :out: Has user pressed "Quit" |
|
5449 |
|
5450 Return Values: CMenu* New menu |
|
5451 |
|
5452 Errors/Exceptions: None |
|
5453 |
|
5454 Status: Draft |
|
5455 |
|
5456 ------------------------------------------------------------------------------- |
|
5457 */ |
|
5458 CMenu* CTestSetCaseMenu::SelectL( TKeyCode aSelection, TBool& aContinue ) |
|
5459 { |
|
5460 |
|
5461 MapKeyCode(aSelection); |
|
5462 |
|
5463 if( ( aSelection == EKeyEnter ) || ( aSelection == EKeyRightArrow ) ) |
|
5464 { |
|
5465 TInt pos = iFirst + iPosOnScreen; |
|
5466 if( iTestSet.Status() & CUIStoreIf::ESetRunning ) |
|
5467 { |
|
5468 pos--; |
|
5469 } |
|
5470 if( pos == -1 ) |
|
5471 { |
|
5472 User::LeaveIfError( |
|
5473 iMain->UIStore().AbortTestSet( iTestSet ) ); |
|
5474 return iParent; |
|
5475 } |
|
5476 else if( pos < iTestCases.Count() ) |
|
5477 { |
|
5478 delete iCaseOperationMenu; |
|
5479 iCaseOperationMenu = 0; |
|
5480 iCaseOperationMenu = CCaseOperationMenu::NewL( |
|
5481 iMain, |
|
5482 this, |
|
5483 iTestCases[pos].TestInfo().TestCaseTitle(), |
|
5484 &iTestCases[pos] ); |
|
5485 |
|
5486 return iCaseOperationMenu; |
|
5487 } |
|
5488 } |
|
5489 |
|
5490 // Let the parent class handle rest |
|
5491 return CMenu::SelectL(aSelection, aContinue); |
|
5492 } |
|
5493 |
|
5494 /* |
|
5495 ------------------------------------------------------------------------------- |
|
5496 |
|
5497 Class: CFilterMenu |
|
5498 |
|
5499 Method: NewL |
|
5500 |
|
5501 Description: Constructs new menu. |
|
5502 |
|
5503 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
5504 CMenu* aParent :in: Parent menu |
|
5505 const TDesC& aName :in: Menu name |
|
5506 |
|
5507 Return Values: CMenu* New menu |
|
5508 |
|
5509 Errors/Exceptions: Leaves if memory allocation fails |
|
5510 Leaves if ConstructL leaves. |
|
5511 |
|
5512 Status: Draft |
|
5513 |
|
5514 ------------------------------------------------------------------------------- |
|
5515 */ |
|
5516 CFilterMenu* CFilterMenu::NewL(CConsoleMain* aConsole, |
|
5517 CMenu* aParent, |
|
5518 const TDesC& aName) |
|
5519 { |
|
5520 CFilterMenu* self = new (ELeave) CFilterMenu(); |
|
5521 CleanupStack::PushL(self); |
|
5522 self->ConstructL(aConsole, aParent, aName); |
|
5523 CleanupStack::Pop(self); |
|
5524 return self; |
|
5525 } |
|
5526 |
|
5527 /* |
|
5528 ------------------------------------------------------------------------------- |
|
5529 |
|
5530 Class: CFilterMenu |
|
5531 |
|
5532 Method: ConstructL |
|
5533 |
|
5534 Description: Second level constructor. |
|
5535 |
|
5536 Parameters: CConsoleMain* aConsole :in: Pointer to main console |
|
5537 CMenu* aParent :in: Parent menu |
|
5538 const TDesC& aName :in: Menu name |
|
5539 |
|
5540 Return Values: None |
|
5541 |
|
5542 Errors/Exceptions: None |
|
5543 |
|
5544 Status: Draft |
|
5545 |
|
5546 ------------------------------------------------------------------------------- |
|
5547 */ |
|
5548 void CFilterMenu::ConstructL(CConsoleMain* aConsole, |
|
5549 CMenu* aParent, |
|
5550 const TDesC& aName |
|
5551 ) |
|
5552 { |
|
5553 CMenu::ConstructL(aConsole, aParent, aName); |
|
5554 } |
|
5555 |
|
5556 /* |
|
5557 ------------------------------------------------------------------------------- |
|
5558 |
|
5559 CFilterMenu |
|
5560 |
|
5561 Method: CFilterMenu |
|
5562 |
|
5563 Description: Constructor |
|
5564 |
|
5565 Parameters: None |
|
5566 |
|
5567 Return Values: None |
|
5568 |
|
5569 Errors/Exceptions: None |
|
5570 |
|
5571 Status: Draft |
|
5572 |
|
5573 ------------------------------------------------------------------------------- |
|
5574 */ |
|
5575 CFilterMenu::CFilterMenu() |
|
5576 { |
|
5577 } |
|
5578 |
|
5579 /* |
|
5580 ------------------------------------------------------------------------------- |
|
5581 |
|
5582 CFilterMenu |
|
5583 |
|
5584 Method: ~CFilterMenu |
|
5585 |
|
5586 Description: Destructor |
|
5587 |
|
5588 Parameters: None |
|
5589 |
|
5590 Return Values: None |
|
5591 |
|
5592 Errors/Exceptions: None |
|
5593 |
|
5594 Status: Draft |
|
5595 |
|
5596 ------------------------------------------------------------------------------- |
|
5597 */ |
|
5598 CFilterMenu::~CFilterMenu() |
|
5599 { |
|
5600 delete iTestCaseMenu; |
|
5601 } |
|
5602 |
|
5603 /* |
|
5604 ------------------------------------------------------------------------------- |
|
5605 |
|
5606 Class: CFilterMenu |
|
5607 |
|
5608 Method: ItemText |
|
5609 |
|
5610 Description: Returns menu item text |
|
5611 |
|
5612 Parameters: const TInt :in: Menu index |
|
5613 |
|
5614 Return Values: const TDesC& Menu line text |
|
5615 |
|
5616 Errors/Exceptions: None |
|
5617 |
|
5618 Status: Draft |
|
5619 |
|
5620 ------------------------------------------------------------------------------- |
|
5621 */ |
|
5622 TInt CFilterMenu::ItemTexts(RRefArray<TDesC>& aArray) |
|
5623 { |
|
5624 const RPointerArray<TDesC> &filters = iMain->GetFilterArray(); |
|
5625 TInt ret; |
|
5626 |
|
5627 TInt count = filters.Count(); |
|
5628 for(TInt i = 0; i < count; i++) |
|
5629 { |
|
5630 ret = aArray.Append(*filters[i]); |
|
5631 if(ret != KErrNone) |
|
5632 { |
|
5633 return ret; |
|
5634 } |
|
5635 } |
|
5636 |
|
5637 return KErrNone; |
|
5638 } |
|
5639 |
|
5640 /* |
|
5641 ------------------------------------------------------------------------------- |
|
5642 |
|
5643 Class: CFilterMenu |
|
5644 |
|
5645 Method: SelectL |
|
5646 |
|
5647 Description: Process keypresses in menu. Handle enter and right arrow here, |
|
5648 others in CMenu::SelectL. |
|
5649 |
|
5650 Parameters: TKeyCode aSelection :in: Key |
|
5651 TBool& aContinue :out: Has user pressed "Quit" |
|
5652 |
|
5653 Return Values: CMenu* New menu |
|
5654 |
|
5655 Errors/Exceptions: None |
|
5656 |
|
5657 Status: Draft |
|
5658 |
|
5659 ------------------------------------------------------------------------------- |
|
5660 */ |
|
5661 CMenu* CFilterMenu::SelectL(TKeyCode aSelection, TBool& aContinue) |
|
5662 { |
|
5663 const RPointerArray<TDesC> &filters = iMain->GetFilterArray(); |
|
5664 |
|
5665 MapKeyCode(aSelection); |
|
5666 |
|
5667 switch ( aSelection ) |
|
5668 { |
|
5669 case EKeyEnter: |
|
5670 case EKeyRightArrow: |
|
5671 { |
|
5672 // Start the case |
|
5673 if((iFirst + iPosOnScreen) < filters.Count()) |
|
5674 { |
|
5675 // Show test cases menu |
|
5676 iMain->SetFilterIndex(iFirst + iPosOnScreen); |
|
5677 if(iTestCaseMenu) |
|
5678 { |
|
5679 return iTestCaseMenu; |
|
5680 } |
|
5681 else |
|
5682 { |
|
5683 RDebug::Print(_L("STIF: CFilterMenu::SelectL: test case menu is not set, however it should be")); |
|
5684 return this; |
|
5685 } |
|
5686 } |
|
5687 else |
|
5688 { |
|
5689 return this; |
|
5690 } |
|
5691 } |
|
5692 |
|
5693 default: |
|
5694 return CMenu::SelectL( aSelection, aContinue); |
|
5695 } |
|
5696 } |
|
5697 |
|
5698 /* |
|
5699 ------------------------------------------------------------------------------- |
|
5700 |
|
5701 Class: CFilterMenu |
|
5702 |
|
5703 Method: SetTestCaseMenu |
|
5704 |
|
5705 Description: Set pointer to test case menu, so it can be shown when user |
|
5706 selects filter. |
|
5707 This menu will be deleted along with the filter menu. |
|
5708 |
|
5709 Parameters: CMenu* aTestCaseMenu :in: test case menu |
|
5710 |
|
5711 Return Values: None |
|
5712 |
|
5713 Errors/Exceptions: None |
|
5714 |
|
5715 Status: Draft |
|
5716 |
|
5717 ------------------------------------------------------------------------------- |
|
5718 */ |
|
5719 void CFilterMenu::SetTestCaseMenu(CMenu* aTestCaseMenu) |
|
5720 { |
|
5721 if(iTestCaseMenu) |
|
5722 { |
|
5723 RDebug::Print(_L("STIF: CFilterMenu::SetTestCaseMenu: test case menu is already set!")); |
|
5724 delete iTestCaseMenu; |
|
5725 iTestCaseMenu = NULL; |
|
5726 } |
|
5727 iTestCaseMenu = aTestCaseMenu; |
|
5728 } |
|
5729 // End of file |