void get_string_piexl_rect(__string_show_info_t *show_info)
{
int len,i;
__u16 uni;
__u16 CharWidth;
__s32 char_size;
i = 0;
show_info->show_size.width = 0;
show_info->show_size.height = GUI_GetFontDistY();
len = eLIBs_strlen(show_info->name);
while( i < len )
{
char_size = esCHS_Char2Uni( show_info->encode_id, (__u8 *)show_info->name+i, len - i, &uni );
if( char_size <= 0 )
{
break;
}
CharWidth = GUI_GetCharDistX(uni);
show_info->show_size.width += CharWidth;
i += char_size;
}
return;
}
/*********************************************************************
*
* GUIDEMO_ShowIntro
*
* This function has to be called by every sample
*/
void GUIDEMO_ShowIntro(const char * acTitle, const char * acDescription) {
int xSize, ySize, xCenter, yCenter, FontDistY, TimeWait, i;
xSize = LCD_GetXSize();
ySize = LCD_GetYSize();
xCenter = xSize >> 1;
yCenter = ySize >> 1;
GUIDEMO_HideInfoWin();
GUIDEMO_ShowControlWin();
GUI_Exec();
GUIDEMO_DrawBk(1);
GUI_SetColor(GUI_WHITE);
//
// Title
//
GUI_SetTextMode(GUI_TM_TRANS);
GUI_SetFont(&GUI_FontRounded22);
GUI_DispStringHCenterAt(acTitle, xCenter, 60);
//
// Description
//
GUI_SetFont(&GUI_FontSouvenir18);
FontDistY = GUI_GetFontDistY();
GUI_DispStringHCenterAt(acDescription, xCenter, yCenter - FontDistY + 10);
//
// Determine time to wait
//
i = 0;
while (acDescription[i]) {
i++;
}
TimeWait = i * 80;
GUIDEMO_Wait(TimeWait);
}
void local_get_string_piexl_rect( const char *str, __string_show_info_t *show_info,SIZE *size)
{
int len,i;
__u16 uni;
__u16 CharWidth;
__s32 char_size;
i = 0;
size->width = 0;
len = eLIBs_strlen(str);
size->height = GUI_GetFontDistY();
while( i < len )
{
char_size = esCHS_Char2Uni( show_info->encode_id, (__u8 *)str+i, len - i, &uni );
if( char_size <= 0 )
break;
CharWidth = GUI_GetCharDistX(uni);
size->width += CharWidth;
i += char_size;
}
return;
}
/*********************************************************************
*
* GUI_DispString
*/
void GUI_DispString(const char GUI_UNI_PTR *s) {
int xAdjust, yAdjust, xOrg;
int FontSizeY;
if (!s)
return;
GUI_LOCK();
FontSizeY = GUI_GetFontDistY();
xOrg = GUI_Context.DispPosX;
/* Adjust vertical position */
yAdjust = GUI_GetYAdjust();
GUI_Context.DispPosY -= yAdjust;
for (; *s; s++) {
GUI_RECT r;
int LineNumChars = GUI__GetLineNumChars(s, 0x7fff);
int xLineSize = GUI__GetLineDistX(s, LineNumChars);
/* Check if x-position needs to be changed due to h-alignment */
switch (GUI_Context.TextAlign & GUI_TA_HORIZONTAL) {
case GUI_TA_CENTER: xAdjust = xLineSize / 2; break;
case GUI_TA_RIGHT: xAdjust = xLineSize; break;
default: xAdjust = 0;
}
r.x0 = GUI_Context.DispPosX -= xAdjust;
r.x1 = r.x0 + xLineSize - 1;
r.y0 = GUI_Context.DispPosY;
r.y1 = r.y0 + FontSizeY - 1;
GUI__DispLine(s, LineNumChars, &r);
GUI_Context.DispPosY = r.y0;
s += GUI_UC__NumChars2NumBytes(s, LineNumChars);
if ((*s == '\n') || (*s == '\r')) {
switch (GUI_Context.TextAlign & GUI_TA_HORIZONTAL) {
case GUI_TA_CENTER:
case GUI_TA_RIGHT:
GUI_Context.DispPosX = xOrg;
break;
default:
GUI_Context.DispPosX = GUI_Context.LBorder;
break;
}
if (*s == '\n')
GUI_Context.DispPosY += FontSizeY;
} else {
GUI_Context.DispPosX = r.x0 + xLineSize;
}
if (*s == 0) /* end of string (last line) reached ? */
break;
}
GUI_Context.DispPosY += yAdjust;
GUI_Context.TextAlign &= ~GUI_TA_HORIZONTAL;
GUI_UNLOCK();
}
static void _DispStringInRect(const char GUI_FAR *s, GUI_RECT* pRect, int TextAlign) {
GUI_RECT r;
GUI_RECT rLine;
int y = 0;
int NumLines;
const char *sOrg =s;
int FontYSize;
int xLine = 0;
FontYSize = GUI_GetFontSizeY();
if (pRect) {
r = *pRect;
} else {
GUI_GetClientRect(&r);
}
/* Count the number of lines for vertical alignment */
for (NumLines=1; ;NumLines++) {
int LineLen= GUI__GetLineLen(s,0x7fff);
s += LineLen;
if (GUI__HandleEOLine(&s))
break;
}
/* Do the vertical alignment */
switch (TextAlign & GUI_TA_VERTICAL) {
case GUI_TA_TOP:
y = r.y0;
break;
case GUI_TA_BASELINE:
case GUI_TA_BOTTOM:
y = r.y1 -NumLines * FontYSize+1;
break;
case GUI_TA_VCENTER:
y = r.y0+(r.y1-r.y0+1 -NumLines * FontYSize) /2;
break;
}
for (s=sOrg; ;) {
int LineLen= GUI__GetLineLen(s,0x7fff);
int xLineSize = GUI_GetLineDistX(s, LineLen);
switch (TextAlign & GUI_TA_HORIZONTAL) {
case GUI_TA_HCENTER:
xLine = r.x0+(r.x1-r.x0-xLineSize)/2; break;
case GUI_TA_LEFT:
xLine = r.x0; break;
case GUI_TA_RIGHT:
xLine = r.x1 -xLineSize;
}
rLine.x0 = GUI_Context.DispPosX = xLine;
rLine.x1 = rLine.x0 + xLineSize-1;
rLine.y0 = GUI_Context.DispPosY = y;
rLine.y1 = y + FontYSize-1;
GUI__DispLine(s, LineLen, &rLine);
s += LineLen;
y += GUI_GetFontDistY();
if (GUI__HandleEOLine(&s))
break;
}
}
/*********************************************************************
*
* _GetItemSizeY
*/
static int _GetItemSizeY(WM_HWIN hWin, int ItemIndex) {
int DistY;
DistY = GUI_GetFontDistY() + 1;
if (LISTBOX_GetMulti(hWin)) {
if (LISTBOX_GetItemSel(hWin, ItemIndex)) {
DistY += 8;
}
} else if (LISTBOX_GetSel(hWin) == ItemIndex) {
DistY += 8;
}
return DistY;
}
/*********************************************************************
*
* GUI_UC_DispString
*/
void GUI_UC_DispString(const U16 GUI_UNI_PTR *s) {
int xAdjust, yAdjust, xOrg;
int FontSizeY;
if (!s)
return;
GUI_LOCK();
FontSizeY = GUI_Context.pAFont->YSize;
xOrg = GUI_Context.DispPosX[GUI_Context.SelLayer];
/* Adjust vertical position */
yAdjust = GUI_GetYAdjust();
GUI_Context.DispPosY[GUI_Context.SelLayer] -= yAdjust;
for (; *s; s++) {
GUI_RECT r;
int LineLen= _GetLineLen(s,0x7fff);
int xLineSize = _GetLineDistX(s, LineLen);
/* Check if x-position needs to be changed due to h-alignment */
switch (GUI_Context.TextAlign & GUI_TA_HORIZONTAL) {
case GUI_TA_CENTER: xAdjust= xLineSize/2; break;
case GUI_TA_RIGHT: xAdjust= xLineSize; break;
default: xAdjust= 0;
}
r.x0 = GUI_Context.DispPosX[GUI_Context.SelLayer] -= xAdjust;
r.x1 = r.x0 + xLineSize-1;
r.y0 = GUI_Context.DispPosY[GUI_Context.SelLayer];
r.y1 = r.y0 + FontSizeY-1;
_DispLine(s, LineLen, &r);
GUI_Context.DispPosY[GUI_Context.SelLayer] = r.y0;
s += LineLen;
if (*s=='\n') {
switch (GUI_Context.TextAlign & GUI_TA_HORIZONTAL) {
case GUI_TA_CENTER:
case GUI_TA_RIGHT:
GUI_Context.DispPosX[GUI_Context.SelLayer] = xOrg;
break;
default:
GUI_Context.DispPosX[GUI_Context.SelLayer] = GUI_Context.LBorder;
break;
}
GUI_Context.DispPosY[GUI_Context.SelLayer] += GUI_GetFontDistY();
} else {
GUI_Context.DispPosX[GUI_Context.SelLayer] = r.x0+xLineSize;
}
if (*s==0) /* end of string (last line) reached ? */
break;
}
GUI_Context.DispPosY[GUI_Context.SelLayer] += yAdjust;
GUI_Context.TextAlign &= ~GUI_TA_HORIZONTAL;
GUI_UNLOCK();
}
/*********************************************************************
*
* GUI__CalcTextRect
*/
void GUI__CalcTextRect(const char GUI_UNI_PTR* pText, const GUI_RECT* pTextRectIn, GUI_RECT* pTextRectOut, int TextAlign) {
if (pText) {
int xPos, yPos, TextWidth, TextHeight;
/* Calculate X-pos of text */
TextWidth = GUI_GetStringDistX(pText);
switch (TextAlign & GUI_TA_HORIZONTAL) {
case GUI_TA_HCENTER:
xPos = pTextRectIn->x0 + ((pTextRectIn->x1 - pTextRectIn->x0 + 1) - TextWidth) / 2;
break;
case GUI_TA_RIGHT:
xPos = pTextRectIn->x1 - TextWidth + 1;
break;
default:
xPos = pTextRectIn->x0;
}
/* Calculate Y-pos of text*/
TextHeight = GUI_GetFontDistY();
switch (TextAlign & GUI_TA_VERTICAL) {
case GUI_TA_VCENTER:
yPos = pTextRectIn->y0 + ((pTextRectIn->y1 - pTextRectIn->y0 + 1) - TextHeight) / 2;
break;
case GUI_TA_BOTTOM:
yPos = pTextRectIn->y1 - TextHeight + 1;
break;
case GUI_TA_BASELINE:
default:
yPos = pTextRectIn->y0;
}
/* Return text rectangle */
pTextRectOut->x0 = xPos;
pTextRectOut->y0 = yPos;
pTextRectOut->x1 = xPos + TextWidth - 1;
pTextRectOut->y1 = yPos + TextHeight - 1;
} else {
*pTextRectOut = *pTextRectIn;
}
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(LISTBOX_Handle hObj) {
int i;
int Border;
GUI_RECT r;
int FontDistY;
LISTBOX_Obj* pObj = LISTBOX_H2P(hObj);
int NumItems = _GetNumItems(pObj);
const GUI_ConstString* ppText = pObj->ppText;
Border = pObj->Widget.pEffect->EffectSize;
GUI_SetFont(pObj->pFont);
FontDistY = GUI_GetFontDistY();
if (Border) {
GUI_SetBkColor(pObj->aBackColor[0]);
GUI_Clear();
}
/* Calculate rect used for painting (subtract border) */
WM_GetClientRect(&r);
r.x1 -= Border;
r.y1 -= Border;
r.y0 -= Border;
WM_SetUserClipArea(&r);
for (i = pObj->ScrollState.v; i < NumItems; i++) {
int y, ColorIndex;
y = Border + (i - pObj->ScrollState.v) * FontDistY;
if (i == pObj->Sel) {
ColorIndex = (pObj->Widget.State & WIDGET_STATE_FOCUS) ? 2 : 1;
} else {
ColorIndex = 0;
}
GUI_SetBkColor(pObj->aBackColor[ColorIndex]);
GUI_SetColor (pObj->aTextColor[ColorIndex]);
GUI_ClearRect(Border, y, Border, y + FontDistY -1);
GUI_DispStringAt(*(ppText+i), Border+1, y);
GUI_DispCEOL();
}
WM_SetUserClipArea(NULL);
/* Draw the 3D effect (if configured) */
WIDGET__EFFECT_DrawDown(&pObj->Widget);
}
/*********************************************************************
*
* _ShowCursorType
*/
static void _ShowCursorType(const CURSORTYPE_INFO* pCursorType, int x0, int y0) {
const GUI_CURSOR * pCursor;
char Char;
int yMax;
int yHot;
int i;
int x;
int y;
yMax = 0;
yHot = 0;
//
// Calculate height and width of biggest cursor
//
for (i = 0; i < NUM_CURSORS; i++) {
pCursor = pCursorType->aCursor[i].pCursor;
if (pCursor->pBitmap->YSize > yMax) {
yMax = pCursor->pBitmap->YSize;
yHot = pCursor->yHot;
}
}
GUI_SetFont(&GUI_FontRounded16);
#if (NUM_CURSORS != 3)
GUI_SetLBorder(x0);
#endif
GUI_DispStringAt(pCursorType->pType, x0, y0);
y0 += GUI_GetFontDistY() + 1;
GUI_SetFont(&GUI_Font13B_ASCII);
for (i = 0; i < NUM_CURSORS; i++) {
pCursor = pCursorType->aCursor[i].pCursor;
Char = pCursorType->aCursor[i].Size;
y = y0 + yHot - pCursor->yHot;
x = ((pCursor->pBitmap->XSize - GUI_GetCharDistX(Char)) / 2);
GUI_DrawBitmap(pCursor->pBitmap, x0 + XMAX * i + 5, y);
GUI_DispCharAt(Char, x0 + XMAX * i + 5 + x, y0 + yMax + 2);
}
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(EDIT_Obj* pObj) {
int PixelLen, xSize, ySize, xPosText = 0,
xPosCursor = 0, yPosText = 0, yPosCursor = 0, XSizeCursor, YSizeCursor;
int IsEnabled;
GUI_RECT rClient, rWindow;
char * s;
s = (char*) WM_HMEM2Ptr(pObj->hpText);
GUI_DEBUG_LOG("BUTTON: _Paint(..)\n");
if (pObj->Border) {
GUI_SetBkColor(pObj->aBkColor[0]);
GUI_Clear();
}
IsEnabled = WIDGET__IsEnabled(&pObj->Widget);
/* Set clipping rectangle */
WIDGET__GetInsideRect(&pObj->Widget, &rWindow);
WM_SetUserClipRect(&rWindow);
/* Calculate size */
GUI_GetClientRect(&rClient);
xSize = rClient.x1 - rClient.x0 + 1;
ySize = rClient.y1 - rClient.y0 + 1;
/* Draw background */
GUI_SetBkColor (pObj->aBkColor[IsEnabled]);
GUI_SetColor (pObj->aTextColor[0]);
GUI_Clear();
/* Calculate length */
GUI_SetFont (pObj->pFont);
PixelLen = GUI_GetStringDistX(s);
/* Calculate size of cursor */
YSizeCursor = GUI_GetFontDistY();
if (pObj->EditMode == GUI_EDIT_MODE_INSERT) {
if (pObj->XSizeCursor != 0) {
XSizeCursor = pObj->XSizeCursor;
} else {
XSizeCursor = GUI_GetCharDistX(' ');
}
} else {
if (pObj->CursorPos < (int)strlen(s)) {
XSizeCursor = GUI_GetCharDistX(*(s + pObj->CursorPos));
} else {
XSizeCursor = pObj->XSizeCursor;
}
}
/* Calculate X-pos */
switch (pObj->Align & GUI_TA_HORIZONTAL) {
case GUI_TA_CENTER:
xPosCursor = (xSize - PixelLen + 1) / 2;
xPosText = xSize / 2;
break;
case GUI_TA_LEFT:
xPosCursor = pObj->Border + EDIT_XOFF;
xPosText = pObj->Border + EDIT_XOFF;
break;
case GUI_TA_RIGHT:
xPosCursor = xSize - (pObj->Border + EDIT_XOFF) - PixelLen;
xPosText = xSize - (pObj->Border + EDIT_XOFF);
break;
}
/* Calculate Y-pos */
switch (pObj->Align & GUI_TA_VERTICAL) {
case GUI_TA_TOP:
yPosCursor = 0;
yPosText = 0;
break;
case GUI_TA_BOTTOM:
yPosCursor = ySize - YSizeCursor;
yPosText = ySize;
break;
case GUI_TA_VCENTER:
yPosCursor = (ySize - YSizeCursor + 1) / 2;
yPosText = ySize / 2;
break;
}
/* Display text */
GUI_SetTextAlign(pObj->Align);
GUI_DispStringAt(s, xPosText, yPosText);
/* Display cursor */
if (pObj->Widget.State & WIDGET_STATE_FOCUS) {
int i;
for (i = 0; i != pObj->CursorPos; i++) {
xPosCursor += GUI_GetCharDistX(*(s + i));
}
GUI_InvertRect(xPosCursor,
yPosCursor,
xPosCursor + XSizeCursor - 1,
yPosCursor + YSizeCursor - 1);
}
WM_SetUserClipRect(NULL);
/* Draw the 3D effect (if configured) */
WIDGET__EFFECT_DrawDown(&pObj->Widget);
}
/*********************************************************************
*
* GUI__DispStringInRect
*/
void GUI__DispStringInRect(const char GUI_UNI_PTR *s, GUI_RECT* pRect, int TextAlign, int MaxNumChars) {
GUI_RECT r;
GUI_RECT rLine;
int y = 0;
const char GUI_UNI_PTR *sOrg =s;
int FontYSize;
int xLine = 0;
int LineLen;
int NumCharsRem; /* Number of remaining characters */
FontYSize = GUI_GetFontSizeY();
if (pRect) {
r = *pRect;
} else {
GUI_GetClientRect(&r);
}
/* handle vertical alignment */
if ((TextAlign & GUI_TA_VERTICAL) == GUI_TA_TOP) {
y = r.y0;
} else {
int NumLines;
/* Count the number of lines */
for (NumCharsRem = MaxNumChars, NumLines = 1; NumCharsRem ;NumLines++) {
LineLen = GUI__GetLineNumChars(s, NumCharsRem);
if(LineLen == 0)
{
break;
}
NumCharsRem -= LineLen;
s += GUI_UC__NumChars2NumBytes(s, LineLen);
if (GUI__HandleEOLine(&s))
break;
}
/* Do the vertical alignment */
switch (TextAlign & GUI_TA_VERTICAL) {
case GUI_TA_BASELINE:
case GUI_TA_BOTTOM:
y = r.y1 -NumLines * FontYSize+1;
break;
case GUI_TA_VCENTER:
y = r.y0+(r.y1-r.y0+1 -NumLines * FontYSize) /2;
break;
}
}
/* Output string */
for (NumCharsRem = MaxNumChars, s = sOrg; NumCharsRem;) {
int xLineSize;
LineLen = GUI__GetLineNumChars(s, NumCharsRem);
if(LineLen == 0)
{
break;
}
NumCharsRem -= LineLen;
xLineSize = GUI__GetLineDistX(s, LineLen);
switch (TextAlign & GUI_TA_HORIZONTAL) {
case GUI_TA_HCENTER:
xLine = r.x0+(r.x1-r.x0-xLineSize)/2; break;
case GUI_TA_LEFT:
xLine = r.x0; break;
case GUI_TA_RIGHT:
xLine = r.x1 -xLineSize + 1;
}
rLine.x0 = GUI_Context.DispPosX[GUI_Context.SelLayer] = xLine;
rLine.x1 = rLine.x0 + xLineSize-1;
rLine.y0 = GUI_Context.DispPosY[GUI_Context.SelLayer] = y;
rLine.y1 = y + FontYSize-1;
GUI__DispLine(s, LineLen, &rLine);
s += GUI_UC__NumChars2NumBytes(s, LineLen);
y += GUI_GetFontDistY();
if (GUI__HandleEOLine(&s))
break;
}
}
/*********************************************************************
*
* _OnPaint
*
* Purpose:
* Paints the RADIO button.
* The button can actually consist of multiple buttons (NumItems).
* The focus rectangle will be drawn on top of the text if any text is set,
* otherwise around the entire buttons.
*/
static void _OnPaint(RADIO_Handle hObj, RADIO_Obj* pObj) {
const GUI_BITMAP* pBmRadio;
const GUI_BITMAP* pBmCheck;
const char* pText;
GUI_FONTINFO FontInfo;
GUI_RECT Rect, r, rFocus = {0};
int i, y, HasFocus, FontDistY;
U8 SpaceAbove, CHeight, FocusBorder;
/* Init some data */
WIDGET__GetClientRect(&pObj->Widget, &rFocus);
HasFocus = (pObj->Widget.State & WIDGET_STATE_FOCUS) ? 1 : 0;
pBmRadio = pObj->apBmRadio[WM__IsEnabled(hObj)];
pBmCheck = pObj->pBmCheck;
rFocus.x1 = pBmRadio->XSize + RADIO_BORDER * 2 - 1;
rFocus.y1 = pObj->Height + ((pObj->NumItems - 1) * pObj->Spacing) - 1;
/* Select font and text color */
LCD_SetColor(pObj->TextColor);
GUI_SetFont(pObj->pFont);
GUI_SetTextMode(GUI_TM_TRANS);
/* Get font infos */
GUI_GetFontInfo(pObj->pFont, &FontInfo);
FontDistY = GUI_GetFontDistY();
CHeight = FontInfo.CHeight;
SpaceAbove = FontInfo.Baseline - CHeight;
Rect.x0 = pBmRadio->XSize + RADIO_BORDER * 2 + 2;
Rect.y0 = (CHeight <= pObj->Height) ? ((pObj->Height - CHeight) / 2) : 0;
Rect.y1 = Rect.y0 + CHeight - 1;
FocusBorder = (FontDistY <= 12) ? 2 : 3;
if (Rect.y0 < FocusBorder) {
FocusBorder = Rect.y0;
}
/* Clear inside ... Just in case */
/* Fill with parents background color */
#if WM_SUPPORT_TRANSPARENCY
if (!WM_GetHasTrans(hObj))
#endif
{
if (pObj->BkColor != GUI_INVALID_COLOR) {
LCD_SetBkColor(pObj->BkColor);
} else {
LCD_SetBkColor(RADIO_DEFAULT_BKCOLOR);
}
GUI_Clear();
}
/* Iterate over all items */
for (i = 0; i < pObj->NumItems; i++) {
y = i * pObj->Spacing;
/* Draw the radio button bitmap */
GUI_DrawBitmap(pBmRadio, RADIO_BORDER, RADIO_BORDER + y);
/* Draw the check bitmap */
if (pObj->Sel == i) {
GUI_DrawBitmap(pBmCheck, RADIO_BORDER + (pBmRadio->XSize - pBmCheck->XSize) / 2,
RADIO_BORDER + ((pBmRadio->YSize - pBmCheck->YSize) / 2) + y);
}
/* Draw text if available */
pText = (const char*)GUI_ARRAY_GetpItem(&pObj->TextArray, i);
if (pText) {
if (*pText) {
r = Rect;
r.x1 = r.x0 + GUI_GetStringDistX(pText) - 2;
GUI_MoveRect(&r, 0, y);
GUI_DispStringAt(pText, r.x0, r.y0 - SpaceAbove);
/* Calculate focus rect */
if (HasFocus && (pObj->Sel == i)) {
_ResizeRect(&rFocus, &r, FocusBorder);
}
}
}
}
/* Draw the focus rect */
if (HasFocus) {
LCD_SetColor(GUI_BLACK);
WIDGET__DrawFocusRect(&pObj->Widget, &rFocus, 0);
}
}
/*********************************************************************
*
* GUI_DispNextLine
*/
void GUI_DispNextLine(void) {
GUI_LOCK();
GUI_Context.DispPosY += GUI_GetFontDistY();
GUI_Context.DispPosX = GUI_Context.LBorder;
GUI_UNLOCK();
}
/*********************************************************************
*
* _OwnerDraw
*
* Purpose:
* This is the owner draw function.
* It allows complete customization of how the items in the listbox are
* drawn. A command specifies what the function should do;
* The minimum is to react to the draw command (WIDGET_ITEM_DRAW);
* If the item x-size differs from the default, then this information
* needs to be returned in reaction to WIDGET_ITEM_GET_XSIZE.
* To insure compatibility with future version, all unhandled commands
* must call the default routine LISTBOX_OwnerDraw.
*/
static int _OwnerDraw(const WIDGET_ITEM_DRAW_INFO * pDrawItemInfo) {
WM_HWIN hWin;
int Index;
hWin = pDrawItemInfo->hWin;
Index = pDrawItemInfo->ItemIndex;
switch (pDrawItemInfo->Cmd) {
case WIDGET_ITEM_GET_XSIZE:
return _GetItemSizeX(hWin, Index);
case WIDGET_ITEM_GET_YSIZE:
return _GetItemSizeY(hWin, Index);
case WIDGET_ITEM_DRAW:
{
int MultiSel, Sel, YSize, FontDistY;
int IsDisabled, IsSelected;
int ColorIndex = 0;
char acBuffer[100];
const GUI_BITMAP * pBm;
const GUI_FONT* pOldFont = 0;
GUI_COLOR aColor[4] = {GUI_BLACK, GUI_WHITE, GUI_WHITE, GUI_GRAY};
GUI_COLOR aBkColor[4] = {GUI_WHITE, GUI_GRAY, GUI_BLUE, 0xC0C0C0};
IsDisabled = LISTBOX_GetItemDisabled(pDrawItemInfo->hWin, pDrawItemInfo->ItemIndex);
IsSelected = LISTBOX_GetItemSel(hWin, Index);
MultiSel = LISTBOX_GetMulti(hWin);
Sel = LISTBOX_GetSel(hWin);
YSize = _GetItemSizeY(hWin, Index);
/* Calculate color index */
if (MultiSel) {
if (IsDisabled) {
ColorIndex = 3;
} else {
ColorIndex = (IsSelected) ? 2 : 0;
}
} else {
if (IsDisabled) {
ColorIndex = 3;
} else {
if (pDrawItemInfo->ItemIndex == Sel) {
ColorIndex = WM_HasFocus(pDrawItemInfo->hWin) ? 2 : 1;
} else {
ColorIndex = 0;
}
}
}
/* Draw item */
GUI_SetBkColor(aBkColor[ColorIndex]);
GUI_SetColor (aColor[ColorIndex]);
LISTBOX_GetItemText(pDrawItemInfo->hWin, pDrawItemInfo->ItemIndex, acBuffer, sizeof(acBuffer));
GUI_Clear();
if ((ColorIndex == 1) || (ColorIndex == 2)) {
pOldFont = GUI_SetFont(&GUI_Font13B_1);
}
FontDistY = GUI_GetFontDistY();
GUI_DispStringAt(acBuffer, pDrawItemInfo->x0 + bmSmilie0.XSize + 16, pDrawItemInfo->y0 + (YSize - FontDistY) / 2);
if (pOldFont) {
GUI_SetFont(pOldFont);
}
GUI_DispCEOL();
/* Draw bitmap */
pBm = MultiSel ? IsSelected ? &bmSmilie1 : &bmSmilie0 : (pDrawItemInfo->ItemIndex == Sel) ? &bmSmilie1 : &bmSmilie0;
GUI_DrawBitmap(pBm, pDrawItemInfo->x0 + 7, pDrawItemInfo->y0 + (YSize - pBm->YSize) / 2);
/* Draw focus rectangle */
if (MultiSel && (pDrawItemInfo->ItemIndex == Sel)) {
GUI_RECT rFocus;
GUI_RECT rInside;
WM_GetInsideRectEx(pDrawItemInfo->hWin, &rInside);
rFocus.x0 = pDrawItemInfo->x0;
rFocus.y0 = pDrawItemInfo->y0;
rFocus.x1 = rInside.x1;
rFocus.y1 = pDrawItemInfo->y0 + YSize - 1;
GUI_SetColor(GUI_WHITE - aBkColor[ColorIndex]);
GUI_DrawFocusRect(&rFocus, 0);
}
}
break;
default:
return LISTBOX_OwnerDraw(pDrawItemInfo);
}
return 0;
}
/*********************************************************************
*
* LISTBOX_OwnerDraw
*/
int LISTBOX_OwnerDraw(const WIDGET_ITEM_DRAW_INFO* pDrawItemInfo) {
switch (pDrawItemInfo->Cmd) {
case WIDGET_ITEM_GET_XSIZE: {
LISTBOX_Obj* pObj;
const GUI_FONT GUI_UNI_PTR* pOldFont;
const char* s;
int DistX;
pObj = LISTBOX_H2P(pDrawItemInfo->hWin);
pOldFont = GUI_SetFont(pObj->Props.pFont);
s = LISTBOX__GetpString(pObj, pDrawItemInfo->ItemIndex);
DistX = GUI_GetStringDistX(s);
GUI_SetFont(pOldFont);
return DistX;
}
case WIDGET_ITEM_GET_YSIZE: {
LISTBOX_Obj* pObj;
pObj = LISTBOX_H2P(pDrawItemInfo->hWin);
return GUI_GetYDistOfFont(pObj->Props.pFont) + pObj->ItemSpacing;
}
case WIDGET_ITEM_DRAW: {
LISTBOX_Obj* pObj;
LISTBOX_ITEM* pItem;
WM_HMEM hItem;
GUI_RECT r;
int FontDistY;
int ItemIndex = pDrawItemInfo->ItemIndex;
const char* s;
int ColorIndex;
char IsDisabled;
char IsSelected;
pObj = LISTBOX_H2P(pDrawItemInfo->hWin);
hItem = GUI_ARRAY_GethItem(&pObj->ItemArray, ItemIndex);
pItem = (LISTBOX_ITEM *)GUI_ALLOC_h2p(hItem);
WM_GetInsideRect(&r);
FontDistY = GUI_GetFontDistY();
/* Calculate color index */
IsDisabled = (pItem->Status & LISTBOX_ITEM_DISABLED) ? 1 : 0;
IsSelected = (pItem->Status & LISTBOX_ITEM_SELECTED) ? 1 : 0;
if (pObj->Flags & LISTBOX_SF_MULTISEL) {
if (IsDisabled) {
ColorIndex = 3;
} else {
ColorIndex = (IsSelected) ? 2 : 0;
}
} else {
if (IsDisabled) {
ColorIndex = 3;
} else {
if (ItemIndex == pObj->Sel) {
ColorIndex = (pObj->Widget.State & WIDGET_STATE_FOCUS) ? 2 : 1;
} else {
ColorIndex = 0;
}
}
}
/* Display item */
LCD_SetBkColor(pObj->Props.aBackColor[ColorIndex]);
LCD_SetColor (pObj->Props.aTextColor[ColorIndex]);
s = LISTBOX__GetpString(pObj, ItemIndex);
GUI_SetTextMode(GUI_TM_TRANS);
GUI_Clear();
GUI_DispStringAt(s, pDrawItemInfo->x0 + 1, pDrawItemInfo->y0);
/* Display focus rectangle */
if ((pObj->Flags & LISTBOX_SF_MULTISEL) && (ItemIndex == pObj->Sel)) {
GUI_RECT rFocus;
rFocus.x0 = pDrawItemInfo->x0;
rFocus.y0 = pDrawItemInfo->y0;
rFocus.x1 = r.x1;
rFocus.y1 = pDrawItemInfo->y0 + FontDistY - 1;
LCD_SetColor(GUI_WHITE - pObj->Props.aBackColor[ColorIndex]);
GUI_DrawFocusRect(&rFocus, 0);
}
return 0;
}
}
return 0;
}
/*********************************************************************
*
* GUI_DispStringInRectWrap
*/
void GUI_DispStringInRectWrap(const char GUI_UNI_PTR * s, GUI_RECT * pRect, int TextAlign, GUI_WRAPMODE WrapMode) {
const GUI_RECT * pOldClipRect;
GUI_RECT Rect;
int xSize, ySizeFont, NumBytesToNextLine, NumCharsDisp;
if (!s) {
return;
}
GUI_LOCK();
Rect = *pRect;
xSize = Rect.x1 - Rect.x0 + 1;
ySizeFont = GUI_GetFontDistY();
/* Vertical alignment */
if ((TextAlign & GUI_TA_VERTICAL) != GUI_TA_TOP) {
int NumLines = 0;
const char GUI_UNI_PTR * pText;
pText = s;
/* Count the number of lines */
do {
NumBytesToNextLine = GUI__WrapGetNumBytesToNextLine(pText, xSize, WrapMode);
pText += NumBytesToNextLine;
if (NumBytesToNextLine) {
NumLines++;
}
} while (NumBytesToNextLine);
/* Do the vertical alignment */
switch (TextAlign & GUI_TA_VERTICAL) {
case GUI_TA_BASELINE:
case GUI_TA_BOTTOM:
Rect.y0 = Rect.y1 - NumLines * ySizeFont + 1;
break;
case GUI_TA_VCENTER:
Rect.y0 = Rect.y0 + (Rect.y1 - Rect.y0 + 1 - NumLines * ySizeFont) / 2;
break;
}
}
pOldClipRect = GUI_SetClipRect(pRect);
do {
int xLineSize;
GUI_RECT RectText;
NumCharsDisp = GUI__WrapGetNumCharsDisp(s, xSize, WrapMode);
Rect.y1 = Rect.y0 + ySizeFont - 1;
RectText = Rect;
/* Horizontal alignment */
xLineSize = GUI__GetLineDistX(s, NumCharsDisp);
switch (TextAlign & GUI_TA_HORIZONTAL) {
case GUI_TA_HCENTER:
RectText.x0 = pRect->x0 + (pRect->x1 - pRect->x0 - xLineSize) / 2;
break;
case GUI_TA_LEFT:
RectText.x0 = pRect->x0;
break;
case GUI_TA_RIGHT:
RectText.x0 = pRect->x1 - xLineSize + 1;
break;
}
GUI__DispLine(s, NumCharsDisp, &RectText);
s += GUI__WrapGetNumBytesToNextLine(s, xSize, WrapMode);
Rect.y0 += ySizeFont;
} while (*s);
GUI_SetClipRect(pOldClipRect);
GUI_UNLOCK();
}