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