Popup.c@ 107935

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

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

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

Download in other formats: