int _ExecKeyboard(void) {
int i;
int Key;
BUTTON_Handle ahButton[52];
BUTTON_Handle hButtonESC;
EDIT_Handle hEdit;
GUI_RECT rText = {000,0, LCD_XSIZE, 20};
GUI_SetBkColor(GUI_BLUE);
GUI_Clear();
GUI_DrawBitmap(&bmMicriumLogo, 0, 0);
GUI_SetFont(&GUI_Font16B_1);
GUI_SetColor(GUI_WHITE);
GUI_DispStringInRect("µC/GUI", &rText, GUI_TA_RIGHT | GUI_TA_VCENTER);
rText.y0 +=20;
rText.y1 +=20;
GUI_DispStringInRect("Touch screen demo", &rText, GUI_TA_RIGHT | GUI_TA_VCENTER);
/* Create Keyboard Buttons */
for (i=0; i< 51; i++) {
int Pos = (i < 47) ? i : i+4;
int x0 = 5 + 28*(Pos%11);
int y0 = 100 + 28*(Pos/11);
char c = _acText[i];
int Id = c ? c : 1;
char ac[2] = {0};
char *s= ac;
ac[0] = c;
ahButton[i] = BUTTON_Create( x0, y0, 25, 25, Id,BUTTON_CF_SHOW );
BUTTON_SetText (ahButton[i], s);
#if GUI_SUPPORT_MEMDEV
BUTTON_EnableMemdev(ahButton[i]);
#endif
}
ahButton[i] = BUTTON_Create( 89, 212, 109, 25, ' ',BUTTON_CF_SHOW );
hButtonESC = BUTTON_Create( 230, 40, 80, 25, GUI_ID_CANCEL,BUTTON_CF_SHOW );
BUTTON_SetText (hButtonESC, "ESC");
hEdit = EDIT_Create( 5, 70, 310, 25, ' ', 80, 0 );
EDIT_SetFont(hEdit, &GUI_Font8x16);
BUTTON_SetBkColor(ahButton[49], 0, GUI_RED);
BUTTON_SetBkColor(ahButton[50], 0, GUI_BLUE);
/* Handle Keyboard until ESC or ENTER is pressed */
do {
Key = GUIDEMO_WaitKey();
switch (Key) {
case 0:
case GUI_ID_CANCEL:
break;
default:
EDIT_AddKey(hEdit, Key);
}
} while ((Key != 'N') && (Key!=GUI_ID_CANCEL) && (Key!=0));
/* Cleanup */
for (i=0; i< countof(ahButton); i++) {
BUTTON_Delete(ahButton[i]);
}
BUTTON_Delete(hButtonESC);
EDIT_Delete(hEdit);
return Key;
}
int _ExecKeyboard(void) {
int y0 = 75;
int XSize = LCD_GetXSize();
int YSize = LCD_GetYSize();
int XStep = XSize / 4;
int YStep = (YSize - y0) / 4;
int i;
int Key;
BUTTON_Handle ahButton[16];
BUTTON_Handle hButtonESC;
EDIT_Handle hEdit;
GUI_RECT rText = {0};
rText.x1 = LCD_GetXSize() - 3;
rText.y1 = 20;
GUI_SetBkColor(GUI_BLUE);
GUI_Clear();
GUI_SetFont(&GUI_FontComic18B_ASCII);
GUI_SetColor(GUI_WHITE);
GUI_DispStringInRect("µC/GUI", &rText, GUI_TA_RIGHT | GUI_TA_VCENTER);
rText.y0 +=20;
rText.y1 +=20;
GUI_DispStringInRect("Touch screen demo", &rText, GUI_TA_RIGHT | GUI_TA_VCENTER);
/* Create Keyboard Buttons */
for (i=0; _acText[i]; i++) {
int XPos = (i%4) * XStep + 3;
int YPos = (i/4) * YStep + 3 + y0;
char c = _acText[i];
int Id = c ? c : 1;
char ac[2] = {0};
char *s= ac;
ac[0] = c;
ahButton[i] = BUTTON_Create( XPos, YPos, XStep - 5, YStep - 5, Id, BUTTON_CF_SHOW );
BUTTON_SetText(ahButton[i], s);
BUTTON_EnableMemdev(ahButton[i]);
}
hButtonESC = BUTTON_Create( 3, 3, 80, 25, GUI_ID_CANCEL, BUTTON_CF_SHOW );
BUTTON_SetText(hButtonESC, "ESC");
hEdit = EDIT_Create( 5, y0 - 30, XSize - 10, 25, ' ', 80, 0 );
EDIT_SetFont(hEdit, &GUI_Font8x16);
/* Handle Keyboard until ESC or ENTER is pressed */
do {
Key = GUIDEMO_WaitKey();
switch (Key) {
case 0:
case GUI_ID_CANCEL:
break;
default:
EDIT_AddKey(hEdit, Key);
}
} while ((Key != 'N') && (Key!=GUI_ID_CANCEL) && (Key!=0));
/* Cleanup */
for (i=0; i< countof(ahButton); i++) {
BUTTON_Delete(ahButton[i]);
}
BUTTON_Delete(hButtonESC);
EDIT_Delete(hEdit);
return Key;
}
/*********************************************************************
*
* _DemoVScreen
*/
static void _DemoVScreen(void) {
GUI_RECT Rect;
unsigned j;
int xSize;
int ySize;
int n;
int aDelay[] = { 20, 5 };
xSize = LCD_GetXSize();
ySize = LCD_GetYSize();
GUI_SetFont(&GUI_FontComic24B_ASCII);
GUI_SetTextMode(GUI_TM_TRANS);
Rect.x0 = 0;
Rect.y0 = 0;
Rect.x1 = xSize - 1;
Rect.y1 = ySize - 1;
GUI_SetColor(GUI_WHITE);
GUI_DispStringInRect("Default screen", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_Delay(250);
Rect.y0 += ySize;
Rect.y1 += ySize;
GUI_DrawGradientV(Rect.x0, Rect.y0, Rect.x1, Rect.y1, 0xFFFFFF, 0x000000);
Rect.y1 -= ySize / 3;
GUI_SetColor(GUI_DARKGREEN);
GUI_DispStringInRect("Here is the virtual screen", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
n = ySize / 5;
for (j = 0; j < GUI_COUNTOF(aDelay); j++) {
if (_Loop(0, 5, n, aDelay[j]) == 1) {
return;
}
GUI_SetOrg(0, ySize);
GUI_Delay(250);
if (_Loop(ySize, -5, n, aDelay[j]) == 1) {
return;
}
GUI_SetOrg(0, 0);
GUI_Delay(250);
if (GUIDEMO_CheckCancel()) {
return;
}
}
for (j = 0; j < 5; j++) {
GUI_SetOrg(0, ySize);
GUI_Delay(200);
GUI_SetOrg(0, 0);
GUI_Delay(200);
if (GUIDEMO_CheckCancel()) {
return;
}
}
GUIDEMO_Delay(1000);
}
/*********************************************************************
*
* _GetPhysValues
*
* Function description
* Asks the user to press the touch screen at the given position
* and returns the physical A/D values
*/
static void _GetPhysValues(int LogX, int LogY, int * pPhysX, int * pPhysY, const char * pString) {
char acText[] = "Press here";
GUI_RECT Rect;
int FontSizeY;
int Align;
FontSizeY = GUI_GetFontSizeY();
GUI_Clear();
GUI_SetColor(GUI_BLACK);
_DispStringCentered("Runtime calibration,\n"
"please touch the screen\n"
"at the center of the ring."); /* Ask user to press the touch */
//
// Calculate the rectangle for the string
//
Rect.y0 = LogY - FontSizeY;
Rect.y1 = LogY + FontSizeY;
if (LogX < LCD_GetXSize() / 2) {
Rect.x0 = LogX + 15;
Rect.x1 = LCD_GetXSize();
Align = GUI_TA_LEFT;
} else {
Rect.x0 = 0;
Rect.x1 = LogX - 15;
Align = GUI_TA_RIGHT;
}
//
// Show the text nearby the ring
//
GUI_DispStringInRect(acText, &Rect, Align | GUI_TA_TOP);
GUI_DispStringInRect(pString, &Rect, Align | GUI_TA_BOTTOM);
//
// Draw the ring
//
GUI_FillCircle(LogX, LogY, 10);
GUI_SetColor(GUI_WHITE);
GUI_FillCircle(LogX, LogY, 5);
GUI_SetColor(GUI_BLACK);
//
// Wait until touch is pressed
//
_WaitForPressedState(1);
*pPhysX = GUI_TOUCH_GetxPhys();
*pPhysY = GUI_TOUCH_GetyPhys();
//
// Wait until touch is released
//
_WaitForPressedState(0);
}
/*******************************************************************
*
* _DemoFade
*/
static void _DemoFade(void) {
GUI_MEMDEV_Handle hMem0, hMem1;
GUI_RECT Rect = {0};
int x, y, v = 0, vz = 4;
int xSize, ySize;
xSize = LCD_GetXSize();
ySize = LCD_GetYSize();
hMem0 = GUI_MEMDEV_CreateFixed(0, 0, 138, 65, GUI_MEMDEV_NOTRANS, GUI_MEMDEV_APILIST_32, GUICC_888); /* Contains the text */
hMem1 = GUI_MEMDEV_CreateFixed(0, 0, 138, 65, GUI_MEMDEV_NOTRANS, GUI_MEMDEV_APILIST_32, GUICC_888); /* Contains the bitmap */
x = (xSize - _bmSeggerLogoBlue.XSize) / 2;
y = (ySize - _bmSeggerLogoBlue.YSize) / 3 * 2;
Rect.x1 = _bmSeggerLogoBlue.XSize - 1;
Rect.y1 = _bmSeggerLogoBlue.YSize - 1;
/* Fill memory device with some text */
GUI_MEMDEV_Select(hMem0);
GUI_SetColor(GUI_RED);
GUI_SetFont(&GUI_Font32B_ASCII);
GUI_SetTextMode(GUI_TM_TRANS);
GUI_DispStringInRect("Fade in", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_DrawRectEx(&Rect);
/* Fill memory device with bitmap */
GUI_MEMDEV_Select(hMem1);
GUI_DrawBitmap(&_bmSeggerLogoBlue, 0, 0);
/* Set device positions */
GUI_MEMDEV_SetOrg(hMem0, x, y);
GUI_MEMDEV_SetOrg(hMem1, x, y);
GUI_MEMDEV_Select(0);
/* Fading loop */
while (1) {
GUI_MEMDEV_FadeDevices(hMem0, hMem1, 1000);
GUI_MEMDEV_FadeDevices(hMem1, hMem0, 1000);
}
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(TEXT_Handle hObj, TEXT_Obj* pObj) {
const char * s;
GUI_RECT Rect;
GUI_USE_PARA(hObj);
LCD_SetColor(pObj->TextColor);
GUI_SetFont (pObj->pFont);
/* Fill with parents background color */
#if !TEXT_SUPPORT_TRANSPARENCY /* Not needed any more, since window is transparent*/
if (pObj->BkColor == GUI_INVALID_COLOR) {
LCD_SetBkColor(WIDGET__GetBkColor(hObj));
} else {
LCD_SetBkColor(pObj->BkColor);
}
GUI_Clear();
#else
if (!WM_GetHasTrans(hObj)) {
LCD_SetBkColor(pObj->BkColor);
GUI_Clear();
}
#endif
/* Show the text */
if (pObj->hpText) {
s = (const char*) GUI_ALLOC_h2p(pObj->hpText);
GUI_SetTextMode(GUI_TM_TRANS);
WM_GetClientRect(&Rect);
GUI_DispStringInRect(s, &Rect, pObj->Align);
}
}
/*********************************************************************
*
* _DispStringCentered
*
* Purpose:
* Shows the given text horizontally and vertically centered
*/
static void _DispStringCentered(const char * pString) {
GUI_RECT Rect;
Rect.x0 = Rect.y0 = 0;
Rect.x1 = LCD_GetXSize() - 1;
Rect.y1 = LCD_GetYSize() - 1;
GUI_DispStringInRect(pString, &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
}
/*********************************************************************
*
* _OnPaint
*
* Purpose: Paints the owner drawn button
*/
static void _OnPaint(BUTTON_Handle hObj) {
int Index;
char ac[50];
GUI_RECT Rect;
Index = (WIDGET_GetState(hObj) & BUTTON_STATE_PRESSED) ? 1 : 0;
WM_GetClientRect(&Rect);
//
// Draw filled ellipse with button background color
//
GUI_SetColor(BUTTON_GetBkColor(hObj, Index));
GUI_FillEllipse(Rect.x1 / 2, Rect.y1 / 2, Rect.x1 / 2, Rect.y1 / 2);
//
// Draw black shape
//
GUI_SetColor(GUI_BLACK);
GUI_DrawEllipse(Rect.x1 / 2, Rect.y1 / 2, Rect.x1 / 2, Rect.y1 / 2);
//
// Draw button text with widget attributes
//
GUI_SetColor(BUTTON_GetTextColor(hObj, Index));
GUI_SetBkColor(BUTTON_GetBkColor(hObj, Index));
GUI_SetFont(BUTTON_GetFont(hObj));
BUTTON_GetText(hObj, ac, sizeof(ac));
if (_Pressed) {
strcpy(ac + strlen(ac), "\npressed");
}
GUI_DispStringInRect(ac, &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
}
/*********************************************************************
*
* 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);
}
}
void OUI_DrawElementData(Element * This, uint16_t x, uint16_t y){
if(This->Redraw){
GUI_SetColor(OUI_BAR_BACKGROUND);
GUI_FillRect(x, y, x+62, y+29);
GUI_SetBkColor(OUI_BAR_BACKGROUND);
GUI_SetColor(GUI_WHITE);
GUI_RECT dispRect;
dispRect.x0 = x+1;
dispRect.y0 = y+1;
dispRect.x1 = x+62;
dispRect.y1 = y+28;
GUI_SetFont(&GUI_Font8_1);
GUI_DispStringInRect(This->Text, &dispRect, GUI_TA_TOP | GUI_TA_HCENTER);
GUI_SetFont(&GUI_Font16_1);
GUI_DispStringInRect(This->Text, &dispRect, GUI_TA_BOTTOM | GUI_TA_HCENTER);
This->Redraw = 0;
}
}
/*********************************************************************
*
* _GetPhysValues
*
* Purpose:
* Asks the user to press the touch screen at the given position
* and returns the physical pixels(A/D) values
*/
static void _GetPhysValues(int LogX, int LogY, int * pPhysX, int * pPhysY, const char * pString) {
char acText[] = "Press here";
GUI_RECT Rect;
GUI_PID_STATE State;
int FontSizeY, Align;
FontSizeY = GUI_GetFontSizeY(); /*获取字体的高度*/
GUI_Clear();
GUI_SetColor(GUI_BLACK);
_DispStringCentered("Runtime calibration,\n"
"please touch the corners of the screen\n"
"at the center of the rings."); /* Ask user to press the touch */
/* Calculate the rectangle for the string(根据触摸点的位置，设置文字显示的区域) */
if (LogX < LCD_GetXSize() / 2) {/*判断是左上角的点，还是有下角的点*/
Rect.x0 = LogX + 25;
Rect.x1 = LCD_GetXSize();
Rect.y0 = LogY - FontSizeY + 5; /*设置大小能显示两行字符*/
Rect.y1 = LogY + FontSizeY + 5;
Align = GUI_TA_LEFT;
} else {
Rect.x0 = 0;
Rect.x1 = LogX - 25;
Rect.y0 = LogY - FontSizeY - 5;
Rect.y1 = LogY + FontSizeY - 5;
Align = GUI_TA_RIGHT;
}
/* Show the text nearby the ring */
GUI_DispStringInRect(acText, &Rect, Align | GUI_TA_TOP);
GUI_DispStringInRect(pString, &Rect, Align | GUI_TA_BOTTOM);
/* Draw the ring */
GUI_FillCircle(LogX, LogY, 10);
GUI_SetColor(GUI_WHITE);
GUI_FillCircle(LogX, LogY, 7);
GUI_SetColor(GUI_BLACK);
/* Wait until touch is pressed */
_WaitForPressedState(1);
/*得到触摸点的值*/
GUI_TOUCH_GetState(&State);
*pPhysX = State.x;
*pPhysY = State.y;
/* Wait until touch is released */
_WaitForPressedState(0);
}
void OUI_DrawLabel(Component * This, uint16_t x, uint16_t y){
GUI_SetColor(This->PrimaryColor);
GUI_FillCircle(x+15, y+22, 12);
GUI_RECT dispRect;
dispRect.x0 = x+3;
dispRect.y0 = y+10;
dispRect.x1 = x+27;
dispRect.y1 = y+34;
GUI_SetFont(&GUI_Font20_1);
GUI_SetBkColor(This->PrimaryColor);
GUI_SetColor(This->TextColor);
GUI_DispStringInRect(&This->Identifier, &dispRect, GUI_TA_VCENTER | GUI_TA_HCENTER);
}
void GUIDEMO_Touch(void) {
#define ID_KEYBOARD 1
#define ID_TESTCAL 2
#define ID_CALIBRATE 3
int i, r;
int XSize = LCD_GetXSize();
int YSize = LCD_GetYSize();
int XMid = XSize / 2;
int YMid = YSize / 2;
//GUIDEMO_NotifyStartNext();
GUIDEMO_HideInfoWin();
do {
GUI_RECT rText;/*= {0, 80, XSize, 120};*/
BUTTON_Handle ahButton[3];
rText.x0=0;
rText.y0=50;
rText.x1=XSize;
rText.y1=90;
GUI_SetBkColor(GUI_BLUE);
GUI_Clear();
GUI_DrawBitmap(&bmMicriumLogo, (XSize - 1 - bmMicriumLogo.XSize) / 2, 15);
GUI_SetFont(&GUI_Font16B_1);
GUI_DispStringInRect("µC/GUI Touch screen demo", &rText, GUI_TA_HCENTER | GUI_TA_VCENTER);
ahButton[0] = BUTTON_Create( XMid - 50, YMid - 30, 100, 50, ID_CALIBRATE,BUTTON_CF_SHOW );
ahButton[1] = BUTTON_Create( XMid - 90, YMid + 30, 80, 30, ID_KEYBOARD, BUTTON_CF_SHOW );
ahButton[2] = BUTTON_Create( XMid + 10, YMid + 30, 80, 30, ID_TESTCAL,BUTTON_CF_SHOW );
BUTTON_SetText (ahButton[0], "Calibrate");
BUTTON_SetBkColor(ahButton[0], 0, GUI_RED);
BUTTON_SetText (ahButton[1], "Keyboard");
BUTTON_SetText (ahButton[2], "Test calibration");
BUTTON_SetFont(ahButton[0], &GUI_FontComic18B_ASCII);
r = GUIDEMO_WaitKey();
if (r==0) {
r = ID_KEYBOARD;
BUTTON_SetState(ahButton[1],BUTTON_STATE_PRESSED);
GUIDEMO_Delay(500);
}
for (i=0; i< countof(ahButton); i++) {
BUTTON_Delete(ahButton[i]);
}
switch (r) {
case ID_KEYBOARD: init_uart0(); send_press_key(); break;
case ID_CALIBRATE: _ExecCalibration(); break;
case ID_TESTCAL: _TestCalibration(); break;
}
} while (r && (r!='n') && (r!='N'));
}
static void Paint(TERMINAL_Obj* pObj/*, GUI_RECT*pRect*/) {
char*s = (char*) WM_HMEM2Ptr(pObj->hpText);
GUI_RECT rClient;
GUI_DEBUG_LOG("TERMINAL: Paint(..)\n");
GUI_GetClientRect(&rClient);
/* Draw background */
GUI_SetBkColor (GUI_WHITE/*pObj->aBkColor[0]*/);
GUI_SetColor (GUI_BLACK /*pObj->aTextColor[0]*/);
GUI_Clear();
/* Draw the text */
{
GUI_RECT rText = rClient;
rText.x0 +=3;
// GUI_SetFont (pObj->pFont);
GUI_DispStringInRect(s, &rText, GUI_TA_LEFT);
}
}
/*********************************************************************
*
* _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);
}
}
/*****************************************************************************
* FUNCTION - ShowErrorMessage_C
* DESCRIPTION: Displays an error message.
* Further actions (Rebooting or ignoring errors when not debugging) depend
* on the caller (or the caller of the caller...).
*
* Called by embOS\D3018X\OS_Error and Factory::FatalErrorOccured()
*
****************************************************************************/
extern "C" void ShowErrorMessage_C(const char* errorDescription = "-")
{
int i;
char sz_msg[250];
WM_HWIN win;
WM_HWIN win_next;
GUI_RECT rect;
WM_SelectWindow(WM_GetDesktopWindow());
win = WM_GetFirstChild(WM_GetDesktopWindow());
while(win != (WM_HWIN) NULL)
{
win_next = WM_GetNextSibling(win);
WM_DeleteWindow(win);
win = win_next;
}
WM_SetStayOnTop(WM_GetDesktopWindow(),1);
WM_BringToTop(WM_GetDesktopWindow());
GUI_SetBkColor(GUI_WHITE);
GUI_SetColor(GUI_BLACK);
GUI_SetFont(&Helvetica_57_13);
GUI_Clear();
sprintf(sz_msg, "Fatal error.\n\n %s", errorDescription);
rect.x0 = 0;
rect.y0 = 10;
rect.x1 = 239;
rect.y1 = 319;
for (i=0; i<5; i++)
{
GUI_Clear();
GUI_Delay(100);
GUI_DispStringInRect(sz_msg,&rect,GUI_TA_VCENTER|GUI_TA_HCENTER);
GUI_Delay(500);
}
}
/*********************************************************************
*
* _Paint
*/
static void _Paint(DROPDOWN_Handle hObj) {
int Border;
GUI_RECT r;
const char* s;
int InnerSize, ColorIndex;
DROPDOWN_Obj* pObj;
int TextBorderSize;
/* Do some initial calculations */
pObj = DROPDOWN_H2P(hObj);
Border = pObj->Widget.pEffect->EffectSize;
TextBorderSize = pObj->Props.TextBorderSize;
GUI_SetFont(pObj->Props.pFont);
ColorIndex = (pObj->Widget.State & WIDGET_STATE_FOCUS) ? 2 : 1;
s = _GetpItem(pObj, pObj->Sel);
WM_GetClientRect(&r);
GUI__ReduceRect(&r, &r, Border);
InnerSize = r.y1 - r.y0 + 1;
/* Draw the 3D effect (if configured) */
WIDGET__EFFECT_DrawDown(&pObj->Widget);
/* Draw the outer text frames */
r.x1 -= InnerSize; /* Spare square area to the right */
LCD_SetColor(pObj->Props.aBackColor[ColorIndex]);
/* Draw the text */
LCD_SetBkColor(pObj->Props.aBackColor[ColorIndex]);
GUI_FillRectEx(&r);
r.x0 += TextBorderSize;
r.x1 -= TextBorderSize;
LCD_SetColor (pObj->Props.aTextColor[ColorIndex]);
GUI_DispStringInRect(s, &r, pObj->Props.Align);/**/
/* Draw arrow */
WM_GetClientRect(&r);
GUI__ReduceRect(&r, &r, Border);
r.x0 = r.x1 + 1 - InnerSize;
LCD_SetColor(0xc0c0c0);
GUI_FillRectEx(&r);
LCD_SetColor(GUI_BLACK);
_DrawTriangleDown((r.x1 + r.x0) / 2, r.y0 + 5, (r.y1 - r.y0 - 8) / 2);
WIDGET__EFFECT_DrawUpRect(&pObj->Widget, &r);
}
/*********************************************************************
*
* _cbCallback
*/
static void _cbCallback(WM_MESSAGE * pMsg) {
WM_HWIN hDlg, hWinSrc;
int Id, NCode;
GUI_RECT Rect;
Rect.x0 = 10;
Rect.y0 = 10;
Rect.x1 = 300;
Rect.y1 = 200;
hWinSrc = pMsg->hWinSrc;
hDlg = pMsg->hWin;
switch (pMsg->MsgId) {
case WM_INIT_DIALOG:
WM_MakeModal(hDlg);
FRAMEWIN_SetFont(hDlg, &GUI_Font24B_ASCII);
FRAMEWIN_SetTextAlign(hDlg, GUI_TA_HCENTER);
FRAMEWIN_SetClientColor(hDlg, GUI_GREEN);
break;
case WM_PAINT:
GUI_SetColor(GUI_BLACK);
GUI_SetFont(&GUI_Font16_ASCII);
GUI_DispStringInRect(&_aExplain[0], &Rect, GUI_TA_LEFT);
break;
case WM_NOTIFY_PARENT:
Id = WM_GetId(hWinSrc); /* Id of widget */
NCode = pMsg->Data.v; /* Notification code */
if (NCode == WM_NOTIFICATION_RELEASED) { /* React only if released */
if (Id == GUI_ID_OK) { /* OK Button */
GUI_EndDialog(hDlg, 0);
WM_SetFocus(_hPrevWin);
}
}
break;
default:
WM_DefaultProc(pMsg);
}
}
/*********************************************************************
*
* _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);
}
/*********************************************************************
*
* MainTask
*/
void MainTask(void) {
const char * pText;
GUI_RECT Rect;
U16 xSizeScreen;
U16 ySizeScreen;
U16 xSizeItem;
U16 ySizeItem;
U16 xSize;
U16 ySize;
U16 xOff;
U16 yOff;
U8 NumLanguagesCSV;
U8 ItemCnt;
U8 LangCnt;
GUI_Init();
GUI_UC_SetEncodeUTF8();
xSizeScreen = LCD_GetXSize();
ySizeScreen = LCD_GetYSize();
if ((xSizeScreen < XSIZE_MIN) || (ySizeScreen < YSIZE_MIN)) {
GUI_DEBUG_ERROROUT("Inaccurate display size.");
}
//
// Stretch the sample up to a size of #define XSIZE_MAX * YSIZE_MAX.
// Above that display size the sample is centered on the according axis.
//
if (xSizeScreen > XSIZE_MAX) {
xOff = (xSizeScreen - XSIZE_MAX) / 2;
xSize = XSIZE_MAX;
} else {
xOff = 0;
xSize = xSizeScreen;
}
if (ySizeScreen > YSIZE_MAX) {
yOff = (ySizeScreen - YSIZE_MAX) / 2;
ySize = YSIZE_MAX;
} else {
yOff = 0;
ySize = ySizeScreen;
}
#ifdef WIN32
_CreateLanguageResources();
#endif
//
// Draw background
//
xSizeItem = xSize / NUM_LANGUAGES;
ySizeItem = (ySize - HEIGHT_TOP) / NUM_ITEMS;
GUI_SetBkColor(GUI_DARKBLUE);
GUI_Clear();
GUI_DrawGradientV(0, HEIGHT_TOP, xSizeScreen - 1, ySizeScreen - 1, GUI_DARKBLUE, GUI_DARKGRAY);
//
// Draw frames
//
Rect.x0 = xOff + BORDER_SIZE;
Rect.x1 = xOff + xSizeItem * 2 - BORDER_SIZE;
Rect.y0 = yOff + HEIGHT_TOP + BORDER_SIZE;
Rect.y1 = ySizeScreen - yOff - BORDER_SIZE - 1;
GUI_DrawRectEx(&Rect);
GUI_DrawHLine(Rect.y0 + ySizeItem, Rect.x0, Rect.x1);
Rect.x0 = xOff + xSizeItem * 2 + BORDER_SIZE;
Rect.x1 = xSizeScreen - xOff - BORDER_SIZE;
GUI_DrawRectEx(&Rect);
GUI_DrawHLine(Rect.y0 + ySizeItem, Rect.x0, Rect.x1);
//
// Display headlines
//
GUI_SetFont(&GUI_Font20B_ASCII);
GUI_SetTextMode(GUI_TM_TRANS);
Rect.x0 = xOff;
Rect.x1 = xOff + xSize - 1;
Rect.y0 = yOff;
Rect.y1 = yOff + HEIGHT_HEADLINE_1 - 1;
GUI_DispStringInRect("emWin - Language Resources", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
GUI_SetFont(&GUI_Font13B_ASCII);
Rect.x1 = xOff + xSizeItem * 2 - 1;
Rect.y0 = yOff + HEIGHT_HEADLINE_1;
Rect.y1 = yOff + HEIGHT_TOP - 1;
GUI_DispStringInRect("CSV file", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
Rect.x0 = Rect.x1;
Rect.x1 = xSizeScreen - xOff - 1;
GUI_DispStringInRect("Text file", &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
//
// Load resource files
//
GUI_LANG_SetMaxNumLang(NUM_LANGUAGES);
#ifdef WIN32
NumLanguagesCSV = GUI_LANG_LoadCSVEx(_GetData, &_ResFileName[0]);
GUI_LANG_LoadTextEx(_GetData, &_ResFileName[1], NumLanguagesCSV);
#else
NumLanguagesCSV = GUI_LANG_LoadCSV(_acGUI_LANG_CSV_Ger_Eng, sizeof(_acGUI_LANG_CSV_Ger_Eng));
GUI_LANG_LoadText(_acGUI_LANG_TXT_Jap, sizeof(_acGUI_LANG_TXT_Jap), NumLanguagesCSV);
#endif
//
// Display the resource text in the calculated rectangle
// using the according font for headline and body.
//
for (LangCnt = 0; LangCnt < NUM_LANGUAGES; LangCnt++) {
Rect.x0 = xOff + LangCnt * xSizeItem;
Rect.x1 = Rect.x0 + xSizeItem;
for (ItemCnt = 0; ItemCnt < NUM_ITEMS; ItemCnt++) {
pText = GUI_LANG_GetTextEx(ItemCnt, LangCnt);
Rect.y0 = yOff + HEIGHT_TOP + (ItemCnt * ySizeItem);
Rect.y1 = Rect.y0 + ySizeItem;
if (ItemCnt == 0) {
GUI_SetFont(_Languages[LangCnt].pFontHeadline);
} else {
GUI_SetFont(_Languages[LangCnt].pFontBody);
}
GUI_DispStringInRect(pText, &Rect, GUI_TA_HCENTER | GUI_TA_VCENTER);
}
}
while (1) {
GUI_Delay(100);
}
}
/*********************************************************************
*
* _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);
}
void MainTask_2D_text_bmp(void) {
int i;
horPos = ICONS_HOR_POS;
verPos = ICONS_VER_POS;
iconTouched = 0xFF;
SetemWinRunning(1);
GUI_SelectLayer(1); // select foregroung layer
GUI_SetBkColor(GUI_TRANSPARENT); // select background as transparent color
GUI_Clear(); // fill with the background color
// get the number of icons
iconNumber = GUI_COUNTOF(iconDrawFunctions);
// compute padding to fit to whole display
iconPadding = ((GUI_GetScreenSizeY() - (iconNumber * ICON_SIZE) - 2*ICONS_VER_POS) / iconNumber);
// start time measurement
timeMeasureStart();
// draw a background bitmap to the bottom LCD layer
GUI_SelectLayer(0); // select the background layer
// !! TO BE MODIFIED !!
GUI_DrawBitmap(&bmbackground, 0, 0);
GUI_SelectLayer(1); // set back the foregroung layer
// now draw our icons one by one
for (i = 0; i < iconNumber; i++)
{
iconDrawFunctions[i](horPos, verPos, ICON_SIZE);
verPos += ICON_SIZE + iconPadding;
}
// add a title text
GUI_SetTextMode(GUI_TM_TRANS);
GUI_SetFont(&GUI_FontTimesNewRoman31);
LCD_AA_SetAndMask(0xFFFFFFFF);
GUI_DispStringInRect("STM32 Player", &rect, GUI_TA_CENTER);
LCD_AA_SetAndMask(0x00FFFFFF);
// end measurement
time = timeMeasureEnd();
GUI_SetFont(&GUI_Font8_1);
sprintf (timeString, "time to render: %d,%dms", time/10, time%10);
GUI_DispStringAt(timeString, 10, 320 - 10);
// optionally we can use cursor
GUI_CURSOR_Show();
// the GUI is now rendered
// in never ending loop just check if an incon is touched
while(!tamperPushed)
{
GUI_TOUCH_GetState(&TouchState); // Get the touch position in pixel
if (TouchState.Pressed)
{
if (iconTouched == 0xFF) // no icon was touched previously
{
GUI_CURSOR_SetPosition(TouchState.x, TouchState.y); // move the cursor to current touch position
// check if the touch is in icons area
if (TouchState.x > ICONS_HOR_POS && TouchState.x < ICONS_HOR_POS + ICON_SIZE)
{
if(TouchState.y > ICONS_VER_POS && TouchState.y < ICONS_VER_POS + iconNumber*(ICON_SIZE + iconPadding))
{
// get he number of touched icon
iconTouched = (TouchState.y - ICONS_VER_POS) / (ICON_SIZE + iconPadding);
ReDrawIcon(GUI_RED, iconTouched); // draw again with hihghlight color
}
}
}
}
else
{
ReDrawIcon(GUI_WHITE, iconTouched);
iconTouched = 0xFF;
}
}
SetemWinRunning(0);
GUI_CURSOR_Hide();
}
void colorbar(void)
{
#define X_START 60 //????? X ??
#define Y_START 40 //????? Y ??
typedef struct {
int NumBars;
GUI_COLOR Color;
const char * s;
} BAR_DATA;
static const BAR_DATA _aBarData[] = {
{ 2, GUI_RED , "Red" },
{ 2, GUI_GREEN , "Green" },
{ 2, GUI_BLUE , "Blue" },
{ 1, GUI_WHITE , "Grey" },
{ 2, GUI_YELLOW , "Yellow" },
{ 2, GUI_CYAN , "Cyan" },
{ 2, GUI_MAGENTA, "Magenta" },
};
static const GUI_COLOR _aColorStart[] = { GUI_BLACK, GUI_WHITE };
GUI_RECT Rect;
int yStep;
int i;
int j;
int xSize;
int ySize;
int NumBars; //????????? 2+2+2+1+2+2+2=13
int NumColors; //????????,??? 7 ?
//??????
GUI_SetBkColor(GUI_BLUE);
GUI_SetColor(GUI_YELLOW);
GUI_Clear();
GUI_SetFont(&GUI_Font24_ASCII);
GUI_SetTextMode(GUI_TM_TRANS); //????
GUI_DispStringHCenterAt("COLOR_BAR TEST!",120,0);
xSize = LCD_GetXSize();
ySize = LCD_GetYSize();
//????????
NumColors = GUI_COUNTOF(_aBarData);
for (i = NumBars = 0, NumBars = 0; i < NumColors; i++) {
NumBars += _aBarData[i].NumBars;
}
yStep = (ySize - Y_START) / NumBars;
//????
Rect.x0 = 0;
Rect.x1 = X_START - 1;
Rect.y0 = Y_START;
GUI_SetFont(&GUI_Font8x16);
for (i = 0; i < NumColors; i++) {
Rect.y1 = Rect.y0 + yStep * _aBarData[i].NumBars - 1;
GUI_DispStringInRect(_aBarData[i].s, &Rect, GUI_TA_LEFT | GUI_TA_VCENTER);
Rect.y0 = Rect.y1 + 1;
}
//????
Rect.x0 = X_START;
Rect.x1 = xSize - 1;
Rect.y0 = Y_START;
for (i = 0; i < NumColors; i++) {
for (j = 0; j < _aBarData[i].NumBars; j++) {
Rect.y1 = Rect.y0 + yStep - 1;
GUI_DrawGradientH(Rect.x0, Rect.y0, Rect.x1, Rect.y1,_aColorStart[j], _aBarData[i].Color); //????
Rect.y0 = Rect.y1 + 1;
}
}
}
__s32 GUI_LongStringMove(__string_show_info_t *show_info)
{
if(!show_info->hmem)
{
ORANGE_WRN("input parameter error!\n");
return ORANGE_FAIL;
}
/*all can see*/
if(show_info->show_size.width < show_info->region.width)
{
return ORANGE_OK;
}
/*clear screen*/
GUI_LyrWinSel(show_info->hlayer);
GUI_MEMDEV_Select(show_info->hmem);
GUI_SetBkColor(show_info->color);
GUI_ClearRect(show_info->region.x,show_info->region.y,
show_info->region.x + show_info->region.width - 1,
show_info->region.y + show_info->region.height - 1);
if(show_info->bk_bmp)
{
GUI_BMP_Draw(show_info->bk_bmp,show_info->region.x + show_info->bmp_pos.x,
show_info->region.y + show_info->bmp_pos.y);
}
if(show_info->alpha_en)
{
GUI_OpenAlphaBlend();
}
GUI_CharSetToEncode(show_info->encode_id);
GUI_SetFont(show_info->pFont);
GUI_SetColor(show_info->fontColor);
if(show_info->align)
{
GUI_RECT rect;
rect.x0 = show_info->region.x;
rect.y0 = show_info->region.y;
rect.x1 = show_info->region.x + show_info->region.width - 1;
rect.y1 = show_info->region.y + show_info->region.height - 1;
GUI_DispStringInRect(show_info->name +
show_info->enocde_align_group[show_info->move_step],&rect,show_info->align);
}
else
{
GUI_DispStringAt(show_info->name +
show_info->enocde_align_group[show_info->move_step],
show_info->region.x,
show_info->region.y);
}
GUI_MEMDEV_CopyToLCD(show_info->hmem);
GUI_MEMDEV_Select(0);
if(show_info->alpha_en)
{
GUI_CloseAlphaBlend();
}
GUI_LyrWinFlushFB(show_info->hlayer);
if(show_info->left_move)
{
SIZE show_size;
show_info->move_step++;
local_get_string_piexl_rect(show_info->name + show_info->enocde_align_group[show_info->move_step],show_info,
&show_size);
if(show_size.width < show_info->region.width)
{
show_info->left_move = 0;
}
}
else
{
show_info->move_step--;
if(show_info->move_step < 0)
{
show_info->move_step = 0;
show_info->left_move = 1;
}
}
return ORANGE_OK;
}
static int StaticCtrlProc (__gui_msg_t *msg)
{
__u32 dwStyle;
static_data_t* pData;
dwStyle = GUI_WinGetStyle(msg->h_deswin);
switch(msg->id)
{
case GUI_MSG_CREATE:
pData = (static_data_t*) orange_malloc(sizeof(static_data_t));
if (pData == NULL)
{
return ORANGE_FAIL;
}
pData->status = 0;
pData->hmem = 0;
pData->str_move = 0;
pData->data = (__u32)GUI_WinGetAttr(msg->h_deswin);
GUI_CtrlWinSetAddData(msg->h_deswin,(__u32)pData);
return 0;
case GUI_MSG_DESTROY:
pData = (static_data_t*)GUI_CtrlWinGetAddData(msg->h_deswin);
if(pData->str_move)
{
GUI_LongStringDelete(pData->str_move);
}
orange_mfree ((void *)GUI_CtrlWinGetAddData(msg->h_deswin));
return 0;
case GUI_MSG_ENABLE:
if (msg->dwAddData1 && (dwStyle & WS_DISABLED))
{
dwStyle &= ~WS_DISABLED;
GUI_WinSetStyle(msg->h_deswin,dwStyle);
}
else if (!msg->dwAddData1 && !(dwStyle & WS_DISABLED))
{
dwStyle |= WS_DISABLED;
GUI_WinSetStyle(msg->h_deswin,dwStyle);
}
else
{
return 0;
}
return 0;
case GUI_MSG_SET_UNFOCUS:
if((STATIC_DRAWSTATUS(msg->h_deswin) & STATICST_FOCUS))
{
STATIC_DRAWSTATUS(msg->h_deswin) &= (~STATICST_FOCUS);
GUI_InvalidateRect (msg->h_deswin, NULL, ORANGE_TRUE);
}
return 0;
case GUI_MSG_SET_FOCUS:
if(!(STATIC_DRAWSTATUS(msg->h_deswin) & STATICST_FOCUS))
{
STATIC_DRAWSTATUS(msg->h_deswin) |= STATICST_FOCUS;
GUI_InvalidateRect (msg->h_deswin, NULL, ORANGE_TRUE);
}
return 0;
case GUI_MSG_KEY:
switch(msg->dwAddData1)
{
/*case GUI_MSG_KEY_RISE:
{
{
__gui_notify_msg_t notify_msg;
notify_msg.hWnd = msg->h_deswin;
notify_msg.id = GUI_WinGetItemId(msg->h_deswin);
notify_msg.msgcode = STN_CLICKED;
notify_msg.dwAddData= last_key;
GUI_NotifyParent (¬ify_msg);
}
}
return 0;*/
case GUI_MSG_KEY_DOWN:
{
if(msg->dwAddData2 == KEY_UP_ACTION)
{
{
__gui_notify_msg_t notify_msg;
notify_msg.hWnd = msg->h_deswin;
notify_msg.id = GUI_WinGetItemId(msg->h_deswin);
notify_msg.msgcode = STN_CLICKED;
notify_msg.dwAddData= last_key;
GUI_NotifyParent (¬ify_msg);
}
}
if(msg->dwAddData2 == KEY_DOWN_ACTION)
{
{
__gui_notify_msg_t notify_msg;
notify_msg.hWnd = msg->h_deswin;
notify_msg.id = GUI_WinGetItemId(msg->h_deswin);
notify_msg.msgcode = STN_PUSHED;
notify_msg.dwAddData= GUI_MSG_KEY_DOWN;
GUI_NotifyParent (¬ify_msg);
}
}
}
return 0;
case GUI_MSG_KEY_ENTER:
{
if(msg->dwAddData2 == KEY_UP_ACTION)
{
{
__gui_notify_msg_t notify_msg;
notify_msg.hWnd = msg->h_deswin;
notify_msg.id = GUI_WinGetItemId(msg->h_deswin);
notify_msg.msgcode = STN_CLICKED;
notify_msg.dwAddData= last_key;
GUI_NotifyParent (¬ify_msg);
}
}
if(msg->dwAddData2 == KEY_DOWN_ACTION)
{
{
__gui_notify_msg_t notify_msg;
notify_msg.hWnd = msg->h_deswin;
notify_msg.id = GUI_WinGetItemId(msg->h_deswin);
notify_msg.msgcode = STN_PUSHED;
notify_msg.dwAddData= GUI_MSG_KEY_ENTER;
GUI_NotifyParent (¬ify_msg);
}
}
}
return 0;
case GUI_MSG_KEY_RIGHT:
case GUI_MSG_KEY_LEFT:
case GUI_MSG_KEY_UP:
default:
{
if(msg->dwAddData2 == KEY_UP_ACTION)
{
{
__gui_notify_msg_t notify_msg;
notify_msg.hWnd = msg->h_deswin;
notify_msg.id = GUI_WinGetItemId(msg->h_deswin);
notify_msg.msgcode = STN_CLICKED;
notify_msg.dwAddData= last_key;
GUI_NotifyParent (¬ify_msg);
}
}
if(msg->dwAddData2 == KEY_DOWN_ACTION)
{
{
__gui_notify_msg_t notify_msg;
notify_msg.hWnd = msg->h_deswin;
notify_msg.id = GUI_WinGetItemId(msg->h_deswin);
notify_msg.msgcode = STN_PUSHED;
notify_msg.dwAddData= msg->dwAddData1;
GUI_NotifyParent (¬ify_msg);
}
}
}
break;
}
/*if(msg->dwAddData1 != GUI_MSG_KEY_RISE)
{
last_key = msg->dwAddData1;
}
else
{
last_key = 0xffffffff;
}*/
last_key = msg->dwAddData1;
return 0;
case GUI_MSG_TOUCH:
{
switch(msg->dwAddData1)
{
case GUI_MSG_TOUCH_DOWN:
{
{
__gui_notify_msg_t notify_msg;
notify_msg.hWnd = msg->h_deswin;
notify_msg.id = GUI_WinGetItemId(msg->h_deswin);
notify_msg.msgcode = STN_PUSHED;
notify_msg.dwAddData= 0;
GUI_NotifyParent (¬ify_msg);
}
}
break;
case GUI_MSG_TOUCH_UP:
{
{
__gui_notify_msg_t notify_msg;
notify_msg.hWnd = msg->h_deswin;
notify_msg.id = GUI_WinGetItemId(msg->h_deswin);
notify_msg.msgcode = STN_CLICKED;
notify_msg.dwAddData= 0;
GUI_NotifyParent (¬ify_msg);
}
}
break;
}
}
return 0;
case GUI_MSG_WIN_WAKEUP:
case GUI_MSG_PAINT:
{
__gui_rect_t rcrect;
RECT fbrect;
//void *pBMP;
static_data_t *static_data;
static_para_t *user_data;
//__u32 color;
//static_data = (static_para_t *)GUI_CtrlWinGetAddData(msg->h_deswin);
user_data = (static_para_t *)(((static_data_t *)GUI_CtrlWinGetAddData(msg->h_deswin))->data);
static_data = (static_data_t *)GUI_CtrlWinGetAddData(msg->h_deswin);
GUI_LyrWinSel(GUI_LyrP2H(GUI_WinGetLyrWin(msg->h_deswin)));
GUI_WinGetClientFBRect(msg->h_deswin,&fbrect);
if(!static_data->hmem && (GUI_WinGetStyle(msg->h_deswin) & WS_MEMDEV))
{
#if GUI_CORE_MEMDEV_EN //avoid complier error, by Derek
static_data->hmem = GUI_MEMDEV_Create(fbrect.x,fbrect.y,fbrect.width,fbrect.height);
#endif
}
SysRectToGuiRect(&fbrect,&rcrect);
if(static_data->hmem)
{
#if GUI_CORE_MEMDEV_EN //avoid complier error, by Derek
GUI_MEMDEV_Select(static_data->hmem); // start memory device
#endif
}
if (STATIC_DRAWSTATUS(msg->h_deswin) & STATICST_FOCUS)
{
GUI_RECT rect;
GUI_SetBkColor(user_data->bk_color);
GUI_ClearRect(rcrect.left,rcrect.top,
rcrect.right,rcrect.bottom);
if(user_data->focus_bmp)
{
GUI_BMP_Draw(user_data->focus_bmp, rcrect.left + user_data->bmp_pos.x,
rcrect.top + user_data->bmp_pos.y);
}
if(user_data->alpha_en)
{
GUI_OpenAlphaBlend();
}
GUI_CharSetToEncode(user_data->draw_code);
GUI_SetFont(user_data->draw_font);
GUI_SetDrawMode(GUI_DRAWMODE_TRANS);
GUI_SetColor(user_data->ftxt_color);
rect.x0 = rcrect.left;
rect.y0 = rcrect.top;
rect.x1 = rcrect.right;
rect.y1 = rcrect.bottom;
if(!user_data->txt_align)
{
GUI_DispStringAt(user_data->text,
rcrect.left + user_data->text_pos.x,
rcrect.top + user_data->text_pos.y);
}
else
{
GUI_DispStringInRect(user_data->text,&rect,user_data->txt_align);
}
}
else
{
GUI_RECT rect;
GUI_SetBkColor(user_data->bk_color);
GUI_ClearRect(rcrect.left,rcrect.top,
rcrect.right,rcrect.bottom);
if(user_data->unfocus_bmp)
{
GUI_BMP_Draw(user_data->unfocus_bmp, rcrect.left + user_data->bmp_pos.x,
rcrect.top + user_data->bmp_pos.y);
}
if(user_data->alpha_en)
{
GUI_OpenAlphaBlend();
}
GUI_CharSetToEncode(user_data->draw_code);
GUI_SetFont(user_data->draw_font);
GUI_SetDrawMode(GUI_DRAWMODE_TRANS);
GUI_SetColor(user_data->uftxt_color);
rect.x0 = rcrect.left;
rect.y0 = rcrect.top;
rect.x1 = rcrect.right;
rect.y1 = rcrect.bottom;
if(!user_data->txt_align)
{
GUI_DispStringAt(user_data->text,
rcrect.left + user_data->text_pos.x,
rcrect.top + user_data->text_pos.y);
}
else
{
GUI_DispStringInRect(user_data->text,&rect,user_data->txt_align);
}
}
if(static_data->hmem)
{
#if GUI_CORE_MEMDEV_EN //avoid complier error, by Derek
GUI_MEMDEV_CopyToLCD( static_data->hmem ); // copy from memory device to fb
GUI_MEMDEV_Select( NULL ); // stop memory device
GUI_MEMDEV_Delete(static_data->hmem);
#endif
static_data->hmem = NULL;
}
if(user_data->alpha_en)
{
GUI_CloseAlphaBlend();
}
GUI_LyrWinFlushFB(GUI_WinGetLyrWin(msg->h_deswin));
}
return 0;
default:
break;
}
return GUI_CtrlWinDefaultProc (msg);
}
/*********************************************************************
*
* _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);
}
/*********************************************************************
*
* _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);
}
}
}
/*********************************************************************
*
* _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);
}
