]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/DisplayEngineDxe/FormDisplay.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Update code to support guid op nest in the statement.
[mirror_edk2.git] / MdeModulePkg / Universal / DisplayEngineDxe / FormDisplay.c
1 /** @file
2 Entry and initialization module for the browser.
3
4 Copyright (c) 2007 - 2013, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php
9
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
12
13 **/
14
15 #include "FormDisplay.h"
16
17 //
18 // Search table for UiDisplayMenu()
19 //
20 SCAN_CODE_TO_SCREEN_OPERATION gScanCodeToOperation[] = {
21 {
22 SCAN_UP,
23 UiUp,
24 },
25 {
26 SCAN_DOWN,
27 UiDown,
28 },
29 {
30 SCAN_PAGE_UP,
31 UiPageUp,
32 },
33 {
34 SCAN_PAGE_DOWN,
35 UiPageDown,
36 },
37 {
38 SCAN_ESC,
39 UiReset,
40 },
41 {
42 SCAN_LEFT,
43 UiLeft,
44 },
45 {
46 SCAN_RIGHT,
47 UiRight,
48 }
49 };
50
51 UINTN mScanCodeNumber = sizeof (gScanCodeToOperation) / sizeof (gScanCodeToOperation[0]);
52
53 SCREEN_OPERATION_T0_CONTROL_FLAG gScreenOperationToControlFlag[] = {
54 {
55 UiNoOperation,
56 CfUiNoOperation,
57 },
58 {
59 UiSelect,
60 CfUiSelect,
61 },
62 {
63 UiUp,
64 CfUiUp,
65 },
66 {
67 UiDown,
68 CfUiDown,
69 },
70 {
71 UiLeft,
72 CfUiLeft,
73 },
74 {
75 UiRight,
76 CfUiRight,
77 },
78 {
79 UiReset,
80 CfUiReset,
81 },
82 {
83 UiPageUp,
84 CfUiPageUp,
85 },
86 {
87 UiPageDown,
88 CfUiPageDown
89 },
90 {
91 UiHotKey,
92 CfUiHotKey
93 }
94 };
95
96 EFI_GUID gDisplayEngineGuid = {
97 0xE38C1029, 0xE38F, 0x45b9, {0x8F, 0x0D, 0xE2, 0xE6, 0x0B, 0xC9, 0xB2, 0x62}
98 };
99
100 FORM_ENTRY_INFO gFormEntryInfo;
101 UINTN gSequence;
102 EFI_SCREEN_DESCRIPTOR gStatementDimensions;
103 BOOLEAN mStatementLayoutIsChanged = TRUE;
104 USER_INPUT *gUserInput;
105 FORM_DISPLAY_ENGINE_FORM *gFormData;
106 EFI_HII_HANDLE gHiiHandle;
107 UINT16 gDirection;
108 LIST_ENTRY gMenuOption;
109 DISPLAY_HIGHLIGHT_MENU_INFO gHighligthMenuInfo = {0};
110 BOOLEAN mIsFirstForm = TRUE;
111 FORM_ENTRY_INFO gOldFormEntry = {0};
112
113 //
114 // Browser Global Strings
115 //
116 CHAR16 *gFormNotFound;
117 CHAR16 *gNoSubmitIf;
118 CHAR16 *gBrwoserError;
119 CHAR16 *gSaveFailed;
120 CHAR16 *gPromptForData;
121 CHAR16 *gPromptForPassword;
122 CHAR16 *gPromptForNewPassword;
123 CHAR16 *gConfirmPassword;
124 CHAR16 *gConfirmError;
125 CHAR16 *gPassowordInvalid;
126 CHAR16 *gPressEnter;
127 CHAR16 *gEmptyString;
128 CHAR16 *gMiniString;
129 CHAR16 *gOptionMismatch;
130 CHAR16 *gFormSuppress;
131 CHAR16 *gProtocolNotFound;
132
133 CHAR16 gModalSkipColumn;
134 CHAR16 gPromptBlockWidth;
135 CHAR16 gOptionBlockWidth;
136 CHAR16 gHelpBlockWidth;
137 CHAR16 *mUnknownString;
138
139 FORM_DISPLAY_DRIVER_PRIVATE_DATA mPrivateData = {
140 FORM_DISPLAY_DRIVER_SIGNATURE,
141 NULL,
142 {
143 FormDisplay,
144 DriverClearDisplayPage,
145 ConfirmDataChange
146 }
147 };
148
149
150 /**
151 Get the string based on the StringId and HII Package List Handle.
152
153 @param Token The String's ID.
154 @param HiiHandle The package list in the HII database to search for
155 the specified string.
156
157 @return The output string.
158
159 **/
160 CHAR16 *
161 GetToken (
162 IN EFI_STRING_ID Token,
163 IN EFI_HII_HANDLE HiiHandle
164 )
165 {
166 EFI_STRING String;
167
168 String = HiiGetString (HiiHandle, Token, NULL);
169 if (String == NULL) {
170 String = AllocateCopyPool (StrSize (mUnknownString), mUnknownString);
171 ASSERT (String != NULL);
172 }
173
174 return (CHAR16 *) String;
175 }
176
177
178 /**
179 Initialize the HII String Token to the correct values.
180
181 **/
182 VOID
183 InitializeDisplayStrings (
184 VOID
185 )
186 {
187 mUnknownString = GetToken (STRING_TOKEN (UNKNOWN_STRING), gHiiHandle);
188 gSaveFailed = GetToken (STRING_TOKEN (SAVE_FAILED), gHiiHandle);
189 gPromptForData = GetToken (STRING_TOKEN (PROMPT_FOR_DATA), gHiiHandle);
190 gPromptForPassword = GetToken (STRING_TOKEN (PROMPT_FOR_PASSWORD), gHiiHandle);
191 gPromptForNewPassword = GetToken (STRING_TOKEN (PROMPT_FOR_NEW_PASSWORD), gHiiHandle);
192 gConfirmPassword = GetToken (STRING_TOKEN (CONFIRM_PASSWORD), gHiiHandle);
193 gConfirmError = GetToken (STRING_TOKEN (CONFIRM_ERROR), gHiiHandle);
194 gPassowordInvalid = GetToken (STRING_TOKEN (PASSWORD_INVALID), gHiiHandle);
195 gPressEnter = GetToken (STRING_TOKEN (PRESS_ENTER), gHiiHandle);
196 gEmptyString = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
197 gMiniString = GetToken (STRING_TOKEN (MINI_STRING), gHiiHandle);
198 gOptionMismatch = GetToken (STRING_TOKEN (OPTION_MISMATCH), gHiiHandle);
199 gFormSuppress = GetToken (STRING_TOKEN (FORM_SUPPRESSED), gHiiHandle);
200 gProtocolNotFound = GetToken (STRING_TOKEN (PROTOCOL_NOT_FOUND), gHiiHandle);
201 gFormNotFound = GetToken (STRING_TOKEN (STATUS_BROWSER_FORM_NOT_FOUND), gHiiHandle);
202 gNoSubmitIf = GetToken (STRING_TOKEN (STATUS_BROWSER_NO_SUBMIT_IF), gHiiHandle);
203 gBrwoserError = GetToken (STRING_TOKEN (STATUS_BROWSER_ERROR), gHiiHandle);
204 }
205
206 /**
207 Free up the resource allocated for all strings required
208 by Setup Browser.
209
210 **/
211 VOID
212 FreeDisplayStrings (
213 VOID
214 )
215 {
216 FreePool (mUnknownString);
217 FreePool (gEmptyString);
218 FreePool (gSaveFailed);
219 FreePool (gPromptForData);
220 FreePool (gPromptForPassword);
221 FreePool (gPromptForNewPassword);
222 FreePool (gConfirmPassword);
223 FreePool (gConfirmError);
224 FreePool (gPassowordInvalid);
225 FreePool (gPressEnter);
226 FreePool (gMiniString);
227 FreePool (gOptionMismatch);
228 FreePool (gFormSuppress);
229 FreePool (gProtocolNotFound);
230 FreePool (gBrwoserError);
231 FreePool (gNoSubmitIf);
232 FreePool (gFormNotFound);
233 }
234
235 /**
236 Get prompt string id from the opcode data buffer.
237
238 @param OpCode The input opcode buffer.
239
240 @return The prompt string id.
241
242 **/
243 EFI_STRING_ID
244 GetPrompt (
245 IN EFI_IFR_OP_HEADER *OpCode
246 )
247 {
248 EFI_IFR_STATEMENT_HEADER *Header;
249
250 if (OpCode->Length <= sizeof (EFI_IFR_OP_HEADER)) {
251 return 0;
252 }
253
254 Header = (EFI_IFR_STATEMENT_HEADER *) (OpCode + 1);
255
256 return Header->Prompt;
257 }
258
259 /**
260 Get the supported width for a particular op-code
261
262 @param MenuOption The menu option.
263 @param AdjustWidth The width which is saved for the space.
264
265 @return Returns the number of CHAR16 characters that is support.
266
267 **/
268 UINT16
269 GetWidth (
270 IN UI_MENU_OPTION *MenuOption,
271 OUT UINT16 *AdjustWidth
272 )
273 {
274 CHAR16 *String;
275 UINTN Size;
276 EFI_IFR_TEXT *TestOp;
277 UINT16 ReturnWidth;
278 FORM_DISPLAY_ENGINE_STATEMENT *Statement;
279
280 Statement = MenuOption->ThisTag;
281
282 //
283 // For modal form, clean the entire row.
284 //
285 if ((gFormData->Attribute & HII_DISPLAY_MODAL) != 0) {
286 if (AdjustWidth != NULL) {
287 *AdjustWidth = LEFT_SKIPPED_COLUMNS;
288 }
289 return (UINT16)(gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 * (gModalSkipColumn + LEFT_SKIPPED_COLUMNS));
290 }
291
292 Size = 0;
293
294 //
295 // See if the second text parameter is really NULL
296 //
297 if (Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) {
298 TestOp = (EFI_IFR_TEXT *) Statement->OpCode;
299 if (TestOp->TextTwo != 0) {
300 String = GetToken (TestOp->TextTwo, gFormData->HiiHandle);
301 Size = StrLen (String);
302 FreePool (String);
303 }
304 }
305
306 if ((Statement->OpCode->OpCode == EFI_IFR_SUBTITLE_OP) ||
307 (Statement->OpCode->OpCode == EFI_IFR_REF_OP) ||
308 (Statement->OpCode->OpCode == EFI_IFR_PASSWORD_OP) ||
309 (Statement->OpCode->OpCode == EFI_IFR_ACTION_OP) ||
310 (Statement->OpCode->OpCode == EFI_IFR_RESET_BUTTON_OP) ||
311 //
312 // Allow a wide display if text op-code and no secondary text op-code
313 //
314 ((Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) && (Size == 0))
315 ) {
316
317 //
318 // Return the space width.
319 //
320 if (AdjustWidth != NULL) {
321 *AdjustWidth = 2;
322 }
323 //
324 // Keep consistent with current behavior.
325 //
326 ReturnWidth = (UINT16) (gPromptBlockWidth + gOptionBlockWidth - 2);
327 } else {
328 if (AdjustWidth != NULL) {
329 *AdjustWidth = 1;
330 }
331
332 ReturnWidth = (UINT16) (gPromptBlockWidth - 1);
333 }
334
335 //
336 // For nest in statement, should the subtitle indent.
337 //
338 if (MenuOption->NestInStatement) {
339 ReturnWidth -= SUBTITLE_INDENT;
340 }
341
342 return ReturnWidth;
343 }
344
345 /**
346 Will copy LineWidth amount of a string in the OutputString buffer and return the
347 number of CHAR16 characters that were copied into the OutputString buffer.
348 The output string format is:
349 Glyph Info + String info + '\0'.
350
351 In the code, it deals \r,\n,\r\n same as \n\r, also it not process the \r or \g.
352
353 @param InputString String description for this option.
354 @param LineWidth Width of the desired string to extract in CHAR16
355 characters
356 @param GlyphWidth The glyph width of the begin of the char in the string.
357 @param Index Where in InputString to start the copy process
358 @param OutputString Buffer to copy the string into
359
360 @return Returns the number of CHAR16 characters that were copied into the OutputString
361 buffer, include extra glyph info and '\0' info.
362
363 **/
364 UINT16
365 GetLineByWidth (
366 IN CHAR16 *InputString,
367 IN UINT16 LineWidth,
368 IN OUT UINT16 *GlyphWidth,
369 IN OUT UINTN *Index,
370 OUT CHAR16 **OutputString
371 )
372 {
373 UINT16 StrOffset;
374 UINT16 GlyphOffset;
375 UINT16 OriginalGlyphWidth;
376 BOOLEAN ReturnFlag;
377 UINT16 LastSpaceOffset;
378 UINT16 LastGlyphWidth;
379
380 if (InputString == NULL || Index == NULL || OutputString == NULL) {
381 return 0;
382 }
383
384 if (LineWidth == 0 || *GlyphWidth == 0) {
385 return 0;
386 }
387
388 //
389 // Save original glyph width.
390 //
391 OriginalGlyphWidth = *GlyphWidth;
392 LastGlyphWidth = OriginalGlyphWidth;
393 ReturnFlag = FALSE;
394 LastSpaceOffset = 0;
395
396 //
397 // NARROW_CHAR can not be printed in screen, so if a line only contain the two CHARs: 'NARROW_CHAR + CHAR_CARRIAGE_RETURN' , it is a empty line in Screen.
398 // To avoid displaying this empty line in screen, just skip the two CHARs here.
399 //
400 if ((InputString[*Index] == NARROW_CHAR) && (InputString[*Index + 1] == CHAR_CARRIAGE_RETURN)) {
401 *Index = *Index + 2;
402 }
403
404 //
405 // Fast-forward the string and see if there is a carriage-return in the string
406 //
407 for (StrOffset = 0, GlyphOffset = 0; GlyphOffset <= LineWidth; StrOffset++) {
408 switch (InputString[*Index + StrOffset]) {
409 case NARROW_CHAR:
410 *GlyphWidth = 1;
411 break;
412
413 case WIDE_CHAR:
414 *GlyphWidth = 2;
415 break;
416
417 case CHAR_CARRIAGE_RETURN:
418 case CHAR_LINEFEED:
419 case CHAR_NULL:
420 ReturnFlag = TRUE;
421 break;
422
423 default:
424 GlyphOffset = GlyphOffset + *GlyphWidth;
425
426 //
427 // Record the last space info in this line. Will be used in rewind.
428 //
429 if ((InputString[*Index + StrOffset] == CHAR_SPACE) && (GlyphOffset <= LineWidth)) {
430 LastSpaceOffset = StrOffset;
431 LastGlyphWidth = *GlyphWidth;
432 }
433 break;
434 }
435
436 if (ReturnFlag) {
437 break;
438 }
439 }
440
441 //
442 // Rewind the string from the maximum size until we see a space to break the line
443 //
444 if (GlyphOffset > LineWidth) {
445 //
446 // Rewind the string to last space char in this line.
447 //
448 if (LastSpaceOffset != 0) {
449 StrOffset = LastSpaceOffset;
450 *GlyphWidth = LastGlyphWidth;
451 } else {
452 //
453 // Roll back to last char in the line width.
454 //
455 StrOffset--;
456 }
457 }
458
459 //
460 // The CHAR_NULL has process last time, this time just return 0 to stand for the end.
461 //
462 if (StrOffset == 0 && (InputString[*Index + StrOffset] == CHAR_NULL)) {
463 return 0;
464 }
465
466 //
467 // Need extra glyph info and '\0' info, so +2.
468 //
469 *OutputString = AllocateZeroPool (((UINTN) (StrOffset + 2) * sizeof(CHAR16)));
470 if (*OutputString == NULL) {
471 return 0;
472 }
473
474 //
475 // Save the glyph info at the begin of the string, will used by Print function.
476 //
477 if (OriginalGlyphWidth == 1) {
478 *(*OutputString) = NARROW_CHAR;
479 } else {
480 *(*OutputString) = WIDE_CHAR;
481 }
482
483 CopyMem ((*OutputString) + 1, &InputString[*Index], StrOffset * sizeof(CHAR16));
484
485 if (InputString[*Index + StrOffset] == CHAR_SPACE) {
486 //
487 // Skip the space info at the begin of next line.
488 //
489 *Index = (UINT16) (*Index + StrOffset + 1);
490 } else if (InputString[*Index + StrOffset] == CHAR_LINEFEED) {
491 //
492 // Skip the /n or /n/r info.
493 //
494 if (InputString[*Index + StrOffset + 1] == CHAR_CARRIAGE_RETURN) {
495 *Index = (UINT16) (*Index + StrOffset + 2);
496 } else {
497 *Index = (UINT16) (*Index + StrOffset + 1);
498 }
499 } else if (InputString[*Index + StrOffset] == CHAR_CARRIAGE_RETURN) {
500 //
501 // Skip the /r or /r/n info.
502 //
503 if (InputString[*Index + StrOffset + 1] == CHAR_LINEFEED) {
504 *Index = (UINT16) (*Index + StrOffset + 2);
505 } else {
506 *Index = (UINT16) (*Index + StrOffset + 1);
507 }
508 } else {
509 *Index = (UINT16) (*Index + StrOffset);
510 }
511
512 //
513 // Include extra glyph info and '\0' info, so +2.
514 //
515 return StrOffset + 2;
516 }
517
518 /**
519 Add one menu option by specified description and context.
520
521 @param Statement Statement of this Menu Option.
522 @param MenuItemCount The index for this Option in the Menu.
523 @param NestIn Whether this statement is nest in another statement.
524
525 **/
526 VOID
527 UiAddMenuOption (
528 IN FORM_DISPLAY_ENGINE_STATEMENT *Statement,
529 IN UINT16 *MenuItemCount,
530 IN BOOLEAN NestIn
531 )
532 {
533 UI_MENU_OPTION *MenuOption;
534 UINTN Index;
535 UINTN Count;
536 CHAR16 *String;
537 UINT16 NumberOfLines;
538 UINT16 GlyphWidth;
539 UINT16 Width;
540 UINTN ArrayEntry;
541 CHAR16 *OutputString;
542 EFI_STRING_ID PromptId;
543
544 NumberOfLines = 1;
545 ArrayEntry = 0;
546 GlyphWidth = 1;
547 Count = 1;
548 MenuOption = NULL;
549
550 PromptId = GetPrompt (Statement->OpCode);
551 ASSERT (PromptId != 0);
552
553 String = GetToken (PromptId, gFormData->HiiHandle);
554 ASSERT (String != NULL);
555
556 if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP || Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
557 Count = 3;
558 }
559
560 for (Index = 0; Index < Count; Index++) {
561 MenuOption = AllocateZeroPool (sizeof (UI_MENU_OPTION));
562 ASSERT (MenuOption);
563
564 MenuOption->Signature = UI_MENU_OPTION_SIGNATURE;
565 MenuOption->Description = String;
566 MenuOption->Handle = gFormData->HiiHandle;
567 MenuOption->ThisTag = Statement;
568 MenuOption->NestInStatement = NestIn;
569 MenuOption->EntryNumber = *MenuItemCount;
570
571 MenuOption->Sequence = Index;
572
573 if ((Statement->Attribute & HII_DISPLAY_GRAYOUT) != 0) {
574 MenuOption->GrayOut = TRUE;
575 } else {
576 MenuOption->GrayOut = FALSE;
577 }
578
579 if ((Statement->Attribute & HII_DISPLAY_LOCK) != 0 || (gFormData->Attribute & HII_DISPLAY_LOCK) != 0) {
580 MenuOption->GrayOut = TRUE;
581 }
582
583 //
584 // If the form or the question has the lock attribute, deal same as grayout.
585 //
586 if ((gFormData->Attribute & HII_DISPLAY_LOCK) != 0 || (Statement->Attribute & HII_DISPLAY_LOCK) != 0) {
587 MenuOption->GrayOut = TRUE;
588 }
589
590 switch (Statement->OpCode->OpCode) {
591 case EFI_IFR_ORDERED_LIST_OP:
592 case EFI_IFR_ONE_OF_OP:
593 case EFI_IFR_NUMERIC_OP:
594 case EFI_IFR_TIME_OP:
595 case EFI_IFR_DATE_OP:
596 case EFI_IFR_CHECKBOX_OP:
597 case EFI_IFR_PASSWORD_OP:
598 case EFI_IFR_STRING_OP:
599 //
600 // User could change the value of these items
601 //
602 MenuOption->IsQuestion = TRUE;
603 break;
604 case EFI_IFR_TEXT_OP:
605 if (FeaturePcdGet (PcdBrowserGrayOutTextStatement)) {
606 //
607 // Initializing GrayOut option as TRUE for Text setup options
608 // so that those options will be Gray in colour and un selectable.
609 //
610 MenuOption->GrayOut = TRUE;
611 }
612 break;
613 default:
614 MenuOption->IsQuestion = FALSE;
615 break;
616 }
617
618 if ((Statement->Attribute & HII_DISPLAY_READONLY) != 0) {
619 MenuOption->ReadOnly = TRUE;
620 if (FeaturePcdGet (PcdBrowerGrayOutReadOnlyMenu)) {
621 MenuOption->GrayOut = TRUE;
622 }
623 }
624
625 if (Index == 0 &&
626 (Statement->OpCode->OpCode != EFI_IFR_DATE_OP) &&
627 (Statement->OpCode->OpCode != EFI_IFR_TIME_OP)) {
628 Width = GetWidth (MenuOption, NULL);
629 for (; GetLineByWidth (String, Width, &GlyphWidth,&ArrayEntry, &OutputString) != 0x0000;) {
630 //
631 // If there is more string to process print on the next row and increment the Skip value
632 //
633 if (StrLen (&String[ArrayEntry]) != 0) {
634 NumberOfLines++;
635 }
636 FreePool (OutputString);
637 }
638 } else {
639 //
640 // Add three MenuOptions for Date/Time
641 // Data format : [01/02/2004] [11:22:33]
642 // Line number : 0 0 1 0 0 1
643 //
644 NumberOfLines = 0;
645 }
646
647 if (Index == 2) {
648 //
649 // Override LineNumber for the MenuOption in Date/Time sequence
650 //
651 MenuOption->Skip = 1;
652 } else {
653 MenuOption->Skip = NumberOfLines;
654 }
655
656 InsertTailList (&gMenuOption, &MenuOption->Link);
657 }
658
659 (*MenuItemCount)++;
660 }
661
662 /**
663 Create the menu list base on the form data info.
664
665 **/
666 VOID
667 ConvertStatementToMenu (
668 VOID
669 )
670 {
671 UINT16 MenuItemCount;
672 LIST_ENTRY *Link;
673 LIST_ENTRY *NestLink;
674 FORM_DISPLAY_ENGINE_STATEMENT *Statement;
675 FORM_DISPLAY_ENGINE_STATEMENT *NestStatement;
676
677 MenuItemCount = 0;
678 InitializeListHead (&gMenuOption);
679
680 Link = GetFirstNode (&gFormData->StatementListHead);
681 while (!IsNull (&gFormData->StatementListHead, Link)) {
682 Statement = FORM_DISPLAY_ENGINE_STATEMENT_FROM_LINK (Link);
683 Link = GetNextNode (&gFormData->StatementListHead, Link);
684
685 //
686 // Skip the opcode not recognized by Display core.
687 //
688 if (Statement->OpCode->OpCode == EFI_IFR_GUID_OP) {
689 continue;
690 }
691
692 UiAddMenuOption (Statement, &MenuItemCount, FALSE);
693
694 //
695 // Check the statement nest in this host statement.
696 //
697 NestLink = GetFirstNode (&Statement->NestStatementList);
698 while (!IsNull (&Statement->NestStatementList, NestLink)) {
699 NestStatement = FORM_DISPLAY_ENGINE_STATEMENT_FROM_LINK (NestLink);
700 NestLink = GetNextNode (&Statement->NestStatementList, NestLink);
701
702 //
703 // Skip the opcode not recognized by Display core.
704 //
705 if (NestStatement->OpCode->OpCode == EFI_IFR_GUID_OP) {
706 continue;
707 }
708
709 UiAddMenuOption (NestStatement, &MenuItemCount, TRUE);
710 }
711 }
712 }
713
714 /**
715 Count the storage space of a Unicode string.
716
717 This function handles the Unicode string with NARROW_CHAR
718 and WIDE_CHAR control characters. NARROW_HCAR and WIDE_CHAR
719 does not count in the resultant output. If a WIDE_CHAR is
720 hit, then 2 Unicode character will consume an output storage
721 space with size of CHAR16 till a NARROW_CHAR is hit.
722
723 If String is NULL, then ASSERT ().
724
725 @param String The input string to be counted.
726
727 @return Storage space for the input string.
728
729 **/
730 UINTN
731 GetStringWidth (
732 IN CHAR16 *String
733 )
734 {
735 UINTN Index;
736 UINTN Count;
737 UINTN IncrementValue;
738
739 ASSERT (String != NULL);
740 if (String == NULL) {
741 return 0;
742 }
743
744 Index = 0;
745 Count = 0;
746 IncrementValue = 1;
747
748 do {
749 //
750 // Advance to the null-terminator or to the first width directive
751 //
752 for (;
753 (String[Index] != NARROW_CHAR) && (String[Index] != WIDE_CHAR) && (String[Index] != 0);
754 Index++, Count = Count + IncrementValue
755 )
756 ;
757
758 //
759 // We hit the null-terminator, we now have a count
760 //
761 if (String[Index] == 0) {
762 break;
763 }
764 //
765 // We encountered a narrow directive - strip it from the size calculation since it doesn't get printed
766 // and also set the flag that determines what we increment by.(if narrow, increment by 1, if wide increment by 2)
767 //
768 if (String[Index] == NARROW_CHAR) {
769 //
770 // Skip to the next character
771 //
772 Index++;
773 IncrementValue = 1;
774 } else {
775 //
776 // Skip to the next character
777 //
778 Index++;
779 IncrementValue = 2;
780 }
781 } while (String[Index] != 0);
782
783 //
784 // Increment by one to include the null-terminator in the size
785 //
786 Count++;
787
788 return Count * sizeof (CHAR16);
789 }
790
791 /**
792 Base on the input option string to update the skip value for a menu option.
793
794 @param MenuOption The MenuOption to be checked.
795 @param OptionString The input option string.
796
797 **/
798 VOID
799 UpdateSkipInfoForMenu (
800 IN UI_MENU_OPTION *MenuOption,
801 IN CHAR16 *OptionString
802 )
803 {
804 UINTN Index;
805 UINT16 Width;
806 UINTN Row;
807 CHAR16 *OutputString;
808 UINT16 GlyphWidth;
809
810 Width = (UINT16) gOptionBlockWidth;
811 GlyphWidth = 1;
812 Row = 1;
813
814 for (Index = 0; GetLineByWidth (OptionString, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {
815 if (StrLen (&OptionString[Index]) != 0) {
816 Row++;
817 }
818
819 FreePool (OutputString);
820 }
821
822 if ((Row > MenuOption->Skip) &&
823 (MenuOption->ThisTag->OpCode->OpCode != EFI_IFR_DATE_OP) &&
824 (MenuOption->ThisTag->OpCode->OpCode != EFI_IFR_TIME_OP)) {
825 MenuOption->Skip = Row;
826 }
827 }
828
829 /**
830 Update display lines for a Menu Option.
831
832 @param MenuOption The MenuOption to be checked.
833
834 **/
835 VOID
836 UpdateOptionSkipLines (
837 IN UI_MENU_OPTION *MenuOption
838 )
839 {
840 CHAR16 *OptionString;
841
842 OptionString = NULL;
843
844 ProcessOptions (MenuOption, FALSE, &OptionString, TRUE);
845 if (OptionString != NULL) {
846 UpdateSkipInfoForMenu (MenuOption, OptionString);
847
848 FreePool (OptionString);
849 }
850
851 if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_TEXT_OP) && (((EFI_IFR_TEXT*)MenuOption->ThisTag->OpCode)->TextTwo != 0)) {
852 OptionString = GetToken (((EFI_IFR_TEXT*)MenuOption->ThisTag->OpCode)->TextTwo, gFormData->HiiHandle);
853
854 if (OptionString != NULL) {
855 UpdateSkipInfoForMenu (MenuOption, OptionString);
856
857 FreePool (OptionString);
858 }
859 }
860 }
861
862 /**
863 Check whether this Menu Option could be print.
864
865 Check Prompt string, option string or text two string not NULL.
866
867 This is an internal function.
868
869 @param MenuOption The MenuOption to be checked.
870
871 @retval TRUE This Menu Option is printable.
872 @retval FALSE This Menu Option could not be printable.
873
874 **/
875 BOOLEAN
876 PrintableMenu (
877 UI_MENU_OPTION *MenuOption
878 )
879 {
880 EFI_STATUS Status;
881 EFI_STRING OptionString;
882
883 OptionString = NULL;
884
885 if (MenuOption->Description[0] != '\0') {
886 return TRUE;
887 }
888
889 Status = ProcessOptions (MenuOption, FALSE, &OptionString, FALSE);
890 if (EFI_ERROR (Status)) {
891 return FALSE;
892 }
893 if (OptionString != NULL && OptionString[0] != '\0') {
894 FreePool (OptionString);
895 return TRUE;
896 }
897
898 if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_TEXT_OP) && (((EFI_IFR_TEXT*)MenuOption->ThisTag->OpCode)->TextTwo != 0)) {
899 OptionString = GetToken (((EFI_IFR_TEXT*)MenuOption->ThisTag->OpCode)->TextTwo, gFormData->HiiHandle);
900 ASSERT (OptionString != NULL);
901 if (OptionString[0] != '\0'){
902 FreePool (OptionString);
903 return TRUE;
904 }
905 }
906
907 return FALSE;
908 }
909
910 /**
911 Check whether this Menu Option could be highlighted.
912
913 This is an internal function.
914
915 @param MenuOption The MenuOption to be checked.
916
917 @retval TRUE This Menu Option is selectable.
918 @retval FALSE This Menu Option could not be selected.
919
920 **/
921 BOOLEAN
922 IsSelectable (
923 UI_MENU_OPTION *MenuOption
924 )
925 {
926 if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_SUBTITLE_OP) ||
927 MenuOption->GrayOut || MenuOption->ReadOnly || !PrintableMenu (MenuOption)) {
928 return FALSE;
929 } else {
930 return TRUE;
931 }
932 }
933
934 /**
935 Move to next selectable statement.
936
937 This is an internal function.
938
939 @param GoUp The navigation direction. TRUE: up, FALSE: down.
940 @param CurrentPosition Current position.
941 @param GapToTop Gap position to top or bottom.
942 @param FindInForm Whether find menu in current form or beyond.
943
944 @return The row distance from current MenuOption to next selectable MenuOption.
945
946 @retval -1 Reach the begin of the menu, still can't find the selectable menu.
947 @retval Value Find the selectable menu, maybe the truly selectable, maybe the
948 first menu showing beyond current form or last menu showing in
949 current form.
950 The value is the line number between the new selected menu and the
951 current select menu, not include the new selected menu.
952
953 **/
954 INTN
955 MoveToNextStatement (
956 IN BOOLEAN GoUp,
957 IN OUT LIST_ENTRY **CurrentPosition,
958 IN UINTN GapToTop,
959 IN BOOLEAN FindInForm
960 )
961 {
962 INTN Distance;
963 LIST_ENTRY *Pos;
964 UI_MENU_OPTION *NextMenuOption;
965 UI_MENU_OPTION *PreMenuOption;
966
967 Distance = 0;
968 Pos = *CurrentPosition;
969
970 if (Pos == &gMenuOption) {
971 return -1;
972 }
973
974 PreMenuOption = MENU_OPTION_FROM_LINK (Pos);
975
976 while (TRUE) {
977 NextMenuOption = MENU_OPTION_FROM_LINK (Pos);
978 //
979 // NextMenuOption->Row == 0 means this menu has not calculate
980 // the NextMenuOption->Skip value yet, just calculate here.
981 //
982 if (NextMenuOption->Row == 0) {
983 UpdateOptionSkipLines (NextMenuOption);
984 }
985
986 if (IsSelectable (NextMenuOption)) {
987 break;
988 }
989
990 //
991 // In this case, still can't find the selectable menu,
992 // return the first one beyond the showing form.
993 //
994 if ((UINTN) Distance + NextMenuOption->Skip > GapToTop) {
995 if (FindInForm) {
996 NextMenuOption = PreMenuOption;
997 }
998 break;
999 }
1000
1001 Distance += NextMenuOption->Skip;
1002
1003 //
1004 // Arrive at begin of the menu list.
1005 //
1006 if ((GoUp ? Pos->BackLink : Pos->ForwardLink) == &gMenuOption) {
1007 Distance = -1;
1008 break;
1009 }
1010
1011 Pos = (GoUp ? Pos->BackLink : Pos->ForwardLink);
1012 PreMenuOption = NextMenuOption;
1013 }
1014
1015 *CurrentPosition = &NextMenuOption->Link;
1016 return Distance;
1017 }
1018
1019
1020 /**
1021 Process option string for date/time opcode.
1022
1023 @param MenuOption Menu option point to date/time.
1024 @param OptionString Option string input for process.
1025 @param AddOptCol Whether need to update MenuOption->OptCol.
1026
1027 **/
1028 VOID
1029 ProcessStringForDateTime (
1030 UI_MENU_OPTION *MenuOption,
1031 CHAR16 *OptionString,
1032 BOOLEAN AddOptCol
1033 )
1034 {
1035 UINTN Index;
1036 UINTN Count;
1037 FORM_DISPLAY_ENGINE_STATEMENT *Statement;
1038 EFI_IFR_DATE *Date;
1039 EFI_IFR_TIME *Time;
1040
1041 ASSERT (MenuOption != NULL && OptionString != NULL);
1042
1043 Statement = MenuOption->ThisTag;
1044 Date = NULL;
1045 Time = NULL;
1046 if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP) {
1047 Date = (EFI_IFR_DATE *) Statement->OpCode;
1048 } else if (Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
1049 Time = (EFI_IFR_TIME *) Statement->OpCode;
1050 }
1051
1052 //
1053 // If leading spaces on OptionString - remove the spaces
1054 //
1055 for (Index = 0; OptionString[Index] == L' '; Index++) {
1056 //
1057 // Base on the blockspace to get the option column info.
1058 //
1059 if (AddOptCol) {
1060 MenuOption->OptCol++;
1061 }
1062 }
1063
1064 for (Count = 0; OptionString[Index] != CHAR_NULL; Index++) {
1065 OptionString[Count] = OptionString[Index];
1066 Count++;
1067 }
1068 OptionString[Count] = CHAR_NULL;
1069
1070 //
1071 // Enable to suppress field in the opcode base on the flag.
1072 //
1073 if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP) {
1074 //
1075 // OptionString format is: <**: **: ****>
1076 // |month|day|year|
1077 // 4 3 5
1078 //
1079 if ((Date->Flags & EFI_QF_DATE_MONTH_SUPPRESS) && (MenuOption->Sequence == 0)) {
1080 //
1081 // At this point, only "<**:" in the optionstring.
1082 // Clean the day's ** field, after clean, the format is "< :"
1083 //
1084 SetUnicodeMem (&OptionString[1], 2, L' ');
1085 } else if ((Date->Flags & EFI_QF_DATE_DAY_SUPPRESS) && (MenuOption->Sequence == 1)) {
1086 //
1087 // At this point, only "**:" in the optionstring.
1088 // Clean the month's "**" field, after clean, the format is " :"
1089 //
1090 SetUnicodeMem (&OptionString[0], 2, L' ');
1091 } else if ((Date->Flags & EFI_QF_DATE_YEAR_SUPPRESS) && (MenuOption->Sequence == 2)) {
1092 //
1093 // At this point, only "****>" in the optionstring.
1094 // Clean the year's "****" field, after clean, the format is " >"
1095 //
1096 SetUnicodeMem (&OptionString[0], 4, L' ');
1097 }
1098 } else if (Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
1099 //
1100 // OptionString format is: <**: **: **>
1101 // |hour|minute|second|
1102 // 4 3 3
1103 //
1104 if ((Time->Flags & QF_TIME_HOUR_SUPPRESS) && (MenuOption->Sequence == 0)) {
1105 //
1106 // At this point, only "<**:" in the optionstring.
1107 // Clean the hour's ** field, after clean, the format is "< :"
1108 //
1109 SetUnicodeMem (&OptionString[1], 2, L' ');
1110 } else if ((Time->Flags & QF_TIME_MINUTE_SUPPRESS) && (MenuOption->Sequence == 1)) {
1111 //
1112 // At this point, only "**:" in the optionstring.
1113 // Clean the minute's "**" field, after clean, the format is " :"
1114 //
1115 SetUnicodeMem (&OptionString[0], 2, L' ');
1116 } else if ((Time->Flags & QF_TIME_SECOND_SUPPRESS) && (MenuOption->Sequence == 2)) {
1117 //
1118 // At this point, only "**>" in the optionstring.
1119 // Clean the second's "**" field, after clean, the format is " >"
1120 //
1121 SetUnicodeMem (&OptionString[0], 2, L' ');
1122 }
1123 }
1124 }
1125
1126
1127 /**
1128 Adjust Data and Time position accordingly.
1129 Data format : [01/02/2004] [11:22:33]
1130 Line number : 0 0 1 0 0 1
1131
1132 This is an internal function.
1133
1134 @param DirectionUp the up or down direction. False is down. True is
1135 up.
1136 @param CurrentPosition Current position. On return: Point to the last
1137 Option (Year or Second) if up; Point to the first
1138 Option (Month or Hour) if down.
1139
1140 @return Return line number to pad. It is possible that we stand on a zero-advance
1141 @return data or time opcode, so pad one line when we judge if we are going to scroll outside.
1142
1143 **/
1144 UINTN
1145 AdjustDateAndTimePosition (
1146 IN BOOLEAN DirectionUp,
1147 IN OUT LIST_ENTRY **CurrentPosition
1148 )
1149 {
1150 UINTN Count;
1151 LIST_ENTRY *NewPosition;
1152 UI_MENU_OPTION *MenuOption;
1153 UINTN PadLineNumber;
1154
1155 PadLineNumber = 0;
1156 NewPosition = *CurrentPosition;
1157 MenuOption = MENU_OPTION_FROM_LINK (NewPosition);
1158
1159 if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_DATE_OP) ||
1160 (MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_TIME_OP)) {
1161 //
1162 // Calculate the distance from current position to the last Date/Time MenuOption
1163 //
1164 Count = 0;
1165 while (MenuOption->Skip == 0) {
1166 Count++;
1167 NewPosition = NewPosition->ForwardLink;
1168 MenuOption = MENU_OPTION_FROM_LINK (NewPosition);
1169 PadLineNumber = 1;
1170 }
1171
1172 NewPosition = *CurrentPosition;
1173 if (DirectionUp) {
1174 //
1175 // Since the behavior of hitting the up arrow on a Date/Time MenuOption is intended
1176 // to be one that back to the previous set of MenuOptions, we need to advance to the first
1177 // Date/Time MenuOption and leave the remaining logic in CfUiUp intact so the appropriate
1178 // checking can be done.
1179 //
1180 while (Count++ < 2) {
1181 NewPosition = NewPosition->BackLink;
1182 }
1183 } else {
1184 //
1185 // Since the behavior of hitting the down arrow on a Date/Time MenuOption is intended
1186 // to be one that progresses to the next set of MenuOptions, we need to advance to the last
1187 // Date/Time MenuOption and leave the remaining logic in CfUiDown intact so the appropriate
1188 // checking can be done.
1189 //
1190 while (Count-- > 0) {
1191 NewPosition = NewPosition->ForwardLink;
1192 }
1193 }
1194
1195 *CurrentPosition = NewPosition;
1196 }
1197
1198 return PadLineNumber;
1199 }
1200
1201 /**
1202 Get step info from numeric opcode.
1203
1204 @param[in] OpCode The input numeric op code.
1205
1206 @return step info for this opcode.
1207 **/
1208 UINT64
1209 GetFieldFromNum (
1210 IN EFI_IFR_OP_HEADER *OpCode
1211 )
1212 {
1213 EFI_IFR_NUMERIC *NumericOp;
1214 UINT64 Step;
1215
1216 NumericOp = (EFI_IFR_NUMERIC *) OpCode;
1217
1218 switch (NumericOp->Flags & EFI_IFR_NUMERIC_SIZE) {
1219 case EFI_IFR_NUMERIC_SIZE_1:
1220 Step = NumericOp->data.u8.Step;
1221 break;
1222
1223 case EFI_IFR_NUMERIC_SIZE_2:
1224 Step = NumericOp->data.u16.Step;
1225 break;
1226
1227 case EFI_IFR_NUMERIC_SIZE_4:
1228 Step = NumericOp->data.u32.Step;
1229 break;
1230
1231 case EFI_IFR_NUMERIC_SIZE_8:
1232 Step = NumericOp->data.u64.Step;
1233 break;
1234
1235 default:
1236 Step = 0;
1237 break;
1238 }
1239
1240 return Step;
1241 }
1242
1243 /**
1244 Find the registered HotKey based on KeyData.
1245
1246 @param[in] KeyData A pointer to a buffer that describes the keystroke
1247 information for the hot key.
1248
1249 @return The registered HotKey context. If no found, NULL will return.
1250 **/
1251 BROWSER_HOT_KEY *
1252 GetHotKeyFromRegisterList (
1253 IN EFI_INPUT_KEY *KeyData
1254 )
1255 {
1256 LIST_ENTRY *Link;
1257 BROWSER_HOT_KEY *HotKey;
1258
1259 Link = GetFirstNode (&gFormData->HotKeyListHead);
1260 while (!IsNull (&gFormData->HotKeyListHead, Link)) {
1261 HotKey = BROWSER_HOT_KEY_FROM_LINK (Link);
1262
1263 if (HotKey->KeyData->ScanCode == KeyData->ScanCode) {
1264 return HotKey;
1265 }
1266
1267 Link = GetNextNode (&gFormData->HotKeyListHead, Link);
1268 }
1269
1270 return NULL;
1271 }
1272
1273
1274 /**
1275 Determine if the menu is the last menu that can be selected.
1276
1277 This is an internal function.
1278
1279 @param Direction The scroll direction. False is down. True is up.
1280 @param CurrentPos The current focus.
1281
1282 @return FALSE -- the menu isn't the last menu that can be selected.
1283 @return TRUE -- the menu is the last menu that can be selected.
1284
1285 **/
1286 BOOLEAN
1287 ValueIsScroll (
1288 IN BOOLEAN Direction,
1289 IN LIST_ENTRY *CurrentPos
1290 )
1291 {
1292 LIST_ENTRY *Temp;
1293
1294 Temp = Direction ? CurrentPos->BackLink : CurrentPos->ForwardLink;
1295
1296 if (Temp == &gMenuOption) {
1297 return TRUE;
1298 }
1299
1300 return FALSE;
1301 }
1302
1303 /**
1304 Wait for a given event to fire, or for an optional timeout to expire.
1305
1306 @param Event The event to wait for
1307
1308 @retval UI_EVENT_TYPE The type of the event which is trigged.
1309
1310 **/
1311 UI_EVENT_TYPE
1312 UiWaitForEvent (
1313 IN EFI_EVENT Event
1314 )
1315 {
1316 EFI_STATUS Status;
1317 UINTN Index;
1318 UINTN EventNum;
1319 UINT64 Timeout;
1320 EFI_EVENT TimerEvent;
1321 EFI_EVENT WaitList[3];
1322 UI_EVENT_TYPE EventType;
1323
1324 TimerEvent = NULL;
1325 Timeout = FormExitTimeout(gFormData);
1326
1327 if (Timeout != 0) {
1328 Status = gBS->CreateEvent (EVT_TIMER, 0, NULL, NULL, &TimerEvent);
1329
1330 //
1331 // Set the timer event
1332 //
1333 gBS->SetTimer (
1334 TimerEvent,
1335 TimerRelative,
1336 Timeout
1337 );
1338 }
1339
1340 WaitList[0] = Event;
1341 EventNum = 1;
1342 if (gFormData->FormRefreshEvent != NULL) {
1343 WaitList[EventNum] = gFormData->FormRefreshEvent;
1344 EventNum ++;
1345 }
1346
1347 if (Timeout != 0) {
1348 WaitList[EventNum] = TimerEvent;
1349 EventNum ++;
1350 }
1351
1352 Status = gBS->WaitForEvent (EventNum, WaitList, &Index);
1353 ASSERT_EFI_ERROR (Status);
1354
1355 switch (Index) {
1356 case 0:
1357 EventType = UIEventKey;
1358 break;
1359
1360 case 1:
1361 if (gFormData->FormRefreshEvent != NULL) {
1362 EventType = UIEventDriver;
1363 } else {
1364 ASSERT (Timeout != 0 && EventNum == 2);
1365 EventType = UIEventTimeOut;
1366 }
1367 break;
1368
1369 default:
1370 ASSERT (Index == 2 && EventNum == 3);
1371 EventType = UIEventTimeOut;
1372 break;
1373 }
1374
1375 if (Timeout != 0) {
1376 gBS->CloseEvent (TimerEvent);
1377 }
1378
1379 return EventType;
1380 }
1381
1382 /**
1383 Get question id info from the input opcode header.
1384
1385 @param OpCode The input opcode header pointer.
1386
1387 @retval The question id for this opcode.
1388
1389 **/
1390 EFI_QUESTION_ID
1391 GetQuestionIdInfo (
1392 IN EFI_IFR_OP_HEADER *OpCode
1393 )
1394 {
1395 EFI_IFR_QUESTION_HEADER *QuestionHeader;
1396
1397 if (OpCode->Length < sizeof (EFI_IFR_OP_HEADER) + sizeof (EFI_IFR_QUESTION_HEADER)) {
1398 return 0;
1399 }
1400
1401 QuestionHeader = (EFI_IFR_QUESTION_HEADER *)((UINT8 *) OpCode + sizeof(EFI_IFR_OP_HEADER));
1402
1403 return QuestionHeader->QuestionId;
1404 }
1405
1406
1407 /**
1408 Find the top of screen menu base on the current menu.
1409
1410 @param CurPos Current input menu.
1411 @param Rows Totol screen rows.
1412 @param SkipValue SkipValue for this new form.
1413
1414 @retval TopOfScreen Top of screen menu for the new form.
1415
1416 **/
1417 LIST_ENTRY *
1418 FindTopOfScreenMenu (
1419 IN LIST_ENTRY *CurPos,
1420 IN UINTN Rows,
1421 OUT UINTN *SkipValue
1422 )
1423 {
1424 LIST_ENTRY *Link;
1425 LIST_ENTRY *TopOfScreen;
1426 UI_MENU_OPTION *PreviousMenuOption;
1427
1428 Link = CurPos;
1429 PreviousMenuOption = NULL;
1430
1431 while (Link->BackLink != &gMenuOption) {
1432 Link = Link->BackLink;
1433 PreviousMenuOption = MENU_OPTION_FROM_LINK (Link);
1434 if (PreviousMenuOption->Row == 0) {
1435 UpdateOptionSkipLines (PreviousMenuOption);
1436 }
1437 if (Rows <= PreviousMenuOption->Skip) {
1438 break;
1439 }
1440 Rows = Rows - PreviousMenuOption->Skip;
1441 }
1442
1443 if (Link->BackLink == &gMenuOption) {
1444 TopOfScreen = gMenuOption.ForwardLink;
1445 if (PreviousMenuOption != NULL && Rows < PreviousMenuOption->Skip) {
1446 *SkipValue = PreviousMenuOption->Skip - Rows;
1447 } else {
1448 *SkipValue = 0;
1449 }
1450 } else {
1451 TopOfScreen = Link;
1452 *SkipValue = PreviousMenuOption->Skip - Rows;
1453 }
1454
1455 return TopOfScreen;
1456 }
1457
1458 /**
1459 Find the first menu which will be show at the top.
1460
1461 @param FormData The data info for this form.
1462 @param TopOfScreen The link_entry pointer to top menu.
1463 @param HighlightMenu The menu which will be highlight.
1464 @param SkipValue The skip value for the top menu.
1465
1466 **/
1467 VOID
1468 FindTopMenu (
1469 IN FORM_DISPLAY_ENGINE_FORM *FormData,
1470 OUT LIST_ENTRY **TopOfScreen,
1471 OUT LIST_ENTRY **HighlightMenu,
1472 OUT UINTN *SkipValue
1473 )
1474 {
1475 LIST_ENTRY *NewPos;
1476 UINTN TopRow;
1477 UINTN BottomRow;
1478 UI_MENU_OPTION *SavedMenuOption;
1479 UINTN TmpValue;
1480
1481 TopRow = gStatementDimensions.TopRow + SCROLL_ARROW_HEIGHT;
1482 BottomRow = gStatementDimensions.BottomRow - SCROLL_ARROW_HEIGHT;
1483
1484 //
1485 // If not has input highlight statement, just return the first one in this form.
1486 //
1487 if (FormData->HighLightedStatement == NULL) {
1488 *TopOfScreen = gMenuOption.ForwardLink;
1489 *HighlightMenu = gMenuOption.ForwardLink;
1490 if (!IsListEmpty (&gMenuOption)) {
1491 MoveToNextStatement (FALSE, HighlightMenu, BottomRow - TopRow, TRUE);
1492 }
1493 *SkipValue = 0;
1494 return;
1495 }
1496
1497 //
1498 // Now base on the input highlight menu to find the top menu in this page.
1499 // Will base on the highlight menu show at the bottom to find the top menu.
1500 //
1501 NewPos = gMenuOption.ForwardLink;
1502 SavedMenuOption = MENU_OPTION_FROM_LINK (NewPos);
1503
1504 while ((SavedMenuOption->ThisTag != FormData->HighLightedStatement) ||
1505 (SavedMenuOption->Sequence != gSequence)) {
1506 NewPos = NewPos->ForwardLink;
1507 if (NewPos == &gMenuOption) {
1508 //
1509 // Not Found it, break
1510 //
1511 break;
1512 }
1513 SavedMenuOption = MENU_OPTION_FROM_LINK (NewPos);
1514 }
1515 ASSERT (SavedMenuOption->ThisTag == FormData->HighLightedStatement);
1516
1517 *HighlightMenu = NewPos;
1518
1519 AdjustDateAndTimePosition(FALSE, &NewPos);
1520 SavedMenuOption = MENU_OPTION_FROM_LINK (NewPos);
1521 UpdateOptionSkipLines (SavedMenuOption);
1522
1523 //
1524 // If highlight opcode is date/time, keep the highlight row info not change.
1525 //
1526 if ((SavedMenuOption->ThisTag->OpCode->OpCode == EFI_IFR_DATE_OP || SavedMenuOption->ThisTag->OpCode->OpCode == EFI_IFR_TIME_OP) &&
1527 (gHighligthMenuInfo.QuestionId != 0) &&
1528 (gHighligthMenuInfo.QuestionId == GetQuestionIdInfo(SavedMenuOption->ThisTag->OpCode))) {
1529 //
1530 // Still show the highlight menu before exit from display engine.
1531 //
1532 BottomRow = gHighligthMenuInfo.DisplayRow + SavedMenuOption->Skip;
1533 }
1534
1535 if (SavedMenuOption->Skip >= BottomRow - TopRow) {
1536 TmpValue = 0;
1537 *TopOfScreen = NewPos;
1538 } else {
1539 *TopOfScreen = FindTopOfScreenMenu(NewPos, BottomRow - TopRow - SavedMenuOption->Skip, &TmpValue);
1540 }
1541
1542 *SkipValue = TmpValue;
1543 }
1544
1545 /**
1546 Update highlight menu info.
1547
1548 @param MenuOption The menu opton which is highlight.
1549
1550 **/
1551 VOID
1552 UpdateHighlightMenuInfo (
1553 IN UI_MENU_OPTION *MenuOption
1554 )
1555 {
1556 FORM_DISPLAY_ENGINE_STATEMENT *Statement;
1557
1558 //
1559 // This is the current selected statement
1560 //
1561 Statement = MenuOption->ThisTag;
1562
1563 //
1564 // Get the highlight statement.
1565 //
1566 gUserInput->SelectedStatement = Statement;
1567 gSequence = (UINT16) MenuOption->Sequence;
1568
1569 //
1570 // Record highlight row info for date/time opcode.
1571 //
1572 if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP || Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
1573 gHighligthMenuInfo.QuestionId = GetQuestionIdInfo(Statement->OpCode);
1574 gHighligthMenuInfo.DisplayRow = (UINT16) MenuOption->Row;
1575 } else {
1576 gHighligthMenuInfo.QuestionId = 0;
1577 gHighligthMenuInfo.DisplayRow = 0;
1578 }
1579
1580 RefreshKeyHelp(gFormData, Statement, FALSE);
1581 }
1582
1583 /**
1584 Update attribut for this menu.
1585
1586 @param MenuOption The menu opton which this attribut used to.
1587 @param Highlight Whether this menu will be highlight.
1588
1589 **/
1590 VOID
1591 SetDisplayAttribute (
1592 IN UI_MENU_OPTION *MenuOption,
1593 IN BOOLEAN Highlight
1594 )
1595 {
1596 FORM_DISPLAY_ENGINE_STATEMENT *Statement;
1597
1598 Statement = MenuOption->ThisTag;
1599
1600 if (Highlight) {
1601 gST->ConOut->SetAttribute (gST->ConOut, GetHighlightTextColor ());
1602 return;
1603 }
1604
1605 if (MenuOption->GrayOut) {
1606 gST->ConOut->SetAttribute (gST->ConOut, GetGrayedTextColor ());
1607 } else {
1608 if (Statement->OpCode->OpCode == EFI_IFR_SUBTITLE_OP) {
1609 gST->ConOut->SetAttribute (gST->ConOut, GetSubTitleTextColor ());
1610 } else {
1611 gST->ConOut->SetAttribute (gST->ConOut, GetFieldTextColor ());
1612 }
1613 }
1614 }
1615
1616 /**
1617 Print string for this menu option.
1618
1619 @param MenuOption The menu opton which this attribut used to.
1620 @param Col The column that this string will be print at.
1621 @param Row The row that this string will be print at.
1622 @param String The string which need to print.
1623 @param Width The width need to print, if string is less than the
1624 width, the block space will be used.
1625 @param Highlight Whether this menu will be highlight.
1626
1627 **/
1628 VOID
1629 DisplayMenuString (
1630 IN UI_MENU_OPTION *MenuOption,
1631 IN UINTN Col,
1632 IN UINTN Row,
1633 IN CHAR16 *String,
1634 IN UINTN Width,
1635 IN BOOLEAN Highlight
1636 )
1637 {
1638 UINTN Length;
1639
1640 //
1641 // Print string with normal color.
1642 //
1643 if (!Highlight) {
1644 PrintStringAtWithWidth (Col, Row, String, Width);
1645 return;
1646 }
1647
1648 //
1649 // Print the highlight menu string.
1650 // First print the highlight string.
1651 //
1652 SetDisplayAttribute(MenuOption, TRUE);
1653 Length = PrintStringAt (Col, Row, String);
1654
1655 //
1656 // Second, clean the empty after the string.
1657 //
1658 SetDisplayAttribute(MenuOption, FALSE);
1659 PrintStringAtWithWidth (Col + Length, Row, L"", Width - Length);
1660 }
1661
1662 /**
1663 Check whether this menu can has option string.
1664
1665 @param MenuOption The menu opton which this attribut used to.
1666
1667 @retval TRUE This menu option can have option string.
1668 @retval FALSE This menu option can't have option string.
1669
1670 **/
1671 BOOLEAN
1672 HasOptionString (
1673 IN UI_MENU_OPTION *MenuOption
1674 )
1675 {
1676 FORM_DISPLAY_ENGINE_STATEMENT *Statement;
1677 CHAR16 *String;
1678 UINTN Size;
1679 EFI_IFR_TEXT *TestOp;
1680
1681 Size = 0;
1682 Statement = MenuOption->ThisTag;
1683
1684 //
1685 // See if the second text parameter is really NULL
1686 //
1687 if (Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) {
1688 TestOp = (EFI_IFR_TEXT *) Statement->OpCode;
1689 if (TestOp->TextTwo != 0) {
1690 String = GetToken (TestOp->TextTwo, gFormData->HiiHandle);
1691 Size = StrLen (String);
1692 FreePool (String);
1693 }
1694 }
1695
1696 if ((Statement->OpCode->OpCode == EFI_IFR_SUBTITLE_OP) ||
1697 (Statement->OpCode->OpCode == EFI_IFR_REF_OP) ||
1698 (Statement->OpCode->OpCode == EFI_IFR_PASSWORD_OP) ||
1699 (Statement->OpCode->OpCode == EFI_IFR_ACTION_OP) ||
1700 (Statement->OpCode->OpCode == EFI_IFR_RESET_BUTTON_OP) ||
1701 //
1702 // Allow a wide display if text op-code and no secondary text op-code
1703 //
1704 ((Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) && (Size == 0))
1705 ) {
1706
1707 return FALSE;
1708 }
1709
1710 return TRUE;
1711 }
1712
1713
1714 /**
1715 Print string for this menu option.
1716
1717 @param MenuOption The menu opton which this attribut used to.
1718 @param SkipWidth The skip width between the left to the start of the prompt.
1719 @param BeginCol The begin column for one menu.
1720 @param SkipLine The skip line for this menu.
1721 @param BottomRow The bottom row for this form.
1722 @param Highlight Whether this menu will be highlight.
1723
1724 @retval EFI_SUCESSS Process the user selection success.
1725
1726 **/
1727 EFI_STATUS
1728 DisplayOneMenu (
1729 IN UI_MENU_OPTION *MenuOption,
1730 IN UINTN SkipWidth,
1731 IN UINTN BeginCol,
1732 IN UINTN SkipLine,
1733 IN UINTN BottomRow,
1734 IN BOOLEAN Highlight
1735 )
1736 {
1737 FORM_DISPLAY_ENGINE_STATEMENT *Statement;
1738 UINTN Index;
1739 UINT16 Width;
1740 UINT16 PromptWidth;
1741 CHAR16 *StringPtr;
1742 CHAR16 *OptionString;
1743 CHAR16 *OutputString;
1744 UINT16 GlyphWidth;
1745 UINTN Temp;
1746 UINTN Temp2;
1747 UINTN Temp3;
1748 EFI_STATUS Status;
1749 UINTN Row;
1750 UINTN Col;
1751 UINTN PromptLineNum;
1752 UINTN OptionLineNum;
1753 CHAR16 AdjustValue;
1754 UINTN MaxRow;
1755
1756 Statement = MenuOption->ThisTag;
1757 Temp = SkipLine;
1758 Temp2 = SkipLine;
1759 Temp3 = SkipLine;
1760 AdjustValue = 0;
1761 PromptLineNum = 0;
1762 OptionLineNum = 0;
1763 MaxRow = 0;
1764
1765 //
1766 // Set default color.
1767 //
1768 SetDisplayAttribute (MenuOption, FALSE);
1769
1770 //
1771 // 1. Paint the option string.
1772 //
1773 Status = ProcessOptions (MenuOption, FALSE, &OptionString, FALSE);
1774 if (EFI_ERROR (Status)) {
1775 return Status;
1776 }
1777
1778 if (OptionString != NULL) {
1779 if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP || Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
1780 //
1781 // Adjust option string for date/time opcode.
1782 //
1783 ProcessStringForDateTime(MenuOption, OptionString, TRUE);
1784 }
1785
1786 Width = (UINT16) gOptionBlockWidth - 1;
1787 Row = MenuOption->Row;
1788 GlyphWidth = 1;
1789 OptionLineNum = 0;
1790
1791 for (Index = 0; GetLineByWidth (OptionString, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {
1792 if (((Temp2 == 0)) && (Row <= BottomRow)) {
1793 if (Statement->OpCode->OpCode == EFI_IFR_DATE_OP || Statement->OpCode->OpCode == EFI_IFR_TIME_OP) {
1794 //
1795 // For date/time question, it has three menu options for this qustion.
1796 // The first/second menu options with the skip value is 0. the last one
1797 // with skip value is 1.
1798 //
1799 if (MenuOption->Skip != 0) {
1800 //
1801 // For date/ time, print the last past (year for date and second for time)
1802 // - 7 means skip [##/##/ for date and [##:##: for time.
1803 //
1804 DisplayMenuString (MenuOption,MenuOption->OptCol, Row, OutputString, Width + 1 - 7, Highlight);
1805 } else {
1806 //
1807 // For date/ time, print the first and second past (year for date and second for time)
1808 //
1809 DisplayMenuString (MenuOption, MenuOption->OptCol, Row, OutputString, StrLen (OutputString), Highlight);
1810 }
1811 } else {
1812 DisplayMenuString (MenuOption, MenuOption->OptCol, Row, OutputString, Width + 1, Highlight);
1813 }
1814 OptionLineNum++;
1815 }
1816
1817 //
1818 // If there is more string to process print on the next row and increment the Skip value
1819 //
1820 if (StrLen (&OptionString[Index]) != 0) {
1821 if (Temp2 == 0) {
1822 Row++;
1823 //
1824 // Since the Number of lines for this menu entry may or may not be reflected accurately
1825 // since the prompt might be 1 lines and option might be many, and vice versa, we need to do
1826 // some testing to ensure we are keeping this in-sync.
1827 //
1828 // If the difference in rows is greater than or equal to the skip value, increase the skip value
1829 //
1830 if ((Row - MenuOption->Row) >= MenuOption->Skip) {
1831 MenuOption->Skip++;
1832 }
1833 }
1834 }
1835
1836 FreePool (OutputString);
1837 if (Temp2 != 0) {
1838 Temp2--;
1839 }
1840 }
1841
1842 Highlight = FALSE;
1843
1844 FreePool (OptionString);
1845 }
1846
1847 //
1848 // 2. Paint the description.
1849 //
1850 PromptWidth = GetWidth (MenuOption, &AdjustValue);
1851 Row = MenuOption->Row;
1852 GlyphWidth = 1;
1853 PromptLineNum = 0;
1854
1855 if (MenuOption->Description == NULL || MenuOption->Description[0] == '\0') {
1856 PrintStringAtWithWidth (BeginCol, Row, L"", PromptWidth + AdjustValue + SkipWidth);
1857 PromptLineNum++;
1858 } else {
1859 for (Index = 0; GetLineByWidth (MenuOption->Description, PromptWidth, &GlyphWidth, &Index, &OutputString) != 0x0000;) {
1860 if ((Temp == 0) && (Row <= BottomRow)) {
1861 //
1862 // 1.Clean the start LEFT_SKIPPED_COLUMNS
1863 //
1864 PrintStringAtWithWidth (BeginCol, Row, L"", SkipWidth);
1865
1866 if (Statement->OpCode->OpCode == EFI_IFR_REF_OP && MenuOption->Col >= 2) {
1867 //
1868 // Print Arrow for Goto button.
1869 //
1870 PrintCharAt (
1871 MenuOption->Col - 2,
1872 Row,
1873 GEOMETRICSHAPE_RIGHT_TRIANGLE
1874 );
1875 }
1876 DisplayMenuString (MenuOption, MenuOption->Col, Row, OutputString, PromptWidth + AdjustValue, Highlight);
1877 PromptLineNum ++;
1878 }
1879 //
1880 // If there is more string to process print on the next row and increment the Skip value
1881 //
1882 if (StrLen (&MenuOption->Description[Index]) != 0) {
1883 if (Temp == 0) {
1884 Row++;
1885 }
1886 }
1887
1888 FreePool (OutputString);
1889 if (Temp != 0) {
1890 Temp--;
1891 }
1892 }
1893
1894 Highlight = FALSE;
1895 }
1896
1897
1898 //
1899 // 3. If this is a text op with secondary text information
1900 //
1901 if ((Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) && (((EFI_IFR_TEXT*)Statement->OpCode)->TextTwo != 0)) {
1902 StringPtr = GetToken (((EFI_IFR_TEXT*)Statement->OpCode)->TextTwo, gFormData->HiiHandle);
1903
1904 Width = (UINT16) gOptionBlockWidth - 1;
1905 Row = MenuOption->Row;
1906 GlyphWidth = 1;
1907 OptionLineNum = 0;
1908
1909 for (Index = 0; GetLineByWidth (StringPtr, Width, &GlyphWidth, &Index, &OutputString) != 0x0000;) {
1910 if ((Temp3 == 0) && (Row <= BottomRow)) {
1911 DisplayMenuString (MenuOption, MenuOption->OptCol, Row, OutputString, Width + 1, Highlight);
1912 OptionLineNum++;
1913 }
1914 //
1915 // If there is more string to process print on the next row and increment the Skip value
1916 //
1917 if (StrLen (&StringPtr[Index]) != 0) {
1918 if (Temp3 == 0) {
1919 Row++;
1920 //
1921 // If the rows for text two is greater than or equal to the skip value, increase the skip value
1922 //
1923 if ((Row - MenuOption->Row) >= MenuOption->Skip) {
1924 MenuOption->Skip++;
1925 }
1926 }
1927 }
1928
1929 FreePool (OutputString);
1930 if (Temp3 != 0) {
1931 Temp3--;
1932 }
1933 }
1934
1935 FreePool (StringPtr);
1936 }
1937
1938 //
1939 // 4.Line number for Option string and prompt string are not equal.
1940 // Clean the column whose line number is less.
1941 //
1942 if (HasOptionString(MenuOption) && (OptionLineNum != PromptLineNum)) {
1943 Col = OptionLineNum < PromptLineNum ? MenuOption->OptCol : BeginCol;
1944 Row = (OptionLineNum < PromptLineNum ? OptionLineNum : PromptLineNum) + MenuOption->Row;
1945 Width = (UINT16) (OptionLineNum < PromptLineNum ? gOptionBlockWidth : PromptWidth + AdjustValue + SkipWidth);
1946 MaxRow = (OptionLineNum < PromptLineNum ? PromptLineNum : OptionLineNum) + MenuOption->Row - 1;
1947
1948 while (Row <= MaxRow) {
1949 DisplayMenuString (MenuOption, Col, Row++, L"", Width, FALSE);
1950 }
1951 }
1952
1953 return EFI_SUCCESS;
1954 }
1955
1956 /**
1957 Display menu and wait for user to select one menu option, then return it.
1958 If AutoBoot is enabled, then if user doesn't select any option,
1959 after period of time, it will automatically return the first menu option.
1960
1961 @param FormData The current form data info.
1962
1963 @retval EFI_SUCESSS Process the user selection success.
1964 @retval EFI_NOT_FOUND Process option string for orderedlist/Oneof fail.
1965
1966 **/
1967 EFI_STATUS
1968 UiDisplayMenu (
1969 IN FORM_DISPLAY_ENGINE_FORM *FormData
1970 )
1971 {
1972 UINTN SkipValue;
1973 INTN Difference;
1974 UINTN DistanceValue;
1975 UINTN Row;
1976 UINTN Col;
1977 UINTN Temp;
1978 UINTN Temp2;
1979 UINTN TopRow;
1980 UINTN BottomRow;
1981 UINTN Index;
1982 UINT16 Width;
1983 CHAR16 *StringPtr;
1984 CHAR16 *OptionString;
1985 CHAR16 *OutputString;
1986 CHAR16 *HelpString;
1987 CHAR16 *HelpHeaderString;
1988 CHAR16 *HelpBottomString;
1989 BOOLEAN NewLine;
1990 BOOLEAN Repaint;
1991 BOOLEAN UpArrow;
1992 BOOLEAN DownArrow;
1993 EFI_STATUS Status;
1994 EFI_INPUT_KEY Key;
1995 LIST_ENTRY *Link;
1996 LIST_ENTRY *NewPos;
1997 LIST_ENTRY *TopOfScreen;
1998 LIST_ENTRY *SavedListEntry;
1999 UI_MENU_OPTION *MenuOption;
2000 UI_MENU_OPTION *NextMenuOption;
2001 UI_MENU_OPTION *SavedMenuOption;
2002 UI_MENU_OPTION *PreviousMenuOption;
2003 UI_CONTROL_FLAG ControlFlag;
2004 UI_SCREEN_OPERATION ScreenOperation;
2005 UINT16 DefaultId;
2006 FORM_DISPLAY_ENGINE_STATEMENT *Statement;
2007 BROWSER_HOT_KEY *HotKey;
2008 UINTN HelpPageIndex;
2009 UINTN HelpPageCount;
2010 UINTN RowCount;
2011 UINTN HelpLine;
2012 UINTN HelpHeaderLine;
2013 UINTN HelpBottomLine;
2014 BOOLEAN MultiHelpPage;
2015 UINT16 EachLineWidth;
2016 UINT16 HeaderLineWidth;
2017 UINT16 BottomLineWidth;
2018 EFI_STRING_ID HelpInfo;
2019 UI_EVENT_TYPE EventType;
2020 FORM_DISPLAY_ENGINE_STATEMENT *InitialHighlight;
2021 BOOLEAN SkipHighLight;
2022
2023 EventType = UIEventNone;
2024 Status = EFI_SUCCESS;
2025 HelpString = NULL;
2026 HelpHeaderString = NULL;
2027 HelpBottomString = NULL;
2028 OptionString = NULL;
2029 ScreenOperation = UiNoOperation;
2030 NewLine = TRUE;
2031 DefaultId = 0;
2032 HelpPageCount = 0;
2033 HelpLine = 0;
2034 RowCount = 0;
2035 HelpBottomLine = 0;
2036 HelpHeaderLine = 0;
2037 HelpPageIndex = 0;
2038 MultiHelpPage = FALSE;
2039 EachLineWidth = 0;
2040 HeaderLineWidth = 0;
2041 BottomLineWidth = 0;
2042 OutputString = NULL;
2043 UpArrow = FALSE;
2044 DownArrow = FALSE;
2045 SkipValue = 0;
2046 SkipHighLight = FALSE;
2047
2048 NextMenuOption = NULL;
2049 PreviousMenuOption = NULL;
2050 SavedMenuOption = NULL;
2051 HotKey = NULL;
2052 Repaint = TRUE;
2053 MenuOption = NULL;
2054 gModalSkipColumn = (CHAR16) (gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn) / 6;
2055 InitialHighlight = gFormData->HighLightedStatement;
2056
2057 ZeroMem (&Key, sizeof (EFI_INPUT_KEY));
2058
2059 //
2060 // Left right
2061 // |<-.->|<-.........->|<- .........->|<-...........->|
2062 // Skip Prompt Option Help
2063 //
2064 Width = (CHAR16) ((gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn) / 3);
2065 gOptionBlockWidth = Width + 1;
2066 gHelpBlockWidth = (CHAR16) (Width - LEFT_SKIPPED_COLUMNS);
2067 gPromptBlockWidth = (CHAR16) (gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 * Width - 1);
2068
2069 TopRow = gStatementDimensions.TopRow + SCROLL_ARROW_HEIGHT;
2070 BottomRow = gStatementDimensions.BottomRow - SCROLL_ARROW_HEIGHT - 1;
2071
2072 Row = TopRow;
2073 if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2074 Col = gStatementDimensions.LeftColumn + LEFT_SKIPPED_COLUMNS + gModalSkipColumn;
2075 } else {
2076 Col = gStatementDimensions.LeftColumn + LEFT_SKIPPED_COLUMNS;
2077 }
2078
2079 FindTopMenu(FormData, &TopOfScreen, &NewPos, &SkipValue);
2080
2081 gST->ConOut->EnableCursor (gST->ConOut, FALSE);
2082
2083 ControlFlag = CfInitialization;
2084 while (TRUE) {
2085 switch (ControlFlag) {
2086 case CfInitialization:
2087 if ((gOldFormEntry.HiiHandle != FormData->HiiHandle) ||
2088 (!CompareGuid (&gOldFormEntry.FormSetGuid, &FormData->FormSetGuid))) {
2089 //
2090 // Clear Statement range if different formset is painted.
2091 //
2092 ClearLines (
2093 gStatementDimensions.LeftColumn,
2094 gStatementDimensions.RightColumn,
2095 TopRow - SCROLL_ARROW_HEIGHT,
2096 BottomRow + SCROLL_ARROW_HEIGHT,
2097 GetFieldTextColor ()
2098 );
2099
2100 }
2101 ControlFlag = CfRepaint;
2102 break;
2103
2104 case CfRepaint:
2105 ControlFlag = CfRefreshHighLight;
2106
2107 if (Repaint) {
2108 //
2109 // Display menu
2110 //
2111 DownArrow = FALSE;
2112 UpArrow = FALSE;
2113 Row = TopRow;
2114
2115 gST->ConOut->SetAttribute (gST->ConOut, GetFieldTextColor ());
2116
2117 //
2118 // 1. Check whether need to print the arrow up.
2119 //
2120 if (!ValueIsScroll (TRUE, TopOfScreen)) {
2121 UpArrow = TRUE;
2122 }
2123
2124 if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2125 PrintStringAtWithWidth(gStatementDimensions.LeftColumn + gModalSkipColumn, TopRow - 1, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 * gModalSkipColumn);
2126 } else {
2127 PrintStringAtWithWidth(gStatementDimensions.LeftColumn, TopRow - 1, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn);
2128 }
2129 if (UpArrow) {
2130 gST->ConOut->SetAttribute (gST->ConOut, GetArrowColor ());
2131 PrintCharAt (
2132 gStatementDimensions.LeftColumn + gPromptBlockWidth + gOptionBlockWidth + 1,
2133 TopRow - SCROLL_ARROW_HEIGHT,
2134 ARROW_UP
2135 );
2136 gST->ConOut->SetAttribute (gST->ConOut, GetFieldTextColor ());
2137 }
2138
2139 //
2140 // 2.Paint the menu.
2141 //
2142 for (Link = TopOfScreen; Link != &gMenuOption; Link = Link->ForwardLink) {
2143 MenuOption = MENU_OPTION_FROM_LINK (Link);
2144 MenuOption->Row = Row;
2145 MenuOption->Col = Col;
2146 if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2147 MenuOption->OptCol = gStatementDimensions.LeftColumn + LEFT_SKIPPED_COLUMNS + gPromptBlockWidth + gModalSkipColumn;
2148 } else {
2149 MenuOption->OptCol = gStatementDimensions.LeftColumn + LEFT_SKIPPED_COLUMNS + gPromptBlockWidth;
2150 }
2151
2152 if (MenuOption->NestInStatement) {
2153 MenuOption->Col += SUBTITLE_INDENT;
2154 }
2155
2156 //
2157 // Save the highlight menu, will be used in CfRefreshHighLight case.
2158 //
2159 if (Link == NewPos) {
2160 SavedMenuOption = MenuOption;
2161 SkipHighLight = TRUE;
2162 }
2163
2164 if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2165 Status = DisplayOneMenu (MenuOption,
2166 MenuOption->Col - gStatementDimensions.LeftColumn,
2167 gStatementDimensions.LeftColumn + gModalSkipColumn,
2168 Link == TopOfScreen ? SkipValue : 0,
2169 BottomRow,
2170 (BOOLEAN) ((Link == NewPos) && IsSelectable(MenuOption))
2171 );
2172 } else {
2173 Status = DisplayOneMenu (MenuOption,
2174 MenuOption->Col - gStatementDimensions.LeftColumn,
2175 gStatementDimensions.LeftColumn,
2176 Link == TopOfScreen ? SkipValue : 0,
2177 BottomRow,
2178 (BOOLEAN) ((Link == NewPos) && IsSelectable(MenuOption))
2179 );
2180 }
2181
2182 if (EFI_ERROR (Status)) {
2183 return Status;
2184 }
2185 //
2186 // 3. Update the row info which will be used by next menu.
2187 //
2188 if (Link == TopOfScreen) {
2189 Row += MenuOption->Skip - SkipValue;
2190 } else {
2191 Row += MenuOption->Skip;
2192 }
2193
2194 if (Row > BottomRow) {
2195 if (!ValueIsScroll (FALSE, Link)) {
2196 DownArrow = TRUE;
2197 }
2198
2199 Row = BottomRow + 1;
2200 break;
2201 }
2202 }
2203
2204 //
2205 // 3. Menus in this form may not cover all form, clean the remain field.
2206 //
2207 while (Row <= BottomRow) {
2208 if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2209 PrintStringAtWithWidth(gStatementDimensions.LeftColumn + gModalSkipColumn, Row++, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 * gModalSkipColumn);
2210 } else {
2211 PrintStringAtWithWidth(gStatementDimensions.LeftColumn, Row++, L"", gStatementDimensions.RightColumn - gHelpBlockWidth - gStatementDimensions.LeftColumn);
2212 }
2213 }
2214
2215 //
2216 // 4. Print the down arrow row.
2217 //
2218 if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2219 PrintStringAtWithWidth(gStatementDimensions.LeftColumn + gModalSkipColumn, BottomRow + 1, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn - 2 * + gModalSkipColumn);
2220 } else {
2221 PrintStringAtWithWidth(gStatementDimensions.LeftColumn, BottomRow + 1, L"", gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn);
2222 }
2223 if (DownArrow) {
2224 gST->ConOut->SetAttribute (gST->ConOut, GetArrowColor ());
2225 PrintCharAt (
2226 gStatementDimensions.LeftColumn + gPromptBlockWidth + gOptionBlockWidth + 1,
2227 BottomRow + SCROLL_ARROW_HEIGHT,
2228 ARROW_DOWN
2229 );
2230 gST->ConOut->SetAttribute (gST->ConOut, GetFieldTextColor ());
2231 }
2232
2233 MenuOption = NULL;
2234 }
2235 break;
2236
2237 case CfRefreshHighLight:
2238
2239 //
2240 // MenuOption: Last menu option that need to remove hilight
2241 // MenuOption is set to NULL in Repaint
2242 // NewPos: Current menu option that need to hilight
2243 //
2244 ControlFlag = CfUpdateHelpString;
2245
2246 if (SkipHighLight) {
2247 MenuOption = SavedMenuOption;
2248 SkipHighLight = FALSE;
2249 UpdateHighlightMenuInfo (MenuOption);
2250 break;
2251 }
2252
2253 if (IsListEmpty (&gMenuOption)) {
2254 //
2255 // No menu option, just update the hotkey filed.
2256 //
2257 RefreshKeyHelp(gFormData, NULL, FALSE);
2258 break;
2259 }
2260
2261 if (MenuOption != NULL && TopOfScreen == &MenuOption->Link) {
2262 Temp = SkipValue;
2263 } else {
2264 Temp = 0;
2265 }
2266 if (NewPos == TopOfScreen) {
2267 Temp2 = SkipValue;
2268 } else {
2269 Temp2 = 0;
2270 }
2271
2272 if (NewPos != NULL && (MenuOption == NULL || NewPos != &MenuOption->Link)) {
2273 if (MenuOption != NULL) {
2274 //
2275 // Remove the old highlight menu.
2276 //
2277 Status = DisplayOneMenu (MenuOption,
2278 MenuOption->Col - gStatementDimensions.LeftColumn,
2279 gStatementDimensions.LeftColumn,
2280 Temp,
2281 BottomRow,
2282 FALSE
2283 );
2284 }
2285
2286 //
2287 // This is the current selected statement
2288 //
2289 MenuOption = MENU_OPTION_FROM_LINK (NewPos);
2290 Statement = MenuOption->ThisTag;
2291
2292 UpdateHighlightMenuInfo (MenuOption);
2293
2294 if (!IsSelectable (MenuOption)) {
2295 break;
2296 }
2297
2298 Status = DisplayOneMenu (MenuOption,
2299 MenuOption->Col - gStatementDimensions.LeftColumn,
2300 gStatementDimensions.LeftColumn,
2301 Temp2,
2302 BottomRow,
2303 TRUE
2304 );
2305 }
2306 break;
2307
2308 case CfUpdateHelpString:
2309 ControlFlag = CfPrepareToReadKey;
2310 if ((FormData->Attribute & HII_DISPLAY_MODAL) != 0) {
2311 break;
2312 }
2313
2314 //
2315 // NewLine means only update highlight menu (remove old highlight and highlith
2316 // the new one), not need to full repain the form.
2317 //
2318 if (Repaint || NewLine) {
2319 if (IsListEmpty (&gMenuOption)) {
2320 //
2321 // Don't print anything if no mwnu option.
2322 //
2323 StringPtr = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2324 } else {
2325 //
2326 // Don't print anything if it is a NULL help token
2327 //
2328 ASSERT(MenuOption != NULL);
2329 HelpInfo = ((EFI_IFR_STATEMENT_HEADER *) ((CHAR8 *)MenuOption->ThisTag->OpCode + sizeof (EFI_IFR_OP_HEADER)))->Help;
2330 if (HelpInfo == 0 || !IsSelectable (MenuOption)) {
2331 StringPtr = GetToken (STRING_TOKEN (EMPTY_STRING), gHiiHandle);
2332 } else {
2333 StringPtr = GetToken (HelpInfo, gFormData->HiiHandle);
2334 }
2335 }
2336
2337 RowCount = BottomRow - TopRow + 1;
2338 HelpPageIndex = 0;
2339 //
2340 // 1.Calculate how many line the help string need to print.
2341 //
2342 if (HelpString != NULL) {
2343 FreePool (HelpString);
2344 HelpString = NULL;
2345 }
2346 HelpLine = ProcessHelpString (StringPtr, &HelpString, &EachLineWidth, RowCount);
2347 FreePool (StringPtr);
2348
2349 if (HelpLine > RowCount) {
2350 MultiHelpPage = TRUE;
2351 StringPtr = GetToken (STRING_TOKEN(ADJUST_HELP_PAGE_UP), gHiiHandle);
2352 if (HelpHeaderString != NULL) {
2353 FreePool (HelpHeaderString);
2354 HelpHeaderString = NULL;
2355 }
2356 HelpHeaderLine = ProcessHelpString (StringPtr, &HelpHeaderString, &HeaderLineWidth, 0);
2357 FreePool (StringPtr);
2358 StringPtr = GetToken (STRING_TOKEN(ADJUST_HELP_PAGE_DOWN), gHiiHandle);
2359 if (HelpBottomString != NULL) {
2360 FreePool (HelpBottomString);
2361 HelpBottomString = NULL;
2362 }
2363 HelpBottomLine = ProcessHelpString (StringPtr, &HelpBottomString, &BottomLineWidth, 0);
2364 FreePool (StringPtr);
2365 //
2366 // Calculate the help page count.
2367 //
2368 if (HelpLine > 2 * RowCount - 2) {
2369 HelpPageCount = (HelpLine - RowCount + 1) / (RowCount - 2) + 1;
2370 if ((HelpLine - RowCount + 1) % (RowCount - 2) > 1) {
2371 HelpPageCount += 1;
2372 }
2373 } else {
2374 HelpPageCount = 2;
2375 }
2376 } else {
2377 MultiHelpPage = FALSE;
2378 }
2379 }
2380
2381 //
2382 // Check whether need to show the 'More(U/u)' at the begin.
2383 // Base on current direct info, here shows aligned to the right side of the column.
2384 // If the direction is multi line and aligned to right side may have problem, so
2385 // add ASSERT code here.
2386 //
2387 if (HelpPageIndex > 0) {
2388 gST->ConOut->SetAttribute (gST->ConOut, GetInfoTextColor ());
2389 for (Index = 0; Index < HelpHeaderLine; Index++) {
2390 ASSERT (HelpHeaderLine == 1);
2391 ASSERT (GetStringWidth (HelpHeaderString) / 2 < (UINTN) (gHelpBlockWidth - 1));
2392 PrintStringAtWithWidth (
2393 gStatementDimensions.RightColumn - gHelpBlockWidth,
2394 Index + TopRow,
2395 gEmptyString,
2396 gHelpBlockWidth
2397 );
2398 PrintStringAt (
2399 gStatementDimensions.RightColumn - GetStringWidth (HelpHeaderString) / 2 - 1,
2400 Index + TopRow,
2401 &HelpHeaderString[Index * HeaderLineWidth]
2402 );
2403 }
2404 }
2405
2406 gST->ConOut->SetAttribute (gST->ConOut, GetHelpTextColor ());
2407 //
2408 // Print the help string info.
2409 //
2410 if (!MultiHelpPage) {
2411 for (Index = 0; Index < HelpLine; Index++) {
2412 PrintStringAtWithWidth (
2413 gStatementDimensions.RightColumn - gHelpBlockWidth,
2414 Index + TopRow,
2415 &HelpString[Index * EachLineWidth],
2416 gHelpBlockWidth
2417 );
2418 }
2419 for (; Index < RowCount; Index ++) {
2420 PrintStringAtWithWidth (
2421 gStatementDimensions.RightColumn - gHelpBlockWidth,
2422 Index + TopRow,
2423 gEmptyString,
2424 gHelpBlockWidth
2425 );
2426 }
2427 gST->ConOut->SetCursorPosition(gST->ConOut, gStatementDimensions.RightColumn-1, BottomRow);
2428 } else {
2429 if (HelpPageIndex == 0) {
2430 for (Index = 0; Index < RowCount - HelpBottomLine; Index++) {
2431 PrintStringAtWithWidth (
2432 gStatementDimensions.RightColumn - gHelpBlockWidth,
2433 Index + TopRow,
2434 &HelpString[Index * EachLineWidth],
2435 gHelpBlockWidth
2436 );
2437 }
2438 } else {
2439 for (Index = 0; (Index < RowCount - HelpBottomLine - HelpHeaderLine) &&
2440 (Index + HelpPageIndex * (RowCount - 2) + 1 < HelpLine); Index++) {
2441 PrintStringAtWithWidth (
2442 gStatementDimensions.RightColumn - gHelpBlockWidth,
2443 Index + TopRow + HelpHeaderLine,
2444 &HelpString[(Index + HelpPageIndex * (RowCount - 2) + 1)* EachLineWidth],
2445 gHelpBlockWidth
2446 );
2447 }
2448 if (HelpPageIndex == HelpPageCount - 1) {
2449 for (; Index < RowCount - HelpHeaderLine; Index ++) {
2450 PrintStringAtWithWidth (
2451 gStatementDimensions.RightColumn - gHelpBlockWidth,
2452 Index + TopRow + HelpHeaderLine,
2453 gEmptyString,
2454 gHelpBlockWidth
2455 );
2456 }
2457 gST->ConOut->SetCursorPosition(gST->ConOut, gStatementDimensions.RightColumn-1, BottomRow);
2458 }
2459 }
2460 }
2461
2462 //
2463 // Check whether need to print the 'More(D/d)' at the bottom.
2464 // Base on current direct info, here shows aligned to the right side of the column.
2465 // If the direction is multi line and aligned to right side may have problem, so
2466 // add ASSERT code here.
2467 //
2468 if (HelpPageIndex < HelpPageCount - 1 && MultiHelpPage) {
2469 gST->ConOut->SetAttribute (gST->ConOut, GetInfoTextColor ());
2470 for (Index = 0; Index < HelpBottomLine; Index++) {
2471 ASSERT (HelpBottomLine == 1);
2472 ASSERT (GetStringWidth (HelpBottomString) / 2 < (UINTN) (gHelpBlockWidth - 1));
2473 PrintStringAtWithWidth (
2474 gStatementDimensions.RightColumn - gHelpBlockWidth,
2475 BottomRow + Index - HelpBottomLine + 1,
2476 gEmptyString,
2477 gHelpBlockWidth
2478 );
2479 PrintStringAt (
2480 gStatementDimensions.RightColumn - GetStringWidth (HelpBottomString) / 2 - 1,
2481 BottomRow + Index - HelpBottomLine + 1,
2482 &HelpBottomString[Index * BottomLineWidth]
2483 );
2484 }
2485 }
2486 //
2487 // Reset this flag every time we finish using it.
2488 //
2489 Repaint = FALSE;
2490 NewLine = FALSE;
2491 break;
2492
2493 case CfPrepareToReadKey:
2494 ControlFlag = CfReadKey;
2495 ScreenOperation = UiNoOperation;
2496 break;
2497
2498 case CfReadKey:
2499 ControlFlag = CfScreenOperation;
2500
2501 //
2502 // Wait for user's selection
2503 //
2504 while (TRUE) {
2505 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
2506 if (!EFI_ERROR (Status)) {
2507 EventType = UIEventKey;
2508 break;
2509 }
2510
2511 //
2512 // If we encounter error, continue to read another key in.
2513 //
2514 if (Status != EFI_NOT_READY) {
2515 continue;
2516 }
2517
2518 EventType = UiWaitForEvent(gST->ConIn->WaitForKey);
2519 if (EventType == UIEventKey) {
2520 gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
2521 }
2522 break;
2523 }
2524
2525 if (EventType == UIEventDriver) {
2526 gUserInput->Action = BROWSER_ACTION_NONE;
2527 ControlFlag = CfExit;
2528 break;
2529 }
2530
2531 if (EventType == UIEventTimeOut) {
2532 gUserInput->Action = BROWSER_ACTION_FORM_EXIT;
2533 ControlFlag = CfExit;
2534 break;
2535 }
2536
2537 switch (Key.UnicodeChar) {
2538 case CHAR_CARRIAGE_RETURN:
2539 if(MenuOption == NULL || MenuOption->GrayOut || MenuOption->ReadOnly) {
2540 ControlFlag = CfReadKey;
2541 break;
2542 }
2543
2544 ScreenOperation = UiSelect;
2545 gDirection = 0;
2546 break;
2547
2548 //
2549 // We will push the adjustment of these numeric values directly to the input handler
2550 // NOTE: we won't handle manual input numeric
2551 //
2552 case '+':
2553 case '-':
2554 //
2555 // If the screen has no menu items, and the user didn't select UiReset
2556 // ignore the selection and go back to reading keys.
2557 //
2558 ASSERT(MenuOption != NULL);
2559 if(IsListEmpty (&gMenuOption) || MenuOption->GrayOut || MenuOption->ReadOnly) {
2560 ControlFlag = CfReadKey;
2561 break;
2562 }
2563
2564 Statement = MenuOption->ThisTag;
2565 if ((Statement->OpCode->OpCode == EFI_IFR_DATE_OP)
2566 || (Statement->OpCode->OpCode == EFI_IFR_TIME_OP)
2567 || ((Statement->OpCode->OpCode == EFI_IFR_NUMERIC_OP) && (GetFieldFromNum(Statement->OpCode) != 0))
2568 ){
2569 if (Key.UnicodeChar == '+') {
2570 gDirection = SCAN_RIGHT;
2571 } else {
2572 gDirection = SCAN_LEFT;
2573 }
2574
2575 Status = ProcessOptions (MenuOption, TRUE, &OptionString, TRUE);
2576 if (OptionString != NULL) {
2577 FreePool (OptionString);
2578 }
2579 if (EFI_ERROR (Status)) {
2580 //
2581 // Repaint to clear possible error prompt pop-up
2582 //
2583 Repaint = TRUE;
2584 NewLine = TRUE;
2585 } else {
2586 ControlFlag = CfExit;
2587 }
2588 }
2589 break;
2590
2591 case '^':
2592 ScreenOperation = UiUp;
2593 break;
2594
2595 case 'V':
2596 case 'v':
2597 ScreenOperation = UiDown;
2598 break;
2599
2600 case ' ':
2601 if(IsListEmpty (&gMenuOption)) {
2602 ControlFlag = CfReadKey;
2603 break;
2604 }
2605
2606 ASSERT(MenuOption != NULL);
2607 if (MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_CHECKBOX_OP && !MenuOption->GrayOut && !MenuOption->ReadOnly) {
2608 ScreenOperation = UiSelect;
2609 }
2610 break;
2611
2612 case 'D':
2613 case 'd':
2614 if (!MultiHelpPage) {
2615 ControlFlag = CfReadKey;
2616 break;
2617 }
2618 ControlFlag = CfUpdateHelpString;
2619 HelpPageIndex = HelpPageIndex < HelpPageCount - 1 ? HelpPageIndex + 1 : HelpPageCount - 1;
2620 break;
2621
2622 case 'U':
2623 case 'u':
2624 if (!MultiHelpPage) {
2625 ControlFlag = CfReadKey;
2626 break;
2627 }
2628 ControlFlag = CfUpdateHelpString;
2629 HelpPageIndex = HelpPageIndex > 0 ? HelpPageIndex - 1 : 0;
2630 break;
2631
2632 case CHAR_NULL:
2633 for (Index = 0; Index < mScanCodeNumber; Index++) {
2634 if (Key.ScanCode == gScanCodeToOperation[Index].ScanCode) {
2635 ScreenOperation = gScanCodeToOperation[Index].ScreenOperation;
2636 break;
2637 }
2638 }
2639
2640 if (((FormData->Attribute & HII_DISPLAY_MODAL) != 0) && (Key.ScanCode == SCAN_ESC || Index == mScanCodeNumber)) {
2641 //
2642 // ModalForm has no ESC key and Hot Key.
2643 //
2644 ControlFlag = CfReadKey;
2645 } else if (Index == mScanCodeNumber) {
2646 //
2647 // Check whether Key matches the registered hot key.
2648 //
2649 HotKey = NULL;
2650 HotKey = GetHotKeyFromRegisterList (&Key);
2651 if (HotKey != NULL) {
2652 ScreenOperation = UiHotKey;
2653 }
2654 }
2655 break;
2656 }
2657 break;
2658
2659 case CfScreenOperation:
2660 if ((ScreenOperation != UiReset) && (ScreenOperation != UiHotKey)) {
2661 //
2662 // If the screen has no menu items, and the user didn't select UiReset or UiHotKey
2663 // ignore the selection and go back to reading keys.
2664 //
2665 if (IsListEmpty (&gMenuOption)) {
2666 ControlFlag = CfReadKey;
2667 break;
2668 }
2669 }
2670
2671 for (Index = 0;
2672 Index < sizeof (gScreenOperationToControlFlag) / sizeof (gScreenOperationToControlFlag[0]);
2673 Index++
2674 ) {
2675 if (ScreenOperation == gScreenOperationToControlFlag[Index].ScreenOperation) {
2676 ControlFlag = gScreenOperationToControlFlag[Index].ControlFlag;
2677 break;
2678 }
2679 }
2680 break;
2681
2682 case CfUiSelect:
2683 ControlFlag = CfRepaint;
2684
2685 ASSERT(MenuOption != NULL);
2686 Statement = MenuOption->ThisTag;
2687 if (Statement->OpCode->OpCode == EFI_IFR_TEXT_OP) {
2688 break;
2689 }
2690
2691 switch (Statement->OpCode->OpCode) {
2692 case EFI_IFR_REF_OP:
2693 case EFI_IFR_ACTION_OP:
2694 case EFI_IFR_RESET_BUTTON_OP:
2695 ControlFlag = CfExit;
2696 break;
2697
2698 default:
2699 //
2700 // Editable Questions: oneof, ordered list, checkbox, numeric, string, password
2701 //
2702 RefreshKeyHelp (gFormData, Statement, TRUE);
2703 Status = ProcessOptions (MenuOption, TRUE, &OptionString, TRUE);
2704
2705 if (OptionString != NULL) {
2706 FreePool (OptionString);
2707 }
2708
2709 if (EFI_ERROR (Status)) {
2710 Repaint = TRUE;
2711 NewLine = TRUE;
2712 RefreshKeyHelp (gFormData, Statement, FALSE);
2713 break;
2714 } else {
2715 ControlFlag = CfExit;
2716 break;
2717 }
2718 }
2719 break;
2720
2721 case CfUiReset:
2722 //
2723 // We come here when someone press ESC
2724 // If the policy is not exit front page when user press ESC, process here.
2725 //
2726 if (!FormExitPolicy()) {
2727 Repaint = TRUE;
2728 NewLine = TRUE;
2729 ControlFlag = CfRepaint;
2730 break;
2731 }
2732
2733 //
2734 // When user press ESC, it will try to show another menu, should clean the gSequence info.
2735 //
2736 if (gSequence != 0) {
2737 gSequence = 0;
2738 }
2739
2740 gUserInput->Action = BROWSER_ACTION_FORM_EXIT;
2741 ControlFlag = CfExit;
2742 break;
2743
2744 case CfUiHotKey:
2745 ControlFlag = CfRepaint;
2746
2747 ASSERT (HotKey != NULL);
2748 gUserInput->Action = HotKey->Action;
2749 ControlFlag = CfExit;
2750 break;
2751
2752 case CfUiLeft:
2753 ControlFlag = CfRepaint;
2754 ASSERT(MenuOption != NULL);
2755 if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_DATE_OP) || (MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_TIME_OP)) {
2756 if (MenuOption->Sequence != 0) {
2757 //
2758 // In the middle or tail of the Date/Time op-code set, go left.
2759 //
2760 ASSERT(NewPos != NULL);
2761 NewPos = NewPos->BackLink;
2762 }
2763 }
2764 break;
2765
2766 case CfUiRight:
2767 ControlFlag = CfRepaint;
2768 ASSERT(MenuOption != NULL);
2769 if ((MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_DATE_OP) || (MenuOption->ThisTag->OpCode->OpCode == EFI_IFR_TIME_OP)) {
2770 if (MenuOption->Sequence != 2) {
2771 //
2772 // In the middle or tail of the Date/Time op-code set, go left.
2773 //
2774 ASSERT(NewPos != NULL);
2775 NewPos = NewPos->ForwardLink;
2776 }
2777 }
2778 break;
2779
2780 case CfUiUp:
2781 ControlFlag = CfRepaint;
2782 NewLine = TRUE;
2783
2784 SavedListEntry = NewPos;
2785
2786 ASSERT(NewPos != NULL);
2787 //
2788 // Adjust Date/Time position before we advance forward.
2789 //
2790 AdjustDateAndTimePosition (TRUE, &NewPos);
2791
2792 MenuOption = MENU_OPTION_FROM_LINK (NewPos);
2793 ASSERT (MenuOption != NULL);
2794
2795 NewPos = NewPos->BackLink;
2796 //
2797 // Find next selectable menu or the first menu beyond current form.
2798 //
2799 Difference = MoveToNextStatement (TRUE, &NewPos, MenuOption->Row - TopRow, FALSE);
2800 if (Difference < 0) {
2801 //
2802 // We hit the begining MenuOption that can be focused
2803 // so we simply scroll to the top.
2804 //
2805 Repaint = TRUE;
2806 if (TopOfScreen != gMenuOption.ForwardLink || SkipValue != 0) {
2807 TopOfScreen = gMenuOption.ForwardLink;
2808 NewPos = SavedListEntry;
2809 SkipValue = 0;
2810 } else {
2811 //
2812 // Scroll up to the last page when we have arrived at top page.
2813 //
2814 TopOfScreen = FindTopOfScreenMenu (gMenuOption.BackLink, BottomRow - TopRow, &SkipValue);
2815 NewPos = gMenuOption.BackLink;
2816 MoveToNextStatement (TRUE, &NewPos, BottomRow - TopRow, TRUE);
2817 }
2818 } else {
2819 NextMenuOption = MENU_OPTION_FROM_LINK (NewPos);
2820
2821 if (MenuOption->Row < TopRow + Difference + NextMenuOption->Skip) {
2822 //
2823 // Previous focus MenuOption is above the TopOfScreen, so we need to scroll
2824 //
2825 TopOfScreen = NewPos;
2826 Repaint = TRUE;
2827 SkipValue = 0;
2828 }
2829
2830 //
2831 // Check whether new highlight menu is selectable, if not, keep highlight on the old one.
2832 //
2833 // BottomRow - TopRow + 1 means the total rows current forms supported.
2834 // Difference + NextMenuOption->Skip + 1 means the distance between last highlight menu
2835 // and new top menu. New top menu will all shows in next form, but last highlight menu
2836 // may only shows 1 line. + 1 at right part means at least need to keep 1 line for the
2837 // last highlight menu.
2838 //
2839 if (!IsSelectable(NextMenuOption) && IsSelectable(MenuOption) &&
2840 (BottomRow - TopRow + 1 >= Difference + NextMenuOption->Skip + 1)) {
2841 NewPos = SavedListEntry;
2842 }
2843 }
2844
2845 UpdateStatusBar (INPUT_ERROR, FALSE);
2846
2847 //
2848 // If we encounter a Date/Time op-code set, rewind to the first op-code of the set.
2849 //
2850 AdjustDateAndTimePosition (TRUE, &TopOfScreen);
2851 AdjustDateAndTimePosition (TRUE, &NewPos);
2852 break;
2853
2854 case CfUiPageUp:
2855 //
2856 // SkipValue means lines is skipped when show the top menu option.
2857 //
2858 ControlFlag = CfRepaint;
2859 NewLine = TRUE;
2860 Repaint = TRUE;
2861
2862 Link = TopOfScreen;
2863 //
2864 // First minus the menu of the top screen, it's value is SkipValue.
2865 //
2866 if (SkipValue >= BottomRow - TopRow + 1) {
2867 //
2868 // SkipValue > (BottomRow - TopRow + 1) means current menu has more than one
2869 // form of options to be show, so just update the SkipValue to show the next
2870 // parts of options.
2871 //
2872 SkipValue -= BottomRow - TopRow + 1;
2873 NewPos = TopOfScreen;
2874 break;
2875 } else {
2876 Index = (BottomRow + 1) - SkipValue - TopRow;
2877 }
2878
2879 TopOfScreen = FindTopOfScreenMenu(TopOfScreen, Index, &SkipValue);
2880 NewPos = TopOfScreen;
2881 MoveToNextStatement (FALSE, &NewPos, BottomRow - TopRow, FALSE);
2882
2883 UpdateStatusBar (INPUT_ERROR, FALSE);
2884
2885 //
2886 // If we encounter a Date/Time op-code set, rewind to the first op-code of the set.
2887 // Don't do this when we are already in the first page.
2888 //
2889 AdjustDateAndTimePosition (TRUE, &TopOfScreen);
2890 AdjustDateAndTimePosition (TRUE, &NewPos);
2891 break;
2892
2893 case CfUiPageDown:
2894 //
2895 // SkipValue means lines is skipped when show the top menu option.
2896 //
2897 ControlFlag = CfRepaint;
2898 NewLine = TRUE;
2899 Repaint = TRUE;
2900
2901 Link = TopOfScreen;
2902 NextMenuOption = MENU_OPTION_FROM_LINK (Link);
2903 Index = TopRow + NextMenuOption->Skip - SkipValue;
2904 //
2905 // Count to the menu option which will show at the top of the next form.
2906 //
2907 while ((Index <= BottomRow + 1) && (Link->ForwardLink != &gMenuOption)) {
2908 Link = Link->ForwardLink;
2909 NextMenuOption = MENU_OPTION_FROM_LINK (Link);
2910 Index = Index + NextMenuOption->Skip;
2911 }
2912
2913 if ((Link->ForwardLink == &gMenuOption) && (Index <= BottomRow + 1)) {
2914 //
2915 // Highlight on the last menu which can be highlight.
2916 //
2917 Repaint = FALSE;
2918 MoveToNextStatement (TRUE, &Link, Index - TopRow, TRUE);
2919 } else {
2920 //
2921 // Calculate the skip line for top of screen menu.
2922 //
2923 if (Link == TopOfScreen) {
2924 //
2925 // The top of screen menu option occupies the entire form.
2926 //
2927 SkipValue += BottomRow - TopRow + 1;
2928 } else {
2929 SkipValue = NextMenuOption->Skip - (Index - (BottomRow + 1));
2930 }
2931 TopOfScreen = Link;
2932 MenuOption = NULL;
2933 //
2934 // Move to the Next selectable menu.
2935 //
2936 MoveToNextStatement (FALSE, &Link, BottomRow - TopRow, TRUE);
2937 }
2938
2939 //
2940 // Save the menu as the next highlight menu.
2941 //
2942 NewPos = Link;
2943
2944 UpdateStatusBar (INPUT_ERROR, FALSE);
2945
2946 //
2947 // If we encounter a Date/Time op-code set, rewind to the first op-code of the set.
2948 // Don't do this when we are already in the last page.
2949 //
2950 AdjustDateAndTimePosition (TRUE, &TopOfScreen);
2951 AdjustDateAndTimePosition (TRUE, &NewPos);
2952 break;
2953
2954 case CfUiDown:
2955 //
2956 // SkipValue means lines is skipped when show the top menu option.
2957 // NewPos points to the menu which is highlighted now.
2958 //
2959 ControlFlag = CfRepaint;
2960 NewLine = TRUE;
2961
2962 if (NewPos == TopOfScreen) {
2963 Temp2 = SkipValue;
2964 } else {
2965 Temp2 = 0;
2966 }
2967
2968 SavedListEntry = NewPos;
2969 //
2970 // Since the behavior of hitting the down arrow on a Date/Time op-code is intended
2971 // to be one that progresses to the next set of op-codes, we need to advance to the last
2972 // Date/Time op-code and leave the remaining logic in UiDown intact so the appropriate
2973 // checking can be done. The only other logic we need to introduce is that if a Date/Time
2974 // op-code is the last entry in the menu, we need to rewind back to the first op-code of
2975 // the Date/Time op-code.
2976 //
2977 AdjustDateAndTimePosition (FALSE, &NewPos);
2978
2979 MenuOption = MENU_OPTION_FROM_LINK (NewPos);
2980 NewPos = NewPos->ForwardLink;
2981 //
2982 // Find the next selectable menu.
2983 //
2984 if (MenuOption->Row + MenuOption->Skip - Temp2 > BottomRow + 1) {
2985 if (gMenuOption.ForwardLink == NewPos || &gMenuOption == NewPos) {
2986 Difference = -1;
2987 } else {
2988 Difference = 0;
2989 }
2990 } else {
2991 Difference = MoveToNextStatement (FALSE, &NewPos, BottomRow + 1 - (MenuOption->Row + MenuOption->Skip - Temp2), FALSE);
2992 }
2993 if (Difference < 0) {
2994 //
2995 // Scroll to the first page.
2996 //
2997 if (TopOfScreen != gMenuOption.ForwardLink || SkipValue != 0) {
2998 TopOfScreen = gMenuOption.ForwardLink;
2999 Repaint = TRUE;
3000 MenuOption = NULL;
3001 } else {
3002 MenuOption = MENU_OPTION_FROM_LINK (SavedListEntry);
3003 }
3004 NewPos = gMenuOption.ForwardLink;
3005 MoveToNextStatement (FALSE, &NewPos, BottomRow - TopRow, TRUE);
3006
3007 SkipValue = 0;
3008 //
3009 // If we are at the end of the list and sitting on a Date/Time op, rewind to the head.
3010 //
3011 AdjustDateAndTimePosition (TRUE, &TopOfScreen);
3012 AdjustDateAndTimePosition (TRUE, &NewPos);
3013 break;
3014 }
3015
3016 //
3017 // Get next selected menu info.
3018 //
3019 AdjustDateAndTimePosition (FALSE, &NewPos);
3020 NextMenuOption = MENU_OPTION_FROM_LINK (NewPos);
3021 if (NextMenuOption->Row == 0) {
3022 UpdateOptionSkipLines (NextMenuOption);
3023 }
3024
3025 //
3026 // Calculate new highlight menu end row.
3027 //
3028 Temp = (MenuOption->Row + MenuOption->Skip - Temp2) + Difference + NextMenuOption->Skip - 1;
3029 if (Temp > BottomRow) {
3030 //
3031 // Get the top screen menu info.
3032 //
3033 AdjustDateAndTimePosition (FALSE, &TopOfScreen);
3034 SavedMenuOption = MENU_OPTION_FROM_LINK (TopOfScreen);
3035
3036 //
3037 // Current Top screen menu occupy (SavedMenuOption->Skip - SkipValue) rows.
3038 // Full shows the new selected menu need to skip (Temp - BottomRow - 1) rows.
3039 //
3040 if ((Temp - BottomRow) >= (SavedMenuOption->Skip - SkipValue)) {
3041 //
3042 // Skip the top op-code
3043 //
3044 TopOfScreen = TopOfScreen->ForwardLink;
3045 DistanceValue = (Temp - BottomRow) - (SavedMenuOption->Skip - SkipValue);
3046
3047 SavedMenuOption = MENU_OPTION_FROM_LINK (TopOfScreen);
3048
3049 //
3050 // If we have a remainder, skip that many more op-codes until we drain the remainder
3051 // Special case is the selected highlight menu has more than one form of menus.
3052 //
3053 while (DistanceValue >= SavedMenuOption->Skip && TopOfScreen != NewPos) {
3054 //
3055 // Since the Difference is greater than or equal to this op-code's skip value, skip it
3056 //
3057 DistanceValue = DistanceValue - (INTN) SavedMenuOption->Skip;
3058 TopOfScreen = TopOfScreen->ForwardLink;
3059 SavedMenuOption = MENU_OPTION_FROM_LINK (TopOfScreen);
3060 }
3061 //
3062 // Since we will act on this op-code in the next routine, and increment the
3063 // SkipValue, set the skips to one less than what is required.
3064 //
3065 if (TopOfScreen != NewPos) {
3066 SkipValue = DistanceValue;
3067 } else {
3068 SkipValue = 0;
3069 }
3070 } else {
3071 //
3072 // Since we will act on this op-code in the next routine, and increment the
3073 // SkipValue, set the skips to one less than what is required.
3074 //
3075 SkipValue += Temp - BottomRow;
3076 }
3077 Repaint = TRUE;
3078 } else if (!IsSelectable (NextMenuOption)) {
3079 //
3080 // Continue to go down until scroll to next page or the selectable option is found.
3081 //
3082 ScreenOperation = UiDown;
3083 ControlFlag = CfScreenOperation;
3084 break;
3085 }
3086
3087 MenuOption = MENU_OPTION_FROM_LINK (SavedListEntry);
3088
3089 //
3090 // Check whether new highlight menu is selectable, if not, keep highlight on the old one.
3091 //
3092 // BottomRow - TopRow + 1 means the total rows current forms supported.
3093 // Difference + NextMenuOption->Skip + 1 means the distance between last highlight menu
3094 // and new top menu. New top menu will all shows in next form, but last highlight menu
3095 // may only shows 1 line. + 1 at right part means at least need to keep 1 line for the
3096 // last highlight menu.
3097 //
3098 if (!IsSelectable (NextMenuOption) && IsSelectable (MenuOption) &&
3099 (BottomRow - TopRow + 1 >= Difference + NextMenuOption->Skip + 1)) {
3100 NewPos = SavedListEntry;
3101 }
3102
3103 UpdateStatusBar (INPUT_ERROR, FALSE);
3104
3105 //
3106 // If we are at the end of the list and sitting on a Date/Time op, rewind to the head.
3107 //
3108 AdjustDateAndTimePosition (TRUE, &TopOfScreen);
3109 AdjustDateAndTimePosition (TRUE, &NewPos);
3110 break;
3111
3112 case CfUiNoOperation:
3113 ControlFlag = CfRepaint;
3114 break;
3115
3116 case CfExit:
3117 gST->ConOut->SetAttribute (gST->ConOut, EFI_TEXT_ATTR (EFI_LIGHTGRAY, EFI_BLACK));
3118 if (HelpString != NULL) {
3119 FreePool (HelpString);
3120 }
3121 if (HelpHeaderString != NULL) {
3122 FreePool (HelpHeaderString);
3123 }
3124 if (HelpBottomString != NULL) {
3125 FreePool (HelpBottomString);
3126 }
3127 return EFI_SUCCESS;
3128
3129 default:
3130 break;
3131 }
3132 }
3133 }
3134
3135 /**
3136
3137 Base on the browser status info to show an pop up message.
3138
3139 **/
3140 VOID
3141 BrowserStatusProcess (
3142 VOID
3143 )
3144 {
3145 CHAR16 *ErrorInfo;
3146 EFI_INPUT_KEY Key;
3147
3148 if (gFormData->BrowserStatus == BROWSER_SUCCESS) {
3149 return;
3150 }
3151
3152 if (gFormData->ErrorString != NULL) {
3153 ErrorInfo = gFormData->ErrorString;
3154 } else {
3155 switch (gFormData->BrowserStatus) {
3156 case BROWSER_SUBMIT_FAIL:
3157 ErrorInfo = gSaveFailed;
3158 break;
3159
3160 case BROWSER_NO_SUBMIT_IF:
3161 ErrorInfo = gNoSubmitIf;
3162 break;
3163
3164 case BROWSER_FORM_NOT_FOUND:
3165 ErrorInfo = gFormNotFound;
3166 break;
3167
3168 case BROWSER_FORM_SUPPRESS:
3169 ErrorInfo = gFormSuppress;
3170 break;
3171
3172 case BROWSER_PROTOCOL_NOT_FOUND:
3173 ErrorInfo = gProtocolNotFound;
3174 break;
3175
3176 default:
3177 ErrorInfo = gBrwoserError;
3178 break;
3179 }
3180 }
3181
3182 //
3183 // Error occur, prompt error message.
3184 //
3185 do {
3186 CreateDialog (&Key, gEmptyString, ErrorInfo, gPressEnter, gEmptyString, NULL);
3187 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
3188 }
3189
3190 /**
3191 Display one form, and return user input.
3192
3193 @param FormData Form Data to be shown.
3194 @param UserInputData User input data.
3195
3196 @retval EFI_SUCCESS 1.Form Data is shown, and user input is got.
3197 2.Error info has show and return.
3198 @retval EFI_INVALID_PARAMETER The input screen dimension is not valid
3199 @retval EFI_NOT_FOUND New form data has some error.
3200 **/
3201 EFI_STATUS
3202 EFIAPI
3203 FormDisplay (
3204 IN FORM_DISPLAY_ENGINE_FORM *FormData,
3205 OUT USER_INPUT *UserInputData
3206 )
3207 {
3208 EFI_STATUS Status;
3209
3210 ASSERT (FormData != NULL);
3211 if (FormData == NULL) {
3212 return EFI_INVALID_PARAMETER;
3213 }
3214
3215 gUserInput = UserInputData;
3216 gFormData = FormData;
3217
3218 //
3219 // Process the status info first.
3220 //
3221 BrowserStatusProcess();
3222 if (UserInputData == NULL) {
3223 //
3224 // UserInputData == NULL, means only need to print the error info, return here.
3225 //
3226 return EFI_SUCCESS;
3227 }
3228
3229 ConvertStatementToMenu();
3230
3231 Status = DisplayPageFrame (FormData, &gStatementDimensions);
3232 if (EFI_ERROR (Status)) {
3233 return Status;
3234 }
3235
3236 //
3237 // Check whether layout is changed.
3238 //
3239 if (mIsFirstForm
3240 || (gOldFormEntry.HiiHandle != FormData->HiiHandle)
3241 || (!CompareGuid (&gOldFormEntry.FormSetGuid, &FormData->FormSetGuid))
3242 || (gOldFormEntry.FormId != FormData->FormId)) {
3243 mStatementLayoutIsChanged = TRUE;
3244 } else {
3245 mStatementLayoutIsChanged = FALSE;
3246 }
3247
3248 Status = UiDisplayMenu(FormData);
3249
3250 //
3251 // Backup last form info.
3252 //
3253 mIsFirstForm = FALSE;
3254 gOldFormEntry.HiiHandle = FormData->HiiHandle;
3255 CopyGuid (&gOldFormEntry.FormSetGuid, &FormData->FormSetGuid);
3256 gOldFormEntry.FormId = FormData->FormId;
3257
3258 return Status;
3259 }
3260
3261 /**
3262 Clear Screen to the initial state.
3263 **/
3264 VOID
3265 EFIAPI
3266 DriverClearDisplayPage (
3267 VOID
3268 )
3269 {
3270 ClearDisplayPage ();
3271 mIsFirstForm = TRUE;
3272 }
3273
3274 /**
3275 Set Buffer to Value for Size bytes.
3276
3277 @param Buffer Memory to set.
3278 @param Size Number of bytes to set
3279 @param Value Value of the set operation.
3280
3281 **/
3282 VOID
3283 SetUnicodeMem (
3284 IN VOID *Buffer,
3285 IN UINTN Size,
3286 IN CHAR16 Value
3287 )
3288 {
3289 CHAR16 *Ptr;
3290
3291 Ptr = Buffer;
3292 while ((Size--) != 0) {
3293 *(Ptr++) = Value;
3294 }
3295 }
3296
3297 /**
3298 Initialize Setup Browser driver.
3299
3300 @param ImageHandle The image handle.
3301 @param SystemTable The system table.
3302
3303 @retval EFI_SUCCESS The Setup Browser module is initialized correctly..
3304 @return Other value if failed to initialize the Setup Browser module.
3305
3306 **/
3307 EFI_STATUS
3308 EFIAPI
3309 InitializeDisplayEngine (
3310 IN EFI_HANDLE ImageHandle,
3311 IN EFI_SYSTEM_TABLE *SystemTable
3312 )
3313 {
3314 EFI_STATUS Status;
3315 EFI_INPUT_KEY HotKey;
3316 EFI_STRING NewString;
3317 EDKII_FORM_BROWSER_EXTENSION2_PROTOCOL *FormBrowserEx2;
3318
3319 //
3320 // Publish our HII data
3321 //
3322 gHiiHandle = HiiAddPackages (
3323 &gDisplayEngineGuid,
3324 ImageHandle,
3325 DisplayEngineStrings,
3326 NULL
3327 );
3328 ASSERT (gHiiHandle != NULL);
3329
3330 //
3331 // Install Form Display protocol
3332 //
3333 Status = gBS->InstallProtocolInterface (
3334 &mPrivateData.Handle,
3335 &gEdkiiFormDisplayEngineProtocolGuid,
3336 EFI_NATIVE_INTERFACE,
3337 &mPrivateData.FromDisplayProt
3338 );
3339 ASSERT_EFI_ERROR (Status);
3340
3341 InitializeDisplayStrings();
3342
3343 ZeroMem (&gHighligthMenuInfo, sizeof (gHighligthMenuInfo));
3344 ZeroMem (&gOldFormEntry, sizeof (gOldFormEntry));
3345
3346 //
3347 // Use BrowserEx2 protocol to register HotKey.
3348 //
3349 Status = gBS->LocateProtocol (&gEdkiiFormBrowserEx2ProtocolGuid, NULL, (VOID **) &FormBrowserEx2);
3350 if (!EFI_ERROR (Status)) {
3351 //
3352 // Register the default HotKey F9 and F10 again.
3353 //
3354 HotKey.UnicodeChar = CHAR_NULL;
3355 HotKey.ScanCode = SCAN_F10;
3356 NewString = HiiGetString (gHiiHandle, STRING_TOKEN (FUNCTION_TEN_STRING), NULL);
3357 ASSERT (NewString != NULL);
3358 FormBrowserEx2->RegisterHotKey (&HotKey, BROWSER_ACTION_SUBMIT, 0, NewString);
3359
3360 HotKey.ScanCode = SCAN_F9;
3361 NewString = HiiGetString (gHiiHandle, STRING_TOKEN (FUNCTION_NINE_STRING), NULL);
3362 ASSERT (NewString != NULL);
3363 FormBrowserEx2->RegisterHotKey (&HotKey, BROWSER_ACTION_DEFAULT, EFI_HII_DEFAULT_CLASS_STANDARD, NewString);
3364 }
3365
3366 return EFI_SUCCESS;
3367 }
3368
3369 /**
3370 This is the default unload handle for display core drivers.
3371
3372 @param[in] ImageHandle The drivers' driver image.
3373
3374 @retval EFI_SUCCESS The image is unloaded.
3375 @retval Others Failed to unload the image.
3376
3377 **/
3378 EFI_STATUS
3379 EFIAPI
3380 UnloadDisplayEngine (
3381 IN EFI_HANDLE ImageHandle
3382 )
3383 {
3384 HiiRemovePackages(gHiiHandle);
3385
3386 FreeDisplayStrings ();
3387
3388 return EFI_SUCCESS;
3389 }
EFI Development Kit II mirror for PVE