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