Popup.c@ 99396

Last change on this file since 99396 was 80721, checked in by vboxsync, 5 years ago
Devices/EFI/FirmwareNew: Start upgrade process to edk2-stable201908 (compiles on Windows and works to some extent), bugref:4643
Property svn:eol-style set to `native`
File size: 24.4 KB

Line
1	/** @file
2	Implementation for Hii Popup Protocol.
3
4	Copyright (c) 2017, Intel Corporation. All rights reserved.<BR>
5	SPDX-License-Identifier: BSD-2-Clause-Patent
6
7	**/
8
9	#include "FormDisplay.h"
10
11	EFI_SCREEN_DESCRIPTOR gPopupDimensions;
12	LIST_ENTRY gUserSelectableOptions;
13	EFI_STRING gMessageString;
14	UINTN gMesStrLineNum;
15	UINTN gMaxRowWidth;
16
17	/**
18	Free the user selectable option structure data.
19
20	@param OptionList Point to the selectable option list which need to be freed.
21
22	**/
23	VOID
24	FreeSelectableOptions(
25	LIST_ENTRY *OptionList
26	)
27	{
28	LIST_ENTRY *Link;
29	USER_SELECTABLE_OPTION *SelectableOption;
30
31	while (!IsListEmpty (OptionList)) {
32	Link = GetFirstNode (OptionList);
33	SelectableOption = SELECTABLE_OPTION_FROM_LINK (Link);
34	RemoveEntryList (&SelectableOption->Link);
35	FreePool (SelectableOption);
36	}
37	}
38
39	/**
40	Display one selectable option.
41
42	@param SelectableOption The selectable option need to be drew.
43	@param Highlight Whether the option need to be highlighted.
44
45	**/
46	VOID
47	DisplayOneSelectableOption(
48	IN USER_SELECTABLE_OPTION *SelectableOption,
49	IN BOOLEAN Highlight
50	)
51	{
52	if (Highlight) {
53	gST->ConOut->SetAttribute (gST->ConOut, GetHighlightTextColor ());
54	}
55	PrintStringAt (SelectableOption->OptionCol, SelectableOption->OptionRow, SelectableOption->OptionString);
56	gST->ConOut->SetAttribute (gST->ConOut, GetPopupColor ());
57	}
58
59	/**
60	Add one selectable option to option list. This is the work function for AddUserSelectableOptions.
61
62	@param PopupType The option need to be drew.
63	@param OptionType The type of this selection option.
64	@param OptionString Point to the option string that to be shown.
65	@param OptionCol The column that the option need to be drew at.
66	@param OptionRow The row that the option need to be drew at.
67
68	@retval EFI_SUCCESS This function implement successfully.
69	@retval EFI_OUT_OF_RESOURCES There are not enough resources available.
70
71	**/
72	EFI_STATUS
73	AddOneSelectableOption (
74	IN EFI_HII_POPUP_TYPE PopupType,
75	IN EFI_HII_POPUP_SELECTION OptionType,
76	IN CHAR16 *OptionString,
77	IN UINTN OptionCol,
78	IN UINTN OptionRow
79	)
80	{
81	USER_SELECTABLE_OPTION *UserSelectableOption;
82
83	UserSelectableOption = AllocateZeroPool (sizeof (USER_SELECTABLE_OPTION));
84	if (UserSelectableOption == NULL) {
85	return EFI_OUT_OF_RESOURCES;
86	}
87	//
88	// Initialize the user selectable option based on the PopupType and OptionType.
89	// And then add the option to the option list gUserSelectableOptions.
90	//
91	UserSelectableOption->Signature = USER_SELECTABLE_OPTION_SIGNATURE;
92	UserSelectableOption->OptionString = OptionString;
93	UserSelectableOption->OptionType = OptionType;
94	UserSelectableOption->OptionCol = OptionCol;
95	UserSelectableOption->OptionRow = OptionRow;
96	UserSelectableOption->MinSequence = 0;
97
98	switch (PopupType) {
99	case EfiHiiPopupTypeOk:
100	UserSelectableOption->MaxSequence = 0;
101	UserSelectableOption->Sequence= 0;
102	break;
103	case EfiHiiPopupTypeOkCancel:
104	UserSelectableOption->MaxSequence = 1;
105	if (OptionType == EfiHiiPopupSelectionOk) {
106	UserSelectableOption->Sequence= 0;
107	} else {
108	UserSelectableOption->Sequence= 1;
109	}
110	break;
111	case EfiHiiPopupTypeYesNo:
112	UserSelectableOption->MaxSequence = 1;
113	if (OptionType == EfiHiiPopupSelectionYes) {
114	UserSelectableOption->Sequence = 0;
115	} else {
116	UserSelectableOption->Sequence = 1;
117	}
118	break;
119	case EfiHiiPopupTypeYesNoCancel:
120	UserSelectableOption->MaxSequence = 2;
121	if (OptionType == EfiHiiPopupSelectionYes) {
122	UserSelectableOption->Sequence = 0;
123	} else if (OptionType == EfiHiiPopupSelectionNo){
124	UserSelectableOption->Sequence = 1;
125	} else {
126	UserSelectableOption->Sequence = 2;
127	}
128	break;
129	default:
130	break;
131	}
132	InsertTailList (&gUserSelectableOptions, &UserSelectableOption->Link);
133
134	return EFI_SUCCESS;
135	}
136
137	/**
138	Add user selectable options to option list for different types of Popup.
139
140	@param PopupType Type of the popup to display.
141
142	@retval EFI_SUCCESS This function implement successfully.
143	@retval EFI_OUT_OF_RESOURCES There are not enough resources available.
144
145	**/
146	EFI_STATUS
147	AddUserSelectableOptions (
148	IN EFI_HII_POPUP_TYPE PopupType
149	)
150	{
151	EFI_STATUS Status;
152	UINTN EndCol;
153	UINTN StartCol;
154	UINTN OptionCol;
155	UINTN OptionRow;
156	UINTN ColDimension;
157
158	Status = EFI_SUCCESS;
159	EndCol = gPopupDimensions.RightColumn;
160	StartCol = gPopupDimensions.LeftColumn;
161	OptionRow = gPopupDimensions.BottomRow - POPUP_BORDER;
162	ColDimension = EndCol - StartCol + 1;
163
164	InitializeListHead (&gUserSelectableOptions);
165
166	switch (PopupType) {
167	case EfiHiiPopupTypeOk:
168	//
169	// Add [Ok] option to the option list.
170	//
171	OptionCol = StartCol + (ColDimension - USER_SELECTABLE_OPTION_OK_WIDTH) / 2;
172	Status = AddOneSelectableOption (PopupType, EfiHiiPopupSelectionOk, gOkOption, OptionCol, OptionRow);
173	break;
174	case EfiHiiPopupTypeOkCancel:
175	//
176	// Add [Ok] and [Cancel] options to the option list.
177	//
178	OptionCol = StartCol + (ColDimension - USER_SELECTABLE_OPTION_OK_CAL_WIDTH) / 3;
179	Status = AddOneSelectableOption (PopupType, EfiHiiPopupSelectionOk, gOkOption, OptionCol, OptionRow);
180	OptionCol = EndCol - (ColDimension - USER_SELECTABLE_OPTION_OK_CAL_WIDTH) / 3 - (GetStringWidth (gCancelOption) -2) / 2 + 1;
181	Status = AddOneSelectableOption (PopupType, EfiHiiPopupSelectionCancel, gCancelOption, OptionCol, OptionRow);
182	break;
183	case EfiHiiPopupTypeYesNo:
184	//
185	// Add [Yes] and [No] options to the option list.
186	//
187	OptionCol = StartCol + (ColDimension - USER_SELECTABLE_OPTION_YES_NO_WIDTH) / 3;
188	Status = AddOneSelectableOption (PopupType, EfiHiiPopupSelectionYes, gYesOption, OptionCol, OptionRow);
189	OptionCol = EndCol - (ColDimension - USER_SELECTABLE_OPTION_YES_NO_WIDTH) / 3 - (GetStringWidth (gNoOption)- 2) / 2 + 1;
190	Status = AddOneSelectableOption (PopupType, EfiHiiPopupSelectionNo, gNoOption, OptionCol, OptionRow);
191	break;
192	case EfiHiiPopupTypeYesNoCancel:
193	//
194	// Add [Yes], [No] and [Cancel] options to the option list.
195	//
196	OptionCol = StartCol + (ColDimension - USER_SELECTABLE_OPTION_YES_NO_CAL_WIDTH) / 4;
197	Status = AddOneSelectableOption (PopupType, EfiHiiPopupSelectionYes, gYesOption, OptionCol, OptionRow);
198	OptionCol = StartCol + (ColDimension - (GetStringWidth (gNoOption) -2) / 2) / 2;
199	Status = AddOneSelectableOption (PopupType, EfiHiiPopupSelectionNo, gNoOption, OptionCol, OptionRow);
200	OptionCol = EndCol - (ColDimension - USER_SELECTABLE_OPTION_YES_NO_CAL_WIDTH) / 4 - (GetStringWidth (gCancelOption) - 2) / 2 + 1;
201	Status = AddOneSelectableOption (PopupType, EfiHiiPopupSelectionCancel, gCancelOption, OptionCol, OptionRow);
202	break;
203	default:
204	break;
205	}
206	return Status;
207	}
208
209	/**
210	Show selectable options to user and get the one that user select.
211
212	@param PopupType Type of the popup to display.
213	@param UserSelection User selection.
214
215	**/
216	VOID
217	GetUserSelection (
218	IN EFI_HII_POPUP_TYPE PopupType,
219	OUT EFI_HII_POPUP_SELECTION *UserSelection
220	)
221	{
222	LIST_ENTRY *HighlightPos;
223	LIST_ENTRY *Link;
224	USER_SELECTABLE_OPTION *SelectableOption;
225	USER_SELECTABLE_OPTION *HighlightOption;
226	EFI_INPUT_KEY KeyValue;
227	EFI_STATUS Status;
228
229	//
230	// Display user selectable options in gUserSelectableOptions and get the option which user selects.
231	//
232	HighlightPos = gUserSelectableOptions.ForwardLink;
233	do {
234	for (Link = gUserSelectableOptions.ForwardLink; Link != &gUserSelectableOptions; Link = Link->ForwardLink) {
235	SelectableOption = SELECTABLE_OPTION_FROM_LINK (Link);
236	DisplayOneSelectableOption (SelectableOption, (BOOLEAN)(Link == HighlightPos));
237	}
238	//
239	//If UserSelection is NULL, there is no need to handle the key user input, just return.
240	//
241	if (UserSelection == NULL) {
242	return;
243	}
244
245	Status = WaitForKeyStroke (&KeyValue);
246	ASSERT_EFI_ERROR (Status);
247
248	HighlightOption = SELECTABLE_OPTION_FROM_LINK (HighlightPos);
249	switch (KeyValue.UnicodeChar) {
250	case CHAR_NULL:
251	switch (KeyValue.ScanCode) {
252	case SCAN_RIGHT:
253	if (HighlightOption->Sequence < HighlightOption->MaxSequence) {
254	HighlightPos = HighlightPos->ForwardLink;
255	} else {
256	HighlightPos = gUserSelectableOptions.ForwardLink;
257	}
258	break;
259	case SCAN_LEFT:
260	if (HighlightOption->Sequence > HighlightOption->MinSequence) {
261	HighlightPos = HighlightPos->BackLink;
262	} else {
263	HighlightPos = gUserSelectableOptions.BackLink;
264	}
265	break;
266	default:
267	break;
268	}
269	break;
270
271	case CHAR_CARRIAGE_RETURN:
272	*UserSelection = HighlightOption->OptionType;
273	return;
274	default:
275	if (((KeyValue.UnicodeChar \| UPPER_LOWER_CASE_OFFSET) == (*gConfirmOptYes \| UPPER_LOWER_CASE_OFFSET)) &&
276	(PopupType == EfiHiiPopupTypeYesNo \|\| PopupType == EfiHiiPopupTypeYesNoCancel)) {
277	*UserSelection = EfiHiiPopupSelectionYes;
278	return;
279	} else if ((KeyValue.UnicodeChar \| UPPER_LOWER_CASE_OFFSET) == (*gConfirmOptNo\| UPPER_LOWER_CASE_OFFSET) &&
280	(PopupType == EfiHiiPopupTypeYesNo \|\| PopupType == EfiHiiPopupTypeYesNoCancel)){
281	*UserSelection = EfiHiiPopupSelectionNo;
282	return;
283	} else if ((KeyValue.UnicodeChar \| UPPER_LOWER_CASE_OFFSET) == (*gConfirmOptOk \| UPPER_LOWER_CASE_OFFSET) &&
284	(PopupType == EfiHiiPopupTypeOk \|\| PopupType == EfiHiiPopupTypeOkCancel)){
285	*UserSelection = EfiHiiPopupSelectionOk;
286	return;
287	} else if ((KeyValue.UnicodeChar \| UPPER_LOWER_CASE_OFFSET) == (*gConfirmOptCancel\| UPPER_LOWER_CASE_OFFSET) &&
288	(PopupType == EfiHiiPopupTypeOkCancel \|\| PopupType == EfiHiiPopupTypeYesNoCancel)){
289	*UserSelection = EfiHiiPopupSelectionCancel;
290	return;
291	}
292	break;
293	}
294	} while (TRUE);
295	}
296
297	/**
298	Get the offset in the input string when the width reaches to a fixed one.
299
300	The input string may contain NARROW_CHAR and WIDE_CHAR.
301	Notice: the input string doesn't contain line break characters.
302
303	@param String The input string to be counted.
304	@param MaxWidth The max length this function supported.
305	@param Offset The max index of the string can be show out. If string's width less than MaxWidth, offset will point to the "\0" of the string.
306
307	**/
308	VOID
309	GetStringOffsetWithWidth (
310	IN CHAR16 *String,
311	IN UINTN MaxWidth,
312	OUT UINTN *Offset
313	)
314	{
315	UINTN StringWidth;
316	UINTN CharWidth;
317	UINTN StrOffset;
318
319	StringWidth = 0;
320	CharWidth = 1;
321
322	for (StrOffset = 0; String[StrOffset] != CHAR_NULL; StrOffset++) {
323	switch (String[StrOffset]) {
324	case NARROW_CHAR:
325	CharWidth = 1;
326	break;
327	case WIDE_CHAR:
328	CharWidth = 2;
329	break;
330	default:
331	StringWidth += CharWidth;
332	if (StringWidth >= MaxWidth) {
333	*Offset = StrOffset;
334	return;
335	}
336	}
337	}
338	*Offset = StrOffset;
339	}
340
341	/**
342	Parse the message to check if it contains line break characters.
343	For once call, caller can get the string for one line and the width of the string.
344	This function call be called recursively to parse the whole InputString.
345
346	(Notice: current implementation, it only checks \r, \n characters, it deals \r,\n,\n\r same as \r\n.)
347
348	@param InputString String description for this option.
349	@param OutputString Buffer to copy the string into, caller is responsible for freeing the buffer.
350	@param OutputStrWidth The width of OutputString.
351	@param Index Where in InputString to start the copy process
352
353	@return Returns the number of CHAR16 characters that were copied into the OutputString buffer, include the '\0' info.
354
355	**/
356	UINTN
357	ParseMessageString (
358	IN CHAR16 *InputString,
359	OUT CHAR16 **OutputString,
360	OUT UINTN *OutputStrWidth,
361	IN OUT UINTN *Index
362	)
363	{
364	UINTN StrOffset;
365
366	if (InputString == NULL \|\| Index == NULL \|\| OutputString == NULL) {
367	return 0;
368	}
369
370	*OutputStrWidth = 0;
371
372	//
373	//Check the string to see if there are line break characters in the string
374	//
375	for (StrOffset = 0;
376	InputString[Index + StrOffset] != CHAR_CARRIAGE_RETURN && InputString[Index + StrOffset] != CHAR_LINEFEED && InputString[*Index + StrOffset] != CHAR_NULL;
377	StrOffset++
378	);
379
380	//
381	// The CHAR_NULL has process last time, this time just return 0 to stand for finishing parsing the InputString.
382	//
383	if (StrOffset == 0 && (InputString[*Index + StrOffset] == CHAR_NULL)) {
384	return 0;
385	}
386
387	//
388	// Copy the string to OutputString buffer and calculate the width of OutputString.
389	//
390	OutputString = AllocateZeroPool ((StrOffset + 1) sizeof(CHAR16));
391	if (*OutputString == NULL) {
392	return 0;
393	}
394	CopyMem ((OutputString), &InputString[Index], StrOffset * sizeof(CHAR16));
395	OutputStrWidth = (GetStringWidth (OutputString) -2) / 2;
396
397	//
398	// Update the value of Index, can be used for marking where to check the input string for next call.
399	//
400	if (InputString[*Index + StrOffset] == CHAR_LINEFEED) {
401	//
402	// Skip the /n or /n/r info.
403	//
404	if (InputString[*Index + StrOffset + 1] == CHAR_CARRIAGE_RETURN) {
405	Index = (Index + StrOffset + 2);
406	} else {
407	Index = (Index + StrOffset + 1);
408	}
409	} else if (InputString[*Index + StrOffset] == CHAR_CARRIAGE_RETURN) {
410	//
411	// Skip the /r or /r/n info.
412	//
413	if (InputString[*Index + StrOffset + 1] == CHAR_LINEFEED) {
414	Index = (Index + StrOffset + 2);
415	} else {
416	Index = (Index + StrOffset + 1);
417	}
418	} else {
419	Index = (Index + StrOffset);
420	}
421
422	return StrOffset + 1;
423	}
424
425	/**
426	Calculate the position of the popup.
427
428	@param PopupType Type of the popup to display.
429	@param ScreenForPopup The screen dimensions for the popup.
430
431	**/
432	VOID
433	CalculatePopupPosition (
434	IN EFI_HII_POPUP_TYPE PopupType,
435	OUT EFI_SCREEN_DESCRIPTOR *ScreenForPopup
436	)
437	{
438	CHAR16 *OutputString;
439	UINTN StringIndex;
440	UINTN OutputStrWidth;
441	UINTN OptionRowWidth;
442	UINTN Columns;
443	UINTN Rows;
444
445	OptionRowWidth = 0;
446
447	//
448	// Calculate the row number which is needed to show the message string and the max width of the string in one row.
449	//
450	for (StringIndex = 0; ParseMessageString (gMessageString, &OutputString, &OutputStrWidth, &StringIndex) != 0;) {
451	gMesStrLineNum ++;
452	if (gMaxRowWidth < OutputStrWidth) {
453	gMaxRowWidth = OutputStrWidth;
454	}
455	FreePool (OutputString);
456	}
457
458	//
459	// Calculate the row width for the selectable options.(OptionRowWidth = Number * SkipWidth + OptionWidth)
460	//
461	if (PopupType == EfiHiiPopupTypeOk) {
462	OptionRowWidth = USER_SELECTABLE_OPTION_SKIP_WIDTH *2 + USER_SELECTABLE_OPTION_OK_WIDTH;
463	} else if (PopupType == EfiHiiPopupTypeOkCancel) {
464	OptionRowWidth = USER_SELECTABLE_OPTION_SKIP_WIDTH *3 + USER_SELECTABLE_OPTION_OK_CAL_WIDTH;
465	} else if (PopupType == EfiHiiPopupTypeYesNo) {
466	OptionRowWidth = USER_SELECTABLE_OPTION_SKIP_WIDTH *3 + USER_SELECTABLE_OPTION_YES_NO_WIDTH;
467	} else if (PopupType == EfiHiiPopupTypeYesNoCancel) {
468	OptionRowWidth = USER_SELECTABLE_OPTION_SKIP_WIDTH *4 + USER_SELECTABLE_OPTION_YES_NO_CAL_WIDTH;
469	}
470	if (OptionRowWidth > gMaxRowWidth) {
471	gMaxRowWidth = OptionRowWidth;
472	}
473
474	//
475	// Avialble row width for message string = screen width - left popup border width - right popup border width.
476	// Avialble line number for message string = screen height - 1 - popup header height - popup footer height.
477	// (Notice: screen height - 1 because in current UI page, the bottom row of srceen is usded to show Status Bar,not for form itself.
478	// So we don't use the bottom row for popup either. If macro STATUS_BAR_HEIGHT changed, we also need to update the height here.)
479	//
480	// Select the smaller one between actual dimension of message string and the avialble dimension for message string.
481	//
482	gST->ConOut->QueryMode (gST->ConOut, gST->ConOut->Mode->Mode, &Columns, &Rows);
483	gMaxRowWidth = MIN (gMaxRowWidth, Columns - 2 * POPUP_BORDER);
484	gMesStrLineNum = MIN (gMesStrLineNum, Rows -1 - POPUP_FOOTER_HEIGHT - POPUP_HEADER_HEIGHT);
485
486	//
487	// Calculate the start column, end column, top row and bottom row for the popup.
488	//
489	ScreenForPopup->LeftColumn = (Columns -2 * POPUP_BORDER - gMaxRowWidth) / 2;
490	ScreenForPopup->RightColumn = ScreenForPopup->LeftColumn + gMaxRowWidth + 2 * POPUP_BORDER - 1;
491	ScreenForPopup->TopRow = (Rows - 1 - POPUP_FOOTER_HEIGHT - POPUP_HEADER_HEIGHT - gMesStrLineNum) / 2;
492	ScreenForPopup->BottomRow = ScreenForPopup->TopRow + gMesStrLineNum + POPUP_FOOTER_HEIGHT + POPUP_HEADER_HEIGHT - 1;
493	}
494
495	/**
496	Draw the Message box.
497	+-------------------------------------------+
498	\| ERROR/WARNING/INFO \|
499	\|-------------------------------------------\|
500	\| popup messages \|
501	\| \|
502	\| user selectable options \|
503	+-------------------------------------------+
504
505	@param PopupStyle Popup style to use.
506
507	**/
508	EFI_STATUS
509	DrawMessageBox (
510	IN EFI_HII_POPUP_STYLE PopupStyle
511	)
512	{
513	UINTN Index;
514	UINTN Length;
515	UINTN EndCol;
516	UINTN TopRow;
517	UINTN StartCol;
518	UINTN BottomRow;
519	CHAR16 Character;
520	UINTN DisplayRow;
521	UINTN StringIndex;
522	CHAR16 *TempString;
523	CHAR16 *OutputString;
524	UINTN ColDimension;
525	UINTN OutputStrWidth;
526	UINTN DrawMesStrRowNum;
527
528	EndCol = gPopupDimensions.RightColumn;
529	TopRow = gPopupDimensions.TopRow;
530	StartCol = gPopupDimensions.LeftColumn;
531	BottomRow = gPopupDimensions.BottomRow;
532	ColDimension = EndCol - StartCol + 1;
533	DrawMesStrRowNum = 0;
534
535	//
536	// 1. Draw the top of the message box.
537	//
538	Character = BOXDRAW_DOWN_RIGHT;
539	PrintCharAt (StartCol, TopRow, Character);
540	Character = BOXDRAW_HORIZONTAL;
541	for (Index = StartCol; Index + 1 < EndCol; Index++) {
542	PrintCharAt ((UINTN)-1, (UINTN)-1, Character);
543	}
544	Character = BOXDRAW_DOWN_LEFT;
545	PrintCharAt ((UINTN)-1, (UINTN)-1, Character);
546
547	//
548	// 2. Draw the prompt string for different popup styles.
549	//
550	Character = BOXDRAW_VERTICAL;
551	DisplayRow = TopRow + POPUP_BORDER;
552	ClearLines (StartCol, EndCol, DisplayRow, DisplayRow, GetPopupColor ());
553	PrintCharAt (StartCol, DisplayRow, Character);
554	PrintCharAt (EndCol, DisplayRow, Character);
555	if (PopupStyle == EfiHiiPopupStyleError) {
556	PrintStringAt ((ColDimension - (GetStringWidth (gErrorPopup) - 2) / 2) / 2 + StartCol, DisplayRow, gErrorPopup);
557	} else if (PopupStyle == EfiHiiPopupStyleWarning) {
558	PrintStringAt ((ColDimension - (GetStringWidth (gWarningPopup) - 2) / 2) / 2 + StartCol, DisplayRow, gWarningPopup);
559	} else {
560	PrintStringAt ((ColDimension - (GetStringWidth (gInfoPopup) - 2) / 2) / 2 + StartCol, DisplayRow, gInfoPopup);
561	}
562
563	//
564	// 3. Draw the horizontal line below the prompt string for different popup styles.
565	//
566	DisplayRow = TopRow + POPUP_BORDER + POPUP_STYLE_STRING_HEIGHT;
567	ClearLines (StartCol, EndCol, DisplayRow, DisplayRow, GetPopupColor ());
568	Character = BOXDRAW_HORIZONTAL;
569	for (Index = StartCol + 1; Index < EndCol; Index++) {
570	PrintCharAt (Index, DisplayRow, Character);
571	}
572	Character = BOXDRAW_VERTICAL;
573	PrintCharAt (StartCol, DisplayRow, Character);
574	PrintCharAt (EndCol, DisplayRow, Character);
575
576	//
577	// 4. Draw the mesage string.
578	//
579	DisplayRow = TopRow + POPUP_HEADER_HEIGHT;
580	for (Index = DisplayRow ,StringIndex = 0; ParseMessageString (gMessageString, &OutputString, &OutputStrWidth, &StringIndex) != 0 && DrawMesStrRowNum < gMesStrLineNum;) {
581	ClearLines (StartCol, EndCol, Index, Index, GetPopupColor ());
582	PrintCharAt (StartCol, Index, Character);
583	PrintCharAt (EndCol, Index, Character);
584	if (OutputStrWidth > gMaxRowWidth) {
585	//
586	//OutputStrWidth > MaxMesStrWidth, cut off the string and print print ... instead.
587	//
588	GetStringOffsetWithWidth (OutputString, gMaxRowWidth, &Length);
589	TempString = AllocateZeroPool ((Length + 1) * sizeof (CHAR16));
590	if (TempString == NULL) {
591	FreePool (OutputString);
592	return EFI_OUT_OF_RESOURCES;
593	}
594	StrnCpyS (TempString, Length + 1, OutputString, Length - 3);
595	StrCatS (TempString, Length + 1, L"...");
596	PrintStringAt ((ColDimension - gMaxRowWidth) / 2 + StartCol, Index, TempString);
597	FreePool (TempString);
598	} else {
599	PrintStringAt ((ColDimension - OutputStrWidth) / 2 + StartCol, Index, OutputString);
600	}
601	Index ++;
602	DrawMesStrRowNum ++;
603	FreePool (OutputString);
604	}
605
606	//
607	// 5. Draw an empty line after message string.
608	//
609	ClearLines (StartCol, EndCol, Index, Index, GetPopupColor ());
610	PrintCharAt (StartCol, Index, Character);
611	PrintCharAt (EndCol, Index, Character);
612	//
613	// Check whether the actual string row number beyond the MesStrRowNum, if yes, print the ...... in the row.
614	//
615	if (OutputStrWidth > 0 && DrawMesStrRowNum >= gMesStrLineNum) {
616	PrintStringAt ((ColDimension - StrLen (L"......")) / 2 + StartCol, Index, L"......");
617	}
618
619	//
620	// 6. Draw an empty line which is used to show user selectable options, will draw concrete option strings in function GetUserSelection().
621	//
622	Character = BOXDRAW_VERTICAL;
623	DisplayRow = BottomRow - POPUP_BORDER;
624	ClearLines (StartCol, EndCol, DisplayRow, DisplayRow, GetPopupColor ());
625	PrintCharAt (StartCol, DisplayRow, Character);
626	PrintCharAt (EndCol, DisplayRow, Character);
627
628	//
629	// 7. Draw the bottom of the message box.
630	//
631	Character = BOXDRAW_UP_RIGHT;
632	PrintCharAt (StartCol, BottomRow, Character);
633	Character = BOXDRAW_HORIZONTAL;
634	for (Index = StartCol; Index + 1 < EndCol; Index++) {
635	PrintCharAt ((UINTN)-1, (UINTN) -1, Character);
636	}
637	Character = BOXDRAW_UP_LEFT;
638	PrintCharAt ((UINTN)-1, (UINTN) -1, Character);
639
640	return EFI_SUCCESS;
641	}
642
643	/**
644	Displays a popup window.
645
646	@param This A pointer to the EFI_HII_POPUP_PROTOCOL instance.
647	@param PopupStyle Popup style to use.
648	@param PopupType Type of the popup to display.
649	@param HiiHandle HII handle of the string pack containing Message
650	@param Message A message to display in the popup box.
651	@param UserSelection User selection.
652
653	@retval EFI_SUCCESS The popup box was successfully displayed.
654	@retval EFI_INVALID_PARAMETER HiiHandle and Message do not define a valid HII string.
655	@retval EFI_INVALID_PARAMETER PopupType is not one of the values defined by this specification.
656	@retval EFI_OUT_OF_RESOURCES There are not enough resources available to display the popup box.
657
658	**/
659	EFI_STATUS
660	EFIAPI
661	CreatePopup (
662	IN EFI_HII_POPUP_PROTOCOL *This,
663	IN EFI_HII_POPUP_STYLE PopupStyle,
664	IN EFI_HII_POPUP_TYPE PopupType,
665	IN EFI_HII_HANDLE HiiHandle,
666	IN EFI_STRING_ID Message,
667	OUT EFI_HII_POPUP_SELECTION *UserSelection OPTIONAL
668	)
669	{
670	EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *ConOut;
671	EFI_SIMPLE_TEXT_OUTPUT_MODE SavedConsoleMode;
672	EFI_STATUS Status;
673
674	if ((PopupType < EfiHiiPopupTypeOk) \|\| (PopupType > EfiHiiPopupTypeYesNoCancel)) {
675	return EFI_INVALID_PARAMETER;
676	}
677
678	if((HiiHandle == NULL) \|\| (Message == 0)) {
679	return EFI_INVALID_PARAMETER;
680	}
681
682	gMessageString = HiiGetString (HiiHandle, Message, NULL);
683	if(gMessageString == NULL) {
684	return EFI_INVALID_PARAMETER;
685	}
686
687	ConOut = gST->ConOut;
688	gMaxRowWidth = 0;
689	gMesStrLineNum = 0;
690
691	CopyMem (&SavedConsoleMode, ConOut->Mode, sizeof (SavedConsoleMode));
692	ConOut->EnableCursor (ConOut, FALSE);
693	ConOut->SetAttribute (ConOut, GetPopupColor ());
694
695	CalculatePopupPosition (PopupType, &gPopupDimensions);
696
697	Status = DrawMessageBox (PopupStyle);
698	if (EFI_ERROR (Status)) {
699	goto Done;
700	}
701
702	//
703	// Add user selectable options to option list: gUserSelectableOptions
704	//
705	Status = AddUserSelectableOptions (PopupType);
706	if (EFI_ERROR (Status)) {
707	goto Done;
708	}
709
710	GetUserSelection (PopupType, UserSelection);
711
712	Done:
713	//
714	// Restore Conout attributes and free the resources allocate before.
715	//
716	ConOut->EnableCursor (ConOut, SavedConsoleMode.CursorVisible);
717	ConOut->SetCursorPosition (ConOut, SavedConsoleMode.CursorColumn, SavedConsoleMode.CursorRow);
718	ConOut->SetAttribute (ConOut, SavedConsoleMode.Attribute);
719	FreeSelectableOptions (&gUserSelectableOptions);
720	FreePool (gMessageString);
721
722	return Status;
723	}
724

Note: See TracBrowser for help on using the repository browser.

source: vbox/trunk/src/VBox/Devices/EFI/FirmwareNew/MdeModulePkg/Universal/DisplayEngineDxe/Popup.c@ 99396

Download in other formats: