Fix to Tom Briden's recent touch-screen commit; the original commit
[refind] / refind / menu.c
1 /*
2 * refit/menu.c
3 * Menu functions
4 *
5 * Copyright (c) 2006 Christoph Pfisterer
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions are
10 * met:
11 *
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 *
15 * * Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the
18 * distribution.
19 *
20 * * Neither the name of Christoph Pfisterer nor the names of the
21 * contributors may be used to endorse or promote products derived
22 * from this software without specific prior written permission.
23 *
24 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
25 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
26 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
27 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
28 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
29 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
30 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
34 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
35 */
36 /*
37 * Modifications copyright (c) 2012-2017 Roderick W. Smith
38 *
39 * Modifications distributed under the terms of the GNU General Public
40 * License (GPL) version 3 (GPLv3), or (at your option) any later version.
41 *
42 */
43 /*
44 * This program is free software: you can redistribute it and/or modify
45 * it under the terms of the GNU General Public License as published by
46 * the Free Software Foundation, either version 3 of the License, or
47 * (at your option) any later version.
48 *
49 * This program is distributed in the hope that it will be useful,
50 * but WITHOUT ANY WARRANTY; without even the implied warranty of
51 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
52 * GNU General Public License for more details.
53 *
54 * You should have received a copy of the GNU General Public License
55 * along with this program. If not, see <http://www.gnu.org/licenses/>.
56 */
57
58 #include "global.h"
59 #include "screen.h"
60 #include "lib.h"
61 #include "menu.h"
62 #include "config.h"
63 #include "libeg.h"
64 #include "libegint.h"
65 #include "line_edit.h"
66 #include "mystrings.h"
67 #include "../include/refit_call_wrapper.h"
68
69 #include "../include/egemb_back_selected_small.h"
70 #include "../include/egemb_back_selected_big.h"
71 #include "../include/egemb_arrow_left.h"
72 #include "../include/egemb_arrow_right.h"
73
74 // other menu definitions
75
76 #define MENU_FUNCTION_INIT (0)
77 #define MENU_FUNCTION_CLEANUP (1)
78 #define MENU_FUNCTION_PAINT_ALL (2)
79 #define MENU_FUNCTION_PAINT_SELECTION (3)
80 #define MENU_FUNCTION_PAINT_TIMEOUT (4)
81 #define MENU_FUNCTION_PAINT_HINTS (5)
82
83 typedef VOID (*MENU_STYLE_FUNC)(IN REFIT_MENU_SCREEN *Screen, IN SCROLL_STATE *State, IN UINTN Function, IN CHAR16 *ParamText);
84
85 static CHAR16 ArrowUp[2] = { ARROW_UP, 0 };
86 static CHAR16 ArrowDown[2] = { ARROW_DOWN, 0 };
87 static UINTN TileSizes[2] = { 144, 64 };
88
89 // Text and icon spacing constants....
90 #define TEXT_YMARGIN (2)
91 #define TITLEICON_SPACING (16)
92
93 #define TILE_XSPACING (8)
94 #define TILE_YSPACING (16)
95
96 // Alignment values for PaintIcon()
97 #define ALIGN_RIGHT 1
98 #define ALIGN_LEFT 0
99
100 static EG_IMAGE *SelectionImages[2] = { NULL, NULL };
101 static EG_PIXEL SelectionBackgroundPixel = { 0xff, 0xff, 0xff, 0 };
102
103 //Touch variables
104 EFI_ABSOLUTE_POINTER_PROTOCOL *TouchProtocol = NULL;
105 EFI_GUID TouchGuid = EFI_ABSOLUTE_POINTER_PROTOCOL_GUID;
106 BOOLEAN TouchEnabled = FALSE;
107 BOOLEAN TouchActive = FALSE;
108
109 //
110 // Graphics helper functions
111 //
112
113 static VOID InitSelection(VOID)
114 {
115 EG_IMAGE *TempSmallImage = NULL, *TempBigImage = NULL;
116 BOOLEAN LoadedSmallImage = FALSE;
117
118 if (!AllowGraphicsMode)
119 return;
120 if (SelectionImages[0] != NULL)
121 return;
122
123 // load small selection image
124 if (GlobalConfig.SelectionSmallFileName != NULL) {
125 TempSmallImage = egLoadImage(SelfDir, GlobalConfig.SelectionSmallFileName, TRUE);
126 }
127 if (TempSmallImage == NULL)
128 TempSmallImage = egPrepareEmbeddedImage(&egemb_back_selected_small, TRUE);
129 else
130 LoadedSmallImage = TRUE;
131 SelectionImages[1] = egScaleImage(TempSmallImage, TileSizes[1], TileSizes[1]);
132
133 // load big selection image
134 if (GlobalConfig.SelectionBigFileName != NULL) {
135 TempBigImage = egLoadImage(SelfDir, GlobalConfig.SelectionBigFileName, TRUE);
136 }
137 if (TempBigImage == NULL) {
138 if (LoadedSmallImage) {
139 // calculate big selection image from small one
140 TempBigImage = egCopyImage(TempSmallImage);
141 } else {
142 TempBigImage = egPrepareEmbeddedImage(&egemb_back_selected_big, TRUE);
143 }
144 }
145 SelectionImages[0] = egScaleImage(TempBigImage, TileSizes[0], TileSizes[0]);
146
147 if (TempSmallImage)
148 egFreeImage(TempSmallImage);
149 if (TempBigImage)
150 egFreeImage(TempBigImage);
151 } // VOID InitSelection()
152
153 //
154 // Scrolling functions
155 //
156
157 static VOID InitScroll(OUT SCROLL_STATE *State, IN UINTN ItemCount, IN UINTN VisibleSpace)
158 {
159 State->PreviousSelection = State->CurrentSelection = 0;
160 State->MaxIndex = (INTN)ItemCount - 1;
161 State->FirstVisible = 0;
162 if (AllowGraphicsMode) {
163 State->MaxVisible = UGAWidth / (TileSizes[0] + TILE_XSPACING) - 1;
164 } else
165 State->MaxVisible = ConHeight - 4;
166 if ((VisibleSpace > 0) && (VisibleSpace < State->MaxVisible))
167 State->MaxVisible = (INTN)VisibleSpace;
168 State->PaintAll = TRUE;
169 State->PaintSelection = FALSE;
170
171 State->LastVisible = State->FirstVisible + State->MaxVisible - 1;
172 }
173
174 // Adjust variables relating to the scrolling of tags, for when a selected icon isn't
175 // visible given the current scrolling condition....
176 static VOID AdjustScrollState(IN SCROLL_STATE *State) {
177 if (State->CurrentSelection > State->LastVisible) {
178 State->LastVisible = State->CurrentSelection;
179 State->FirstVisible = 1 + State->CurrentSelection - State->MaxVisible;
180 if (State->FirstVisible < 0) // shouldn't happen, but just in case....
181 State->FirstVisible = 0;
182 State->PaintAll = TRUE;
183 } // Scroll forward
184 if (State->CurrentSelection < State->FirstVisible) {
185 State->FirstVisible = State->CurrentSelection;
186 State->LastVisible = State->CurrentSelection + State->MaxVisible - 1;
187 State->PaintAll = TRUE;
188 } // Scroll backward
189 } // static VOID AdjustScrollState
190
191 static VOID UpdateScroll(IN OUT SCROLL_STATE *State, IN UINTN Movement)
192 {
193 State->PreviousSelection = State->CurrentSelection;
194
195 switch (Movement) {
196 case SCROLL_LINE_LEFT:
197 if (State->CurrentSelection > 0) {
198 State->CurrentSelection --;
199 }
200 break;
201
202 case SCROLL_LINE_RIGHT:
203 if (State->CurrentSelection < State->MaxIndex) {
204 State->CurrentSelection ++;
205 }
206 break;
207
208 case SCROLL_LINE_UP:
209 if (State->ScrollMode == SCROLL_MODE_ICONS) {
210 if (State->CurrentSelection >= State->InitialRow1) {
211 if (State->MaxIndex > State->InitialRow1) { // avoid division by 0!
212 State->CurrentSelection = State->FirstVisible + (State->LastVisible - State->FirstVisible) *
213 (State->CurrentSelection - State->InitialRow1) /
214 (State->MaxIndex - State->InitialRow1);
215 } else {
216 State->CurrentSelection = State->FirstVisible;
217 } // if/else
218 } // if in second row
219 } else {
220 if (State->CurrentSelection > 0)
221 State->CurrentSelection--;
222 } // if/else
223 break;
224
225 case SCROLL_LINE_DOWN:
226 if (State->ScrollMode == SCROLL_MODE_ICONS) {
227 if (State->CurrentSelection <= State->FinalRow0) {
228 if (State->LastVisible > State->FirstVisible) { // avoid division by 0!
229 State->CurrentSelection = State->InitialRow1 + (State->MaxIndex - State->InitialRow1) *
230 (State->CurrentSelection - State->FirstVisible) /
231 (State->LastVisible - State->FirstVisible);
232 } else {
233 State->CurrentSelection = State->InitialRow1;
234 } // if/else
235 } // if in first row
236 } else {
237 if (State->CurrentSelection < State->MaxIndex)
238 State->CurrentSelection++;
239 } // if/else
240 break;
241
242 case SCROLL_PAGE_UP:
243 if (State->CurrentSelection <= State->FinalRow0)
244 State->CurrentSelection -= State->MaxVisible;
245 else if (State->CurrentSelection == State->InitialRow1)
246 State->CurrentSelection = State->FinalRow0;
247 else
248 State->CurrentSelection = State->InitialRow1;
249 if (State->CurrentSelection < 0)
250 State->CurrentSelection = 0;
251 break;
252
253 case SCROLL_FIRST:
254 if (State->CurrentSelection > 0) {
255 State->PaintAll = TRUE;
256 State->CurrentSelection = 0;
257 }
258 break;
259
260 case SCROLL_PAGE_DOWN:
261 if (State->CurrentSelection < State->FinalRow0) {
262 State->CurrentSelection += State->MaxVisible;
263 if (State->CurrentSelection > State->FinalRow0)
264 State->CurrentSelection = State->FinalRow0;
265 } else if (State->CurrentSelection == State->FinalRow0) {
266 State->CurrentSelection++;
267 } else {
268 State->CurrentSelection = State->MaxIndex;
269 }
270 if (State->CurrentSelection > State->MaxIndex)
271 State->CurrentSelection = State->MaxIndex;
272 break;
273
274 case SCROLL_LAST:
275 if (State->CurrentSelection < State->MaxIndex) {
276 State->PaintAll = TRUE;
277 State->CurrentSelection = State->MaxIndex;
278 }
279 break;
280
281 case SCROLL_NONE:
282 break;
283
284 }
285 if (State->ScrollMode == SCROLL_MODE_TEXT)
286 AdjustScrollState(State);
287
288 if (!State->PaintAll && State->CurrentSelection != State->PreviousSelection)
289 State->PaintSelection = TRUE;
290 State->LastVisible = State->FirstVisible + State->MaxVisible - 1;
291 } // static VOID UpdateScroll()
292
293 //
294 // menu helper functions
295 //
296
297 VOID AddMenuInfoLine(IN REFIT_MENU_SCREEN *Screen, IN CHAR16 *InfoLine)
298 {
299 AddListElement((VOID ***) &(Screen->InfoLines), &(Screen->InfoLineCount), InfoLine);
300 }
301
302 VOID AddMenuEntry(IN REFIT_MENU_SCREEN *Screen, IN REFIT_MENU_ENTRY *Entry)
303 {
304 AddListElement((VOID ***) &(Screen->Entries), &(Screen->EntryCount), Entry);
305 }
306
307
308 static INTN FindMenuShortcutEntry(IN REFIT_MENU_SCREEN *Screen, IN CHAR16 *Defaults)
309 {
310 UINTN i, j = 0;
311 CHAR16 *Shortcut;
312
313 while ((Shortcut = FindCommaDelimited(Defaults, j)) != NULL) {
314 if (StrLen(Shortcut) == 1) {
315 if (Shortcut[0] >= 'a' && Shortcut[0] <= 'z')
316 Shortcut[0] -= ('a' - 'A');
317 if (Shortcut[0]) {
318 for (i = 0; i < Screen->EntryCount; i++) {
319 if (Screen->Entries[i]->ShortcutDigit == Shortcut[0] || Screen->Entries[i]->ShortcutLetter == Shortcut[0]) {
320 MyFreePool(Shortcut);
321 return i;
322 } // if
323 } // for
324 } // if
325 } else if (StrLen(Shortcut) > 1) {
326 for (i = 0; i < Screen->EntryCount; i++) {
327 if (StriSubCmp(Shortcut, Screen->Entries[i]->Title)) {
328 MyFreePool(Shortcut);
329 return i;
330 } // if
331 } // for
332 }
333 MyFreePool(Shortcut);
334 j++;
335 } // while()
336 return -1;
337 }
338
339 // Identify the end of row 0 and the beginning of row 1; store the results in the
340 // appropriate fields in State. Also reduce MaxVisible if that value is greater
341 // than the total number of row-0 tags and if we're in an icon-based screen
342 static VOID IdentifyRows(IN SCROLL_STATE *State, IN REFIT_MENU_SCREEN *Screen) {
343 UINTN i;
344
345 State->FinalRow0 = 0;
346 State->InitialRow1 = State->MaxIndex;
347 for (i = 0; i <= State->MaxIndex; i++) {
348 if (Screen->Entries[i]->Row == 0) {
349 State->FinalRow0 = i;
350 } else if ((Screen->Entries[i]->Row == 1) && (State->InitialRow1 > i)) {
351 State->InitialRow1 = i;
352 } // if/else
353 } // for
354 if ((State->ScrollMode == SCROLL_MODE_ICONS) && (State->MaxVisible > (State->FinalRow0 + 1)))
355 State->MaxVisible = State->FinalRow0 + 1;
356 } // static VOID IdentifyRows()
357
358 // Blank the screen, wait for a keypress or touch event, and restore banner/background.
359 // Screen may still require redrawing of text and icons on return.
360 // TODO: Support more sophisticated screen savers, such as power-saving
361 // mode and dynamic images.
362 static VOID SaveScreen(VOID) {
363 UINTN index;
364 EG_PIXEL Black = { 0x0, 0x0, 0x0, 0 };
365 EFI_EVENT WaitList[2] = { ST->ConIn->WaitForKey, NULL };
366
367 egClearScreen(&Black);
368 if(TouchEnabled) {
369 WaitList[1] = TouchProtocol->WaitForInput;
370 refit_call3_wrapper(BS->WaitForEvent, 2, WaitList, &index);
371 } else {
372 refit_call3_wrapper(BS->WaitForEvent, 1, WaitList, &index);
373 }
374 if (AllowGraphicsMode)
375 SwitchToGraphicsAndClear();
376 ReadAllKeyStrokes();
377 } // VOID SaveScreen()
378
379 //
380 // generic menu function
381 //
382 static UINTN RunGenericMenu(IN REFIT_MENU_SCREEN *Screen, IN MENU_STYLE_FUNC StyleFunc, IN OUT INTN *DefaultEntryIndex,
383 OUT REFIT_MENU_ENTRY **ChosenEntry)
384 {
385 SCROLL_STATE State;
386 EFI_STATUS Status;
387 EFI_INPUT_KEY key;
388 UINTN index;
389 INTN ShortcutEntry;
390 BOOLEAN HaveTimeout = FALSE;
391 BOOLEAN WaitForRelease = FALSE;
392 UINTN TimeoutCountdown = 0;
393 INTN PreviousTime = -1, CurrentTime, TimeSinceKeystroke = 0;
394 CHAR16 TimeoutMessage[256];
395 CHAR16 KeyAsString[2];
396 UINTN MenuExit;
397 EFI_STATUS TouchStatus = EFI_NOT_READY;
398 EFI_ABSOLUTE_POINTER_STATE TouchState;
399 UINT32 TouchScreenPosX;
400 UINT32 TouchScreenPosY;
401 UINTN Item;
402
403 if (Screen->TimeoutSeconds > 0) {
404 HaveTimeout = TRUE;
405 TimeoutCountdown = Screen->TimeoutSeconds * 10;
406 }
407 MenuExit = 0;
408
409 StyleFunc(Screen, &State, MENU_FUNCTION_INIT, NULL);
410 IdentifyRows(&State, Screen);
411 // override the starting selection with the default index, if any
412 if (*DefaultEntryIndex >= 0 && *DefaultEntryIndex <= State.MaxIndex) {
413 State.CurrentSelection = *DefaultEntryIndex;
414 if (GlobalConfig.ScreensaverTime != -1)
415 UpdateScroll(&State, SCROLL_NONE);
416 }
417
418 if (Screen->TimeoutSeconds == -1) {
419 Status = refit_call2_wrapper(ST->ConIn->ReadKeyStroke, ST->ConIn, &key);
420 if (Status == EFI_NOT_READY) {
421 MenuExit = MENU_EXIT_TIMEOUT;
422 } else {
423 KeyAsString[0] = key.UnicodeChar;
424 KeyAsString[1] = 0;
425 ShortcutEntry = FindMenuShortcutEntry(Screen, KeyAsString);
426 if (ShortcutEntry >= 0) {
427 State.CurrentSelection = ShortcutEntry;
428 MenuExit = MENU_EXIT_ENTER;
429 } else {
430 WaitForRelease = TRUE;
431 HaveTimeout = FALSE;
432 }
433 }
434 }
435
436 if (GlobalConfig.ScreensaverTime != -1)
437 State.PaintAll = TRUE;
438
439 while (!MenuExit) {
440 // update the screen
441 if (State.PaintAll && (GlobalConfig.ScreensaverTime != -1)) {
442 StyleFunc(Screen, &State, MENU_FUNCTION_PAINT_ALL, NULL);
443 State.PaintAll = FALSE;
444 } else if (State.PaintSelection) {
445 StyleFunc(Screen, &State, MENU_FUNCTION_PAINT_SELECTION, NULL);
446 State.PaintSelection = FALSE;
447 }
448
449 if (WaitForRelease) {
450 Status = refit_call2_wrapper(ST->ConIn->ReadKeyStroke, ST->ConIn, &key);
451 if (Status == EFI_SUCCESS) {
452 // reset, because otherwise the buffer gets queued with keystrokes
453 refit_call2_wrapper(ST->ConIn->Reset, ST->ConIn, FALSE);
454 refit_call1_wrapper(BS->Stall, 100000);
455 } else {
456 WaitForRelease = FALSE;
457 refit_call2_wrapper(ST->ConIn->Reset, ST->ConIn, TRUE);
458 }
459 continue;
460 }
461
462 if (HaveTimeout) {
463 CurrentTime = (TimeoutCountdown + 5) / 10;
464 if (CurrentTime != PreviousTime) {
465 SPrint(TimeoutMessage, 255, L"%s in %d seconds", Screen->TimeoutText, CurrentTime);
466 if (GlobalConfig.ScreensaverTime != -1)
467 StyleFunc(Screen, &State, MENU_FUNCTION_PAINT_TIMEOUT, TimeoutMessage);
468 PreviousTime = CurrentTime;
469 }
470 }
471
472 // read key press or touch event (and wait for them if applicable)
473 if(TouchEnabled) {
474 TouchStatus = refit_call2_wrapper(TouchProtocol->GetState, TouchProtocol, &TouchState);
475 }
476 Status = refit_call2_wrapper(ST->ConIn->ReadKeyStroke, ST->ConIn, &key);
477
478 if(Status == EFI_SUCCESS) {
479 TouchActive = FALSE;
480 TimeSinceKeystroke = 0;
481 } else if (TouchStatus == EFI_SUCCESS) {
482 if (StyleFunc != MainMenuStyle) {
483 // prevent user from getting stuck on submenus
484 // (the only one currently reachable without a keyboard is the about screen)
485 MenuExit = MENU_EXIT_ENTER;
486 break;
487 }
488
489 TouchActive = TRUE;
490 TimeSinceKeystroke = 0;
491 } else {
492 EFI_EVENT WaitList[3] = { ST->ConIn->WaitForKey, NULL, NULL };
493 if (HaveTimeout && TimeoutCountdown == 0) {
494 // timeout expired
495 MenuExit = MENU_EXIT_TIMEOUT;
496 break;
497 } else if (HaveTimeout || GlobalConfig.ScreensaverTime > 0) {
498 EFI_EVENT TimerEvent;
499 UINTN ElapsCount = 1;
500
501 Status = refit_call5_wrapper(BS->CreateEvent, EVT_TIMER, 0, NULL, NULL, &TimerEvent);
502 if (EFI_ERROR(Status)) {
503 refit_call1_wrapper(BS->Stall, 100000); // Pause for 100 ms
504 } else {
505 UINTN Index;
506
507 refit_call3_wrapper(BS->SetTimer, TimerEvent, TimerRelative, 10000000); // 1s Timeout
508
509 if (TouchEnabled) {
510 WaitList[1] = TouchProtocol->WaitForInput;
511 WaitList[2] = TimerEvent;
512 Status = refit_call3_wrapper(BS->WaitForEvent, 3, WaitList, &Index);
513 } else {
514 WaitList[1] = TimerEvent;
515 Status = refit_call3_wrapper(BS->WaitForEvent, 2, WaitList, &Index);
516 }
517
518 refit_call1_wrapper(BS->CloseEvent, TimerEvent);
519 if (EFI_ERROR(Status))
520 refit_call1_wrapper(BS->Stall, 100000); // Pause for 100 ms
521 else if(Index == 0 || (TouchEnabled && Index == 1))
522 continue;
523 else
524 ElapsCount = 10; // always counted as 1s to end of the timeout
525 }
526 TimeSinceKeystroke += ElapsCount;
527 if(HaveTimeout) {
528 TimeoutCountdown = TimeoutCountdown <= ElapsCount ? 0 : TimeoutCountdown - ElapsCount;
529 } else if (GlobalConfig.ScreensaverTime > 0 &&
530 TimeSinceKeystroke > (GlobalConfig.ScreensaverTime * 10))
531 {
532 SaveScreen();
533 State.PaintAll = TRUE;
534 TimeSinceKeystroke = 0;
535 } // if
536 } else {
537 if (TouchEnabled) {
538 WaitList[1] = TouchProtocol->WaitForInput;
539 refit_call3_wrapper(BS->WaitForEvent, 2, WaitList, &index);
540 } else {
541 refit_call3_wrapper(BS->WaitForEvent, 1, WaitList, &index);
542 }
543 }
544 continue;
545 } // if/else !read keystroke
546
547 if (HaveTimeout) {
548 // the user pressed a key, cancel the timeout
549 StyleFunc(Screen, &State, MENU_FUNCTION_PAINT_TIMEOUT, L"");
550 HaveTimeout = FALSE;
551 if (GlobalConfig.ScreensaverTime == -1) { // cancel start-with-blank-screen coding
552 GlobalConfig.ScreensaverTime = 0;
553 if (!GlobalConfig.TextOnly)
554 BltClearScreen(TRUE);
555 }
556 }
557
558 if(!TouchActive) { // react to key press
559 switch (key.ScanCode) {
560 case SCAN_UP:
561 UpdateScroll(&State, SCROLL_LINE_UP);
562 break;
563 case SCAN_LEFT:
564 UpdateScroll(&State, SCROLL_LINE_LEFT);
565 break;
566 case SCAN_DOWN:
567 UpdateScroll(&State, SCROLL_LINE_DOWN);
568 break;
569 case SCAN_RIGHT:
570 UpdateScroll(&State, SCROLL_LINE_RIGHT);
571 break;
572 case SCAN_HOME:
573 UpdateScroll(&State, SCROLL_FIRST);
574 break;
575 case SCAN_END:
576 UpdateScroll(&State, SCROLL_LAST);
577 break;
578 case SCAN_PAGE_UP:
579 UpdateScroll(&State, SCROLL_PAGE_UP);
580 break;
581 case SCAN_PAGE_DOWN:
582 UpdateScroll(&State, SCROLL_PAGE_DOWN);
583 break;
584 case SCAN_ESC:
585 MenuExit = MENU_EXIT_ESCAPE;
586 break;
587 case SCAN_INSERT:
588 case SCAN_F2:
589 MenuExit = MENU_EXIT_DETAILS;
590 break;
591 case SCAN_F10:
592 egScreenShot();
593 break;
594 case 0x0016: // F12
595 if (EjectMedia())
596 MenuExit = MENU_EXIT_ESCAPE;
597 break;
598 }
599 switch (key.UnicodeChar) {
600 case CHAR_LINEFEED:
601 case CHAR_CARRIAGE_RETURN:
602 case ' ':
603 MenuExit = MENU_EXIT_ENTER;
604 break;
605 case CHAR_BACKSPACE:
606 MenuExit = MENU_EXIT_ESCAPE;
607 break;
608 case '+':
609 case CHAR_TAB:
610 MenuExit = MENU_EXIT_DETAILS;
611 break;
612 default:
613 KeyAsString[0] = key.UnicodeChar;
614 KeyAsString[1] = 0;
615 ShortcutEntry = FindMenuShortcutEntry(Screen, KeyAsString);
616 if (ShortcutEntry >= 0) {
617 State.CurrentSelection = ShortcutEntry;
618 MenuExit = MENU_EXIT_ENTER;
619 }
620 break;
621 }
622 } else { //react to touch event
623 //the TouchProtocol min/max may not match the screen size
624 TouchScreenPosX = ((UINT32) TouchState.CurrentX * UGAWidth) / (UINT32) TouchProtocol->Mode->AbsoluteMaxX;
625 TouchScreenPosY = ((UINT32) TouchState.CurrentY * UGAHeight) / (UINT32) TouchProtocol->Mode->AbsoluteMaxY;
626 Item = FindMainMenuItem(Screen, &State, TouchScreenPosX, TouchScreenPosY);
627 switch (Item) {
628 case TOUCH_NO_ITEM:
629 //do nothing
630 break;
631 case TOUCH_LEFT_ARROW:
632 UpdateScroll(&State, SCROLL_PAGE_UP);
633 break;
634 case TOUCH_RIGHT_ARROW:
635 UpdateScroll(&State, SCROLL_PAGE_DOWN);
636 break;
637 default:
638 State.CurrentSelection = Item;
639 MenuExit = MENU_EXIT_ENTER;
640 break;
641 }
642 }
643 }
644
645 StyleFunc(Screen, &State, MENU_FUNCTION_CLEANUP, NULL);
646
647 if (ChosenEntry)
648 *ChosenEntry = Screen->Entries[State.CurrentSelection];
649 *DefaultEntryIndex = State.CurrentSelection;
650 return MenuExit;
651 } /* static UINTN RunGenericMenu() */
652
653 //
654 // text-mode generic style
655 //
656
657 // Show information lines in text mode.
658 static VOID ShowTextInfoLines(IN REFIT_MENU_SCREEN *Screen) {
659 INTN i;
660
661 BeginTextScreen(Screen->Title);
662 if (Screen->InfoLineCount > 0) {
663 refit_call2_wrapper(ST->ConOut->SetAttribute, ST->ConOut, ATTR_BASIC);
664 for (i = 0; i < (INTN)Screen->InfoLineCount; i++) {
665 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 3, 4 + i);
666 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, Screen->InfoLines[i]);
667 }
668 }
669 } // VOID ShowTextInfoLines()
670
671 // Do most of the work for text-based menus....
672 static VOID TextMenuStyle(IN REFIT_MENU_SCREEN *Screen, IN SCROLL_STATE *State, IN UINTN Function, IN CHAR16 *ParamText)
673 {
674 INTN i;
675 UINTN MenuWidth, ItemWidth, MenuHeight;
676 static UINTN MenuPosY;
677 static CHAR16 **DisplayStrings;
678 CHAR16 TimeoutMessage[256];
679
680 State->ScrollMode = SCROLL_MODE_TEXT;
681 switch (Function) {
682
683 case MENU_FUNCTION_INIT:
684 // vertical layout
685 MenuPosY = 4;
686 if (Screen->InfoLineCount > 0)
687 MenuPosY += Screen->InfoLineCount + 1;
688 MenuHeight = ConHeight - MenuPosY - 3;
689 if (Screen->TimeoutSeconds > 0)
690 MenuHeight -= 2;
691 InitScroll(State, Screen->EntryCount, MenuHeight);
692
693 // determine width of the menu
694 MenuWidth = 20; // minimum
695 for (i = 0; i <= State->MaxIndex; i++) {
696 ItemWidth = StrLen(Screen->Entries[i]->Title);
697 if (MenuWidth < ItemWidth)
698 MenuWidth = ItemWidth;
699 }
700 MenuWidth += 2;
701 if (MenuWidth > ConWidth - 3)
702 MenuWidth = ConWidth - 3;
703
704 // prepare strings for display
705 DisplayStrings = AllocatePool(sizeof(CHAR16 *) * Screen->EntryCount);
706 for (i = 0; i <= State->MaxIndex; i++) {
707 // Note: Theoretically, SPrint() is a cleaner way to do this; but the
708 // description of the StrSize parameter to SPrint implies it's measured
709 // in characters, but in practice both TianoCore and GNU-EFI seem to
710 // use bytes instead, resulting in truncated displays. I could just
711 // double the size of the StrSize parameter, but that seems unsafe in
712 // case a future library change starts treating this as characters, so
713 // I'm doing it the hard way in this instance.
714 // TODO: Review the above and possibly change other uses of SPrint()
715 DisplayStrings[i] = AllocateZeroPool(2 * sizeof(CHAR16));
716 DisplayStrings[i][0] = L' ';
717 MergeStrings(&DisplayStrings[i], Screen->Entries[i]->Title, 0);
718 if (StrLen(DisplayStrings[i]) > MenuWidth)
719 DisplayStrings[i][MenuWidth - 1] = 0;
720 // TODO: use more elaborate techniques for shortening too long strings (ellipses in the middle)
721 // TODO: account for double-width characters
722 } // for
723
724 break;
725
726 case MENU_FUNCTION_CLEANUP:
727 // release temporary memory
728 for (i = 0; i <= State->MaxIndex; i++)
729 MyFreePool(DisplayStrings[i]);
730 MyFreePool(DisplayStrings);
731 break;
732
733 case MENU_FUNCTION_PAINT_ALL:
734 // paint the whole screen (initially and after scrolling)
735
736 ShowTextInfoLines(Screen);
737 for (i = 0; i <= State->MaxIndex; i++) {
738 if (i >= State->FirstVisible && i <= State->LastVisible) {
739 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 2, MenuPosY + (i - State->FirstVisible));
740 if (i == State->CurrentSelection)
741 refit_call2_wrapper(ST->ConOut->SetAttribute, ST->ConOut, ATTR_CHOICE_CURRENT);
742 else
743 refit_call2_wrapper(ST->ConOut->SetAttribute, ST->ConOut, ATTR_CHOICE_BASIC);
744 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, DisplayStrings[i]);
745 }
746 }
747 // scrolling indicators
748 refit_call2_wrapper(ST->ConOut->SetAttribute, ST->ConOut, ATTR_SCROLLARROW);
749 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 0, MenuPosY);
750 if (State->FirstVisible > 0)
751 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, ArrowUp);
752 else
753 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, L" ");
754 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 0, MenuPosY + State->MaxVisible);
755 if (State->LastVisible < State->MaxIndex)
756 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, ArrowDown);
757 else
758 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, L" ");
759 if (!(GlobalConfig.HideUIFlags & HIDEUI_FLAG_HINTS)) {
760 if (Screen->Hint1 != NULL) {
761 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 0, ConHeight - 2);
762 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, Screen->Hint1);
763 }
764 if (Screen->Hint2 != NULL) {
765 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 0, ConHeight - 1);
766 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, Screen->Hint2);
767 }
768 }
769 break;
770
771 case MENU_FUNCTION_PAINT_SELECTION:
772 // redraw selection cursor
773 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 2,
774 MenuPosY + (State->PreviousSelection - State->FirstVisible));
775 refit_call2_wrapper(ST->ConOut->SetAttribute, ST->ConOut, ATTR_CHOICE_BASIC);
776 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, DisplayStrings[State->PreviousSelection]);
777 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 2,
778 MenuPosY + (State->CurrentSelection - State->FirstVisible));
779 refit_call2_wrapper(ST->ConOut->SetAttribute, ST->ConOut, ATTR_CHOICE_CURRENT);
780 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, DisplayStrings[State->CurrentSelection]);
781 break;
782
783 case MENU_FUNCTION_PAINT_TIMEOUT:
784 if (ParamText[0] == 0) {
785 // clear message
786 refit_call2_wrapper(ST->ConOut->SetAttribute, ST->ConOut, ATTR_BASIC);
787 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 0, ConHeight - 3);
788 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, BlankLine + 1);
789 } else {
790 // paint or update message
791 refit_call2_wrapper(ST->ConOut->SetAttribute, ST->ConOut, ATTR_ERROR);
792 refit_call3_wrapper(ST->ConOut->SetCursorPosition, ST->ConOut, 3, ConHeight - 3);
793 SPrint(TimeoutMessage, 255, L"%s ", ParamText);
794 refit_call2_wrapper(ST->ConOut->OutputString, ST->ConOut, TimeoutMessage);
795 }
796 break;
797
798 }
799 }
800
801 //
802 // graphical generic style
803 //
804
805 inline static UINTN TextLineHeight(VOID) {
806 return egGetFontHeight() + TEXT_YMARGIN * 2;
807 } // UINTN TextLineHeight()
808
809 //
810 // Display a submenu
811 //
812
813 // Display text with a solid background (MenuBackgroundPixel or SelectionBackgroundPixel).
814 // Indents text by one character and placed TEXT_YMARGIN pixels down from the
815 // specified XPos and YPos locations.
816 static VOID DrawText(IN CHAR16 *Text, IN BOOLEAN Selected, IN UINTN FieldWidth, IN UINTN XPos, IN UINTN YPos)
817 {
818 EG_IMAGE *TextBuffer;
819 EG_PIXEL Bg;
820
821 TextBuffer = egCreateImage(FieldWidth, TextLineHeight(), FALSE);
822
823 egFillImage(TextBuffer, &MenuBackgroundPixel);
824 Bg = MenuBackgroundPixel;
825 if (Selected) {
826 // draw selection bar background
827 egFillImageArea(TextBuffer, 0, 0, FieldWidth, TextBuffer->Height, &SelectionBackgroundPixel);
828 Bg = SelectionBackgroundPixel;
829 }
830
831 // render the text
832 egRenderText(Text, TextBuffer, egGetFontCellWidth(), TEXT_YMARGIN, (Bg.r + Bg.g + Bg.b) / 3);
833 egDrawImageWithTransparency(TextBuffer, NULL, XPos, YPos, TextBuffer->Width, TextBuffer->Height);
834 // BltImage(TextBuffer, XPos, YPos);
835 }
836
837 // Finds the average brightness of the input Image.
838 // NOTE: Passing an Image that covers the whole screen can strain the
839 // capacity of a UINTN on a 32-bit system with a very large display.
840 // Using UINT64 instead is unworkable, since the code won't compile
841 // on a 32-bit system. As the intended use for this function is to handle
842 // a single text string's background, this shouldn't be a problem, but it
843 // may need addressing if it's applied more broadly....
844 static UINT8 AverageBrightness(EG_IMAGE *Image) {
845 UINTN i;
846 UINTN Sum = 0;
847
848 if ((Image != NULL) && ((Image->Width * Image->Height) != 0)) {
849 for (i = 0; i < (Image->Width * Image->Height); i++) {
850 Sum += (Image->PixelData[i].r + Image->PixelData[i].g + Image->PixelData[i].b);
851 }
852 Sum /= (Image->Width * Image->Height * 3);
853 } // if
854 return (UINT8) Sum;
855 } // UINT8 AverageBrightness()
856
857 // Display text against the screen's background image. Special case: If Text is NULL
858 // or 0-length, clear the line. Does NOT indent the text or reposition it relative
859 // to the specified XPos and YPos values.
860 static VOID DrawTextWithTransparency(IN CHAR16 *Text, IN UINTN XPos, IN UINTN YPos)
861 {
862 UINTN TextWidth;
863 EG_IMAGE *TextBuffer = NULL;
864
865 if (Text == NULL)
866 Text = L"";
867
868 egMeasureText(Text, &TextWidth, NULL);
869 if (TextWidth == 0) {
870 TextWidth = UGAWidth;
871 XPos = 0;
872 }
873
874 TextBuffer = egCropImage(GlobalConfig.ScreenBackground, XPos, YPos, TextWidth, TextLineHeight());
875 if (TextBuffer == NULL)
876 return;
877
878 // render the text
879 egRenderText(Text, TextBuffer, 0, 0, AverageBrightness(TextBuffer));
880 egDrawImageWithTransparency(TextBuffer, NULL, XPos, YPos, TextBuffer->Width, TextBuffer->Height);
881 egFreeImage(TextBuffer);
882 }
883
884 // Compute the size & position of the window that will hold a subscreen's information.
885 static VOID ComputeSubScreenWindowSize(REFIT_MENU_SCREEN *Screen, IN SCROLL_STATE *State, UINTN *XPos, UINTN *YPos,
886 UINTN *Width, UINTN *Height, UINTN *LineWidth) {
887 UINTN i, ItemWidth, HintTop, BannerBottomEdge, TitleWidth;
888 UINTN FontCellWidth = egGetFontCellWidth();
889 UINTN FontCellHeight = egGetFontHeight();
890
891 *Width = 20;
892 *Height = 5;
893 TitleWidth = egComputeTextWidth(Screen->Title);
894
895 for (i = 0; i < Screen->InfoLineCount; i++) {
896 ItemWidth = StrLen(Screen->InfoLines[i]);
897 if (*Width < ItemWidth) {
898 *Width = ItemWidth;
899 }
900 (*Height)++;
901 }
902 for (i = 0; i <= State->MaxIndex; i++) {
903 ItemWidth = StrLen(Screen->Entries[i]->Title);
904 if (*Width < ItemWidth) {
905 *Width = ItemWidth;
906 }
907 (*Height)++;
908 }
909 *Width = (*Width + 2) * FontCellWidth;
910 *LineWidth = *Width;
911 if (Screen->TitleImage)
912 *Width += (Screen->TitleImage->Width + TITLEICON_SPACING * 2 + FontCellWidth);
913 else
914 *Width += FontCellWidth;
915
916 if (*Width < TitleWidth)
917 *Width = TitleWidth + 2 * FontCellWidth;
918
919 // Keep it within the bounds of the screen, or 2/3 of the screen's width
920 // for screens over 800 pixels wide
921 if (*Width > UGAWidth)
922 *Width = UGAWidth;
923
924 *XPos = (UGAWidth - *Width) / 2;
925
926 HintTop = UGAHeight - (FontCellHeight * 3); // top of hint text
927 *Height *= TextLineHeight();
928 if (Screen->TitleImage && (*Height < (Screen->TitleImage->Height + TextLineHeight() * 4)))
929 *Height = Screen->TitleImage->Height + TextLineHeight() * 4;
930
931 if (GlobalConfig.BannerBottomEdge >= HintTop) { // probably a full-screen image; treat it as an empty banner
932 BannerBottomEdge = 0;
933 } else {
934 BannerBottomEdge = GlobalConfig.BannerBottomEdge;
935 }
936 if (*Height > (HintTop - BannerBottomEdge - FontCellHeight * 2)) {
937 BannerBottomEdge = 0;
938 }
939 if (*Height > (HintTop - BannerBottomEdge - FontCellHeight * 2)) {
940 // TODO: Implement scrolling in text screen.
941 *Height = (HintTop - BannerBottomEdge - FontCellHeight * 2);
942 }
943
944 *YPos = ((UGAHeight - *Height) / 2);
945 if (*YPos < BannerBottomEdge)
946 *YPos = BannerBottomEdge + FontCellHeight + (HintTop - BannerBottomEdge - *Height) / 2;
947 } // VOID ComputeSubScreenWindowSize()
948
949 // Displays sub-menus
950 static VOID GraphicsMenuStyle(IN REFIT_MENU_SCREEN *Screen, IN SCROLL_STATE *State, IN UINTN Function, IN CHAR16 *ParamText)
951 {
952 INTN i;
953 UINTN ItemWidth;
954 static UINTN LineWidth, MenuWidth, MenuHeight, EntriesPosX, TitlePosX, EntriesPosY, TimeoutPosY, CharWidth;
955 EG_IMAGE *Window;
956 EG_PIXEL *BackgroundPixel = &(GlobalConfig.ScreenBackground->PixelData[0]);
957
958 CharWidth = egGetFontCellWidth();
959 State->ScrollMode = SCROLL_MODE_TEXT;
960 switch (Function) {
961
962 case MENU_FUNCTION_INIT:
963 InitScroll(State, Screen->EntryCount, 0);
964 ComputeSubScreenWindowSize(Screen, State, &EntriesPosX, &EntriesPosY, &MenuWidth, &MenuHeight, &LineWidth);
965 TimeoutPosY = EntriesPosY + (Screen->EntryCount + 1) * TextLineHeight();
966
967 // initial painting
968 SwitchToGraphicsAndClear();
969 Window = egCreateFilledImage(MenuWidth, MenuHeight, FALSE, BackgroundPixel);
970 egDrawImage(Window, EntriesPosX, EntriesPosY);
971 ItemWidth = egComputeTextWidth(Screen->Title);
972 if (MenuWidth > ItemWidth) {
973 TitlePosX = EntriesPosX + (MenuWidth - ItemWidth) / 2 - CharWidth;
974 } else {
975 TitlePosX = EntriesPosX;
976 if (CharWidth > 0) {
977 i = MenuWidth / CharWidth - 2;
978 if (i > 0)
979 Screen->Title[i] = 0;
980 } // if
981 } // if/else
982 break;
983
984 case MENU_FUNCTION_CLEANUP:
985 // nothing to do
986 break;
987
988 case MENU_FUNCTION_PAINT_ALL:
989 ComputeSubScreenWindowSize(Screen, State, &EntriesPosX, &EntriesPosY, &MenuWidth, &MenuHeight, &LineWidth);
990 DrawText(Screen->Title, FALSE, (StrLen(Screen->Title) + 2) * CharWidth, TitlePosX, EntriesPosY += TextLineHeight());
991 if (Screen->TitleImage) {
992 BltImageAlpha(Screen->TitleImage, EntriesPosX + TITLEICON_SPACING, EntriesPosY + TextLineHeight() * 2,
993 BackgroundPixel);
994 EntriesPosX += (Screen->TitleImage->Width + TITLEICON_SPACING * 2);
995 }
996 EntriesPosY += (TextLineHeight() * 2);
997 if (Screen->InfoLineCount > 0) {
998 for (i = 0; i < (INTN)Screen->InfoLineCount; i++) {
999 DrawText(Screen->InfoLines[i], FALSE, LineWidth, EntriesPosX, EntriesPosY);
1000 EntriesPosY += TextLineHeight();
1001 }
1002 EntriesPosY += TextLineHeight(); // also add a blank line
1003 }
1004
1005 for (i = 0; i <= State->MaxIndex; i++) {
1006 DrawText(Screen->Entries[i]->Title, (i == State->CurrentSelection), LineWidth, EntriesPosX,
1007 EntriesPosY + i * TextLineHeight());
1008 }
1009 if (!(GlobalConfig.HideUIFlags & HIDEUI_FLAG_HINTS)) {
1010 if ((Screen->Hint1 != NULL) && (StrLen(Screen->Hint1) > 0))
1011 DrawTextWithTransparency(Screen->Hint1, (UGAWidth - egComputeTextWidth(Screen->Hint1)) / 2,
1012 UGAHeight - (egGetFontHeight() * 3));
1013 if ((Screen->Hint2 != NULL) && (StrLen(Screen->Hint2) > 0))
1014 DrawTextWithTransparency(Screen->Hint2, (UGAWidth - egComputeTextWidth(Screen->Hint2)) / 2,
1015 UGAHeight - (egGetFontHeight() * 2));
1016 } // if
1017 break;
1018
1019 case MENU_FUNCTION_PAINT_SELECTION:
1020 // redraw selection cursor
1021 DrawText(Screen->Entries[State->PreviousSelection]->Title, FALSE, LineWidth,
1022 EntriesPosX, EntriesPosY + State->PreviousSelection * TextLineHeight());
1023 DrawText(Screen->Entries[State->CurrentSelection]->Title, TRUE, LineWidth,
1024 EntriesPosX, EntriesPosY + State->CurrentSelection * TextLineHeight());
1025 break;
1026
1027 case MENU_FUNCTION_PAINT_TIMEOUT:
1028 DrawText(ParamText, FALSE, LineWidth, EntriesPosX, TimeoutPosY);
1029 break;
1030
1031 }
1032 } // static VOID GraphicsMenuStyle()
1033
1034 //
1035 // graphical main menu style
1036 //
1037
1038 static VOID DrawMainMenuEntry(REFIT_MENU_ENTRY *Entry, BOOLEAN selected, UINTN XPos, UINTN YPos)
1039 {
1040 EG_IMAGE *Background;
1041
1042 // don't draw selection image if using touch
1043 if (selected && !TouchActive) {
1044 Background = egCropImage(GlobalConfig.ScreenBackground, XPos, YPos,
1045 SelectionImages[Entry->Row]->Width, SelectionImages[Entry->Row]->Height);
1046 egComposeImage(Background, SelectionImages[Entry->Row], 0, 0);
1047 BltImageCompositeBadge(Background, Entry->Image, Entry->BadgeImage, XPos, YPos);
1048 } else { // Image not selected; copy background
1049 egDrawImageWithTransparency(Entry->Image, Entry->BadgeImage, XPos, YPos,
1050 SelectionImages[Entry->Row]->Width, SelectionImages[Entry->Row]->Height);
1051 } // if/else
1052 } // VOID DrawMainMenuEntry()
1053
1054 static VOID PaintAll(IN REFIT_MENU_SCREEN *Screen, IN SCROLL_STATE *State, UINTN *itemPosX,
1055 UINTN row0PosY, UINTN row1PosY, UINTN textPosY) {
1056 INTN i;
1057
1058 if (Screen->Entries[State->CurrentSelection]->Row == 0)
1059 AdjustScrollState(State);
1060 for (i = State->FirstVisible; i <= State->MaxIndex; i++) {
1061 if (Screen->Entries[i]->Row == 0) {
1062 if (i <= State->LastVisible) {
1063 DrawMainMenuEntry(Screen->Entries[i], (i == State->CurrentSelection) ? TRUE : FALSE,
1064 itemPosX[i - State->FirstVisible], row0PosY);
1065 } // if
1066 } else {
1067 DrawMainMenuEntry(Screen->Entries[i], (i == State->CurrentSelection) ? TRUE : FALSE, itemPosX[i], row1PosY);
1068 }
1069 }
1070 if (!(GlobalConfig.HideUIFlags & HIDEUI_FLAG_LABEL)) {
1071 DrawTextWithTransparency(L"", 0, textPosY);
1072 DrawTextWithTransparency(Screen->Entries[State->CurrentSelection]->Title,
1073 (UGAWidth - egComputeTextWidth(Screen->Entries[State->CurrentSelection]->Title)) >> 1,
1074 textPosY);
1075 }
1076
1077 if (!(GlobalConfig.HideUIFlags & HIDEUI_FLAG_HINTS)) {
1078 DrawTextWithTransparency(Screen->Hint1, (UGAWidth - egComputeTextWidth(Screen->Hint1)) / 2,
1079 UGAHeight - (egGetFontHeight() * 3));
1080 DrawTextWithTransparency(Screen->Hint2, (UGAWidth - egComputeTextWidth(Screen->Hint2)) / 2,
1081 UGAHeight - (egGetFontHeight() * 2));
1082 } // if
1083 } // static VOID PaintAll()
1084
1085 // Move the selection to State->CurrentSelection, adjusting icon row if necessary...
1086 static VOID PaintSelection(IN REFIT_MENU_SCREEN *Screen, IN SCROLL_STATE *State, UINTN *itemPosX,
1087 UINTN row0PosY, UINTN row1PosY, UINTN textPosY) {
1088 UINTN XSelectPrev, XSelectCur, YPosPrev, YPosCur;
1089
1090 if (((State->CurrentSelection <= State->LastVisible) && (State->CurrentSelection >= State->FirstVisible)) ||
1091 (State->CurrentSelection >= State->InitialRow1) ) {
1092 if (Screen->Entries[State->PreviousSelection]->Row == 0) {
1093 XSelectPrev = State->PreviousSelection - State->FirstVisible;
1094 YPosPrev = row0PosY;
1095 } else {
1096 XSelectPrev = State->PreviousSelection;
1097 YPosPrev = row1PosY;
1098 } // if/else
1099 if (Screen->Entries[State->CurrentSelection]->Row == 0) {
1100 XSelectCur = State->CurrentSelection - State->FirstVisible;
1101 YPosCur = row0PosY;
1102 } else {
1103 XSelectCur = State->CurrentSelection;
1104 YPosCur = row1PosY;
1105 } // if/else
1106 DrawMainMenuEntry(Screen->Entries[State->PreviousSelection], FALSE, itemPosX[XSelectPrev], YPosPrev);
1107 DrawMainMenuEntry(Screen->Entries[State->CurrentSelection], TRUE, itemPosX[XSelectCur], YPosCur);
1108 if (!(GlobalConfig.HideUIFlags & HIDEUI_FLAG_LABEL)) {
1109 DrawTextWithTransparency(L"", 0, textPosY);
1110 DrawTextWithTransparency(Screen->Entries[State->CurrentSelection]->Title,
1111 (UGAWidth - egComputeTextWidth(Screen->Entries[State->CurrentSelection]->Title)) >> 1,
1112 textPosY);
1113 }
1114 } else { // Current selection not visible; must redraw the menu....
1115 MainMenuStyle(Screen, State, MENU_FUNCTION_PAINT_ALL, NULL);
1116 }
1117 } // static VOID MoveSelection(VOID)
1118
1119 // Display a 48x48 icon at the specified location. Uses the image specified by
1120 // ExternalFilename if it's available, or BuiltInImage if it's not. The
1121 // Y position is specified as the center value, and so is adjusted by half
1122 // the icon's height. The X position is set along the icon's left
1123 // edge if Alignment == ALIGN_LEFT, and along the right edge if
1124 // Alignment == ALIGN_RIGHT
1125 static VOID PaintIcon(IN EG_EMBEDDED_IMAGE *BuiltInIcon, IN CHAR16 *ExternalFilename, UINTN PosX, UINTN PosY, UINTN Alignment) {
1126 EG_IMAGE *Icon = NULL;
1127
1128 Icon = egFindIcon(ExternalFilename, GlobalConfig.IconSizes[ICON_SIZE_SMALL]);
1129 if (Icon == NULL)
1130 Icon = egPrepareEmbeddedImage(BuiltInIcon, TRUE);
1131 if (Icon != NULL) {
1132 if (Alignment == ALIGN_RIGHT)
1133 PosX -= Icon->Width;
1134 egDrawImageWithTransparency(Icon, NULL, PosX, PosY - (Icon->Height / 2), Icon->Width, Icon->Height);
1135 }
1136 } // static VOID ()
1137
1138 UINTN ComputeRow0PosY(VOID) {
1139 return ((UGAHeight / 2) - TileSizes[0] / 2);
1140 } // UINTN ComputeRow0PosY()
1141
1142 // Display (or erase) the arrow icons to the left and right of an icon's row,
1143 // as appropriate.
1144 static VOID PaintArrows(SCROLL_STATE *State, UINTN PosX, UINTN PosY, UINTN row0Loaders) {
1145 EG_IMAGE *TempImage;
1146 UINTN Width, Height, RightX, AdjPosY;
1147
1148 // NOTE: Assume that left and right arrows are of the same size....
1149 Width = egemb_arrow_left.Width;
1150 Height = egemb_arrow_left.Height;
1151 RightX = (UGAWidth + (TileSizes[0] + TILE_XSPACING) * State->MaxVisible) / 2 + TILE_XSPACING;
1152 AdjPosY = PosY - (Height / 2);
1153
1154 // For PaintIcon() calls, the starting Y position is moved to the midpoint
1155 // of the surrounding row; PaintIcon() adjusts this back up by half the
1156 // icon's height to properly center it.
1157 if ((State->FirstVisible > 0) && (!(GlobalConfig.HideUIFlags & HIDEUI_FLAG_ARROWS))) {
1158 PaintIcon(&egemb_arrow_left, L"arrow_left", PosX, PosY, ALIGN_RIGHT);
1159 } else {
1160 TempImage = egCropImage(GlobalConfig.ScreenBackground, PosX - Width, AdjPosY, Width, Height);
1161 BltImage(TempImage, PosX - Width, AdjPosY);
1162 egFreeImage(TempImage);
1163 } // if/else
1164
1165 if ((State->LastVisible < (row0Loaders - 1)) && (!(GlobalConfig.HideUIFlags & HIDEUI_FLAG_ARROWS))) {
1166 PaintIcon(&egemb_arrow_right, L"arrow_right", RightX, PosY, ALIGN_LEFT);
1167 } else {
1168 TempImage = egCropImage(GlobalConfig.ScreenBackground, RightX, AdjPosY, Width, Height);
1169 BltImage(TempImage, RightX, AdjPosY);
1170 egFreeImage(TempImage);
1171 } // if/else
1172 } // VOID PaintArrows()
1173
1174 // Display main menu in graphics mode
1175 VOID MainMenuStyle(IN REFIT_MENU_SCREEN *Screen, IN SCROLL_STATE *State, IN UINTN Function, IN CHAR16 *ParamText)
1176 {
1177 INTN i;
1178 static UINTN row0PosX, row0PosXRunning, row1PosY, row0Loaders;
1179 UINTN row0Count, row1Count, row1PosX, row1PosXRunning;
1180 static UINTN *itemPosX;
1181 static UINTN row0PosY, textPosY;
1182
1183 State->ScrollMode = SCROLL_MODE_ICONS;
1184 switch (Function) {
1185
1186 case MENU_FUNCTION_INIT:
1187 InitScroll(State, Screen->EntryCount, GlobalConfig.MaxTags);
1188
1189 // layout
1190 row0Count = 0;
1191 row1Count = 0;
1192 row0Loaders = 0;
1193 for (i = 0; i <= State->MaxIndex; i++) {
1194 if (Screen->Entries[i]->Row == 1) {
1195 row1Count++;
1196 } else {
1197 row0Loaders++;
1198 if (row0Count < State->MaxVisible)
1199 row0Count++;
1200 }
1201 }
1202 row0PosX = (UGAWidth + TILE_XSPACING - (TileSizes[0] + TILE_XSPACING) * row0Count) >> 1;
1203 row0PosY = ComputeRow0PosY();
1204 row1PosX = (UGAWidth + TILE_XSPACING - (TileSizes[1] + TILE_XSPACING) * row1Count) >> 1;
1205 row1PosY = row0PosY + TileSizes[0] + TILE_YSPACING;
1206 if (row1Count > 0)
1207 textPosY = row1PosY + TileSizes[1] + TILE_YSPACING;
1208 else
1209 textPosY = row1PosY;
1210
1211 itemPosX = AllocatePool(sizeof(UINTN) * Screen->EntryCount);
1212 row0PosXRunning = row0PosX;
1213 row1PosXRunning = row1PosX;
1214 for (i = 0; i <= State->MaxIndex; i++) {
1215 if (Screen->Entries[i]->Row == 0) {
1216 itemPosX[i] = row0PosXRunning;
1217 row0PosXRunning += TileSizes[0] + TILE_XSPACING;
1218 } else {
1219 itemPosX[i] = row1PosXRunning;
1220 row1PosXRunning += TileSizes[1] + TILE_XSPACING;
1221 }
1222 }
1223 // initial painting
1224 InitSelection();
1225 SwitchToGraphicsAndClear();
1226 break;
1227
1228 case MENU_FUNCTION_CLEANUP:
1229 MyFreePool(itemPosX);
1230 break;
1231
1232 case MENU_FUNCTION_PAINT_ALL:
1233 PaintAll(Screen, State, itemPosX, row0PosY, row1PosY, textPosY);
1234 // For PaintArrows(), the starting Y position is moved to the midpoint
1235 // of the surrounding row; PaintIcon() adjusts this back up by half the
1236 // icon's height to properly center it.
1237 PaintArrows(State, row0PosX - TILE_XSPACING, row0PosY + (TileSizes[0] / 2), row0Loaders);
1238 break;
1239
1240 case MENU_FUNCTION_PAINT_SELECTION:
1241 PaintSelection(Screen, State, itemPosX, row0PosY, row1PosY, textPosY);
1242 break;
1243
1244 case MENU_FUNCTION_PAINT_TIMEOUT:
1245 if (!(GlobalConfig.HideUIFlags & HIDEUI_FLAG_LABEL)) {
1246 DrawTextWithTransparency(L"", 0, textPosY + TextLineHeight());
1247 DrawTextWithTransparency(ParamText, (UGAWidth - egComputeTextWidth(ParamText)) >> 1, textPosY + TextLineHeight());
1248 }
1249 break;
1250
1251 }
1252 } // VOID MainMenuStyle()
1253
1254 // Determines the index of the main menu item at the given coordinates.
1255 UINTN FindMainMenuItem(IN REFIT_MENU_SCREEN *Screen, IN SCROLL_STATE *State, IN UINT64 PosX, IN UINT64 PosY)
1256 {
1257 UINTN i;
1258 static UINTN row0PosX, row0PosXRunning, row1PosY, row0Loaders;
1259 UINTN row0Count, row1Count, row1PosX, row1PosXRunning;
1260 static UINTN *itemPosX;
1261 static UINTN row0PosY;
1262 UINTN itemRow;
1263
1264 row0Count = 0;
1265 row1Count = 0;
1266 row0Loaders = 0;
1267 for (i = 0; i <= State->MaxIndex; i++) {
1268 if (Screen->Entries[i]->Row == 1) {
1269 row1Count++;
1270 } else {
1271 row0Loaders++;
1272 if (row0Count < State->MaxVisible)
1273 row0Count++;
1274 }
1275 }
1276 row0PosX = (UGAWidth + TILE_XSPACING - (TileSizes[0] + TILE_XSPACING) * row0Count) >> 1;
1277 row0PosY = ComputeRow0PosY();
1278 row1PosX = (UGAWidth + TILE_XSPACING - (TileSizes[1] + TILE_XSPACING) * row1Count) >> 1;
1279 row1PosY = row0PosY + TileSizes[0] + TILE_YSPACING;
1280
1281 if(PosY >= row0PosY && PosY <= row0PosY + TileSizes[0]) {
1282 itemRow = 0;
1283 if(PosX <= row0PosX) {
1284 return TOUCH_LEFT_ARROW;
1285 }
1286 else if(PosX >= (UGAWidth - row0PosX)) {
1287 return TOUCH_RIGHT_ARROW;
1288 }
1289 } else if(PosY >= row1PosY && PosY <= row1PosY + TileSizes[1]) {
1290 itemRow = 1;
1291 } else { // Y coordinate is outside of either row
1292 return TOUCH_NO_ITEM;
1293 }
1294
1295 UINTN ItemIndex = TOUCH_NO_ITEM;
1296
1297 itemPosX = AllocatePool(sizeof(UINTN) * Screen->EntryCount);
1298 row0PosXRunning = row0PosX;
1299 row1PosXRunning = row1PosX;
1300 for (i = 0; i <= State->MaxIndex; i++) {
1301 if (Screen->Entries[i]->Row == 0) {
1302 itemPosX[i] = row0PosXRunning;
1303 row0PosXRunning += TileSizes[0] + TILE_XSPACING;
1304 } else {
1305 itemPosX[i] = row1PosXRunning;
1306 row1PosXRunning += TileSizes[1] + TILE_XSPACING;
1307 }
1308 }
1309
1310 for (i = State->FirstVisible; i <= State->MaxIndex; i++) {
1311 if (Screen->Entries[i]->Row == 0 && itemRow == 0) {
1312 if (i <= State->LastVisible) {
1313 if(PosX >= itemPosX[i - State->FirstVisible] && PosX <= itemPosX[i - State->FirstVisible] + TileSizes[0]) {
1314 ItemIndex = i;
1315 break;
1316 }
1317 } // if
1318 } else if (Screen->Entries[i]->Row == 1 && itemRow == 1) {
1319 if(PosX >= itemPosX[i] && PosX <= itemPosX[i] + TileSizes[1]) {
1320 ItemIndex = i;
1321 break;
1322 }
1323 }
1324 }
1325
1326 MyFreePool(itemPosX);
1327
1328 return ItemIndex;
1329 } // VOID FindMainMenuItem()
1330
1331 // Enable the user to edit boot loader options.
1332 // Returns TRUE if the user exited with edited options; FALSE if the user
1333 // pressed Esc to terminate the edit.
1334 static BOOLEAN EditOptions(LOADER_ENTRY *MenuEntry) {
1335 UINTN x_max, y_max;
1336 CHAR16 *EditedOptions;
1337 BOOLEAN retval = FALSE;
1338
1339 if (GlobalConfig.HideUIFlags & HIDEUI_FLAG_EDITOR) {
1340 return FALSE;
1341 }
1342
1343 refit_call4_wrapper(ST->ConOut->QueryMode, ST->ConOut, ST->ConOut->Mode->Mode, &x_max, &y_max);
1344
1345 if (!GlobalConfig.TextOnly)
1346 SwitchToText(TRUE);
1347
1348 if (line_edit(MenuEntry->LoadOptions, &EditedOptions, x_max)) {
1349 MyFreePool(MenuEntry->LoadOptions);
1350 MenuEntry->LoadOptions = EditedOptions;
1351 retval = TRUE;
1352 } // if
1353 if (!GlobalConfig.TextOnly)
1354 SwitchToGraphics();
1355 return retval;
1356 } // VOID EditOptions()
1357
1358 //
1359 // user-callable dispatcher functions
1360 //
1361
1362 UINTN RunMenu(IN REFIT_MENU_SCREEN *Screen, OUT REFIT_MENU_ENTRY **ChosenEntry)
1363 {
1364 INTN DefaultEntry = -1;
1365 MENU_STYLE_FUNC Style = TextMenuStyle;
1366
1367 if (AllowGraphicsMode)
1368 Style = GraphicsMenuStyle;
1369
1370 return RunGenericMenu(Screen, Style, &DefaultEntry, ChosenEntry);
1371 }
1372
1373 UINTN RunMainMenu(REFIT_MENU_SCREEN *Screen, CHAR16** DefaultSelection, REFIT_MENU_ENTRY **ChosenEntry)
1374 {
1375 MENU_STYLE_FUNC Style = TextMenuStyle;
1376 MENU_STYLE_FUNC MainStyle = TextMenuStyle;
1377 REFIT_MENU_ENTRY *TempChosenEntry;
1378 CHAR16 *MenuTitle;
1379 UINTN MenuExit = 0;
1380 INTN DefaultEntryIndex = -1;
1381 INTN DefaultSubmenuIndex = -1;
1382
1383 TileSizes[0] = (GlobalConfig.IconSizes[ICON_SIZE_BIG] * 9) / 8;
1384 TileSizes[1] = (GlobalConfig.IconSizes[ICON_SIZE_SMALL] * 4) / 3;
1385
1386 if ((DefaultSelection != NULL) && (*DefaultSelection != NULL)) {
1387 // Find a menu entry that includes *DefaultSelection as a substring
1388 DefaultEntryIndex = FindMenuShortcutEntry(Screen, *DefaultSelection);
1389 }
1390
1391 if (AllowGraphicsMode) {
1392 Style = GraphicsMenuStyle;
1393 MainStyle = MainMenuStyle;
1394 if (GlobalConfig.EnableTouch) {
1395 // Check for touch availability
1396 EFI_STATUS status = refit_call3_wrapper(BS->LocateProtocol, &TouchGuid, NULL, (VOID **) &TouchProtocol);
1397 if (status == EFI_SUCCESS) {
1398 TouchEnabled = TouchActive = TRUE;
1399 }
1400 }
1401 }
1402
1403 while (!MenuExit) {
1404 MenuExit = RunGenericMenu(Screen, MainStyle, &DefaultEntryIndex, &TempChosenEntry);
1405 Screen->TimeoutSeconds = 0;
1406
1407 MenuTitle = StrDuplicate(TempChosenEntry->Title);
1408 if (MenuExit == MENU_EXIT_DETAILS) {
1409 if (TempChosenEntry->SubScreen != NULL) {
1410 MenuExit = RunGenericMenu(TempChosenEntry->SubScreen, Style, &DefaultSubmenuIndex, &TempChosenEntry);
1411 if (MenuExit == MENU_EXIT_ESCAPE || TempChosenEntry->Tag == TAG_RETURN)
1412 MenuExit = 0;
1413 if (MenuExit == MENU_EXIT_DETAILS) {
1414 if (!EditOptions((LOADER_ENTRY *) TempChosenEntry))
1415 MenuExit = 0;
1416 } // if
1417 } else { // no sub-screen; ignore keypress
1418 MenuExit = 0;
1419 }
1420 } // Enter sub-screen
1421 }
1422
1423 if (ChosenEntry)
1424 *ChosenEntry = TempChosenEntry;
1425 if (DefaultSelection) {
1426 MyFreePool(*DefaultSelection);
1427 *DefaultSelection = MenuTitle;
1428 } // if
1429 return MenuExit;
1430 } /* UINTN RunMainMenu() */