void GUI_DispStringInRect(const char GUI_FAR *s, GUI_RECT* pRect, int TextAlign) {
#if (GUI_WINSUPPORT)
const GUI_RECT *pClipRect_Old = NULL;
#else
GUI_RECT Rect_Old;
#endif
if (s) {
GUI_LOCK();
if (pRect) {
#if (GUI_WINSUPPORT)
pClipRect_Old = WM_SetUserClipRect(pRect);
#else
Rect_Old = GUI_Context.ClipRect;
LCD_SetClipRectEx(pRect);
#endif
}
_DispStringInRect(s, pRect, TextAlign);
#if (GUI_WINSUPPORT)
WM_SetUserClipRect(pClipRect_Old);
#else
LCD_SetClipRectEx(&Rect_Old);
#endif
GUI_UNLOCK();
}
}
void GUI_DispStringInRectMax(const char GUI_UNI_PTR *s, GUI_RECT* pRect, int TextAlign, int MaxLen) {
if (s) {
const GUI_RECT *pOldClipRect = NULL;
GUI_RECT r;
GUI_LOCK();
if (pRect) {
pOldClipRect = WM_SetUserClipRect(pRect);
if (pOldClipRect) {
GUI__IntersectRects(&r, pRect, pOldClipRect);
WM_SetUserClipRect(&r);
}
}
GUI__DispStringInRect(s, pRect, TextAlign, MaxLen);
WM_SetUserClipRect(pOldClipRect);
GUI_UNLOCK();
}
}
/*********************************************************************
*
* GUI_DispStringInRectEx
*/
void GUI_DispStringInRectEx(const char GUI_UNI_PTR *s, GUI_RECT* pRect, int TextAlign, int MaxLen, const GUI_ROTATION * pLCD_Api) {
const GUI_ROTATION * pLCD_ApiOld;
if (pLCD_Api == GUI_ROTATE_0) {
/* Do nothing else but calling GUI_DispStringInRectMax if pLCD_Api == GUI_ROTATE_0 */
GUI_DispStringInRectMax(s, pRect, TextAlign, MaxLen);
} else {
#if (!GUI_WINSUPPORT)
GUI_RECT Rect_Old;
#else
const GUI_RECT * pOldClipRect = NULL;
#endif
GUI_RECT rClip, rText = {0};
GUI_LOCK();
/* Set the clip rectangle */
if (pRect) {
rText = *pRect;
GUI_RectDispString = rText;
#if (GUI_WINSUPPORT)
pOldClipRect = WM_SetUserClipRect(pRect);
if (pOldClipRect) {
GUI__IntersectRects(&rClip, pRect, pOldClipRect);
WM_SetUserClipRect(&rClip);
}
#else
Rect_Old = GUI_Context.ClipRect;
GUI__IntersectRects(&rClip, pRect, &Rect_Old);
LCD_SetClipRectEx(&rClip);
#endif
}
pLCD_ApiOld = _SetRotation(pLCD_Api); /* Set the new function pointer for rotating text */
pLCD_Api->pfRect2TextRect(&rText); /* Calculate the text rectangle */
GUI__DispStringInRect(s, &rText, TextAlign, MaxLen); /* Display the string */
/* Restore old clipping rectangle */
#if (GUI_WINSUPPORT)
WM_SetUserClipRect(pOldClipRect);
#else
LCD_SetClipRectEx(&Rect_Old);
#endif
_SetRotation(pLCD_ApiOld);
GUI_UNLOCK();
}
}
/*********************************************************************
*
* _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);
}
/*********************************************************************
*
* _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);
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(CHECKBOX_Obj* pObj, CHECKBOX_Handle hObj) {
GUI_RECT RectBox = {0};
int ColorIndex, EffectSize, Index;
EffectSize = pObj->Widget.pEffect->EffectSize;
ColorIndex = WM__IsEnabled(hObj);
/* Clear inside ... Just in case */
/* Fill with parents background color */
#if WM_SUPPORT_TRANSPARENCY
if (!WM_GetHasTrans(hObj))
#endif
{
if (pObj->Props.BkColor == GUI_INVALID_COLOR) {
LCD_SetBkColor(WIDGET__GetBkColor(hObj));
} else {
LCD_SetBkColor(pObj->Props.BkColor);
}
GUI_Clear();
}
/* Get size from bitmap */
RectBox.x1 = pObj->Props.apBm[CHECKBOX_BI_ACTIV]->XSize - 1 + 2 * EffectSize;
RectBox.y1 = pObj->Props.apBm[CHECKBOX_BI_ACTIV]->YSize - 1 + 2 * EffectSize;
WM_SetUserClipRect(&RectBox);
/* Clear inside ... Just in case */
LCD_SetBkColor(pObj->Props.aBkColorBox[ColorIndex]);
GUI_Clear();
Index = pObj->CurrentState * 2 + ColorIndex;
if (pObj->Props.apBm[Index]) {
GUI_DrawBitmap(pObj->Props.apBm[Index], EffectSize, EffectSize);
}
/* Draw the effect arround the box */
WIDGET__EFFECT_DrawDownRect(&pObj->Widget, &RectBox);
WM_SetUserClipRect(NULL);
/* Draw text if needed */
if (pObj->hpText) {
const char * s;
GUI_RECT RectText;
/* Draw the text */
s = (const char *) GUI_ALLOC_h2p(pObj->hpText);
WM_GetClientRect(&RectText);
RectText.x0 += RectBox.x1 + 1 + pObj->Props.Spacing;
GUI_SetTextMode(GUI_TM_TRANS);
LCD_SetColor(pObj->Props.TextColor);
GUI_SetFont(pObj->Props.pFont);
GUI_DispStringInRect(s, &RectText, pObj->Props.Align);
/* Draw focus rectangle */
if (pObj->Widget.State & WIDGET_STATE_FOCUS) {
int xSizeText = GUI_GetStringDistX(s);
int ySizeText = GUI_GetFontSizeY();
GUI_RECT RectFocus = RectText;
switch (pObj->Props.Align & ~(GUI_TA_HORIZONTAL)) {
case GUI_TA_VCENTER:
RectFocus.y0 = (RectText.y1 - ySizeText + 1) / 2;
break;
case GUI_TA_BOTTOM:
RectFocus.y0 = RectText.y1 - ySizeText;
break;
}
switch (pObj->Props.Align & ~(GUI_TA_VERTICAL)) {
case GUI_TA_HCENTER:
RectFocus.x0 += ((RectText.x1 - RectText.x0) - xSizeText) / 2;
break;
case GUI_TA_RIGHT:
RectFocus.x0 += (RectText.x1 - RectText.x0) - xSizeText;
break;
}
RectFocus.x1 = RectFocus.x0 + xSizeText - 1;
RectFocus.y1 = RectFocus.y0 + ySizeText - 1;
LCD_SetColor(pObj->Props.FocusColor);
GUI_DrawFocusRect(&RectFocus, -1);
}
}
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(EDIT_Obj* pObj, EDIT_Handle hObj) {
GUI_RECT rFillRect, rInside, rText, rInvert;
const char GUI_UNI_PTR * pText = NULL;
int IsEnabled, CursorWidth = 0;
IsEnabled = WM__IsEnabled(hObj);
/* Set colors and font */
LCD_SetBkColor(pObj->Props.aBkColor[IsEnabled]);
LCD_SetColor(pObj->Props.aTextColor[0]);
GUI_SetFont(pObj->Props.pFont);
/* Calculate size */
WIDGET__GetInsideRect(&pObj->Widget, &rFillRect);
if (pObj->hpText) {
pText = (const char*) GUI_ALLOC_h2p(pObj->hpText);
}
rInside = rFillRect;
rInside.x0 += pObj->Props.Border + EDIT_XOFF;
rInside.x1 -= pObj->Props.Border + EDIT_XOFF;
GUI__CalcTextRect(pText, &rInside, &rText, pObj->Props.Align);
/* Calculate position and size of cursor */
if (pObj->Widget.State & WIDGET_STATE_FOCUS) {
int NumChars;
CursorWidth = ((pObj->XSizeCursor > 0) ? (pObj->XSizeCursor) : (1));
NumChars = GUI__GetNumChars(pText);
if (pText) {
U16 Char;
int i, IsRTL = 0;
if ((pObj->EditMode != GUI_EDIT_MODE_INSERT) || (pObj->SelSize)) {
if (pObj->CursorPos < NumChars) {
if (pObj->SelSize) {
CursorWidth = 0;
for (i = pObj->CursorPos; i < (int)(pObj->CursorPos + pObj->SelSize); i++) {
Char = GUI__GetCursorCharacter(pText, i, NumChars, 0);
CursorWidth += GUI_GetCharDistX(Char);
}
if (!CursorWidth) {
CursorWidth = 1;
}
} else {
Char = GUI__GetCursorCharacter(pText, pObj->CursorPos, NumChars, &IsRTL);
CursorWidth = GUI_GetCharDistX(Char);
}
}
}
rInvert = rText;
if (IsRTL) {
rInvert.x0 -= CursorWidth;
}
rInvert.x0 += GUI__GetCursorPosX(pText, pObj->CursorPos, NumChars);
}
}
/* WM loop */
WM_ITERATE_START(NULL) {
/* Set clipping rectangle */
WM_SetUserClipRect(&rFillRect);
/* Display text */
WIDGET__FillStringInRect(pText, &rFillRect, &rInside, &rText);
/* Display cursor if needed */
if (pObj->Widget.State & WIDGET_STATE_FOCUS) {
GUI_InvertRect(rInvert.x0, rInvert.y0, rInvert.x0 + CursorWidth - 1, rInvert.y1);
}
WM_SetUserClipRect(NULL);
/* Draw the 3D effect (if configured) */
WIDGET__EFFECT_DrawDown(&pObj->Widget);
} WM_ITERATE_END();
}
