Pass GCC build.

[mirror_edk2.git] / MdeModulePkg / Universal / HiiDatabaseDxe / Font.c

/** @file\r
\r
Copyright (c) 2007, Intel Corporation\r
All rights reserved. This program and the accompanying materials\r
are licensed and made available under the terms and conditions of the BSD License\r
which accompanies this distribution.  The full text of the license may be found at\r
http://opensource.org/licenses/bsd-license.php\r
\r
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
Module Name:\r
\r
    Font.c\r
\r
Abstract:\r
\r
    Implementation for EFI_HII_FONT_PROTOCOL.\r
\r
Revision History\r
\r
\r
**/\r
\r
\r
#include "HiiDatabase.h"\r
\r
static EFI_GRAPHICS_OUTPUT_BLT_PIXEL        mEfiColors[16] = {\r
  //\r
  // B     G     R\r
  //\r
  0x00, 0x00, 0x00, 0x00,  // BLACK\r
  0x98, 0x00, 0x00, 0x00,  // BLUE\r
  0x00, 0x98, 0x00, 0x00,  // GREEN\r
  0x98, 0x98, 0x00, 0x00,  // CYAN\r
  0x00, 0x00, 0x98, 0x00,  // RED\r
  0x98, 0x00, 0x98, 0x00,  // MAGENTA\r
  0x00, 0x98, 0x98, 0x00,  // BROWN\r
  0x98, 0x98, 0x98, 0x00,  // LIGHTGRAY\r
  0x30, 0x30, 0x30, 0x00,  // DARKGRAY - BRIGHT BLACK\r
  0xff, 0x00, 0x00, 0x00,  // LIGHTBLUE\r
  0x00, 0xff, 0x00, 0x00,  // LIGHTGREEN\r
  0xff, 0xff, 0x00, 0x00,  // LIGHTCYAN\r
  0x00, 0x00, 0xff, 0x00,  // LIGHTRED\r
  0xff, 0x00, 0xff, 0x00,  // LIGHTMAGENTA\r
  0x00, 0xff, 0xff, 0x00,  // YELLOW\r
  0xff, 0xff, 0xff, 0x00,  // WHITE\r
};\r
\r
\r
/**\r
  Insert a character cell information to the list specified by GlyphInfoList.\r
\r
  @param  CharValue               Unicode character value, which identifies a glyph\r
                                  block.\r
  @param  GlyphInfoList           HII_GLYPH_INFO list head.\r
  @param  Cell                    Incoming character cell information.\r
\r
  @retval EFI_SUCCESS             Cell information is added to the GlyphInfoList.\r
  @retval EFI_OUT_OF_RESOURCES    The system is out of resources to accomplish the\r
                                  task.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
NewCell (\r
  IN  CHAR16                         CharValue,\r
  IN  LIST_ENTRY                     *GlyphInfoList,\r
  IN  EFI_HII_GLYPH_INFO             *Cell\r
  )\r
{\r
  HII_GLYPH_INFO           *GlyphInfo;\r
\r
  ASSERT (Cell != NULL && GlyphInfoList != NULL);\r
\r
  GlyphInfo = (HII_GLYPH_INFO *) AllocateZeroPool (sizeof (HII_GLYPH_INFO));\r
  if (GlyphInfo == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  //\r
  // GlyphInfoList stores a list of default character cell information, each is\r
  // identified by "CharId".\r
  //\r
  GlyphInfo->Signature = HII_GLYPH_INFO_SIGNATURE;\r
  GlyphInfo->CharId    = CharValue;\r
  CopyMem (&GlyphInfo->Cell, Cell, sizeof (EFI_HII_GLYPH_INFO));\r
  InsertTailList (GlyphInfoList, &GlyphInfo->Entry);\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Get a character cell information from the list specified by GlyphInfoList.\r
\r
  @param  CharValue               Unicode character value, which identifies a glyph\r
                                  block.\r
  @param  GlyphInfoList           HII_GLYPH_INFO list head.\r
  @param  Cell                    Buffer which stores output character cell\r
                                  information.\r
\r
  @retval EFI_SUCCESS             Cell information is added to the GlyphInfoList.\r
  @retval EFI_NOT_FOUND           The character info specified by CharValue does\r
                                  not exist.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
GetCell (\r
  IN  CHAR16                         CharValue,\r
  IN  LIST_ENTRY                     *GlyphInfoList,\r
  OUT EFI_HII_GLYPH_INFO             *Cell\r
  )\r
{\r
  HII_GLYPH_INFO           *GlyphInfo;\r
  LIST_ENTRY               *Link;\r
\r
  ASSERT (Cell != NULL && GlyphInfoList != NULL);\r
\r
  //\r
  // Since the EFI_HII_GIBT_DEFAULTS block won't increment CharValueCurrent,\r
  // the value of "CharId" of a default character cell which is used for a\r
  // EFI_HII_GIBT_GLYPH_DEFAULT or EFI_HII_GIBT_GLYPHS_DEFAULT should be\r
  // less or equal to the value of "CharValueCurrent" of this default block.\r
  //\r
  // For instance, if the CharId of a GlyphInfoList is {1, 3, 7}, a default glyph\r
  // with CharValue equals "7" uses the GlyphInfo with CharId = 7;\r
  // a default glyph with CharValue equals "6" uses the GlyphInfo with CharId = 3.\r
  //\r
  for (Link = GlyphInfoList->BackLink; Link != GlyphInfoList; Link = Link->BackLink) {\r
    GlyphInfo = CR (Link, HII_GLYPH_INFO, Entry, HII_GLYPH_INFO_SIGNATURE);\r
    if (GlyphInfo->CharId <= CharValue) {\r
      CopyMem (Cell, &GlyphInfo->Cell, sizeof (EFI_HII_GLYPH_INFO));\r
      return EFI_SUCCESS;\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
/**\r
  Convert the glyph for a single character into a bitmap.\r
\r
  @param  Private                 HII database driver private data.\r
  @param  Char                    Character to retrieve.\r
  @param  StringInfo              Points to the string font and color information\r
                                  or NULL  if the string should use the default\r
                                  system font and color.\r
  @param  GlyphBuffer             Buffer to store the retrieved bitmap data.\r
  @param  Cell                    Points to EFI_HII_GLYPH_INFO structure.\r
  @param  Attributes              If not NULL, output the glyph attributes if any.\r
\r
  @retval EFI_SUCCESS             Glyph bitmap outputted.\r
  @retval EFI_OUT_OF_RESOURCES    Unable to allocate the output buffer GlyphBuffer.\r
  @retval EFI_NOT_FOUND           The glyph was unknown can not be found.\r
  @retval EFI_INVALID_PARAMETER   Any input parameter is invalid.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
GetGlyphBuffer (\r
  IN  HII_DATABASE_PRIVATE_DATA      *Private,\r
  IN  CHAR16                         Char,\r
  IN  EFI_FONT_INFO                  *StringInfo,\r
  OUT UINT8                          **GlyphBuffer,\r
  OUT EFI_HII_GLYPH_INFO             *Cell,\r
  OUT UINT8                          *Attributes OPTIONAL\r
  )\r
{\r
  HII_DATABASE_RECORD                *Node;\r
  LIST_ENTRY                         *Link;\r
  HII_SIMPLE_FONT_PACKAGE_INSTANCE   *SimpleFont;\r
  LIST_ENTRY                         *Link1;\r
  UINT16                             Index;\r
  EFI_NARROW_GLYPH                   Narrow;\r
  EFI_WIDE_GLYPH                     Wide;\r
  HII_GLOBAL_FONT_INFO               *GlobalFont;\r
  UINTN                              HeaderSize;\r
  EFI_NARROW_GLYPH                   *NarrowPtr;\r
  EFI_WIDE_GLYPH                     *WidePtr;\r
\r
  if (GlyphBuffer == NULL || Cell == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  if (Private == NULL || Private->Signature != HII_DATABASE_PRIVATE_DATA_SIGNATURE) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  ZeroMem (Cell, sizeof (EFI_HII_GLYPH_INFO));\r
\r
  //\r
  // If StringInfo is not NULL, it must point to an existing EFI_FONT_INFO rather\r
  // than system default font and color.\r
  // If NULL, try to find the character in simplified font packages since\r
  // default system font is the fixed font (narrow or wide glyph).\r
  //\r
  if (StringInfo != NULL) {\r
    if(!IsFontInfoExisted (Private, StringInfo, NULL, NULL, &GlobalFont)) {\r
      return EFI_INVALID_PARAMETER;\r
    }\r
    if (Attributes != NULL) {\r
      *Attributes = PROPORTIONAL_GLYPH;\r
    }\r
    return FindGlyphBlock (GlobalFont->FontPackage, Char, GlyphBuffer, Cell, NULL);\r
  } else {\r
    HeaderSize = sizeof (EFI_HII_SIMPLE_FONT_PACKAGE_HDR);\r
\r
    for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {\r
      Node = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);\r
      for (Link1 = Node->PackageList->SimpleFontPkgHdr.ForwardLink;\r
           Link1 != &Node->PackageList->SimpleFontPkgHdr;\r
           Link1 = Link1->ForwardLink\r
          ) {\r
        SimpleFont = CR (Link1, HII_SIMPLE_FONT_PACKAGE_INSTANCE, SimpleFontEntry, HII_S_FONT_PACKAGE_SIGNATURE);\r
        //\r
        // Search the narrow glyph array\r
        //\r
        NarrowPtr = (EFI_NARROW_GLYPH *) ((UINT8 *) (SimpleFont->SimpleFontPkgHdr) + HeaderSize);\r
        for (Index = 0; Index < SimpleFont->SimpleFontPkgHdr->NumberOfNarrowGlyphs; Index++) {\r
          CopyMem (&Narrow, NarrowPtr + Index,sizeof (EFI_NARROW_GLYPH));\r
          if (Narrow.UnicodeWeight == Char) {\r
            *GlyphBuffer = (UINT8 *) AllocateZeroPool (EFI_GLYPH_HEIGHT);\r
            if (*GlyphBuffer == NULL) {\r
              return EFI_OUT_OF_RESOURCES;\r
            }\r
            Cell->Width    = EFI_GLYPH_WIDTH;\r
            Cell->Height   = EFI_GLYPH_HEIGHT;\r
            Cell->OffsetY  = NARROW_BASELINE;\r
            Cell->AdvanceX = Cell->Width;\r
            CopyMem (*GlyphBuffer, Narrow.GlyphCol1, Cell->Height);\r
            if (Attributes != NULL) {\r
              *Attributes = (UINT8) (Narrow.Attributes | NARROW_GLYPH);\r
            }\r
            return EFI_SUCCESS;\r
          }\r
        }\r
        //\r
        // Search the wide glyph array\r
        //\r
        WidePtr = (EFI_WIDE_GLYPH *) (NarrowPtr + SimpleFont->SimpleFontPkgHdr->NumberOfNarrowGlyphs);\r
        for (Index = 0; Index < SimpleFont->SimpleFontPkgHdr->NumberOfWideGlyphs; Index++) {\r
          CopyMem (&Wide, WidePtr + Index, sizeof (EFI_WIDE_GLYPH));\r
          if (Wide.UnicodeWeight == Char) {\r
            *GlyphBuffer    = (UINT8 *) AllocateZeroPool (EFI_GLYPH_HEIGHT * 2);\r
            if (*GlyphBuffer == NULL) {\r
              return EFI_OUT_OF_RESOURCES;\r
            }\r
            Cell->Width    = EFI_GLYPH_WIDTH * 2;\r
            Cell->Height   = EFI_GLYPH_HEIGHT;\r
            Cell->OffsetY  = WIDE_BASELINE;\r
            Cell->AdvanceX = Cell->Width;\r
            CopyMem (*GlyphBuffer, Wide.GlyphCol1, EFI_GLYPH_HEIGHT);\r
            CopyMem (*GlyphBuffer + EFI_GLYPH_HEIGHT, Wide.GlyphCol2, EFI_GLYPH_HEIGHT);\r
            if (Attributes != NULL) {\r
              *Attributes = (UINT8) (Wide.Attributes | EFI_GLYPH_WIDE);\r
            }\r
            return EFI_SUCCESS;\r
          }\r
        }\r
      }\r
    }\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
STATIC\r
VOID\r
NarrowGlyphToBlt (\r
  IN     UINT8                         *GlyphBuffer,\r
  IN     EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground,\r
  IN     EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background,\r
  IN     UINTN                         ImageWidth,\r
  IN     UINTN                         ImageHeight,\r
  IN     BOOLEAN                       Transparent,\r
  IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL **Origin\r
  )\r
{\r
  UINT8                                X;\r
  UINT8                                Y;\r
  UINT8                                Height;\r
  UINT8                                Width;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL        *Buffer;\r
\r
  ASSERT (GlyphBuffer != NULL && Origin != NULL && *Origin != NULL);\r
\r
  Height = EFI_GLYPH_HEIGHT;\r
  Width  = EFI_GLYPH_WIDTH;\r
\r
  ASSERT (Width <= ImageWidth && Height <= ImageHeight);\r
\r
  Buffer = *Origin;\r
\r
  for (Y = 0; Y < Height; Y++) {\r
    for (X = 0; X < Width; X++) {\r
      if ((GlyphBuffer[Y] & (1 << X)) != 0) {\r
        Buffer[Y * ImageWidth + (Width - X - 1)] = Foreground;\r
      } else {\r
        if (!Transparent) {\r
          Buffer[Y * ImageWidth + (Width - X - 1)] = Background;\r
        }\r
      }\r
    }\r
  }\r
\r
  *Origin = Buffer + Width;\r
}\r
\r
\r
/**\r
  Convert bitmap data of the glyph to blt structure.\r
\r
  @param  GlyphBuffer             Buffer points to bitmap data of glyph.\r
  @param  Foreground              The color of the "on" pixels in the glyph in the\r
                                  bitmap.\r
  @param  Background              The color of the "off" pixels in the glyph in the\r
                                  bitmap.\r
  @param  Width                   Width of the character or character cell, in\r
                                  pixels.\r
  @param  Height                  Height of the character or character cell, in\r
                                  pixels.\r
  @param  Transparent             If TRUE, the Background color is ignored and all\r
                                  "off" pixels in the character's drawn wil use the\r
                                  pixel value from BltBuffer.\r
  @param  BltBuffer               Points to the blt buffer.\r
\r
\r
**/\r
STATIC\r
VOID\r
GlyphToBlt (\r
  IN     UINT8                         *GlyphBuffer,\r
  IN     EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground,\r
  IN     EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background,\r
  IN     UINTN                         ImageWidth,\r
  IN     UINTN                         ImageHeight,\r
  IN     BOOLEAN                       Transparent,\r
  IN     EFI_HII_GLYPH_INFO            Cell,\r
  IN     UINT8                         Attributes,\r
  IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL **Origin\r
  )\r
{\r
  UINT8                                X;\r
  UINT8                                Y;\r
  UINT8                                Data;\r
  UINT8                                Index;\r
  UINTN                                OffsetY;\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL        *BltBuffer;\r
\r
  ASSERT (GlyphBuffer != NULL && Origin != NULL && *Origin != NULL);\r
  ASSERT (Cell.Width <= ImageWidth && Cell.Height <= ImageHeight);\r
\r
  BltBuffer = *Origin;\r
\r
  //\r
  // Since non-spacing key will be printed OR'd with the previous glyph, don't\r
  // write 0.\r
  //\r
  if ((Attributes & EFI_GLYPH_NON_SPACING) == EFI_GLYPH_NON_SPACING) {\r
    Transparent = TRUE;\r
  }\r
\r
  //\r
  // The glyph's upper left hand corner pixel is the most significant bit of the\r
  // first bitmap byte.\r
  //\r
  for (Y = 0; Y < Cell.Height; Y++) {\r
    OffsetY = BITMAP_LEN_1_BIT (Cell.Width, Y);\r
\r
    //\r
    // All bits in these bytes are meaningful.\r
    //\r
    for (X = 0; X < Cell.Width / 8; X++) {\r
      Data  = *(GlyphBuffer + OffsetY + X);\r
      for (Index = 0; Index < 8; Index++) {\r
        if ((Data & (1 << Index)) != 0) {\r
          BltBuffer[Y * ImageWidth + X * 8 + (8 - Index - 1)] = Foreground;\r
        } else {\r
          if (!Transparent) {\r
            BltBuffer[Y * ImageWidth + X * 8 + (8 - Index - 1)] = Background;\r
          }\r
        }\r
      }\r
    }\r
\r
    if (Cell.Width % 8 != 0) {\r
      //\r
      // There are some padding bits in this byte. Ignore them.\r
      //\r
      Data  = *(GlyphBuffer + OffsetY + X);\r
      for (Index = 0; Index < Cell.Width % 8; Index++) {\r
        if ((Data & (1 << (8 - Index - 1))) != 0) {\r
          BltBuffer[Y * ImageWidth + X * 8 + Index] = Foreground;\r
        } else {\r
          if (!Transparent) {\r
            BltBuffer[Y * ImageWidth + X * 8 + Index] = Background;\r
          }\r
        }\r
      }\r
    } // end of if (Width % 8...)\r
\r
  } // end of for (Y=0...)\r
\r
  *Origin = BltBuffer + Cell.Width;\r
}\r
\r
\r
/**\r
  Convert bitmap data of the glyph to blt structure.\r
\r
  @param  GlyphBuffer             Buffer points to bitmap data of glyph.\r
  @param  Foreground              The color of the "on" pixels in the glyph in the\r
                                  bitmap.\r
  @param  Background              The color of the "off" pixels in the glyph in the\r
                                  bitmap.\r
  @param  Width                   Width of the character or character cell, in\r
                                  pixels.\r
  @param  Height                  Height of the character or character cell, in\r
                                  pixels.\r
  @param  Transparent             If TRUE, the Background color is ignored and all\r
                                  "off" pixels in the character's drawn wil use the\r
                                  pixel value from BltBuffer.\r
  @param  Cell                    Points to EFI_HII_GLYPH_INFO structure.\r
  @param  Attributes              The attribute of incoming glyph in GlyphBuffer.\r
  @param  Origin                  On input, points to the origin of the to be\r
                                  displayed character, on output, points to the\r
                                  next glyph's origin.\r
\r
  @return Points to the address of next origin node in BltBuffer.\r
\r
**/\r
STATIC\r
VOID\r
GlyphToImage (\r
  IN     UINT8                         *GlyphBuffer,\r
  IN     EFI_GRAPHICS_OUTPUT_BLT_PIXEL Foreground,\r
  IN     EFI_GRAPHICS_OUTPUT_BLT_PIXEL Background,\r
  IN     UINTN                         ImageWidth,\r
  IN     UINTN                         ImageHeight,\r
  IN     BOOLEAN                       Transparent,\r
  IN     EFI_HII_GLYPH_INFO            Cell,\r
  IN     UINT8                         Attributes,\r
  IN OUT EFI_GRAPHICS_OUTPUT_BLT_PIXEL **Origin\r
  )\r
{\r
  EFI_GRAPHICS_OUTPUT_BLT_PIXEL        *Buffer;\r
\r
  ASSERT (GlyphBuffer != NULL && Origin != NULL && *Origin != NULL);\r
  ASSERT (Cell.Width <= ImageWidth && Cell.Height <= ImageHeight);\r
\r
  Buffer = *Origin;\r
\r
  if ((Attributes & EFI_GLYPH_NON_SPACING) == EFI_GLYPH_NON_SPACING) {\r
    //\r
    // This character is a non-spacing key, print it OR'd with the previous glyph.\r
    // without advancing cursor.\r
    //\r
    Buffer -= Cell.Width;\r
    GlyphToBlt (\r
      GlyphBuffer,\r
      Foreground,\r
      Background,\r
      ImageWidth,\r
      ImageHeight,\r
      Transparent,\r
      Cell,\r
      Attributes,\r
      &Buffer\r
      );\r
\r
  } else if ((Attributes & EFI_GLYPH_WIDE) == EFI_GLYPH_WIDE) {\r
    //\r
    // This character is wide glyph, i.e. 16 pixels * 19 pixels.\r
    // Draw it as two narrow glyphs.\r
    //\r
    NarrowGlyphToBlt (\r
      GlyphBuffer,\r
      Foreground,\r
      Background,\r
      ImageWidth,\r
      ImageHeight,\r
      Transparent,\r
      Origin\r
      );\r
\r
    NarrowGlyphToBlt (\r
      GlyphBuffer + EFI_GLYPH_HEIGHT,\r
      Foreground,\r
      Background,\r
      ImageWidth,\r
      ImageHeight,\r
      Transparent,\r
      Origin\r
      );\r
\r
  } else if ((Attributes & NARROW_GLYPH) == NARROW_GLYPH) {\r
    //\r
    // This character is narrow glyph, i.e. 8 pixels * 19 pixels.\r
    //\r
    NarrowGlyphToBlt (\r
      GlyphBuffer,\r
      Foreground,\r
      Background,\r
      ImageWidth,\r
      ImageHeight,\r
      Transparent,\r
      Origin\r
      );\r
\r
  } else if ((Attributes & PROPORTIONAL_GLYPH) == PROPORTIONAL_GLYPH) {\r
    //\r
    // This character is proportional glyph, i.e. Cell.Width * Cell.Height pixels.\r
    //\r
    GlyphToBlt (\r
      GlyphBuffer,\r
      Foreground,\r
      Background,\r
      ImageWidth,\r
      ImageHeight,\r
      Transparent,\r
      Cell,\r
      Attributes,\r
      Origin\r
      );\r
  }\r
}\r
\r
\r
/**\r
  Write the output parameters of FindGlyphBlock().\r
\r
  @param  BufferIn                Buffer which stores the bitmap data of the found\r
                                  block.\r
  @param  BufferLen               Length of BufferIn.\r
  @param  InputCell               Buffer which stores cell information of the\r
                                  encoded bitmap.\r
  @param  GlyphBuffer             Output the corresponding bitmap data of the found\r
                                  block. It is the caller's responsiblity to free\r
                                  this buffer.\r
  @param  Cell                    Output cell information of the encoded bitmap.\r
  @param  GlyphBufferLen          If not NULL, output the length of GlyphBuffer.\r
\r
  @retval EFI_SUCCESS             The operation is performed successfully.\r
  @retval EFI_INVALID_PARAMETER   Any input parameter is invalid.\r
  @retval EFI_OUT_OF_RESOURCES    The system is out of resources to accomplish the\r
                                  task.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
WriteOutputParam (\r
  IN  UINT8                          *BufferIn,\r
  IN  UINTN                          BufferLen,\r
  IN  EFI_HII_GLYPH_INFO             *InputCell,\r
  OUT UINT8                          **GlyphBuffer, OPTIONAL\r
  OUT EFI_HII_GLYPH_INFO             *Cell, OPTIONAL\r
  OUT UINTN                          *GlyphBufferLen OPTIONAL\r
  )\r
{\r
  if (BufferIn == NULL || BufferLen < 1 || InputCell == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  if (Cell != NULL) {\r
    CopyMem (Cell, InputCell, sizeof (EFI_HII_GLYPH_INFO));\r
  }\r
\r
  if (GlyphBuffer != NULL) {\r
    *GlyphBuffer = (UINT8 *) AllocateZeroPool (BufferLen);\r
    if (*GlyphBuffer == NULL) {\r
      return EFI_OUT_OF_RESOURCES;\r
    }\r
    CopyMem (*GlyphBuffer, BufferIn, BufferLen);\r
  }\r
\r
  if (GlyphBufferLen != NULL) {\r
    *GlyphBufferLen = BufferLen;\r
  }\r
\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Parse all glyph blocks to find a glyph block specified by CharValue.\r
  If CharValue = (CHAR16) (-1), collect all default character cell information\r
  within this font package and backup its information.\r
\r
  @param  FontPackage             Hii string package instance.\r
  @param  CharValue               Unicode character value, which identifies a glyph\r
                                  block.\r
  @param  GlyphBuffer             Output the corresponding bitmap data of the found\r
                                  block. It is the caller's responsiblity to free\r
                                  this buffer.\r
  @param  Cell                    Output cell information of the encoded bitmap.\r
  @param  GlyphBufferLen          If not NULL, output the length of GlyphBuffer.\r
\r
  @retval EFI_SUCCESS             The bitmap data is retrieved successfully.\r
  @retval EFI_NOT_FOUND           The specified CharValue does not exist in current\r
                                  database.\r
  @retval EFI_OUT_OF_RESOURCES    The system is out of resources to accomplish the\r
                                  task.\r
\r
**/\r
EFI_STATUS\r
FindGlyphBlock (\r
  IN  HII_FONT_PACKAGE_INSTANCE      *FontPackage,\r
  IN  CHAR16                         CharValue,\r
  OUT UINT8                          **GlyphBuffer, OPTIONAL\r
  OUT EFI_HII_GLYPH_INFO             *Cell, OPTIONAL\r
  OUT UINTN                          *GlyphBufferLen OPTIONAL\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  UINT8                               *BlockPtr;\r
  UINT16                              CharCurrent;\r
  UINT16                              Length16;\r
  UINT32                              Length32;\r
  EFI_HII_GIBT_GLYPHS_BLOCK           Glyphs;\r
  UINTN                               BufferLen;\r
  UINT16                              Index;\r
  EFI_HII_GLYPH_INFO                  DefaultCell;\r
  EFI_HII_GLYPH_INFO                  LocalCell;\r
\r
  ASSERT (FontPackage != NULL);\r
  ASSERT (FontPackage->Signature == HII_FONT_PACKAGE_SIGNATURE);\r
\r
  if (CharValue == (CHAR16) (-1)) {\r
    //\r
    // Collect the cell information specified in font package fixed header.\r
    // Use CharValue =0 to represent this particular cell.\r
    //\r
    Status = NewCell (\r
               0,\r
               &FontPackage->GlyphInfoList,\r
               (EFI_HII_GLYPH_INFO *) ((UINT8 *) FontPackage->FontPkgHdr + 3 * sizeof (UINT32))\r
               );\r
    if (EFI_ERROR (Status)) {\r
      return Status;\r
    }\r
  }\r
\r
  BlockPtr    = FontPackage->GlyphBlock;\r
  CharCurrent = 1;\r
  BufferLen   = 0;\r
\r
  while (*BlockPtr != EFI_HII_GIBT_END) {\r
    switch (*BlockPtr) {\r
    case EFI_HII_GIBT_DEFAULTS:\r
      //\r
      // Collect all default character cell information specified by\r
      // EFI_HII_GIBT_DEFAULTS.\r
      //\r
      if (CharValue == (CHAR16) (-1)) {\r
        Status = NewCell (\r
                   CharCurrent,\r
                   &FontPackage->GlyphInfoList,\r
                   (EFI_HII_GLYPH_INFO *) (BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK))\r
                   );\r
        if (EFI_ERROR (Status)) {\r
          return Status;\r
        }\r
      }\r
      BlockPtr += sizeof (EFI_HII_GIBT_DEFAULTS_BLOCK);\r
      break;\r
\r
    case EFI_HII_GIBT_DUPLICATE:\r
      if (CharCurrent == CharValue) {\r
        CopyMem (&CharValue, BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK), sizeof (CHAR16));\r
        CharCurrent = 1;\r
        BlockPtr    = FontPackage->GlyphBlock;\r
        continue;\r
      }\r
      CharCurrent++;\r
      BlockPtr += sizeof (EFI_HII_GIBT_DUPLICATE_BLOCK);\r
      break;\r
\r
    case EFI_HII_GIBT_EXT1:\r
      BlockPtr += *(BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK) + sizeof (UINT8));\r
      break;\r
    case EFI_HII_GIBT_EXT2:\r
      CopyMem (\r
        &Length16,\r
        BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK) + sizeof (UINT8),\r
        sizeof (UINT16)\r
        );\r
      BlockPtr += Length16;\r
      break;\r
    case EFI_HII_GIBT_EXT4:\r
      CopyMem (\r
        &Length32,\r
        BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK) + sizeof (UINT8),\r
        sizeof (UINT32)\r
        );\r
      BlockPtr += Length32;\r
      break;\r
\r
    case EFI_HII_GIBT_GLYPH:\r
      CopyMem (\r
        &LocalCell,\r
        BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK),\r
        sizeof (EFI_HII_GLYPH_INFO)\r
        );\r
      BufferLen = BITMAP_LEN_1_BIT (LocalCell.Width, LocalCell.Height);\r
      if (CharCurrent == CharValue) {\r
        return WriteOutputParam (\r
                 BlockPtr + sizeof (EFI_HII_GIBT_GLYPH_BLOCK) - sizeof (UINT8),\r
                 BufferLen,\r
                 &LocalCell,\r
                 GlyphBuffer,\r
                 Cell,\r
                 GlyphBufferLen\r
                 );\r
      }\r
      CharCurrent++;\r
      BlockPtr += sizeof (EFI_HII_GIBT_GLYPH_BLOCK) - sizeof (UINT8) + BufferLen;\r
      break;\r
\r
    case EFI_HII_GIBT_GLYPHS:\r
      BlockPtr += sizeof (EFI_HII_GLYPH_BLOCK);\r
      CopyMem (&Glyphs.Cell, BlockPtr, sizeof (EFI_HII_GLYPH_INFO));\r
      BlockPtr += sizeof (EFI_HII_GLYPH_INFO);\r
      CopyMem (&Glyphs.Count, BlockPtr, sizeof (UINT16));\r
      BlockPtr += sizeof (UINT16);\r
\r
      BufferLen = BITMAP_LEN_1_BIT (Glyphs.Cell.Width, Glyphs.Cell.Height);\r
      for (Index = 0; Index < Glyphs.Count; Index++) {\r
        if (CharCurrent + Index == CharValue) {\r
          return WriteOutputParam (\r
                   BlockPtr,\r
                   BufferLen,\r
                   &Glyphs.Cell,\r
                   GlyphBuffer,\r
                   Cell,\r
                   GlyphBufferLen\r
                   );\r
        }\r
        BlockPtr += BufferLen;\r
      }\r
      CharCurrent = (UINT16) (CharCurrent + Glyphs.Count);\r
      break;\r
\r
    case EFI_HII_GIBT_GLYPH_DEFAULT:\r
      Status = GetCell (CharCurrent, &FontPackage->GlyphInfoList, &DefaultCell);\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
      BufferLen = BITMAP_LEN_1_BIT (DefaultCell.Width, DefaultCell.Height);\r
\r
      if (CharCurrent == CharValue) {\r
        return WriteOutputParam (\r
                 BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK),\r
                 BufferLen,\r
                 &DefaultCell,\r
                 GlyphBuffer,\r
                 Cell,\r
                 GlyphBufferLen\r
                 );\r
      }\r
      CharCurrent++;\r
      BlockPtr += sizeof (EFI_HII_GLYPH_BLOCK) + BufferLen;\r
      break;\r
\r
    case EFI_HII_GIBT_GLYPHS_DEFAULT:\r
      CopyMem (&Length16, BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK), sizeof (UINT16));\r
      Status = GetCell (CharCurrent, &FontPackage->GlyphInfoList, &DefaultCell);\r
      if (EFI_ERROR (Status)) {\r
        return Status;\r
      }\r
      BufferLen = BITMAP_LEN_1_BIT (DefaultCell.Width, DefaultCell.Height);\r
      BlockPtr += sizeof (EFI_HII_GIBT_GLYPHS_DEFAULT_BLOCK) - sizeof (UINT8);\r
      for (Index = 0; Index < Length16; Index++) {\r
        if (CharCurrent + Index == CharValue) {\r
          return WriteOutputParam (\r
                   BlockPtr,\r
                   BufferLen,\r
                   &DefaultCell,\r
                   GlyphBuffer,\r
                   Cell,\r
                   GlyphBufferLen\r
                   );\r
        }\r
        BlockPtr += BufferLen;\r
      }\r
      CharCurrent = (UINT16) (CharCurrent + Length16);\r
      break;\r
\r
    case EFI_HII_GIBT_SKIP1:\r
      CharCurrent = (UINT16) (CharCurrent + (UINT16) (*(BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK))));\r
      BlockPtr    += sizeof (EFI_HII_GIBT_SKIP1_BLOCK);\r
      break;\r
    case EFI_HII_GIBT_SKIP2:\r
      CopyMem (&Length16, BlockPtr + sizeof (EFI_HII_GLYPH_BLOCK), sizeof (UINT16));\r
      CharCurrent = (UINT16) (CharCurrent + Length16);\r
      BlockPtr    += sizeof (EFI_HII_GIBT_SKIP2_BLOCK);\r
      break;\r
    default:\r
      ASSERT (FALSE);\r
      break;\r
    }\r
\r
    if (CharValue < CharCurrent) {\r
      return EFI_NOT_FOUND;\r
    }\r
  }\r
\r
  if (CharValue == (CHAR16) (-1)) {\r
    return EFI_SUCCESS;\r
  }\r
\r
  return EFI_NOT_FOUND;\r
}\r
\r
\r
/**\r
  Copy a Font Name to a new created EFI_FONT_INFO structure.\r
\r
  @param  FontName                NULL-terminated string.\r
  @param  FontInfo                a new EFI_FONT_INFO which stores the FontName.\r
                                  It's caller's responsibility to free this buffer.\r
\r
  @retval EFI_SUCCESS             FontInfo is allocated and copied with FontName.\r
  @retval EFI_OUT_OF_RESOURCES    The system is out of resources to accomplish the\r
                                  task.\r
\r
**/\r
STATIC\r
EFI_STATUS\r
SaveFontName (\r
  IN  EFI_STRING                       FontName,\r
  OUT EFI_FONT_INFO                    **FontInfo\r
  )\r
{\r
  UINTN         FontInfoLen;\r
\r
  ASSERT (FontName != NULL && FontInfo != NULL);\r
\r
  FontInfoLen = sizeof (EFI_FONT_INFO) - sizeof (CHAR16) + StrSize (FontName);\r
  *FontInfo = (EFI_FONT_INFO *) AllocateZeroPool (FontInfoLen);\r
  if (*FontInfo == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  StrCpy ((*FontInfo)->FontName, FontName);\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Retrieve system default font and color.\r
\r
  @param  Private                 HII database driver private data.\r
  @param  FontInfo                Points to system default font output-related\r
                                  information. It's caller's responsibility to free\r
                                  this buffer.\r
  @param  FontInfoSize            If not NULL, output the size of buffer FontInfo.\r
\r
  @retval EFI_SUCCESS             Cell information is added to the GlyphInfoList.\r
  @retval EFI_OUT_OF_RESOURCES    The system is out of resources to accomplish the\r
                                  task.\r
  @retval EFI_INVALID_PARAMETER   Any input parameter is invalid.\r
\r
**/\r
EFI_STATUS\r
GetSystemFont (\r
  IN  HII_DATABASE_PRIVATE_DATA      *Private,\r
  OUT EFI_FONT_DISPLAY_INFO          **FontInfo,\r
  OUT UINTN                          *FontInfoSize OPTIONAL\r
  )\r
{\r
  EFI_FONT_DISPLAY_INFO              *Info;\r
  UINTN                              InfoSize;\r
\r
  if (Private == NULL || Private->Signature != HII_DATABASE_PRIVATE_DATA_SIGNATURE) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
  if (FontInfo == NULL) {\r
    return EFI_INVALID_PARAMETER;\r
  }\r
\r
  //\r
  // The standard font always has the name "sysdefault".\r
  //\r
  InfoSize = sizeof (EFI_FONT_DISPLAY_INFO) - sizeof (CHAR16) + StrSize (L"sysdefault");\r
  Info = (EFI_FONT_DISPLAY_INFO *) AllocateZeroPool (InfoSize);\r
  if (Info == NULL) {\r
    return EFI_OUT_OF_RESOURCES;\r
  }\r
\r
  Info->ForegroundColor    = mEfiColors[Private->Attribute & 0x0f];\r
  Info->BackgroundColor    = mEfiColors[Private->Attribute >> 4];\r
  Info->FontInfoMask       = EFI_FONT_INFO_SYS_FONT | EFI_FONT_INFO_SYS_SIZE | EFI_FONT_INFO_SYS_STYLE;\r
  Info->FontInfo.FontStyle = 0;\r
  Info->FontInfo.FontSize  = EFI_GLYPH_HEIGHT;\r
  StrCpy (Info->FontInfo.FontName, L"sysdefault");\r
\r
  *FontInfo = Info;\r
  if (FontInfoSize != NULL) {\r
    *FontInfoSize = InfoSize;\r
  }\r
  return EFI_SUCCESS;\r
}\r
\r
\r
/**\r
  Check whether EFI_FONT_DISPLAY_INFO points to system default font and color.\r
\r
  @param  Private                 HII database driver private data.\r
  @param  StringInfo              Points to the string output information,\r
                                  including the color and font.\r
  @param  SystemInfo              If not NULL, points to system default font and\r
                                  color when incoming StringInfo does not match the\r
                                  default.  Points to NULL if matches. It's\r
                                  caller's reponsibility to free this buffer.\r
  @param  SystemInfoLen           If not NULL, output the length of default system\r
                                  info.\r
\r
  @retval TRUE                    Yes, it points to system default.\r
  @retval FALSE                   No.\r
\r
**/\r
STATIC\r
BOOLEAN\r
IsSystemFontInfo (\r
  IN  HII_DATABASE_PRIVATE_DATA      *Private,\r
  IN  EFI_FONT_DISPLAY_INFO          *StringInfo,\r
  OUT EFI_FONT_DISPLAY_INFO          **SystemInfo, OPTIONAL\r
  OUT UINTN                          *SystemInfoLen OPTIONAL\r
  )\r
{\r
  EFI_STATUS                          Status;\r
  EFI_FONT_DISPLAY_INFO               *SystemDefault;\r
  UINTN                               DefaultLen;\r
\r
  ASSERT (Private != NULL && Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);\r
\r
  if (StringInfo == NULL && SystemInfo == NULL) {\r
    return TRUE;\r
  }\r
\r
  //\r
  // Check whether incoming string font and color matches system default.\r
  //\r
  Status = GetSystemFont (Private, &SystemDefault, &DefaultLen);\r
  ASSERT_EFI_ERROR (Status);\r
\r
  if (SystemInfo != NULL) {\r
    *SystemInfo = SystemDefault;\r
  } else {\r
    SafeFreePool (SystemDefault);\r
  }\r
\r
  if (SystemInfoLen != NULL) {\r
    *SystemInfoLen = DefaultLen;\r
  }\r
\r
  if (StringInfo == NULL ||\r
      (StringInfo != NULL && CompareMem (SystemDefault, StringInfo, DefaultLen) == 0)) {\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
\r
/**\r
  This function checks whether EFI_FONT_INFO exists in current database. If\r
  FontInfoMask is specified, check what options can be used to make a match.\r
  Note that the masks relate to where the system default should be supplied\r
  are ignored by this function.\r
\r
  @param  Private                 Hii database private structure.\r
  @param  FontInfo                Points to EFI_FONT_INFO structure.\r
  @param  FontInfoMask            If not NULL, describes what options can be used\r
                                  to make a match between the font requested and\r
                                  the font available. The caller must guarantee\r
                                  this mask is valid.\r
  @param  FontHandle              On entry, Points to the font handle returned by a\r
                                  previous  call to GetFontInfo() or NULL to start\r
                                  with the first font.\r
  @param  GlobalFontInfo          If not NULL, output the corresponding globa font\r
                                  info.\r
\r
  @retval TRUE                    Existed\r
  @retval FALSE                   Not existed\r
\r
**/\r
BOOLEAN\r
IsFontInfoExisted (\r
  IN  HII_DATABASE_PRIVATE_DATA *Private,\r
  IN  EFI_FONT_INFO             *FontInfo,\r
  IN  EFI_FONT_INFO_MASK        *FontInfoMask,   OPTIONAL\r
  IN  EFI_FONT_HANDLE           FontHandle,      OPTIONAL\r
  OUT HII_GLOBAL_FONT_INFO      **GlobalFontInfo OPTIONAL\r
  )\r
{\r
  HII_GLOBAL_FONT_INFO          *GlobalFont;\r
  HII_GLOBAL_FONT_INFO          *GlobalFontBackup1;\r
  HII_GLOBAL_FONT_INFO          *GlobalFontBackup2;\r
  LIST_ENTRY                    *Link;\r
  EFI_FONT_INFO_MASK            Mask;\r
  BOOLEAN                       Matched;\r
  BOOLEAN                       VagueMatched1;\r
  BOOLEAN                       VagueMatched2;\r
\r
  ASSERT (Private != NULL && Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);\r
  ASSERT (FontInfo != NULL);\r
\r
  //\r
  // Matched flag represents an exactly match; VagueMatched1 repensents a RESIZE\r
  // or RESTYLE match; VagueMatched2 represents a RESIZE | RESTYLE match.\r
  //\r
  Matched           = FALSE;\r
  VagueMatched1     = FALSE;\r
  VagueMatched2     = FALSE;\r
\r
  Mask              = 0;\r
  GlobalFontBackup1 = NULL;\r
  GlobalFontBackup2 = NULL;\r
\r
  // The process of where the system default should be supplied instead of\r
  // the specified font info beyonds this function's scope.\r
  //\r
  if (FontInfoMask != NULL) {\r
    Mask = *FontInfoMask & (~SYS_FONT_INFO_MASK);\r
  }\r
\r
  //\r
  // If not NULL, FontHandle points to the next node of the last searched font\r
  // node by previous call.\r
  //\r
  if (FontHandle == NULL) {\r
    Link = Private->FontInfoList.ForwardLink;\r
  } else {\r
    Link = (LIST_ENTRY     *) FontHandle;\r
  }\r
\r
  for (; Link != &Private->FontInfoList; Link = Link->ForwardLink) {\r
    GlobalFont = CR (Link, HII_GLOBAL_FONT_INFO, Entry, HII_GLOBAL_FONT_INFO_SIGNATURE);\r
    if (FontInfoMask == NULL) {\r
      if (CompareMem (GlobalFont->FontInfo, FontInfo, GlobalFont->FontInfoSize) == 0) {\r
        if (GlobalFontInfo != NULL) {\r
          *GlobalFontInfo = GlobalFont;\r
        }\r
        return TRUE;\r
      }\r
    } else {\r
      //\r
      // Check which options could be used to make a match.\r
      //\r
      switch (Mask) {\r
      case EFI_FONT_INFO_ANY_FONT:\r
        if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle &&\r
            GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
          Matched = TRUE;\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_STYLE:\r
        if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {\r
          Matched = TRUE;\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_SIZE:\r
        if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {\r
          Matched = TRUE;\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_SIZE | EFI_FONT_INFO_ANY_STYLE:\r
        Matched   = TRUE;\r
        break;\r
      //\r
      // If EFI_FONT_INFO_RESTYLE is specified, then the system may attempt to\r
      // remove some of the specified styles to meet the style requested.\r
      //\r
      case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_RESTYLE:\r
        if (GlobalFont->FontInfo->FontSize == FontInfo->FontSize) {\r
          if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {\r
            Matched           = TRUE;\r
          } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {\r
            VagueMatched1     = TRUE;\r
            GlobalFontBackup1 = GlobalFont;\r
          }\r
        }\r
        break;\r
      //\r
      // If EFI_FONT_INFO_RESIZE is specified, then the sytem may attempt to\r
      // stretch or shrink a font to meet the size requested.\r
      //\r
      case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_RESIZE:\r
        if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {\r
          if (GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
            Matched           = TRUE;\r
          } else {\r
            VagueMatched1     = TRUE;\r
            GlobalFontBackup1 = GlobalFont;\r
          }\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_RESTYLE | EFI_FONT_INFO_RESIZE:\r
        if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {\r
          if (GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
            Matched           = TRUE;\r
          } else {\r
            VagueMatched1     = TRUE;\r
            GlobalFontBackup1 = GlobalFont;\r
          }\r
        } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {\r
          if (GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
            VagueMatched1     = TRUE;\r
            GlobalFontBackup1 = GlobalFont;\r
          } else {\r
            VagueMatched2     = TRUE;\r
            GlobalFontBackup2 = GlobalFont;\r
          }\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_STYLE | EFI_FONT_INFO_RESIZE:\r
        if (GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
          Matched           = TRUE;\r
        } else {\r
          VagueMatched1     = TRUE;\r
          GlobalFontBackup1 = GlobalFont;\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_FONT | EFI_FONT_INFO_ANY_SIZE | EFI_FONT_INFO_RESTYLE:\r
        if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {\r
          Matched           = TRUE;\r
        } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {\r
          VagueMatched1     = TRUE;\r
          GlobalFontBackup1 = GlobalFont;\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_STYLE:\r
        if ((CompareMem (\r
               GlobalFont->FontInfo->FontName,\r
               FontInfo->FontName,\r
               StrSize (FontInfo->FontName)\r
               ) == 0) &&\r
            GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
          Matched = TRUE;\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_STYLE | EFI_FONT_INFO_ANY_SIZE:\r
        if (CompareMem (\r
              GlobalFont->FontInfo->FontName,\r
              FontInfo->FontName,\r
              StrSize (FontInfo->FontName)\r
              ) == 0) {\r
          Matched = TRUE;\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_STYLE | EFI_FONT_INFO_RESIZE:\r
        if (CompareMem (\r
              GlobalFont->FontInfo->FontName,\r
              FontInfo->FontName,\r
              StrSize (FontInfo->FontName)\r
              ) == 0) {\r
          if (GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
            Matched           = TRUE;\r
          } else {\r
            VagueMatched1     = TRUE;\r
            GlobalFontBackup1 = GlobalFont;\r
          }\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_SIZE:\r
        if ((CompareMem (\r
               GlobalFont->FontInfo->FontName,\r
               FontInfo->FontName,\r
               StrSize (FontInfo->FontName)\r
               ) == 0) &&\r
            GlobalFont->FontInfo->FontStyle  == FontInfo->FontStyle) {\r
          Matched = TRUE;\r
        }\r
        break;\r
      case EFI_FONT_INFO_ANY_SIZE | EFI_FONT_INFO_RESTYLE:\r
        if (CompareMem (\r
              GlobalFont->FontInfo->FontName,\r
              FontInfo->FontName,\r
              StrSize (FontInfo->FontName)\r
              ) == 0) {\r
          if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {\r
            Matched           = TRUE;\r
          } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {\r
            VagueMatched1     = TRUE;\r
            GlobalFontBackup1 = GlobalFont;\r
          }\r
        }\r
        break;\r
      case EFI_FONT_INFO_RESTYLE:\r
        if ((CompareMem (\r
               GlobalFont->FontInfo->FontName,\r
               FontInfo->FontName,\r
               StrSize (FontInfo->FontName)\r
               ) == 0) &&\r
            GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
\r
          if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {\r
            Matched           = TRUE;\r
          } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {\r
            VagueMatched1     = TRUE;\r
            GlobalFontBackup1 = GlobalFont;\r
          }\r
        }\r
        break;\r
      case EFI_FONT_INFO_RESIZE:\r
        if ((CompareMem (\r
               GlobalFont->FontInfo->FontName,\r
               FontInfo->FontName,\r
               StrSize (FontInfo->FontName)\r
               ) == 0) &&\r
            GlobalFont->FontInfo->FontStyle  == FontInfo->FontStyle) {\r
\r
          if (GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
            Matched           = TRUE;\r
          } else {\r
            VagueMatched1     = TRUE;\r
            GlobalFontBackup1 = GlobalFont;\r
          }\r
        }\r
        break;\r
      case EFI_FONT_INFO_RESIZE | EFI_FONT_INFO_RESTYLE:\r
        if (CompareMem (\r
              GlobalFont->FontInfo->FontName,\r
              FontInfo->FontName,\r
              StrSize (FontInfo->FontName)\r
              ) == 0) {\r
          if (GlobalFont->FontInfo->FontStyle == FontInfo->FontStyle) {\r
            if (GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
              Matched           = TRUE;\r
            } else {\r
              VagueMatched1     = TRUE;\r
              GlobalFontBackup1 = GlobalFont;\r
            }\r
          } else if ((GlobalFont->FontInfo->FontStyle & FontInfo->FontStyle) == FontInfo->FontStyle) {\r
            if (GlobalFont->FontInfo->FontSize  == FontInfo->FontSize) {\r
              VagueMatched1     = TRUE;\r
              GlobalFontBackup1 = GlobalFont;\r
            } else {\r
              VagueMatched2     = TRUE;\r
              GlobalFontBackup2 = GlobalFont;\r
            }\r
          }\r
        }\r
        break;\r
      default:\r
        break;\r
      }\r
\r
      if (Matched) {\r
        if (GlobalFontInfo != NULL) {\r
          *GlobalFontInfo = GlobalFont;\r
        }\r
        return TRUE;\r
      }\r
    }\r
  }\r
\r
  if (VagueMatched1) {\r
    if (GlobalFontInfo != NULL) {\r
      *GlobalFontInfo = GlobalFontBackup1;\r
    }\r
    return TRUE;\r
  } else if (VagueMatched2) {\r
    if (GlobalFontInfo != NULL) {\r
      *GlobalFontInfo = GlobalFontBackup2;\r
    }\r
    return TRUE;\r
  }\r
\r
  return FALSE;\r
}\r
\r
\r
/**\r
  Check whether the unicode represents a line break or not.\r
\r
  @param  Char                    Unicode character\r
\r
  @retval 0                       Yes, it is a line break.\r
  @retval 1                       Yes, it is a hyphen that desires a line break\r
                                  after this character.\r
  @retval 2                       Yes, it is a dash that desires a line break\r
                                  before and after it.\r
  @retval -1                      No, it is not a link break.\r
\r
**/\r
STATIC\r
INT8\r
IsLineBreak (\r
  IN  CHAR16    Char\r
  )\r
{\r
  UINT8         Byte1;\r
  UINT8         Byte2;\r
\r
  //\r
  // In little endian, Byte1 is the low byte of Char, Byte2 is the high byte of Char.\r
  //\r
  Byte1 = *((UINT8 *) (&Char));\r
  Byte2 = *(((UINT8 *) (&Char) + 1));\r
\r
  if (Byte2 == 0x20) {\r
    switch (Byte1) {\r
    case 0x00:\r
    case 0x01:\r
    case 0x02:\r
    case 0x03:\r
    case 0x04:\r
    case 0x05:\r
    case 0x06:\r
    case 0x08:\r
    case 0x09:\r
    case 0x0A:\r
    case 0x0B:\r
    case 0x28:\r
    case 0x29:\r
    case 0x5F:\r
      return 0;\r
    case 0x10:\r
    case 0x12:\r
    case 0x13:\r
      return 1;\r
    case 0x14:\r
      //\r
      // BUGBUG: Does it really require line break before it and after it?\r
      //\r
      return 2;\r
    }\r
  } else if (Byte2 == 0x00) {\r
    switch (Byte1) {\r
    case 0x20:\r
    case 0x0C:\r
    case 0x0D:\r
      return 0;\r
    }\r
  }\r
\r
  switch (Char) {\r
    case 0x1680:\r
      return 0;\r
    case 0x058A:\r
    case 0x0F0B:\r
    case 0x1361:\r
    case 0x17D5:\r
      return 1;\r
  }\r
\r
  return -1;\r
}\r
\r
\r
/**\r
  Renders a string to a bitmap or to the display.\r
\r
  @param  This                    A pointer to the EFI_HII_FONT_PROTOCOL instance.\r
  @param  Flags                   Describes how the string is to be drawn.\r
  @param  String                  Points to the null-terminated string to be\r
                                  displayed.\r
  @param  StringInfo              Points to the string output information,\r
                                  including the color and font.  If NULL, then the\r
                                  string will be output in the default system font\r
                                  and color.\r
  @param  Blt                     If this points to a non-NULL on entry, this\r
                                  points to the image, which is Width pixels   wide\r
                                  and Height pixels high. The string will be drawn\r
                                  onto this image and\r
                                  EFI_HII_OUT_FLAG_CLIP is implied. If this points\r
                                  to a NULL on entry, then a              buffer\r
                                  will be allocated to hold the generated image and\r