]> git.proxmox.com Git - mirror_edk2.git/blob - MdeModulePkg/Universal/DisplayEngineDxe/ProcessOptions.c
projects / mirror_edk2.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
UefiCpuPkg: Move AsmRelocateApLoopStart from Mpfuncs.nasm to AmdSev.nasm
[mirror_edk2.git] / MdeModulePkg / Universal / DisplayEngineDxe / ProcessOptions.c
1 /** @file
2 Implementation for handling the User Interface option processing.
3
4
5 Copyright (c) 2004 - 2020, Intel Corporation. All rights reserved.<BR>
6 SPDX-License-Identifier: BSD-2-Clause-Patent
7
8 **/
9
10 #include "FormDisplay.h"
11
12 #define MAX_TIME_OUT_LEN 0x10
13
14 /**
15 Concatenate a narrow string to another string.
16
17 @param Destination The destination string.
18 @param DestMax The Max length of destination string.
19 @param Source The source string. The string to be concatenated.
20 to the end of Destination.
21
22 **/
23 VOID
24 NewStrCat (
25 IN OUT CHAR16 *Destination,
26 IN UINTN DestMax,
27 IN CHAR16 *Source
28 )
29 {
30 UINTN Length;
31
32 for (Length = 0; Destination[Length] != 0; Length++)
33 ;
34
35 //
36 // We now have the length of the original string
37 // We can safely assume for now that we are concatenating a narrow value to this string.
38 // For instance, the string is "XYZ" and cat'ing ">"
39 // If this assumption changes, we need to make this routine a bit more complex
40 //
41 Destination[Length] = NARROW_CHAR;
42 Length++;
43
44 StrCpyS (Destination + Length, DestMax - Length, Source);
45 }
46
47 /**
48 Get UINT64 type value.
49
50 @param Value Input Hii value.
51
52 @retval UINT64 Return the UINT64 type value.
53
54 **/
55 UINT64
56 HiiValueToUINT64 (
57 IN EFI_HII_VALUE *Value
58 )
59 {
60 UINT64 RetVal;
61
62 RetVal = 0;
63
64 switch (Value->Type) {
65 case EFI_IFR_TYPE_NUM_SIZE_8:
66 RetVal = Value->Value.u8;
67 break;
68
69 case EFI_IFR_TYPE_NUM_SIZE_16:
70 RetVal = Value->Value.u16;
71 break;
72
73 case EFI_IFR_TYPE_NUM_SIZE_32:
74 RetVal = Value->Value.u32;
75 break;
76
77 case EFI_IFR_TYPE_BOOLEAN:
78 RetVal = Value->Value.b;
79 break;
80
81 case EFI_IFR_TYPE_DATE:
82 RetVal = *(UINT64*) &Value->Value.date;
83 break;
84
85 case EFI_IFR_TYPE_TIME:
86 RetVal = (*(UINT64*) &Value->Value.time) & 0xffffff;
87 break;
88
89 default:
90 RetVal = Value->Value.u64;
91 break;
92 }
93
94 return RetVal;
95 }
96
97 /**
98 Check whether this value type can be transfer to EFI_IFR_TYPE_BUFFER type.
99
100 EFI_IFR_TYPE_REF, EFI_IFR_TYPE_DATE and EFI_IFR_TYPE_TIME are converted to
101 EFI_IFR_TYPE_BUFFER when do the value compare.
102
103 @param Value Expression value to compare on.
104
105 @retval TRUE This value type can be transter to EFI_IFR_TYPE_BUFFER type.
106 @retval FALSE This value type can't be transter to EFI_IFR_TYPE_BUFFER type.
107
108 **/
109 BOOLEAN
110 IsTypeInBuffer (
111 IN EFI_HII_VALUE *Value
112 )
113 {
114 switch (Value->Type) {
115 case EFI_IFR_TYPE_BUFFER:
116 case EFI_IFR_TYPE_DATE:
117 case EFI_IFR_TYPE_TIME:
118 case EFI_IFR_TYPE_REF:
119 return TRUE;
120
121 default:
122 return FALSE;
123 }
124 }
125
126 /**
127 Check whether this value type can be transfer to EFI_IFR_TYPE_UINT64
128
129 @param Value Expression value to compare on.
130
131 @retval TRUE This value type can be transter to EFI_IFR_TYPE_BUFFER type.
132 @retval FALSE This value type can't be transter to EFI_IFR_TYPE_BUFFER type.
133
134 **/
135 BOOLEAN
136 IsTypeInUINT64 (
137 IN EFI_HII_VALUE *Value
138 )
139 {
140 switch (Value->Type) {
141 case EFI_IFR_TYPE_NUM_SIZE_8:
142 case EFI_IFR_TYPE_NUM_SIZE_16:
143 case EFI_IFR_TYPE_NUM_SIZE_32:
144 case EFI_IFR_TYPE_NUM_SIZE_64:
145 case EFI_IFR_TYPE_BOOLEAN:
146 return TRUE;
147
148 default:
149 return FALSE;
150 }
151 }
152
153 /**
154 Return the buffer length and buffer pointer for this value.
155
156 EFI_IFR_TYPE_REF, EFI_IFR_TYPE_DATE and EFI_IFR_TYPE_TIME are converted to
157 EFI_IFR_TYPE_BUFFER when do the value compare.
158
159 @param Value Expression value to compare on.
160 @param Buf Return the buffer pointer.
161 @param BufLen Return the buffer length.
162
163 **/
164 VOID
165 GetBufAndLenForValue (
166 IN EFI_HII_VALUE *Value,
167 OUT UINT8 **Buf,
168 OUT UINT16 *BufLen
169 )
170 {
171 switch (Value->Type) {
172 case EFI_IFR_TYPE_BUFFER:
173 *Buf = Value->Buffer;
174 *BufLen = Value->BufferLen;
175 break;
176
177 case EFI_IFR_TYPE_DATE:
178 *Buf = (UINT8 *) (&Value->Value.date);
179 *BufLen = (UINT16) sizeof (EFI_HII_DATE);
180 break;
181
182 case EFI_IFR_TYPE_TIME:
183 *Buf = (UINT8 *) (&Value->Value.time);
184 *BufLen = (UINT16) sizeof (EFI_HII_TIME);
185 break;
186
187 case EFI_IFR_TYPE_REF:
188 *Buf = (UINT8 *) (&Value->Value.ref);
189 *BufLen = (UINT16) sizeof (EFI_HII_REF);
190 break;
191
192 default:
193 *Buf = NULL;
194 *BufLen = 0;
195 }
196 }
197
198 /**
199 Compare two Hii value.
200
201 @param Value1 Expression value to compare on left-hand.
202 @param Value2 Expression value to compare on right-hand.
203 @param Result Return value after compare.
204 retval 0 Two operators equal.
205 return Positive value if Value1 is greater than Value2.
206 retval Negative value if Value1 is less than Value2.
207 @param HiiHandle Only required for string compare.
208
209 @retval other Could not perform compare on two values.
210 @retval EFI_SUCCESS Compare the value success.
211
212 **/
213 EFI_STATUS
214 CompareHiiValue (
215 IN EFI_HII_VALUE *Value1,
216 IN EFI_HII_VALUE *Value2,
217 OUT INTN *Result,
218 IN EFI_HII_HANDLE HiiHandle OPTIONAL
219 )
220 {
221 INT64 Temp64;
222 CHAR16 *Str1;
223 CHAR16 *Str2;
224 UINTN Len;
225 UINT8 *Buf1;
226 UINT16 Buf1Len;
227 UINT8 *Buf2;
228 UINT16 Buf2Len;
229
230 if (Value1->Type == EFI_IFR_TYPE_STRING && Value2->Type == EFI_IFR_TYPE_STRING) {
231 if (Value1->Value.string == 0 || Value2->Value.string == 0) {
232 //
233 // StringId 0 is reserved
234 //
235 return EFI_INVALID_PARAMETER;
236 }
237
238 if (Value1->Value.string == Value2->Value.string) {
239 *Result = 0;
240 return EFI_SUCCESS;
241 }
242
243 Str1 = GetToken (Value1->Value.string, HiiHandle);
244 if (Str1 == NULL) {
245 //
246 // String not found
247 //
248 return EFI_NOT_FOUND;
249 }
250
251 Str2 = GetToken (Value2->Value.string, HiiHandle);
252 if (Str2 == NULL) {
253 FreePool (Str1);
254 return EFI_NOT_FOUND;
255 }
256
257 *Result = StrCmp (Str1, Str2);
258
259 FreePool (Str1);
260 FreePool (Str2);
261
262 return EFI_SUCCESS;
263 }
264
265 //
266 // Take types(date, time, ref, buffer) as buffer
267 //
268 if (IsTypeInBuffer(Value1) && IsTypeInBuffer(Value2)) {
269 GetBufAndLenForValue(Value1, &Buf1, &Buf1Len);
270 GetBufAndLenForValue(Value2, &Buf2, &Buf2Len);
271
272 Len = Buf1Len > Buf2Len ? Buf2Len : Buf1Len;
273 *Result = CompareMem (Buf1, Buf2, Len);
274 if ((*Result == 0) && (Buf1Len != Buf2Len)) {
275 //
276 // In this case, means base on samll number buffer, the data is same
277 // So which value has more data, which value is bigger.
278 //
279 *Result = Buf1Len > Buf2Len ? 1 : -1;
280 }
281 return EFI_SUCCESS;
282 }
283
284 //
285 // Take remain types(integer, boolean, date/time) as integer
286 //
287 if (IsTypeInUINT64(Value1) && IsTypeInUINT64(Value2)) {
288 Temp64 = HiiValueToUINT64(Value1) - HiiValueToUINT64(Value2);
289 if (Temp64 > 0) {
290 *Result = 1;
291 } else if (Temp64 < 0) {
292 *Result = -1;
293 } else {
294 *Result = 0;
295 }
296 return EFI_SUCCESS;
297 }
298
299 return EFI_UNSUPPORTED;
300 }
301
302 /**
303 Search an Option of a Question by its value.
304
305 @param Question The Question
306 @param OptionValue Value for Option to be searched.
307
308 @retval Pointer Pointer to the found Option.
309 @retval NULL Option not found.
310
311 **/
312 DISPLAY_QUESTION_OPTION *
313 ValueToOption (
314 IN FORM_DISPLAY_ENGINE_STATEMENT *Question,
315 IN EFI_HII_VALUE *OptionValue
316 )
317 {
318 LIST_ENTRY *Link;
319 DISPLAY_QUESTION_OPTION *Option;
320 INTN Result;
321 EFI_HII_VALUE Value;
322
323 Link = GetFirstNode (&Question->OptionListHead);
324 while (!IsNull (&Question->OptionListHead, Link)) {
325 Option = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);
326
327 ZeroMem (&Value, sizeof (EFI_HII_VALUE));
328 Value.Type = Option->OptionOpCode->Type;
329 CopyMem (&Value.Value, &Option->OptionOpCode->Value, Option->OptionOpCode->Header.Length - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value));
330
331 if ((CompareHiiValue (&Value, OptionValue, &Result, NULL) == EFI_SUCCESS) && (Result == 0)) {
332 return Option;
333 }
334
335 Link = GetNextNode (&Question->OptionListHead, Link);
336 }
337
338 return NULL;
339 }
340
341
342 /**
343 Return data element in an Array by its Index.
344
345 @param Array The data array.
346 @param Type Type of the data in this array.
347 @param Index Zero based index for data in this array.
348
349 @retval Value The data to be returned
350
351 **/
352 UINT64
353 GetArrayData (
354 IN VOID *Array,
355 IN UINT8 Type,
356 IN UINTN Index
357 )
358 {
359 UINT64 Data;
360
361 ASSERT (Array != NULL);
362
363 Data = 0;
364 switch (Type) {
365 case EFI_IFR_TYPE_NUM_SIZE_8:
366 Data = (UINT64) *(((UINT8 *) Array) + Index);
367 break;
368
369 case EFI_IFR_TYPE_NUM_SIZE_16:
370 Data = (UINT64) *(((UINT16 *) Array) + Index);
371 break;
372
373 case EFI_IFR_TYPE_NUM_SIZE_32:
374 Data = (UINT64) *(((UINT32 *) Array) + Index);
375 break;
376
377 case EFI_IFR_TYPE_NUM_SIZE_64:
378 Data = (UINT64) *(((UINT64 *) Array) + Index);
379 break;
380
381 default:
382 break;
383 }
384
385 return Data;
386 }
387
388
389 /**
390 Set value of a data element in an Array by its Index.
391
392 @param Array The data array.
393 @param Type Type of the data in this array.
394 @param Index Zero based index for data in this array.
395 @param Value The value to be set.
396
397 **/
398 VOID
399 SetArrayData (
400 IN VOID *Array,
401 IN UINT8 Type,
402 IN UINTN Index,
403 IN UINT64 Value
404 )
405 {
406
407 ASSERT (Array != NULL);
408
409 switch (Type) {
410 case EFI_IFR_TYPE_NUM_SIZE_8:
411 *(((UINT8 *) Array) + Index) = (UINT8) Value;
412 break;
413
414 case EFI_IFR_TYPE_NUM_SIZE_16:
415 *(((UINT16 *) Array) + Index) = (UINT16) Value;
416 break;
417
418 case EFI_IFR_TYPE_NUM_SIZE_32:
419 *(((UINT32 *) Array) + Index) = (UINT32) Value;
420 break;
421
422 case EFI_IFR_TYPE_NUM_SIZE_64:
423 *(((UINT64 *) Array) + Index) = (UINT64) Value;
424 break;
425
426 default:
427 break;
428 }
429 }
430
431 /**
432 Check whether this value already in the array, if yes, return the index.
433
434 @param Array The data array.
435 @param Type Type of the data in this array.
436 @param Value The value to be find.
437 @param Index The index in the array which has same value with Value.
438
439 @retval TRUE Found the value in the array.
440 @retval FALSE Not found the value.
441
442 **/
443 BOOLEAN
444 FindArrayData (
445 IN VOID *Array,
446 IN UINT8 Type,
447 IN UINT64 Value,
448 OUT UINTN *Index OPTIONAL
449 )
450 {
451 UINTN Count;
452 UINT64 TmpValue;
453 UINT64 ValueComp;
454
455 ASSERT (Array != NULL);
456
457 Count = 0;
458 TmpValue = 0;
459
460 switch (Type) {
461 case EFI_IFR_TYPE_NUM_SIZE_8:
462 ValueComp = (UINT8) Value;
463 break;
464
465 case EFI_IFR_TYPE_NUM_SIZE_16:
466 ValueComp = (UINT16) Value;
467 break;
468
469 case EFI_IFR_TYPE_NUM_SIZE_32:
470 ValueComp = (UINT32) Value;
471 break;
472
473 case EFI_IFR_TYPE_NUM_SIZE_64:
474 ValueComp = (UINT64) Value;
475 break;
476
477 default:
478 ValueComp = 0;
479 break;
480 }
481
482 while ((TmpValue = GetArrayData (Array, Type, Count)) != 0) {
483 if (ValueComp == TmpValue) {
484 if (Index != NULL) {
485 *Index = Count;
486 }
487 return TRUE;
488 }
489
490 Count ++;
491 }
492
493 return FALSE;
494 }
495
496 /**
497 Print Question Value according to it's storage width and display attributes.
498
499 @param Question The Question to be printed.
500 @param FormattedNumber Buffer for output string.
501 @param BufferSize The FormattedNumber buffer size in bytes.
502
503 @retval EFI_SUCCESS Print success.
504 @retval EFI_BUFFER_TOO_SMALL Buffer size is not enough for formatted number.
505
506 **/
507 EFI_STATUS
508 PrintFormattedNumber (
509 IN FORM_DISPLAY_ENGINE_STATEMENT *Question,
510 IN OUT CHAR16 *FormattedNumber,
511 IN UINTN BufferSize
512 )
513 {
514 INT64 Value;
515 CHAR16 *Format;
516 EFI_HII_VALUE *QuestionValue;
517 EFI_IFR_NUMERIC *NumericOp;
518
519 if (BufferSize < (21 * sizeof (CHAR16))) {
520 return EFI_BUFFER_TOO_SMALL;
521 }
522
523 QuestionValue = &Question->CurrentValue;
524 NumericOp = (EFI_IFR_NUMERIC *) Question->OpCode;
525
526 Value = (INT64) QuestionValue->Value.u64;
527 switch (NumericOp->Flags & EFI_IFR_DISPLAY) {
528 case EFI_IFR_DISPLAY_INT_DEC:
529 switch (QuestionValue->Type) {
530 case EFI_IFR_NUMERIC_SIZE_1:
531 Value = (INT64) ((INT8) QuestionValue->Value.u8);
532 break;
533
534 case EFI_IFR_NUMERIC_SIZE_2:
535 Value = (INT64) ((INT16) QuestionValue->Value.u16);
536 break;
537
538 case EFI_IFR_NUMERIC_SIZE_4:
539 Value = (INT64) ((INT32) QuestionValue->Value.u32);
540 break;
541
542 case EFI_IFR_NUMERIC_SIZE_8:
543 default:
544 break;
545 }
546
547 if (Value < 0) {
548 Value = -Value;
549 Format = L"-%ld";
550 } else {
551 Format = L"%ld";
552 }
553 break;
554
555 case EFI_IFR_DISPLAY_UINT_DEC:
556 Format = L"%ld";
557 break;
558
559 case EFI_IFR_DISPLAY_UINT_HEX:
560 Format = L"%lx";
561 break;
562
563 default:
564 return EFI_UNSUPPORTED;
565 }
566
567 UnicodeSPrint (FormattedNumber, BufferSize, Format, Value);
568
569 return EFI_SUCCESS;
570 }
571
572
573 /**
574 Draw a pop up windows based on the dimension, number of lines and
575 strings specified.
576
577 @param RequestedWidth The width of the pop-up.
578 @param NumberOfLines The number of lines.
579 @param Marker The variable argument list for the list of string to be printed.
580
581 **/
582 VOID
583 CreateSharedPopUp (
584 IN UINTN RequestedWidth,
585 IN UINTN NumberOfLines,
586 IN VA_LIST Marker
587 )
588 {
589 UINTN Index;
590 UINTN Count;
591 CHAR16 Character;
592 UINTN Start;
593 UINTN End;
594 UINTN Top;
595 UINTN Bottom;
596 CHAR16 *String;
597 UINTN DimensionsWidth;
598 UINTN DimensionsHeight;
599
600 DimensionsWidth = gStatementDimensions.RightColumn - gStatementDimensions.LeftColumn;
601 DimensionsHeight = gStatementDimensions.BottomRow - gStatementDimensions.TopRow;
602
603 gST->ConOut->SetAttribute (gST->ConOut, GetPopupColor ());
604
605 if ((RequestedWidth + 2) > DimensionsWidth) {
606 RequestedWidth = DimensionsWidth - 2;
607 }
608
609 //
610 // Subtract the PopUp width from total Columns, allow for one space extra on
611 // each end plus a border.
612 //
613 Start = (DimensionsWidth - RequestedWidth - 2) / 2 + gStatementDimensions.LeftColumn + 1;
614 End = Start + RequestedWidth + 1;
615
616 Top = ((DimensionsHeight - NumberOfLines - 2) / 2) + gStatementDimensions.TopRow - 1;
617 Bottom = Top + NumberOfLines + 2;
618
619 Character = BOXDRAW_DOWN_RIGHT;
620 PrintCharAt (Start, Top, Character);
621 Character = BOXDRAW_HORIZONTAL;
622 for (Index = Start; Index + 2 < End; Index++) {
623 PrintCharAt ((UINTN)-1, (UINTN)-1, Character);
624 }
625
626 Character = BOXDRAW_DOWN_LEFT;
627 PrintCharAt ((UINTN)-1, (UINTN)-1, Character);
628 Character = BOXDRAW_VERTICAL;
629
630 Count = 0;
631 for (Index = Top; Index + 2 < Bottom; Index++, Count++) {
632 String = VA_ARG (Marker, CHAR16*);
633
634 //
635 // This will clear the background of the line - we never know who might have been
636 // here before us. This differs from the next clear in that it used the non-reverse
637 // video for normal printing.
638 //
639 if (GetStringWidth (String) / 2 > 1) {
640 ClearLines (Start, End, Index + 1, Index + 1, GetPopupColor ());
641 }
642
643 //
644 // Passing in a space results in the assumption that this is where typing will occur
645 //
646 if (String[0] == L' ') {
647 ClearLines (Start + 1, End - 1, Index + 1, Index + 1, GetPopupInverseColor ());
648 }
649
650 //
651 // Passing in a NULL results in a blank space
652 //
653 if (String[0] == CHAR_NULL) {
654 ClearLines (Start, End, Index + 1, Index + 1, GetPopupColor ());
655 }
656
657 PrintStringAt (
658 ((DimensionsWidth - GetStringWidth (String) / 2) / 2) + gStatementDimensions.LeftColumn + 1,
659 Index + 1,
660 String
661 );
662 gST->ConOut->SetAttribute (gST->ConOut, GetPopupColor ());
663 PrintCharAt (Start, Index + 1, Character);
664 PrintCharAt (End - 1, Index + 1, Character);
665 }
666
667 Character = BOXDRAW_UP_RIGHT;
668 PrintCharAt (Start, Bottom - 1, Character);
669 Character = BOXDRAW_HORIZONTAL;
670 for (Index = Start; Index + 2 < End; Index++) {
671 PrintCharAt ((UINTN)-1, (UINTN)-1, Character);
672 }
673
674 Character = BOXDRAW_UP_LEFT;
675 PrintCharAt ((UINTN)-1, (UINTN)-1, Character);
676 }
677
678 /**
679 Draw a pop up windows based on the dimension, number of lines and
680 strings specified.
681
682 @param RequestedWidth The width of the pop-up.
683 @param NumberOfLines The number of lines.
684 @param ... A series of text strings that displayed in the pop-up.
685
686 **/
687 VOID
688 EFIAPI
689 CreateMultiStringPopUp (
690 IN UINTN RequestedWidth,
691 IN UINTN NumberOfLines,
692 ...
693 )
694 {
695 VA_LIST Marker;
696
697 VA_START (Marker, NumberOfLines);
698
699 CreateSharedPopUp (RequestedWidth, NumberOfLines, Marker);
700
701 VA_END (Marker);
702 }
703
704 /**
705 Process nothing.
706
707 @param Event The Event need to be process
708 @param Context The context of the event.
709
710 **/
711 VOID
712 EFIAPI
713 EmptyEventProcess (
714 IN EFI_EVENT Event,
715 IN VOID *Context
716 )
717 {
718 }
719
720 /**
721 Process for the refresh interval statement.
722
723 @param Event The Event need to be process
724 @param Context The context of the event.
725
726 **/
727 VOID
728 EFIAPI
729 RefreshTimeOutProcess (
730 IN EFI_EVENT Event,
731 IN VOID *Context
732 )
733 {
734 WARNING_IF_CONTEXT *EventInfo;
735 CHAR16 TimeOutString[MAX_TIME_OUT_LEN];
736
737 EventInfo = (WARNING_IF_CONTEXT *) Context;
738
739 if (*(EventInfo->TimeOut) == 0) {
740 gBS->CloseEvent (Event);
741
742 gBS->SignalEvent (EventInfo->SyncEvent);
743 return;
744 }
745
746 UnicodeSPrint(TimeOutString, MAX_TIME_OUT_LEN, L"%d", *(EventInfo->TimeOut));
747
748 CreateDialog (NULL, gEmptyString, EventInfo->ErrorInfo, gPressEnter, gEmptyString, TimeOutString, NULL);
749
750 *(EventInfo->TimeOut) -= 1;
751 }
752
753 /**
754 Display error message for invalid password.
755
756 **/
757 VOID
758 PasswordInvalid (
759 VOID
760 )
761 {
762 EFI_INPUT_KEY Key;
763
764 //
765 // Invalid password, prompt error message
766 //
767 do {
768 CreateDialog (&Key, gEmptyString, gPassowordInvalid, gPressEnter, gEmptyString, NULL);
769 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
770 }
771
772 /**
773 Process password op code.
774
775 @param MenuOption The menu for current password op code.
776
777 @retval EFI_SUCCESS Question Option process success.
778 @retval Other Question Option process fail.
779
780 **/
781 EFI_STATUS
782 PasswordProcess (
783 IN UI_MENU_OPTION *MenuOption
784 )
785 {
786 CHAR16 *StringPtr;
787 CHAR16 *TempString;
788 UINTN Maximum;
789 EFI_STATUS Status;
790 EFI_IFR_PASSWORD *PasswordInfo;
791 FORM_DISPLAY_ENGINE_STATEMENT *Question;
792 EFI_INPUT_KEY Key;
793
794 Question = MenuOption->ThisTag;
795 PasswordInfo = (EFI_IFR_PASSWORD *) Question->OpCode;
796 Maximum = PasswordInfo->MaxSize;
797 Status = EFI_SUCCESS;
798
799 StringPtr = AllocateZeroPool ((Maximum + 1) * sizeof (CHAR16));
800 ASSERT (StringPtr);
801
802 //
803 // Use a NULL password to test whether old password is required
804 //
805 *StringPtr = 0;
806 Status = Question->PasswordCheck (gFormData, Question, StringPtr);
807 if (Status == EFI_NOT_AVAILABLE_YET || Status == EFI_UNSUPPORTED) {
808 //
809 // Password can't be set now.
810 //
811 if (Status == EFI_UNSUPPORTED) {
812 do {
813 CreateDialog (&Key, gEmptyString, gPasswordUnsupported, gPressEnter, gEmptyString, NULL);
814 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
815 }
816 FreePool (StringPtr);
817 return EFI_SUCCESS;
818 }
819
820 if (EFI_ERROR (Status)) {
821 //
822 // Old password exist, ask user for the old password
823 //
824 Status = ReadString (MenuOption, gPromptForPassword, StringPtr);
825 if (EFI_ERROR (Status)) {
826 ZeroMem (StringPtr, (Maximum + 1) * sizeof (CHAR16));
827 FreePool (StringPtr);
828 return Status;
829 }
830
831 //
832 // Check user input old password
833 //
834 Status = Question->PasswordCheck (gFormData, Question, StringPtr);
835 if (EFI_ERROR (Status)) {
836 if (Status == EFI_NOT_READY) {
837 //
838 // Typed in old password incorrect
839 //
840 PasswordInvalid ();
841 } else {
842 Status = EFI_SUCCESS;
843 }
844 ZeroMem (StringPtr, (Maximum + 1) * sizeof (CHAR16));
845 FreePool (StringPtr);
846 return Status;
847 }
848 }
849
850 //
851 // Ask for new password
852 //
853 ZeroMem (StringPtr, (Maximum + 1) * sizeof (CHAR16));
854 Status = ReadString (MenuOption, gPromptForNewPassword, StringPtr);
855 if (EFI_ERROR (Status)) {
856 //
857 // Reset state machine for password
858 //
859 Question->PasswordCheck (gFormData, Question, NULL);
860 ZeroMem (StringPtr, (Maximum + 1) * sizeof (CHAR16));
861 FreePool (StringPtr);
862 return Status;
863 }
864
865 //
866 // Confirm new password
867 //
868 TempString = AllocateZeroPool ((Maximum + 1) * sizeof (CHAR16));
869 ASSERT (TempString);
870 Status = ReadString (MenuOption, gConfirmPassword, TempString);
871 if (EFI_ERROR (Status)) {
872 //
873 // Reset state machine for password
874 //
875 Question->PasswordCheck (gFormData, Question, NULL);
876 ZeroMem (StringPtr, (Maximum + 1) * sizeof (CHAR16));
877 ZeroMem (TempString, (Maximum + 1) * sizeof (CHAR16));
878 FreePool (StringPtr);
879 FreePool (TempString);
880 return Status;
881 }
882
883 //
884 // Compare two typed-in new passwords
885 //
886 if (StrCmp (StringPtr, TempString) == 0) {
887 gUserInput->InputValue.Buffer = AllocateCopyPool (Question->CurrentValue.BufferLen, StringPtr);
888 gUserInput->InputValue.BufferLen = Question->CurrentValue.BufferLen;
889 gUserInput->InputValue.Type = Question->CurrentValue.Type;
890 gUserInput->InputValue.Value.string = HiiSetString(gFormData->HiiHandle, gUserInput->InputValue.Value.string, StringPtr, NULL);
891
892 Status = EFI_SUCCESS;
893 } else {
894 //
895 // Reset state machine for password
896 //
897 Question->PasswordCheck (gFormData, Question, NULL);
898
899 //
900 // Two password mismatch, prompt error message
901 //
902 do {
903 CreateDialog (&Key, gEmptyString, gConfirmError, gPressEnter, gEmptyString, NULL);
904 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
905
906 Status = EFI_INVALID_PARAMETER;
907 }
908 ZeroMem (TempString, (Maximum + 1) * sizeof (CHAR16));
909 ZeroMem (StringPtr, (Maximum + 1) * sizeof (CHAR16));
910 FreePool (TempString);
911 FreePool (StringPtr);
912
913 return Status;
914 }
915
916 /**
917 Process a Question's Option (whether selected or un-selected).
918
919 @param MenuOption The MenuOption for this Question.
920 @param Selected TRUE: if Question is selected.
921 @param OptionString Pointer of the Option String to be displayed.
922 @param SkipErrorValue Whether need to return when value without option for it.
923
924 @retval EFI_SUCCESS Question Option process success.
925 @retval Other Question Option process fail.
926
927 **/
928 EFI_STATUS
929 ProcessOptions (
930 IN UI_MENU_OPTION *MenuOption,
931 IN BOOLEAN Selected,
932 OUT CHAR16 **OptionString,
933 IN BOOLEAN SkipErrorValue
934 )
935 {
936 EFI_STATUS Status;
937 CHAR16 *StringPtr;
938 UINTN Index;
939 FORM_DISPLAY_ENGINE_STATEMENT *Question;
940 CHAR16 FormattedNumber[21];
941 UINT16 Number;
942 CHAR16 Character[2];
943 EFI_INPUT_KEY Key;
944 UINTN BufferSize;
945 DISPLAY_QUESTION_OPTION *OneOfOption;
946 LIST_ENTRY *Link;
947 EFI_HII_VALUE HiiValue;
948 EFI_HII_VALUE *QuestionValue;
949 DISPLAY_QUESTION_OPTION *Option;
950 UINTN Index2;
951 UINT8 *ValueArray;
952 UINT8 ValueType;
953 EFI_IFR_ORDERED_LIST *OrderList;
954 BOOLEAN ValueInvalid;
955 UINTN MaxLen;
956
957 Status = EFI_SUCCESS;
958
959 StringPtr = NULL;
960 Character[1] = L'\0';
961 *OptionString = NULL;
962 ValueInvalid = FALSE;
963
964 ZeroMem (FormattedNumber, 21 * sizeof (CHAR16));
965 BufferSize = (gOptionBlockWidth + 1) * 2 * gStatementDimensions.BottomRow;
966
967 Question = MenuOption->ThisTag;
968 QuestionValue = &Question->CurrentValue;
969
970 switch (Question->OpCode->OpCode) {
971 case EFI_IFR_ORDERED_LIST_OP:
972
973 //
974 // Check whether there are Options of this OrderedList
975 //
976 if (IsListEmpty (&Question->OptionListHead)) {
977 break;
978 }
979
980 OrderList = (EFI_IFR_ORDERED_LIST *) Question->OpCode;
981
982 Link = GetFirstNode (&Question->OptionListHead);
983 OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);
984
985 ValueType = OneOfOption->OptionOpCode->Type;
986 ValueArray = Question->CurrentValue.Buffer;
987
988 if (Selected) {
989 //
990 // Go ask for input
991 //
992 Status = GetSelectionInputPopUp (MenuOption);
993 } else {
994 //
995 // We now know how many strings we will have, so we can allocate the
996 // space required for the array or strings.
997 //
998 MaxLen = OrderList->MaxContainers * BufferSize / sizeof (CHAR16);
999 *OptionString = AllocateZeroPool (MaxLen * sizeof (CHAR16));
1000 ASSERT (*OptionString);
1001
1002 HiiValue.Type = ValueType;
1003 HiiValue.Value.u64 = 0;
1004 for (Index = 0; Index < OrderList->MaxContainers; Index++) {
1005 HiiValue.Value.u64 = GetArrayData (ValueArray, ValueType, Index);
1006 if (HiiValue.Value.u64 == 0) {
1007 //
1008 // Values for the options in ordered lists should never be a 0
1009 //
1010 break;
1011 }
1012
1013 OneOfOption = ValueToOption (Question, &HiiValue);
1014 if (OneOfOption == NULL) {
1015 if (SkipErrorValue) {
1016 //
1017 // Just try to get the option string, skip the value which not has option.
1018 //
1019 continue;
1020 }
1021
1022 //
1023 // Show error message
1024 //
1025 do {
1026 CreateDialog (&Key, gEmptyString, gOptionMismatch, gPressEnter, gEmptyString, NULL);
1027 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
1028
1029 //
1030 // The initial value of the orderedlist is invalid, force to be valid value
1031 // Exit current DisplayForm with new value.
1032 //
1033 gUserInput->SelectedStatement = Question;
1034 gMisMatch = TRUE;
1035 ValueArray = AllocateZeroPool (Question->CurrentValue.BufferLen);
1036 ASSERT (ValueArray != NULL);
1037 gUserInput->InputValue.Buffer = ValueArray;
1038 gUserInput->InputValue.BufferLen = Question->CurrentValue.BufferLen;
1039 gUserInput->InputValue.Type = Question->CurrentValue.Type;
1040
1041 Link = GetFirstNode (&Question->OptionListHead);
1042 Index2 = 0;
1043 while (!IsNull (&Question->OptionListHead, Link) && Index2 < OrderList->MaxContainers) {
1044 Option = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);
1045 Link = GetNextNode (&Question->OptionListHead, Link);
1046 SetArrayData (ValueArray, ValueType, Index2, Option->OptionOpCode->Value.u64);
1047 Index2++;
1048 }
1049 SetArrayData (ValueArray, ValueType, Index2, 0);
1050
1051 FreePool (*OptionString);
1052 *OptionString = NULL;
1053 return EFI_NOT_FOUND;
1054 }
1055
1056 Character[0] = LEFT_ONEOF_DELIMITER;
1057 NewStrCat (OptionString[0], MaxLen, Character);
1058 StringPtr = GetToken (OneOfOption->OptionOpCode->Option, gFormData->HiiHandle);
1059 ASSERT (StringPtr != NULL);
1060 NewStrCat (OptionString[0], MaxLen, StringPtr);
1061 Character[0] = RIGHT_ONEOF_DELIMITER;
1062 NewStrCat (OptionString[0], MaxLen, Character);
1063 Character[0] = CHAR_CARRIAGE_RETURN;
1064 NewStrCat (OptionString[0], MaxLen, Character);
1065 FreePool (StringPtr);
1066 }
1067
1068 //
1069 // If valid option more than the max container, skip these options.
1070 //
1071 if (Index >= OrderList->MaxContainers) {
1072 break;
1073 }
1074
1075 //
1076 // Search the other options, try to find the one not in the container.
1077 //
1078 Link = GetFirstNode (&Question->OptionListHead);
1079 while (!IsNull (&Question->OptionListHead, Link)) {
1080 OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);
1081 Link = GetNextNode (&Question->OptionListHead, Link);
1082
1083 if (FindArrayData (ValueArray, ValueType, OneOfOption->OptionOpCode->Value.u64, NULL)) {
1084 continue;
1085 }
1086
1087 if (SkipErrorValue) {
1088 //
1089 // Not report error, just get the correct option string info.
1090 //
1091 Character[0] = LEFT_ONEOF_DELIMITER;
1092 NewStrCat (OptionString[0], MaxLen, Character);
1093 StringPtr = GetToken (OneOfOption->OptionOpCode->Option, gFormData->HiiHandle);
1094 ASSERT (StringPtr != NULL);
1095 NewStrCat (OptionString[0], MaxLen, StringPtr);
1096 Character[0] = RIGHT_ONEOF_DELIMITER;
1097 NewStrCat (OptionString[0], MaxLen, Character);
1098 Character[0] = CHAR_CARRIAGE_RETURN;
1099 NewStrCat (OptionString[0], MaxLen, Character);
1100 FreePool (StringPtr);
1101
1102 continue;
1103 }
1104
1105 if (!ValueInvalid) {
1106 ValueInvalid = TRUE;
1107 //
1108 // Show error message
1109 //
1110 do {
1111 CreateDialog (&Key, gEmptyString, gOptionMismatch, gPressEnter, gEmptyString, NULL);
1112 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
1113
1114 //
1115 // The initial value of the orderedlist is invalid, force to be valid value
1116 // Exit current DisplayForm with new value.
1117 //
1118 gUserInput->SelectedStatement = Question;
1119 gMisMatch = TRUE;
1120 ValueArray = AllocateCopyPool (Question->CurrentValue.BufferLen, Question->CurrentValue.Buffer);
1121 ASSERT (ValueArray != NULL);
1122 gUserInput->InputValue.Buffer = ValueArray;
1123 gUserInput->InputValue.BufferLen = Question->CurrentValue.BufferLen;
1124 gUserInput->InputValue.Type = Question->CurrentValue.Type;
1125 }
1126
1127 SetArrayData (ValueArray, ValueType, Index++, OneOfOption->OptionOpCode->Value.u64);
1128 }
1129
1130 if (ValueInvalid) {
1131 FreePool (*OptionString);
1132 *OptionString = NULL;
1133 return EFI_NOT_FOUND;
1134 }
1135 }
1136 break;
1137
1138 case EFI_IFR_ONE_OF_OP:
1139 //
1140 // Check whether there are Options of this OneOf
1141 //
1142 if (IsListEmpty (&Question->OptionListHead)) {
1143 break;
1144 }
1145 if (Selected) {
1146 //
1147 // Go ask for input
1148 //
1149 Status = GetSelectionInputPopUp (MenuOption);
1150 } else {
1151 MaxLen = BufferSize / sizeof(CHAR16);
1152 *OptionString = AllocateZeroPool (BufferSize);
1153 ASSERT (*OptionString);
1154
1155 OneOfOption = ValueToOption (Question, QuestionValue);
1156 if (OneOfOption == NULL) {
1157 if (SkipErrorValue) {
1158 //
1159 // Not report error, just get the correct option string info.
1160 //
1161 Link = GetFirstNode (&Question->OptionListHead);
1162 OneOfOption = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);
1163 } else {
1164 //
1165 // Show error message
1166 //
1167 do {
1168 CreateDialog (&Key, gEmptyString, gOptionMismatch, gPressEnter, gEmptyString, NULL);
1169 } while (Key.UnicodeChar != CHAR_CARRIAGE_RETURN);
1170
1171 //
1172 // Force the Question value to be valid
1173 // Exit current DisplayForm with new value.
1174 //
1175 Link = GetFirstNode (&Question->OptionListHead);
1176 Option = DISPLAY_QUESTION_OPTION_FROM_LINK (Link);
1177
1178 gUserInput->InputValue.Type = Option->OptionOpCode->Type;
1179 switch (gUserInput->InputValue.Type) {
1180 case EFI_IFR_TYPE_NUM_SIZE_8:
1181 gUserInput->InputValue.Value.u8 = Option->OptionOpCode->Value.u8;
1182 break;
1183 case EFI_IFR_TYPE_NUM_SIZE_16:
1184 CopyMem (&gUserInput->InputValue.Value.u16, &Option->OptionOpCode->Value.u16, sizeof (UINT16));
1185 break;
1186 case EFI_IFR_TYPE_NUM_SIZE_32:
1187 CopyMem (&gUserInput->InputValue.Value.u32, &Option->OptionOpCode->Value.u32, sizeof (UINT32));
1188 break;
1189 case EFI_IFR_TYPE_NUM_SIZE_64:
1190 CopyMem (&gUserInput->InputValue.Value.u64, &Option->OptionOpCode->Value.u64, sizeof (UINT64));
1191 break;
1192 default:
1193 ASSERT (FALSE);
1194 break;
1195 }
1196 gUserInput->SelectedStatement = Question;
1197 gMisMatch = TRUE;
1198 FreePool (*OptionString);
1199 *OptionString = NULL;
1200 return EFI_NOT_FOUND;
1201 }
1202 }
1203
1204 Character[0] = LEFT_ONEOF_DELIMITER;
1205 NewStrCat (OptionString[0], MaxLen, Character);
1206 StringPtr = GetToken (OneOfOption->OptionOpCode->Option, gFormData->HiiHandle);
1207 ASSERT (StringPtr != NULL);
1208 NewStrCat (OptionString[0], MaxLen, StringPtr);
1209 Character[0] = RIGHT_ONEOF_DELIMITER;
1210 NewStrCat (OptionString[0], MaxLen, Character);
1211
1212 FreePool (StringPtr);
1213 }
1214 break;
1215
1216 case EFI_IFR_CHECKBOX_OP:
1217 if (Selected) {
1218 //
1219 // Since this is a BOOLEAN operation, flip it upon selection
1220 //
1221 gUserInput->InputValue.Type = QuestionValue->Type;
1222 gUserInput->InputValue.Value.b = (BOOLEAN) (QuestionValue->Value.b ? FALSE : TRUE);
1223
1224 //
1225 // Perform inconsistent check
1226 //
1227 return EFI_SUCCESS;
1228 } else {
1229 *OptionString = AllocateZeroPool (BufferSize);
1230 ASSERT (*OptionString);
1231
1232 *OptionString[0] = LEFT_CHECKBOX_DELIMITER;
1233
1234 if (QuestionValue->Value.b) {
1235 *(OptionString[0] + 1) = CHECK_ON;
1236 } else {
1237 *(OptionString[0] + 1) = CHECK_OFF;
1238 }
1239 *(OptionString[0] + 2) = RIGHT_CHECKBOX_DELIMITER;
1240 }
1241 break;
1242
1243 case EFI_IFR_NUMERIC_OP:
1244 if (Selected) {
1245 //
1246 // Go ask for input
1247 //
1248 Status = GetNumericInput (MenuOption);
1249 } else {
1250 *OptionString = AllocateZeroPool (BufferSize);
1251 ASSERT (*OptionString);
1252
1253 *OptionString[0] = LEFT_NUMERIC_DELIMITER;
1254
1255 //
1256 // Formatted print
1257 //
1258 PrintFormattedNumber (Question, FormattedNumber, 21 * sizeof (CHAR16));
1259 Number = (UINT16) GetStringWidth (FormattedNumber);
1260 CopyMem (OptionString[0] + 1, FormattedNumber, Number);
1261
1262 *(OptionString[0] + Number / 2) = RIGHT_NUMERIC_DELIMITER;
1263 }
1264 break;
1265
1266 case EFI_IFR_DATE_OP:
1267 if (Selected) {
1268 //
1269 // This is similar to numerics
1270 //
1271 Status = GetNumericInput (MenuOption);
1272 } else {
1273 *OptionString = AllocateZeroPool (BufferSize);
1274 ASSERT (*OptionString);
1275
1276 switch (MenuOption->Sequence) {
1277 case 0:
1278 *OptionString[0] = LEFT_NUMERIC_DELIMITER;
1279 if (QuestionValue->Value.date.Month == 0xff){
1280 UnicodeSPrint (OptionString[0] + 1, 21 * sizeof (CHAR16), L"??");
1281 } else {
1282 UnicodeSPrint (OptionString[0] + 1, 21 * sizeof (CHAR16), L"%02d", QuestionValue->Value.date.Month);
1283 }
1284 *(OptionString[0] + 3) = DATE_SEPARATOR;
1285 break;
1286
1287 case 1:
1288 SetUnicodeMem (OptionString[0], 4, L' ');
1289 if (QuestionValue->Value.date.Day == 0xff){
1290 UnicodeSPrint (OptionString[0] + 4, 21 * sizeof (CHAR16), L"??");
1291 } else {
1292 UnicodeSPrint (OptionString[0] + 4, 21 * sizeof (CHAR16), L"%02d", QuestionValue->Value.date.Day);
1293 }
1294 *(OptionString[0] + 6) = DATE_SEPARATOR;
1295 break;
1296
1297 case 2:
1298 SetUnicodeMem (OptionString[0], 7, L' ');
1299 if (QuestionValue->Value.date.Year == 0xff){
1300 UnicodeSPrint (OptionString[0] + 7, 21 * sizeof (CHAR16), L"????");
1301 } else {
1302 UnicodeSPrint (OptionString[0] + 7, 21 * sizeof (CHAR16), L"%04d", QuestionValue->Value.date.Year);
1303 }
1304 *(OptionString[0] + 11) = RIGHT_NUMERIC_DELIMITER;
1305 break;
1306 }
1307 }
1308 break;
1309
1310 case EFI_IFR_TIME_OP:
1311 if (Selected) {
1312 //
1313 // This is similar to numerics
1314 //
1315 Status = GetNumericInput (MenuOption);
1316 } else {
1317 *OptionString = AllocateZeroPool (BufferSize);
1318 ASSERT (*OptionString);
1319
1320 switch (MenuOption->Sequence) {
1321 case 0:
1322 *OptionString[0] = LEFT_NUMERIC_DELIMITER;
1323 if (QuestionValue->Value.time.Hour == 0xff){
1324 UnicodeSPrint (OptionString[0] + 1, 21 * sizeof (CHAR16), L"??");
1325 } else {
1326 UnicodeSPrint (OptionString[0] + 1, 21 * sizeof (CHAR16), L"%02d", QuestionValue->Value.time.Hour);
1327 }
1328 *(OptionString[0] + 3) = TIME_SEPARATOR;
1329 break;
1330
1331 case 1:
1332 SetUnicodeMem (OptionString[0], 4, L' ');
1333 if (QuestionValue->Value.time.Minute == 0xff){
1334 UnicodeSPrint (OptionString[0] + 4, 21 * sizeof (CHAR16), L"??");
1335 } else {
1336 UnicodeSPrint (OptionString[0] + 4, 21 * sizeof (CHAR16), L"%02d", QuestionValue->Value.time.Minute);
1337 }
1338 *(OptionString[0] + 6) = TIME_SEPARATOR;
1339 break;
1340
1341 case 2:
1342 SetUnicodeMem (OptionString[0], 7, L' ');
1343 if (QuestionValue->Value.time.Second == 0xff){
1344 UnicodeSPrint (OptionString[0] + 7, 21 * sizeof (CHAR16), L"??");
1345 } else {
1346 UnicodeSPrint (OptionString[0] + 7, 21 * sizeof (CHAR16), L"%02d", QuestionValue->Value.time.Second);
1347 }
1348 *(OptionString[0] + 9) = RIGHT_NUMERIC_DELIMITER;
1349 break;
1350 }
1351 }
1352 break;
1353
1354 case EFI_IFR_STRING_OP:
1355 if (Selected) {
1356 StringPtr = AllocateZeroPool (Question->CurrentValue.BufferLen + sizeof (CHAR16));
1357 ASSERT (StringPtr);
1358 CopyMem(StringPtr, Question->CurrentValue.Buffer, Question->CurrentValue.BufferLen);
1359
1360 Status = ReadString (MenuOption, gPromptForData, StringPtr);
1361 if (EFI_ERROR (Status)) {
1362 FreePool (StringPtr);
1363 return Status;
1364 }
1365
1366 gUserInput->InputValue.Buffer = AllocateCopyPool (Question->CurrentValue.BufferLen, StringPtr);
1367 gUserInput->InputValue.BufferLen = Question->CurrentValue.BufferLen;
1368 gUserInput->InputValue.Type = Question->CurrentValue.Type;
1369 gUserInput->InputValue.Value.string = HiiSetString(gFormData->HiiHandle, gUserInput->InputValue.Value.string, StringPtr, NULL);
1370 FreePool (StringPtr);
1371 return EFI_SUCCESS;
1372 } else {
1373 *OptionString = AllocateZeroPool (BufferSize);
1374 ASSERT (*OptionString);
1375
1376 if (((CHAR16 *) Question->CurrentValue.Buffer)[0] == 0x0000) {
1377 *(OptionString[0]) = '_';
1378 } else {
1379 if (Question->CurrentValue.BufferLen < BufferSize) {
1380 BufferSize = Question->CurrentValue.BufferLen;
1381 }
1382 CopyMem (OptionString[0], (CHAR16 *) Question->CurrentValue.Buffer, BufferSize);
1383 }
1384 }
1385 break;
1386
1387 case EFI_IFR_PASSWORD_OP:
1388 if (Selected) {
1389 Status = PasswordProcess (MenuOption);
1390 }
1391 break;
1392
1393 default:
1394 break;
1395 }
1396
1397 return Status;
1398 }
1399
1400
1401 /**
1402 Process the help string: Split StringPtr to several lines of strings stored in
1403 FormattedString and the glyph width of each line cannot exceed gHelpBlockWidth.
1404
1405 @param StringPtr The entire help string.
1406 @param FormattedString The oupput formatted string.
1407 @param EachLineWidth The max string length of each line in the formatted string.
1408 @param RowCount TRUE: if Question is selected.
1409
1410 **/
1411 UINTN
1412 ProcessHelpString (
1413 IN CHAR16 *StringPtr,
1414 OUT CHAR16 **FormattedString,
1415 OUT UINT16 *EachLineWidth,
1416 IN UINTN RowCount
1417 )
1418 {
1419 UINTN Index;
1420 CHAR16 *OutputString;
1421 UINTN TotalRowNum;
1422 UINTN CheckedNum;
1423 UINT16 GlyphWidth;
1424 UINT16 LineWidth;
1425 UINT16 MaxStringLen;
1426 UINT16 StringLen;
1427
1428 TotalRowNum = 0;
1429 CheckedNum = 0;
1430 GlyphWidth = 1;
1431 Index = 0;
1432 MaxStringLen = 0;
1433 StringLen = 0;
1434
1435 //
1436 // Set default help string width.
1437 //
1438 LineWidth = (UINT16) (gHelpBlockWidth - 1);
1439
1440 //
1441 // Get row number of the String.
1442 //
1443 while ((StringLen = GetLineByWidth (StringPtr, LineWidth, &GlyphWidth, &Index, &OutputString)) != 0) {
1444 if (StringLen > MaxStringLen) {
1445 MaxStringLen = StringLen;
1446 }
1447
1448 TotalRowNum ++;
1449 FreePool (OutputString);
1450 }
1451 *EachLineWidth = MaxStringLen;
1452
1453 *FormattedString = AllocateZeroPool (TotalRowNum * MaxStringLen * sizeof (CHAR16));
1454 ASSERT (*FormattedString != NULL);
1455
1456 //
1457 // Generate formatted help string array.
1458 //
1459 GlyphWidth = 1;
1460 Index = 0;
1461 while((StringLen = GetLineByWidth (StringPtr, LineWidth, &GlyphWidth, &Index, &OutputString)) != 0) {
1462 CopyMem (*FormattedString + CheckedNum * MaxStringLen, OutputString, StringLen * sizeof (CHAR16));
1463 CheckedNum ++;
1464 FreePool (OutputString);
1465 }
1466
1467 return TotalRowNum;
1468 }
EFI Development Kit II mirror for PVE