// *****************************************************************************
GFX_STATUS GFX_GOL_StaticTextDraw(void *pObject)
{
typedef enum
{
DRAW_STATIC_TEXT_IDLE,
DRAW_STATIC_TEXT_CLEANAREA,
DRAW_STATIC_TEXT_INIT,
DRAW_STATIC_TEXT_DRAWTEXT,
} ST_DRAW_STATES;
static ST_DRAW_STATES state = DRAW_STATIC_TEXT_IDLE;
GFX_GOL_STATICTEXT *pSt;
pSt = (GFX_GOL_STATICTEXT *)pObject;
while(1)
{
if (GFX_RenderStatusGet() == GFX_STATUS_BUSY_BIT)
return (GFX_STATUS_FAILURE);
switch(state)
{
case DRAW_STATIC_TEXT_IDLE:
if (GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_HIDE_STATE))
{
// Hide the GFX_GOL_STATICTEXT (remove from screen)
if (GFX_GOL_ObjectHideDraw(&(pSt->hdr)) != GFX_STATUS_SUCCESS)
return (GFX_STATUS_FAILURE);
// State is still IDLE STATE so no need to set state
return (GFX_STATUS_SUCCESS);
}
if(GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DRAW_STATE))
{
// show frame if specified to be shown
GFX_LineStyleSet(GFX_LINE_STYLE_THIN_SOLID);
if(GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_FRAME_STATE))
{
// set the line style to solid thin line
GFX_LineStyleSet(GFX_LINE_STYLE_THIN_SOLID);
if(!GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DISABLED_STATE))
{
// show enabled color
GFX_ColorSet(pSt->hdr.pGolScheme->Color1);
if(GFX_RectangleDraw(
pSt->hdr.left,
pSt->hdr.top,
pSt->hdr.right,
pSt->hdr.bottom) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
}
else
{
// show disabled color
GFX_ColorSet(pSt->hdr.pGolScheme->ColorDisabled);
if(GFX_RectangleDraw(
pSt->hdr.left,
pSt->hdr.top,
pSt->hdr.right,
pSt->hdr.bottom) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
}
}
}
// check if there is no background
if(GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_NOBACKGROUNDCOLORFILL_STATE))
{
state = DRAW_STATIC_TEXT_INIT;
break;
}
else
{
state = DRAW_STATIC_TEXT_CLEANAREA;
}
case DRAW_STATIC_TEXT_CLEANAREA:
// clean area where text will be placed.
GFX_ColorSet(pSt->hdr.pGolScheme->CommonBkColor);
GFX_GOL_ObjectBackGroundSet(&pSt->hdr);
if(GFX_RectangleFillDraw(
pSt->hdr.left + 1,
pSt->hdr.top + 1,
pSt->hdr.right - 1,
pSt->hdr.bottom - 1) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
state = DRAW_STATIC_TEXT_INIT;
case DRAW_STATIC_TEXT_INIT:
if (GFX_RenderStatusGet() == GFX_STATUS_BUSY_BIT)
return (GFX_STATUS_FAILURE);
// set the text color
if(!GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DISABLED_STATE))
{
GFX_ColorSet(pSt->hdr.pGolScheme->TextColor0);
}
else
{
GFX_ColorSet(pSt->hdr.pGolScheme->TextColorDisabled);
}
// use the font specified in the object
GFX_FontSet(pSt->hdr.pGolScheme->pFont);
state = DRAW_STATIC_TEXT_DRAWTEXT;
case DRAW_STATIC_TEXT_DRAWTEXT:
if (GFX_TextStringBoxDraw( \
pSt->hdr.left + 1, \
pSt->hdr.top + 1, \
pSt->hdr.right - pSt->hdr.left - 1, \
pSt->hdr.bottom - pSt->hdr.top - 1, \
pSt->pText, \
0, \
pSt->alignment) != GFX_STATUS_SUCCESS)
return (GFX_STATUS_FAILURE);
state = DRAW_STATIC_TEXT_IDLE; // go back to IDLE state
return (GFX_STATUS_SUCCESS);
} // end of switch()
} // end of while(1)
}
/*********************************************************************
* Function: uint16_t GFX_GOL_StaticTextDraw(void *pObj)
*
* Notes: This is the state machine to draw the static text.
*
********************************************************************/
GFX_STATUS GFX_GOL_StaticTextDraw(void *pObject)
{
typedef enum
{
GFX_GOL_STATICTEXT_STATE_IDLE,
GFX_GOL_STATICTEXT_STATE_CLEANAREA,
GFX_GOL_STATICTEXT_STATE_INIT,
WAIT
} GFX_GOL_STATICTEXT_DRAW_STATES;
static GFX_GOL_STATICTEXT_DRAW_STATES state = GFX_GOL_STATICTEXT_STATE_IDLE;
static GFX_STATUS index;
GFX_GOL_STATICTEXT *pSt;
pSt = (GFX_GOL_STATICTEXT *) pObject;
while (1)
{
switch (state)
{
case GFX_GOL_STATICTEXT_STATE_IDLE:
if (GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_HIDE_STATE))
{
GFX_ColorSet(pSt->hdr.pGolScheme->CommonBkColor);
if (GFX_RectangleFillDraw(pSt->hdr.left, pSt->hdr.top, pSt->hdr.right, pSt->hdr.bottom) == GFX_STATUS_FAILURE)
return (GFX_STATUS_FAILURE);
// State is still IDLE STATE so no need to set state
return (GFX_STATUS_SUCCESS);
}
if (GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DRAW_STATE))
{
if (GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_FRAME_STATE))
{
// show frame if specified to be shown
GFX_LineStyleSet(GFX_LINE_STYLE_THIN_SOLID);
if (!GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DISABLED_STATE))
{
// show enabled color
GFX_ColorSet(pSt->hdr.pGolScheme->Color1);
}
else
{
// show disabled color
GFX_ColorSet(pSt->hdr.pGolScheme->ColorDisabled);
}
if (GFX_RectangleDraw(pSt->hdr.left, pSt->hdr.top, pSt->hdr.right, pSt->hdr.bottom) == GFX_STATUS_FAILURE)
return (GFX_STATUS_FAILURE);
}
}
state = GFX_GOL_STATICTEXT_STATE_CLEANAREA;
case GFX_GOL_STATICTEXT_STATE_CLEANAREA:
#ifdef USE_ALPHABLEND //Draw the background image
if (pSt->hdr.pGolScheme->AlphaValue != 100)
{
GFX_AlphaParamsSet(GFX_Primitive_instance.backgroundPage,pSt->hdr.left, pSt->hdr.top,
GFX_Primitive_instance.backgroundPage,pSt->hdr.left, pSt->hdr.top,
GFX_Primitive_instance.activePage,pSt->hdr.left, pSt->hdr.top);
if(CopyPageWindow(
&GFX_Primitive_instance.alphaArea,
pSt->hdr.right - pSt->hdr.left, pSt->hdr.bottom - pSt->hdr.top) == GFX_STATUS_FAILURE)
return(GFX_STATUS_FAILURE);
}
else
#endif
{
// clean area where text will be placed.
GFX_ColorSet(pSt->hdr.pGolScheme->CommonBkColor);
if (GFX_RectangleFillDraw(pSt->hdr.left, pSt->hdr.top, pSt->hdr.right, pSt->hdr.bottom) == GFX_STATUS_FAILURE)
return (GFX_STATUS_FAILURE);
}
state = GFX_GOL_STATICTEXT_STATE_INIT;
case GFX_GOL_STATICTEXT_STATE_INIT:
// set the text color
if (!GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DISABLED_STATE))
{
GFX_ColorSet(pSt->hdr.pGolScheme->TextColor0);
}
else
{
GFX_ColorSet(pSt->hdr.pGolScheme->TextColorDisabled);
}
// use the font specified in the object
GFX_FontSet(pSt->hdr.pGolScheme->pFont);
index = GFX_TextStringBoxDraw(
pSt->hdr.left,
pSt->hdr.top,
pSt->hdr.right - pSt->hdr.left,
pSt->hdr.bottom - pSt->hdr.top,
pSt->pText, pSt->alignment);
if(index == GFX_STATUS_FAILURE)
{
return (GFX_STATUS_FAILURE);
}
state = WAIT;
case WAIT:
state = GFX_GOL_STATICTEXT_STATE_IDLE; // go back to IDLE state
return (GFX_STATUS_SUCCESS);
}
} // end of switch()
} // end of while(1)
// *****************************************************************************
GFX_STATUS GFX_GOL_StaticTextDraw(void *pObject)
{
typedef enum
{
DRAW_STATIC_TEXT_IDLE,
DRAW_STATIC_TEXT_CLEANAREA,
DRAW_STATIC_TEXT_INIT,
DRAW_STATIC_TEXT_DRAWTEXT,
} ST_DRAW_STATES;
static ST_DRAW_STATES state = DRAW_STATIC_TEXT_IDLE;
GFX_GOL_STATICTEXT *pSt;
static uint16_t adjustBackground = 0;
#ifdef GFX_CONFIG_ALPHABLEND_DISABLE
#ifndef GFX_CONFIG_TRANSPARENT_COLOR_DISABLE
uint16_t transparentColorStatus;
GFX_COLOR transparentColorSet = 0;
#endif
#endif
pSt = (GFX_GOL_STATICTEXT *)pObject;
while(1)
{
if (GFX_RenderStatusGet() == GFX_STATUS_BUSY_BIT)
return (GFX_STATUS_FAILURE);
switch(state)
{
case DRAW_STATIC_TEXT_IDLE:
#ifdef GFX_CONFIG_BISTABLE_DISPLAY_AUTO_REFRESH_ENABLE
GFX_DRIVER_SetupDrawUpdate( \
pSt->hdr.left, \
pSt->hdr.top, \
pSt->hdr.right, \
pSt->hdr.bottom);
#endif
if (GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_HIDE_STATE))
{
// Hide the GFX_GOL_STATICTEXT (remove from screen)
if (GFX_GOL_ObjectHideDraw(&(pSt->hdr)) != GFX_STATUS_SUCCESS)
return (GFX_STATUS_FAILURE);
// State is still IDLE STATE so no need to set state
#ifdef GFX_CONFIG_BISTABLE_DISPLAY_AUTO_REFRESH_ENABLE
GFX_DRIVER_CompleteDrawUpdate( \
pSt->hdr.left, \
pSt->hdr.top, \
pSt->hdr.right, \
pSt->hdr.bottom);
#endif
return (GFX_STATUS_SUCCESS);
}
if(GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DRAW_STATE))
{
// show frame if specified to be shown
GFX_LineStyleSet(GFX_LINE_STYLE_THIN_SOLID);
if(GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_FRAME_STATE))
{
adjustBackground = 1;
// set the line style to solid thin line
GFX_LineStyleSet(GFX_LINE_STYLE_THIN_SOLID);
if(!GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DISABLED_STATE))
{
// show enabled color
GFX_ColorSet(pSt->hdr.pGolScheme->Color1);
if(GFX_RectangleDraw(
pSt->hdr.left,
pSt->hdr.top,
pSt->hdr.right,
pSt->hdr.bottom) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
}
else
{
// show disabled color
GFX_ColorSet(pSt->hdr.pGolScheme->ColorDisabled);
if(GFX_RectangleDraw(
pSt->hdr.left,
pSt->hdr.top,
pSt->hdr.right,
pSt->hdr.bottom) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
}
}
else
{
adjustBackground = 0;
}
}
// check if there is no background
if(GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_NOBACKGROUNDCOLORFILL_STATE))
{
state = DRAW_STATIC_TEXT_INIT;
break;
}
else
{
state = DRAW_STATIC_TEXT_CLEANAREA;
}
case DRAW_STATIC_TEXT_CLEANAREA:
/* The refreshing of the static area is dependent on the
features set.
Case 1:
When fill style is GFX_FILL_STYLE_NONE, text cannot be
changed and refreshed. If text changes then use one
of the following fill styles:
GFX_FILL_STYLE_COLOR
GFX_FILL_STYLE_ALPHA_COLOR
GFX_FILL_STYLE_GRADIENT_DOWN,
GFX_FILL_STYLE_GRADIENT_UP,
GFX_FILL_STYLE_GRADIENT_RIGHT,
GFX_FILL_STYLE_GRADIENT_LEFT,
GFX_FILL_STYLE_GRADIENT_DOUBLE_VER,
GFX_FILL_STYLE_GRADIENT_DOUBLE_HOR,
or
use (or enable) the common background image
if available in the application (see case 2).
Case 2:
When common background image is set, then
GFX_FILL_STYLE_NONE can be used. Redrawing the
static text will redraw the background which in turn
refreshes the text. Therefore, in this case the text
can be modified.
Case 3:
Alpha blending cannot be used with gradient fills.
Therefore, do use gradient fills when alpha blending of
panels are enabled.
*/
// check if fill style is GFX_FILL_STYLE_NONE and common
// background is present
if ((pSt->hdr.pGolScheme->pCommonBkImage != NULL) &&
(pSt->hdr.pGolScheme->fillStyle == GFX_FILL_STYLE_NONE))
{
#ifdef GFX_CONFIG_ALPHABLEND_DISABLE
#ifndef GFX_CONFIG_TRANSPARENT_COLOR_DISABLE
if (GFX_TransparentColorStatusGet() == GFX_FEATURE_ENABLED)
{
// disable the transparent color since we want the
// background to refresh with all pixels being drawn
GFX_TransparentColorDisable();
transparentColorStatus = 1;
transparentColorSet = GFX_TransparentColorGet();
}
#endif
#endif
if (GFX_ImagePartialDraw(
pSt->hdr.left + adjustBackground, pSt->hdr.top + adjustBackground,
pSt->hdr.left - pSt->hdr.pGolScheme->CommonBkLeft + adjustBackground,
pSt->hdr.top - pSt->hdr.pGolScheme->CommonBkTop + adjustBackground,
pSt->hdr.right - pSt->hdr.left + 1 - (adjustBackground << 1),
pSt->hdr.bottom - pSt->hdr.top + 1 - (adjustBackground << 1),
pSt->hdr.pGolScheme->pCommonBkImage
) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
#ifdef GFX_CONFIG_ALPHABLEND_DISABLE
#ifndef GFX_CONFIG_TRANSPARENT_COLOR_DISABLE
// after rendering the background, we need to restore the
// transparent color if previously enabled.
if (transparentColorStatus)
{
GFX_TransparentColorEnable(transparentColorSet);
}
#endif
#endif
}
else
{
if (pSt->hdr.pGolScheme->fillStyle != GFX_FILL_STYLE_NONE)
{
// clean area where text will be placed.
GFX_ColorSet(pSt->hdr.pGolScheme->CommonBkColor);
GFX_GOL_ObjectBackGroundSet(&pSt->hdr);
if(GFX_RectangleFillDraw(
pSt->hdr.left + 1,
pSt->hdr.top + 1,
pSt->hdr.right - 1,
pSt->hdr.bottom - 1) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
}
}
state = DRAW_STATIC_TEXT_INIT;
case DRAW_STATIC_TEXT_INIT:
if (GFX_RenderStatusGet() == GFX_STATUS_BUSY_BIT)
return (GFX_STATUS_FAILURE);
// set the text color
if(!GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DISABLED_STATE))
{
GFX_ColorSet(pSt->hdr.pGolScheme->TextColor0);
}
else
{
GFX_ColorSet(pSt->hdr.pGolScheme->TextColorDisabled);
}
// use the font specified in the object
GFX_FontSet(pSt->hdr.pGolScheme->pFont);
state = DRAW_STATIC_TEXT_DRAWTEXT;
case DRAW_STATIC_TEXT_DRAWTEXT:
if (GFX_TextStringBoxDraw( \
pSt->hdr.left + 1, \
pSt->hdr.top + 1, \
pSt->hdr.right - pSt->hdr.left - 1, \
pSt->hdr.bottom - pSt->hdr.top - 1, \
pSt->pText, \
0, \
pSt->alignment) != GFX_STATUS_SUCCESS)
return (GFX_STATUS_FAILURE);
state = DRAW_STATIC_TEXT_IDLE; // go back to IDLE state
#ifdef GFX_CONFIG_BISTABLE_DISPLAY_AUTO_REFRESH_ENABLE
GFX_DRIVER_CompleteDrawUpdate( \
pSt->hdr.left, \
pSt->hdr.top, \
pSt->hdr.right, \
pSt->hdr.bottom);
#endif
return (GFX_STATUS_SUCCESS);
} // end of switch()
} // end of while(1)
}
// *****************************************************************************
GFX_STATUS GFX_GOL_CheckBoxDraw(void *pObject)
{
typedef enum
{
DRAW_CHECKBOX_START,
DRAW_CHECKBOX_BOX_DRAW,
DRAW_CHECKBOX_RUN_DRAW,
DRAW_CHECKBOX_TEXT_DRAW,
DRAW_CHECKBOX_TEXT_DRAW_RUN,
DRAW_CHECKBOX_CHECK_SET_DRAW,
DRAW_CHECKBOX_CHECK_DRAW,
DRAW_CHECKBOX_FOCUS_DRAW
} CB_DRAW_STATES;
static CB_DRAW_STATES state = DRAW_CHECKBOX_START;
static int16_t checkIndent;
static uint16_t width;
GFX_GOL_CHECKBOX *pCb;
pCb = (GFX_GOL_CHECKBOX *)pObject;
while(1)
{
if (GFX_RenderStatusGet() == GFX_STATUS_BUSY_BIT)
return (GFX_STATUS_FAILURE);
switch(state)
{
case DRAW_CHECKBOX_RUN_DRAW:
if(GFX_GOL_PanelDraw() != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
state = DRAW_CHECKBOX_TEXT_DRAW;
case DRAW_CHECKBOX_TEXT_DRAW:
if(pCb->pText != NULL)
{
GFX_FontSet(pCb->hdr.pGolScheme->pFont);
if(!GFX_GOL_ObjectStateGet(
pCb,
GFX_GOL_CHECKBOX_DISABLED_STATE))
{
GFX_ColorSet(pCb->hdr.pGolScheme->TextColor0);
}
else
{
GFX_ColorSet(pCb->hdr.pGolScheme->TextColorDisabled);
}
width = pCb->hdr.bottom - pCb->hdr.top;
state = DRAW_CHECKBOX_TEXT_DRAW_RUN;
}
else
{
state = DRAW_CHECKBOX_CHECK_SET_DRAW;
break;
}
case DRAW_CHECKBOX_TEXT_DRAW_RUN:
if (GFX_TextStringBoxDraw(
pCb->hdr.left + width + CB_INDENT,
pCb->hdr.top + pCb->hdr.pGolScheme->EmbossSize,
pCb->hdr.right -
pCb->hdr.left -
(pCb->hdr.pGolScheme->EmbossSize << 1) -
width,
width -
(pCb->hdr.pGolScheme->EmbossSize << 1),
pCb->pText,
0,
pCb->alignment) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
state = DRAW_CHECKBOX_CHECK_SET_DRAW;
break;
case DRAW_CHECKBOX_START:
#ifdef GFX_CONFIG_BISTABLE_DISPLAY_AUTO_REFRESH_ENABLE
GFX_DRIVER_SetupDrawUpdate( pCb->hdr.left,
pCb->hdr.top,
pCb->hdr.right,
pCb->hdr.bottom);
#endif
if(GFX_GOL_ObjectStateGet(pCb, GFX_GOL_CHECKBOX_HIDE_STATE))
{
if (GFX_GOL_ObjectHideDraw(&(pCb->hdr)) != GFX_STATUS_SUCCESS)
return (GFX_STATUS_FAILURE);
#ifdef GFX_CONFIG_BISTABLE_DISPLAY_AUTO_REFRESH_ENABLE
GFX_DRIVER_CompleteDrawUpdate( pCb->hdr.left,
pCb->hdr.top,
pCb->hdr.right,
pCb->hdr.bottom);
#endif
return (GFX_STATUS_SUCCESS);
}
else if(GFX_GOL_ObjectStateGet(
pCb,
GFX_GOL_CHECKBOX_DRAW_STATE))
{
GFX_ColorSet(pCb->hdr.pGolScheme->CommonBkColor);
GFX_GOL_ObjectBackGroundSet(&pCb->hdr);
if(GFX_RectangleFillDraw(
pCb->hdr.left,
pCb->hdr.top,
pCb->hdr.right,
pCb->hdr.bottom) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
}
state = DRAW_CHECKBOX_BOX_DRAW;
case DRAW_CHECKBOX_BOX_DRAW:
GFX_LineStyleSet(GFX_LINE_STYLE_THIN_SOLID);
if(GFX_GOL_ObjectStateGet(
pCb,
GFX_GOL_CHECKBOX_DRAW_STATE))
{
if(GFX_GOL_ObjectStateGet(
pCb,
GFX_GOL_CHECKBOX_DISABLED_STATE))
{
GFX_GOL_PanelParameterSet(
pCb->hdr.left + CB_INDENT,
pCb->hdr.top + CB_INDENT,
pCb->hdr.left + \
(pCb->hdr.bottom - pCb->hdr.top) - CB_INDENT,
pCb->hdr.bottom - CB_INDENT,
0,
pCb->hdr.pGolScheme->ColorDisabled,
pCb->hdr.pGolScheme->EmbossDkColor,
pCb->hdr.pGolScheme->EmbossLtColor,
NULL,
pCb->hdr.pGolScheme->fillStyle,
pCb->hdr.pGolScheme->EmbossSize);
}
else
{
GFX_GOL_PanelParameterSet(
pCb->hdr.left + CB_INDENT,
pCb->hdr.top + CB_INDENT,
pCb->hdr.left + \
(pCb->hdr.bottom - pCb->hdr.top) - CB_INDENT,
pCb->hdr.bottom - CB_INDENT,
0,
pCb->hdr.pGolScheme->Color0,
pCb->hdr.pGolScheme->EmbossDkColor,
pCb->hdr.pGolScheme->EmbossLtColor,
NULL,
pCb->hdr.pGolScheme->fillStyle,
pCb->hdr.pGolScheme->EmbossSize);
}
// set the background information
GFX_GOL_PanelBackgroundSet(&pCb->hdr);
state = DRAW_CHECKBOX_RUN_DRAW;
break;
}
else
{
state = DRAW_CHECKBOX_CHECK_SET_DRAW;
}
case DRAW_CHECKBOX_CHECK_SET_DRAW:
if(GFX_GOL_ObjectStateGet(
pCb,
(GFX_GOL_CHECKBOX_DRAW_STATE | GFX_GOL_CHECKBOX_DRAW_CHECK_STATE)))
{
if(!GFX_GOL_ObjectStateGet(
pCb,
GFX_GOL_CHECKBOX_DISABLED_STATE))
{
if(GFX_GOL_ObjectStateGet(
pCb,
GFX_GOL_CHECKBOX_CHECKED_STATE))
{
GFX_ColorSet(pCb->hdr.pGolScheme->TextColor0);
GFX_FillStyleSet(GFX_FILL_STYLE_COLOR);
}
else
{
GFX_GOL_ObjectBackGroundSet(&pCb->hdr);
GFX_ColorSet(pCb->hdr.pGolScheme->Color0);
}
}
else
{
if(GFX_GOL_ObjectStateGet(
pCb,
GFX_GOL_CHECKBOX_CHECKED_STATE))
{
GFX_ColorSet(pCb->hdr.pGolScheme->TextColorDisabled);
GFX_FillStyleSet(GFX_FILL_STYLE_COLOR);
}
else
{
GFX_GOL_ObjectBackGroundSet(&pCb->hdr);
GFX_ColorSet(pCb->hdr.pGolScheme->ColorDisabled);
}
}
checkIndent = (pCb->hdr.bottom - pCb->hdr.top) >> 2;
state = DRAW_CHECKBOX_CHECK_DRAW;
}
else
{
state = DRAW_CHECKBOX_FOCUS_DRAW;
break;
}
case DRAW_CHECKBOX_CHECK_DRAW:
if ( GFX_RectangleFillDraw(
pCb->hdr.left +
checkIndent + pCb->hdr.pGolScheme->EmbossSize,
pCb->hdr.top +
checkIndent + pCb->hdr.pGolScheme->EmbossSize,
pCb->hdr.left +
(pCb->hdr.bottom - pCb->hdr.top) -
checkIndent - pCb->hdr.pGolScheme->EmbossSize,
pCb->hdr.bottom -
checkIndent - pCb->hdr.pGolScheme->EmbossSize)
!= GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
state = DRAW_CHECKBOX_FOCUS_DRAW;
case DRAW_CHECKBOX_FOCUS_DRAW:
if(GFX_GOL_ObjectStateGet(
pCb,
(GFX_GOL_CHECKBOX_DRAW_STATE |
GFX_GOL_CHECKBOX_DRAW_FOCUS_STATE)))
{
if(GFX_GOL_ObjectStateGet(
pCb,
GFX_GOL_CHECKBOX_FOCUSED_STATE))
{
GFX_ColorSet(pCb->hdr.pGolScheme->TextColor0);
}
else
{
GFX_ColorSet(pCb->hdr.pGolScheme->CommonBkColor);
}
GFX_LineStyleSet(GFX_LINE_STYLE_THIN_DASHED);
if(GFX_RectangleDraw(
pCb->hdr.left,
pCb->hdr.top,
pCb->hdr.right,
pCb->hdr.bottom) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
GFX_LineStyleSet(GFX_LINE_STYLE_THIN_SOLID);
}
state = DRAW_CHECKBOX_START;
#ifdef GFX_CONFIG_BISTABLE_DISPLAY_AUTO_REFRESH_ENABLE
GFX_DRIVER_CompleteDrawUpdate( pCb->hdr.left,
pCb->hdr.top,
pCb->hdr.right,
pCb->hdr.bottom);
#endif
return (GFX_STATUS_SUCCESS);
} // end of switch()
} // end of while(1)
// *****************************************************************************
GFX_STATUS GFX_GOL_EditBoxDraw(void *pObject)
{
typedef enum
{
DRAW_EDITBOX_START,
DRAW_EDITBOX_PANEL,
DRAW_EDITBOX_PREPARE_TEXT,
DRAW_EDITBOX_TEXT,
DRAW_EDITBOX_CARET,
} DRAW_EDITBOX_STATES;
static DRAW_EDITBOX_STATES state = DRAW_EDITBOX_START;
static GFX_COLOR tempColor;
GFX_GOL_EDITBOX *pEb;
pEb = (GFX_GOL_EDITBOX *)pObject;
while(1)
{
if (GFX_RenderStatusGet() == GFX_STATUS_BUSY_BIT)
return (GFX_STATUS_FAILURE);
switch(state)
{
case DRAW_EDITBOX_START:
#ifdef GFX_LIB_CFG_USE_BISTABLE_DISPLAY_GOL_AUTO_REFRESH
GFX_DRIVER_SetupDrawUpdate( pEb->hdr.left,
pEb->hdr.top,
pEb->hdr.right,
pEb->hdr.bottom);
#endif
if(GFX_GOL_ObjectStateGet(pEb, GFX_GOL_EDITBOX_HIDE_STATE))
{
// Hide the object (remove from screen)
if (GFX_GOL_ObjectHideDraw(&(pEb->hdr)) != GFX_STATUS_SUCCESS)
return (GFX_STATUS_FAILURE);
#ifdef GFX_LIB_CFG_USE_BISTABLE_DISPLAY_GOL_AUTO_REFRESH
GFX_DRIVER_CompleteDrawUpdate( pEb->hdr.left,
pEb->hdr.top,
pEb->hdr.right,
pEb->hdr.bottom);
#endif
return (GFX_STATUS_SUCCESS);
}
if(GFX_GOL_ObjectStateGet(pEb,GFX_GOL_EDITBOX_DISABLED_STATE))
{
tempColor = pEb->hdr.pGolScheme->ColorDisabled;
}
else
{
tempColor = pEb->hdr.pGolScheme->Color0;
}
if(GFX_GOL_ObjectStateGet(pEb,GFX_GOL_EDITBOX_DRAW_STATE))
{
// set up the background
GFX_GOL_PanelBackgroundSet(&pEb->hdr);
// set panel parameters
GFX_GOL_PanelParameterSet
(
pEb->hdr.left,
pEb->hdr.top,
pEb->hdr.right,
pEb->hdr.bottom,
0,
tempColor,
pEb->hdr.pGolScheme->EmbossDkColor,
pEb->hdr.pGolScheme->EmbossLtColor,
NULL,
pEb->hdr.pGolScheme->fillStyle,
pEb->hdr.pGolScheme->EmbossSize
);
state = DRAW_EDITBOX_PANEL;
// no break here since it will always go
// to the DRAW_EDITBOX_PANEL state
}
else
{
state = DRAW_EDITBOX_PREPARE_TEXT;
break;
}
case DRAW_EDITBOX_PANEL:
if(GFX_GOL_PanelDraw() != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
}
state = DRAW_EDITBOX_PREPARE_TEXT;
// no break here since it will always go to
// the DRAW_EDITBOX_PREPARE_TEXT state
case DRAW_EDITBOX_PREPARE_TEXT:
GFX_FontSet(pEb->hdr.pGolScheme->pFont);
if(GFX_GOL_ObjectStateGet(pEb,GFX_GOL_EDITBOX_DISABLED_STATE))
{
GFX_ColorSet(pEb->hdr.pGolScheme->TextColorDisabled);
}
else
{
GFX_ColorSet(pEb->hdr.pGolScheme->TextColor0);
}
state = DRAW_EDITBOX_TEXT;
// no break here since it will always go to
// the DRAW_EDITBOX_TEXT state
case DRAW_EDITBOX_TEXT:
// render the text
if (GFX_TextStringBoxDraw(
pEb->hdr.left + pEb->hdr.pGolScheme->EmbossSize,
pEb->hdr.top + pEb->hdr.pGolScheme->EmbossSize,
pEb->hdr.right - pEb->hdr.left -
(pEb->hdr.pGolScheme->EmbossSize << 1),
pEb->hdr.bottom - pEb->hdr.top -
(pEb->hdr.pGolScheme->EmbossSize << 1),
pEb->pText,
0,
pEb->alignment) != GFX_STATUS_SUCCESS)
{
return (GFX_STATUS_FAILURE);
};
// draw the caret if required
if(!GFX_GOL_ObjectStateGet(
pEb,
GFX_GOL_EDITBOX_DISABLED_STATE))
{
if( (GFX_GOL_ObjectStateGet(
pEb,
GFX_GOL_EDITBOX_FOCUSED_STATE) &&
GFX_GOL_ObjectStateGet(
pEb,
GFX_GOL_EDITBOX_DRAW_CARET_STATE)
) ||
(GFX_GOL_ObjectStateGet(
pEb,
GFX_GOL_EDITBOX_ENABLE_CARET_STATE)
)
)
{
GFX_ColorSet(pEb->hdr.pGolScheme->TextColor0);
}
else
{
GFX_ColorSet(pEb->hdr.pGolScheme->Color0);
}
state = DRAW_EDITBOX_CARET;
// no break here since it will always go to
// the DRAW_EDITBOX_CARET state
}
else
{
state = DRAW_EDITBOX_START;
#ifdef GFX_LIB_CFG_USE_BISTABLE_DISPLAY_GOL_AUTO_REFRESH
GFX_DRIVER_CompleteDrawUpdate( pEb->hdr.left,
pEb->hdr.top,
pEb->hdr.right,
pEb->hdr.bottom);
#endif
return (GFX_STATUS_SUCCESS);
}
case DRAW_EDITBOX_CARET:
// draw the caret if required
if(!GFX_BarDraw(
GFX_TextCursorPositionXGet(),
GFX_TextCursorPositionYGet(),
GFX_TextCursorPositionXGet() +
GFX_GOL_EDITBOX_CARET_WIDTH,
GFX_TextCursorPositionYGet() +
pEb->textHeight)
)
{
return (GFX_STATUS_FAILURE);
}
state = DRAW_EDITBOX_START;
#ifdef GFX_LIB_CFG_USE_BISTABLE_DISPLAY_GOL_AUTO_REFRESH
GFX_DRIVER_CompleteDrawUpdate( pEb->hdr.left,
pEb->hdr.top,
pEb->hdr.right,
pEb->hdr.bottom);
#endif
return (GFX_STATUS_SUCCESS);
} // switch()
}// while(1)
}
void PagingDemo(void)
{
int x,y;
GFX_XCHAR Scroll[] = {'C','o','l','o','r','s',' ','C','h','a','n','g','e',' ','w',' ','T','e','m','p','s',0};
GFX_XCHAR Cloud[] = {'C','l','o','u','d','y',0};
GFX_XCHAR Temper[] = {'T','e','m','p','e','r','a','t','u','r','e',0};
GFX_XCHAR SetTemp[] = {'S','e','t',' ','T','e','m','p',0};
GFX_XCHAR Time[] = {'8',':','2','0',' ','P','M',0};
GFX_XCHAR Date[] = {'J','u','n','e',' ','1','1',',',' ','2','0','1','2',0};
GFX_XCHAR Room[] = {'7','4',0};
while(GFX_PageSet(ACTIVE_PAGE,PIP_BUFFER) == GFX_STATUS_FAILURE);
GFX_GradientColorSet(GFX_RGBConvert(55,0,0),BLACK);
GFX_GradientTypeSet(GFX_FILL_STYLE_GRADIENT_DOWN);
while(GFX_BarGradientDraw(0,0,GFX_MaxXGet(),55) == GFX_STATUS_FAILURE);
GFX_ColorSet(WHITE);
GFX_FontSet((void *) &Monospaced_plain_36);
while(GFX_TextStringBoxDraw(0,0,0,0,(GFX_XCHAR*)Scroll,0,GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
GFX_XCHAR Temp[] ={'7','3',0};
for(x=0;x<2;x++)
{
while(GFX_PageSet(ACTIVE_PAGE,x) == GFX_STATUS_FAILURE);
if(x==0)
{
GFX_GradientColorSet(BRIGHTRED,BLACK);
while(GFX_BarGradientDraw(0,0,GFX_MaxXGet(),GFX_MaxYGet())== GFX_STATUS_FAILURE);
}
else
{
GFX_GradientColorSet(BRIGHTBLUE,BLACK);
while(GFX_BarGradientDraw(0,0,GFX_MaxXGet(),GFX_MaxYGet()) == GFX_STATUS_FAILURE);
}
GFX_GradientColorSet(WHITE,BLACK);
while(GFX_BevelGradientDraw(340,120,370,140,10) == GFX_STATUS_FAILURE);
while(GFX_BevelGradientDraw(340,165,370,185,10) == GFX_STATUS_FAILURE);
GFX_ColorSet(WHITE);
GFX_FontSet((void *) &Gentium_16);
while(GFX_TextStringBoxDraw(50,75,0,0,(GFX_XCHAR*)Cloud,0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
while(GFX_TextStringBoxDraw(190,75,0,0,(GFX_XCHAR*)Temper,0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
while(GFX_TextStringBoxDraw(380,75,0,0,(GFX_XCHAR*)SetTemp,0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
GFX_ColorSet(WHITE);
while(GFX_TextStringBoxDraw(GFX_MaxXGet()-80,0,0,0,(GFX_XCHAR*)Time,0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
while(GFX_TextStringBoxDraw(10,0,0,0,(GFX_XCHAR*)Date,0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
GFX_FontSet((void *) &Monospaced_plain_36);
while(GFX_TextStringBoxDraw(345,100,0,0,(GFX_XCHAR*)"+",0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
while(GFX_TextStringBoxDraw(345,145,0,0,(GFX_XCHAR*)"-",0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
GFX_FontSet((void *) &Monospaced_bold_Bold_72);
if(x==0)
{
while(GFX_TextStringBoxDraw(210,100,0,0,(GFX_XCHAR*)Temp,0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE); //Room Temp
}
while(GFX_TextStringBoxDraw(385,100,0,0,(GFX_XCHAR*)Room,0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
while(ImageDecode
(
(void *)&clouds,
IMG_JPEG,
10,
100,
10 + clouds_WIDTH,
100 + clouds_HEIGHT,
0,
&_jpegFileApi,
NULL
) == 0xff);
}
while(GFX_PageSet(ACTIVE_PAGE,0) == GFX_STATUS_FAILURE);
while(GFX_PageSet(VISUAL_PAGE,0) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_PAGE, PIP_BUFFER, 0) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_SIZE, GFX_MaxXGet()-10, 55) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_PAGE_START, 0, GFX_MaxYGet()-56) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_LAYER_START, 0, 0) == GFX_STATUS_FAILURE);
SYS_TMR_DelayMS(1000);
x=0;
while(x++ < 3)
{
while(GFX_Layer(0, DISABLE, 0, 0) == GFX_STATUS_FAILURE);
SYS_TMR_DelayMS(500);
while(GFX_Layer(0, ENABLE, 0, 0) == GFX_STATUS_FAILURE);
SYS_TMR_DelayMS(500);
}
x = 0;
while(x++ < 465)
{
while(GFX_Layer(0, SET_LAYER_START, x, 0) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_SIZE, GFX_MaxXGet()-10-x, 55) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, UPDATE, 0, 0) == GFX_STATUS_FAILURE);
SYS_TMR_DelayMS(10);
}
while(GFX_Layer(0, DISABLE, 0, 0) == GFX_STATUS_FAILURE);
GFX_ColorSet(WHITE);
for(x=0;x<1;x++)
{
Temp[1] += 1; SYS_TMR_DelayMS(1000);
GFX_GradientColorSet(GFX_RGBConvert(148,0,0),BLACK);
GFX_GradientTypeSet(GFX_FILL_STYLE_GRADIENT_DOWN);
while(GFX_BarGradientDraw(250,116,300,GFX_MaxYGet()) == GFX_STATUS_FAILURE);
GFX_ColorSet(WHITE);
GFX_FontSet((void *) &Gentium_16);
while(GFX_TextStringBoxDraw(190,75,0,0,(GFX_XCHAR*)Temper,0,GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
GFX_FontSet((void *) &Monospaced_bold_Bold_72);
while(GFX_TextStringBoxDraw(210,100,0,0,(GFX_XCHAR*)Temp,0,GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
}
while(GFX_PageSet(ACTIVE_PAGE,1) == GFX_STATUS_FAILURE);
while(GFX_TextStringBoxDraw(210,100,0,0,(GFX_XCHAR*)Temp,0,GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
while(GFX_PageSet(VISUAL_PAGE,1) == GFX_STATUS_FAILURE);
SYS_TMR_DelayMS(2000);
while(GFX_PageSet(ACTIVE_PAGE, 0) == GFX_STATUS_FAILURE);
while(GFX_PageSet(VISUAL_PAGE, 0) == GFX_STATUS_FAILURE);
GFX_ColorSet(WHITE);
while(GFX_ScreenClear() == GFX_STATUS_FAILURE);
}
void PIPDemo(void)
{
int x,y;
GFX_XCHAR Title1[] = {'P','I','P',' ','D','e','m','o',0};
GFX_XCHAR Title2[] = {'P','a','g','e',0};
GFX_XCHAR Title3[] = {'S','t','a','r','t',0};
while(GFX_PageSet(ACTIVE_PAGE,0) == GFX_STATUS_FAILURE);
while(GFX_PageSet(VISUAL_PAGE,0) == GFX_STATUS_FAILURE);
GFX_ColorSet(BLACK);
while(GFX_ScreenClear() == GFX_STATUS_FAILURE);
while(GFX_PageSet(ACTIVE_PAGE,PIP_BUFFER) == GFX_STATUS_FAILURE);
GFX_ColorSet(BLACK);
while(GFX_ScreenClear() == GFX_STATUS_FAILURE);
while(GFX_ImageDraw(0,0, (void*)&mouse) == GFX_STATUS_FAILURE); //Draw Mouse in cursor area
while(GFX_ImageDraw(15,0, (void*)&Pacman) == GFX_STATUS_FAILURE); //Draw Pacman in cursor area
while(GFX_PageSet(ACTIVE_PAGE,0) == GFX_STATUS_FAILURE);
GFX_FontSet((void *) &Monospaced_plain_36);
GFX_ColorSet(WHITE);
while(GFX_TextStringBoxDraw(0,40,0,0,(GFX_XCHAR*)Title1,0,GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
while(GFX_TextStringBoxDraw(0,90,0,0,(GFX_XCHAR*)Title2,0,GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
GFX_GradientColorSet(WHITE,BLACK);
GFX_GradientTypeSet(GFX_FILL_STYLE_GRADIENT_DOWN);
while(GFX_BevelGradientDraw(200,125,300,165,5) == GFX_STATUS_FAILURE);
GFX_ColorSet(BLACK);
while(GFX_TextStringBoxDraw(195,115,0,0,(GFX_XCHAR*)Title3,0,GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_PAGE, PIP_BUFFER, 0) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_SIZE, 15, 15) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_LAYER_START, 0, 0) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, ENABLE, 0, 0) == GFX_STATUS_FAILURE);
x = 0;
y = 224;
while(x<280)
{
while(GFX_Layer(0, SET_PAGE_START, x, y) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, UPDATE, 0, 0) == GFX_STATUS_FAILURE);
y--;
SYS_TMR_DelayMS(40);
x+=5;
}
SYS_TMR_DelayMS(500);
GFX_GradientColorSet(BLUE,BLACK);
GFX_GradientTypeSet(GFX_FILL_STYLE_GRADIENT_DOWN);
while(GFX_BevelGradientDraw(200,125,300,165,5)==GFX_STATUS_FAILURE);
GFX_ColorSet(WHITE);
while(GFX_TextStringBoxDraw(195,115,0,0,(GFX_XCHAR*)Title3,0, GFX_ALIGN_LEFT) == GFX_STATUS_FAILURE);
SYS_TMR_DelayMS(1000);
while(GFX_Layer(0, DISABLE, 0, 0) == GFX_STATUS_FAILURE);
SYS_TMR_DelayMS(1000);
x = GFX_MaxXGet()-50;
GFX_ColorSet(BLACK);
while(GFX_Layer(0, SET_SIZE, 45, 45) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_LAYER_START, 15, 0) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, ENABLE, 0, 0) == GFX_STATUS_FAILURE);
while(x>5)
{
while(GFX_Layer(0, SET_PAGE_START, x, 32) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_LAYER_START, 15, 0) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, UPDATE, 0, 0) == GFX_STATUS_FAILURE);
SYS_TMR_DelayMS(40);
while(GFX_Layer(0, SET_PAGE_START, x-5, 32) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, SET_LAYER_START, 60, 0) == GFX_STATUS_FAILURE);
while(GFX_Layer(0, UPDATE, 0, 0) == GFX_STATUS_FAILURE);
SYS_TMR_DelayMS(40);
x -= 10;
}
while(GFX_Layer(0, DISABLE, 0, 0) == GFX_STATUS_FAILURE);
}
