929 lines
25 KiB
C
929 lines
25 KiB
C
//
|
|
// FILENAME.
|
|
// Ui.c
|
|
// -----------------------------------------------------------------------
|
|
//
|
|
// NOTICE.
|
|
// Copyright (C) 2014 Lenovo All Rights Reserved.
|
|
//
|
|
|
|
//
|
|
// Include standard header files.
|
|
//
|
|
#include "Ui.h"
|
|
#include "Batt.h"
|
|
#include "TrueTypeCharRes.h"
|
|
#include "minilzo.h"
|
|
#include "library\TrueTypeLib\TrueTypeLib.h"
|
|
|
|
EFI_STRING StringsAcSatatus[] = {
|
|
L"Unpluged",
|
|
L"Plug in",
|
|
};
|
|
|
|
EFI_STRING StringsBattSatatus[] = {
|
|
L"Battery non-exist",
|
|
L"Battery abnormal",
|
|
L"Charging",
|
|
L"Full Charged",
|
|
L"DisCharging",
|
|
L"Full DisCharged",
|
|
L"Battery Unknown"
|
|
};
|
|
|
|
//
|
|
//Global Graphics handle for whole GUI
|
|
//
|
|
static EFI_GRAPHICS_OUTPUT_PROTOCOL *mGraphicsOutput = NULL;
|
|
|
|
static UINTN mHorizontalResolution = 0;
|
|
static UINTN mVerticalResolution = 0;
|
|
|
|
|
|
/**
|
|
Set rectangle data
|
|
|
|
@param[in, out] Rect Pointer to rectangle data which will be set
|
|
@param[in] Left Left value of rectangle data
|
|
@param[in] Top Top value of rectangle data
|
|
@param[in] Right Right value of rectangle data
|
|
@param[in] Bottom Bottom value of rectangle data
|
|
|
|
@retval TRUE Rectangle data is set
|
|
**/
|
|
BOOLEAN
|
|
EFIAPI
|
|
SetRect(
|
|
IN OUT RECT *Rect,
|
|
IN UINTN Left,
|
|
IN UINTN Top,
|
|
IN UINTN Right,
|
|
IN UINTN Bottom
|
|
)
|
|
{
|
|
Rect->left = Left;
|
|
Rect->top = Top;
|
|
Rect->right = Right;
|
|
Rect->bottom = Bottom;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/**
|
|
Copy rectangle data
|
|
|
|
@param[out] DestRect Pointer to destination rectangle data
|
|
@param[in] SrcRect Pointer to source rectangle data
|
|
|
|
@retval TRUE Rectangle data is copied
|
|
**/
|
|
BOOLEAN
|
|
EFIAPI
|
|
CopyRect(
|
|
OUT RECT *DestRect,
|
|
IN CONST RECT *SrcRect
|
|
)
|
|
{
|
|
CopyMem(DestRect, SrcRect, sizeof (RECT));
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**
|
|
shrink the rectangle data
|
|
|
|
@param[in, out] Rect Pointer to rectangle data which will be inflated
|
|
@param[in] DiffX Inflated x-axis value
|
|
@param[in] DiffY Inflated y-axis value
|
|
|
|
@retval TRUE Rectangle data is inflated
|
|
**/
|
|
BOOLEAN
|
|
EFIAPI
|
|
ShrinkRect(
|
|
IN OUT RECT *Rect,
|
|
IN UINTN DiffX,
|
|
IN UINTN DiffY
|
|
)
|
|
{
|
|
Rect->left += DiffX;
|
|
Rect->top += DiffY;
|
|
Rect->right -= DiffX;
|
|
Rect->bottom -= DiffY;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/**
|
|
Width of the rectangle
|
|
|
|
@param[in, out] Rect Pointer to rectangle data which will be inflated
|
|
@param[in] DiffX Inflated x-axis value
|
|
@param[in] DiffY Inflated y-axis value
|
|
|
|
@retval TRUE Rectangle data is inflated
|
|
**/
|
|
UINTN
|
|
EFIAPI
|
|
WidthRect(
|
|
IN OUT RECT *Rect
|
|
)
|
|
{
|
|
return (Rect->right - Rect->left + 1);
|
|
}
|
|
|
|
UINTN
|
|
EFIAPI
|
|
HeightRect(
|
|
IN OUT RECT *Rect
|
|
)
|
|
{
|
|
return (Rect->bottom - Rect->top + 1);
|
|
}
|
|
|
|
|
|
/**
|
|
Offset the rectangle data
|
|
|
|
@param[in, out] Rect Pointer to rectangle data which will be offset
|
|
@param[in] DiffX Offset x-axis value
|
|
@param[in] DiffY Offset y-axis value
|
|
|
|
@retval TRUE Rectangle data is offset
|
|
**/
|
|
BOOLEAN
|
|
EFIAPI
|
|
OffsetRect(
|
|
IN OUT RECT *Rect,
|
|
IN UINTN DiffX,
|
|
IN UINTN DiffY
|
|
)
|
|
{
|
|
Rect->left += DiffX;
|
|
Rect->right += DiffX;
|
|
Rect->top += DiffY;
|
|
Rect->bottom += DiffY;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
DisplayBitBlt(
|
|
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt,
|
|
IN EFI_GRAPHICS_OUTPUT_BLT_OPERATION Mode,
|
|
IN RECT* Rect
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
UINTN X;
|
|
UINTN Y;
|
|
UINTN Width;
|
|
UINTN Height;
|
|
|
|
|
|
//
|
|
// Draw a one pixel width rectangle as a vertical line by Graphics Output
|
|
// Protocol. Use the argument Mode to fill this rectangle.
|
|
//
|
|
Width = WidthRect(Rect);
|
|
Height = HeightRect(Rect);
|
|
X = Rect->left;
|
|
Y = Rect->top;
|
|
//DebugL(L"Function: DisplayBitBlt,(%d,%d, W=%d,H=%d). \n ",X,Y,Width,Height);
|
|
|
|
switch (Mode) {
|
|
case EfiBltVideoFill:
|
|
case EfiBltBufferToVideo:
|
|
Status = mGraphicsOutput->Blt(
|
|
mGraphicsOutput,
|
|
Blt,
|
|
Mode,
|
|
0,
|
|
0,
|
|
X,
|
|
Y,
|
|
Width,
|
|
Height,
|
|
0);
|
|
break;
|
|
|
|
case EfiBltVideoToBltBuffer:
|
|
Status = mGraphicsOutput->Blt (
|
|
mGraphicsOutput,
|
|
Blt,
|
|
Mode,
|
|
X,
|
|
Y,
|
|
0,
|
|
0,
|
|
Width,
|
|
Height,
|
|
0
|
|
);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
//DebugL(L"Function(DisplayBitBlt mode=%d,ret=%d) X=%d,Y=%d,W=%d,D=%d,color=0x%x.\n ", Mode,Status,X,Y,Width,Height);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
TrueTypeStringToImage(
|
|
IN CHAR16 *String,
|
|
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Blt,
|
|
IN UINT16 Width,
|
|
IN UINT16 Height,
|
|
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL FgColor,
|
|
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL BkColor
|
|
)
|
|
{
|
|
|
|
EFI_STATUS Status;
|
|
STATIC UINT8 *GlyphBuffer = NULL;
|
|
STATIC UINTN BufferLen = 0;
|
|
UINTN GlyphBufferLen = 0;
|
|
EFI_HII_GLYPH_INFO Cell;
|
|
// UINT16 i = 0;
|
|
UINT16 X;
|
|
UINT16 Y;
|
|
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer;
|
|
UINT8 Alpha;
|
|
UINT16 BltWidth;
|
|
|
|
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBufferForSmooth;
|
|
|
|
ASSERT(String != NULL);
|
|
ASSERT(Blt != NULL);
|
|
|
|
BltBuffer = Blt;
|
|
|
|
BltBufferForSmooth = Blt;
|
|
|
|
//for (i = 0; i < (Width*Height); i++){
|
|
// BltBuffer[i] = BkColor;
|
|
//}
|
|
|
|
|
|
BltWidth = Width;
|
|
while (*String != 0) {
|
|
GlyphBufferLen = BufferLen;
|
|
Status = TrueTypeGetGlyph(
|
|
*String,
|
|
GlyphBuffer,
|
|
&GlyphBufferLen,
|
|
&Cell
|
|
);
|
|
if (Status == EFI_BUFFER_TOO_SMALL) {
|
|
if (GlyphBuffer != NULL) {
|
|
gBS->FreePool(GlyphBuffer);
|
|
}
|
|
GlyphBuffer = (UINT8 *)AllocateZeroPool(GlyphBufferLen);
|
|
BufferLen = GlyphBufferLen;
|
|
Status = TrueTypeGetGlyph(
|
|
*String,
|
|
GlyphBuffer,
|
|
&GlyphBufferLen,
|
|
&Cell
|
|
);
|
|
}
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
String++;
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// glyph to buffer
|
|
//
|
|
for (Y = 0; Y < Cell.Height; Y++) {
|
|
if ((UINTN)(Cell.OffsetY + Y) >= Height) {
|
|
continue;
|
|
}
|
|
|
|
for (X = 0; X < Cell.Width; X++) {
|
|
if ((Cell.OffsetX + X) < 0 ||
|
|
((UINTN)(Cell.OffsetX + X) >= (UINTN)Cell.AdvanceX)) {
|
|
continue;
|
|
}
|
|
|
|
Alpha = GlyphBuffer[Y * Cell.Width + X];
|
|
if (Alpha) {
|
|
FgColor.Reserved = Alpha;
|
|
BltBuffer[(Y + Cell.OffsetY) * BltWidth + X + Cell.OffsetX] = FgColor;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Cell.AdvanceX >= Width) {
|
|
break;
|
|
}
|
|
|
|
Width -= Cell.AdvanceX;
|
|
BltBuffer += Cell.AdvanceX;
|
|
|
|
String++;
|
|
}
|
|
|
|
|
|
for (Y = 0; Y < Height; Y++) {
|
|
|
|
for (X = 0; X < BltWidth; X++) {
|
|
|
|
if (BltBufferForSmooth[(BltWidth * Y) + X].Reserved != 0 &&
|
|
BltBufferForSmooth[(BltWidth * Y) + X].Reserved != 255) {
|
|
|
|
BltBufferForSmooth[(BltWidth * Y) + X].Blue =
|
|
BkColor.Blue +
|
|
(((BltBufferForSmooth[(BltWidth * Y) + X].Blue) - BkColor.Blue) *
|
|
(BltBufferForSmooth[(BltWidth * Y) + X].Reserved)) / 255;
|
|
|
|
BltBufferForSmooth[(BltWidth * Y) + X].Green =
|
|
BkColor.Green +
|
|
(((BltBufferForSmooth[(BltWidth * Y) + X].Green) - BkColor.Green) *
|
|
(BltBufferForSmooth[(BltWidth * Y) + X].Reserved)) / 255;
|
|
|
|
BltBufferForSmooth[(BltWidth * Y) + X].Red =
|
|
BkColor.Red +
|
|
(((BltBufferForSmooth[(BltWidth * Y) + X].Red) - BkColor.Red) *
|
|
(BltBufferForSmooth[(BltWidth * Y) + X].Reserved)) / 255;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
EFI_STATUS
|
|
TrueTypeGetWidth(
|
|
IN UINT16 FontSize,
|
|
IN EFI_STRING String,
|
|
IN OUT UINT16 *Width,
|
|
IN OUT UINT16 *Height
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
EFI_HII_GLYPH_INFO Cell;
|
|
|
|
TrueTypeSetFontSize(FontSize);
|
|
|
|
while (*String != 0) {
|
|
Status = TrueTypeGetGlyph(
|
|
*String,
|
|
NULL,
|
|
NULL,
|
|
&Cell
|
|
);
|
|
if (EFI_ERROR (Status)) {
|
|
//DebugL(L"Function: TrueTypeGetGlyph faild, font=0x%x\n ",*String);
|
|
}
|
|
else {
|
|
*Width += Cell.AdvanceX;
|
|
if (Cell.Height + Cell.OffsetY > *Height)
|
|
{
|
|
*Height = Cell.Height + Cell.OffsetY;
|
|
}
|
|
|
|
//DebugL(L"Function: TrueTypeGetGlyph width=%d,height=%d,AdvanceX=%d,offsetX=%d,offsetY=%d\n ",
|
|
// Cell.Width,Cell.Height,Cell.AdvanceX,Cell.OffsetX,Cell.OffsetY);
|
|
}
|
|
|
|
String++;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Use HiiFont to draw text to blt buffer
|
|
|
|
@param [in] ImageInfo Destination Image
|
|
@param [in] TextColor Text Color
|
|
@param [in] BackgroundColor Background color
|
|
@param [in] String Destination LineLen
|
|
@param [in] TextRc Destination rectangle
|
|
|
|
@return return StringToImage status
|
|
|
|
**/
|
|
EFI_STATUS
|
|
TrueTypeDrawText(
|
|
IN UINT16 FontSize,
|
|
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *TextColor,
|
|
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BackgroundColor,
|
|
IN EFI_STRING String,
|
|
IN RECT *TextRc,
|
|
IN UINTN Style,
|
|
IN BOOLEAN bTransparent
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
UINT16 TextRCWidth = 0;
|
|
UINT16 TextRCHeight = 0;
|
|
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *BltBuffer = NULL;
|
|
RECT Rect;
|
|
UINTN nTry = 0;
|
|
UINT16 NewFontSize = FontSize;
|
|
|
|
//
|
|
//let align to enter
|
|
//
|
|
CopyRect(&Rect,TextRc);
|
|
for(nTry=0; nTry<10; nTry++)
|
|
{
|
|
TextRCWidth = 0;
|
|
TextRCHeight = 0;
|
|
|
|
Status = TrueTypeGetWidth(NewFontSize,(CHAR16 *)String,&TextRCWidth,&TextRCHeight);
|
|
if (EFI_ERROR(Status)) {
|
|
DebugL(L"Function: TrueTypeGetWidth faild\n ");
|
|
return Status;
|
|
}
|
|
DebugL(L"Function: TrueTypeDrawText(%d-%d) fontsize=%d, width=%d, height=%d\n ",TextRc->left,TextRc->right,NewFontSize, TextRCWidth,TextRCHeight);
|
|
|
|
if (TextRCWidth < (TextRc->right - TextRc->left) && TextRCHeight < (TextRc->bottom - TextRc->top)) {
|
|
UINTN XStep = (TextRc->right - TextRc->left - TextRCWidth)/2;
|
|
UINTN YStep = (TextRc->bottom - TextRc->top - TextRCHeight)/2;
|
|
|
|
//find sultiable font size
|
|
switch (Style)
|
|
{
|
|
case FRONT_STYLE_LEFT_TOP:
|
|
SetRect(&Rect,TextRc->left,TextRc->top, TextRc->right-XStep*2, TextRc->bottom-YStep*2);
|
|
break;
|
|
|
|
case FRONT_STYLE_LEFT_BOTTOM:
|
|
SetRect(&Rect,TextRc->left,TextRc->top + YStep*2,TextRc->right-XStep*2, TextRc->bottom);
|
|
break;
|
|
|
|
case FRONT_STYLE_LEFT_CENTER:
|
|
SetRect(&Rect,TextRc->left,TextRc->top + YStep,TextRc->right-XStep*2, TextRc->bottom-YStep);
|
|
break;
|
|
|
|
case FRONT_STYLE_MIDLLE_TOP:
|
|
SetRect(&Rect,TextRc->left+XStep,TextRc->top ,TextRc->right-XStep, TextRc->bottom-YStep*2);
|
|
break;
|
|
|
|
case FRONT_STYLE_MIDLLE_BOTTOM:
|
|
SetRect(&Rect,TextRc->left+XStep,TextRc->top+YStep ,TextRc->right-XStep, TextRc->bottom-YStep);
|
|
break;
|
|
|
|
case FRONT_STYLE_MIDLLE_CENTER:
|
|
ShrinkRect(&Rect,XStep, YStep);
|
|
break;
|
|
|
|
case FRONT_STYLE_RIGHT_TOP:
|
|
SetRect(&Rect,TextRc->left+XStep*2,TextRc->top ,TextRc->right, TextRc->bottom-YStep*2);
|
|
break;
|
|
|
|
case FRONT_STYLE_RIGHT_BOTTOM:
|
|
SetRect(&Rect,TextRc->left+XStep*2,TextRc->top+YStep*2 ,TextRc->right, TextRc->bottom);
|
|
break;
|
|
|
|
case FRONT_STYLE_RIGHT_CENTER:
|
|
SetRect(&Rect,TextRc->left+XStep*2,TextRc->top+YStep ,TextRc->right, TextRc->bottom-YStep);
|
|
break;
|
|
|
|
case FRONT_STYLE_DISK_INFO:
|
|
OffsetRect(&Rect, 80, YStep);
|
|
break;
|
|
|
|
default:
|
|
ShrinkRect(&Rect,XStep, YStep);
|
|
break;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
NewFontSize-=4;
|
|
}
|
|
if (nTry == 10) {
|
|
DebugL(L"Function: TrueTypeDrawText area too samll\n ");
|
|
return Status;
|
|
}
|
|
|
|
Rect.right = Rect.left + TextRCWidth - 1;
|
|
Rect.bottom = Rect.top + TextRCHeight - 1;
|
|
|
|
BltBuffer = AllocateZeroPool((TextRCWidth * TextRCHeight + 64) * sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL));
|
|
if (NULL == BltBuffer){
|
|
DebugL(L"Function: TrueTypeDrawText alloc memory faild\n ");
|
|
return Status;
|
|
}
|
|
//
|
|
//for transparent,capture screen first
|
|
//
|
|
if (bTransparent) {
|
|
Status = DisplayBitBlt(
|
|
(EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)BltBuffer,
|
|
EfiBltVideoToBltBuffer,
|
|
&Rect
|
|
);
|
|
}
|
|
else {
|
|
for (nTry = 0; nTry < (TextRCWidth * TextRCHeight); nTry++){
|
|
BltBuffer[nTry] = *BackgroundColor;
|
|
}
|
|
}
|
|
|
|
Status = TrueTypeStringToImage(
|
|
(CHAR16 *)String,
|
|
BltBuffer,
|
|
(UINT16)TextRCWidth,
|
|
(UINT16)TextRCHeight,
|
|
*TextColor,
|
|
*BackgroundColor
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
DebugL(L"Function: TrueTypeStringToImage faild\n ");
|
|
gBS->FreePool(BltBuffer);
|
|
return Status;
|
|
}
|
|
|
|
Status = DisplayBitBlt(
|
|
(EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)BltBuffer,
|
|
EfiBltBufferToVideo,
|
|
&Rect
|
|
);
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
DebugL(L"Function: TrueTypeDrawText Blt faild\n ");
|
|
gBS->FreePool(BltBuffer);
|
|
return Status;
|
|
}
|
|
|
|
gBS->FreePool(BltBuffer);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
EFI_STATUS
|
|
InitializeTrueTypeFont(
|
|
)
|
|
{
|
|
#ifdef SUPPORT_FONT_IN_FV
|
|
EFI_STATUS Status;
|
|
UINTN FvProtocolCount;
|
|
EFI_HANDLE *FvHandles;
|
|
EFI_FIRMWARE_VOLUME2_PROTOCOL *Fv;
|
|
UINTN Index;
|
|
UINT32 AuthenticationStatus;
|
|
UINTN ImageSize;
|
|
UINT8 *ImageData;
|
|
#endif
|
|
STATIC BOOLEAN FirstIn = TRUE;
|
|
|
|
if (!FirstIn) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
else {
|
|
FirstIn = FALSE;
|
|
}
|
|
#ifdef SUPPORT_FONT_IN_FV
|
|
Status = gBS->LocateHandleBuffer(
|
|
ByProtocol,
|
|
&gEfiFirmwareVolume2ProtocolGuid,
|
|
NULL,
|
|
&FvProtocolCount,
|
|
&FvHandles
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
ImageData = NULL;
|
|
ImageSize = 0;
|
|
|
|
for (Index = 0; Index < FvProtocolCount; Index++) {
|
|
Status = gBS->HandleProtocol(
|
|
FvHandles[Index],
|
|
&gEfiFirmwareVolume2ProtocolGuid,
|
|
(VOID **)&Fv
|
|
);
|
|
|
|
Status = Fv->ReadSection(
|
|
Fv,
|
|
&gEfiTtfFontFileGuid,
|
|
EFI_SECTION_RAW,
|
|
0,
|
|
(VOID**)&ImageData,
|
|
&ImageSize,
|
|
&AuthenticationStatus
|
|
);
|
|
if (!EFI_ERROR(Status)) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if (EFI_ERROR(Status)) {
|
|
DebugL(L"Function: Load TTF font(FV) faild,try to use buitin font. \n ");
|
|
//return Status;
|
|
}
|
|
|
|
TrueTypeInit();
|
|
|
|
TrueTypeLoadMemory(ImageData, (UINT32)ImageSize);
|
|
|
|
#else
|
|
TrueTypeInit();
|
|
|
|
#ifdef LZO_TRUE_TYPE_CHAR_RES
|
|
{
|
|
UINT8 *pStr = NULL;
|
|
UINTN nSize = 0;
|
|
pStr = (UINT8 *)AllocateZeroPool (sizeof(UINT8) * ResLen);
|
|
if (NULL != pStr) {
|
|
lzo1x_decompress(TrueTypeFont, sizeof(TrueTypeFont), pStr, (lzo_uintp)&nSize, NULL);
|
|
if (nSize == ResLen) {
|
|
DebugL(L"Function: Load TTF from LZO format. \n ");
|
|
TrueTypeLoadMemory(pStr, (UINT32)nSize);
|
|
}
|
|
|
|
//Niote: always used, not free here
|
|
//FreePool(pStr);
|
|
}
|
|
}
|
|
#else
|
|
TrueTypeLoadMemory(TrueTypeFont, (UINT32)sizeof(TrueTypeFont));
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#if 0
|
|
{
|
|
UINT16 TextRCWidth = 0;
|
|
UINT16 TextRCHeight = 0;
|
|
CHAR16 String[] = L"g";
|
|
UINT16 NewFontSize = 0;
|
|
|
|
for (NewFontSize=12; NewFontSize<40;NewFontSize+=2) {
|
|
TrueTypeGetWidth(NewFontSize,(CHAR16 *)String,&TextRCWidth,&TextRCHeight);
|
|
DebugL(L"Fontsize=%d,width=%d,height=%d\n ", NewFontSize,TextRCWidth,TextRCHeight);
|
|
TextRCWidth = 0;
|
|
TextRCHeight = 0;
|
|
}
|
|
|
|
while(1);
|
|
|
|
}
|
|
#endif
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
EFI_STATUS
|
|
InitializeGUI(
|
|
)
|
|
{
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
UINT32 Index;
|
|
|
|
|
|
//
|
|
// Try to open GOP.
|
|
//
|
|
|
|
if (NULL == mGraphicsOutput) {
|
|
UINTN i;
|
|
UINTN HandleCount;
|
|
EFI_HANDLE *HandleBufferGop;
|
|
EFI_DEVICE_PATH_PROTOCOL *DevicePath;
|
|
|
|
Status = gBS->LocateHandleBuffer ( // Get all instances of GOP.
|
|
ByProtocol,
|
|
&gEfiGraphicsOutputProtocolGuid,
|
|
NULL,
|
|
&HandleCount,
|
|
&HandleBufferGop);
|
|
if (EFI_ERROR (Status)) {
|
|
return Status;
|
|
}
|
|
|
|
for (i = 0; i < HandleCount; i++) { // Search for physical device.
|
|
Status = gBS->HandleProtocol (
|
|
HandleBufferGop [i],
|
|
&gEfiDevicePathProtocolGuid,
|
|
(VOID *)&DevicePath);
|
|
if (!EFI_ERROR (Status)) {
|
|
gBS->HandleProtocol (
|
|
HandleBufferGop [i],
|
|
&gEfiGraphicsOutputProtocolGuid,
|
|
(VOID *)&mGraphicsOutput);
|
|
break;
|
|
}
|
|
}
|
|
|
|
gBS->FreePool (HandleBufferGop);
|
|
|
|
if (i >= HandleCount) {
|
|
DebugL(L"[BOKR_UI] HandleProtocol Error\r\n");
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
}
|
|
|
|
|
|
if (NULL != mGraphicsOutput)
|
|
{
|
|
UINTN SizeOfInfo;
|
|
EFI_GRAPHICS_OUTPUT_MODE_INFORMATION *Info;
|
|
|
|
for (Index = 0; Index < mGraphicsOutput->Mode->MaxMode; Index++) {
|
|
mGraphicsOutput->QueryMode (mGraphicsOutput, Index, &SizeOfInfo, &Info);
|
|
DebugL(L"Function(InitializeGUI) Mode %d resolution is (%d * %d).\n ", Index, Info->HorizontalResolution, Info->VerticalResolution);
|
|
if (DEFAULT_X == Info->HorizontalResolution &&
|
|
DEFAULT_Y == Info->VerticalResolution) {
|
|
Status = mGraphicsOutput->SetMode (mGraphicsOutput, Index);
|
|
gBS->FreePool (Info);
|
|
break;
|
|
}
|
|
gBS->FreePool (Info);
|
|
}
|
|
|
|
//
|
|
// Cannot find suitable GOP mode, set mode with default resolution.
|
|
//
|
|
if (EFI_ERROR (Status) || (Index == mGraphicsOutput->Mode->MaxMode)) {
|
|
for (Index = 0; Index < mGraphicsOutput->Mode->MaxMode; Index++) {
|
|
mGraphicsOutput->QueryMode (mGraphicsOutput, Index, &SizeOfInfo, &Info);
|
|
if (P1080P_X <= Info->HorizontalResolution &&
|
|
P1080P_Y <= Info->VerticalResolution) {
|
|
Status = mGraphicsOutput->SetMode (mGraphicsOutput, Index);
|
|
DebugL(L"Function(InitializeGUI) Selected Mode %d resolution is (%d * %d).\n ", Index, Info->HorizontalResolution, Info->VerticalResolution);
|
|
gBS->FreePool (Info);
|
|
break;
|
|
}
|
|
gBS->FreePool (Info);
|
|
}
|
|
}
|
|
|
|
//
|
|
// Error checking on options.
|
|
//
|
|
mHorizontalResolution = mGraphicsOutput->Mode->Info->HorizontalResolution;
|
|
mVerticalResolution = mGraphicsOutput->Mode->Info->VerticalResolution;
|
|
|
|
DebugL(L"Function(InitializeGUI) Selected Mode %d resolution is (%d * %d).\n ", Index, mHorizontalResolution, mVerticalResolution);
|
|
|
|
|
|
}
|
|
|
|
//
|
|
//init Truetype font support
|
|
//
|
|
Status = InitializeTrueTypeFont();
|
|
if (EFI_ERROR(Status)) {
|
|
DebugL(L"[BOKR_UI] InitializeTrueTypeFont Error\r\n");
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
/****************************************************************************************/
|
|
|
|
|
|
EFI_STATUS
|
|
DrawBatteryInfo(UINTN Percent,UINT8 ACStatus,UINT8 BattStatus)
|
|
{
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
|
|
RECT Rect;
|
|
UINT32 nColor,nBGColor;
|
|
CHAR16 strTemp0[64] = L"";
|
|
CHAR16 strTemp1[16] = L"";
|
|
|
|
if(Percent > 100){
|
|
DebugL(L"Function(DrawBatteryInfo) INVALID PARAMETER.\n ");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if(ACStatus >= MAX_AC_STATUS){
|
|
DebugL(L"Function(DrawBatteryInfo) INVALID PARAMETER.\n ");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if(BattStatus >= MAX_BATTERY_STATUS){
|
|
DebugL(L"Function(DrawBatteryInfo) INVALID PARAMETER.\n ");
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
|
|
if(Percent < 20)
|
|
nColor = RED_COLOR;
|
|
else
|
|
nColor = GREEN_COLOR;
|
|
nBGColor = BLACK_COLOR;
|
|
|
|
UnicodeSPrint (strTemp0, sizeof (strTemp0), L"%s,%s", StringsAcSatatus[ACStatus],StringsBattSatatus[BattStatus]);
|
|
SetRect(&Rect,
|
|
0,
|
|
0,
|
|
mHorizontalResolution,
|
|
mVerticalResolution*PERCENT_FONT_TOP_SIDE_SCALE);
|
|
|
|
TrueTypeDrawText(AC_BATT_INFO_FONT_SIZE,
|
|
(EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nColor,
|
|
(EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nBGColor,
|
|
strTemp0,
|
|
&Rect,
|
|
FRONT_STYLE_MIDLLE_CENTER,
|
|
FALSE
|
|
);
|
|
|
|
UnicodeSPrint (strTemp1, sizeof (strTemp1), L"%02d%%", Percent);
|
|
SetRect(&Rect,
|
|
0,
|
|
mVerticalResolution*PERCENT_FONT_TOP_SIDE_SCALE,
|
|
mHorizontalResolution,
|
|
mVerticalResolution*PERCENT_FONT_BOTTOM_SIDE_SCALE);
|
|
|
|
TrueTypeDrawText(PERCENT_FONT_SIZE,
|
|
(EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nColor,
|
|
(EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nBGColor,
|
|
strTemp1,
|
|
&Rect,
|
|
FRONT_STYLE_MIDLLE_CENTER,
|
|
FALSE
|
|
);
|
|
|
|
DebugL(L"Function(DrawBatteryInfo) End.\n ");
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
EFI_STATUS
|
|
DrawBattery(UINTN Percent)
|
|
{
|
|
EFI_STATUS Status = EFI_SUCCESS;
|
|
|
|
RECT Rect;
|
|
UINT32 nColor;
|
|
|
|
UINTN i = 0;
|
|
|
|
DebugL(L"Function(DrawBattery) Start.\n ");
|
|
DebugL(L"Function(DrawBattery) resolution is (%d * %d).\n ", mHorizontalResolution, mVerticalResolution);
|
|
|
|
if(Percent < 20)
|
|
nColor = RED_COLOR;
|
|
else
|
|
nColor = GREEN_COLOR;
|
|
|
|
SetRect(&Rect,mHorizontalResolution*BATT_LEFT_SIDE_SCALE-BATT_HULL, mVerticalResolution*BATT_TOP_SIDE_SCALE-BATT_HULL,
|
|
mHorizontalResolution*BATT_RIGHT_SIDE_SCALE+BATT_HULL, mVerticalResolution*BATT_BOTTOM_SIDE_SCALE+BATT_HULL);
|
|
DisplayBitBlt((EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nColor,EfiBltVideoFill,&Rect);
|
|
|
|
SetRect(&Rect,mHorizontalResolution*BATT_RIGHT_SIDE_SCALE+BATT_HULL, (mVerticalResolution*BATT_TOP_SIDE_SCALE+mVerticalResolution*BATT_BOTTOM_SIDE_SCALE)/2-BATT_CAP_HALF_WIDTH,
|
|
mHorizontalResolution*BATT_RIGHT_SIDE_SCALE+BATT_HULL+BATT_CAP_LENGTH, (mVerticalResolution*BATT_TOP_SIDE_SCALE+mVerticalResolution*BATT_BOTTOM_SIDE_SCALE)/2+BATT_CAP_HALF_WIDTH);
|
|
DisplayBitBlt((EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nColor,EfiBltVideoFill,&Rect);
|
|
|
|
/************************************************/
|
|
nColor = BLACK_COLOR;
|
|
|
|
SetRect(&Rect,mHorizontalResolution*BATT_LEFT_SIDE_SCALE, mVerticalResolution*BATT_TOP_SIDE_SCALE,
|
|
mHorizontalResolution*BATT_RIGHT_SIDE_SCALE, mVerticalResolution*BATT_TOP_SIDE_SCALE+BATT_GAP);
|
|
DisplayBitBlt((EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nColor,EfiBltVideoFill,&Rect);
|
|
|
|
SetRect(&Rect,mHorizontalResolution*BATT_LEFT_SIDE_SCALE, mVerticalResolution*BATT_BOTTOM_SIDE_SCALE-BATT_GAP,
|
|
mHorizontalResolution*BATT_RIGHT_SIDE_SCALE, mVerticalResolution*BATT_BOTTOM_SIDE_SCALE);
|
|
DisplayBitBlt((EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nColor,EfiBltVideoFill,&Rect);
|
|
|
|
SetRect(&Rect,mHorizontalResolution*BATT_LEFT_SIDE_SCALE+mHorizontalResolution*BATT_LEFT_SIDE_SCALE*Percent/100,
|
|
mVerticalResolution*1/2,
|
|
mHorizontalResolution*BATT_RIGHT_SIDE_SCALE,
|
|
mVerticalResolution*7/10);
|
|
DisplayBitBlt((EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nColor,EfiBltVideoFill,&Rect);
|
|
|
|
for(i=0;i<11;i++){
|
|
SetRect(&Rect,mHorizontalResolution*BATT_LEFT_SIDE_SCALE+mHorizontalResolution*BATT_LEFT_SIDE_SCALE*i/10,
|
|
mVerticalResolution*BATT_TOP_SIDE_SCALE,
|
|
mHorizontalResolution*BATT_LEFT_SIDE_SCALE+mHorizontalResolution*BATT_LEFT_SIDE_SCALE*i/10+BATT_GAP,
|
|
mVerticalResolution*BATT_BOTTOM_SIDE_SCALE);
|
|
DisplayBitBlt((EFI_GRAPHICS_OUTPUT_BLT_PIXEL *)&nColor,EfiBltVideoFill,&Rect);
|
|
}
|
|
|
|
|
|
DebugL(L"Function(DrawBattery) End.\n ");
|
|
return Status;
|
|
}
|
|
|
|
|
|
|