VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Application/BootManagerMenuApp/BootManagerMenu.c@ 99404

Last change on this file since 99404 was 99404, checked in by vboxsync, 23 months ago

Devices/EFI/FirmwareNew: Update to edk2-stable202302 and make it build, bugref:4643
  • Property svn:eol-style set to native
File size: 35.6 KB
Line 
1/** @file
2 The application to show the Boot Manager Menu.
3
4Copyright (c) 2011 - 2021, Intel Corporation. All rights reserved.<BR>
5SPDX-License-Identifier: BSD-2-Clause-Patent
6
7**/
8
9#include "BootManagerMenu.h"
10
11EFI_HII_HANDLE gStringPackHandle;
12
13BOOLEAN mModeInitialized = FALSE;
14
15//
16// Boot video resolution and text mode.
17//
18UINT32 mBootHorizontalResolution = 0;
19UINT32 mBootVerticalResolution = 0;
20UINT32 mBootTextModeColumn = 0;
21UINT32 mBootTextModeRow = 0;
22//
23// BIOS setup video resolution and text mode.
24//
25UINT32 mSetupTextModeColumn = 0;
26UINT32 mSetupTextModeRow = 0;
27UINT32 mSetupHorizontalResolution = 0;
28UINT32 mSetupVerticalResolution = 0;
29
30/**
31 Prints a unicode string to the default console, at
32 the supplied cursor position, using L"%s" format.
33
34 @param Column The cursor position to print the string at.
35 @param Row The cursor position to print the string at
36 @param String String pointer.
37
38 @return Length of string printed to the console
39
40**/
41UINTN
42PrintStringAt (
43 IN UINTN Column,
44 IN UINTN Row,
45 IN CHAR16 *String
46 )
47{
48 UINTN ScreenWidth;
49 UINTN ScreenRows;
50 CHAR16 *TurncateString;
51 EFI_STATUS Status;
52 UINTN ShowingLength;
53
54 gST->ConOut->SetCursorPosition (gST->ConOut, Column, Row);
55
56 gST->ConOut->QueryMode (
57 gST->ConOut,
58 gST->ConOut->Mode->Mode,
59 &ScreenWidth,
60 &ScreenRows
61 );
62
63 if ((Column > (ScreenWidth - 1)) || (Row > (ScreenRows - 1))) {
64 return 0;
65 }
66
67 if ((StrLen (String) + Column) > (ScreenWidth - 1)) {
68 //
69 // | - ScreenWidth - |
70 // ...Column.....................
71 // TurncateString length should leave one character for draw box and
72 // require one character for string end.
73 //
74 ShowingLength = ScreenWidth - Column - 1;
75 TurncateString = AllocatePool ((ShowingLength + 1) * sizeof (CHAR16));
76
77 if (TurncateString == NULL) {
78 return 0;
79 }
80
81 Status = StrnCpyS (TurncateString, ShowingLength + 1, String, ShowingLength - 3);
82
83 if (EFI_ERROR (Status)) {
84 FreePool (TurncateString);
85 return 0;
86 }
87
88 *(TurncateString + ShowingLength - 3) = L'.';
89 *(TurncateString + ShowingLength - 2) = L'.';
90 *(TurncateString + ShowingLength - 1) = L'.';
91 *(TurncateString + ShowingLength) = L'\0';
92 ShowingLength = Print (L"%s", TurncateString);
93 FreePool (TurncateString);
94 return ShowingLength;
95 } else {
96 return Print (L"%s", String);
97 }
98}
99
100/**
101 Prints a character to the default console, at
102 the supplied cursor position, using L"%c" format.
103
104 @param Column The cursor position to print the string at.
105 @param Row The cursor position to print the string at.
106 @param Character Character to print.
107
108 @return Length of string printed to the console.
109
110**/
111UINTN
112PrintCharAt (
113 IN UINTN Column,
114 IN UINTN Row,
115 CHAR16 Character
116 )
117{
118 UINTN ScreenWidth;
119 UINTN ScreenRows;
120
121 gST->ConOut->SetCursorPosition (gST->ConOut, Column, Row);
122
123 gST->ConOut->QueryMode (
124 gST->ConOut,
125 gST->ConOut->Mode->Mode,
126 &ScreenWidth,
127 &ScreenRows
128 );
129
130 if ((Column > (ScreenWidth - 1)) || (Row > (ScreenRows - 1))) {
131 return 0;
132 }
133
134 return Print (L"%c", Character);
135}
136
137/**
138 Count the storage space of a Unicode string which uses current language to get
139 from input string ID.
140
141 @param StringId The input string to be counted.
142
143 @return Storage space for the input string.
144
145**/
146UINTN
147GetLineWidth (
148 IN EFI_STRING_ID StringId
149 )
150{
151 UINTN Index;
152 UINTN IncrementValue;
153 EFI_STRING String;
154 UINTN LineWidth;
155
156 LineWidth = 0;
157 String = HiiGetString (gStringPackHandle, StringId, NULL);
158
159 if (String != NULL) {
160 Index = 0;
161 IncrementValue = 1;
162
163 do {
164 //
165 // Advance to the null-terminator or to the first width directive
166 //
167 for ( ;
168 (String[Index] != NARROW_CHAR) && (String[Index] != WIDE_CHAR) && (String[Index] != 0);
169 Index++, LineWidth = LineWidth + IncrementValue
170 )
171 {
172 }
173
174 //
175 // We hit the null-terminator, we now have a count
176 //
177 if (String[Index] == 0) {
178 break;
179 }
180
181 //
182 // We encountered a narrow directive - strip it from the size calculation since it doesn't get printed
183 // and also set the flag that determines what we increment by.(if narrow, increment by 1, if wide increment by 2)
184 //
185 if (String[Index] == NARROW_CHAR) {
186 //
187 // Skip to the next character
188 //
189 Index++;
190 IncrementValue = 1;
191 } else {
192 //
193 // Skip to the next character
194 //
195 Index++;
196 IncrementValue = 2;
197 }
198 } while (String[Index] != 0);
199
200 FreePool (String);
201 }
202
203 return LineWidth;
204}
205
206/**
207 This function uses calculate the boot menu location, size and scroll bar information.
208
209 @param BootMenuData The boot menu data to be processed.
210
211 @return EFI_SUCCESS calculate boot menu information successful.
212 @retval EFI_INVALID_PARAMETER Input parameter is invalid
213
214**/
215EFI_STATUS
216InitializeBootMenuScreen (
217 IN OUT BOOT_MENU_POPUP_DATA *BootMenuData
218 )
219{
220 UINTN MaxStrWidth;
221 UINTN StrWidth;
222 UINTN Index;
223 UINTN Column;
224 UINTN Row;
225 UINTN MaxPrintRows;
226 UINTN UnSelectableItmes;
227
228 if (BootMenuData == NULL) {
229 return EFI_INVALID_PARAMETER;
230 }
231
232 //
233 // Get maximum string width
234 //
235 MaxStrWidth = 0;
236 for (Index = 0; Index < TITLE_TOKEN_COUNT; Index++) {
237 StrWidth = GetLineWidth (BootMenuData->TitleToken[Index]);
238 MaxStrWidth = MaxStrWidth > StrWidth ? MaxStrWidth : StrWidth;
239 }
240
241 for (Index = 0; Index < BootMenuData->ItemCount; Index++) {
242 StrWidth = GetLineWidth (BootMenuData->PtrTokens[Index]);
243 MaxStrWidth = MaxStrWidth > StrWidth ? MaxStrWidth : StrWidth;
244 }
245
246 for (Index = 0; Index < HELP_TOKEN_COUNT; Index++) {
247 StrWidth = GetLineWidth (BootMenuData->HelpToken[Index]);
248 MaxStrWidth = MaxStrWidth > StrWidth ? MaxStrWidth : StrWidth;
249 }
250
251 //
252 // query current row and column to calculate boot menu location
253 //
254 gST->ConOut->QueryMode (
255 gST->ConOut,
256 gST->ConOut->Mode->Mode,
257 &Column,
258 &Row
259 );
260
261 MaxPrintRows = Row - 6;
262 UnSelectableItmes = TITLE_TOKEN_COUNT + 2 + HELP_TOKEN_COUNT + 2;
263 if (MaxStrWidth + 8 > Column) {
264 BootMenuData->MenuScreen.Width = Column;
265 } else {
266 BootMenuData->MenuScreen.Width = MaxStrWidth + 8;
267 }
268
269 if (BootMenuData->ItemCount + UnSelectableItmes > MaxPrintRows) {
270 BootMenuData->MenuScreen.Height = MaxPrintRows;
271 BootMenuData->ScrollBarControl.HasScrollBar = TRUE;
272 BootMenuData->ScrollBarControl.ItemCountPerScreen = MaxPrintRows - UnSelectableItmes;
273 BootMenuData->ScrollBarControl.FirstItem = 0;
274 BootMenuData->ScrollBarControl.LastItem = MaxPrintRows - UnSelectableItmes - 1;
275 } else {
276 BootMenuData->MenuScreen.Height = BootMenuData->ItemCount + UnSelectableItmes;
277 BootMenuData->ScrollBarControl.HasScrollBar = FALSE;
278 BootMenuData->ScrollBarControl.ItemCountPerScreen = BootMenuData->ItemCount;
279 BootMenuData->ScrollBarControl.FirstItem = 0;
280 BootMenuData->ScrollBarControl.LastItem = BootMenuData->ItemCount - 1;
281 }
282
283 BootMenuData->MenuScreen.StartCol = (Column - BootMenuData->MenuScreen.Width) / 2;
284 BootMenuData->MenuScreen.StartRow = (Row - BootMenuData->MenuScreen.Height) / 2;
285
286 return EFI_SUCCESS;
287}
288
289/**
290 This function uses check boot option is wheher setup application or no
291
292 @param BootOption Pointer to EFI_BOOT_MANAGER_LOAD_OPTION array.
293
294 @retval TRUE This boot option is setup application.
295 @retval FALSE This boot options isn't setup application
296
297**/
298BOOLEAN
299IsBootManagerMenu (
300 IN EFI_BOOT_MANAGER_LOAD_OPTION *BootOption
301 )
302{
303 EFI_STATUS Status;
304 EFI_BOOT_MANAGER_LOAD_OPTION BootManagerMenu;
305
306 Status = EfiBootManagerGetBootManagerMenu (&BootManagerMenu);
307 if (!EFI_ERROR (Status)) {
308 EfiBootManagerFreeLoadOption (&BootManagerMenu);
309 }
310
311 return (BOOLEAN)(!EFI_ERROR (Status) && (BootOption->OptionNumber == BootManagerMenu.OptionNumber));
312}
313
314/**
315 Return whether to ignore the boot option.
316
317 @param BootOption Pointer to EFI_BOOT_MANAGER_LOAD_OPTION to check.
318
319 @retval TRUE Ignore the boot option.
320 @retval FALSE Do not ignore the boot option.
321**/
322BOOLEAN
323IgnoreBootOption (
324 IN EFI_BOOT_MANAGER_LOAD_OPTION *BootOption
325 )
326{
327 EFI_STATUS Status;
328 EFI_DEVICE_PATH_PROTOCOL *ImageDevicePath;
329
330 //
331 // Ignore myself.
332 //
333 Status = gBS->HandleProtocol (gImageHandle, &gEfiLoadedImageDevicePathProtocolGuid, (VOID **)&ImageDevicePath);
334 ASSERT_EFI_ERROR (Status);
335 if (CompareMem (BootOption->FilePath, ImageDevicePath, GetDevicePathSize (ImageDevicePath)) == 0) {
336 return TRUE;
337 }
338
339 //
340 // Do not ignore Boot Manager Menu.
341 //
342 if (IsBootManagerMenu (BootOption)) {
343 return FALSE;
344 }
345
346 //
347 // Ignore the hidden/inactive boot option.
348 //
349 if (((BootOption->Attributes & LOAD_OPTION_HIDDEN) != 0) || ((BootOption->Attributes & LOAD_OPTION_ACTIVE) == 0)) {
350 return TRUE;
351 }
352
353 return FALSE;
354}
355
356/**
357 This function uses to initialize boot menu data
358
359 @param BootOption Pointer to EFI_BOOT_MANAGER_LOAD_OPTION array.
360 @param BootOptionCount Number of boot option.
361 @param BootMenuData The Input BootMenuData to be initialized.
362
363 @retval EFI_SUCCESS Initialize boot menu data successful.
364 @retval EFI_INVALID_PARAMETER Input parameter is invalid.
365
366**/
367EFI_STATUS
368InitializeBootMenuData (
369 IN EFI_BOOT_MANAGER_LOAD_OPTION *BootOption,
370 IN UINTN BootOptionCount,
371 OUT BOOT_MENU_POPUP_DATA *BootMenuData
372 )
373{
374 UINTN Index;
375 UINTN StrIndex;
376
377 if ((BootOption == NULL) || (BootMenuData == NULL)) {
378 return EFI_INVALID_PARAMETER;
379 }
380
381 BootMenuData->TitleToken[0] = STRING_TOKEN (STR_BOOT_POPUP_MENU_TITLE_STRING);
382 BootMenuData->PtrTokens = AllocateZeroPool (BootOptionCount * sizeof (EFI_STRING_ID));
383 ASSERT (BootMenuData->PtrTokens != NULL);
384
385 //
386 // Skip boot option which created by BootNext Variable
387 //
388 for (StrIndex = 0, Index = 0; Index < BootOptionCount; Index++) {
389 if (IgnoreBootOption (&BootOption[Index])) {
390 continue;
391 }
392
393 ASSERT (BootOption[Index].Description != NULL);
394 BootMenuData->PtrTokens[StrIndex++] = HiiSetString (
395 gStringPackHandle,
396 0,
397 BootOption[Index].Description,
398 NULL
399 );
400 }
401
402 BootMenuData->ItemCount = StrIndex;
403 BootMenuData->HelpToken[0] = STRING_TOKEN (STR_BOOT_POPUP_MENU_HELP1_STRING);
404 BootMenuData->HelpToken[1] = STRING_TOKEN (STR_BOOT_POPUP_MENU_HELP2_STRING);
405 BootMenuData->HelpToken[2] = STRING_TOKEN (STR_BOOT_POPUP_MENU_HELP3_STRING);
406 InitializeBootMenuScreen (BootMenuData);
407 BootMenuData->SelectItem = 0;
408 return EFI_SUCCESS;
409}
410
411/**
412 This function uses input select item to highlight selected item
413 and set current selected item in BootMenuData
414
415 @param WantSelectItem The user wants to select item.
416 @param BootMenuData The boot menu data to be processed
417
418 @return EFI_SUCCESS Highlight selected item and update current selected
419 item successful
420 @retval EFI_INVALID_PARAMETER Input parameter is invalid
421**/
422EFI_STATUS
423BootMenuSelectItem (
424 IN UINTN WantSelectItem,
425 IN OUT BOOT_MENU_POPUP_DATA *BootMenuData
426 )
427{
428 INT32 SavedAttribute;
429 EFI_STRING String;
430 UINTN StartCol;
431 UINTN StartRow;
432 UINTN PrintCol;
433 UINTN PrintRow;
434 UINTN TopShadeNum;
435 UINTN LowShadeNum;
436 UINTN FirstItem;
437 UINTN LastItem;
438 UINTN ItemCountPerScreen;
439 UINTN Index;
440 BOOLEAN RePaintItems;
441
442 if ((BootMenuData == NULL) || (WantSelectItem >= BootMenuData->ItemCount)) {
443 return EFI_INVALID_PARAMETER;
444 }
445
446 ASSERT (BootMenuData->ItemCount != 0);
447 SavedAttribute = gST->ConOut->Mode->Attribute;
448 RePaintItems = FALSE;
449 StartCol = BootMenuData->MenuScreen.StartCol;
450 StartRow = BootMenuData->MenuScreen.StartRow;
451 //
452 // print selectable items again and adjust scroll bar if need
453 //
454 if (BootMenuData->ScrollBarControl.HasScrollBar &&
455 ((WantSelectItem < BootMenuData->ScrollBarControl.FirstItem) ||
456 (WantSelectItem > BootMenuData->ScrollBarControl.LastItem) ||
457 (WantSelectItem == BootMenuData->SelectItem)))
458 {
459 ItemCountPerScreen = BootMenuData->ScrollBarControl.ItemCountPerScreen;
460 //
461 // Set first item and last item
462 //
463 if (WantSelectItem < BootMenuData->ScrollBarControl.FirstItem) {
464 BootMenuData->ScrollBarControl.FirstItem = WantSelectItem;
465 BootMenuData->ScrollBarControl.LastItem = WantSelectItem + ItemCountPerScreen - 1;
466 } else if (WantSelectItem > BootMenuData->ScrollBarControl.LastItem) {
467 BootMenuData->ScrollBarControl.FirstItem = WantSelectItem - ItemCountPerScreen + 1;
468 BootMenuData->ScrollBarControl.LastItem = WantSelectItem;
469 }
470
471 gST->ConOut->SetAttribute (gST->ConOut, EFI_WHITE | EFI_BACKGROUND_BLUE);
472 FirstItem = BootMenuData->ScrollBarControl.FirstItem;
473 LastItem = BootMenuData->ScrollBarControl.LastItem;
474 TopShadeNum = 0;
475 if (FirstItem != 0) {
476 TopShadeNum = (FirstItem * ItemCountPerScreen) / BootMenuData->ItemCount;
477 if ((FirstItem * ItemCountPerScreen) % BootMenuData->ItemCount != 0) {
478 TopShadeNum++;
479 }
480
481 PrintCol = StartCol + BootMenuData->MenuScreen.Width - 2;
482 PrintRow = StartRow + TITLE_TOKEN_COUNT + 2;
483 for (Index = 0; Index < TopShadeNum; Index++, PrintRow++) {
484 PrintCharAt (PrintCol, PrintRow, BLOCKELEMENT_LIGHT_SHADE);
485 }
486 }
487
488 LowShadeNum = 0;
489 if (LastItem != BootMenuData->ItemCount - 1) {
490 LowShadeNum = ((BootMenuData->ItemCount - 1 - LastItem) * ItemCountPerScreen) / BootMenuData->ItemCount;
491 if (((BootMenuData->ItemCount - 1 - LastItem) * ItemCountPerScreen) % BootMenuData->ItemCount != 0) {
492 LowShadeNum++;
493 }
494
495 PrintCol = StartCol + BootMenuData->MenuScreen.Width - 2;
496 PrintRow = StartRow + TITLE_TOKEN_COUNT + 2 + ItemCountPerScreen - LowShadeNum;
497 for (Index = 0; Index < LowShadeNum; Index++, PrintRow++) {
498 PrintCharAt (PrintCol, PrintRow, BLOCKELEMENT_LIGHT_SHADE);
499 }
500 }
501
502 PrintCol = StartCol + BootMenuData->MenuScreen.Width - 2;
503 PrintRow = StartRow + TITLE_TOKEN_COUNT + 2 + TopShadeNum;
504 for (Index = TopShadeNum; Index < ItemCountPerScreen - LowShadeNum; Index++, PrintRow++) {
505 PrintCharAt (PrintCol, PrintRow, BLOCKELEMENT_FULL_BLOCK);
506 }
507
508 //
509 // Clear selectable items first
510 //
511 PrintCol = StartCol + 1;
512 PrintRow = StartRow + TITLE_TOKEN_COUNT + 2;
513 String = AllocateZeroPool ((BootMenuData->MenuScreen.Width - 2) * sizeof (CHAR16));
514 ASSERT (String != NULL);
515 for (Index = 0; Index < BootMenuData->MenuScreen.Width - 3; Index++) {
516 String[Index] = 0x20;
517 }
518
519 for (Index = 0; Index < ItemCountPerScreen; Index++) {
520 PrintStringAt (PrintCol, PrintRow + Index, String);
521 }
522
523 FreePool (String);
524 //
525 // print selectable items
526 //
527 for (Index = 0; Index < ItemCountPerScreen; Index++, PrintRow++) {
528 String = HiiGetString (gStringPackHandle, BootMenuData->PtrTokens[Index + FirstItem], NULL);
529 PrintStringAt (PrintCol, PrintRow, String);
530 FreePool (String);
531 }
532
533 RePaintItems = TRUE;
534 }
535
536 //
537 // if Want Select and selected item isn't the same and doesn't re-draw selectable
538 // items, clear select item
539 //
540 FirstItem = BootMenuData->ScrollBarControl.FirstItem;
541 if ((WantSelectItem != BootMenuData->SelectItem) && !RePaintItems) {
542 gST->ConOut->SetAttribute (gST->ConOut, EFI_WHITE | EFI_BACKGROUND_BLUE);
543 String = HiiGetString (gStringPackHandle, BootMenuData->PtrTokens[BootMenuData->SelectItem], NULL);
544 PrintCol = StartCol + 1;
545 PrintRow = StartRow + 3 + BootMenuData->SelectItem - FirstItem;
546 PrintStringAt (PrintCol, PrintRow, String);
547 FreePool (String);
548 }
549
550 //
551 // Print want to select item
552 //
553 gST->ConOut->SetAttribute (gST->ConOut, EFI_WHITE | EFI_BACKGROUND_BLACK);
554 String = HiiGetString (gStringPackHandle, BootMenuData->PtrTokens[WantSelectItem], NULL);
555 PrintCol = StartCol + 1;
556 PrintRow = StartRow + TITLE_TOKEN_COUNT + 2 + WantSelectItem - FirstItem;
557 PrintStringAt (PrintCol, PrintRow, String);
558 FreePool (String);
559
560 gST->ConOut->SetAttribute (gST->ConOut, SavedAttribute);
561 BootMenuData->SelectItem = WantSelectItem;
562 return EFI_SUCCESS;
563}
564
565/**
566 This function uses to draw boot popup menu
567
568 @param BootMenuData The Input BootMenuData to be processed.
569
570 @retval EFI_SUCCESS Draw boot popup menu successful.
571
572**/
573EFI_STATUS
574DrawBootPopupMenu (
575 IN BOOT_MENU_POPUP_DATA *BootMenuData
576 )
577{
578 EFI_STRING String;
579 UINTN Index;
580 UINTN Width;
581 UINTN StartCol;
582 UINTN StartRow;
583 UINTN PrintRow;
584 UINTN PrintCol;
585 UINTN LineWidth;
586 INT32 SavedAttribute;
587 UINTN ItemCountPerScreen;
588
589 gST->ConOut->ClearScreen (gST->ConOut);
590
591 SavedAttribute = gST->ConOut->Mode->Attribute;
592 gST->ConOut->SetAttribute (gST->ConOut, EFI_WHITE | EFI_BACKGROUND_BLUE);
593 Width = BootMenuData->MenuScreen.Width;
594 StartCol = BootMenuData->MenuScreen.StartCol;
595 StartRow = BootMenuData->MenuScreen.StartRow;
596 ItemCountPerScreen = BootMenuData->ScrollBarControl.ItemCountPerScreen;
597 PrintRow = StartRow;
598
599 gST->ConOut->EnableCursor (gST->ConOut, FALSE);
600 //
601 // Draw Boot popup menu screen
602 //
603 PrintCharAt (StartCol, PrintRow, BOXDRAW_DOWN_RIGHT);
604 for (Index = 1; Index < Width - 1; Index++) {
605 PrintCharAt (StartCol + Index, PrintRow, BOXDRAW_HORIZONTAL);
606 }
607
608 PrintCharAt (StartCol + Width - 1, PrintRow, BOXDRAW_DOWN_LEFT);
609
610 //
611 // Draw the screen for title
612 //
613 String = AllocateZeroPool ((Width - 1) * sizeof (CHAR16));
614 ASSERT (String != NULL);
615 for (Index = 0; Index < Width - 2; Index++) {
616 String[Index] = 0x20;
617 }
618
619 for (Index = 0; Index < TITLE_TOKEN_COUNT; Index++) {
620 PrintRow++;
621 PrintCharAt (StartCol, PrintRow, BOXDRAW_VERTICAL);
622 PrintStringAt (StartCol + 1, PrintRow, String);
623 PrintCharAt (StartCol + Width - 1, PrintRow, BOXDRAW_VERTICAL);
624 }
625
626 PrintRow++;
627 PrintCharAt (StartCol, PrintRow, BOXDRAW_VERTICAL_RIGHT);
628 for (Index = 1; Index < Width - 1; Index++) {
629 PrintCharAt (StartCol + Index, PrintRow, BOXDRAW_HORIZONTAL);
630 }
631
632 PrintCharAt (StartCol + Width - 1, PrintRow, BOXDRAW_VERTICAL_LEFT);
633
634 //
635 // Draw screen for selectable items
636 //
637 for (Index = 0; Index < ItemCountPerScreen; Index++) {
638 PrintRow++;
639 PrintCharAt (StartCol, PrintRow, BOXDRAW_VERTICAL);
640 PrintStringAt (StartCol + 1, PrintRow, String);
641 PrintCharAt (StartCol + Width - 1, PrintRow, BOXDRAW_VERTICAL);
642 }
643
644 PrintRow++;
645 PrintCharAt (StartCol, PrintRow, BOXDRAW_VERTICAL_RIGHT);
646 for (Index = 1; Index < Width - 1; Index++) {
647 PrintCharAt (StartCol + Index, PrintRow, BOXDRAW_HORIZONTAL);
648 }
649
650 PrintCharAt (StartCol + Width - 1, PrintRow, BOXDRAW_VERTICAL_LEFT);
651
652 //
653 // Draw screen for Help
654 //
655 for (Index = 0; Index < HELP_TOKEN_COUNT; Index++) {
656 PrintRow++;
657 PrintCharAt (StartCol, PrintRow, BOXDRAW_VERTICAL);
658 PrintStringAt (StartCol + 1, PrintRow, String);
659 PrintCharAt (StartCol + Width - 1, PrintRow, BOXDRAW_VERTICAL);
660 }
661
662 FreePool (String);
663
664 PrintRow++;
665 PrintCharAt (StartCol, PrintRow, BOXDRAW_UP_RIGHT);
666 for (Index = 1; Index < Width - 1; Index++) {
667 PrintCharAt (StartCol + Index, PrintRow, BOXDRAW_HORIZONTAL);
668 }
669
670 PrintCharAt (StartCol + Width - 1, PrintRow, BOXDRAW_UP_LEFT);
671
672 //
673 // print title strings
674 //
675 PrintRow = StartRow + 1;
676 for (Index = 0; Index < TITLE_TOKEN_COUNT; Index++, PrintRow++) {
677 String = HiiGetString (gStringPackHandle, BootMenuData->TitleToken[Index], NULL);
678 LineWidth = GetLineWidth (BootMenuData->TitleToken[Index]);
679 PrintCol = StartCol + (Width - LineWidth) / 2;
680 PrintStringAt (PrintCol, PrintRow, String);
681 FreePool (String);
682 }
683
684 //
685 // print selectable items
686 //
687 PrintCol = StartCol + 1;
688 PrintRow = StartRow + TITLE_TOKEN_COUNT + 2;
689 for (Index = 0; Index < ItemCountPerScreen; Index++, PrintRow++) {
690 String = HiiGetString (gStringPackHandle, BootMenuData->PtrTokens[Index], NULL);
691 PrintStringAt (PrintCol, PrintRow, String);
692 FreePool (String);
693 }
694
695 //
696 // Print Help strings
697 //
698 PrintRow++;
699 for (Index = 0; Index < HELP_TOKEN_COUNT; Index++, PrintRow++) {
700 String = HiiGetString (gStringPackHandle, BootMenuData->HelpToken[Index], NULL);
701 LineWidth = GetLineWidth (BootMenuData->HelpToken[Index]);
702 PrintCol = StartCol + (Width - LineWidth) / 2;
703 PrintStringAt (PrintCol, PrintRow, String);
704 FreePool (String);
705 }
706
707 //
708 // Print scroll bar if has scroll bar
709 //
710 if (BootMenuData->ScrollBarControl.HasScrollBar) {
711 PrintCol = StartCol + Width - 2;
712 PrintRow = StartRow + 2;
713 PrintCharAt (PrintCol, PrintRow, GEOMETRICSHAPE_UP_TRIANGLE);
714 PrintCharAt (PrintCol + 1, PrintRow, BOXDRAW_VERTICAL);
715 PrintRow += (ItemCountPerScreen + 1);
716 PrintCharAt (PrintCol, PrintRow, GEOMETRICSHAPE_DOWN_TRIANGLE);
717 PrintCharAt (PrintCol + 1, PrintRow, BOXDRAW_VERTICAL);
718 }
719
720 gST->ConOut->SetAttribute (gST->ConOut, SavedAttribute);
721 //
722 // Print Selected item
723 //
724 BootMenuSelectItem (BootMenuData->SelectItem, BootMenuData);
725 return EFI_SUCCESS;
726}
727
728/**
729 This function uses to boot from selected item
730
731 @param BootOptions Pointer to EFI_BOOT_MANAGER_LOAD_OPTION array.
732 @param BootOptionCount Number of boot option.
733 @param SelectItem Current selected item.
734**/
735VOID
736BootFromSelectOption (
737 IN EFI_BOOT_MANAGER_LOAD_OPTION *BootOptions,
738 IN UINTN BootOptionCount,
739 IN UINTN SelectItem
740 )
741{
742 UINTN ItemNum;
743 UINTN Index;
744
745 ASSERT (BootOptions != NULL);
746
747 for (ItemNum = 0, Index = 0; Index < BootOptionCount; Index++) {
748 if (IgnoreBootOption (&BootOptions[Index])) {
749 continue;
750 }
751
752 if (ItemNum++ == SelectItem) {
753 EfiBootManagerBoot (&BootOptions[Index]);
754 break;
755 }
756 }
757}
758
759/**
760 This function will change video resolution and text mode
761 according to defined setup mode or defined boot mode
762
763 @param IsSetupMode Indicate mode is changed to setup mode or boot mode.
764
765 @retval EFI_SUCCESS Mode is changed successfully.
766 @retval Others Mode failed to be changed.
767
768**/
769EFI_STATUS
770EFIAPI
771BdsSetConsoleMode (
772 BOOLEAN IsSetupMode
773 )
774{
775 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
776 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOut;
777 UINTN SizeOfInfo;
778 EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
779 UINT32 MaxGopMode;
780 UINT32 MaxTextMode;
781 UINT32 ModeNumber;
782 UINT32 NewHorizontalResolution;
783 UINT32 NewVerticalResolution;
784 UINT32 NewColumns;
785 UINT32 NewRows;
786 UINTN HandleCount;
787 EFI_HANDLE *HandleBuffer;
788 EFI_STATUS Status;
789 UINTN Index;
790 UINTN CurrentColumn;
791 UINTN CurrentRow;
792
793 MaxGopMode = 0;
794 MaxTextMode = 0;
795
796 //
797 // Get current video resolution and text mode
798 //
799 Status = gBS->HandleProtocol (
800 gST->ConsoleOutHandle,
801 &gEfiGraphicsOutputProtocolGuid,
802 (VOID **)&GraphicsOutput
803 );
804 if (EFI_ERROR (Status)) {
805 GraphicsOutput = NULL;
806 }
807
808 Status = gBS->HandleProtocol (
809 gST->ConsoleOutHandle,
810 &gEfiSimpleTextOutProtocolGuid,
811 (VOID **)&SimpleTextOut
812 );
813 if (EFI_ERROR (Status)) {
814 SimpleTextOut = NULL;
815 }
816
817 if ((GraphicsOutput == NULL) || (SimpleTextOut == NULL)) {
818 return EFI_UNSUPPORTED;
819 }
820
821 if (IsSetupMode) {
822 //
823 // The required resolution and text mode is setup mode.
824 //
825 NewHorizontalResolution = mSetupHorizontalResolution;
826 NewVerticalResolution = mSetupVerticalResolution;
827 NewColumns = mSetupTextModeColumn;
828 NewRows = mSetupTextModeRow;
829 } else {
830 //
831 // The required resolution and text mode is boot mode.
832 //
833 NewHorizontalResolution = mBootHorizontalResolution;
834 NewVerticalResolution = mBootVerticalResolution;
835 NewColumns = mBootTextModeColumn;
836 NewRows = mBootTextModeRow;
837 }
838
839 if (GraphicsOutput != NULL) {
840 MaxGopMode = GraphicsOutput->Mode->MaxMode;
841 }
842
843 if (SimpleTextOut != NULL) {
844 MaxTextMode = SimpleTextOut->Mode->MaxMode;
845 }
846
847 //
848 // 1. If current video resolution is same with required video resolution,
849 // video resolution need not be changed.
850 // 1.1. If current text mode is same with required text mode, text mode need not be changed.
851 // 1.2. If current text mode is different from required text mode, text mode need be changed.
852 // 2. If current video resolution is different from required video resolution, we need restart whole console drivers.
853 //
854 for (ModeNumber = 0; ModeNumber < MaxGopMode; ModeNumber++) {
855 Status = GraphicsOutput->QueryMode (
856 GraphicsOutput,
857 ModeNumber,
858 &SizeOfInfo,
859 &Info
860 );
861 if (!EFI_ERROR (Status)) {
862 if ((Info->HorizontalResolution == NewHorizontalResolution) &&
863 (Info->VerticalResolution == NewVerticalResolution))
864 {
865 if ((GraphicsOutput->Mode->Info->HorizontalResolution == NewHorizontalResolution) &&
866 (GraphicsOutput->Mode->Info->VerticalResolution == NewVerticalResolution))
867 {
868 //
869 // Current resolution is same with required resolution, check if text mode need be set
870 //
871 Status = SimpleTextOut->QueryMode (SimpleTextOut, SimpleTextOut->Mode->Mode, &CurrentColumn, &CurrentRow);
872 ASSERT_EFI_ERROR (Status);
873 if ((CurrentColumn == NewColumns) && (CurrentRow == NewRows)) {
874 //
875 // If current text mode is same with required text mode. Do nothing
876 //
877 FreePool (Info);
878 return EFI_SUCCESS;
879 } else {
880 //
881 // If current text mode is different from required text mode. Set new video mode
882 //
883 for (Index = 0; Index < MaxTextMode; Index++) {
884 Status = SimpleTextOut->QueryMode (SimpleTextOut, Index, &CurrentColumn, &CurrentRow);
885 if (!EFI_ERROR (Status)) {
886 if ((CurrentColumn == NewColumns) && (CurrentRow == NewRows)) {
887 //
888 // Required text mode is supported, set it.
889 //
890 Status = SimpleTextOut->SetMode (SimpleTextOut, Index);
891 ASSERT_EFI_ERROR (Status);
892 //
893 // Update text mode PCD.
894 //
895 Status = PcdSet32S (PcdConOutColumn, mSetupTextModeColumn);
896 ASSERT_EFI_ERROR (Status);
897 Status = PcdSet32S (PcdConOutRow, mSetupTextModeRow);
898 ASSERT_EFI_ERROR (Status);
899 FreePool (Info);
900 return EFI_SUCCESS;
901 }
902 }
903 }
904
905 if (Index == MaxTextMode) {
906 //
907 // If required text mode is not supported, return error.
908 //
909 FreePool (Info);
910 return EFI_UNSUPPORTED;
911 }
912 }
913 } else {
914 //
915 // If current video resolution is not same with the new one, set new video resolution.
916 // In this case, the driver which produces simple text out need be restarted.
917 //
918 Status = GraphicsOutput->SetMode (GraphicsOutput, ModeNumber);
919 if (!EFI_ERROR (Status)) {
920 FreePool (Info);
921 break;
922 }
923 }
924 }
925
926 FreePool (Info);
927 }
928 }
929
930 if (ModeNumber == MaxGopMode) {
931 //
932 // If the resolution is not supported, return error.
933 //
934 return EFI_UNSUPPORTED;
935 }
936
937 //
938 // Set PCD to Inform GraphicsConsole to change video resolution.
939 // Set PCD to Inform Consplitter to change text mode.
940 //
941 Status = PcdSet32S (PcdVideoHorizontalResolution, NewHorizontalResolution);
942 ASSERT_EFI_ERROR (Status);
943 Status = PcdSet32S (PcdVideoVerticalResolution, NewVerticalResolution);
944 ASSERT_EFI_ERROR (Status);
945 Status = PcdSet32S (PcdConOutColumn, NewColumns);
946 ASSERT_EFI_ERROR (Status);
947 Status = PcdSet32S (PcdConOutRow, NewRows);
948 ASSERT_EFI_ERROR (Status);
949
950 //
951 // Video mode is changed, so restart graphics console driver and higher level driver.
952 // Reconnect graphics console driver and higher level driver.
953 // Locate all the handles with GOP protocol and reconnect it.
954 //
955 Status = gBS->LocateHandleBuffer (
956 ByProtocol,
957 &gEfiSimpleTextOutProtocolGuid,
958 NULL,
959 &HandleCount,
960 &HandleBuffer
961 );
962 if (!EFI_ERROR (Status)) {
963 for (Index = 0; Index < HandleCount; Index++) {
964 gBS->DisconnectController (HandleBuffer[Index], NULL, NULL);
965 }
966
967 for (Index = 0; Index < HandleCount; Index++) {
968 gBS->ConnectController (HandleBuffer[Index], NULL, NULL, TRUE);
969 }
970
971 if (HandleBuffer != NULL) {
972 FreePool (HandleBuffer);
973 }
974 }
975
976 return EFI_SUCCESS;
977}
978
979/**
980 Display the boot popup menu and allow user select boot item.
981
982 @param ImageHandle The image handle.
983 @param SystemTable The system table.
984
985 @retval EFI_SUCCESS Boot from selected boot option, and return success from boot option
986 @retval EFI_NOT_FOUND User select to enter setup or can not find boot option
987
988**/
989EFI_STATUS
990EFIAPI
991BootManagerMenuEntry (
992 IN EFI_HANDLE ImageHandle,
993 IN EFI_SYSTEM_TABLE *SystemTable
994 )
995{
996 EFI_BOOT_MANAGER_LOAD_OPTION *BootOption;
997 UINTN BootOptionCount;
998 EFI_STATUS Status;
999 BOOT_MENU_POPUP_DATA BootMenuData;
1000 UINTN Index;
1001 EFI_INPUT_KEY Key;
1002 BOOLEAN ExitApplication;
1003 UINTN SelectItem;
1004 EFI_BOOT_LOGO_PROTOCOL *BootLogo;
1005 EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput;
1006 EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *SimpleTextOut;
1007 UINTN BootTextColumn;
1008 UINTN BootTextRow;
1009
1010 //
1011 // Set Logo status invalid when boot manager menu is launched
1012 //
1013 BootLogo = NULL;
1014 Status = gBS->LocateProtocol (&gEfiBootLogoProtocolGuid, NULL, (VOID **)&BootLogo);
1015 if (!EFI_ERROR (Status) && (BootLogo != NULL)) {
1016 Status = BootLogo->SetBootLogo (BootLogo, NULL, 0, 0, 0, 0);
1017 ASSERT_EFI_ERROR (Status);
1018 }
1019
1020 gBS->SetWatchdogTimer (0x0000, 0x0000, 0x0000, NULL);
1021
1022 gStringPackHandle = HiiAddPackages (
1023 &gEfiCallerIdGuid,
1024 gImageHandle,
1025 BootManagerMenuAppStrings,
1026 NULL
1027 );
1028 ASSERT (gStringPackHandle != NULL);
1029
1030 //
1031 // Connect all prior to entering the platform setup menu.
1032 //
1033 EfiBootManagerConnectAll ();
1034 EfiBootManagerRefreshAllBootOption ();
1035
1036 BootOption = EfiBootManagerGetLoadOptions (&BootOptionCount, LoadOptionTypeBoot);
1037
1038 if (!mModeInitialized) {
1039 //
1040 // After the console is ready, get current video resolution
1041 // and text mode before launching setup at first time.
1042 //
1043 Status = gBS->HandleProtocol (
1044 gST->ConsoleOutHandle,
1045 &gEfiGraphicsOutputProtocolGuid,
1046 (VOID **)&GraphicsOutput
1047 );
1048 if (EFI_ERROR (Status)) {
1049 GraphicsOutput = NULL;
1050 }
1051
1052 Status = gBS->HandleProtocol (
1053 gST->ConsoleOutHandle,
1054 &gEfiSimpleTextOutProtocolGuid,
1055 (VOID **)&SimpleTextOut
1056 );
1057 if (EFI_ERROR (Status)) {
1058 SimpleTextOut = NULL;
1059 }
1060
1061 if (GraphicsOutput != NULL) {
1062 //
1063 // Get current video resolution and text mode.
1064 //
1065 mBootHorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
1066 mBootVerticalResolution = GraphicsOutput->Mode->Info->VerticalResolution;
1067 }
1068
1069 if (SimpleTextOut != NULL) {
1070 Status = SimpleTextOut->QueryMode (
1071 SimpleTextOut,
1072 SimpleTextOut->Mode->Mode,
1073 &BootTextColumn,
1074 &BootTextRow
1075 );
1076 mBootTextModeColumn = (UINT32)BootTextColumn;
1077 mBootTextModeRow = (UINT32)BootTextRow;
1078 }
1079
1080 //
1081 // Get user defined text mode for setup.
1082 //
1083 mSetupHorizontalResolution = PcdGet32 (PcdSetupVideoHorizontalResolution);
1084 mSetupVerticalResolution = PcdGet32 (PcdSetupVideoVerticalResolution);
1085 mSetupTextModeColumn = PcdGet32 (PcdSetupConOutColumn);
1086 mSetupTextModeRow = PcdGet32 (PcdSetupConOutRow);
1087 mModeInitialized = TRUE;
1088 }
1089
1090 //
1091 // Set back to conventional setup resolution
1092 //
1093 BdsSetConsoleMode (TRUE);
1094
1095 //
1096 // Initialize Boot menu data
1097 //
1098 Status = InitializeBootMenuData (BootOption, BootOptionCount, &BootMenuData);
1099 //
1100 // According to boot menu data to draw boot popup menu
1101 //
1102 DrawBootPopupMenu (&BootMenuData);
1103
1104 //
1105 // check user input to determine want to re-draw or boot from user selected item
1106 //
1107 ExitApplication = FALSE;
1108 while (!ExitApplication) {
1109 gBS->WaitForEvent (1, &gST->ConIn->WaitForKey, &Index);
1110 Status = gST->ConIn->ReadKeyStroke (gST->ConIn, &Key);
1111 if (!EFI_ERROR (Status)) {
1112 switch (Key.UnicodeChar) {
1113 case CHAR_NULL:
1114 switch (Key.ScanCode) {
1115 case SCAN_UP:
1116 SelectItem = BootMenuData.SelectItem == 0 ? BootMenuData.ItemCount - 1 : BootMenuData.SelectItem - 1;
1117 BootMenuSelectItem (SelectItem, &BootMenuData);
1118 break;
1119
1120 case SCAN_DOWN:
1121 SelectItem = BootMenuData.SelectItem == BootMenuData.ItemCount - 1 ? 0 : BootMenuData.SelectItem + 1;
1122 BootMenuSelectItem (SelectItem, &BootMenuData);
1123 break;
1124
1125 case SCAN_ESC:
1126 gST->ConOut->ClearScreen (gST->ConOut);
1127 ExitApplication = TRUE;
1128 //
1129 // Set boot resolution for normal boot
1130 //
1131 BdsSetConsoleMode (FALSE);
1132 break;
1133
1134 default:
1135 break;
1136 }
1137
1138 break;
1139
1140 case CHAR_CARRIAGE_RETURN:
1141 gST->ConOut->ClearScreen (gST->ConOut);
1142 //
1143 // Set boot resolution for normal boot
1144 //
1145 BdsSetConsoleMode (FALSE);
1146 BootFromSelectOption (BootOption, BootOptionCount, BootMenuData.SelectItem);
1147 //
1148 // Back to boot manager menu again, set back to setup resolution
1149 //
1150 BdsSetConsoleMode (TRUE);
1151 DrawBootPopupMenu (&BootMenuData);
1152 break;
1153
1154 default:
1155 break;
1156 }
1157 }
1158 }
1159
1160 EfiBootManagerFreeLoadOptions (BootOption, BootOptionCount);
1161 FreePool (BootMenuData.PtrTokens);
1162
1163 HiiRemovePackages (gStringPackHandle);
1164
1165 return Status;
1166}
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette