VirtualBox

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/HiiDatabaseDxe/Font.c@ 58459

Last change on this file since 58459 was 58459, checked in by vboxsync, 9 years ago

EFI/Firmware: 'svn merge /vendor/edk2/UDK2010.SR1 /vendor/edk2/current .', reverting and removing files+dirs listed in ReadMe.vbox, resolving conflicts with help from ../UDK2014.SP1/. This is a raw untested merge.
  • Property svn:eol-style set to native
File size: 97.9 KB
Line 
1/** @file
2Implementation for EFI_HII_FONT_PROTOCOL.
3
4
5Copyright (c) 2007 - 2014, Intel Corporation. All rights reserved.<BR>
6This program and the accompanying materials
7are licensed and made available under the terms and conditions of the BSD License
8which accompanies this distribution. The full text of the license may be found at
9http://opensource.org/licenses/bsd-license.php
10
11THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
13
14**/
15
16
17#include "HiiDatabase.h"
18
19EFI_GRAPHICS_OUTPUT_BLT_PIXEL mHiiEfiColors[16] = {
20 //
21 // B G R
22 //
23 {0x00, 0x00, 0x00, 0x00}, // BLACK
24 {0x98, 0x00, 0x00, 0x00}, // BLUE
25 {0x00, 0x98, 0x00, 0x00}, // GREEN
26 {0x98, 0x98, 0x00, 0x00}, // CYAN
27 {0x00, 0x00, 0x98, 0x00}, // RED
28 {0x98, 0x00, 0x98, 0x00}, // MAGENTA
29 {0x00, 0x98, 0x98, 0x00}, // BROWN
30 {0x98, 0x98, 0x98, 0x00}, // LIGHTGRAY
31 {0x30, 0x30, 0x30, 0x00}, // DARKGRAY - BRIGHT BLACK
32 {0xff, 0x00, 0x00, 0x00}, // LIGHTBLUE
33 {0x00, 0xff, 0x00, 0x00}, // LIGHTGREEN
34 {0xff, 0xff, 0x00, 0x00}, // LIGHTCYAN
35 {0x00, 0x00, 0xff, 0x00}, // LIGHTRED
36 {0xff, 0x00, 0xff, 0x00}, // LIGHTMAGENTA
37 {0x00, 0xff, 0xff, 0x00}, // YELLOW
38 {0xff, 0xff, 0xff, 0x00}, // WHITE
39};
40
41
42/**
43 Insert a character cell information to the list specified by GlyphInfoList.
44
45 This is a internal function.
46
47 @param CharValue Unicode character value, which identifies a glyph
48 block.
49 @param GlyphInfoList HII_GLYPH_INFO list head.
50 @param Cell Incoming character cell information.
51
52 @retval EFI_SUCCESS Cell information is added to the GlyphInfoList.
53 @retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
54 task.
55
56**/
57EFI_STATUS
58NewCell (
59 IN CHAR16 CharValue,
60 IN LIST_ENTRY *GlyphInfoList,
61 IN EFI_HII_GLYPH_INFO *Cell
62 )
63{
64 HII_GLYPH_INFO *GlyphInfo;
65
66 ASSERT (Cell != NULL && GlyphInfoList != NULL);
67
68 GlyphInfo = (HII_GLYPH_INFO *) AllocateZeroPool (sizeof (HII_GLYPH_INFO));
69 if (GlyphInfo == NULL) {
70 return EFI_OUT_OF_RESOURCES;
71 }
72
73 //
74 // GlyphInfoList stores a list of default character cell information, each is
75 // identified by "CharId".
76 //
77 GlyphInfo->Signature = HII_GLYPH_INFO_SIGNATURE;
78 GlyphInfo->CharId = CharValue;
79 if (Cell->AdvanceX == 0) {
80 Cell->AdvanceX = Cell->Width;
81 }
82 CopyMem (&GlyphInfo->Cell, Cell, sizeof (EFI_HII_GLYPH_INFO));
83 InsertTailList (GlyphInfoList, &GlyphInfo->Entry);
84
85 return EFI_SUCCESS;
86}
87
88
89/**
90 Get a character cell information from the list specified by GlyphInfoList.
91
92 This is a internal function.
93
94 @param CharValue Unicode character value, which identifies a glyph
95 block.
96 @param GlyphInfoList HII_GLYPH_INFO list head.
97 @param Cell Buffer which stores output character cell
98 information.
99
100 @retval EFI_SUCCESS Cell information is added to the GlyphInfoList.
101 @retval EFI_NOT_FOUND The character info specified by CharValue does
102 not exist.
103
104**/
105EFI_STATUS
106GetCell (
107 IN CHAR16 CharValue,
108 IN LIST_ENTRY *GlyphInfoList,
109 OUT EFI_HII_GLYPH_INFO *Cell
110 )
111{
112 HII_GLYPH_INFO *GlyphInfo;
113 LIST_ENTRY *Link;
114
115 ASSERT (Cell != NULL && GlyphInfoList != NULL);
116
117 //
118 // Since the EFI_HII_GIBT_DEFAULTS block won't increment CharValueCurrent,
119 // the value of "CharId" of a default character cell which is used for a
120 // EFI_HII_GIBT_GLYPH_DEFAULT or EFI_HII_GIBT_GLYPHS_DEFAULT should be
121 // less or equal to the value of "CharValueCurrent" of this default block.
122 //
123 // For instance, if the CharId of a GlyphInfoList is {1, 3, 7}, a default glyph
124 // with CharValue equals "7" uses the GlyphInfo with CharId = 7;
125 // a default glyph with CharValue equals "6" uses the GlyphInfo with CharId = 3.
126 //
127 for (Link = GlyphInfoList->BackLink; Link != GlyphInfoList; Link = Link->BackLink) {
128 GlyphInfo = CR (Link, HII_GLYPH_INFO, Entry, HII_GLYPH_INFO_SIGNATURE);
129 if (GlyphInfo->CharId <= CharValue) {
130 CopyMem (Cell, &GlyphInfo->Cell, sizeof (EFI_HII_GLYPH_INFO));
131 return EFI_SUCCESS;
132 }
133 }
134
135 return EFI_NOT_FOUND;
136}
137
138
139/**
140 Convert the glyph for a single character into a bitmap.
141
142 This is a internal function.
143
144 @param Private HII database driver private data.
145 @param Char Character to retrieve.
146 @param StringInfo Points to the string font and color information
147 or NULL if the string should use the default
148 system font and color.
149 @param GlyphBuffer Buffer to store the retrieved bitmap data.
150 @param Cell Points to EFI_HII_GLYPH_INFO structure.
151 @param Attributes If not NULL, output the glyph attributes if any.
152
153 @retval EFI_SUCCESS Glyph bitmap outputted.
154 @retval EFI_OUT_OF_RESOURCES Unable to allocate the output buffer GlyphBuffer.
155 @retval EFI_NOT_FOUND The glyph was unknown can not be found.
156 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
157
158**/
159EFI_STATUS
160GetGlyphBuffer (
161 IN HII_DATABASE_PRIVATE_DATA *Private,
162 IN CHAR16 Char,
163 IN EFI_FONT_INFO *StringInfo,
164 OUT UINT8 **GlyphBuffer,
165 OUT EFI_HII_GLYPH_INFO *Cell,
166 OUT UINT8 *Attributes OPTIONAL
167 )
168{
169 HII_DATABASE_RECORD *Node;
170 LIST_ENTRY *Link;
171 HII_SIMPLE_FONT_PACKAGE_INSTANCE *SimpleFont;
172 LIST_ENTRY *Link1;
173 UINT16 Index;
174 EFI_NARROW_GLYPH Narrow;
175 EFI_WIDE_GLYPH Wide;
176 HII_GLOBAL_FONT_INFO *GlobalFont;
177 UINTN HeaderSize;
178 EFI_NARROW_GLYPH *NarrowPtr;
179 EFI_WIDE_GLYPH *WidePtr;
180
181 if (GlyphBuffer == NULL || Cell == NULL) {
182 return EFI_INVALID_PARAMETER;
183 }
184 if (Private == NULL || Private->Signature != HII_DATABASE_PRIVATE_DATA_SIGNATURE) {
185 return EFI_INVALID_PARAMETER;
186 }
187
188 ZeroMem (Cell, sizeof (EFI_HII_GLYPH_INFO));
189
190 //
191 // If StringInfo is not NULL, it must point to an existing EFI_FONT_INFO rather
192 // than system default font and color.
193 // If NULL, try to find the character in simplified font packages since
194 // default system font is the fixed font (narrow or wide glyph).
195 //
196 if (StringInfo != NULL) {
197 if(!IsFontInfoExisted (Private, StringInfo, NULL, NULL, &GlobalFont)) {
198 return EFI_INVALID_PARAMETER;
199 }
200 if (Attributes != NULL) {
201 *Attributes = PROPORTIONAL_GLYPH;
202 }
203 return FindGlyphBlock (GlobalFont->FontPackage, Char, GlyphBuffer, Cell, NULL);
204 } else {
205 HeaderSize = sizeof (EFI_HII_SIMPLE_FONT_PACKAGE_HDR);
206
207 for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
208 Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
209 for (Link1 = Node->PackageList->SimpleFontPkgHdr.ForwardLink;
210 Link1 != &Node->PackageList->SimpleFontPkgHdr;
211 Link1 = Link1->ForwardLink
212 ) {
213 SimpleFont = CR (Link1, HII_SIMPLE_FONT_PACKAGE_INSTANCE, SimpleFontEntry, HII_S_FONT_PACKAGE_SIGNATURE);
214 //
215 // Search the narrow glyph array
216 //
217 NarrowPtr = (EFI_NARROW_GLYPH *) ((UINT8 *) (SimpleFont->SimpleFontPkgHdr) + HeaderSize);
218 for (Index = 0; Index < SimpleFont->SimpleFontPkgHdr->NumberOfNarrowGlyphs; Index++) {
219 CopyMem (&Narrow, NarrowPtr + Index,sizeof (EFI_NARROW_GLYPH));
220 if (Narrow.UnicodeWeight == Char) {
221 *GlyphBuffer = (UINT8 *) AllocateZeroPool (EFI_GLYPH_HEIGHT);
222 if (*GlyphBuffer == NULL) {
223 return EFI_OUT_OF_RESOURCES;
224 }
225 Cell->Width = EFI_GLYPH_WIDTH;
226 Cell->Height = EFI_GLYPH_HEIGHT;
227 Cell->AdvanceX = Cell->Width;
228 CopyMem (*GlyphBuffer, Narrow.GlyphCol1, Cell->Height);
229 if (Attributes != NULL) {
230 *Attributes = (UINT8) (Narrow.Attributes | NARROW_GLYPH);
231 }
232 return EFI_SUCCESS;
233 }
234 }
235 //
236 // Search the wide glyph array
237 //
238 WidePtr = (EFI_WIDE_GLYPH *) (NarrowPtr + SimpleFont->SimpleFontPkgHdr->NumberOfNarrowGlyphs);
239 for (Index = 0; Index < SimpleFont->SimpleFontPkgHdr->NumberOfWideGlyphs; Index++) {
240 CopyMem (&Wide, WidePtr + Index, sizeof (EFI_WIDE_GLYPH));
241 if (Wide.UnicodeWeight == Char) {
242 *GlyphBuffer = (UINT8 *) AllocateZeroPool (EFI_GLYPH_HEIGHT * 2);
243 if (*GlyphBuffer == NULL) {
244 return EFI_OUT_OF_RESOURCES;
245 }
246 Cell->Width = EFI_GLYPH_WIDTH * 2;
247 Cell->Height = EFI_GLYPH_HEIGHT;
248 Cell->AdvanceX = Cell->Width;
249 CopyMem (*GlyphBuffer, Wide.GlyphCol1, EFI_GLYPH_HEIGHT);
250 CopyMem (*GlyphBuffer + EFI_GLYPH_HEIGHT, Wide.GlyphCol2, EFI_GLYPH_HEIGHT);
251 if (Attributes != NULL) {
252 *Attributes = (UINT8) (Wide.Attributes | EFI_GLYPH_WIDE);
253 }
254 return EFI_SUCCESS;
255 }
256 }
257 }
258 }
259 }
260
261 return EFI_NOT_FOUND;
262}
263
264/**
265 Convert bitmap data of the glyph to blt structure.
266
267 This is a internal function.
268
269 @param GlyphBuffer Buffer points to bitmap data of glyph.
270 @param Foreground The color of the "on" pixels in the glyph in the
271 bitmap.
272 @param Background The color of the "off" pixels in the glyph in the
273 bitmap.
274 @param ImageWidth Width of the whole image in pixels.
275 @param RowWidth The width of the text on the line, in pixels.
276 @param RowHeight The height of the line, in pixels.
277 @param Transparent If TRUE, the Background color is ignored and all
278 "off" pixels in the character's drawn wil use the
279 pixel value from BltBuffer.
280 @param Origin On input, points to the origin of the to be
281 displayed character, on output, points to the
282 next glyph's origin.
283
284**/
285VOID
286NarrowGlyphToBlt (
287 IN UINT8 *GlyphBuffer,
288 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground,
289 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background,
290 IN UINT16 ImageWidth,
291 IN UINTN RowWidth,
292 IN UINTN RowHeight,
293 IN BOOLEAN Transparent,
294 IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL **Origin
295 )
296{
297 UINT8 Xpos;
298 UINT8 Ypos;
299 UINT8 Height;
300 UINT8 Width;
301 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Buffer;
302
303 ASSERT (GlyphBuffer != NULL && Origin != NULL && *Origin != NULL);
304
305 Height = EFI_GLYPH_HEIGHT;
306 Width = EFI_GLYPH_WIDTH;
307
308 //
309 // Move position to the left-top corner of char.
310 //
311 Buffer = *Origin - EFI_GLYPH_HEIGHT * ImageWidth;
312
313 //
314 // Char may be partially displayed when CLIP_X or CLIP_Y is not set.
315 //
316 if (RowHeight < Height) {
317 Height = (UINT8) RowHeight;
318 }
319 if (RowWidth < Width) {
320 Width = (UINT8) RowWidth;
321 }
322
323 for (Ypos = 0; Ypos < Height; Ypos++) {
324 for (Xpos = 0; Xpos < Width; Xpos++) {
325 if ((GlyphBuffer[Ypos] & (1 << (EFI_GLYPH_WIDTH - Xpos - 1))) != 0) {
326 Buffer[Ypos * ImageWidth + Xpos] = Foreground;
327 } else {
328 if (!Transparent) {
329 Buffer[Ypos * ImageWidth + Xpos] = Background;
330 }
331 }
332 }
333 }
334
335 *Origin = *Origin + EFI_GLYPH_WIDTH;
336}
337
338
339/**
340 Convert bitmap data of the glyph to blt structure.
341
342 This is a internal function.
343
344 @param GlyphBuffer Buffer points to bitmap data of glyph.
345 @param Foreground The color of the "on" pixels in the glyph in the
346 bitmap.
347 @param Background The color of the "off" pixels in the glyph in the
348 bitmap.
349 @param ImageWidth Width of the whole image in pixels.
350 @param BaseLine BaseLine in the line.
351 @param RowWidth The width of the text on the line, in pixels.
352 @param RowHeight The height of the line, in pixels.
353 @param Transparent If TRUE, the Background color is ignored and all
354 "off" pixels in the character's drawn wil use the
355 pixel value from BltBuffer.
356 @param Cell Points to EFI_HII_GLYPH_INFO structure.
357 @param Attributes The attribute of incoming glyph in GlyphBuffer.
358 @param Origin On input, points to the origin of the to be
359 displayed character, on output, points to the
360 next glyph's origin.
361
362
363**/
364VOID
365GlyphToBlt (
366 IN UINT8 *GlyphBuffer,
367 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground,
368 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background,
369 IN UINT16 ImageWidth,
370 IN UINT16 BaseLine,
371 IN UINTN RowWidth,
372 IN UINTN RowHeight,
373 IN BOOLEAN Transparent,
374 IN CONST EFI_HII_GLYPH_INFO *Cell,
375 IN UINT8 Attributes,
376 IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL **Origin
377 )
378{
379 UINT16 Xpos;
380 UINT16 Ypos;
381 UINT8 Data;
382 UINT16 Index;
383 UINT16 YposOffset;
384 UINTN OffsetY;
385 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
386
387 ASSERT (Origin != NULL && *Origin != NULL && Cell != NULL);
388
389 //
390 // Only adjust origin position if char has no bitmap.
391 //
392 if (GlyphBuffer == NULL) {
393 *Origin = *Origin + Cell->AdvanceX;
394 return;
395 }
396 //
397 // Move position to the left-top corner of char.
398 //
399 BltBuffer = *Origin + Cell->OffsetX - (Cell->OffsetY + Cell->Height) * ImageWidth;
400 YposOffset = (UINT16) (BaseLine - (Cell->OffsetY + Cell->Height));
401
402 //
403 // Since non-spacing key will be printed OR'd with the previous glyph, don't
404 // write 0.
405 //
406 if ((Attributes & EFI_GLYPH_NON_SPACING) == EFI_GLYPH_NON_SPACING) {
407 Transparent = TRUE;
408 }
409
410 //
411 // The glyph's upper left hand corner pixel is the most significant bit of the
412 // first bitmap byte.
413 //
414 for (Ypos = 0; Ypos < Cell->Height && ((UINTN) (Ypos + YposOffset) < RowHeight); Ypos++) {
415 OffsetY = BITMAP_LEN_1_BIT (Cell->Width, Ypos);
416
417 //
418 // All bits in these bytes are meaningful.
419 //
420 for (Xpos = 0; Xpos < Cell->Width / 8; Xpos++) {
421 Data = *(GlyphBuffer + OffsetY + Xpos);
422 for (Index = 0; Index < 8 && ((UINTN) (Xpos * 8 + Index + Cell->OffsetX) < RowWidth); Index++) {
423 if ((Data & (1 << (8 - Index - 1))) != 0) {
424 BltBuffer[Ypos * ImageWidth + Xpos * 8 + Index] = Foreground;
425 } else {
426 if (!Transparent) {
427 BltBuffer[Ypos * ImageWidth + Xpos * 8 + Index] = Background;
428 }
429 }
430 }
431 }
432
433 if (Cell->Width % 8 != 0) {
434 //
435 // There are some padding bits in this byte. Ignore them.
436 //
437 Data = *(GlyphBuffer + OffsetY + Xpos);
438 for (Index = 0; Index < Cell->Width % 8 && ((UINTN) (Xpos * 8 + Index + Cell->OffsetX) < RowWidth); Index++) {
439 if ((Data & (1 << (8 - Index - 1))) != 0) {
440 BltBuffer[Ypos * ImageWidth + Xpos * 8 + Index] = Foreground;
441 } else {
442 if (!Transparent) {
443 BltBuffer[Ypos * ImageWidth + Xpos * 8 + Index] = Background;
444 }
445 }
446 }
447 } // end of if (Width % 8...)
448
449 } // end of for (Ypos=0...)
450
451 *Origin = *Origin + Cell->AdvanceX;
452}
453
454
455/**
456 Convert bitmap data of the glyph to blt structure.
457
458 This is a internal function.
459
460 @param GlyphBuffer Buffer points to bitmap data of glyph.
461 @param Foreground The color of the "on" pixels in the glyph in the
462 bitmap.
463 @param Background The color of the "off" pixels in the glyph in the
464 bitmap.
465 @param ImageWidth Width of the whole image in pixels.
466 @param BaseLine BaseLine in the line.
467 @param RowWidth The width of the text on the line, in pixels.
468 @param RowHeight The height of the line, in pixels.
469 @param Transparent If TRUE, the Background color is ignored and all
470 "off" pixels in the character's drawn wil use the
471 pixel value from BltBuffer.
472 @param Cell Points to EFI_HII_GLYPH_INFO structure.
473 @param Attributes The attribute of incoming glyph in GlyphBuffer.
474 @param Origin On input, points to the origin of the to be
475 displayed character, on output, points to the
476 next glyph's origin.
477
478 @return Points to the address of next origin node in BltBuffer.
479
480**/
481VOID
482GlyphToImage (
483 IN UINT8 *GlyphBuffer,
484 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground,
485 IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background,
486 IN UINT16 ImageWidth,
487 IN UINT16 BaseLine,
488 IN UINTN RowWidth,
489 IN UINTN RowHeight,
490 IN BOOLEAN Transparent,
491 IN CONST EFI_HII_GLYPH_INFO *Cell,
492 IN UINT8 Attributes,
493 IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL **Origin
494 )
495{
496 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Buffer;
497
498 ASSERT (Origin != NULL && *Origin != NULL && Cell != NULL);
499
500 Buffer = *Origin;
501
502 if ((Attributes & EFI_GLYPH_NON_SPACING) == EFI_GLYPH_NON_SPACING) {
503 //
504 // This character is a non-spacing key, print it OR'd with the previous glyph.
505 // without advancing cursor.
506 //
507 Buffer -= Cell->AdvanceX;
508 GlyphToBlt (
509 GlyphBuffer,
510 Foreground,
511 Background,
512 ImageWidth,
513 BaseLine,
514 RowWidth,
515 RowHeight,
516 Transparent,
517 Cell,
518 Attributes,
519 &Buffer
520 );
521
522 } else if ((Attributes & EFI_GLYPH_WIDE) == EFI_GLYPH_WIDE) {
523 //
524 // This character is wide glyph, i.e. 16 pixels * 19 pixels.
525 // Draw it as two narrow glyphs.
526 //
527 NarrowGlyphToBlt (
528 GlyphBuffer,
529 Foreground,
530 Background,
531 ImageWidth,
532 RowWidth,
533 RowHeight,
534 Transparent,
535 Origin
536 );
537
538 NarrowGlyphToBlt (
539 GlyphBuffer + EFI_GLYPH_HEIGHT,
540 Foreground,
541 Background,
542 ImageWidth,
543 RowWidth,
544 RowHeight,
545 Transparent,
546 Origin
547 );
548
549 } else if ((Attributes & NARROW_GLYPH) == NARROW_GLYPH) {
550 //
551 // This character is narrow glyph, i.e. 8 pixels * 19 pixels.
552 //
553 NarrowGlyphToBlt (
554 GlyphBuffer,
555 Foreground,
556 Background,
557 ImageWidth,
558 RowWidth,
559 RowHeight,
560 Transparent,
561 Origin
562 );
563
564 } else if ((Attributes & PROPORTIONAL_GLYPH) == PROPORTIONAL_GLYPH) {
565 //
566 // This character is proportional glyph, i.e. Cell->Width * Cell->Height pixels.
567 //
568 GlyphToBlt (
569 GlyphBuffer,
570 Foreground,
571 Background,
572 ImageWidth,
573 BaseLine,
574 RowWidth,
575 RowHeight,
576 Transparent,
577 Cell,
578 Attributes,
579 Origin
580 );
581 }
582}
583
584
585/**
586 Write the output parameters of FindGlyphBlock().
587
588 This is a internal function.
589
590 @param BufferIn Buffer which stores the bitmap data of the found
591 block.
592 @param BufferLen Length of BufferIn.
593 @param InputCell Buffer which stores cell information of the
594 encoded bitmap.
595 @param GlyphBuffer Output the corresponding bitmap data of the found
596 block. It is the caller's responsiblity to free
597 this buffer.
598 @param Cell Output cell information of the encoded bitmap.
599 @param GlyphBufferLen If not NULL, output the length of GlyphBuffer.
600
601 @retval EFI_SUCCESS The operation is performed successfully.
602 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
603 @retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
604 task.
605
606**/
607EFI_STATUS
608WriteOutputParam (
609 IN UINT8 *BufferIn,
610 IN UINTN BufferLen,
611 IN EFI_HII_GLYPH_INFO *InputCell,
612 OUT UINT8 **GlyphBuffer, OPTIONAL
613 OUT EFI_HII_GLYPH_INFO *Cell, OPTIONAL
614 OUT UINTN *GlyphBufferLen OPTIONAL
615 )
616{
617 if (BufferIn == NULL || InputCell == NULL) {
618 return EFI_INVALID_PARAMETER;
619 }
620
621 if (Cell != NULL) {
622 CopyMem (Cell, InputCell, sizeof (EFI_HII_GLYPH_INFO));
623 }
624
625 if (GlyphBuffer != NULL && BufferLen > 0) {
626 *GlyphBuffer = (UINT8 *) AllocateZeroPool (BufferLen);
627 if (*GlyphBuffer == NULL) {
628 return EFI_OUT_OF_RESOURCES;
629 }
630 CopyMem (*GlyphBuffer, BufferIn, BufferLen);
631 }
632
633 if (GlyphBufferLen != NULL) {
634 *GlyphBufferLen = BufferLen;
635 }
636
637 return EFI_SUCCESS;
638}
639
640
641/**
642 Parse all glyph blocks to find a glyph block specified by CharValue.
643 If CharValue = (CHAR16) (-1), collect all default character cell information
644 within this font package and backup its information.
645
646 @param FontPackage Hii string package instance.
647 @param CharValue Unicode character value, which identifies a glyph
648 block.
649 @param GlyphBuffer Output the corresponding bitmap data of the found
650 block. It is the caller's responsiblity to free
651 this buffer.
652 @param Cell Output cell information of the encoded bitmap.
653 @param GlyphBufferLen If not NULL, output the length of GlyphBuffer.
654
655 @retval EFI_SUCCESS The bitmap data is retrieved successfully.
656 @retval EFI_NOT_FOUND The specified CharValue does not exist in current
657 database.
658 @retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
659 task.
660
661**/
662EFI_STATUS
663FindGlyphBlock (
664 IN HII_FONT_PACKAGE_INSTANCE *FontPackage,
665 IN CHAR16 CharValue,
666 OUT UINT8 **GlyphBuffer, OPTIONAL
667 OUT EFI_HII_GLYPH_INFO *Cell, OPTIONAL
668 OUT UINTN *GlyphBufferLen OPTIONAL
669 )
670{
671 EFI_STATUS Status;
672 UINT8 *BlockPtr;
673 UINT16 CharCurrent;
674 UINT16 Length16;
675 UINT32 Length32;
676 EFI_HII_GIBT_GLYPHS_BLOCK Glyphs;
677 UINTN BufferLen;
678 UINT16 Index;
679 EFI_HII_GLYPH_INFO DefaultCell;
680 EFI_HII_GLYPH_INFO LocalCell;
681 INT16 MinOffsetY;
682 UINT16 BaseLine;
683
684 ASSERT (FontPackage != NULL);
685 ASSERT (FontPackage->Signature == HII_FONT_PACKAGE_SIGNATURE);
686 BaseLine = 0;
687 MinOffsetY = 0;
688
689 if (CharValue == (CHAR16) (-1)) {
690 //
691 // Collect the cell information specified in font package fixed header.
692 // Use CharValue =0 to represent this particular cell.
693 //
694 Status = NewCell (
695 0,
696 &FontPackage->GlyphInfoList,
697 (EFI_HII_GLYPH_INFO *) ((UINT8 *) FontPackage->FontPkgHdr + 3 * sizeof (UINT32))
698 );
699 if (EFI_ERROR (Status)) {
700 return Status;
701 }
702 CopyMem (
703 &LocalCell,
704 (UINT8 *) FontPackage->FontPkgHdr + 3 * sizeof (UINT32),
705 sizeof (EFI_HII_GLYPH_INFO)
706 );
707 BaseLine = (UINT16) (LocalCell.Height + LocalCell.OffsetY);
708 if (MinOffsetY > LocalCell.OffsetY) {
709 MinOffsetY = LocalCell.OffsetY;
710 }
711 }
712
713 BlockPtr = FontPackage->GlyphBlock;
714 CharCurrent = 1;
715 BufferLen = 0;
716
717 while (*BlockPtr != EFI_HII_GIBT_END) {
718 switch (*BlockPtr) {
719 case EFI_HII_GIBT_DEFAULTS:
720 //
721 // Collect all default character cell information specified by
722 // EFI_HII_GIBT_DEFAULTS.
723 //
724 if (CharValue == (CHAR16) (-1)) {
725 Status = NewCell (
726 CharCurrent,
727 &FontPackage->GlyphInfoList,
728 (EFI_HII_GLYPH_INFO *) (BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK))
729 );
730 if (EFI_ERROR (Status)) {
731 return Status;
732 }
733 CopyMem (
734 &LocalCell,
735 BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK),
736 sizeof (EFI_HII_GLYPH_INFO)
737 );
738 if (BaseLine < LocalCell.Height + LocalCell.OffsetY) {
739 BaseLine = (UINT16) (LocalCell.Height + LocalCell.OffsetY);
740 }
741 if (MinOffsetY > LocalCell.OffsetY) {
742 MinOffsetY = LocalCell.OffsetY;
743 }
744 }
745 BlockPtr += sizeof (EFI_HII_GIBT_DEFAULTS_BLOCK);
746 break;
747
748 case EFI_HII_GIBT_DUPLICATE:
749 if (CharCurrent == CharValue) {
750 CopyMem (&CharValue, BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK), sizeof (CHAR16));
751 CharCurrent = 1;
752 BlockPtr = FontPackage->GlyphBlock;
753 continue;
754 }
755 CharCurrent++;
756 BlockPtr += sizeof (EFI_HII_GIBT_DUPLICATE_BLOCK);
757 break;
758
759 case EFI_HII_GIBT_EXT1:
760 BlockPtr += *(UINT8*)((UINTN)BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK) + sizeof (UINT8));
761 break;
762 case EFI_HII_GIBT_EXT2:
763 CopyMem (
764 &Length16,
765 (UINT8*)((UINTN)BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK) + sizeof (UINT8)),
766 sizeof (UINT16)
767 );
768 BlockPtr += Length16;
769 break;
770 case EFI_HII_GIBT_EXT4:
771 CopyMem (
772 &Length32,
773 (UINT8*)((UINTN)BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK) + sizeof (UINT8)),
774 sizeof (UINT32)
775 );
776 BlockPtr += Length32;
777 break;
778
779 case EFI_HII_GIBT_GLYPH:
780 CopyMem (
781 &LocalCell,
782 BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK),
783 sizeof (EFI_HII_GLYPH_INFO)
784 );
785 if (CharValue == (CHAR16) (-1)) {
786 if (BaseLine < LocalCell.Height + LocalCell.OffsetY) {
787 BaseLine = (UINT16) (LocalCell.Height + LocalCell.OffsetY);
788 }
789 if (MinOffsetY > LocalCell.OffsetY) {
790 MinOffsetY = LocalCell.OffsetY;
791 }
792 }
793 BufferLen = BITMAP_LEN_1_BIT (LocalCell.Width, LocalCell.Height);
794 if (CharCurrent == CharValue) {
795 return WriteOutputParam (
796 (UINT8*)((UINTN)BlockPtr + sizeof (EFI_HII_GIBT_GLYPH_BLOCK) - sizeof (UINT8)),
797 BufferLen,
798 &LocalCell,
799 GlyphBuffer,
800 Cell,
801 GlyphBufferLen
802 );
803 }
804 CharCurrent++;
805 BlockPtr += sizeof (EFI_HII_GIBT_GLYPH_BLOCK) - sizeof (UINT8) + BufferLen;
806 break;
807
808 case EFI_HII_GIBT_GLYPHS:
809 BlockPtr += sizeof (EFI_HII_GLYPH_BLOCK);
810 CopyMem (&Glyphs.Cell, BlockPtr, sizeof (EFI_HII_GLYPH_INFO));
811 BlockPtr += sizeof (EFI_HII_GLYPH_INFO);
812 CopyMem (&Glyphs.Count, BlockPtr, sizeof (UINT16));
813 BlockPtr += sizeof (UINT16);
814
815 if (CharValue == (CHAR16) (-1)) {
816 if (BaseLine < Glyphs.Cell.Height + Glyphs.Cell.OffsetY) {
817 BaseLine = (UINT16) (Glyphs.Cell.Height + Glyphs.Cell.OffsetY);
818 }
819 if (MinOffsetY > Glyphs.Cell.OffsetY) {
820 MinOffsetY = Glyphs.Cell.OffsetY;
821 }
822 }
823
824 BufferLen = BITMAP_LEN_1_BIT (Glyphs.Cell.Width, Glyphs.Cell.Height);
825 for (Index = 0; Index < Glyphs.Count; Index++) {
826 if (CharCurrent + Index == CharValue) {
827 return WriteOutputParam (
828 BlockPtr,
829 BufferLen,
830 &Glyphs.Cell,
831 GlyphBuffer,
832 Cell,
833 GlyphBufferLen
834 );
835 }
836 BlockPtr += BufferLen;
837 }
838 CharCurrent = (UINT16) (CharCurrent + Glyphs.Count);
839 break;
840
841 case EFI_HII_GIBT_GLYPH_DEFAULT:
842 Status = GetCell (CharCurrent, &FontPackage->GlyphInfoList, &DefaultCell);
843 if (EFI_ERROR (Status)) {
844 return Status;
845 }
846 BufferLen = BITMAP_LEN_1_BIT (DefaultCell.Width, DefaultCell.Height);
847
848 if (CharCurrent == CharValue) {
849 return WriteOutputParam (
850 BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK),
851 BufferLen,
852 &DefaultCell,
853 GlyphBuffer,
854 Cell,
855 GlyphBufferLen
856 );
857 }
858 CharCurrent++;
859 BlockPtr += sizeof (EFI_HII_GLYPH_BLOCK) + BufferLen;
860 break;
861
862 case EFI_HII_GIBT_GLYPHS_DEFAULT:
863 CopyMem (&Length16, BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK), sizeof (UINT16));
864 Status = GetCell (CharCurrent, &FontPackage->GlyphInfoList, &DefaultCell);
865 if (EFI_ERROR (Status)) {
866 return Status;
867 }
868 BufferLen = BITMAP_LEN_1_BIT (DefaultCell.Width, DefaultCell.Height);
869 BlockPtr += sizeof (EFI_HII_GIBT_GLYPHS_DEFAULT_BLOCK) - sizeof (UINT8);
870 for (Index = 0; Index < Length16; Index++) {
871 if (CharCurrent + Index == CharValue) {
872 return WriteOutputParam (
873 BlockPtr,
874 BufferLen,
875 &DefaultCell,
876 GlyphBuffer,
877 Cell,
878 GlyphBufferLen
879 );
880 }
881 BlockPtr += BufferLen;
882 }
883 CharCurrent = (UINT16) (CharCurrent + Length16);
884 break;
885
886 case EFI_HII_GIBT_SKIP1:
887 CharCurrent = (UINT16) (CharCurrent + (UINT16) (*(BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK))));
888 BlockPtr += sizeof (EFI_HII_GIBT_SKIP1_BLOCK);
889 break;
890 case EFI_HII_GIBT_SKIP2:
891 CopyMem (&Length16, BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK), sizeof (UINT16));
892 CharCurrent = (UINT16) (CharCurrent + Length16);
893 BlockPtr += sizeof (EFI_HII_GIBT_SKIP2_BLOCK);
894 break;
895 default:
896 ASSERT (FALSE);
897 break;
898 }
899
900 if (CharValue < CharCurrent) {
901 return EFI_NOT_FOUND;
902 }
903 }
904
905 if (CharValue == (CHAR16) (-1)) {
906 FontPackage->BaseLine = BaseLine;
907 FontPackage->Height = (UINT16) (BaseLine - MinOffsetY);
908 return EFI_SUCCESS;
909 }
910
911 return EFI_NOT_FOUND;
912}
913
914
915/**
916 Copy a Font Name to a new created EFI_FONT_INFO structure.
917
918 This is a internal function.
919
920 @param FontName NULL-terminated string.
921 @param FontInfo a new EFI_FONT_INFO which stores the FontName.
922 It's caller's responsibility to free this buffer.
923
924 @retval EFI_SUCCESS FontInfo is allocated and copied with FontName.
925 @retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
926 task.
927
928**/
929EFI_STATUS
930SaveFontName (
931 IN EFI_STRING FontName,
932 OUT EFI_FONT_INFO **FontInfo
933 )
934{
935 UINTN FontInfoLen;
936
937 ASSERT (FontName != NULL && FontInfo != NULL);
938
939 FontInfoLen = sizeof (EFI_FONT_INFO) - sizeof (CHAR16) + StrSize (FontName);
940 *FontInfo = (EFI_FONT_INFO *) AllocateZeroPool (FontInfoLen);
941 if (*FontInfo == NULL) {
942 return EFI_OUT_OF_RESOURCES;
943 }
944
945 StrCpy ((*FontInfo)->FontName, FontName);
946 return EFI_SUCCESS;
947}
948
949
950/**
951 Retrieve system default font and color.
952
953 @param Private HII database driver private data.
954 @param FontInfo Points to system default font output-related
955 information. It's caller's responsibility to free
956 this buffer.
957 @param FontInfoSize If not NULL, output the size of buffer FontInfo.
958
959 @retval EFI_SUCCESS Cell information is added to the GlyphInfoList.
960 @retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
961 task.
962 @retval EFI_INVALID_PARAMETER Any input parameter is invalid.
963
964**/
965EFI_STATUS
966GetSystemFont (
967 IN HII_DATABASE_PRIVATE_DATA *Private,
968 OUT EFI_FONT_DISPLAY_INFO **FontInfo,
969 OUT UINTN *FontInfoSize OPTIONAL
970 )
971{
972 EFI_FONT_DISPLAY_INFO *Info;
973 UINTN InfoSize;
974
975 if (Private == NULL || Private->Signature != HII_DATABASE_PRIVATE_DATA_SIGNATURE) {
976 return EFI_INVALID_PARAMETER;
977 }
978 if (FontInfo == NULL) {
979 return EFI_INVALID_PARAMETER;
980 }
981
982 //
983 // The standard font always has the name "sysdefault".
984 //
985 InfoSize = sizeof (EFI_FONT_DISPLAY_INFO) - sizeof (CHAR16) + StrSize (L"sysdefault");
986 Info = (EFI_FONT_DISPLAY_INFO *) AllocateZeroPool (InfoSize);
987 if (Info == NULL) {
988 return EFI_OUT_OF_RESOURCES;
989 }
990
991 Info->ForegroundColor = mHiiEfiColors[Private->Attribute & 0x0f];
992 Info->BackgroundColor = mHiiEfiColors[Private->Attribute >> 4];
993 Info->FontInfoMask = EFI_FONT_INFO_SYS_FONT | EFI_FONT_INFO_SYS_SIZE | EFI_FONT_INFO_SYS_STYLE;
994 Info->FontInfo.FontStyle = 0;
995 Info->FontInfo.FontSize = EFI_GLYPH_HEIGHT;
996 StrCpy (Info->FontInfo.FontName, L"sysdefault");
997
998 *FontInfo = Info;
999 if (FontInfoSize != NULL) {
1000 *FontInfoSize = InfoSize;
1001 }
1002 return EFI_SUCCESS;
1003}
1004
1005
1006/**
1007 Check whether EFI_FONT_DISPLAY_INFO points to system default font and color or
1008 returns the system default according to the optional inputs.
1009
1010 This is a internal function.
1011
1012 @param Private HII database driver private data.
1013 @param StringInfo Points to the string output information,
1014 including the color and font.
1015 @param SystemInfo If not NULL, points to system default font and color.
1016
1017 @param SystemInfoLen If not NULL, output the length of default system
1018 info.
1019
1020 @retval TRUE Yes, it points to system default.
1021 @retval FALSE No.
1022
1023**/
1024BOOLEAN
1025IsSystemFontInfo (
1026 IN HII_DATABASE_PRIVATE_DATA *Private,
1027 IN EFI_FONT_DISPLAY_INFO *StringInfo,
1028 OUT EFI_FONT_DISPLAY_INFO **SystemInfo, OPTIONAL
1029 OUT UINTN *SystemInfoLen OPTIONAL
1030 )
1031{
1032 EFI_STATUS Status;
1033 EFI_FONT_DISPLAY_INFO *SystemDefault;
1034 UINTN DefaultLen;
1035 BOOLEAN Flag;
1036
1037 ASSERT (Private != NULL && Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);
1038
1039 if (StringInfo == NULL && SystemInfo == NULL) {
1040 return TRUE;
1041 }
1042
1043 SystemDefault = NULL;
1044 DefaultLen = 0;
1045
1046 Status = GetSystemFont (Private, &SystemDefault, &DefaultLen);
1047 ASSERT_EFI_ERROR (Status);
1048 ASSERT ((SystemDefault != NULL) && (DefaultLen != 0));
1049
1050 //
1051 // Record the system default info.
1052 //
1053 if (SystemInfo != NULL) {
1054 *SystemInfo = SystemDefault;
1055 }
1056
1057 if (SystemInfoLen != NULL) {
1058 *SystemInfoLen = DefaultLen;
1059 }
1060
1061 if (StringInfo == NULL) {
1062 return TRUE;
1063 }
1064
1065 Flag = FALSE;
1066 //
1067 // Check the FontInfoMask to see whether it is retrieving system info.
1068 //
1069 if ((StringInfo->FontInfoMask & (EFI_FONT_INFO_SYS_FONT | EFI_FONT_INFO_ANY_FONT)) == 0) {
1070 if (StrCmp (StringInfo->FontInfo.FontName, SystemDefault->FontInfo.FontName) != 0) {
1071 goto Exit;
1072 }
1073 }
1074 if ((StringInfo->FontInfoMask & (EFI_FONT_INFO_SYS_SIZE | EFI_FONT_INFO_ANY_SIZE)) == 0) {
1075 if (StringInfo->FontInfo.FontSize != SystemDefault->FontInfo.FontSize) {
1076 goto Exit;
1077 }
1078 }
1079 if ((StringInfo->FontInfoMask & (EFI_FONT_INFO_SYS_STYLE | EFI_FONT_INFO_ANY_STYLE)) == 0) {
1080 if (StringInfo->FontInfo.FontStyle != SystemDefault->FontInfo.FontStyle) {
1081 goto Exit;
1082 }
1083 }
1084 if ((StringInfo->FontInfoMask & EFI_FONT_INFO_SYS_FORE_COLOR) == 0) {
1085 if (CompareMem (
1086 &StringInfo->ForegroundColor,
1087 &SystemDefault->ForegroundColor,
1088 sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
1089 ) != 0) {
1090 goto Exit;
1091 }
1092 }
1093 if ((StringInfo->FontInfoMask & EFI_FONT_INFO_SYS_BACK_COLOR) == 0) {
1094 if (CompareMem (
1095 &StringInfo->BackgroundColor,
1096 &SystemDefault->BackgroundColor,
1097 sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
1098 ) != 0) {
1099 goto Exit;
1100 }
1101 }
1102
1103 Flag = TRUE;
1104
1105Exit:
1106 if (SystemInfo == NULL) {
1107 if (SystemDefault != NULL) {
1108 FreePool (SystemDefault);
1109 }
1110 }
1111 return Flag;
1112}
1113
1114
1115/**
1116 This function checks whether EFI_FONT_INFO exists in current database. If
1117 FontInfoMask is specified, check what options can be used to make a match.
1118 Note that the masks relate to where the system default should be supplied
1119 are ignored by this function.
1120
1121 @param Private Hii database private structure.
1122 @param FontInfo Points to EFI_FONT_INFO structure.
1123 @param FontInfoMask If not NULL, describes what options can be used
1124 to make a match between the font requested and
1125 the font available. The caller must guarantee
1126 this mask is valid.
1127 @param FontHandle On entry, Points to the font handle returned by a
1128 previous call to GetFontInfo() or NULL to start
1129 with the first font.
1130 @param GlobalFontInfo If not NULL, output the corresponding globa font
1131 info.
1132
1133 @retval TRUE Existed
1134 @retval FALSE Not existed
1135
1136**/
1137BOOLEAN
1138IsFontInfoExisted (
1139 IN HII_DATABASE_PRIVATE_DATA *Private,
1140 IN EFI_FONT_INFO *FontInfo,
1141 IN EFI_FONT_INFO_MASK *FontInfoMask, OPTIONAL
1142 IN EFI_FONT_HANDLE FontHandle, OPTIONAL
1143 OUT HII_GLOBAL_FONT_INFO **GlobalFontInfo OPTIONAL
1144 )
1145{
1146 HII_GLOBAL_FONT_INFO *GlobalFont;
1147 HII_GLOBAL_FONT_INFO *GlobalFontBackup1;
1148 HII_GLOBAL_FONT_INFO *GlobalFontBackup2;
1149 LIST_ENTRY *Link;
1150 EFI_FONT_INFO_MASK Mask;
1151 BOOLEAN Matched;
1152 BOOLEAN VagueMatched1;
1153 BOOLEAN VagueMatched2;
1154
1155 ASSERT (Private != NULL && Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);
1156 ASSERT (FontInfo != NULL);
1157
1158 //
1159 // Matched flag represents an exactly match; VagueMatched1 repensents a RESIZE
1160 // or RESTYLE match; VagueMatched2 represents a RESIZE | RESTYLE match.
1161 //
1162 Matched = FALSE;
1163 VagueMatched1 = FALSE;
1164 VagueMatched2 = FALSE;
1165
1166 Mask = 0;
1167 GlobalFontBackup1 = NULL;
1168 GlobalFontBackup2 = NULL;
1169
1170 // The process of where the system default should be supplied instead of
1171 // the specified font info beyonds this function's scope.
1172 //
1173 if (FontInfoMask != NULL) {
1174 Mask = *FontInfoMask & (~SYS_FONT_INFO_MASK);
1175 }
1176
1177 //
1178 // If not NULL, FontHandle points to the next node of the last searched font
1179 // node by previous call.
1180 //
1181 if (FontHandle == NULL) {
1182 Link = Private->FontInfoList.ForwardLink;
1183 } else {
1184 Link = (LIST_ENTRY *) FontHandle;
1185 }
1186
1187 for (; Link != &Private->FontInfoList; Link = Link->ForwardLink) {
1188 GlobalFont = CR (Link, HII_GLOBAL_FONT_INFO, Entry, HII_GLOBAL_FONT_INFO_SIGNATURE);
1189 if (FontInfoMask == NULL) {
1190 if (CompareMem (GlobalFont->FontInfo, FontInfo, GlobalFont->FontInfoSize) == 0) {
1191 if (GlobalFontInfo != NULL) {
1192 *GlobalFontInfo = GlobalFont;
1193 }
1194 return TRUE;
1195 }
1196 } else {
1197 //
1198 // Check which options could be used to make a match.
1199 //
1200 switch (Mask) {
1201 case EFI_FONT_INFO_ANY_FONT:
1202 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle &&
1203 GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1204 Matched = TRUE;
1205 }
1206 break;
1207 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_STYLE:
1208 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1209 Matched = TRUE;
1210 }
1211 break;
1212 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_SIZE:
1213 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1214 Matched = TRUE;
1215 }
1216 break;
1217 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_SIZE | EFI_FONT_INFO_ANY_STYLE:
1218 Matched = TRUE;
1219 break;
1220 //
1221 // If EFI_FONT_INFO_RESTYLE is specified, then the system may attempt to
1222 // remove some of the specified styles to meet the style requested.
1223 //
1224 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_RESTYLE:
1225 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1226 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1227 Matched = TRUE;
1228 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1229 VagueMatched1 = TRUE;
1230 GlobalFontBackup1 = GlobalFont;
1231 }
1232 }
1233 break;
1234 //
1235 // If EFI_FONT_INFO_RESIZE is specified, then the sytem may attempt to
1236 // stretch or shrink a font to meet the size requested.
1237 //
1238 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_RESIZE:
1239 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1240 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1241 Matched = TRUE;
1242 } else {
1243 VagueMatched1 = TRUE;
1244 GlobalFontBackup1 = GlobalFont;
1245 }
1246 }
1247 break;
1248 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_RESTYLE | EFI_FONT_INFO_RESIZE:
1249 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1250 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1251 Matched = TRUE;
1252 } else {
1253 VagueMatched1 = TRUE;
1254 GlobalFontBackup1 = GlobalFont;
1255 }
1256 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1257 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1258 VagueMatched1 = TRUE;
1259 GlobalFontBackup1 = GlobalFont;
1260 } else {
1261 VagueMatched2 = TRUE;
1262 GlobalFontBackup2 = GlobalFont;
1263 }
1264 }
1265 break;
1266 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_STYLE | EFI_FONT_INFO_RESIZE:
1267 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1268 Matched = TRUE;
1269 } else {
1270 VagueMatched1 = TRUE;
1271 GlobalFontBackup1 = GlobalFont;
1272 }
1273 break;
1274 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_SIZE | EFI_FONT_INFO_RESTYLE:
1275 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1276 Matched = TRUE;
1277 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1278 VagueMatched1 = TRUE;
1279 GlobalFontBackup1 = GlobalFont;
1280 }
1281 break;
1282 case EFI_FONT_INFO_ANY_STYLE:
1283 if ((CompareMem (
1284 GlobalFont->FontInfo->FontName,
1285 FontInfo->FontName,
1286 StrSize (FontInfo->FontName)
1287 ) == 0) &&
1288 GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1289 Matched = TRUE;
1290 }
1291 break;
1292 case EFI_FONT_INFO_ANY_STYLE | EFI_FONT_INFO_ANY_SIZE:
1293 if (CompareMem (
1294 GlobalFont->FontInfo->FontName,
1295 FontInfo->FontName,
1296 StrSize (FontInfo->FontName)
1297 ) == 0) {
1298 Matched = TRUE;
1299 }
1300 break;
1301 case EFI_FONT_INFO_ANY_STYLE | EFI_FONT_INFO_RESIZE:
1302 if (CompareMem (
1303 GlobalFont->FontInfo->FontName,
1304 FontInfo->FontName,
1305 StrSize (FontInfo->FontName)
1306 ) == 0) {
1307 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1308 Matched = TRUE;
1309 } else {
1310 VagueMatched1 = TRUE;
1311 GlobalFontBackup1 = GlobalFont;
1312 }
1313 }
1314 break;
1315 case EFI_FONT_INFO_ANY_SIZE:
1316 if ((CompareMem (
1317 GlobalFont->FontInfo->FontName,
1318 FontInfo->FontName,
1319 StrSize (FontInfo->FontName)
1320 ) == 0) &&
1321 GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1322 Matched = TRUE;
1323 }
1324 break;
1325 case EFI_FONT_INFO_ANY_SIZE | EFI_FONT_INFO_RESTYLE:
1326 if (CompareMem (
1327 GlobalFont->FontInfo->FontName,
1328 FontInfo->FontName,
1329 StrSize (FontInfo->FontName)
1330 ) == 0) {
1331 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1332 Matched = TRUE;
1333 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1334 VagueMatched1 = TRUE;
1335 GlobalFontBackup1 = GlobalFont;
1336 }
1337 }
1338 break;
1339 case EFI_FONT_INFO_RESTYLE:
1340 if ((CompareMem (
1341 GlobalFont->FontInfo->FontName,
1342 FontInfo->FontName,
1343 StrSize (FontInfo->FontName)
1344 ) == 0) &&
1345 GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1346
1347 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1348 Matched = TRUE;
1349 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1350 VagueMatched1 = TRUE;
1351 GlobalFontBackup1 = GlobalFont;
1352 }
1353 }
1354 break;
1355 case EFI_FONT_INFO_RESIZE:
1356 if ((CompareMem (
1357 GlobalFont->FontInfo->FontName,
1358 FontInfo->FontName,
1359 StrSize (FontInfo->FontName)
1360 ) == 0) &&
1361 GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1362
1363 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1364 Matched = TRUE;
1365 } else {
1366 VagueMatched1 = TRUE;
1367 GlobalFontBackup1 = GlobalFont;
1368 }
1369 }
1370 break;
1371 case EFI_FONT_INFO_RESIZE | EFI_FONT_INFO_RESTYLE:
1372 if (CompareMem (
1373 GlobalFont->FontInfo->FontName,
1374 FontInfo->FontName,
1375 StrSize (FontInfo->FontName)
1376 ) == 0) {
1377 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1378 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1379 Matched = TRUE;
1380 } else {
1381 VagueMatched1 = TRUE;
1382 GlobalFontBackup1 = GlobalFont;
1383 }
1384 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1385 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1386 VagueMatched1 = TRUE;
1387 GlobalFontBackup1 = GlobalFont;
1388 } else {
1389 VagueMatched2 = TRUE;
1390 GlobalFontBackup2 = GlobalFont;
1391 }
1392 }
1393 }
1394 break;
1395 default:
1396 break;
1397 }
1398
1399 if (Matched) {
1400 if (GlobalFontInfo != NULL) {
1401 *GlobalFontInfo = GlobalFont;
1402 }
1403 return TRUE;
1404 }
1405 }
1406 }
1407
1408 if (VagueMatched1) {
1409 if (GlobalFontInfo != NULL) {
1410 *GlobalFontInfo = GlobalFontBackup1;
1411 }
1412 return TRUE;
1413 } else if (VagueMatched2) {
1414 if (GlobalFontInfo != NULL) {
1415 *GlobalFontInfo = GlobalFontBackup2;
1416 }
1417 return TRUE;
1418 }
1419
1420 return FALSE;
1421}
1422
1423
1424/**
1425 Check whether the unicode represents a line break or not.
1426
1427 This is a internal function. Please see Section 27.2.6 of the UEFI Specification
1428 for a description of the supported string format.
1429
1430 @param Char Unicode character
1431
1432 @retval 0 Yes, it forces a line break.
1433 @retval 1 Yes, it presents a line break opportunity
1434 @retval 2 Yes, it requires a line break happen before and after it.
1435 @retval -1 No, it is not a link break.
1436
1437**/
1438INT8
1439IsLineBreak (
1440 IN CHAR16 Char
1441 )
1442{
1443 switch (Char) {
1444 //
1445 // Mandatory line break characters, which force a line-break
1446 //
1447 case 0x000C:
1448 case 0x000D:
1449 case 0x2028:
1450 case 0x2029:
1451 return 0;
1452 //
1453 // Space characters, which is taken as a line-break opportunity
1454 //
1455 case 0x0020:
1456 case 0x1680:
1457 case 0x2000:
1458 case 0x2001:
1459 case 0x2002:
1460 case 0x2003:
1461 case 0x2004:
1462 case 0x2005:
1463 case 0x2006:
1464 case 0x2008:
1465 case 0x2009:
1466 case 0x200A:
1467 case 0x205F:
1468 //
1469 // In-Word Break Opportunities
1470 //
1471 case 0x200B:
1472 return 1;
1473 //
1474 // A space which is not a line-break opportunity
1475 //
1476 case 0x00A0:
1477 case 0x202F:
1478 //
1479 // A hyphen which is not a line-break opportunity
1480 //
1481 case 0x2011:
1482 return -1;
1483 //
1484 // Hyphen characters which describe line break opportunities after the character
1485 //
1486 case 0x058A:
1487 case 0x2010:
1488 case 0x2012:
1489 case 0x2013:
1490 case 0x0F0B:
1491 case 0x1361:
1492 case 0x17D5:
1493 return 1;
1494 //
1495 // A hyphen which describes line break opportunities before and after them, but not between a pair of them
1496 //
1497 case 0x2014:
1498 return 2;
1499 }
1500 return -1;
1501}
1502
1503
1504/**
1505 Renders a string to a bitmap or to the display.
1506
1507 @param This A pointer to the EFI_HII_FONT_PROTOCOL instance.
1508 @param Flags Describes how the string is to be drawn.
1509 @param String Points to the null-terminated string to be
1510 displayed.
1511 @param StringInfo Points to the string output information,
1512 including the color and font. If NULL, then the
1513 string will be output in the default system font
1514 and color.
1515 @param Blt If this points to a non-NULL on entry, this
1516 points to the image, which is Width pixels wide
1517 and Height pixels high. The string will be drawn
1518 onto this image and
1519 EFI_HII_OUT_FLAG_CLIP is implied. If this points
1520 to a NULL on entry, then a buffer
1521 will be allocated to hold the generated image and
1522 the pointer updated on exit. It is the caller's
1523 responsibility to free this buffer.
1524 @param BltX Specifies the offset from the left and top edge
1525 of the image of the first character cell in the
1526 image.
1527 @param BltY Specifies the offset from the left and top edge
1528 of the image of the first character cell in the
1529 image.
1530 @param RowInfoArray If this is non-NULL on entry, then on exit, this
1531 will point to an allocated buffer containing
1532 row information and RowInfoArraySize will be
1533 updated to contain the number of elements.
1534 This array describes the characters which were at
1535 least partially drawn and the heights of the
1536 rows. It is the caller's responsibility to free
1537 this buffer.
1538 @param RowInfoArraySize If this is non-NULL on entry, then on exit it
1539 contains the number of elements in RowInfoArray.
1540 @param ColumnInfoArray If this is non-NULL, then on return it will be
1541 filled with the horizontal offset for each
1542 character in the string on the row where it is
1543 displayed. Non-printing characters will have
1544 the offset ~0. The caller is responsible to
1545 allocate a buffer large enough so that there
1546 is one entry for each character in the string,
1547 not including the null-terminator. It is possible
1548 when character display is normalized that some
1549 character cells overlap.
1550
1551 @retval EFI_SUCCESS The string was successfully rendered.
1552 @retval EFI_OUT_OF_RESOURCES Unable to allocate an output buffer for
1553 RowInfoArray or Blt.
1554 @retval EFI_INVALID_PARAMETER The String or Blt was NULL.
1555 @retval EFI_INVALID_PARAMETER Flags were invalid combination..
1556
1557**/
1558EFI_STATUS
1559EFIAPI
1560HiiStringToImage (
1561 IN CONST EFI_HII_FONT_PROTOCOL *This,
1562 IN EFI_HII_OUT_FLAGS Flags,
1563 IN CONST EFI_STRING String,
1564 IN CONST EFI_FONT_DISPLAY_INFO *StringInfo OPTIONAL,
1565 IN OUT EFI_IMAGE_OUTPUT **Blt,
1566 IN UINTN BltX,
1567 IN UINTN BltY,
1568 OUT EFI_HII_ROW_INFO **RowInfoArray OPTIONAL,
1569 OUT UINTN *RowInfoArraySize OPTIONAL,
1570 OUT UINTN *ColumnInfoArray OPTIONAL
1571 )
1572{
1573 EFI_STATUS Status;
1574 HII_DATABASE_PRIVATE_DATA *Private;
1575 UINT8 **GlyphBuf;
1576 EFI_HII_GLYPH_INFO *Cell;
1577 UINT8 *Attributes;
1578 EFI_IMAGE_OUTPUT *Image;
1579 EFI_STRING StringPtr;
1580 EFI_STRING StringTmp;
1581 EFI_HII_ROW_INFO *RowInfo;
1582 UINTN LineWidth;
1583 UINTN LineHeight;
1584 UINTN LineOffset;
1585 UINTN LastLineHeight;
1586 UINTN BaseLineOffset;
1587 UINT16 MaxRowNum;
1588 UINT16 RowIndex;
1589 UINTN Index;
1590 UINTN NextIndex;
1591 UINTN Index1;
1592 EFI_FONT_DISPLAY_INFO *StringInfoOut;
1593 EFI_FONT_DISPLAY_INFO *SystemDefault;
1594 EFI_FONT_HANDLE FontHandle;
1595 EFI_STRING StringIn;
1596 EFI_STRING StringIn2;
1597 UINT16 Height;
1598 UINT16 BaseLine;
1599 EFI_FONT_INFO *FontInfo;
1600 BOOLEAN SysFontFlag;
1601 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground;
1602 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background;
1603 BOOLEAN Transparent;
1604 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
1605 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BufferPtr;
1606 UINTN RowInfoSize;
1607 BOOLEAN LineBreak;
1608 UINTN StrLength;
1609 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *RowBufferPtr;
1610 HII_GLOBAL_FONT_INFO *GlobalFont;
1611
1612 //
1613 // Check incoming parameters.
1614 //
1615
1616 if (This == NULL || String == NULL || Blt == NULL) {
1617 return EFI_INVALID_PARAMETER;
1618 }
1619 if (*Blt == NULL) {
1620 //
1621 // These two flag cannot be used if Blt is NULL upon entry.
1622 //
1623 if ((Flags & EFI_HII_OUT_FLAG_TRANSPARENT) == EFI_HII_OUT_FLAG_TRANSPARENT) {
1624 return EFI_INVALID_PARAMETER;
1625 }
1626 if ((Flags & EFI_HII_OUT_FLAG_CLIP) == EFI_HII_OUT_FLAG_CLIP) {
1627 return EFI_INVALID_PARAMETER;
1628 }
1629 }
1630 //
1631 // These two flags require that EFI_HII_OUT_FLAG_CLIP be also set.
1632 //
1633 if ((Flags & (EFI_HII_OUT_FLAG_CLIP | EFI_HII_OUT_FLAG_CLIP_CLEAN_X)) == EFI_HII_OUT_FLAG_CLIP_CLEAN_X) {
1634 return EFI_INVALID_PARAMETER;
1635 }
1636 if ((Flags & (EFI_HII_OUT_FLAG_CLIP | EFI_HII_OUT_FLAG_CLIP_CLEAN_Y)) == EFI_HII_OUT_FLAG_CLIP_CLEAN_Y) {
1637 return EFI_INVALID_PARAMETER;
1638 }
1639 //
1640 // This flag cannot be used with EFI_HII_OUT_FLAG_CLEAN_X.
1641 //
1642 if ((Flags & (EFI_HII_OUT_FLAG_WRAP | EFI_HII_OUT_FLAG_CLIP_CLEAN_X)) == (EFI_HII_OUT_FLAG_WRAP | EFI_HII_OUT_FLAG_CLIP_CLEAN_X)) {
1643 return EFI_INVALID_PARAMETER;
1644 }
1645
1646 if (*Blt == NULL) {
1647 //
1648 // Create a new bitmap and draw the string onto this image.
1649 //
1650 Image = AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
1651 if (Image == NULL) {
1652 return EFI_OUT_OF_RESOURCES;
1653 }
1654 Image->Width = 800;
1655 Image->Height = 600;
1656 Image->Image.Bitmap = AllocateZeroPool (Image->Width * Image->Height *sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
1657 if (Image->Image.Bitmap == NULL) {
1658 FreePool (Image);
1659 return EFI_OUT_OF_RESOURCES;
1660 }
1661
1662 //
1663 // Other flags are not permitted when Blt is NULL.
1664 //
1665 Flags &= EFI_HII_OUT_FLAG_WRAP | EFI_HII_IGNORE_IF_NO_GLYPH | EFI_HII_IGNORE_LINE_BREAK;
1666 *Blt = Image;
1667 }
1668
1669 StrLength = StrLen(String);
1670 GlyphBuf = (UINT8 **) AllocateZeroPool (StrLength * sizeof (UINT8 *));
1671 ASSERT (GlyphBuf != NULL);
1672 Cell = (EFI_HII_GLYPH_INFO *) AllocateZeroPool (StrLength * sizeof (EFI_HII_GLYPH_INFO));
1673 ASSERT (Cell != NULL);
1674 Attributes = (UINT8 *) AllocateZeroPool (StrLength * sizeof (UINT8));
1675 ASSERT (Attributes != NULL);
1676
1677 RowInfo = NULL;
1678 Status = EFI_SUCCESS;
1679 StringIn2 = NULL;
1680 SystemDefault = NULL;
1681 StringIn = NULL;
1682
1683 //
1684 // Calculate the string output information, including specified color and font .
1685 // If StringInfo does not points to system font info, it must indicate an existing
1686 // EFI_FONT_INFO.
1687 //
1688 StringInfoOut = NULL;
1689 FontHandle = NULL;
1690 Private = HII_FONT_DATABASE_PRIVATE_DATA_FROM_THIS (This);
1691 SysFontFlag = IsSystemFontInfo (Private, (EFI_FONT_DISPLAY_INFO *) StringInfo, &SystemDefault, NULL);
1692
1693 if (SysFontFlag) {
1694 ASSERT (SystemDefault != NULL);
1695 FontInfo = NULL;
1696 Height = SystemDefault->FontInfo.FontSize;
1697 BaseLine = SystemDefault->FontInfo.FontSize;
1698 Foreground = SystemDefault->ForegroundColor;
1699 Background = SystemDefault->BackgroundColor;
1700
1701 } else {
1702 //
1703 // StringInfo must not be NULL if it is not system info.
1704 //
1705 ASSERT (StringInfo != NULL);
1706 Status = HiiGetFontInfo (This, &FontHandle, (EFI_FONT_DISPLAY_INFO *) StringInfo, &StringInfoOut, NULL);
1707 if (Status == EFI_NOT_FOUND) {
1708 //
1709 // The specified EFI_FONT_DISPLAY_INFO does not exist in current database.
1710 // Use the system font instead. Still use the color specified by StringInfo.
1711 //
1712 SysFontFlag = TRUE;
1713 FontInfo = NULL;
1714 Height = SystemDefault->FontInfo.FontSize;
1715 BaseLine = SystemDefault->FontInfo.FontSize;
1716 Foreground = ((EFI_FONT_DISPLAY_INFO *) StringInfo)->ForegroundColor;
1717 Background = ((EFI_FONT_DISPLAY_INFO *) StringInfo)->BackgroundColor;
1718
1719 } else if (Status == EFI_SUCCESS) {
1720 FontInfo = &StringInfoOut->FontInfo;
1721 IsFontInfoExisted (Private, FontInfo, NULL, NULL, &GlobalFont);
1722 Height = GlobalFont->FontPackage->Height;
1723 BaseLine = GlobalFont->FontPackage->BaseLine;
1724 Foreground = StringInfoOut->ForegroundColor;
1725 Background = StringInfoOut->BackgroundColor;
1726 } else {
1727 goto Exit;
1728 }
1729 }
1730
1731 //
1732 // Use the maxinum height of font as the base line.
1733 // And, use the maxinum height as line height.
1734 //
1735 LineHeight = Height;
1736 LastLineHeight = Height;
1737 BaseLineOffset = Height - BaseLine;
1738
1739 //
1740 // Parse the string to be displayed to drop some ignored characters.
1741 //
1742
1743 StringPtr = String;
1744
1745 //
1746 // Ignore line-break characters only. Hyphens or dash character will be displayed
1747 // without line-break opportunity.
1748 //
1749 if ((Flags & EFI_HII_IGNORE_LINE_BREAK) == EFI_HII_IGNORE_LINE_BREAK) {
1750 StringIn = AllocateZeroPool (StrSize (StringPtr));
1751 if (StringIn == NULL) {
1752 Status = EFI_OUT_OF_RESOURCES;
1753 goto Exit;
1754 }
1755 StringTmp = StringIn;
1756 while (*StringPtr != 0) {
1757 if (IsLineBreak (*StringPtr) == 0) {
1758 StringPtr++;
1759 } else {
1760 *StringTmp++ = *StringPtr++;
1761 }
1762 }
1763 *StringTmp = 0;
1764 StringPtr = StringIn;
1765 }
1766 //
1767 // If EFI_HII_IGNORE_IF_NO_GLYPH is set, then characters which have no glyphs
1768 // are not drawn. Otherwise they are replaced wth Unicode character 0xFFFD.
1769 //
1770 StringIn2 = AllocateZeroPool (StrSize (StringPtr));
1771 if (StringIn2 == NULL) {
1772 Status = EFI_OUT_OF_RESOURCES;
1773 goto Exit;
1774 }
1775 Index = 0;
1776 StringTmp = StringIn2;
1777 StrLength = StrLen(StringPtr);
1778 while (*StringPtr != 0 && Index < StrLength) {
1779 if (IsLineBreak (*StringPtr) == 0) {
1780 *StringTmp++ = *StringPtr++;
1781 Index++;
1782 continue;
1783 }
1784
1785 Status = GetGlyphBuffer (Private, *StringPtr, FontInfo, &GlyphBuf[Index], &Cell[Index], &Attributes[Index]);
1786 if (Status == EFI_NOT_FOUND) {
1787 if ((Flags & EFI_HII_IGNORE_IF_NO_GLYPH) == EFI_HII_IGNORE_IF_NO_GLYPH) {
1788 GlyphBuf[Index] = NULL;
1789 ZeroMem (&Cell[Index], sizeof (Cell[Index]));
1790 Status = EFI_SUCCESS;
1791 } else {
1792 //
1793 // Unicode 0xFFFD must exist in current hii database if this flag is not set.
1794 //
1795 Status = GetGlyphBuffer (
1796 Private,
1797 REPLACE_UNKNOWN_GLYPH,
1798 FontInfo,
1799 &GlyphBuf[Index],
1800 &Cell[Index],
1801 &Attributes[Index]
1802 );
1803 if (EFI_ERROR (Status)) {
1804 Status = EFI_INVALID_PARAMETER;
1805 }
1806 }
1807 }
1808
1809 if (EFI_ERROR (Status)) {
1810 goto Exit;
1811 }
1812
1813 *StringTmp++ = *StringPtr++;
1814 Index++;
1815 }
1816 *StringTmp = 0;
1817 StringPtr = StringIn2;
1818
1819 //
1820 // Draw the string according to the specified EFI_HII_OUT_FLAGS and Blt.
1821 // If Blt is not NULL, then EFI_HII_OUT_FLAG_CLIP is implied, render this string
1822 // to an existing image (bitmap or screen depending on flags) pointed by "*Blt".
1823 // Otherwise render this string to a new allocated image and output it.
1824 //
1825 Image = *Blt;
1826 BufferPtr = Image->Image.Bitmap + Image->Width * BltY + BltX;
1827 if (Image->Height < BltY) {
1828 //
1829 // the top edge of the image should be in Image resolution scope.
1830 //
1831 Status = EFI_INVALID_PARAMETER;
1832 goto Exit;
1833 }
1834 MaxRowNum = (UINT16) ((Image->Height - BltY) / Height);
1835 if ((Image->Height - BltY) % Height != 0) {
1836 LastLineHeight = (Image->Height - BltY) % Height;
1837 MaxRowNum++;
1838 }
1839
1840 RowInfo = (EFI_HII_ROW_INFO *) AllocateZeroPool (MaxRowNum * sizeof (EFI_HII_ROW_INFO));
1841 if (RowInfo == NULL) {
1842 Status = EFI_OUT_OF_RESOURCES;
1843 goto Exit;
1844 }
1845
1846 //
1847 // Format the glyph buffer according to flags.
1848 //
1849 Transparent = (BOOLEAN) ((Flags & EFI_HII_OUT_FLAG_TRANSPARENT) == EFI_HII_OUT_FLAG_TRANSPARENT ? TRUE : FALSE);
1850
1851 for (RowIndex = 0, Index = 0; RowIndex < MaxRowNum && StringPtr[Index] != 0; ) {
1852 LineWidth = 0;
1853 LineBreak = FALSE;
1854
1855 //
1856 // Clip the final row if the row's bottom-most on pixel cannot fit when
1857 // EFI_HII_OUT_FLAG_CLEAN_Y is set.
1858 //
1859 if (RowIndex == MaxRowNum - 1) {
1860 if ((Flags & EFI_HII_OUT_FLAG_CLIP_CLEAN_Y) == EFI_HII_OUT_FLAG_CLIP_CLEAN_Y && LastLineHeight < LineHeight ) {
1861 //
1862 // Don't draw at all if the row's bottom-most on pixel cannot fit.
1863 //
1864 break;
1865 }
1866 LineHeight = LastLineHeight;
1867 }
1868
1869 //
1870 // Calculate how many characters there are in a row.
1871 //
1872 RowInfo[RowIndex].StartIndex = Index;
1873
1874 while (LineWidth + BltX < Image->Width && StringPtr[Index] != 0) {
1875 if ((Flags & EFI_HII_IGNORE_LINE_BREAK) == 0 &&
1876 IsLineBreak (StringPtr[Index]) == 0) {
1877 //
1878 // It forces a line break that ends this row.
1879 //
1880 Index++;
1881 LineBreak = TRUE;
1882 break;
1883 }
1884
1885 //
1886 // If the glyph of the character is existing, then accumulate the actual printed width
1887 //
1888 LineWidth += (UINTN) Cell[Index].AdvanceX;
1889
1890 Index++;
1891 }
1892
1893 //
1894 // Record index of next char.
1895 //
1896 NextIndex = Index;
1897 //
1898 // Return to the previous char.
1899 //
1900 Index--;
1901 if (LineBreak && Index > 0 ) {
1902 //
1903 // Return the previous non line break char.
1904 //
1905 Index --;
1906 }
1907
1908 //
1909 // If this character is the last character of a row, we need not
1910 // draw its (AdvanceX - Width - OffsetX) for next character.
1911 //
1912 LineWidth -= (UINTN) (Cell[Index].AdvanceX - Cell[Index].Width - Cell[Index].OffsetX);
1913
1914 //
1915 // Clip the right-most character if cannot fit when EFI_HII_OUT_FLAG_CLEAN_X is set.
1916 //
1917 if (LineWidth + BltX <= Image->Width ||
1918 (LineWidth + BltX > Image->Width && (Flags & EFI_HII_OUT_FLAG_CLIP_CLEAN_X) == 0)) {
1919 //
1920 // Record right-most character in RowInfo even if it is partially displayed.
1921 //
1922 RowInfo[RowIndex].EndIndex = Index;
1923 RowInfo[RowIndex].LineWidth = LineWidth;
1924 RowInfo[RowIndex].LineHeight = LineHeight;
1925 RowInfo[RowIndex].BaselineOffset = BaseLineOffset;
1926 } else {
1927 //
1928 // When EFI_HII_OUT_FLAG_CLEAN_X is set, it will not draw a character
1929 // if its right-most on pixel cannot fit.
1930 //
1931 if (Index > RowInfo[RowIndex].StartIndex) {
1932 //
1933 // Don't draw the last char on this row. And, don't draw the second last char (AdvanceX - Width - OffsetX).
1934 //
1935 LineWidth -= (UINTN) (Cell[Index].Width + Cell[Index].OffsetX);
1936 LineWidth -= (UINTN) (Cell[Index - 1].AdvanceX - Cell[Index - 1].Width - Cell[Index - 1].OffsetX);
1937 RowInfo[RowIndex].EndIndex = Index - 1;
1938 RowInfo[RowIndex].LineWidth = LineWidth;
1939 RowInfo[RowIndex].LineHeight = LineHeight;
1940 RowInfo[RowIndex].BaselineOffset = BaseLineOffset;
1941 } else {
1942 //
1943 // There is no enough column to draw any character, so set current line width to zero.
1944 // And go to draw Next line if LineBreak is set.
1945 //
1946 RowInfo[RowIndex].LineWidth = 0;
1947 goto NextLine;
1948 }
1949 }
1950
1951 //
1952 // EFI_HII_OUT_FLAG_WRAP will wrap the text at the right-most line-break
1953 // opportunity prior to a character whose right-most extent would exceed Width.
1954 // Search the right-most line-break opportunity here.
1955 //
1956 if ((Flags & EFI_HII_OUT_FLAG_WRAP) == EFI_HII_OUT_FLAG_WRAP &&
1957 (RowInfo[RowIndex].LineWidth + BltX > Image->Width || StringPtr[NextIndex] != 0) &&
1958 !LineBreak) {
1959 if ((Flags & EFI_HII_IGNORE_LINE_BREAK) == 0) {
1960 LineWidth = RowInfo[RowIndex].LineWidth;
1961 for (Index1 = RowInfo[RowIndex].EndIndex; Index1 >= RowInfo[RowIndex].StartIndex; Index1--) {
1962 if (Index1 == RowInfo[RowIndex].EndIndex) {
1963 LineWidth -= (Cell[Index1].Width + Cell[Index1].OffsetX);
1964 } else {
1965 LineWidth -= Cell[Index1].AdvanceX;
1966 }
1967 if (IsLineBreak (StringPtr[Index1]) > 0) {
1968 LineBreak = TRUE;
1969 if (Index1 > RowInfo[RowIndex].StartIndex) {
1970 RowInfo[RowIndex].EndIndex = Index1 - 1;
1971 }
1972 //
1973 // relocate to the character after the right-most line break opportunity of this line
1974 //
1975 NextIndex = Index1 + 1;
1976 break;
1977 }
1978 //
1979 // If don't find a line break opportunity from EndIndex to StartIndex,
1980 // then jump out.
1981 //
1982 if (Index1 == RowInfo[RowIndex].StartIndex)
1983 break;
1984 }
1985
1986 //
1987 // Update LineWidth to the real width
1988 //
1989 if (IsLineBreak (StringPtr[Index1]) > 0) {
1990 if (Index1 == RowInfo[RowIndex].StartIndex) {
1991 LineWidth = 0;
1992 } else {
1993 LineWidth -= (UINTN) (Cell[Index1 - 1].AdvanceX - Cell[Index1 - 1].Width - Cell[Index1 - 1].OffsetX);
1994 }
1995 RowInfo[RowIndex].LineWidth = LineWidth;
1996 }
1997 }
1998 //
1999 // If no line-break opportunity can be found, then the text will
2000 // behave as if EFI_HII_OUT_FLAG_CLEAN_X is set.
2001 //
2002 if (!LineBreak) {
2003 LineWidth = RowInfo[RowIndex].LineWidth;
2004 Index1 = RowInfo[RowIndex].EndIndex;
2005 if (LineWidth + BltX > Image->Width) {
2006 if (Index1 > RowInfo[RowIndex].StartIndex) {
2007 //
2008 // Don't draw the last char on this row. And, don't draw the second last char (AdvanceX - Width - OffsetX).
2009 //
2010 LineWidth -= (UINTN) (Cell[Index1].Width + Cell[Index1].OffsetX);
2011 LineWidth -= (UINTN) (Cell[Index1 - 1].AdvanceX - Cell[Index1 - 1].Width - Cell[Index1 - 1].OffsetX);
2012 RowInfo[RowIndex].EndIndex = Index1 - 1;
2013 RowInfo[RowIndex].LineWidth = LineWidth;
2014 } else {
2015 //
2016 // There is no enough column to draw any character, so set current line width to zero.
2017 // And go to draw Next line if LineBreak is set.
2018 //
2019 RowInfo[RowIndex].LineWidth = 0;
2020 goto NextLine;
2021 }
2022 }
2023 }
2024 }
2025
2026 //
2027 // LineWidth can't exceed Image width.
2028 //
2029 if (RowInfo[RowIndex].LineWidth + BltX > Image->Width) {
2030 RowInfo[RowIndex].LineWidth = Image->Width - BltX;
2031 }
2032
2033 //
2034 // Draw it to screen or existing bitmap depending on whether
2035 // EFI_HII_DIRECT_TO_SCREEN is set.
2036 //
2037 LineOffset = 0;
2038 if ((Flags & EFI_HII_DIRECT_TO_SCREEN) == EFI_HII_DIRECT_TO_SCREEN) {
2039 BltBuffer = NULL;
2040 if (RowInfo[RowIndex].LineWidth != 0) {
2041 BltBuffer = AllocateZeroPool (RowInfo[RowIndex].LineWidth * RowInfo[RowIndex].LineHeight * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
2042 if (BltBuffer == NULL) {
2043 Status = EFI_OUT_OF_RESOURCES;
2044 goto Exit;
2045 }
2046 //
2047 // Set BufferPtr to Origin by adding baseline to the starting position.
2048 //
2049 BufferPtr = BltBuffer + BaseLine * RowInfo[RowIndex].LineWidth;
2050 }
2051 for (Index1 = RowInfo[RowIndex].StartIndex; Index1 <= RowInfo[RowIndex].EndIndex; Index1++) {
2052 if (RowInfo[RowIndex].LineWidth > 0 && RowInfo[RowIndex].LineWidth > LineOffset) {
2053 //
2054 // Only BLT these character which have corrsponding glyph in font basebase.
2055 //
2056 GlyphToImage (
2057 GlyphBuf[Index1],
2058 Foreground,
2059 Background,
2060 (UINT16) RowInfo[RowIndex].LineWidth,
2061 BaseLine,
2062 RowInfo[RowIndex].LineWidth - LineOffset,
2063 RowInfo[RowIndex].LineHeight,
2064 Transparent,
2065 &Cell[Index1],
2066 Attributes[Index1],
2067 &BufferPtr
2068 );
2069 }
2070 if (ColumnInfoArray != NULL) {
2071 if ((GlyphBuf[Index1] == NULL && Cell[Index1].AdvanceX == 0)
2072 || RowInfo[RowIndex].LineWidth == 0) {
2073 *ColumnInfoArray = (UINTN) ~0;
2074 } else {
2075 *ColumnInfoArray = LineOffset + Cell[Index1].OffsetX + BltX;
2076 }
2077 ColumnInfoArray++;
2078 }
2079 LineOffset += Cell[Index1].AdvanceX;
2080 }
2081
2082 if (BltBuffer != NULL) {
2083 Status = Image->Image.Screen->Blt (
2084 Image->Image.Screen,
2085 BltBuffer,
2086 EfiBltBufferToVideo,
2087 0,
2088 0,
2089 BltX,
2090 BltY,
2091 RowInfo[RowIndex].LineWidth,
2092 RowInfo[RowIndex].LineHeight,
2093 0
2094 );
2095 if (EFI_ERROR (Status)) {
2096 FreePool (BltBuffer);
2097 goto Exit;
2098 }
2099
2100 FreePool (BltBuffer);
2101 }
2102 } else {
2103 //
2104 // Save the starting position for calculate the starting postition of next row.
2105 //
2106 RowBufferPtr = BufferPtr;
2107 //
2108 // Set BufferPtr to Origin by adding baseline to the starting position.
2109 //
2110 BufferPtr = BufferPtr + BaseLine * Image->Width;
2111 for (Index1 = RowInfo[RowIndex].StartIndex; Index1 <= RowInfo[RowIndex].EndIndex; Index1++) {
2112 if (RowInfo[RowIndex].LineWidth > 0 && RowInfo[RowIndex].LineWidth > LineOffset) {
2113 //
2114 // Only BLT these character which have corrsponding glyph in font basebase.
2115 //
2116 GlyphToImage (
2117 GlyphBuf[Index1],
2118 Foreground,
2119 Background,
2120 Image->Width,
2121 BaseLine,
2122 RowInfo[RowIndex].LineWidth - LineOffset,
2123 RowInfo[RowIndex].LineHeight,
2124 Transparent,
2125 &Cell[Index1],
2126 Attributes[Index1],
2127 &BufferPtr
2128 );
2129 }
2130 if (ColumnInfoArray != NULL) {
2131 if ((GlyphBuf[Index1] == NULL && Cell[Index1].AdvanceX == 0)
2132 || RowInfo[RowIndex].LineWidth == 0) {
2133 *ColumnInfoArray = (UINTN) ~0;
2134 } else {
2135 *ColumnInfoArray = LineOffset + Cell[Index1].OffsetX + BltX;
2136 }
2137 ColumnInfoArray++;
2138 }
2139 LineOffset += Cell[Index1].AdvanceX;
2140 }
2141
2142 //
2143 // Jump to starting position of next row.
2144 //
2145 if (RowIndex == 0) {
2146 BufferPtr = RowBufferPtr - BltX + LineHeight * Image->Width;
2147 } else {
2148 BufferPtr = RowBufferPtr + LineHeight * Image->Width;
2149 }
2150 }
2151
2152NextLine:
2153 //
2154 // Recalculate the start point of X/Y axis to draw multi-lines with the order of top-to-down
2155 //
2156 BltX = 0;
2157 BltY += RowInfo[RowIndex].LineHeight;
2158
2159 RowIndex++;
2160 Index = NextIndex;
2161
2162 if (!LineBreak) {
2163 //
2164 // If there is not a mandatory line break or line break opportunity, only render one line to image
2165 //
2166 break;
2167 }
2168 }
2169
2170 //
2171 // Write output parameters.
2172 //
2173 RowInfoSize = RowIndex * sizeof (EFI_HII_ROW_INFO);
2174 if (RowInfoArray != NULL) {
2175 if (RowInfoSize > 0) {
2176 *RowInfoArray = AllocateZeroPool (RowInfoSize);
2177 if (*RowInfoArray == NULL) {
2178 Status = EFI_OUT_OF_RESOURCES;
2179 goto Exit;
2180 }
2181 CopyMem (*RowInfoArray, RowInfo, RowInfoSize);
2182 } else {
2183 *RowInfoArray = NULL;
2184 }
2185 }
2186 if (RowInfoArraySize != NULL) {
2187 *RowInfoArraySize = RowIndex;
2188 }
2189
2190 Status = EFI_SUCCESS;
2191
2192Exit:
2193
2194 for (Index = 0; Index < StrLength; Index++) {
2195 if (GlyphBuf[Index] != NULL) {
2196 FreePool (GlyphBuf[Index]);
2197 }
2198 }
2199 if (StringIn != NULL) {
2200 FreePool (StringIn);
2201 }
2202 if (StringIn2 != NULL) {
2203 FreePool (StringIn2);
2204 }
2205 if (StringInfoOut != NULL) {
2206 FreePool (StringInfoOut);
2207 }
2208 if (RowInfo != NULL) {
2209 FreePool (RowInfo);
2210 }
2211 if (SystemDefault != NULL) {
2212 FreePool (SystemDefault);
2213 }
2214 if (GlyphBuf != NULL) {
2215 FreePool (GlyphBuf);
2216 }
2217 if (Cell != NULL) {
2218 FreePool (Cell);
2219 }
2220 if (Attributes != NULL) {
2221 FreePool (Attributes);
2222 }
2223
2224 return Status;
2225}
2226
2227
2228/**
2229 Render a string to a bitmap or the screen containing the contents of the specified string.
2230
2231 @param This A pointer to the EFI_HII_FONT_PROTOCOL instance.
2232 @param Flags Describes how the string is to be drawn.
2233 @param PackageList The package list in the HII database to search
2234 for the specified string.
2235 @param StringId The string's id, which is unique within
2236 PackageList.
2237 @param Language Points to the language for the retrieved string.
2238 If NULL, then the current system language is
2239 used.
2240 @param StringInfo Points to the string output information,
2241 including the color and font. If NULL, then the
2242 string will be output in the default system font
2243 and color.
2244 @param Blt If this points to a non-NULL on entry, this
2245 points to the image, which is Width pixels wide
2246 and Height pixels high. The string will be drawn
2247 onto this image and
2248 EFI_HII_OUT_FLAG_CLIP is implied. If this points
2249 to a NULL on entry, then a buffer
2250 will be allocated to hold the generated image and
2251 the pointer updated on exit. It is the caller's
2252 responsibility to free this buffer.
2253 @param BltX Specifies the offset from the left and top edge
2254 of the image of the first character cell in the
2255 image.
2256 @param BltY Specifies the offset from the left and top edge
2257 of the image of the first character cell in the
2258 image.
2259 @param RowInfoArray If this is non-NULL on entry, then on exit, this
2260 will point to an allocated buffer containing
2261 row information and RowInfoArraySize will be
2262 updated to contain the number of elements.
2263 This array describes the characters which were at
2264 least partially drawn and the heights of the
2265 rows. It is the caller's responsibility to free
2266 this buffer.
2267 @param RowInfoArraySize If this is non-NULL on entry, then on exit it
2268 contains the number of elements in RowInfoArray.
2269 @param ColumnInfoArray If this is non-NULL, then on return it will be
2270 filled with the horizontal offset for each
2271 character in the string on the row where it is
2272 displayed. Non-printing characters will have
2273 the offset ~0. The caller is responsible to
2274 allocate a buffer large enough so that there
2275 is one entry for each character in the string,
2276 not including the null-terminator. It is possible
2277 when character display is normalized that some
2278 character cells overlap.
2279
2280 @retval EFI_SUCCESS The string was successfully rendered.
2281 @retval EFI_OUT_OF_RESOURCES Unable to allocate an output buffer for
2282 RowInfoArray or Blt.
2283 @retval EFI_INVALID_PARAMETER The Blt or PackageList was NULL.
2284 @retval EFI_INVALID_PARAMETER Flags were invalid combination.
2285 @retval EFI_NOT_FOUND The specified PackageList is not in the Database or the stringid is not
2286 in the specified PackageList.
2287
2288**/
2289EFI_STATUS
2290EFIAPI
2291HiiStringIdToImage (
2292 IN CONST EFI_HII_FONT_PROTOCOL *This,
2293 IN EFI_HII_OUT_FLAGS Flags,
2294 IN EFI_HII_HANDLE PackageList,
2295 IN EFI_STRING_ID StringId,
2296 IN CONST CHAR8* Language,
2297 IN CONST EFI_FONT_DISPLAY_INFO *StringInfo OPTIONAL,
2298 IN OUT EFI_IMAGE_OUTPUT **Blt,
2299 IN UINTN BltX,
2300 IN UINTN BltY,
2301 OUT EFI_HII_ROW_INFO **RowInfoArray OPTIONAL,
2302 OUT UINTN *RowInfoArraySize OPTIONAL,
2303 OUT UINTN *ColumnInfoArray OPTIONAL
2304 )
2305{
2306 EFI_STATUS Status;
2307 HII_DATABASE_PRIVATE_DATA *Private;
2308 EFI_HII_STRING_PROTOCOL *HiiString;
2309 EFI_STRING String;
2310 UINTN StringSize;
2311 UINTN FontLen;
2312 EFI_FONT_INFO *StringFontInfo;
2313 EFI_FONT_DISPLAY_INFO *NewStringInfo;
2314 CHAR8 TempSupportedLanguages;
2315 CHAR8 *SupportedLanguages;
2316 UINTN SupportedLanguagesSize;
2317 CHAR8 *CurrentLanguage;
2318 CHAR8 *BestLanguage;
2319
2320 if (This == NULL || PackageList == NULL || Blt == NULL || PackageList == NULL) {
2321 return EFI_INVALID_PARAMETER;
2322 }
2323
2324 if (!IsHiiHandleValid (PackageList)) {
2325 return EFI_NOT_FOUND;
2326 }
2327
2328 //
2329 // Initialize string pointers to be NULL
2330 //
2331 SupportedLanguages = NULL;
2332 CurrentLanguage = NULL;
2333 BestLanguage = NULL;
2334 String = NULL;
2335 StringFontInfo = NULL;
2336 NewStringInfo = NULL;
2337
2338 //
2339 // Get the string to be displayed.
2340 //
2341 Private = HII_FONT_DATABASE_PRIVATE_DATA_FROM_THIS (This);
2342 HiiString = &Private->HiiString;
2343
2344 //
2345 // Get the size of supported language.
2346 //
2347 SupportedLanguagesSize = 0;
2348 Status = HiiString->GetLanguages (
2349 HiiString,
2350 PackageList,
2351 &TempSupportedLanguages,
2352 &SupportedLanguagesSize
2353 );
2354 if (Status != EFI_BUFFER_TOO_SMALL) {
2355 return Status;
2356 }
2357
2358 SupportedLanguages = AllocatePool (SupportedLanguagesSize);
2359 if (SupportedLanguages == NULL) {
2360 return EFI_OUT_OF_RESOURCES;
2361 }
2362
2363 Status = HiiString->GetLanguages (
2364 HiiString,
2365 PackageList,
2366 SupportedLanguages,
2367 &SupportedLanguagesSize
2368 );
2369 if (EFI_ERROR (Status)) {
2370 goto Exit;
2371 }
2372
2373 if (Language == NULL) {
2374 Language = "";
2375 }
2376 GetEfiGlobalVariable2 (L"PlatformLang", (VOID**)&CurrentLanguage, NULL);
2377 BestLanguage = GetBestLanguage (
2378 SupportedLanguages,
2379 FALSE,
2380 Language,
2381 (CurrentLanguage == NULL) ? CurrentLanguage : "",
2382 (CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLang),
2383 NULL
2384 );
2385 if (BestLanguage == NULL) {
2386 Status = EFI_NOT_FOUND;
2387 goto Exit;
2388 }
2389
2390 StringSize = MAX_STRING_LENGTH;
2391 String = (EFI_STRING) AllocateZeroPool (StringSize);
2392 if (String == NULL) {
2393 Status = EFI_OUT_OF_RESOURCES;
2394 goto Exit;
2395 }
2396
2397 Status = HiiString->GetString (
2398 HiiString,
2399 BestLanguage,
2400 PackageList,
2401 StringId,
2402 String,
2403 &StringSize,
2404 &StringFontInfo
2405 );
2406 if (Status == EFI_BUFFER_TOO_SMALL) {
2407 FreePool (String);
2408 String = (EFI_STRING) AllocateZeroPool (StringSize);
2409 if (String == NULL) {
2410 Status = EFI_OUT_OF_RESOURCES;
2411 goto Exit;
2412 }
2413 Status = HiiString->GetString (
2414 HiiString,
2415 BestLanguage,
2416 PackageList,
2417 StringId,
2418 String,
2419 &StringSize,
2420 NULL
2421 );
2422 }
2423
2424 if (EFI_ERROR (Status)) {
2425 goto Exit;
2426 }
2427
2428 //
2429 // When StringInfo specifies that string will be output in the system default font and color,
2430 // use particular stringfontinfo described in string package instead if exists.
2431 // StringFontInfo equals NULL means system default font attaches with the string block.
2432 //
2433 if (StringFontInfo != NULL && IsSystemFontInfo (Private, (EFI_FONT_DISPLAY_INFO *) StringInfo, NULL, NULL)) {
2434 FontLen = sizeof (EFI_FONT_DISPLAY_INFO) - sizeof (CHAR16) + StrSize (StringFontInfo->FontName);
2435 NewStringInfo = AllocateZeroPool (FontLen);
2436 if (NewStringInfo == NULL) {
2437 Status = EFI_OUT_OF_RESOURCES;
2438 goto Exit;
2439 }
2440 NewStringInfo->FontInfoMask = EFI_FONT_INFO_SYS_FORE_COLOR | EFI_FONT_INFO_SYS_BACK_COLOR;
2441 NewStringInfo->FontInfo.FontStyle = StringFontInfo->FontStyle;
2442 NewStringInfo->FontInfo.FontSize = StringFontInfo->FontSize;
2443 StrCpy (NewStringInfo->FontInfo.FontName, StringFontInfo->FontName);
2444
2445 Status = HiiStringToImage (
2446 This,
2447 Flags,
2448 String,
2449 NewStringInfo,
2450 Blt,
2451 BltX,
2452 BltY,
2453 RowInfoArray,
2454 RowInfoArraySize,
2455 ColumnInfoArray
2456 );
2457 goto Exit;
2458 }
2459
2460 Status = HiiStringToImage (
2461 This,
2462 Flags,
2463 String,
2464 StringInfo,
2465 Blt,
2466 BltX,
2467 BltY,
2468 RowInfoArray,
2469 RowInfoArraySize,
2470 ColumnInfoArray
2471 );
2472
2473Exit:
2474 if (SupportedLanguages != NULL) {
2475 FreePool (SupportedLanguages);
2476 }
2477 if (CurrentLanguage != NULL) {
2478 FreePool (CurrentLanguage);
2479 }
2480 if (BestLanguage != NULL) {
2481 FreePool (BestLanguage);
2482 }
2483 if (String != NULL) {
2484 FreePool (String);
2485 }
2486 if (StringFontInfo != NULL) {
2487 FreePool (StringFontInfo);
2488 }
2489 if (NewStringInfo != NULL) {
2490 FreePool (NewStringInfo);
2491 }
2492
2493 return Status;
2494}
2495
2496
2497/**
2498 Convert the glyph for a single character into a bitmap.
2499
2500 @param This A pointer to the EFI_HII_FONT_PROTOCOL instance.
2501 @param Char Character to retrieve.
2502 @param StringInfo Points to the string font and color information
2503 or NULL if the string should use the default
2504 system font and color.
2505 @param Blt Thus must point to a NULL on entry. A buffer will
2506 be allocated to hold the output and the pointer
2507 updated on exit. It is the caller's
2508 responsibility to free this buffer.
2509 @param Baseline Number of pixels from the bottom of the bitmap to
2510 the baseline.
2511
2512 @retval EFI_SUCCESS Glyph bitmap created.
2513 @retval EFI_OUT_OF_RESOURCES Unable to allocate the output buffer Blt.
2514 @retval EFI_WARN_UNKNOWN_GLYPH The glyph was unknown and was replaced with the
2515 glyph for Unicode character 0xFFFD.
2516 @retval EFI_INVALID_PARAMETER Blt is NULL or *Blt is not NULL.
2517
2518**/
2519EFI_STATUS
2520EFIAPI
2521HiiGetGlyph (
2522 IN CONST EFI_HII_FONT_PROTOCOL *This,
2523 IN CHAR16 Char,
2524 IN CONST EFI_FONT_DISPLAY_INFO *StringInfo,
2525 OUT EFI_IMAGE_OUTPUT **Blt,
2526 OUT UINTN *Baseline OPTIONAL
2527 )
2528{
2529 EFI_STATUS Status;
2530 HII_DATABASE_PRIVATE_DATA *Private;
2531 EFI_IMAGE_OUTPUT *Image;
2532 UINT8 *GlyphBuffer;
2533 EFI_FONT_DISPLAY_INFO *SystemDefault;
2534 EFI_FONT_DISPLAY_INFO *StringInfoOut;
2535 BOOLEAN Default;
2536 EFI_FONT_HANDLE FontHandle;
2537 EFI_STRING String;
2538 EFI_HII_GLYPH_INFO Cell;
2539 EFI_FONT_INFO *FontInfo;
2540 UINT8 Attributes;
2541 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground;
2542 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background;
2543 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
2544 UINT16 BaseLine;
2545
2546 if (This == NULL || Blt == NULL || *Blt != NULL) {
2547 return EFI_INVALID_PARAMETER;
2548 }
2549
2550 Private = HII_FONT_DATABASE_PRIVATE_DATA_FROM_THIS (This);
2551
2552 Default = FALSE;
2553 Image = NULL;
2554 SystemDefault = NULL;
2555 FontHandle = NULL;
2556 String = NULL;
2557 GlyphBuffer = NULL;
2558 StringInfoOut = NULL;
2559 FontInfo = NULL;
2560
2561 ZeroMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
2562 ZeroMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
2563
2564 Default = IsSystemFontInfo (Private, (EFI_FONT_DISPLAY_INFO *) StringInfo, &SystemDefault, NULL);
2565
2566 if (!Default) {
2567 //
2568 // Find out a EFI_FONT_DISPLAY_INFO which could display the character in
2569 // the specified color and font.
2570 //
2571 String = (EFI_STRING) AllocateZeroPool (sizeof (CHAR16) * 2);
2572 if (String == NULL) {
2573 Status = EFI_OUT_OF_RESOURCES;
2574 goto Exit;
2575 }
2576 *String = Char;
2577 *(String + 1) = 0;
2578
2579 Status = HiiGetFontInfo (This, &FontHandle, StringInfo, &StringInfoOut, String);
2580 if (EFI_ERROR (Status)) {
2581 goto Exit;
2582 }
2583 ASSERT (StringInfoOut != NULL);
2584 FontInfo = &StringInfoOut->FontInfo;
2585 Foreground = StringInfoOut->ForegroundColor;
2586 Background = StringInfoOut->BackgroundColor;
2587 } else {
2588 ASSERT (SystemDefault != NULL);
2589 Foreground = SystemDefault->ForegroundColor;
2590 Background = SystemDefault->BackgroundColor;
2591 }
2592
2593 Status = GetGlyphBuffer (Private, Char, FontInfo, &GlyphBuffer, &Cell, &Attributes);
2594 if (EFI_ERROR (Status)) {
2595 goto Exit;
2596 }
2597
2598 Image = (EFI_IMAGE_OUTPUT *) AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
2599 if (Image == NULL) {
2600 Status = EFI_OUT_OF_RESOURCES;
2601 goto Exit;
2602 }
2603 Image->Width = Cell.Width;
2604 Image->Height = Cell.Height;
2605
2606 if (Image->Width * Image->Height > 0) {
2607 Image->Image.Bitmap = AllocateZeroPool (Image->Width * Image->Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
2608 if (Image->Image.Bitmap == NULL) {
2609 FreePool (Image);
2610 Status = EFI_OUT_OF_RESOURCES;
2611 goto Exit;
2612 }
2613
2614 //
2615 // Set BaseLine to the char height.
2616 //
2617 BaseLine = (UINT16) (Cell.Height + Cell.OffsetY);
2618 //
2619 // Set BltBuffer to the position of Origin.
2620 //
2621 BltBuffer = Image->Image.Bitmap + (Cell.Height + Cell.OffsetY) * Image->Width - Cell.OffsetX;
2622 GlyphToImage (
2623 GlyphBuffer,
2624 Foreground,
2625 Background,
2626 Image->Width,
2627 BaseLine,
2628 Cell.Width + Cell.OffsetX,
2629 BaseLine - Cell.OffsetY,
2630 FALSE,
2631 &Cell,
2632 Attributes,
2633 &BltBuffer
2634 );
2635 }
2636
2637 *Blt = Image;
2638 if (Baseline != NULL) {
2639 *Baseline = Cell.OffsetY;
2640 }
2641
2642 Status = EFI_SUCCESS;
2643
2644Exit:
2645
2646 if (Status == EFI_NOT_FOUND) {
2647 //
2648 // Glyph is unknown and replaced with the glyph for unicode character 0xFFFD
2649 //
2650 if (Char != REPLACE_UNKNOWN_GLYPH) {
2651 Status = HiiGetGlyph (This, REPLACE_UNKNOWN_GLYPH, StringInfo, Blt, Baseline);
2652 if (!EFI_ERROR (Status)) {
2653 Status = EFI_WARN_UNKNOWN_GLYPH;
2654 }
2655 } else {
2656 Status = EFI_WARN_UNKNOWN_GLYPH;
2657 }
2658 }
2659
2660 if (SystemDefault != NULL) {
2661 FreePool (SystemDefault);
2662 }
2663 if (StringInfoOut != NULL) {
2664 FreePool (StringInfoOut);
2665 }
2666 if (String != NULL) {
2667 FreePool (String);
2668 }
2669 if (GlyphBuffer != NULL) {
2670 FreePool (GlyphBuffer);
2671 }
2672
2673 return Status;
2674}
2675
2676
2677/**
2678 This function iterates through fonts which match the specified font, using
2679 the specified criteria. If String is non-NULL, then all of the characters in
2680 the string must exist in order for a candidate font to be returned.
2681
2682 @param This A pointer to the EFI_HII_FONT_PROTOCOL instance.
2683 @param FontHandle On entry, points to the font handle returned by a
2684 previous call to GetFontInfo() or NULL to start
2685 with the first font. On return, points to the
2686 returned font handle or points to NULL if there
2687 are no more matching fonts.
2688 @param StringInfoIn Upon entry, points to the font to return information
2689 about. If NULL, then the information about the system
2690 default font will be returned.
2691 @param StringInfoOut Upon return, contains the matching font's information.
2692 If NULL, then no information is returned. This buffer
2693 is allocated with a call to the Boot Service AllocatePool().
2694 It is the caller's responsibility to call the Boot
2695 Service FreePool() when the caller no longer requires
2696 the contents of StringInfoOut.
2697 @param String Points to the string which will be tested to
2698 determine if all characters are available. If
2699 NULL, then any font is acceptable.
2700
2701 @retval EFI_SUCCESS Matching font returned successfully.
2702 @retval EFI_NOT_FOUND No matching font was found.
2703 @retval EFI_INVALID_PARAMETER StringInfoIn->FontInfoMask is an invalid combination.
2704 @retval EFI_OUT_OF_RESOURCES There were insufficient resources to complete the
2705 request.
2706
2707**/
2708EFI_STATUS
2709EFIAPI
2710HiiGetFontInfo (
2711 IN CONST EFI_HII_FONT_PROTOCOL *This,
2712 IN OUT EFI_FONT_HANDLE *FontHandle,
2713 IN CONST EFI_FONT_DISPLAY_INFO *StringInfoIn, OPTIONAL
2714 OUT EFI_FONT_DISPLAY_INFO **StringInfoOut,
2715 IN CONST EFI_STRING String OPTIONAL
2716 )
2717{
2718 HII_DATABASE_PRIVATE_DATA *Private;
2719 EFI_STATUS Status;
2720 EFI_FONT_DISPLAY_INFO *SystemDefault;
2721 EFI_FONT_DISPLAY_INFO InfoOut;
2722 UINTN StringInfoOutLen;
2723 EFI_FONT_INFO *FontInfo;
2724 HII_GLOBAL_FONT_INFO *GlobalFont;
2725 EFI_STRING StringIn;
2726 EFI_FONT_HANDLE LocalFontHandle;
2727
2728 if (This == NULL) {
2729 return EFI_INVALID_PARAMETER;
2730 }
2731
2732 StringInfoOutLen = 0;
2733 FontInfo = NULL;
2734 SystemDefault = NULL;
2735 LocalFontHandle = NULL;
2736 if (FontHandle != NULL) {
2737 LocalFontHandle = *FontHandle;
2738 }
2739
2740 Private = HII_FONT_DATABASE_PRIVATE_DATA_FROM_THIS (This);
2741
2742 //
2743 // Already searched to the end of the whole list, return directly.
2744 //
2745 if (LocalFontHandle == &Private->FontInfoList) {
2746 LocalFontHandle = NULL;
2747 Status = EFI_NOT_FOUND;
2748 goto Exit;
2749 }
2750
2751 //
2752 // Get default system display info, if StringInfoIn points to
2753 // system display info, return it directly.
2754 //
2755 if (IsSystemFontInfo (Private, (EFI_FONT_DISPLAY_INFO *) StringInfoIn, &SystemDefault, &StringInfoOutLen)) {
2756 //
2757 // System font is the first node. When handle is not NULL, system font can not
2758 // be found any more.
2759 //
2760 if (LocalFontHandle == NULL) {
2761 if (StringInfoOut != NULL) {
2762 *StringInfoOut = AllocateCopyPool (StringInfoOutLen, SystemDefault);
2763 if (*StringInfoOut == NULL) {
2764 Status = EFI_OUT_OF_RESOURCES;
2765 LocalFontHandle = NULL;
2766 goto Exit;
2767 }
2768 }
2769
2770 LocalFontHandle = Private->FontInfoList.ForwardLink;
2771 Status = EFI_SUCCESS;
2772 goto Exit;
2773 } else {
2774 LocalFontHandle = NULL;
2775 Status = EFI_NOT_FOUND;
2776 goto Exit;
2777 }
2778 }
2779
2780 //
2781 // StringInfoIn must not be NULL if it is not system default font info.
2782 //
2783 ASSERT (StringInfoIn != NULL);
2784 //
2785 // Check the font information mask to make sure it is valid.
2786 //
2787 if (((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_SYS_FONT | EFI_FONT_INFO_ANY_FONT)) ==
2788 (EFI_FONT_INFO_SYS_FONT | EFI_FONT_INFO_ANY_FONT)) ||
2789 ((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_SYS_SIZE | EFI_FONT_INFO_ANY_SIZE)) ==
2790 (EFI_FONT_INFO_SYS_SIZE | EFI_FONT_INFO_ANY_SIZE)) ||
2791 ((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_SYS_STYLE | EFI_FONT_INFO_ANY_STYLE)) ==
2792 (EFI_FONT_INFO_SYS_STYLE | EFI_FONT_INFO_ANY_STYLE)) ||
2793 ((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_RESIZE | EFI_FONT_INFO_ANY_SIZE)) ==
2794 (EFI_FONT_INFO_RESIZE | EFI_FONT_INFO_ANY_SIZE)) ||
2795 ((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_RESTYLE | EFI_FONT_INFO_ANY_STYLE)) ==
2796 (EFI_FONT_INFO_RESTYLE | EFI_FONT_INFO_ANY_STYLE))) {
2797 return EFI_INVALID_PARAMETER;
2798 }
2799
2800 //
2801 // Parse the font information mask to find a matching font.
2802 //
2803
2804 CopyMem (&InfoOut, (EFI_FONT_DISPLAY_INFO *) StringInfoIn, sizeof (EFI_FONT_DISPLAY_INFO));
2805
2806 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_FONT) == EFI_FONT_INFO_SYS_FONT) {
2807 Status = SaveFontName (SystemDefault->FontInfo.FontName, &FontInfo);
2808 } else {
2809 Status = SaveFontName (((EFI_FONT_DISPLAY_INFO *) StringInfoIn)->FontInfo.FontName, &FontInfo);
2810 }
2811 if (EFI_ERROR (Status)) {
2812 goto Exit;
2813 }
2814
2815 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_SIZE) == EFI_FONT_INFO_SYS_SIZE) {
2816 InfoOut.FontInfo.FontSize = SystemDefault->FontInfo.FontSize;
2817 }
2818 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_STYLE) == EFI_FONT_INFO_SYS_STYLE) {
2819 InfoOut.FontInfo.FontStyle = SystemDefault->FontInfo.FontStyle;
2820 }
2821 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_FORE_COLOR) == EFI_FONT_INFO_SYS_FORE_COLOR) {
2822 InfoOut.ForegroundColor = SystemDefault->ForegroundColor;
2823 }
2824 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_BACK_COLOR) == EFI_FONT_INFO_SYS_BACK_COLOR) {
2825 InfoOut.BackgroundColor = SystemDefault->BackgroundColor;
2826 }
2827
2828 ASSERT (FontInfo != NULL);
2829 FontInfo->FontSize = InfoOut.FontInfo.FontSize;
2830 FontInfo->FontStyle = InfoOut.FontInfo.FontStyle;
2831
2832 if (IsFontInfoExisted (Private, FontInfo, &InfoOut.FontInfoMask, LocalFontHandle, &GlobalFont)) {
2833 //
2834 // Test to guarantee all characters are available in the found font.
2835 //
2836 if (String != NULL) {
2837 StringIn = String;
2838 while (*StringIn != 0) {
2839 Status = FindGlyphBlock (GlobalFont->FontPackage, *StringIn, NULL, NULL, NULL);
2840 if (EFI_ERROR (Status)) {
2841 LocalFontHandle = NULL;
2842 goto Exit;
2843 }
2844 StringIn++;
2845 }
2846 }
2847 //
2848 // Write to output parameter
2849 //
2850 if (StringInfoOut != NULL) {
2851 StringInfoOutLen = sizeof (EFI_FONT_DISPLAY_INFO) - sizeof (EFI_FONT_INFO) + GlobalFont->FontInfoSize;
2852 *StringInfoOut = (EFI_FONT_DISPLAY_INFO *) AllocateZeroPool (StringInfoOutLen);
2853 if (*StringInfoOut == NULL) {
2854 Status = EFI_OUT_OF_RESOURCES;
2855 LocalFontHandle = NULL;
2856 goto Exit;
2857 }
2858
2859 CopyMem (*StringInfoOut, &InfoOut, sizeof (EFI_FONT_DISPLAY_INFO));
2860 CopyMem (&(*StringInfoOut)->FontInfo, GlobalFont->FontInfo, GlobalFont->FontInfoSize);
2861 }
2862
2863 LocalFontHandle = GlobalFont->Entry.ForwardLink;
2864 Status = EFI_SUCCESS;
2865 goto Exit;
2866 }
2867
2868 Status = EFI_NOT_FOUND;
2869
2870Exit:
2871
2872 if (FontHandle != NULL) {
2873 *FontHandle = LocalFontHandle;
2874 }
2875
2876 if (SystemDefault != NULL) {
2877 FreePool (SystemDefault);
2878 }
2879 if (FontInfo != NULL) {
2880 FreePool (FontInfo);
2881 }
2882 return Status;
2883}
2884
2885
Note: See TracBrowser for help on using the repository browser.

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