]> 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
Support proportional Font and Font output flags.
[mirror_edk2.git] / MdeModulePkg / Universal / HiiDatabaseDxe / Font.c
1 /** @file
2 Implementation for EFI_HII_FONT_PROTOCOL.
3
4
5 Copyright (c) 2007 - 2011, Intel Corporation. All rights reserved.<BR>
6 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 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 **/
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 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 **/
105 EFI_STATUS
106 GetCell (
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 **/
159 EFI_STATUS
160 GetGlyphBuffer (
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 **/
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 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 **/
364 VOID
365 GlyphToBlt (
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 **/
481 VOID
482 GlyphToImage (
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 **/
607 EFI_STATUS
608 WriteOutputParam (
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 **/
662 EFI_STATUS
663 FindGlyphBlock (
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 += *(BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK) + sizeof (UINT8));
761 break;
762 case EFI_HII_GIBT_EXT2:
763 CopyMem (
764 &Length16,
765 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 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 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 **/
929 EFI_STATUS
930 SaveFontName (
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 **/
965 EFI_STATUS
966 GetSystemFont (
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 **/
1024 BOOLEAN
1025 IsSystemFontInfo (
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 Status = GetSystemFont (Private, &SystemDefault, &DefaultLen);
1044 ASSERT_EFI_ERROR (Status);
1045
1046 //
1047 // Record the system default info.
1048 //
1049 if (SystemInfo != NULL) {
1050 *SystemInfo = SystemDefault;
1051 }
1052
1053 if (SystemInfoLen != NULL) {
1054 *SystemInfoLen = DefaultLen;
1055 }
1056
1057 if (StringInfo == NULL) {
1058 return TRUE;
1059 }
1060
1061 Flag = FALSE;
1062 //
1063 // Check the FontInfoMask to see whether it is retrieving system info.
1064 //
1065 if ((StringInfo->FontInfoMask & (EFI_FONT_INFO_SYS_FONT | EFI_FONT_INFO_ANY_FONT)) == 0) {
1066 if (StrCmp (StringInfo->FontInfo.FontName, SystemDefault->FontInfo.FontName) != 0) {
1067 goto Exit;
1068 }
1069 }
1070 if ((StringInfo->FontInfoMask & (EFI_FONT_INFO_SYS_SIZE | EFI_FONT_INFO_ANY_SIZE)) == 0) {
1071 if (StringInfo->FontInfo.FontSize != SystemDefault->FontInfo.FontSize) {
1072 goto Exit;
1073 }
1074 }
1075 if ((StringInfo->FontInfoMask & (EFI_FONT_INFO_SYS_STYLE | EFI_FONT_INFO_ANY_STYLE)) == 0) {
1076 if (StringInfo->FontInfo.FontStyle != SystemDefault->FontInfo.FontStyle) {
1077 goto Exit;
1078 }
1079 }
1080 if ((StringInfo->FontInfoMask & EFI_FONT_INFO_SYS_FORE_COLOR) == 0) {
1081 if (CompareMem (
1082 &StringInfo->ForegroundColor,
1083 &SystemDefault->ForegroundColor,
1084 sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
1085 ) != 0) {
1086 goto Exit;
1087 }
1088 }
1089 if ((StringInfo->FontInfoMask & EFI_FONT_INFO_SYS_BACK_COLOR) == 0) {
1090 if (CompareMem (
1091 &StringInfo->BackgroundColor,
1092 &SystemDefault->BackgroundColor,
1093 sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL)
1094 ) != 0) {
1095 goto Exit;
1096 }
1097 }
1098
1099 Flag = TRUE;
1100
1101 Exit:
1102 if (SystemInfo == NULL) {
1103 if (SystemDefault != NULL) {
1104 FreePool (SystemDefault);
1105 }
1106 }
1107 return Flag;
1108 }
1109
1110
1111 /**
1112 This function checks whether EFI_FONT_INFO exists in current database. If
1113 FontInfoMask is specified, check what options can be used to make a match.
1114 Note that the masks relate to where the system default should be supplied
1115 are ignored by this function.
1116
1117 @param Private Hii database private structure.
1118 @param FontInfo Points to EFI_FONT_INFO structure.
1119 @param FontInfoMask If not NULL, describes what options can be used
1120 to make a match between the font requested and
1121 the font available. The caller must guarantee
1122 this mask is valid.
1123 @param FontHandle On entry, Points to the font handle returned by a
1124 previous call to GetFontInfo() or NULL to start
1125 with the first font.
1126 @param GlobalFontInfo If not NULL, output the corresponding globa font
1127 info.
1128
1129 @retval TRUE Existed
1130 @retval FALSE Not existed
1131
1132 **/
1133 BOOLEAN
1134 IsFontInfoExisted (
1135 IN HII_DATABASE_PRIVATE_DATA *Private,
1136 IN EFI_FONT_INFO *FontInfo,
1137 IN EFI_FONT_INFO_MASK *FontInfoMask, OPTIONAL
1138 IN EFI_FONT_HANDLE FontHandle, OPTIONAL
1139 OUT HII_GLOBAL_FONT_INFO **GlobalFontInfo OPTIONAL
1140 )
1141 {
1142 HII_GLOBAL_FONT_INFO *GlobalFont;
1143 HII_GLOBAL_FONT_INFO *GlobalFontBackup1;
1144 HII_GLOBAL_FONT_INFO *GlobalFontBackup2;
1145 LIST_ENTRY *Link;
1146 EFI_FONT_INFO_MASK Mask;
1147 BOOLEAN Matched;
1148 BOOLEAN VagueMatched1;
1149 BOOLEAN VagueMatched2;
1150
1151 ASSERT (Private != NULL && Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);
1152 ASSERT (FontInfo != NULL);
1153
1154 //
1155 // Matched flag represents an exactly match; VagueMatched1 repensents a RESIZE
1156 // or RESTYLE match; VagueMatched2 represents a RESIZE | RESTYLE match.
1157 //
1158 Matched = FALSE;
1159 VagueMatched1 = FALSE;
1160 VagueMatched2 = FALSE;
1161
1162 Mask = 0;
1163 GlobalFontBackup1 = NULL;
1164 GlobalFontBackup2 = NULL;
1165
1166 // The process of where the system default should be supplied instead of
1167 // the specified font info beyonds this function's scope.
1168 //
1169 if (FontInfoMask != NULL) {
1170 Mask = *FontInfoMask & (~SYS_FONT_INFO_MASK);
1171 }
1172
1173 //
1174 // If not NULL, FontHandle points to the next node of the last searched font
1175 // node by previous call.
1176 //
1177 if (FontHandle == NULL) {
1178 Link = Private->FontInfoList.ForwardLink;
1179 } else {
1180 Link = (LIST_ENTRY *) FontHandle;
1181 }
1182
1183 for (; Link != &Private->FontInfoList; Link = Link->ForwardLink) {
1184 GlobalFont = CR (Link, HII_GLOBAL_FONT_INFO, Entry, HII_GLOBAL_FONT_INFO_SIGNATURE);
1185 if (FontInfoMask == NULL) {
1186 if (CompareMem (GlobalFont->FontInfo, FontInfo, GlobalFont->FontInfoSize) == 0) {
1187 if (GlobalFontInfo != NULL) {
1188 *GlobalFontInfo = GlobalFont;
1189 }
1190 return TRUE;
1191 }
1192 } else {
1193 //
1194 // Check which options could be used to make a match.
1195 //
1196 switch (Mask) {
1197 case EFI_FONT_INFO_ANY_FONT:
1198 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle &&
1199 GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1200 Matched = TRUE;
1201 }
1202 break;
1203 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_STYLE:
1204 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1205 Matched = TRUE;
1206 }
1207 break;
1208 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_SIZE:
1209 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1210 Matched = TRUE;
1211 }
1212 break;
1213 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_SIZE | EFI_FONT_INFO_ANY_STYLE:
1214 Matched = TRUE;
1215 break;
1216 //
1217 // If EFI_FONT_INFO_RESTYLE is specified, then the system may attempt to
1218 // remove some of the specified styles to meet the style requested.
1219 //
1220 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_RESTYLE:
1221 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1222 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1223 Matched = TRUE;
1224 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1225 VagueMatched1 = TRUE;
1226 GlobalFontBackup1 = GlobalFont;
1227 }
1228 }
1229 break;
1230 //
1231 // If EFI_FONT_INFO_RESIZE is specified, then the sytem may attempt to
1232 // stretch or shrink a font to meet the size requested.
1233 //
1234 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_RESIZE:
1235 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1236 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1237 Matched = TRUE;
1238 } else {
1239 VagueMatched1 = TRUE;
1240 GlobalFontBackup1 = GlobalFont;
1241 }
1242 }
1243 break;
1244 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_RESTYLE | EFI_FONT_INFO_RESIZE:
1245 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1246 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1247 Matched = TRUE;
1248 } else {
1249 VagueMatched1 = TRUE;
1250 GlobalFontBackup1 = GlobalFont;
1251 }
1252 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1253 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1254 VagueMatched1 = TRUE;
1255 GlobalFontBackup1 = GlobalFont;
1256 } else {
1257 VagueMatched2 = TRUE;
1258 GlobalFontBackup2 = GlobalFont;
1259 }
1260 }
1261 break;
1262 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_STYLE | EFI_FONT_INFO_RESIZE:
1263 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1264 Matched = TRUE;
1265 } else {
1266 VagueMatched1 = TRUE;
1267 GlobalFontBackup1 = GlobalFont;
1268 }
1269 break;
1270 case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_SIZE | EFI_FONT_INFO_RESTYLE:
1271 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1272 Matched = TRUE;
1273 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1274 VagueMatched1 = TRUE;
1275 GlobalFontBackup1 = GlobalFont;
1276 }
1277 break;
1278 case EFI_FONT_INFO_ANY_STYLE:
1279 if ((CompareMem (
1280 GlobalFont->FontInfo->FontName,
1281 FontInfo->FontName,
1282 StrSize (FontInfo->FontName)
1283 ) == 0) &&
1284 GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1285 Matched = TRUE;
1286 }
1287 break;
1288 case EFI_FONT_INFO_ANY_STYLE | EFI_FONT_INFO_ANY_SIZE:
1289 if (CompareMem (
1290 GlobalFont->FontInfo->FontName,
1291 FontInfo->FontName,
1292 StrSize (FontInfo->FontName)
1293 ) == 0) {
1294 Matched = TRUE;
1295 }
1296 break;
1297 case EFI_FONT_INFO_ANY_STYLE | EFI_FONT_INFO_RESIZE:
1298 if (CompareMem (
1299 GlobalFont->FontInfo->FontName,
1300 FontInfo->FontName,
1301 StrSize (FontInfo->FontName)
1302 ) == 0) {
1303 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1304 Matched = TRUE;
1305 } else {
1306 VagueMatched1 = TRUE;
1307 GlobalFontBackup1 = GlobalFont;
1308 }
1309 }
1310 break;
1311 case EFI_FONT_INFO_ANY_SIZE:
1312 if ((CompareMem (
1313 GlobalFont->FontInfo->FontName,
1314 FontInfo->FontName,
1315 StrSize (FontInfo->FontName)
1316 ) == 0) &&
1317 GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1318 Matched = TRUE;
1319 }
1320 break;
1321 case EFI_FONT_INFO_ANY_SIZE | EFI_FONT_INFO_RESTYLE:
1322 if (CompareMem (
1323 GlobalFont->FontInfo->FontName,
1324 FontInfo->FontName,
1325 StrSize (FontInfo->FontName)
1326 ) == 0) {
1327 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1328 Matched = TRUE;
1329 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1330 VagueMatched1 = TRUE;
1331 GlobalFontBackup1 = GlobalFont;
1332 }
1333 }
1334 break;
1335 case EFI_FONT_INFO_RESTYLE:
1336 if ((CompareMem (
1337 GlobalFont->FontInfo->FontName,
1338 FontInfo->FontName,
1339 StrSize (FontInfo->FontName)
1340 ) == 0) &&
1341 GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1342
1343 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1344 Matched = TRUE;
1345 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1346 VagueMatched1 = TRUE;
1347 GlobalFontBackup1 = GlobalFont;
1348 }
1349 }
1350 break;
1351 case EFI_FONT_INFO_RESIZE:
1352 if ((CompareMem (
1353 GlobalFont->FontInfo->FontName,
1354 FontInfo->FontName,
1355 StrSize (FontInfo->FontName)
1356 ) == 0) &&
1357 GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1358
1359 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1360 Matched = TRUE;
1361 } else {
1362 VagueMatched1 = TRUE;
1363 GlobalFontBackup1 = GlobalFont;
1364 }
1365 }
1366 break;
1367 case EFI_FONT_INFO_RESIZE | EFI_FONT_INFO_RESTYLE:
1368 if (CompareMem (
1369 GlobalFont->FontInfo->FontName,
1370 FontInfo->FontName,
1371 StrSize (FontInfo->FontName)
1372 ) == 0) {
1373 if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {
1374 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1375 Matched = TRUE;
1376 } else {
1377 VagueMatched1 = TRUE;
1378 GlobalFontBackup1 = GlobalFont;
1379 }
1380 } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {
1381 if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {
1382 VagueMatched1 = TRUE;
1383 GlobalFontBackup1 = GlobalFont;
1384 } else {
1385 VagueMatched2 = TRUE;
1386 GlobalFontBackup2 = GlobalFont;
1387 }
1388 }
1389 }
1390 break;
1391 default:
1392 break;
1393 }
1394
1395 if (Matched) {
1396 if (GlobalFontInfo != NULL) {
1397 *GlobalFontInfo = GlobalFont;
1398 }
1399 return TRUE;
1400 }
1401 }
1402 }
1403
1404 if (VagueMatched1) {
1405 if (GlobalFontInfo != NULL) {
1406 *GlobalFontInfo = GlobalFontBackup1;
1407 }
1408 return TRUE;
1409 } else if (VagueMatched2) {
1410 if (GlobalFontInfo != NULL) {
1411 *GlobalFontInfo = GlobalFontBackup2;
1412 }
1413 return TRUE;
1414 }
1415
1416 return FALSE;
1417 }
1418
1419
1420 /**
1421 Check whether the unicode represents a line break or not.
1422
1423 This is a internal function. Please see Section 27.2.6 of the UEFI Specification
1424 for a description of the supported string format.
1425
1426 @param Char Unicode character
1427
1428 @retval 0 Yes, it forces a line break.
1429 @retval 1 Yes, it presents a line break opportunity
1430 @retval 2 Yes, it requires a line break happen before and after it.
1431 @retval -1 No, it is not a link break.
1432
1433 **/
1434 INT8
1435 IsLineBreak (
1436 IN CHAR16 Char
1437 )
1438 {
1439 switch (Char) {
1440 //
1441 // Mandatory line break characters, which force a line-break
1442 //
1443 case 0x000C:
1444 case 0x000D:
1445 case 0x2028:
1446 case 0x2029:
1447 return 0;
1448 //
1449 // Space characters, which is taken as a line-break opportunity
1450 //
1451 case 0x0020:
1452 case 0x1680:
1453 case 0x2000:
1454 case 0x2001:
1455 case 0x2002:
1456 case 0x2003:
1457 case 0x2004:
1458 case 0x2005:
1459 case 0x2006:
1460 case 0x2008:
1461 case 0x2009:
1462 case 0x200A:
1463 case 0x205F:
1464 //
1465 // In-Word Break Opportunities
1466 //
1467 case 0x200B:
1468 return 1;
1469 //
1470 // A space which is not a line-break opportunity
1471 //
1472 case 0x00A0:
1473 case 0x202F:
1474 //
1475 // A hyphen which is not a line-break opportunity
1476 //
1477 case 0x2011:
1478 return -1;
1479 //
1480 // Hyphen characters which describe line break opportunities after the character
1481 //
1482 case 0x058A:
1483 case 0x2010:
1484 case 0x2012:
1485 case 0x2013:
1486 case 0x0F0B:
1487 case 0x1361:
1488 case 0x17D5:
1489 return 1;
1490 //
1491 // A hyphen which describes line break opportunities before and after them, but not between a pair of them
1492 //
1493 case 0x2014:
1494 return 2;
1495 }
1496 return -1;
1497 }
1498
1499
1500 /**
1501 Renders a string to a bitmap or to the display.
1502
1503 @param This A pointer to the EFI_HII_FONT_PROTOCOL instance.
1504 @param Flags Describes how the string is to be drawn.
1505 @param String Points to the null-terminated string to be
1506 displayed.
1507 @param StringInfo Points to the string output information,
1508 including the color and font. If NULL, then the
1509 string will be output in the default system font
1510 and color.
1511 @param Blt If this points to a non-NULL on entry, this
1512 points to the image, which is Width pixels wide
1513 and Height pixels high. The string will be drawn
1514 onto this image and
1515 EFI_HII_OUT_FLAG_CLIP is implied. If this points
1516 to a NULL on entry, then a buffer
1517 will be allocated to hold the generated image and
1518 the pointer updated on exit. It is the caller's
1519 responsibility to free this buffer.
1520 @param BltX Specifies the offset from the left and top edge
1521 of the image of the first character cell in the
1522 image.
1523 @param BltY Specifies the offset from the left and top edge
1524 of the image of the first character cell in the
1525 image.
1526 @param RowInfoArray If this is non-NULL on entry, then on exit, this
1527 will point to an allocated buffer containing
1528 row information and RowInfoArraySize will be
1529 updated to contain the number of elements.
1530 This array describes the characters which were at
1531 least partially drawn and the heights of the
1532 rows. It is the caller's responsibility to free
1533 this buffer.
1534 @param RowInfoArraySize If this is non-NULL on entry, then on exit it
1535 contains the number of elements in RowInfoArray.
1536 @param ColumnInfoArray If this is non-NULL, then on return it will be
1537 filled with the horizontal offset for each
1538 character in the string on the row where it is
1539 displayed. Non-printing characters will have
1540 the offset ~0. The caller is responsible to
1541 allocate a buffer large enough so that there
1542 is one entry for each character in the string,
1543 not including the null-terminator. It is possible
1544 when character display is normalized that some
1545 character cells overlap.
1546
1547 @retval EFI_SUCCESS The string was successfully rendered.
1548 @retval EFI_OUT_OF_RESOURCES Unable to allocate an output buffer for
1549 RowInfoArray or Blt.
1550 @retval EFI_INVALID_PARAMETER The String or Blt was NULL.
1551 @retval EFI_INVALID_PARAMETER Flags were invalid combination..
1552
1553 **/
1554 EFI_STATUS
1555 EFIAPI
1556 HiiStringToImage (
1557 IN CONST EFI_HII_FONT_PROTOCOL *This,
1558 IN EFI_HII_OUT_FLAGS Flags,
1559 IN CONST EFI_STRING String,
1560 IN CONST EFI_FONT_DISPLAY_INFO *StringInfo OPTIONAL,
1561 IN OUT EFI_IMAGE_OUTPUT **Blt,
1562 IN UINTN BltX,
1563 IN UINTN BltY,
1564 OUT EFI_HII_ROW_INFO **RowInfoArray OPTIONAL,
1565 OUT UINTN *RowInfoArraySize OPTIONAL,
1566 OUT UINTN *ColumnInfoArray OPTIONAL
1567 )
1568 {
1569 EFI_STATUS Status;
1570 HII_DATABASE_PRIVATE_DATA *Private;
1571 UINT8 **GlyphBuf;
1572 EFI_HII_GLYPH_INFO *Cell;
1573 UINT8 *Attributes;
1574 EFI_IMAGE_OUTPUT *Image;
1575 EFI_STRING StringPtr;
1576 EFI_STRING StringTmp;
1577 EFI_HII_ROW_INFO *RowInfo;
1578 UINTN LineWidth;
1579 UINTN LineHeight;
1580 UINTN LineOffset;
1581 UINTN LastLineHeight;
1582 UINTN BaseLineOffset;
1583 UINT16 MaxRowNum;
1584 UINT16 RowIndex;
1585 UINTN Index;
1586 UINTN NextIndex;
1587 UINTN Index1;
1588 EFI_FONT_DISPLAY_INFO *StringInfoOut;
1589 EFI_FONT_DISPLAY_INFO *SystemDefault;
1590 EFI_FONT_HANDLE FontHandle;
1591 EFI_STRING StringIn;
1592 EFI_STRING StringIn2;
1593 UINT16 Height;
1594 UINT16 BaseLine;
1595 EFI_FONT_INFO *FontInfo;
1596 BOOLEAN SysFontFlag;
1597 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground;
1598 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background;
1599 BOOLEAN Transparent;
1600 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
1601 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BufferPtr;
1602 UINTN RowInfoSize;
1603 BOOLEAN LineBreak;
1604 UINTN StrLength;
1605 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *RowBufferPtr;
1606 HII_GLOBAL_FONT_INFO *GlobalFont;
1607
1608 //
1609 // Check incoming parameters.
1610 //
1611
1612 if (This == NULL || String == NULL || Blt == NULL) {
1613 return EFI_INVALID_PARAMETER;
1614 }
1615 if (*Blt == NULL) {
1616 //
1617 // These two flag cannot be used if Blt is NULL upon entry.
1618 //
1619 if ((Flags & EFI_HII_OUT_FLAG_TRANSPARENT) == EFI_HII_OUT_FLAG_TRANSPARENT) {
1620 return EFI_INVALID_PARAMETER;
1621 }
1622 if ((Flags & EFI_HII_OUT_FLAG_CLIP) == EFI_HII_OUT_FLAG_CLIP) {
1623 return EFI_INVALID_PARAMETER;
1624 }
1625 }
1626 //
1627 // These two flags require that EFI_HII_OUT_FLAG_CLIP be also set.
1628 //
1629 if ((Flags & (EFI_HII_OUT_FLAG_CLIP | EFI_HII_OUT_FLAG_CLIP_CLEAN_X)) == EFI_HII_OUT_FLAG_CLIP_CLEAN_X) {
1630 return EFI_INVALID_PARAMETER;
1631 }
1632 if ((Flags & (EFI_HII_OUT_FLAG_CLIP | EFI_HII_OUT_FLAG_CLIP_CLEAN_Y)) == EFI_HII_OUT_FLAG_CLIP_CLEAN_Y) {
1633 return EFI_INVALID_PARAMETER;
1634 }
1635 //
1636 // This flag cannot be used with EFI_HII_OUT_FLAG_CLEAN_X.
1637 //
1638 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)) {
1639 return EFI_INVALID_PARAMETER;
1640 }
1641
1642 if (*Blt == NULL) {
1643 //
1644 // Create a new bitmap and draw the string onto this image.
1645 //
1646 Image = AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
1647 if (Image == NULL) {
1648 return EFI_OUT_OF_RESOURCES;
1649 }
1650 Image->Width = 800;
1651 Image->Height = 600;
1652 Image->Image.Bitmap = AllocateZeroPool (Image->Width * Image->Height *sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
1653 if (Image->Image.Bitmap == NULL) {
1654 FreePool (Image);
1655 return EFI_OUT_OF_RESOURCES;
1656 }
1657
1658 //
1659 // Other flags are not permitted when Blt is NULL.
1660 //
1661 Flags &= EFI_HII_OUT_FLAG_WRAP | EFI_HII_IGNORE_IF_NO_GLYPH | EFI_HII_IGNORE_LINE_BREAK;
1662 *Blt = Image;
1663 }
1664
1665 StrLength = StrLen(String);
1666 GlyphBuf = (UINT8 **) AllocateZeroPool (StrLength * sizeof (UINT8 *));
1667 ASSERT (GlyphBuf != NULL);
1668 Cell = (EFI_HII_GLYPH_INFO *) AllocateZeroPool (StrLength * sizeof (EFI_HII_GLYPH_INFO));
1669 ASSERT (Cell != NULL);
1670 Attributes = (UINT8 *) AllocateZeroPool (StrLength * sizeof (UINT8));
1671 ASSERT (Attributes != NULL);
1672
1673 RowInfo = NULL;
1674 Status = EFI_SUCCESS;
1675 StringIn2 = NULL;
1676 SystemDefault = NULL;
1677 StringIn = NULL;
1678
1679 //
1680 // Calculate the string output information, including specified color and font .
1681 // If StringInfo does not points to system font info, it must indicate an existing
1682 // EFI_FONT_INFO.
1683 //
1684 StringInfoOut = NULL;
1685 FontHandle = NULL;
1686 Private = HII_FONT_DATABASE_PRIVATE_DATA_FROM_THIS (This);
1687 SysFontFlag = IsSystemFontInfo (Private, (EFI_FONT_DISPLAY_INFO *) StringInfo, &SystemDefault, NULL);
1688
1689 if (SysFontFlag) {
1690 FontInfo = NULL;
1691 Height = SystemDefault->FontInfo.FontSize;
1692 BaseLine = SystemDefault->FontInfo.FontSize;
1693 Foreground = SystemDefault->ForegroundColor;
1694 Background = SystemDefault->BackgroundColor;
1695
1696 } else {
1697 //
1698 // StringInfo must not be NULL if it is not system info.
1699 //
1700 ASSERT (StringInfo != NULL);
1701 Status = HiiGetFontInfo (This, &FontHandle, (EFI_FONT_DISPLAY_INFO *) StringInfo, &StringInfoOut, NULL);
1702 if (Status == EFI_NOT_FOUND) {
1703 //
1704 // The specified EFI_FONT_DISPLAY_INFO does not exist in current database.
1705 // Use the system font instead. Still use the color specified by StringInfo.
1706 //
1707 SysFontFlag = TRUE;
1708 FontInfo = NULL;
1709 Height = SystemDefault->FontInfo.FontSize;
1710 BaseLine = SystemDefault->FontInfo.FontSize;
1711 Foreground = ((EFI_FONT_DISPLAY_INFO *) StringInfo)->ForegroundColor;
1712 Background = ((EFI_FONT_DISPLAY_INFO *) StringInfo)->BackgroundColor;
1713
1714 } else if (Status == EFI_SUCCESS) {
1715 FontInfo = &StringInfoOut->FontInfo;
1716 IsFontInfoExisted (Private, FontInfo, NULL, NULL, &GlobalFont);
1717 Height = GlobalFont->FontPackage->Height;
1718 BaseLine = GlobalFont->FontPackage->BaseLine;
1719 Foreground = StringInfoOut->ForegroundColor;
1720 Background = StringInfoOut->BackgroundColor;
1721 } else {
1722 goto Exit;
1723 }
1724 }
1725
1726 //
1727 // Use the maxinum height of font as the base line.
1728 // And, use the maxinum height as line height.
1729 //
1730 LineHeight = Height;
1731 LastLineHeight = Height;
1732 BaseLineOffset = Height - BaseLine;
1733
1734 //
1735 // Parse the string to be displayed to drop some ignored characters.
1736 //
1737
1738 StringPtr = String;
1739
1740 //
1741 // Ignore line-break characters only. Hyphens or dash character will be displayed
1742 // without line-break opportunity.
1743 //
1744 if ((Flags & EFI_HII_IGNORE_LINE_BREAK) == EFI_HII_IGNORE_LINE_BREAK) {
1745 StringIn = AllocateZeroPool (StrSize (StringPtr));
1746 if (StringIn == NULL) {
1747 Status = EFI_OUT_OF_RESOURCES;
1748 goto Exit;
1749 }
1750 StringTmp = StringIn;
1751 while (*StringPtr != 0) {
1752 if (IsLineBreak (*StringPtr) == 0) {
1753 StringPtr++;
1754 } else {
1755 *StringTmp++ = *StringPtr++;
1756 }
1757 }
1758 *StringTmp = 0;
1759 StringPtr = StringIn;
1760 }
1761 //
1762 // If EFI_HII_IGNORE_IF_NO_GLYPH is set, then characters which have no glyphs
1763 // are not drawn. Otherwise they are replaced wth Unicode character 0xFFFD.
1764 //
1765 StringIn2 = AllocateZeroPool (StrSize (StringPtr));
1766 if (StringIn2 == NULL) {
1767 Status = EFI_OUT_OF_RESOURCES;
1768 goto Exit;
1769 }
1770 Index = 0;
1771 StringTmp = StringIn2;
1772 StrLength = StrLen(StringPtr);
1773 while (*StringPtr != 0 && Index < StrLength) {
1774 if (IsLineBreak (*StringPtr) == 0) {
1775 *StringTmp++ = *StringPtr++;
1776 Index++;
1777 continue;
1778 }
1779
1780 Status = GetGlyphBuffer (Private, *StringPtr, FontInfo, &GlyphBuf[Index], &Cell[Index], &Attributes[Index]);
1781 if (Status == EFI_NOT_FOUND) {
1782 if ((Flags & EFI_HII_IGNORE_IF_NO_GLYPH) == EFI_HII_IGNORE_IF_NO_GLYPH) {
1783 GlyphBuf[Index] = NULL;
1784 ZeroMem (&Cell[Index], sizeof (Cell[Index]));
1785 Status = EFI_SUCCESS;
1786 } else {
1787 //
1788 // Unicode 0xFFFD must exist in current hii database if this flag is not set.
1789 //
1790 Status = GetGlyphBuffer (
1791 Private,
1792 REPLACE_UNKNOWN_GLYPH,
1793 FontInfo,
1794 &GlyphBuf[Index],
1795 &Cell[Index],
1796 &Attributes[Index]
1797 );
1798 if (EFI_ERROR (Status)) {
1799 Status = EFI_INVALID_PARAMETER;
1800 }
1801 }
1802 }
1803
1804 if (EFI_ERROR (Status)) {
1805 goto Exit;
1806 }
1807
1808 *StringTmp++ = *StringPtr++;
1809 Index++;
1810 }
1811 *StringTmp = 0;
1812 StringPtr = StringIn2;
1813
1814 //
1815 // Draw the string according to the specified EFI_HII_OUT_FLAGS and Blt.
1816 // If Blt is not NULL, then EFI_HII_OUT_FLAG_CLIP is implied, render this string
1817 // to an existing image (bitmap or screen depending on flags) pointed by "*Blt".
1818 // Otherwise render this string to a new allocated image and output it.
1819 //
1820 Image = *Blt;
1821 BufferPtr = Image->Image.Bitmap + Image->Width * BltY + BltX;
1822 ASSERT (Image->Height >= BltY);
1823 MaxRowNum = (UINT16) ((Image->Height - BltY) / Height);
1824 if ((Image->Height - BltY) % Height != 0) {
1825 LastLineHeight = (Image->Height - BltY) % Height;
1826 MaxRowNum++;
1827 }
1828
1829 RowInfo = (EFI_HII_ROW_INFO *) AllocateZeroPool (MaxRowNum * sizeof (EFI_HII_ROW_INFO));
1830 if (RowInfo == NULL) {
1831 Status = EFI_OUT_OF_RESOURCES;
1832 goto Exit;
1833 }
1834
1835 //
1836 // Format the glyph buffer according to flags.
1837 //
1838 Transparent = (BOOLEAN) ((Flags & EFI_HII_OUT_FLAG_TRANSPARENT) == EFI_HII_OUT_FLAG_TRANSPARENT ? TRUE : FALSE);
1839
1840 for (RowIndex = 0, Index = 0; RowIndex < MaxRowNum && StringPtr[Index] != 0; ) {
1841 LineWidth = 0;
1842 LineBreak = FALSE;
1843
1844 //
1845 // Clip the final row if the row's bottom-most on pixel cannot fit when
1846 // EFI_HII_OUT_FLAG_CLEAN_Y is set.
1847 //
1848 if (RowIndex == MaxRowNum - 1) {
1849 if ((Flags & EFI_HII_OUT_FLAG_CLIP_CLEAN_Y) == EFI_HII_OUT_FLAG_CLIP_CLEAN_Y && LastLineHeight < LineHeight ) {
1850 //
1851 // Don't draw at all if the row's bottom-most on pixel cannot fit.
1852 //
1853 break;
1854 }
1855 LineHeight = LastLineHeight;
1856 }
1857
1858 //
1859 // Calculate how many characters there are in a row.
1860 //
1861 RowInfo[RowIndex].StartIndex = Index;
1862
1863 while (LineWidth + BltX < Image->Width && StringPtr[Index] != 0) {
1864 if ((Flags & EFI_HII_IGNORE_LINE_BREAK) == 0 &&
1865 IsLineBreak (StringPtr[Index]) == 0) {
1866 //
1867 // It forces a line break that ends this row.
1868 //
1869 Index++;
1870 LineBreak = TRUE;
1871 break;
1872 }
1873
1874 //
1875 // If the glyph of the character is existing, then accumulate the actual printed width
1876 //
1877 LineWidth += (UINTN) Cell[Index].AdvanceX;
1878
1879 Index++;
1880 }
1881
1882 //
1883 // Record index of next char.
1884 //
1885 NextIndex = Index;
1886 //
1887 // Return to the previous char.
1888 //
1889 Index--;
1890 if (LineBreak && Index > 0 ) {
1891 //
1892 // Return the previous non line break char.
1893 //
1894 Index --;
1895 }
1896
1897 //
1898 // If this character is the last character of a row, we need not
1899 // draw its (AdvanceX - Width - OffsetX) for next character.
1900 //
1901 LineWidth -= (UINTN) (Cell[Index].AdvanceX - Cell[Index].Width - Cell[Index].OffsetX);
1902
1903 //
1904 // Clip the right-most character if cannot fit when EFI_HII_OUT_FLAG_CLEAN_X is set.
1905 //
1906 if (LineWidth + BltX <= Image->Width ||
1907 (LineWidth + BltX > Image->Width && (Flags & EFI_HII_OUT_FLAG_CLIP_CLEAN_X) == 0)) {
1908 //
1909 // Record right-most character in RowInfo even if it is partially displayed.
1910 //
1911 RowInfo[RowIndex].EndIndex = Index;
1912 RowInfo[RowIndex].LineWidth = LineWidth;
1913 RowInfo[RowIndex].LineHeight = LineHeight;
1914 RowInfo[RowIndex].BaselineOffset = BaseLineOffset;
1915 } else {
1916 //
1917 // When EFI_HII_OUT_FLAG_CLEAN_X is set, it will not draw a character
1918 // if its right-most on pixel cannot fit.
1919 //
1920 if (Index > 0) {
1921 //
1922 // Don't draw the last char on this row. And, don't draw the second last char (AdvanceX - Width - OffsetX).
1923 //
1924 LineWidth -= (UINTN) (Cell[Index].Width + Cell[Index].OffsetX);
1925 LineWidth -= (UINTN) (Cell[Index - 1].AdvanceX - Cell[Index - 1].Width - Cell[Index - 1].OffsetX);
1926 RowInfo[RowIndex].EndIndex = Index - 1;
1927 RowInfo[RowIndex].LineWidth = LineWidth;
1928 RowInfo[RowIndex].LineHeight = LineHeight;
1929 RowInfo[RowIndex].BaselineOffset = BaseLineOffset;
1930 } else {
1931 //
1932 // There is only one column and it can not be drawn so that return directly.
1933 //
1934 Status = EFI_SUCCESS;
1935 goto Exit;
1936 }
1937 }
1938
1939 //
1940 // EFI_HII_OUT_FLAG_WRAP will wrap the text at the right-most line-break
1941 // opportunity prior to a character whose right-most extent would exceed Width.
1942 // Search the right-most line-break opportunity here.
1943 //
1944 if ((Flags & EFI_HII_OUT_FLAG_WRAP) == EFI_HII_OUT_FLAG_WRAP && StringPtr[NextIndex] != 0 && !LineBreak) {
1945 if ((Flags & EFI_HII_IGNORE_LINE_BREAK) == 0) {
1946 LineWidth = RowInfo[RowIndex].LineWidth;
1947 for (Index1 = RowInfo[RowIndex].EndIndex; Index1 >= RowInfo[RowIndex].StartIndex; Index1--) {
1948 if (Index1 == RowInfo[RowIndex].EndIndex) {
1949 LineWidth -= (Cell[Index1].Width + Cell[Index1].OffsetX);
1950 } else {
1951 LineWidth -= Cell[Index1].AdvanceX;
1952 }
1953 if (IsLineBreak (StringPtr[Index1]) > 0) {
1954 LineBreak = TRUE;
1955 if (Index1 > RowInfo[RowIndex].StartIndex) {
1956 RowInfo[RowIndex].EndIndex = Index1 - 1;
1957 }
1958 //
1959 // relocate to the character after the right-most line break opportunity of this line
1960 //
1961 NextIndex = Index1 + 1;
1962 break;
1963 }
1964 //
1965 // If don't find a line break opportunity from EndIndex to StartIndex,
1966 // then jump out.
1967 //
1968 if (Index1 == RowInfo[RowIndex].StartIndex)
1969 break;
1970 }
1971
1972 //
1973 // Update LineWidth to the real width
1974 //
1975 if (IsLineBreak (StringPtr[Index1]) > 0) {
1976 if (Index1 == RowInfo[RowIndex].StartIndex) {
1977 LineWidth = 0;
1978 } else {
1979 LineWidth -= (UINTN) (Cell[Index1 - 1].AdvanceX - Cell[Index1 - 1].Width - Cell[Index1 - 1].OffsetX);
1980 }
1981 RowInfo[RowIndex].LineWidth = LineWidth;
1982 }
1983 }
1984 //
1985 // If no line-break opportunity can be found, then the text will
1986 // behave as if EFI_HII_OUT_FLAG_CLEAN_X is set.
1987 //
1988 if (!LineBreak) {
1989 Flags &= (~ (EFI_HII_OUT_FLAGS) EFI_HII_OUT_FLAG_WRAP);
1990 Flags |= EFI_HII_OUT_FLAG_CLIP_CLEAN_X;
1991 }
1992 }
1993
1994 //
1995 // LineWidth can't exceed Image width.
1996 //
1997 if (RowInfo[RowIndex].LineWidth + BltX > Image->Width) {
1998 RowInfo[RowIndex].LineWidth = Image->Width - BltX;
1999 }
2000
2001 //
2002 // Draw it to screen or existing bitmap depending on whether
2003 // EFI_HII_DIRECT_TO_SCREEN is set.
2004 //
2005 LineOffset = 0;
2006 if ((Flags & EFI_HII_DIRECT_TO_SCREEN) == EFI_HII_DIRECT_TO_SCREEN) {
2007 BltBuffer = NULL;
2008 if (RowInfo[RowIndex].LineWidth != 0) {
2009 BltBuffer = AllocateZeroPool (RowInfo[RowIndex].LineWidth * RowInfo[RowIndex].LineHeight * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
2010 if (BltBuffer == NULL) {
2011 Status = EFI_OUT_OF_RESOURCES;
2012 goto Exit;
2013 }
2014 //
2015 // Set BufferPtr to Origin by adding baseline to the starting position.
2016 //
2017 BufferPtr = BltBuffer + BaseLine * RowInfo[RowIndex].LineWidth;
2018 }
2019 for (Index1 = RowInfo[RowIndex].StartIndex; Index1 <= RowInfo[RowIndex].EndIndex; Index1++) {
2020 if (RowInfo[RowIndex].LineWidth > 0 && RowInfo[RowIndex].LineWidth > LineOffset) {
2021 //
2022 // Only BLT these character which have corrsponding glyph in font basebase.
2023 //
2024 GlyphToImage (
2025 GlyphBuf[Index1],
2026 Foreground,
2027 Background,
2028 (UINT16) RowInfo[RowIndex].LineWidth,
2029 BaseLine,
2030 RowInfo[RowIndex].LineWidth - LineOffset,
2031 RowInfo[RowIndex].LineHeight,
2032 Transparent,
2033 &Cell[Index1],
2034 Attributes[Index1],
2035 &BufferPtr
2036 );
2037 }
2038 if (ColumnInfoArray != NULL) {
2039 if ((GlyphBuf[Index1] == NULL && Cell[Index1].AdvanceX == 0)
2040 || RowInfo[RowIndex].LineWidth == 0) {
2041 *ColumnInfoArray = (UINTN) ~0;
2042 } else {
2043 *ColumnInfoArray = LineOffset + Cell[Index1].OffsetX + BltX;
2044 }
2045 ColumnInfoArray++;
2046 }
2047 LineOffset += Cell[Index1].AdvanceX;
2048 }
2049
2050 if (BltBuffer != NULL) {
2051 Status = Image->Image.Screen->Blt (
2052 Image->Image.Screen,
2053 BltBuffer,
2054 EfiBltBufferToVideo,
2055 0,
2056 0,
2057 BltX,
2058 BltY,
2059 RowInfo[RowIndex].LineWidth,
2060 RowInfo[RowIndex].LineHeight,
2061 0
2062 );
2063 if (EFI_ERROR (Status)) {
2064 FreePool (BltBuffer);
2065 goto Exit;
2066 }
2067
2068 FreePool (BltBuffer);
2069 }
2070 } else {
2071 //
2072 // Save the starting position for calculate the starting postition of next row.
2073 //
2074 RowBufferPtr = BufferPtr;
2075 //
2076 // Set BufferPtr to Origin by adding baseline to the starting position.
2077 //
2078 BufferPtr = BufferPtr + BaseLine * Image->Width;
2079 for (Index1 = RowInfo[RowIndex].StartIndex; Index1 <= RowInfo[RowIndex].EndIndex; Index1++) {
2080 if (RowInfo[RowIndex].LineWidth > 0 && RowInfo[RowIndex].LineWidth > LineOffset) {
2081 //
2082 // Only BLT these character which have corrsponding glyph in font basebase.
2083 //
2084 GlyphToImage (
2085 GlyphBuf[Index1],
2086 Foreground,
2087 Background,
2088 Image->Width,
2089 BaseLine,
2090 RowInfo[RowIndex].LineWidth - LineOffset,
2091 RowInfo[RowIndex].LineHeight,
2092 Transparent,
2093 &Cell[Index1],
2094 Attributes[Index1],
2095 &BufferPtr
2096 );
2097 }
2098 if (ColumnInfoArray != NULL) {
2099 if ((GlyphBuf[Index1] == NULL && Cell[Index1].AdvanceX == 0)
2100 || RowInfo[RowIndex].LineWidth == 0) {
2101 *ColumnInfoArray = (UINTN) ~0;
2102 } else {
2103 *ColumnInfoArray = LineOffset + Cell[Index1].OffsetX + BltX;
2104 }
2105 ColumnInfoArray++;
2106 }
2107 LineOffset += Cell[Index1].AdvanceX;
2108 }
2109
2110 //
2111 // Jump to starting position of next row.
2112 //
2113 if (RowIndex == 0) {
2114 BufferPtr = RowBufferPtr - BltX + LineHeight * Image->Width;
2115 } else {
2116 BufferPtr = RowBufferPtr + LineHeight * Image->Width;
2117 }
2118 }
2119
2120 //
2121 // Recalculate the start point of X/Y axis to draw multi-lines with the order of top-to-down
2122 //
2123 BltX = 0;
2124 BltY += RowInfo[RowIndex].LineHeight;
2125
2126 RowIndex++;
2127 Index = NextIndex;
2128
2129 if (!LineBreak) {
2130 //
2131 // If there is not a mandatory line break or line break opportunity, only render one line to image
2132 //
2133 break;
2134 }
2135 }
2136
2137 //
2138 // Write output parameters.
2139 //
2140 RowInfoSize = RowIndex * sizeof (EFI_HII_ROW_INFO);
2141 if (RowInfoArray != NULL) {
2142 if (RowInfoSize > 0) {
2143 *RowInfoArray = AllocateZeroPool (RowInfoSize);
2144 if (*RowInfoArray == NULL) {
2145 Status = EFI_OUT_OF_RESOURCES;
2146 goto Exit;
2147 }
2148 CopyMem (*RowInfoArray, RowInfo, RowInfoSize);
2149 } else {
2150 *RowInfoArray = NULL;
2151 }
2152 }
2153 if (RowInfoArraySize != NULL) {
2154 *RowInfoArraySize = RowIndex;
2155 }
2156
2157 Status = EFI_SUCCESS;
2158
2159 Exit:
2160
2161 for (Index = 0; Index < StrLength; Index++) {
2162 if (GlyphBuf[Index] != NULL) {
2163 FreePool (GlyphBuf[Index]);
2164 }
2165 }
2166 if (StringIn != NULL) {
2167 FreePool (StringIn);
2168 }
2169 if (StringIn2 != NULL) {
2170 FreePool (StringIn2);
2171 }
2172 if (StringInfoOut != NULL) {
2173 FreePool (StringInfoOut);
2174 }
2175 if (RowInfo != NULL) {
2176 FreePool (RowInfo);
2177 }
2178 if (SystemDefault != NULL) {
2179 FreePool (SystemDefault);
2180 }
2181 if (GlyphBuf != NULL) {
2182 FreePool (GlyphBuf);
2183 }
2184 if (Cell != NULL) {
2185 FreePool (Cell);
2186 }
2187 if (Attributes != NULL) {
2188 FreePool (Attributes);
2189 }
2190
2191 return Status;
2192 }
2193
2194
2195 /**
2196 Render a string to a bitmap or the screen containing the contents of the specified string.
2197
2198 @param This A pointer to the EFI_HII_FONT_PROTOCOL instance.
2199 @param Flags Describes how the string is to be drawn.
2200 @param PackageList The package list in the HII database to search
2201 for the specified string.
2202 @param StringId The string's id, which is unique within
2203 PackageList.
2204 @param Language Points to the language for the retrieved string.
2205 If NULL, then the current system language is
2206 used.
2207 @param StringInfo Points to the string output information,
2208 including the color and font. If NULL, then the
2209 string will be output in the default system font
2210 and color.
2211 @param Blt If this points to a non-NULL on entry, this
2212 points to the image, which is Width pixels wide
2213 and Height pixels high. The string will be drawn
2214 onto this image and
2215 EFI_HII_OUT_FLAG_CLIP is implied. If this points
2216 to a NULL on entry, then a buffer
2217 will be allocated to hold the generated image and
2218 the pointer updated on exit. It is the caller's
2219 responsibility to free this buffer.
2220 @param BltX Specifies the offset from the left and top edge
2221 of the image of the first character cell in the
2222 image.
2223 @param BltY Specifies the offset from the left and top edge
2224 of the image of the first character cell in the
2225 image.
2226 @param RowInfoArray If this is non-NULL on entry, then on exit, this
2227 will point to an allocated buffer containing
2228 row information and RowInfoArraySize will be
2229 updated to contain the number of elements.
2230 This array describes the characters which were at
2231 least partially drawn and the heights of the
2232 rows. It is the caller's responsibility to free
2233 this buffer.
2234 @param RowInfoArraySize If this is non-NULL on entry, then on exit it
2235 contains the number of elements in RowInfoArray.
2236 @param ColumnInfoArray If this is non-NULL, then on return it will be
2237 filled with the horizontal offset for each
2238 character in the string on the row where it is
2239 displayed. Non-printing characters will have
2240 the offset ~0. The caller is responsible to
2241 allocate a buffer large enough so that there
2242 is one entry for each character in the string,
2243 not including the null-terminator. It is possible
2244 when character display is normalized that some
2245 character cells overlap.
2246
2247 @retval EFI_SUCCESS The string was successfully rendered.
2248 @retval EFI_OUT_OF_RESOURCES Unable to allocate an output buffer for
2249 RowInfoArray or Blt.
2250 @retval EFI_INVALID_PARAMETER The Blt or PackageList was NULL.
2251 @retval EFI_INVALID_PARAMETER Flags were invalid combination.
2252 @retval EFI_NOT_FOUND The specified PackageList is not in the Database or the stringid is not
2253 in the specified PackageList.
2254
2255 **/
2256 EFI_STATUS
2257 EFIAPI
2258 HiiStringIdToImage (
2259 IN CONST EFI_HII_FONT_PROTOCOL *This,
2260 IN EFI_HII_OUT_FLAGS Flags,
2261 IN EFI_HII_HANDLE PackageList,
2262 IN EFI_STRING_ID StringId,
2263 IN CONST CHAR8* Language,
2264 IN CONST EFI_FONT_DISPLAY_INFO *StringInfo OPTIONAL,
2265 IN OUT EFI_IMAGE_OUTPUT **Blt,
2266 IN UINTN BltX,
2267 IN UINTN BltY,
2268 OUT EFI_HII_ROW_INFO **RowInfoArray OPTIONAL,
2269 OUT UINTN *RowInfoArraySize OPTIONAL,
2270 OUT UINTN *ColumnInfoArray OPTIONAL
2271 )
2272 {
2273 EFI_STATUS Status;
2274 HII_DATABASE_PRIVATE_DATA *Private;
2275 EFI_HII_STRING_PROTOCOL *HiiString;
2276 EFI_STRING String;
2277 UINTN StringSize;
2278 UINTN FontLen;
2279 EFI_FONT_INFO *StringFontInfo;
2280 EFI_FONT_DISPLAY_INFO *NewStringInfo;
2281 CHAR8 TempSupportedLanguages;
2282 CHAR8 *SupportedLanguages;
2283 UINTN SupportedLanguagesSize;
2284 CHAR8 *CurrentLanguage;
2285 CHAR8 *BestLanguage;
2286
2287 if (This == NULL || PackageList == NULL || Blt == NULL || PackageList == NULL) {
2288 return EFI_INVALID_PARAMETER;
2289 }
2290
2291 if (!IsHiiHandleValid (PackageList)) {
2292 return EFI_NOT_FOUND;
2293 }
2294
2295 //
2296 // Initialize string pointers to be NULL
2297 //
2298 SupportedLanguages = NULL;
2299 CurrentLanguage = NULL;
2300 BestLanguage = NULL;
2301 String = NULL;
2302 StringInfo = NULL;
2303 StringFontInfo = NULL;
2304 NewStringInfo = NULL;
2305
2306 //
2307 // Get the string to be displayed.
2308 //
2309 Private = HII_FONT_DATABASE_PRIVATE_DATA_FROM_THIS (This);
2310 HiiString = &Private->HiiString;
2311
2312 //
2313 // Get the size of supported language.
2314 //
2315 SupportedLanguagesSize = 0;
2316 Status = HiiString->GetLanguages (
2317 HiiString,
2318 PackageList,
2319 &TempSupportedLanguages,
2320 &SupportedLanguagesSize
2321 );
2322 if (Status != EFI_BUFFER_TOO_SMALL) {
2323 return Status;
2324 }
2325
2326 SupportedLanguages = AllocatePool (SupportedLanguagesSize);
2327 if (SupportedLanguages == NULL) {
2328 return EFI_OUT_OF_RESOURCES;
2329 }
2330
2331 Status = HiiString->GetLanguages (
2332 HiiString,
2333 PackageList,
2334 SupportedLanguages,
2335 &SupportedLanguagesSize
2336 );
2337 if (EFI_ERROR (Status)) {
2338 goto Exit;
2339 }
2340
2341 if (Language == NULL) {
2342 Language = "";
2343 }
2344 CurrentLanguage = GetEfiGlobalVariable (L"PlatformLang");
2345 BestLanguage = GetBestLanguage (
2346 SupportedLanguages,
2347 FALSE,
2348 Language,
2349 (CurrentLanguage == NULL) ? CurrentLanguage : "",
2350 (CHAR8 *) PcdGetPtr (PcdUefiVariableDefaultPlatformLang),
2351 NULL
2352 );
2353 if (BestLanguage == NULL) {
2354 Status = EFI_NOT_FOUND;
2355 goto Exit;
2356 }
2357
2358 StringSize = MAX_STRING_LENGTH;
2359 String = (EFI_STRING) AllocateZeroPool (StringSize);
2360 if (String == NULL) {
2361 Status = EFI_OUT_OF_RESOURCES;
2362 goto Exit;
2363 }
2364
2365 Status = HiiString->GetString (
2366 HiiString,
2367 BestLanguage,
2368 PackageList,
2369 StringId,
2370 String,
2371 &StringSize,
2372 &StringFontInfo
2373 );
2374 if (Status == EFI_BUFFER_TOO_SMALL) {
2375 FreePool (String);
2376 String = (EFI_STRING) AllocateZeroPool (StringSize);
2377 if (String == NULL) {
2378 Status = EFI_OUT_OF_RESOURCES;
2379 goto Exit;
2380 }
2381 Status = HiiString->GetString (
2382 HiiString,
2383 BestLanguage,
2384 PackageList,
2385 StringId,
2386 String,
2387 &StringSize,
2388 NULL
2389 );
2390 }
2391
2392 if (EFI_ERROR (Status)) {
2393 goto Exit;
2394 }
2395
2396 //
2397 // When StringInfo specifies that string will be output in the system default font and color,
2398 // use particular stringfontinfo described in string package instead if exists.
2399 // StringFontInfo equals NULL means system default font attaches with the string block.
2400 //
2401 if (StringFontInfo != NULL && IsSystemFontInfo (Private, (EFI_FONT_DISPLAY_INFO *) StringInfo, NULL, NULL)) {
2402 FontLen = sizeof (EFI_FONT_DISPLAY_INFO) - sizeof (CHAR16) + StrSize (StringFontInfo->FontName);
2403 NewStringInfo = AllocateZeroPool (FontLen);
2404 if (NewStringInfo == NULL) {
2405 Status = EFI_OUT_OF_RESOURCES;
2406 goto Exit;
2407 }
2408 NewStringInfo->FontInfoMask = EFI_FONT_INFO_SYS_FORE_COLOR | EFI_FONT_INFO_SYS_BACK_COLOR;
2409 NewStringInfo->FontInfo.FontStyle = StringFontInfo->FontStyle;
2410 NewStringInfo->FontInfo.FontSize = StringFontInfo->FontSize;
2411 StrCpy (NewStringInfo->FontInfo.FontName, StringFontInfo->FontName);
2412
2413 Status = HiiStringToImage (
2414 This,
2415 Flags,
2416 String,
2417 NewStringInfo,
2418 Blt,
2419 BltX,
2420 BltY,
2421 RowInfoArray,
2422 RowInfoArraySize,
2423 ColumnInfoArray
2424 );
2425 goto Exit;
2426 }
2427
2428 Status = HiiStringToImage (
2429 This,
2430 Flags,
2431 String,
2432 StringInfo,
2433 Blt,
2434 BltX,
2435 BltY,
2436 RowInfoArray,
2437 RowInfoArraySize,
2438 ColumnInfoArray
2439 );
2440
2441 Exit:
2442 if (SupportedLanguages != NULL) {
2443 FreePool (SupportedLanguages);
2444 }
2445 if (CurrentLanguage != NULL) {
2446 FreePool (CurrentLanguage);
2447 }
2448 if (BestLanguage != NULL) {
2449 FreePool (BestLanguage);
2450 }
2451 if (String != NULL) {
2452 FreePool (String);
2453 }
2454 if (StringFontInfo != NULL) {
2455 FreePool (StringFontInfo);
2456 }
2457 if (NewStringInfo != NULL) {
2458 FreePool (NewStringInfo);
2459 }
2460
2461 return Status;
2462 }
2463
2464
2465 /**
2466 Convert the glyph for a single character into a bitmap.
2467
2468 @param This A pointer to the EFI_HII_FONT_PROTOCOL instance.
2469 @param Char Character to retrieve.
2470 @param StringInfo Points to the string font and color information
2471 or NULL if the string should use the default
2472 system font and color.
2473 @param Blt Thus must point to a NULL on entry. A buffer will
2474 be allocated to hold the output and the pointer
2475 updated on exit. It is the caller's
2476 responsibility to free this buffer.
2477 @param Baseline Number of pixels from the bottom of the bitmap to
2478 the baseline.
2479
2480 @retval EFI_SUCCESS Glyph bitmap created.
2481 @retval EFI_OUT_OF_RESOURCES Unable to allocate the output buffer Blt.
2482 @retval EFI_WARN_UNKNOWN_GLYPH The glyph was unknown and was replaced with the
2483 glyph for Unicode character 0xFFFD.
2484 @retval EFI_INVALID_PARAMETER Blt is NULL or *Blt is not NULL.
2485
2486 **/
2487 EFI_STATUS
2488 EFIAPI
2489 HiiGetGlyph (
2490 IN CONST EFI_HII_FONT_PROTOCOL *This,
2491 IN CHAR16 Char,
2492 IN CONST EFI_FONT_DISPLAY_INFO *StringInfo,
2493 OUT EFI_IMAGE_OUTPUT **Blt,
2494 OUT UINTN *Baseline OPTIONAL
2495 )
2496 {
2497 EFI_STATUS Status;
2498 HII_DATABASE_PRIVATE_DATA *Private;
2499 EFI_IMAGE_OUTPUT *Image;
2500 UINT8 *GlyphBuffer;
2501 EFI_FONT_DISPLAY_INFO *SystemDefault;
2502 EFI_FONT_DISPLAY_INFO *StringInfoOut;
2503 BOOLEAN Default;
2504 EFI_FONT_HANDLE FontHandle;
2505 EFI_STRING String;
2506 EFI_HII_GLYPH_INFO Cell;
2507 EFI_FONT_INFO *FontInfo;
2508 UINT8 Attributes;
2509 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground;
2510 EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background;
2511 EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
2512 UINT16 BaseLine;
2513
2514 if (This == NULL || Blt == NULL || *Blt != NULL) {
2515 return EFI_INVALID_PARAMETER;
2516 }
2517
2518 Private = HII_FONT_DATABASE_PRIVATE_DATA_FROM_THIS (This);
2519
2520 Default = FALSE;
2521 Image = NULL;
2522 SystemDefault = NULL;
2523 FontHandle = NULL;
2524 String = NULL;
2525 GlyphBuffer = NULL;
2526 StringInfoOut = NULL;
2527 FontInfo = NULL;
2528
2529 ZeroMem (&Foreground, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
2530 ZeroMem (&Background, sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
2531
2532 Default = IsSystemFontInfo (Private, (EFI_FONT_DISPLAY_INFO *) StringInfo, &SystemDefault, NULL);
2533
2534 if (!Default) {
2535 //
2536 // Find out a EFI_FONT_DISPLAY_INFO which could display the character in
2537 // the specified color and font.
2538 //
2539 String = (EFI_STRING) AllocateZeroPool (sizeof (CHAR16) * 2);
2540 if (String == NULL) {
2541 Status = EFI_OUT_OF_RESOURCES;
2542 goto Exit;
2543 }
2544 *String = Char;
2545 *(String + 1) = 0;
2546
2547 Status = HiiGetFontInfo (This, &FontHandle, StringInfo, &StringInfoOut, String);
2548 if (EFI_ERROR (Status)) {
2549 goto Exit;
2550 }
2551 ASSERT (StringInfoOut != NULL);
2552 FontInfo = &StringInfoOut->FontInfo;
2553 Foreground = StringInfoOut->ForegroundColor;
2554 Background = StringInfoOut->BackgroundColor;
2555 } else {
2556 Foreground = SystemDefault->ForegroundColor;
2557 Background = SystemDefault->BackgroundColor;
2558 }
2559
2560 Status = GetGlyphBuffer (Private, Char, FontInfo, &GlyphBuffer, &Cell, &Attributes);
2561 if (EFI_ERROR (Status)) {
2562 goto Exit;
2563 }
2564
2565 Image = (EFI_IMAGE_OUTPUT *) AllocateZeroPool (sizeof (EFI_IMAGE_OUTPUT));
2566 if (Image == NULL) {
2567 Status = EFI_OUT_OF_RESOURCES;
2568 goto Exit;
2569 }
2570 Image->Width = Cell.Width;
2571 Image->Height = Cell.Height;
2572
2573 if (Image->Width * Image->Height > 0) {
2574 Image->Image.Bitmap = AllocateZeroPool (Image->Width * Image->Height * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
2575 if (Image->Image.Bitmap == NULL) {
2576 FreePool (Image);
2577 Status = EFI_OUT_OF_RESOURCES;
2578 goto Exit;
2579 }
2580
2581 //
2582 // Set BaseLine to the char height.
2583 //
2584 BaseLine = (UINT16) (Cell.Height + Cell.OffsetY);
2585 //
2586 // Set BltBuffer to the position of Origin.
2587 //
2588 BltBuffer = Image->Image.Bitmap + (Cell.Height + Cell.OffsetY) * Image->Width - Cell.OffsetX;
2589 GlyphToImage (
2590 GlyphBuffer,
2591 Foreground,
2592 Background,
2593 Image->Width,
2594 BaseLine,
2595 Cell.Width + Cell.OffsetX,
2596 BaseLine - Cell.OffsetY,
2597 FALSE,
2598 &Cell,
2599 Attributes,
2600 &BltBuffer
2601 );
2602 }
2603
2604 *Blt = Image;
2605 if (Baseline != NULL) {
2606 *Baseline = Cell.OffsetY;
2607 }
2608
2609 Status = EFI_SUCCESS;
2610
2611 Exit:
2612
2613 if (Status == EFI_NOT_FOUND) {
2614 //
2615 // Glyph is unknown and replaced with the glyph for unicode character 0xFFFD
2616 //
2617 if (Char != REPLACE_UNKNOWN_GLYPH) {
2618 Status = HiiGetGlyph (This, REPLACE_UNKNOWN_GLYPH, StringInfo, Blt, Baseline);
2619 if (!EFI_ERROR (Status)) {
2620 Status = EFI_WARN_UNKNOWN_GLYPH;
2621 }
2622 } else {
2623 Status = EFI_WARN_UNKNOWN_GLYPH;
2624 }
2625 }
2626
2627 if (SystemDefault != NULL) {
2628 FreePool (SystemDefault);
2629 }
2630 if (StringInfoOut != NULL) {
2631 FreePool (StringInfoOut);
2632 }
2633 if (String != NULL) {
2634 FreePool (String);
2635 }
2636 if (GlyphBuffer != NULL) {
2637 FreePool (GlyphBuffer);
2638 }
2639
2640 return Status;
2641 }
2642
2643
2644 /**
2645 This function iterates through fonts which match the specified font, using
2646 the specified criteria. If String is non-NULL, then all of the characters in
2647 the string must exist in order for a candidate font to be returned.
2648
2649 @param This A pointer to the EFI_HII_FONT_PROTOCOL instance.
2650 @param FontHandle On entry, points to the font handle returned by a
2651 previous call to GetFontInfo() or NULL to start
2652 with the first font. On return, points to the
2653 returned font handle or points to NULL if there
2654 are no more matching fonts.
2655 @param StringInfoIn Upon entry, points to the font to return
2656 information about.
2657 If NULL, then the information about the system default
2658 font will be returned.
2659 @param StringInfoOut Upon return, contains the matching font's
2660 information. If NULL, then no information is
2661 returned. It's caller's responsibility to free
2662 this buffer.
2663 @param String Points to the string which will be tested to
2664 determine if all characters are available. If
2665 NULL, then any font is acceptable.
2666
2667 @retval EFI_SUCCESS Matching font returned successfully.
2668 @retval EFI_NOT_FOUND No matching font was found.
2669 @retval EFI_INVALID_PARAMETER StringInfoIn->FontInfoMask is an invalid combination.
2670 @retval EFI_OUT_OF_RESOURCES There were insufficient resources to complete the
2671 request.
2672
2673 **/
2674 EFI_STATUS
2675 EFIAPI
2676 HiiGetFontInfo (
2677 IN CONST EFI_HII_FONT_PROTOCOL *This,
2678 IN OUT EFI_FONT_HANDLE *FontHandle,
2679 IN CONST EFI_FONT_DISPLAY_INFO *StringInfoIn, OPTIONAL
2680 OUT EFI_FONT_DISPLAY_INFO **StringInfoOut,
2681 IN CONST EFI_STRING String OPTIONAL
2682 )
2683 {
2684 HII_DATABASE_PRIVATE_DATA *Private;
2685 EFI_STATUS Status;
2686 EFI_FONT_DISPLAY_INFO *SystemDefault;
2687 EFI_FONT_DISPLAY_INFO InfoOut;
2688 UINTN StringInfoOutLen;
2689 EFI_FONT_INFO *FontInfo;
2690 HII_GLOBAL_FONT_INFO *GlobalFont;
2691 EFI_STRING StringIn;
2692 EFI_FONT_HANDLE LocalFontHandle;
2693
2694 if (This == NULL) {
2695 return EFI_INVALID_PARAMETER;
2696 }
2697
2698 FontInfo = NULL;
2699 SystemDefault = NULL;
2700 LocalFontHandle = NULL;
2701 if (FontHandle != NULL) {
2702 LocalFontHandle = *FontHandle;
2703 }
2704
2705 Private = HII_FONT_DATABASE_PRIVATE_DATA_FROM_THIS (This);
2706
2707 //
2708 // Already searched to the end of the whole list, return directly.
2709 //
2710 if (LocalFontHandle == &Private->FontInfoList) {
2711 LocalFontHandle = NULL;
2712 Status = EFI_NOT_FOUND;
2713 goto Exit;
2714 }
2715
2716 //
2717 // Get default system display info, if StringInfoIn points to
2718 // system display info, return it directly.
2719 //
2720 if (IsSystemFontInfo (Private, (EFI_FONT_DISPLAY_INFO *) StringInfoIn, &SystemDefault, &StringInfoOutLen)) {
2721 //
2722 // System font is the first node. When handle is not NULL, system font can not
2723 // be found any more.
2724 //
2725 if (LocalFontHandle == NULL) {
2726 if (StringInfoOut != NULL) {
2727 *StringInfoOut = AllocateCopyPool (StringInfoOutLen, SystemDefault);
2728 if (*StringInfoOut == NULL) {
2729 Status = EFI_OUT_OF_RESOURCES;
2730 LocalFontHandle = NULL;
2731 goto Exit;
2732 }
2733 }
2734
2735 LocalFontHandle = Private->FontInfoList.ForwardLink;
2736 Status = EFI_SUCCESS;
2737 goto Exit;
2738 } else {
2739 LocalFontHandle = NULL;
2740 Status = EFI_NOT_FOUND;
2741 goto Exit;
2742 }
2743 }
2744
2745 //
2746 // StringInfoIn must not be NULL if it is not system default font info.
2747 //
2748 ASSERT (StringInfoIn != NULL);
2749 //
2750 // Check the font information mask to make sure it is valid.
2751 //
2752 if (((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_SYS_FONT | EFI_FONT_INFO_ANY_FONT)) ==
2753 (EFI_FONT_INFO_SYS_FONT | EFI_FONT_INFO_ANY_FONT)) ||
2754 ((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_SYS_SIZE | EFI_FONT_INFO_ANY_SIZE)) ==
2755 (EFI_FONT_INFO_SYS_SIZE | EFI_FONT_INFO_ANY_SIZE)) ||
2756 ((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_SYS_STYLE | EFI_FONT_INFO_ANY_STYLE)) ==
2757 (EFI_FONT_INFO_SYS_STYLE | EFI_FONT_INFO_ANY_STYLE)) ||
2758 ((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_RESIZE | EFI_FONT_INFO_ANY_SIZE)) ==
2759 (EFI_FONT_INFO_RESIZE | EFI_FONT_INFO_ANY_SIZE)) ||
2760 ((StringInfoIn->FontInfoMask & (EFI_FONT_INFO_RESTYLE | EFI_FONT_INFO_ANY_STYLE)) ==
2761 (EFI_FONT_INFO_RESTYLE | EFI_FONT_INFO_ANY_STYLE))) {
2762 return EFI_INVALID_PARAMETER;
2763 }
2764
2765 //
2766 // Parse the font information mask to find a matching font.
2767 //
2768
2769 CopyMem (&InfoOut, (EFI_FONT_DISPLAY_INFO *) StringInfoIn, sizeof (EFI_FONT_DISPLAY_INFO));
2770
2771 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_FONT) == EFI_FONT_INFO_SYS_FONT) {
2772 Status = SaveFontName (SystemDefault->FontInfo.FontName, &FontInfo);
2773 } else {
2774 Status = SaveFontName (((EFI_FONT_DISPLAY_INFO *) StringInfoIn)->FontInfo.FontName, &FontInfo);
2775 }
2776 if (EFI_ERROR (Status)) {
2777 goto Exit;
2778 }
2779
2780 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_SIZE) == EFI_FONT_INFO_SYS_SIZE) {
2781 InfoOut.FontInfo.FontSize = SystemDefault->FontInfo.FontSize;
2782 }
2783 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_STYLE) == EFI_FONT_INFO_SYS_STYLE) {
2784 InfoOut.FontInfo.FontStyle = SystemDefault->FontInfo.FontStyle;
2785 }
2786 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_FORE_COLOR) == EFI_FONT_INFO_SYS_FORE_COLOR) {
2787 InfoOut.ForegroundColor = SystemDefault->ForegroundColor;
2788 }
2789 if ((StringInfoIn->FontInfoMask & EFI_FONT_INFO_SYS_BACK_COLOR) == EFI_FONT_INFO_SYS_BACK_COLOR) {
2790 InfoOut.BackgroundColor = SystemDefault->BackgroundColor;
2791 }
2792
2793 ASSERT (FontInfo != NULL);
2794 FontInfo->FontSize = InfoOut.FontInfo.FontSize;
2795 FontInfo->FontStyle = InfoOut.FontInfo.FontStyle;
2796
2797 if (IsFontInfoExisted (Private, FontInfo, &InfoOut.FontInfoMask, LocalFontHandle, &GlobalFont)) {
2798 //
2799 // Test to guarantee all characters are available in the found font.
2800 //
2801 if (String != NULL) {
2802 StringIn = String;
2803 while (*StringIn != 0) {
2804 Status = FindGlyphBlock (GlobalFont->FontPackage, *StringIn, NULL, NULL, NULL);
2805 if (EFI_ERROR (Status)) {
2806 LocalFontHandle = NULL;
2807 goto Exit;
2808 }
2809 StringIn++;
2810 }
2811 }
2812 //
2813 // Write to output parameter
2814 //
2815 if (StringInfoOut != NULL) {
2816 StringInfoOutLen = sizeof (EFI_FONT_DISPLAY_INFO) - sizeof (EFI_FONT_INFO) + GlobalFont->FontInfoSize;
2817 *StringInfoOut = (EFI_FONT_DISPLAY_INFO *) AllocateZeroPool (StringInfoOutLen);
2818 if (*StringInfoOut == NULL) {
2819 Status = EFI_OUT_OF_RESOURCES;
2820 LocalFontHandle = NULL;
2821 goto Exit;
2822 }
2823
2824 CopyMem (*StringInfoOut, &InfoOut, sizeof (EFI_FONT_DISPLAY_INFO));
2825 CopyMem (&(*StringInfoOut)->FontInfo, GlobalFont->FontInfo, GlobalFont->FontInfoSize);
2826 }
2827
2828 LocalFontHandle = GlobalFont->Entry.ForwardLink;
2829 Status = EFI_SUCCESS;
2830 goto Exit;
2831 }
2832
2833 Status = EFI_NOT_FOUND;
2834
2835 Exit:
2836
2837 if (FontHandle != NULL) {
2838 *FontHandle = LocalFontHandle;
2839 }
2840
2841 if (SystemDefault != NULL) {
2842 FreePool (SystemDefault);
2843 }
2844 if (FontInfo != NULL) {
2845 FreePool (FontInfo);
2846 }
2847 return Status;
2848 }
2849
2850
EFI Development Kit II mirror for PVE