/*********************************************************************
*
* WM_GetInsideRectExScrollbar
*
Purpose:
Return the inside rectangle in client coordinates.
The inside rectangle is the client rectangle minus the effect,
which typically reduces the rectangle by 0 - 3 pixels on either side
(2 for the standard 3D effect).
*/
void WM_GetInsideRectExScrollbar(WM_HWIN hWin, GUI_RECT* pRect) {
GUI_RECT rWin, rInside, rScrollbar;
WM_HWIN hBarV, hBarH;
U16 WinFlags;
if (hWin) {
if (pRect) {
hBarH = WM_GetDialogItem(hWin, GUI_ID_HSCROLL);
hBarV = WM_GetDialogItem(hWin, GUI_ID_VSCROLL);
WM_GetWindowRectEx(hWin, &rWin); /* The entire window in screen coordinates */
WM_GetInsideRectEx(hWin, &rInside);
if (hBarV) {
WM_GetWindowRectEx(hBarV, &rScrollbar);
GUI_MoveRect(&rScrollbar, -rWin.x0, -rWin.y0);
WinFlags = WM_GetFlags(hBarV);
if ((WinFlags & WM_SF_ANCHOR_RIGHT) && (WinFlags & WM_SF_ISVIS)) {
rInside.x1 = rScrollbar.x0 - 1;
}
}
if (hBarH) {
WM_GetWindowRectEx(hBarH, &rScrollbar);
GUI_MoveRect(&rScrollbar, -rWin.x0, -rWin.y0);
WinFlags = WM_GetFlags(hBarH);
if ((WinFlags & WM_SF_ANCHOR_BOTTOM) && (WinFlags & WM_SF_ISVIS)) {
rInside.y1 = rScrollbar.y0 - 1;
}
}
*pRect = rInside;
}
}
}
/*********************************************************************
*
* _MoveDescendents
*
* Description
* Moves _MoveDescendents.
* Since the parent has already been moved, there is no need to
* take care of invalidation.
*
* Parameters
* hWin The first of all descendents to be moved (first child)
*/
static void _MoveDescendents(WM_HWIN hWin, int dx, int dy) {
WM_Obj* pWin;
for (;hWin; hWin = pWin->hNext) {
pWin = WM_HANDLE2PTR(hWin);
GUI_MoveRect(&pWin->Rect, dx, dy);
GUI_MoveRect(&pWin->InvalidRect, dx, dy);
_MoveDescendents(pWin->hFirstChild, dx, dy); /* Children need to be moved along ...*/
WM__SendMsgNoData(hWin, WM_MOVE);
}
}
/*********************************************************************
*
* _DrawScreen
*/
static void _DrawScreen(void) {
GUI_RECT Rect;
int yd;
GUI_DrawBitmap(&_bmSeggerLogo_50x25, 10, 10);
GUI_SetFont(GUI_FONT_20B_ASCII);
GUI_DispStringHCenterAt("Antialiased text sample", 190, 5);
GUI_SetFont(GUI_FONT_13_ASCII);
GUI_DispStringHCenterAt("Shows antialiased text on different backgrounds.", 190, 25);
Rect.x0 = 0;
Rect.y0 = 43;
Rect.x1 = 59;
Rect.y1 = Rect.y0 + 95;
yd = (Rect.y1 - Rect.y0) / 3;
//
// 4 bit antialiasing sample
//
_DrawText("Antialiased text\n (4 bpp)", &Rect);
GUI_SetFont(&_FontAA4_32);
_DrawSample(&Rect, yd);
//
// 2 bit antialiasing sample
//
GUI_MoveRect(&Rect, 0, 101);
_DrawText("Antialiased text\n (2 bpp)", &Rect);
GUI_SetFont(&_FontAA2_32);
_DrawSample(&Rect, yd);
}
WM_RESULT WM_DefaultProc(WM_MESSAGE* pMsg) {
WM_HWIN hWin = pMsg->hWin;
void *p = pMsg->Data.p;
WM_Obj* pWin = WM_H2P(hWin);
/* Exec message */
switch (pMsg->MsgId) {
case WM_GETORG:
((GUI_POINT*)p)->x = pWin->Rect.x0;
((GUI_POINT*)p)->y = pWin->Rect.y0;
break;
case WM_GETCLIENTRECT: /* return client window in window coordinates */
WM__GetClientRectWin(pWin, (GUI_RECT*)p);
break;
case WM_GETCLIENTRECT_ABS: /* return client window in absolute (screen) coordinates */
WM__GetClientRectWin(pWin, (GUI_RECT*)p);
GUI_MoveRect((GUI_RECT*)p, pWin->Rect.x0, pWin->Rect.y0);
break;
case WM_GET_CLIENT_WINDOW: /* return handle to client window. For most windows, there is no seperate client window, so it is the same handle */
pMsg->Data.v = hWin;
return; /* Message handled */
case WM_KEY:
WM_SendToParent(hWin, pMsg);
return; /* Message handled */
case WM_GET_BKCOLOR:
pMsg->Data.Color = GUI_INVALID_COLOR;
return; /* Message handled */
}
/* Message not handled. If it queries something, we return 0 to be on the safe side. */
pMsg->Data.v = 0;
pMsg->Data.p = 0;
}
static void _DrawNext(void) {
int UpdateRem = 1;
WM_HWIN iWin = (NextDrawWin == WM_HWIN_NULL) ? WM__FirstWin : NextDrawWin;
GUI_CONTEXT ContextOld;
GUI_SaveContext(&ContextOld);
/* Make sure the next window to redraw is valid */
for (; (iWin!=WM_HWIN_NULL) && UpdateRem; ) {
WM_Obj* pWin = WM_H2P(iWin);
if (pWin->Status & WM_SF_INVALID) {
U8 Status = (pWin->Status &= ~WM_SF_INVALID); /* Clear invalid flag */
WM__NumInvalidWindows--;
/* Send WM_PAINT if window is visible and a callback is defined */
if ((pWin->cb != NULL) && (Status & WM_SF_ISVIS)) {
WM_MESSAGE Msg;
Msg.hWin = iWin;
Msg.MsgId = WM_PAINT;
Msg.Data.p = (GUI_RECT*)&pWin->InvalidRect;
WM_SelectWindow(iWin);
WM_SetDefault();
#if GUI_SUPPORT_MEMDEV
if (Status & WM_SF_MEMDEV) {
GUI_RECT r = pWin->InvalidRect;
GUI_MoveRect (&r, pWin->Rect.x0, pWin->Rect.y0);
GUI_MEMDEV_Draw(&r, cbPaint, &Msg, 0, (Status & WM_SF_HASTRANS) ? GUI_MEMDEV_HASTRANS : 0);
} else
#endif
WM_SendMessage(iWin, &Msg);
UpdateRem--; /* Only the given number of windows at a time ... */
}
}
iWin = pWin->hNextLin;
}
NextDrawWin = iWin; /* Remember the window */
GUI_RestoreContext(&ContextOld);
}
/*********************************************************************
*
* WM_SetCaptureMove
*/
void WM_SetCaptureMove(WM_HWIN hWin, const GUI_PID_STATE* pState, int MinVisibility) {
if (!WM_HasCaptured(hWin)) {
WM_SetCapture(hWin, 1); /* Set capture with auto release */
WM__CapturePoint.x = pState->x;
WM__CapturePoint.y = pState->y;
} else { /* Moving ... let the window move ! */
int dx, dy;
dx = pState->x - WM__CapturePoint.x;
dy = pState->y - WM__CapturePoint.y;
/* make sure at least a part of the windows stays inside of its parent */
if (MinVisibility == 0) {
WM_MoveWindow(hWin, dx, dy);
} else {
GUI_RECT Rect, RectParent;
/* make sure at least a part of the windows stays inside of its parent */
WM_GetWindowRectEx(hWin, &Rect);
WM_GetWindowRectEx(WM_GetParent(hWin), &RectParent);
GUI_MoveRect(&Rect, dx, dy);
GUI__ReduceRect(&RectParent, &RectParent, MinVisibility);
if (GUI_RectsIntersect(&Rect, &RectParent)) {
WM_MoveWindow(hWin, dx, dy);
}
}
}
}
/* Invalidate, using desktop coordinates */
void WM_InvalidateBWinAbs(WM_HWIN hWin, const GUI_RECT*pRect) {
GUI_RECT r = *pRect;
WM_LOCK();
GUI_MoveRect(&r, -WM_H2P(hWin)->Rect.x0, -WM_H2P(hWin)->Rect.y0);
WM_InvalidateRect(hWin, &r);
WM_UNLOCK();
}
/*********************************************************************
*
* MYWIDGET_Callback
*/
void MYWIDGET_Callback(WM_MESSAGE * pMsg) {
MYWIDGET_Handle hWin;
GUI_PID_STATE * pState;
MYWIDGET_Obj MyWidget;
GUI_RECT WinRect;
int ColorIndex;
U8 Pressed;
hWin = pMsg->hWin;
WM_GetWindowRectEx(hWin, &WinRect);
GUI_MoveRect(&WinRect, -WinRect.x0, -WinRect.y0);
WM_GetUserData(hWin, &MyWidget, sizeof(MYWIDGET_Obj));
switch (pMsg->MsgId) {
case WM_PAINT:
if (WM_IsEnabled(hWin)) {
if (MyWidget.Pressed) {
ColorIndex = MYWIDGET_CI_PRESSED;
} else {
ColorIndex = MYWIDGET_CI_UNPRESSED;
}
} else {
ColorIndex = MYWIDGET_CI_DISABLED;
}
GUI_SetColor(MyWidget.aBkColor[ColorIndex]);
GUI_FillRectEx(&WinRect);
if (WM_HasFocus(hWin)) {
GUI_SetColor(MyWidget.FocusColor);
GUI_DrawRectEx(&WinRect);
}
GUI_SetColor(MyWidget.aTextColor[ColorIndex]);
GUI_SetTextMode(GUI_TM_TRANS);
GUI_DispStringInRect(MyWidget.pText, &WinRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
break;
case WM_TOUCH:
pState = (GUI_PID_STATE *)pMsg->Data.p;
if (pState) {
Pressed = pState->Pressed;
} else {
Pressed = 0;
}
if (MyWidget.Pressed != Pressed) {
MyWidget.Pressed = Pressed;
WM_SetUserData(hWin, &MyWidget, sizeof(MYWIDGET_Obj));
if (Pressed) {
WM_SetFocus(hWin);
}
WM_InvalidateWindow(hWin);
}
break;
case WM_SET_FOCUS:
if (pMsg->Data.v) {
pMsg->Data.v = 0;
}
WM_InvalidateWindow(hWin);
break;
default:
WM_DefaultProc(pMsg);
}
}
/*********************************************************************
*
* WM__MoveWindow
*/
void WM__MoveWindow(WM_HWIN hWin, int dx, int dy) {
GUI_RECT r;
WM_Obj* pWin;
if (hWin) {
pWin = WM_HANDLE2PTR(hWin);
r = pWin->Rect;
GUI_MoveRect(&pWin->Rect, dx, dy);
GUI_MoveRect(&pWin->InvalidRect, dx, dy);
_MoveDescendents(pWin->hFirstChild, dx, dy); /* Children need to be moved along ...*/
/* Invalidate old and new area ... */
if (pWin->Status & WM_SF_ISVIS) {
WM_InvalidateArea(&pWin->Rect); /* Invalidate new area */
WM_InvalidateArea(&r) ; /* Invalidate old area */
}
WM__SendMsgNoData(hWin, WM_MOVE); /* Notify window it has been moved */
}
}
/*********************************************************************
*
* _CalcPositions
*
* Calculates all positions required for drawing or for mouse / touch
* evaluation.
*/
static void _CalcPositions(SCROLLBAR_Obj* pObj, SCROLLBAR_POSITIONS* pPos) {
int xSizeArrow, xSize, xSizeMoveable, ThumbSize, NumItems, xSizeThumbArea;
WM_HWIN hWin;
GUI_RECT r, rSub;
int x0, y0;
r = pObj->Widget.Win.Rect;
x0 = r.x0;
y0 = r.y0;
pPos->x1 = (pObj->Widget.State & WIDGET_STATE_VERTICAL) ? r.y1 : r.x1;
/* Subtract the rectangle of the other scrollbar (if existing and visible) */
if (pObj->Widget.Id == GUI_ID_HSCROLL) {
hWin = WM_GetScrollbarV(pObj->Widget.Win.hParent);
if (hWin) {
WM_GetWindowRectEx(hWin, &rSub);
if (r.x1 == rSub.x1) {
r.x1 = rSub.x0 -1;
}
}
}
if (pObj->Widget.Id == GUI_ID_VSCROLL) {
hWin = WM_GetScrollbarH(pObj->Widget.Win.hParent);
if (hWin) {
WM_GetWindowRectEx(hWin, &rSub);
if (r.y1 == rSub.y1) {
r.y1 = rSub.y0 -1;
}
}
}
/* Convert coordinates of this window */
GUI_MoveRect(&r, -x0, -y0);
/* Convert real into virtual coordinates */
_WIDGET__RECT2VRECT(&pObj->Widget, &r);
NumItems = pObj->NumItems;
xSize = r.x1 - r.x0 + 1;
xSizeArrow = _GetArrowSize(pObj);
xSizeThumbArea= xSize - 2 * xSizeArrow; /* Number of pixels available for thumb and movement */
ThumbSize = GUI__DivideRound(xSizeThumbArea * pObj->PageSize, NumItems);
if (ThumbSize < 4) {
ThumbSize = 4;
}
if (ThumbSize > xSizeThumbArea) {
ThumbSize = xSizeThumbArea;
}
xSizeMoveable = xSizeThumbArea - ThumbSize;
pPos->x0_LeftArrow = r.x0;
pPos->x1_LeftArrow = xSizeArrow - 1;
pPos->x1_RightArrow = xSize - 1;
pPos->x0_RightArrow = xSize - xSizeArrow;
pPos->x0_Thumb = pPos->x1_LeftArrow + 1+ GUI__DivideRound(xSizeMoveable * pObj->v, NumItems - pObj->PageSize);
pPos->x1_Thumb = pPos->x0_Thumb + ThumbSize - 1;
pPos->xSizeMoveable = xSizeMoveable;
pPos->ThumbSize = ThumbSize;
}
/*********************************************************************
*
* _OnPaint
*/
static void _OnPaint(LISTBOX_Handle hObj, LISTBOX_Obj* pObj, WM_MESSAGE* pMsg) {
WIDGET_ITEM_DRAW_INFO ItemInfo;
GUI_RECT RectInside, RectItem, ClipRect;
int ItemDistY, NumItems, i;
NumItems = LISTBOX__GetNumItems(pObj);
GUI_SetFont(pObj->Props.pFont);
/* Calculate clipping rectangle */
ClipRect = *(const GUI_RECT*)pMsg->Data.p;
GUI_MoveRect(&ClipRect, -pObj->Widget.Win.Rect.x0, -pObj->Widget.Win.Rect.y0);
WM_GetInsideRectExScrollbar(hObj, &RectInside);
GUI__IntersectRect(&ClipRect, &RectInside);
RectItem.x0 = ClipRect.x0;
RectItem.x1 = ClipRect.x1;
/* Fill item info structure */
ItemInfo.Cmd = WIDGET_ITEM_DRAW;
ItemInfo.hWin = hObj;
ItemInfo.x0 = RectInside.x0 - pObj->ScrollStateH.v;
ItemInfo.y0 = RectInside.y0;
/* Do the drawing */
for (i = pObj->ScrollStateV.v; i < NumItems; i++) {
RectItem.y0 = ItemInfo.y0;
/* Break when all other rows are outside the drawing area */
if (RectItem.y0 > ClipRect.y1) {
break;
}
ItemDistY = _GetItemSizeY(hObj, pObj, i);
RectItem.y1 = RectItem.y0 + ItemDistY - 1;
/* Make sure that we draw only when row is in drawing area */
if (RectItem.y1 >= ClipRect.y0) {
/* Set user clip rect */
WM_SetUserClipArea(&RectItem);
/* Fill item info structure */
ItemInfo.ItemIndex = i;
/* Draw item */
if (pObj->pfDrawItem) {
pObj->pfDrawItem(&ItemInfo);
} else {
LISTBOX_OwnerDraw(&ItemInfo);
}
}
ItemInfo.y0 += ItemDistY;
}
WM_SetUserClipArea(NULL);
/* Calculate & clear 'data free' area */
RectItem.y0 = ItemInfo.y0;
RectItem.y1 = RectInside.y1;
LCD_SetBkColor(pObj->Props.aBackColor[0]);
GUI_ClearRectEx(&RectItem);
/* Draw the 3D effect (if configured) */
WIDGET__EFFECT_DrawDown(&pObj->Widget);
}
/*********************************************************************
*
* DROPDOWN_Expand
*/
void DROPDOWN_Expand(DROPDOWN_Handle hObj) {
int xSize, ySize, i, NumItems;
WM_HWIN hLst;
GUI_RECT r;
WM_HWIN hParent;
WM_Obj* pParent;
DROPDOWN_Obj* pObj;
if (hObj) {
WM_LOCK();
pObj = DROPDOWN_H2P(hObj);
if (pObj->hListWin == 0) {
hParent = WM_GetParent(hObj);
pParent = WM_H2P(hParent);
xSize = WM__GetWindowSizeX(&pObj->Widget.Win);
ySize = pObj->ySizeEx;
NumItems = _GetNumItems(pObj);
/* Get coordinates of window in client coordiantes of parent */
r = pObj->Widget.Win.Rect;
GUI_MoveRect(&r, -pParent->Rect.x0, -pParent->Rect.y0);
if (pObj->Flags & DROPDOWN_CF_UP) {
r.y0 -= ySize;
} else {
r.y0 = r.y1;
}
hLst = LISTBOX_CreateAsChild(NULL, WM_GetParent(hObj), r.x0, r.y0
, xSize, ySize, WM_CF_SHOW);
if (pObj->Flags & DROPDOWN_SF_AUTOSCROLLBAR) {
LISTBOX_SetScrollbarWidth(hLst, pObj->ScrollbarWidth);
LISTBOX_SetAutoScrollV(hLst, 1);
}
for (i = 0; i< NumItems; i++) {
LISTBOX_AddString(hLst, _GetpItem(pObj, i));
}
for (i = 0; i < GUI_COUNTOF(pObj->Props.aBackColor); i++) {
LISTBOX_SetBkColor(hLst, i, pObj->Props.aBackColor[i]);
}
for (i = 0; i < GUI_COUNTOF(pObj->Props.aTextColor); i++) {
LISTBOX_SetTextColor(hLst, i, pObj->Props.aTextColor[i]);
}
LISTBOX_SetItemSpacing(hLst, pObj->ItemSpacing);
LISTBOX_SetFont(hLst, pObj->Props.pFont);
WM_SetFocus(hLst);
pObj->hListWin = hLst;
LISTBOX_SetOwner(hLst, hObj);
LISTBOX_SetSel(hLst, pObj->Sel);
WM_NotifyParent(hObj, WM_NOTIFICATION_CLICKED);
}
WM_UNLOCK();
}
}
/*********************************************************************
*
* _cbMyWidget
*/
static void _cbMyWidget(WM_MESSAGE * pMsg) {
GUI_RECT WinRect;
char acText[20] = { 0 };
switch (pMsg->MsgId) {
case WM_PAINT:
MYWIDGET_Callback(pMsg);
MYWIDGET_GetUserData(pMsg->hWin, acText, sizeof(acText));
GUI_SetColor(GUI_WHITE);
GUI_SetTextMode(GUI_TM_TRANS);
WM_GetWindowRectEx(pMsg->hWin, &WinRect);
GUI_MoveRect(&WinRect, -WinRect.x0, -WinRect.y0);
GUI_DispStringInRect(acText, &WinRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
break;
default:
MYWIDGET_Callback(pMsg);
}
}
/*********************************************************************
*
* _FillPolygonAA
*/
static void _FillPolygonAA(const GUI_POINT* paPoint, int NumPoints, int x0, int y0) {
#if GUI_SUPPORT_AA
GUI_RECT r;
_CalcPolyRect(&r, paPoint, NumPoints);
GUI_MoveRect(&r, x0, y0);
if (GUI_Context.AA_HiResEnable) {
r.x0 /= GUI_Context.AA_Factor;
r.y0 /= GUI_Context.AA_Factor;
r.x1 = (r.x1 + GUI_Context.AA_Factor - 1) / GUI_Context.AA_Factor;
r.y1 = (r.y1 + GUI_Context.AA_Factor - 1) / GUI_Context.AA_Factor;
}
_MarkRect(r.x0, r.y0, r.x1, r.y1);
#else
GUI_USE_PARA(paPoint);
GUI_USE_PARA(NumPoints);
GUI_USE_PARA(x0);
GUI_USE_PARA(y0);
#endif
}
void WM_InvalidateRect(WM_HWIN hWin, const GUI_RECT*pRect) {
GUI_RECT r;
WM_Obj* pWin;
WM_LOCK();
pWin = WM_H2P(hWin);
WM__GetClientRectWin(pWin, &r);
if (pRect) {
GUI__IntersectRect(&r, pRect);
}
WM_InvalidateBWin1(hWin, &r);
/* Convert into absolute coordinates ... */
GUI_MoveRect (&r, pWin->Rect.x0, pWin->Rect.y0);
/* Make sure windows below are invalidated if this one is transparent */
if (pWin->Status & WM_SF_HASTRANS) {
ResetNextDrawWin();
WM__InvalidateAreaBelow(&r, hWin);
}
/* Invalidate the transparent ones above */
WM__InvalidateTransAreaAbove(&r,hWin);
WM_UNLOCK();
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(xIconSelBtn_Handle hWin)
{
GUI_RECT WinRect;
xIconSelBtn_OBJ tWidget;
GUI_CONST_STORAGE GUI_BITMAP* pBMP;
int xSize, ySize;
if(!hWin) return;
DEBUGOUT("xIconSelBtn hWin = 0x%08x\r\n", hWin);
WM_GetWindowRectEx(hWin, &WinRect);
GUI_MoveRect(&WinRect, -WinRect.x0, -WinRect.y0);
DEBUGOUT("xIconSelBtn Paint(%d,%d,%d,%d)\r\n",WinRect.x0, WinRect.y0, WinRect.x1, WinRect.y1);
BUTTON_GetUserData(hWin, &tWidget, sizeof(xIconSelBtn_OBJ));
tWidget.hThis = hWin;
BUTTON_SetUserData(hWin, &tWidget, sizeof(xIconSelBtn_OBJ));
if(tWidget.pBkBMP)
{
GUI_DrawBitmap(tWidget.pBkBMP, WinRect.x0, WinRect.y0);
}
else
{
//Draw Window Frame Outline, and Background.
GUI_SetColor(tWidget.aBkColor[0]);
//Draw Window Frame Outline, and Background.
GUI_FillRoundedRect(WinRect.x0, WinRect.y0, WinRect.x1, WinRect.y1, 1);
}
xSize = WinRect.x1 - WinRect.x0;
ySize = WinRect.y1 - WinRect.y0;
pBMP = tWidget.xIconArray[tWidget.SelectedIndex].pBMP;
if(pBMP)
{
//Draw BMP in H & V center
GUI_DrawBitmap(pBMP, WinRect.x0 + (xSize - pBMP->XSize)/2 , WinRect.y0 + (ySize - pBMP->YSize)/2 );
}
}
/*********************************************************************
*
* Framewin Callback
*/
static void _FRAMEWIN_Callback (WM_MESSAGE *pMsg) {
FRAMEWIN_Handle hWin = (FRAMEWIN_Handle)(pMsg->hWin);
FRAMEWIN_Obj* pObj = FRAMEWIN_H2P(hWin);
GUI_RECT* pRect = (GUI_RECT*)(pMsg->Data.p);
switch (pMsg->MsgId) {
case WM_PAINT:
_Paint(pObj);
break;
case WM_TOUCH:
_OnTouch(hWin, pObj, pMsg);
return; /* Return here ... Message handled */
case WM_GETCLIENTRECT:
*pRect = pObj->rClient;
return; /* Return here ... Message handled */
case WM_GETCLIENTRECT_ABS: /* Do not seperate from WM_GETCLIENTRECT !!! */
*pRect = pObj->rClient;
GUI_MoveRect(pRect, pObj->Widget.Win.Rect.x0, pObj->Widget.Win.Rect.y0);
return; /* Return here ... Message handled */
case WM_GET_CLIENT_WINDOW: /* return handle to client window. For most windows, there is no seperate client window, so it is the same handle */
pMsg->Data.v = pObj->hClient;
return; /* Return here ... Message handled */
case WM_GET_FOCUSSED_CHILD:
pMsg->Data.v = pObj->hFocussedChild;
return; /* Return here ... Message handled */
case WM_SET_FOCUS:
if (pMsg->Data.v == 1) {
WM_SetFocus(pObj->hFocussedChild);
} else {
WM_SetFocus(0);
}
return;
}
/* Let widget handle the standard messages */
if (WIDGET_HandleActive(hWin, pMsg) == 0) {
return;
}
WM_DefaultProc(pMsg);
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(LISTVIEW_Handle hObj, LISTVIEW_Obj* pObj, WM_MESSAGE* pMsg) {
const LISTVIEW_ROW* pRow;
GUI_RECT ClipRect, Rect;
int NumRows, NumVisRows, NumColumns;
int LBorder, RBorder, EffectSize;
int xPos, yPos, Width, RowDistY;
int Align, i, j, EndRow;
/* Init some values */
NumColumns = LISTVIEW__GetNumColumns(pObj);
NumRows = LISTVIEW__GetNumRows(pObj);
NumVisRows = _GetNumVisibleRows(hObj, pObj);
RowDistY = LISTVIEW__GetRowDistY(pObj);
LBorder = pObj->LBorder;
RBorder = pObj->RBorder;
EffectSize = pObj->Widget.pEffect->EffectSize;
yPos = HEADER_GetHeight(pObj->hHeader) + EffectSize;
/* Calculate clipping rectangle */
ClipRect = *(const GUI_RECT*)pMsg->Data.p;
GUI_MoveRect(&ClipRect, -pObj->Widget.Win.Rect.x0, -pObj->Widget.Win.Rect.y0);
WM_GetInsideRectExScrollbar(hObj, &Rect);
GUI__IntersectRect(&ClipRect, &Rect);
/* Set drawing color, font and text mode */
LCD_SetColor(pObj->Props.aTextColor[0]);
GUI_SetFont(pObj->Props.pFont);
GUI_SetTextMode(GUI_TM_TRANS);
/* Sort before drawing, because scroll position may change */
if (pObj->hSort && (pObj->SortIndex >= 0)) {
LISTVIEW_SORT * pSort;
pSort = (LISTVIEW_SORT *)GUI_ALLOC_h2p(pObj->hSort);
if (pSort->fpSort(hObj)) {
return; /* Return on error */
}
}
/* Calculate end row after sorting, because scroll position may have changed */
EndRow = pObj->ScrollStateV.v + (((NumVisRows + 1) > NumRows) ? NumRows : NumVisRows + 1);
/* Do the drawing */
for (i = pObj->ScrollStateV.v; i < EndRow; i++) {
pRow = _GetpRow(pObj, i);
if (pRow) {
Rect.y0 = yPos;
/* Break when all other rows are outside the drawing area */
if (Rect.y0 > ClipRect.y1) {
break;
}
Rect.y1 = yPos + RowDistY - 1;
/* Make sure that we draw only when row is in drawing area */
if (Rect.y1 >= ClipRect.y0) {
int ColorIndex;
/* Set background color */
if (pRow->Disabled) {
ColorIndex = LISTVIEW_CI_DISABLED;
} else if (i == pObj->Sel) {
ColorIndex = (pObj->Widget.State & WIDGET_STATE_FOCUS) ? LISTVIEW_CI_SELFOCUS : LISTVIEW_CI_SEL;
} else {
ColorIndex = LISTVIEW_CI_UNSEL;
}
LCD_SetBkColor(pObj->Props.aBkColor[ColorIndex]);
/* Iterate over all columns */
if (pObj->ShowGrid) {
Rect.y1--;
}
xPos = EffectSize - pObj->ScrollStateH.v;
for (j = 0; j < NumColumns; j++) {
Width = HEADER_GetItemWidth(pObj->hHeader, j);
Rect.x0 = xPos;
/* Break when all other columns are outside the drawing area */
if (Rect.x0 > ClipRect.x1) {
break;
}
Rect.x1 = xPos + Width - 1;
/* Make sure that we draw only when column is in drawing area */
if (Rect.x1 >= ClipRect.x0) {
LISTVIEW_COLUMN* pColumn;
LISTVIEW_CELL* pCell;
pCell = (LISTVIEW_CELL*)GUI_ARRAY_GetpItem(&pRow->CellArray, j);
if (pCell) {
if (pCell->hCellInfo) {
LISTVIEW_CELL_INFO* pCellInfo;
pCellInfo = (LISTVIEW_CELL_INFO*) GUI_ALLOC_h2p(pCell->hCellInfo);
LCD_SetBkColor(pCellInfo->aBkColor[ColorIndex]);
LCD_SetColor(pCellInfo->aTextColor[ColorIndex]);
} else {
LCD_SetColor(pObj->Props.aTextColor[ColorIndex]);
}
/* Clear background */
GUI_ClearRect(Rect.x0, Rect.y0, Rect.x1, Rect.y1);
/* Draw text */
Rect.x0 += LBorder;
Rect.x1 -= RBorder;
pColumn = (LISTVIEW_COLUMN*) GUI_ARRAY_GetpItem(&pObj->ColumnArray, j);
Align = pColumn->Align;
GUI_DispStringInRect(pCell->acText, &Rect, Align);
if (pCell->hCellInfo) {
LCD_SetBkColor(pObj->Props.aBkColor[ColorIndex]);
}
}
}
xPos += Width;
}
/* Clear unused area to the right of items */
if (xPos <= ClipRect.x1) {
GUI_ClearRect(xPos, Rect.y0, ClipRect.x1, Rect.y1);
}
}
yPos += RowDistY;
}
}
/* Clear unused area below items */
if (yPos <= ClipRect.y1) {
LCD_SetBkColor(pObj->Props.aBkColor[0]);
GUI_ClearRect(ClipRect.x0, yPos, ClipRect.x1, ClipRect.y1);
}
/* Draw grid */
if (pObj->ShowGrid) {
LCD_SetColor(pObj->Props.GridColor);
yPos = HEADER_GetHeight(pObj->hHeader) + EffectSize - 1;
for (i = 0; i < NumVisRows; i++) {
yPos += RowDistY;
/* Break when all other rows are outside the drawing area */
if (yPos > ClipRect.y1) {
break;
}
/* Make sure that we draw only when row is in drawing area */
if (yPos >= ClipRect.y0) {
GUI_DrawHLine(yPos, ClipRect.x0, ClipRect.x1);
}
}
xPos = EffectSize - pObj->ScrollStateH.v;
for (i = 0; i < NumColumns; i++) {
xPos += HEADER_GetItemWidth(pObj->hHeader, i);
/* Break when all other columns are outside the drawing area */
if (xPos > ClipRect.x1) {
break;
}
/* Make sure that we draw only when column is in drawing area */
if (xPos >= ClipRect.x0) {
GUI_DrawVLine(xPos, ClipRect.y0, ClipRect.y1);
}
}
}
/* Draw the effect */
WIDGET__EFFECT_DrawDown(&pObj->Widget);
}
/*********************************************************************
*
* _FillPolygon
*/
static void _FillPolygon(const GUI_POINT* paPoint, int NumPoints, int x0, int y0) {
GUI_RECT r;
_CalcPolyRect(&r, paPoint, NumPoints);
GUI_MoveRect(&r, x0, y0);
_MarkRect(r.x0, r.y0, r.x1, r.y1);
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(LISTVIEW_Handle hObj, LISTVIEW_Obj* pObj, WM_MESSAGE* pMsg) {
const GUI_ARRAY* pRow;
GUI_RECT ClipRect, Rect;
int NumRows, NumVisRows, NumColumns;
int LBorder, RBorder, EffectSize;
int xPos, yPos, Width, RowDistY;
int Align, i, j, EndRow;
/* Init some values */
NumColumns = HEADER_GetNumItems(pObj->hHeader);
NumRows = GUI_ARRAY_GetNumItems(&pObj->RowArray);
NumVisRows = _GetNumVisibleRows(hObj, pObj);
RowDistY = LISTVIEW__GetRowDistY(pObj);
LBorder = pObj->LBorder;
RBorder = pObj->RBorder;
EffectSize = pObj->Widget.pEffect->EffectSize;
yPos = HEADER_GetHeight(pObj->hHeader) + EffectSize;
EndRow = pObj->ScrollStateV.v + (((NumVisRows + 1) > NumRows) ? NumRows : NumVisRows + 1);
/* Calculate clipping rectangle */
ClipRect = *(const GUI_RECT*)pMsg->Data.p;
GUI_MoveRect(&ClipRect, -pObj->Widget.Win.Rect.x0, -pObj->Widget.Win.Rect.y0);
WM_GetInsideRectExScrollbar(hObj, &Rect);
GUI__IntersectRect(&ClipRect, &Rect);
/* Set drawing color, font and text mode */
LCD_SetColor(pObj->Props.aTextColor[0]);
GUI_SetFont(pObj->Props.pFont);
GUI_SetTextMode(GUI_TM_TRANS);
/* Do the drawing */
for (i = pObj->ScrollStateV.v; i < EndRow; i++) {
pRow = (const GUI_ARRAY*)GUI_ARRAY_GetpItem(&pObj->RowArray, i);
if (pRow) {
Rect.y0 = yPos;
/* Break when all other rows are outside the drawing area */
if (Rect.y0 > ClipRect.y1) {
break;
}
Rect.y1 = yPos + RowDistY - 1;
/* Make sure that we draw only when row is in drawing area */
if (Rect.y1 >= ClipRect.y0) {
int ColorIndex;
/* Set background color */
if (i == pObj->Sel) {
ColorIndex = (pObj->Widget.State & WIDGET_STATE_FOCUS) ? 2 : 1;
} else {
ColorIndex = 0;
}
LCD_SetBkColor(pObj->Props.aBkColor[ColorIndex]);
/* Iterate over all columns */
if (pObj->ShowGrid) {
Rect.y1--;
}
xPos = EffectSize - pObj->ScrollStateH.v;
for (j = 0; j < NumColumns; j++) {
Width = HEADER_GetItemWidth(pObj->hHeader, j);
Rect.x0 = xPos;
/* Break when all other columns are outside the drawing area */
if (Rect.x0 > ClipRect.x1) {
break;
}
Rect.x1 = xPos + Width - 1;
/* Make sure that we draw only when column is in drawing area */
if (Rect.x1 >= ClipRect.x0) {
LISTVIEW_ITEM * pItem;
pItem = (LISTVIEW_ITEM *)GUI_ARRAY_GetpItem(pRow, j);
if (pItem->hItemInfo) {
LISTVIEW_ITEM_INFO * pItemInfo;
pItemInfo = (LISTVIEW_ITEM_INFO *)GUI_ALLOC_h2p(pItem->hItemInfo);
LCD_SetBkColor(pItemInfo->aBkColor[ColorIndex]);
LCD_SetColor(pItemInfo->aTextColor[ColorIndex]);
} else {
LCD_SetColor(pObj->Props.aTextColor[ColorIndex]);
}
/* Clear background */
GUI_ClearRect(Rect.x0, Rect.y0, Rect.x1, Rect.y1);
/* Draw text */
Rect.x0 += LBorder;
Rect.x1 -= RBorder;
Align = *((int*)GUI_ARRAY_GetpItem(&pObj->AlignArray, j));
GUI_DispStringInRect(pItem->acText, &Rect, Align);
if (pItem->hItemInfo) {
LCD_SetBkColor(pObj->Props.aBkColor[ColorIndex]);
}
}
xPos += Width;
}
/* Clear unused area to the right of items */
if (xPos <= ClipRect.x1) {
GUI_ClearRect(xPos, Rect.y0, ClipRect.x1, Rect.y1);
}
}
yPos += RowDistY;
}
}
/* Clear unused area below items */
if (yPos <= ClipRect.y1) {
LCD_SetBkColor(pObj->Props.aBkColor[0]);
GUI_ClearRect(ClipRect.x0, yPos, ClipRect.x1, ClipRect.y1);
}
/* Draw grid */
if (pObj->ShowGrid) {
LCD_SetColor(pObj->Props.GridColor);
yPos = HEADER_GetHeight(pObj->hHeader) + EffectSize - 1;
for (i = 0; i < NumVisRows; i++) {
yPos += RowDistY;
/* Break when all other rows are outside the drawing area */
if (yPos > ClipRect.y1) {
break;
}
/* Make sure that we draw only when row is in drawing area */
if (yPos >= ClipRect.y0) {
GUI_DrawHLine(yPos, ClipRect.x0, ClipRect.x1);
}
}
xPos = EffectSize - pObj->ScrollStateH.v;
for (i = 0; i < NumColumns; i++) {
xPos += HEADER_GetItemWidth(pObj->hHeader, i);
/* Break when all other columns are outside the drawing area */
if (xPos > ClipRect.x1) {
break;
}
/* Make sure that we draw only when column is in drawing area */
if (xPos >= ClipRect.x0) {
GUI_DrawVLine(xPos, ClipRect.y0, ClipRect.y1);
}
}
}
/* Draw the effect */
WIDGET__EFFECT_DrawDown(&pObj->Widget);
}
void WM__Client2Screen(const WM_Obj* pWin, GUI_RECT *pRect) {
GUI_MoveRect(pRect, pWin->Rect.x0, pWin->Rect.y0);
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(BUTTON_Obj* pObj, BUTTON_Handle hObj) {
const char* s = NULL;
unsigned int Index;
int State, PressedState, ColorIndex;
GUI_RECT rClient, rInside;
State = pObj->Widget.State;
PressedState = (State & BUTTON_STATE_PRESSED) ? 1 : 0;
ColorIndex = (WM__IsEnabled(hObj)) ? PressedState : 2;
GUI_SetFont(pObj->Props.pFont);
GUI_DEBUG_LOG("BUTTON: Paint(..)\n");
if (pObj->hpText) {
s = (const char*) GUI_ALLOC_h2p(pObj->hpText);
}
GUI_GetClientRect(&rClient);
/* Start drawing */
rInside = rClient;
/* Draw the 3D effect (if configured) */
#if BUTTON_USE_3D
{
int EffectSize;
if ((PressedState) == 0) {
pObj->Widget.pEffect->pfDrawUp(); /* _WIDGET_EFFECT_3D_DrawUp(); */
EffectSize = pObj->Widget.pEffect->EffectSize;
} else {
LCD_SetColor(0x000000);
GUI_DrawRect(rClient.y0, rClient.x0, rClient.x1, rClient.y1);
EffectSize = 1;
}
GUI__ReduceRect(&rInside, &rInside, EffectSize);
}
#endif
/* Draw background */
LCD_SetBkColor (pObj->Props.aBkColor[ColorIndex]);
LCD_SetColor (pObj->Props.aTextColor[ColorIndex]);
WM_SetUserClipRect(&rInside);
GUI_Clear();
/* Draw bitmap.
If we have only one, we will use it.
If we have to we will use the second one (Index 1) for the pressed state
*/
if (ColorIndex < 2) {
Index = (pObj->ahDrawObj[BUTTON_BI_PRESSED] && PressedState) ? BUTTON_BI_PRESSED : BUTTON_BI_UNPRESSED;
} else {
Index = pObj->ahDrawObj[BUTTON_BI_DISABLED] ? BUTTON_BI_DISABLED : BUTTON_BI_UNPRESSED;
}
GUI_DRAW__Draw(pObj->ahDrawObj[Index], 0, 0);
/* Draw the actual button (background and text) */
{
GUI_RECT r;
r = rInside;
#if BUTTON_USE_3D
if (PressedState) {
GUI_MoveRect(&r, BUTTON_3D_MOVE_X,BUTTON_3D_MOVE_Y);
}
#endif
GUI_SetTextMode(GUI_TM_TRANS);
GUI_DispStringInRect(s, &r, pObj->Props.Align);
}
/* Draw focus */
if (State & BUTTON_STATE_FOCUS) {
LCD_SetColor(pObj->Props.FocusColor);
GUI_DrawFocusRect(&rClient, 2);
}
WM_SetUserClipRect(NULL);
}
static void WM__GetInvalidRectAbs(WM_Obj* pWin, GUI_RECT* pRect) {
*pRect = pWin->InvalidRect;
GUI_MoveRect (pRect, pWin->Rect.x0, pWin->Rect.y0);
}
/*********************************************************************
*
* WM__Screen2Client
*/
void WM__Screen2Client(const WM_Obj* pWin, GUI_RECT *pRect) {
GUI_MoveRect(pRect, -pWin->Rect.x0, -pWin->Rect.y0);
}
/*********************************************************************
*
* _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);
}
}
/*********************************************************************
*
* _DrawSample
*/
static void _DrawSample(GUI_RECT Rect, const GUI_FONT * pFont, const char * pText) {
GUI_RECT CurrentRect;
int yDistDiv3;
Rect.x0 += BORDER;
Rect.y0 += BORDER;
Rect.x1 -= BORDER;
Rect.y1 -= BORDER;
yDistDiv3 = (Rect.y1 - Rect.y0) / 3;
CurrentRect.x0 = Rect.x0;
CurrentRect.y0 = Rect.y0;
CurrentRect.x1 = Rect.x0 + 59;
CurrentRect.y1 = Rect.y0 + 3 * yDistDiv3;
GUI_SetClipRect(&CurrentRect);
//
// Display info text
//
GUI_SetFont(GUI_FONT_13_ASCII);
GUI_SetColor(GUI_WHITE);
GUI_DispStringInRectWrap(pText, &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER, GUI_WRAPMODE_WORD);
//
// Alpha circles
//
GUI_MoveRect(&CurrentRect, 63, 0);
GUI_SetBkColor(GUI_BLACK);
GUI_Clear();
_DrawAlphaCircles((CurrentRect.x0 + CurrentRect.x1) / 2, (CurrentRect.y0 + CurrentRect.y1) / 2, 35, 0, 4);
GUI_SetColor(GUI_WHITE);
GUI_SetFont(pFont);
CurrentRect.y1 = CurrentRect.y0 + yDistDiv3;
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
//
// Black to white gradient
//
CurrentRect.y0 = Rect.y0;
CurrentRect.y1 = Rect.y0 + 3 * yDistDiv3;
GUI_MoveRect(&CurrentRect, 63, 0);
GUI_DrawGradientH(CurrentRect.x0, CurrentRect.y0, CurrentRect.x1, CurrentRect.y1, GUI_BLACK, GUI_WHITE);
CurrentRect.y1 = CurrentRect.y0 + yDistDiv3;
GUI_SetColor(GUI_RED);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_SetColor(GUI_GREEN);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_SetColor(GUI_BLUE);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
//
// RGB
//
CurrentRect.y0 = Rect.y0;
CurrentRect.y1 = CurrentRect.y0 + yDistDiv3;
GUI_MoveRect(&CurrentRect, 63, 0);
GUI_SetBkColor(GUI_RED);
GUI_Clear();
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_SetBkColor(GUI_GREEN);
GUI_Clear();
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_SetBkColor(GUI_BLUE);
GUI_Clear();
GUI_SetColor(GUI_WHITE);
CurrentRect.y0 = Rect.y0;
CurrentRect.y1 = CurrentRect.y0 + yDistDiv3;
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
//
// RGB gradients
//
CurrentRect.y0 = Rect.y0;
CurrentRect.y1 = CurrentRect.y0 + yDistDiv3;
GUI_MoveRect(&CurrentRect, 63, 0);
GUI_DrawGradientV(CurrentRect.x0, CurrentRect.y0, CurrentRect.x1, CurrentRect.y1, GUI_RED, GUI_BLACK);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_DrawGradientV(CurrentRect.x0, CurrentRect.y0, CurrentRect.x1, CurrentRect.y1, GUI_GREEN, GUI_BLACK);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_DrawGradientV(CurrentRect.x0, CurrentRect.y0, CurrentRect.x1, CurrentRect.y1, GUI_BLUE, GUI_BLACK);
CurrentRect.y0 = Rect.y0;
CurrentRect.y1 = CurrentRect.y0 + yDistDiv3;
GUI_SetColor(GUI_WHITE);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&CurrentRect, 0, yDistDiv3);
GUI_DispStringInRect("ABC", &CurrentRect, GUI_TA_HCENTER | GUI_TA_VCENTER);
//
// Disable application defined clip rectangle
//
GUI_SetClipRect(NULL);
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(BUTTON_Obj* pObj) {
const char*s =NULL;
int State = pObj->Widget.State;
int PressedState = (State & BUTTON_STATE_PRESSED) ? 1:0;
GUI_RECT rClient;
GUI_RECT r;
GUI_SetFont(pObj->pFont);
GUI_DEBUG_LOG("BUTTON: Paint(..)\n");
if (pObj->hpText) {
s = (const char*) WM_HMEM2Ptr(pObj->hpText);
}
GUI_GetClientRect(&rClient);
r = rClient;
/* Draw background */
GUI_SetBkColor (pObj->aBkColor[PressedState]);
GUI_SetColor (pObj->aTextColor[PressedState]);
GUI_Clear();
/* Draw bitmap.
If we have only one, we will use it.
If we have to we will use the second one (Index 1) for the pressed state
*/
{
int Index =0;
if (pObj->apBitmap[1] && PressedState) {
Index =1;
}
if (pObj->apBitmap[Index]) {
#if BUTTON_SUPPORT_STREAMED_BITMAP
if(pObj->aBitmapIsStreamed[Index]) {
#if BUTTON_SUPPORT_BITMAP_OFFSET
GUI_DrawStreamedBitmap((const GUI_BITMAP_STREAM*)(pObj->apBitmap[Index]), pObj->xOffBitmap, pObj->yOffBitmap);
#else
GUI_DrawBitmapStreamed((const GUI_BITMAP_STREAM*)(pObj->apBitmap[Index]), 0,0);
#endif
} else
#endif
{
#if BUTTON_SUPPORT_BITMAP_OFFSET
GUI_DrawBitmap(pObj->apBitmap[Index], pObj->xOffBitmap[Index], pObj->yOffBitmap[Index]);
#else
GUI_DrawBitmap(pObj->apBitmap[Index], 0,0);
#endif
}
}
}
/* Draw the actual button (background and text) */
#if BUTTON_USE_3D
if (pObj->Widget.State & BUTTON_STATE_PRESSED) {
GUI_MoveRect(&r, BUTTON_3D_MOVE_X,BUTTON_3D_MOVE_Y);
}
#endif
GUI_SetTextMode(GUI_TM_TRANS);
GUI_DispStringInRect(s, &r, GUI_TA_HCENTER | GUI_TA_VCENTER);
/* Draw the 3D effect (if configured) */
#if BUTTON_USE_3D
if ((State & BUTTON_STATE_PRESSED) == 0) {
WIDGET_EFFECT_3D_DrawUp();
} else {
GUI_SetColor(0x000000); /// TBD: Use halftone
GUI_DrawRect(rClient.y0, rClient.x0, rClient.x1, rClient.y1);
}
#endif
/* Draw focus */
if (State & BUTTON_STATE_FOCUS) {
GUI_SetColor(GUI_BLACK);
GUI_DrawFocusRect(&rClient, 2);
}
}
/*********************************************************************
*
* _DrawSample
*/
static void _DrawSample(GUI_RECT * pRect, int yd) {
GUI_RECT Rect;
Rect = *pRect;
//
// Use application defined clip rectangle
//
GUI_SetClipRect(&Rect);
//
// Move clip rectangle
//
GUI_MoveRect(&Rect, 65, 0);
//
// Draw sample
//
_DrawAlphaCircles((Rect.x0 + Rect.x1) >> 1, (Rect.y0 + Rect.y1) >> 1, 35, 0, 4);
GUI_SetColor(GUI_WHITE);
GUI_DispStringInRectWrap("ABC\nABC\nABC", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER, GUI_WRAPMODE_WORD);
//
// Move clip rectangle
//
GUI_MoveRect(&Rect, 65, 0);
GUI_DrawGradientH(Rect.x0, Rect.y0, Rect.x1, Rect.y1, GUI_BLACK, GUI_WHITE);
Rect.y1 = Rect.y0 + yd;
GUI_SetColor(GUI_RED);
GUI_DispStringInRect("ABC", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&Rect, 0, yd);
GUI_SetColor(GUI_GREEN);
GUI_DispStringInRect("ABC", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&Rect, 0, yd);
GUI_SetColor(GUI_BLUE);
GUI_DispStringInRect("ABC", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_MoveRect(&Rect, 0, -yd * 2);
Rect.y1 = Rect.y0 + yd * 3;
//
// Move clip rectangle
//
GUI_MoveRect(&Rect, 65, 0);
//
// Draw sample
//
Rect.y1 = Rect.y0 + yd;
GUI_SetBkColor(GUI_RED);
GUI_Clear();
GUI_MoveRect(&Rect, 0, yd);
GUI_SetBkColor(GUI_GREEN);
GUI_Clear();
GUI_MoveRect(&Rect, 0, yd);
GUI_SetBkColor(GUI_BLUE);
GUI_Clear();
GUI_MoveRect(&Rect, 0, -yd * 2);
Rect.y1 = Rect.y0 + yd * 3;
GUI_SetColor(GUI_WHITE);
GUI_DispStringInRectWrap("ABC\nABC\nABC", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER, GUI_WRAPMODE_WORD);
//
// Move clip rectangle
//
GUI_MoveRect(&Rect, 65, 0);
//
// Draw sample
//
Rect.y1 = Rect.y0 + yd;
GUI_DrawGradientV(Rect.x0, Rect.y0, Rect.x1, Rect.y1, GUI_RED, GUI_BLACK);
GUI_MoveRect(&Rect, 0, yd);
GUI_DrawGradientV(Rect.x0, Rect.y0, Rect.x1, Rect.y1, GUI_GREEN, GUI_BLACK);
GUI_MoveRect(&Rect, 0, yd);
GUI_DrawGradientV(Rect.x0, Rect.y0, Rect.x1, Rect.y1, GUI_BLUE, GUI_BLACK);
GUI_MoveRect(&Rect, 0, -yd * 2);
Rect.y1 = Rect.y0 + yd * 3;
GUI_SetColor(GUI_WHITE);
GUI_DispStringInRectWrap("ABC\nABC\nABC", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER, GUI_WRAPMODE_WORD);
//
// Disable application defined clip rectangle
//
GUI_SetClipRect(NULL);
}
