/********************************************************************* * Function: uint16_t PictTranslateMsg(void *pObj, GFX_OBJ_MESSAGE *pMsg) * * Overview: translates the GOL message for the picture control * ********************************************************************/ GFX_GOL_TRANSLATED_ACTION GFX_GOL_PictureControlActionGet(void *pObj, GFX_GOL_MESSAGE *pMsg) { GFX_GOL_PICTURECONTROL *pPict; pPict = (GFX_GOL_PICTURECONTROL *)pObj; // Evaluate if the message is for the picture // Check if disabled first if(GFX_GOL_ObjectStateGet(pPict, GFX_GOL_PICTURECONTROL_DISABLED_STATE)) return (GFX_GOL_OBJECT_ACTION_INVALID); #ifdef USE_TOUCHSCREEN if(pMsg->type == TYPE_TOUCHSCREEN) { // Check if it falls in the picture area if ( (pPict->hdr.left < pMsg->param1) && (pPict->hdr.right > pMsg->param1) && (pPict->hdr.top < pMsg->param2) && (pPict->hdr.bottom > pMsg->param2) ) { return (GFX_GOL_PICTURECONTROL_ACTION_SELECTED); } } #endif return (GFX_GOL_OBJECT_ACTION_INVALID); }
/********************************************************************* * Function: uint16_t StTranslateMsg(void *pObj, GFX_GOL_MESSAGE *pMsg) * * Notes: Evaluates the message if the object will be affected by the * message or not. * ********************************************************************/ GFX_GOL_TRANSLATED_ACTION GFX_GOL_StaticTextActionGet(void *pObj, GFX_GOL_MESSAGE *pMsg) { GFX_GOL_STATICTEXT *pSt; pSt = (GFX_GOL_STATICTEXT *) pObj; // Evaluate if the message is for the static text // Check if disabled first if (GFX_GOL_ObjectStateGet(pSt, GFX_GOL_STATICTEXT_DISABLED_STATE)) return (GFX_GOL_OBJECT_ACTION_INVALID); #ifdef USE_TOUCHSCREEN if (pMsg->type == TYPE_TOUCHSCREEN) { // Check if it falls in static text control borders if ( (pSt->hdr.left < pMsg->param1) && (pSt->hdr.right > pMsg->param1) && (pSt->hdr.top < pMsg->param2) && (pSt->hdr.bottom > pMsg->param2) ) { return (GFX_GOL_STATICTEXT_ACTION_SELECTED); } } #endif return (GFX_GOL_OBJECT_ACTION_INVALID); }
/********************************************************************* * Function: uint16_t SldGetHeight(GFX_GOL_SCROLLBAR *pSld) * * Notes: An INTERNAL function that computes for the height * of the thumb. This function is created to save * code size. This function is called only to dynamically * compute for the thumb size. * ********************************************************************/ uint16_t SldGetHeight(GFX_GOL_SCROLLBAR *pSld) { uint16_t temp; /* Calculating the height is dependent on the mode type. If type Scrollbar, width is dependent on the ratio of the page/range = width/max-min (see SetThumbSize()) if type is Slider, width is dependent on width*3/8 When vertical height is dynamic, width is contant. */ if (GFX_GOL_ObjectStateGet(pSld, GFX_GOL_SCROLLBAR_VERTICAL_STATE)) { if (GFX_GOL_ObjectStateGet(pSld, GFX_GOL_SCROLLBAR_SLIDER_MODE_STATE)) { temp = SldSetThumbSize(pSld, pSld->hdr.bottom, pSld->hdr.top); } else { temp = (((pSld->hdr.right - pSld->hdr.left) - (GFX_GOL_EMBOSS_SIZE << 1) - 2) * 3) >> 3; } } else {
/********************************************************************* * Function: uint16_t SldGetWidth(GFX_GOL_SCROLLBAR *pSld) * * Notes: An INTERNAL function that computes for the width * of the thumb. This function is created to save * code size. This function is called only to dynamically * compute for the thumb size. * ********************************************************************/ uint16_t SldGetWidth(GFX_GOL_SCROLLBAR *pSld) { uint16_t temp; /* Calculating the width is dependent on the mode type. If type Scrollbar, width is dependent on the ratio of the page/range = width/max-min (see SetThumbSize()) if type is Slider, width is dependent on height*3/8 When horizontal width is dynamic, height is contant. */ if (GFX_GOL_ObjectStateGet(pSld, GFX_GOL_SCROLLBAR_VERTICAL_STATE)) { temp = pSld->hdr.right - pSld->hdr.left; if (GFX_GOL_ObjectStateGet(pSld, GFX_GOL_SCROLLBAR_SLIDER_MODE_STATE)) { temp = temp - (GFX_GOL_EMBOSS_SIZE << 1); } else { temp = temp - (GFX_GOL_EMBOSS_SIZE << 1) - 2; } } else { if (GFX_GOL_ObjectStateGet(pSld, GFX_GOL_SCROLLBAR_SLIDER_MODE_STATE)) { temp = SldSetThumbSize(pSld, pSld->hdr.right, pSld->hdr.left); } else { temp = (((pSld->hdr.bottom - pSld->hdr.top) - (GFX_GOL_EMBOSS_SIZE << 1) - 2) * 3) >> 3; } } // to avoid calculations of dividing by two, we store half the width value return (temp >> 1); }
// ***************************************************************************** GFX_GOL_TRANSLATED_ACTION GFX_GOL_EditBoxActionGet( void *pObject, GFX_GOL_MESSAGE *pMessage) { GFX_GOL_EDITBOX *pEb; pEb = (GFX_GOL_EDITBOX *)pObject; // Evaluate if the message is for the edit box // Check if disabled first if (GFX_GOL_ObjectStateGet(pEb, GFX_GOL_EDITBOX_DISABLED_STATE)) return (GFX_GOL_OBJECT_ACTION_INVALID); #ifndef GFX_CONFIG_USE_TOUCHSCREEN_DISABLE if(pMessage->type == TYPE_TOUCHSCREEN) { // Check if it falls in edit box borders if( (pEb->hdr.left < pMessage->param1) && (pEb->hdr.right > pMessage->param1) && (pEb->hdr.top < pMessage->param2) && (pEb->hdr.bottom > pMessage->param2)) { return GFX_GOL_EDITBOX_ACTION_TOUCHSCREEN; } return GFX_GOL_OBJECT_ACTION_INVALID; } #endif #ifndef GFX_CONFIG_USE_KEYBOARD_DISABLE if(pMessage->type == TYPE_KEYBOARD) { if(pMessage->uiEvent == EVENT_CHARCODE) return GFX_GOL_EDITBOX_ACTION_ADD_CHAR; if(pMessage->uiEvent == EVENT_KEYSCAN) if(pMessage->param2 == SCAN_BS_PRESSED) return GFX_GOL_EDITBOX_ACTION_DEL_CHAR; return GFX_GOL_OBJECT_ACTION_INVALID; } #endif return GFX_GOL_OBJECT_ACTION_INVALID; }
// ***************************************************************************** void GFX_GOL_CheckBoxActionSet( GFX_GOL_TRANSLATED_ACTION translatedMsg, void *pObject, GFX_GOL_MESSAGE *pMessage) { GFX_GOL_CHECKBOX *pCb; pCb = (GFX_GOL_CHECKBOX *)pObject; #ifndef GFX_CONFIG_FOCUS_DISABLE #ifndef GFX_CONFIG_USE_TOUCHSCREEN_DISABLE if(pMsg->type == TYPE_TOUCHSCREEN) { if(!GFX_GOL_ObjectStateGet(pCb, GFX_GOL_CHECKBOX_FOCUSED_STATE)) { GFX_GOL_ObjectFocusSet((OBJ_HEADER *)pCb); } } #endif #endif switch(translatedMsg) { case GFX_GOL_CHECKBOX_ACTION_CHECKED: // Set checked and redraw GFX_GOL_ObjectStateSet( pCb, GFX_GOL_CHECKBOX_CHECKED_STATE | GFX_GOL_CHECKBOX_DRAW_CHECK_STATE); break; case GFX_GOL_CHECKBOX_ACTION_UNCHECKED: // Reset check GFX_GOL_ObjectStateClear(pCb, GFX_GOL_CHECKBOX_CHECKED_STATE); // Redraw GFX_GOL_ObjectStateSet(pCb, GFX_GOL_CHECKBOX_DRAW_CHECK_STATE); break; default: // do nothing return; } }
// ***************************************************************************** void GFX_GOL_EditBoxActionSet( GFX_GOL_TRANSLATED_ACTION translatedMsg, void *pObject, GFX_GOL_MESSAGE *pMessage) { GFX_GOL_EDITBOX *pEb; pEb = (GFX_GOL_EDITBOX *)pObject; #if defined(GFX_LIB_CFG_USE_FOCUS) #ifndef GFX_CONFIG_USE_TOUCHSCREEN_DISABLE if(pMessage->type == TYPE_TOUCHSCREEN) { if(!GFX_GOL_ObjectStateGet(pEb,GFX_GOL_EDITBOX_FOCUSED_STATE)){ GFX_GOL_ObjectFocusSet((OBJ_HEADER*)pEb); } } #endif #endif switch(translatedMsg) { case GFX_GOL_EDITBOX_ACTION_ADD_CHAR: GFX_GOL_EditBoxCharAdd(pEb,(GFX_XCHAR)pMessage->param2); GFX_GOL_ObjectStateSet(pEb, GFX_GOL_EDITBOX_DRAW_STATE); break; case GFX_GOL_EDITBOX_ACTION_DEL_CHAR: GFX_GOL_EditBoxCharRemove(pEb); GFX_GOL_ObjectStateSet(pEb, GFX_GOL_EDITBOX_DRAW_STATE); break; default: // do nothing break; } }
/********************************************************************* * Function: uint16_t GFX_GOL_PictureDraw(void *pObj) * * Output: returns the status of the drawing * 0 - not completed * 1 - done * * Overview: draws picture * ********************************************************************/ GFX_STATUS GFX_GOL_PictureControlDraw(void *pObj) { typedef enum { REMOVE, DRAW_IMAGE, DRAW_BACKGROUND1, DRAW_BACKGROUND2, DRAW_BACKGROUND3, DRAW_BACKGROUND4, DRAW_FRAME, } GFX_GOL_PICTURE_DRAW_STATES; static GFX_GOL_PICTURE_DRAW_STATES state = REMOVE; static uint16_t posleft; static uint16_t postop; static uint16_t posright; static uint16_t posbottom; static GFX_STATUS index = GFX_STATUS_FAILURE; GFX_GOL_PICTURECONTROL *pPict; pPict = (GFX_GOL_PICTURECONTROL *)pObj; switch(state) { case REMOVE: if(GFX_GOL_ObjectStateGet(pPict, GFX_GOL_PICTURECONTROL_HIDE_STATE)) { GFX_ColorSet(pPict->hdr.pGolScheme->CommonBkColor); if(GFX_RectangleFillDraw(pPict->hdr.left, pPict->hdr.top, pPict->hdr.right, pPict->hdr.bottom) == GFX_STATUS_FAILURE) return (GFX_STATUS_FAILURE); return (GFX_STATUS_SUCCESS); } posleft = (pPict->hdr.left + 1 + pPict->hdr.right - pPict->scaleFactor * GFX_ImageWidthGet(pPict->pImage)) >> 1; postop = (pPict->hdr.top + 1 + pPict->hdr.bottom - pPict->scaleFactor * GFX_ImageHeightGet(pPict->pImage)) >> 1; posright = (pPict->hdr.right + pPict->hdr.left + pPict->scaleFactor * GFX_ImageWidthGet(pPict->pImage)) >> 1; posbottom = (pPict->hdr.bottom + pPict->hdr.top + pPict->scaleFactor * GFX_ImageHeightGet(pPict->pImage)) >> 1; GFX_ImageStretchSet(pPict->scaleFactor); state = DRAW_IMAGE; case DRAW_IMAGE: if(pPict->pImage != NULL) { if(GFX_ImagePartialDraw(posleft, postop, pPict->partial.xoffset,pPict->partial.yoffset,pPict->partial.width,pPict->partial.height, pPict->pImage)==GFX_STATUS_FAILURE) return (GFX_STATUS_FAILURE); } if(GFX_GOL_ObjectStateGet(pPict, GFX_GOL_PICTURECONTROL_STREAM_STATE)) { if(pPict->count > 0) { SYS_TMR_DelayMS(pPict->delay); pPict->count -= 1; pPict->pImage = (GFX_RESOURCE_HDR*)*pPict->stream++; //Index to next bitmap in stream return(GFX_STATUS_FAILURE); } } state = DRAW_BACKGROUND1; case DRAW_BACKGROUND1: GFX_ColorSet(pPict->hdr.pGolScheme->CommonBkColor); if(GFX_RectangleFillDraw(pPict->hdr.left + 1, pPict->hdr.top + 1, pPict->hdr.right - 1, postop - 1) == GFX_STATUS_FAILURE) return (GFX_STATUS_FAILURE); state = DRAW_BACKGROUND2; case DRAW_BACKGROUND2: if(GFX_RectangleFillDraw(pPict->hdr.left + 1, posbottom, pPict->hdr.right - 1, pPict->hdr.bottom - 1) == GFX_STATUS_FAILURE) return (GFX_STATUS_FAILURE); state = DRAW_BACKGROUND3; case DRAW_BACKGROUND3: if(GFX_RectangleFillDraw(pPict->hdr.left + 1, postop, posleft - 1, posbottom) == GFX_STATUS_FAILURE) return (GFX_STATUS_FAILURE); state = DRAW_BACKGROUND4; case DRAW_BACKGROUND4: index = GFX_RectangleFillDraw(posright, postop, pPict->hdr.right - 1, posbottom); if(index == GFX_STATUS_FAILURE) { return (GFX_STATUS_FAILURE); } state = DRAW_FRAME; case DRAW_FRAME: if(GFX_GOL_ObjectStateGet(pPict, GFX_GOL_PICTURECONTROL_FRAME_STATE)) { GFX_LineStyleSet(GFX_LINE_STYLE_THIN_SOLID); GFX_ColorSet(pPict->hdr.pGolScheme->TextColor0); index = GFX_RectangleDraw(pPict->hdr.left, pPict->hdr.top, pPict->hdr.right, pPict->hdr.bottom); if(index == GFX_STATUS_FAILURE) { return (GFX_STATUS_FAILURE); } } state = REMOVE; return (GFX_STATUS_SUCCESS); } return (GFX_STATUS_SUCCESS); }
/********************************************************************* * 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; 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) }
// ***************************************************************************** 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_GOL_TRANSLATED_ACTION GFX_GOL_CheckBoxActionGet( void *pObject, GFX_GOL_MESSAGE *pMessage) { GFX_GOL_CHECKBOX *pCb; pCb = (GFX_GOL_CHECKBOX *)pObject; // Evaluate if the message is for the check box // Check if disabled first if(GFX_GOL_ObjectStateGet(pCb, GFX_GOL_CHECKBOX_DISABLED_STATE)) return (GFX_GOL_OBJECT_ACTION_INVALID); #ifndef GFX_CONFIG_USE_TOUCHSCREEN_DISABLE if(pMessage->type == TYPE_TOUCHSCREEN) { // Check if it falls in the check box borders if ( (pCb->hdr.left < pMessage->param1) && (pCb->hdr.right > pMessage->param1) && (pCb->hdr.top < pMessage->param2) && (pCb->hdr.bottom > pMessage->param2) ) { if(pMessage->uiEvent == EVENT_RELEASE) { if(GFX_GOL_ObjectStateGet(pCb, GFX_GOL_CHECKBOX_CHECKED_STATE)) return (GFX_GOL_CHECKBOX_ACTION_UNCHECKED); else return (GFX_GOL_CHECKBOX_ACTION_CHECKED); } } return (GFX_GOL_OBJECT_ACTION_INVALID); } #endif #ifndef GFX_CONFIG_USE_KEYBOARD_DISABLE if(pMessage->type == TYPE_KEYBOARD) { if((uint16_t)pMessage->param1 == pCb->hdr.ID) { if(pMessage->uiEvent == EVENT_KEYSCAN) { if( (pMessage->param2 == SCAN_SPACE_PRESSED) || (pMessage->param2 == SCAN_CR_PRESSED)) { if(GFX_GOL_ObjectStateGet( pCb, GFX_GOL_CHECKBOX_CHECKED_STATE)) { return (GFX_GOL_CHECKBOX_ACTION_UNCHECKED); } else { return (GFX_GOL_CHECKBOX_ACTION_CHECKED); } } } } return (GFX_GOL_OBJECT_ACTION_INVALID); } #endif return (GFX_GOL_OBJECT_ACTION_INVALID); }
// ***************************************************************************** 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) }
///////////////////////////////////////////////////////////////////////////// // Function: WORD GOLMsgCallback(WORD objMsg, OBJ_HEADER* pObj, GOL_MSG* pMsg) // Input: objMsg - translated message for the object, // pObj - pointer to the object, // pMsg - pointer to the non-translated, raw GOL message // Output: if the function returns non-zero the message will be processed by default // Overview: it's a user defined function. GOLMsg() function calls it each // time the valid message for the object received ///////////////////////////////////////////////////////////////////////////// bool GFX_GOL_MessageCallback(GFX_GOL_TRANSLATED_ACTION objMsg, GFX_GOL_OBJ_HEADER *pObj, GFX_GOL_MESSAGE *pMsg) { uint16_t objID; // check first if we need to exit the selected demo (if applicable) if ((objMsg == GFX_GOL_BUTTON_ACTION_RELEASED) && (pObj->ID == ID_BACK)) { // check if the button is indeed pressed if (GFX_GOL_ObjectStateGet(pObj, GFX_GOL_BUTTON_PRESSED_STATE)) { screenState = CREATE_MAINMENU; return 1; } } // process messages for demo screens switch(screenState) { case DISPLAY_MAINMENU: // In this portion, all management of the Button states are // done here. This portion will always return 0 to inhibit // the button default message processing to take place. objID = GFX_GOL_ObjectIDGet(pObj); if ((objID == ID_ICON1) || (objID == ID_ICON2) || (objID == ID_ICON3) || (objID == ID_ICON4)) { if(objMsg == GFX_GOL_BUTTON_ACTION_PRESSED) { // check if button is pressed and show pressed icon GFX_GOL_ObjectStateSet(pObj, GFX_GOL_BUTTON_PRESSED_STATE); } else if(objMsg == GFX_GOL_BUTTON_ACTION_RELEASED) { // check if button is released and show release icon GFX_GOL_ObjectStateClear(pObj, GFX_GOL_BUTTON_PRESSED_STATE); if (objID == ID_ICON1) { while(GFX_DoubleBufferDisable() == GFX_STATUS_FAILURE); PIPDemo(); screenState = CREATE_MAINMENU; } else if (objID == ID_ICON2) { while(GFX_DoubleBufferDisable() == GFX_STATUS_FAILURE); SpeedDemo(); screenState = CREATE_MAINMENU; } else if (objID == ID_ICON3) { screenState = CREATE_ALPHABLEND; } else if (objID == ID_ICON4) { while(GFX_DoubleBufferDisable() == GFX_STATUS_FAILURE); PagingDemo(); screenState = CREATE_MAINMENU; } else // this should not happen screenState = DISPLAY_MAINMENU; } else if(objMsg == GFX_GOL_BUTTON_ACTION_STILLPRESSED) { // do not do anything since it is already pressed return 0; } else { // check if button is released and show release icon GFX_GOL_ObjectStateClear(pObj, GFX_GOL_BUTTON_PRESSED_STATE); // reset pressed } GFX_GOL_ObjectStateSet(pObj, GFX_GOL_BUTTON_DRAW_STATE); return 0; } if ((objID == ID_SCROLL1) || (objID == ID_SCROLL2) || (objID == ID_SCROLL3) || (objID == ID_SCROLL4)) { if(objMsg == GFX_GOL_BUTTON_ACTION_RELEASED) { switch(objID) //Up = 1, Down = 2, Left = 3, Right = 4 { case ID_SCROLL1: ScrollScreen(3,10); break; case ID_SCROLL2: ScrollScreen(1,10); break; case ID_SCROLL3: ScrollScreen(4,10); break; case ID_SCROLL4: ScrollScreen(2,10); break; } } } break; case DISPLAY_ALPHABLEND: return (MsgAlphaBlendScreenCallback(objMsg, pObj, pMsg)); default: break; } return (1); }