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