glib.c

Go to the documentation of this file.

 /*************************************************************************/
/* Standard C header files */
#include <stdint.h>

/* EM types and devices */
#include "em_types.h"
#include "em_device.h"

/* GLIB files */
#include "glib.h"

#ifndef GLIB_NO_DEFAULT_FONT
#define GLIB_DEFAULT_FONT       ((GLIB_Font_t *)&GLIB_FontNormal8x8)
#endif

static __INLINE void GLIB_colorTranslate24bppInl(uint32_t color, uint8_t *red, uint8_t *green, uint8_t *blue)
{
  *red   = (color >> RedShift) & 0xFF;
  *green = (color >> GreenShift) & 0xFF;
  *blue  = (color >> BlueShift) & 0xFF;
}
/**************************************************************************/
EMSTATUS GLIB_contextInit(GLIB_Context_t *pContext)
{
  EMSTATUS status;
  DMD_DisplayGeometry *pTmpDisplayGeometry;

  /* Check arguments */
  if (pContext == NULL) return GLIB_ERROR_INVALID_ARGUMENT;

  /* Sets the default background and foreground color */
  pContext->backgroundColor = Black;
  pContext->foregroundColor = White;

  /* Sets a pointer to the display geometry struct */
  status = DMD_getDisplayGeometry(&pTmpDisplayGeometry);
  if (status != DMD_OK) return status;

  pContext->pDisplayGeometry = pTmpDisplayGeometry;

  /* Sets the clipping region to the whole display */
  GLIB_Rectangle_t tmpRect = {0, 0, pTmpDisplayGeometry->xSize - 1, pTmpDisplayGeometry->ySize - 1};
  status = GLIB_setClippingRegion(pContext, &tmpRect);
  if (status != GLIB_OK) return status;

  /* Configure font. Default to NORMAL 8x8 if included in project. */
#ifndef GLIB_NO_DEFAULT_FONT
  GLIB_setFont(pContext, GLIB_DEFAULT_FONT);
#endif

  return status;
}

/**************************************************************************/
EMSTATUS GLIB_displayWakeUp()
{
  /* Use display driver's wake up function */
  return DMD_wakeUp();
}

/**************************************************************************/
EMSTATUS GLIB_displaySleep()
{
  /* Use Display Driver sleep function */
  return DMD_sleep();
}

/**************************************************************************/
EMSTATUS GLIB_setClippingRegion(GLIB_Context_t *pContext, const GLIB_Rectangle_t *pRect)
{
  /* Check arguments */
  if ((pContext == NULL) || (pRect == NULL)) return GLIB_ERROR_INVALID_ARGUMENT;

  /* Check coordinates against the display region */
  if ((pRect->xMin >= pRect->xMax) ||
      (pRect->yMin >= pRect->yMax))
    return GLIB_ERROR_INVALID_CLIPPINGREGION;

  if ((pRect->xMin < 0) ||
      (pRect->yMin < 0) ||
      (pRect->xMax > pContext->pDisplayGeometry->xSize - 1) ||
      (pRect->yMax > pContext->pDisplayGeometry->ySize - 1))
    return GLIB_OUT_OF_BOUNDS;

  GLIB_Rectangle_t tmpRect = {pRect->xMin, pRect->yMin, pRect->xMax, pRect->yMax};
  pContext->clippingRegion = tmpRect;
  return GLIB_applyClippingRegion(pContext);
}


/**************************************************************************/
EMSTATUS GLIB_clear(GLIB_Context_t *pContext)
{
  EMSTATUS status;
  uint8_t  red;
  uint8_t  green;
  uint8_t  blue;
  uint32_t width;
  uint32_t height;

  /* Check arguments */
  if (pContext == NULL) return GLIB_ERROR_INVALID_ARGUMENT;

  /* Divide the 24-color into it's components */
  GLIB_colorTranslate24bpp(pContext->backgroundColor, &red, &green, &blue);

  /* Reset display driver clipping area */
  status = GLIB_resetDisplayClippingArea(pContext);
  if (status != GLIB_OK) return status;

  /* Fill the display with the background color of the GLIB_Context_t  */
  width = pContext->pDisplayGeometry->clipWidth;
  height = pContext->pDisplayGeometry->clipHeight;
  return DMD_writeColor(0, 0, red, green, blue, width * height);
}

/**************************************************************************/
EMSTATUS GLIB_clearRegion(const GLIB_Context_t *pContext)
{
  EMSTATUS status;
  uint8_t  red;
  uint8_t  green;
  uint8_t  blue;
  uint32_t width;
  uint32_t height;

  /* Check arguments */
  if (pContext == NULL) return GLIB_ERROR_INVALID_ARGUMENT;

  /* Divide the 24-color into it's components */
  GLIB_colorTranslate24bpp(pContext->backgroundColor, &red, &green, &blue);

  status = GLIB_applyClippingRegion(pContext);
  if (status != DMD_OK) return status;

  /* Fill the region with the background color of the GLIB_Context_t */
  width = pContext->clippingRegion.xMax - pContext->clippingRegion.xMin + 1;
  height = pContext->clippingRegion.yMax - pContext->clippingRegion.yMin + 1;
  status = DMD_writeColor(0, 0, red, green, blue, width * height);
  if (status != DMD_OK) return status;
  
  return status;
}

/**************************************************************************/
EMSTATUS GLIB_resetDisplayClippingArea(GLIB_Context_t *pContext)
{
  /* Check arguments */
  if (pContext == NULL) return GLIB_ERROR_INVALID_ARGUMENT;

  return DMD_setClippingArea(0, 0, pContext->pDisplayGeometry->xSize,
                                   pContext->pDisplayGeometry->ySize);
}

/**************************************************************************/
EMSTATUS GLIB_resetClippingRegion(GLIB_Context_t *pContext)
{
  /* Check arguments */
  if (pContext == NULL) return GLIB_ERROR_INVALID_ARGUMENT;

  pContext->clippingRegion.xMin = 0;
  pContext->clippingRegion.yMin = 0;
  pContext->clippingRegion.xMax = pContext->pDisplayGeometry->xSize - 1;
  pContext->clippingRegion.yMax = pContext->pDisplayGeometry->ySize - 1;

  return GLIB_OK;
}

/**************************************************************************/
EMSTATUS GLIB_applyClippingRegion(const GLIB_Context_t *pContext)
{
  /* Check arguments */
  if (pContext == NULL) return GLIB_ERROR_INVALID_ARGUMENT;

  /* Reset driver clipping area to GLIB clipping region */
  return DMD_setClippingArea(pContext->clippingRegion.xMin,
                             pContext->clippingRegion.yMin,
                             pContext->clippingRegion.xMax - pContext->clippingRegion.xMin + 1,
                             pContext->clippingRegion.yMax - pContext->clippingRegion.yMin + 1);
}

/**************************************************************************/
void GLIB_colorTranslate24bpp(uint32_t color, uint8_t *red, uint8_t *green, uint8_t *blue)
{
  GLIB_colorTranslate24bppInl(color, red, green, blue);
}

/**************************************************************************/
uint32_t GLIB_rgbColor(uint8_t red, uint8_t green, uint8_t blue)
{
  return (red << RedShift) | (green << GreenShift) | (blue << BlueShift);
}

/**************************************************************************/
EMSTATUS GLIB_drawPixel(GLIB_Context_t *pContext, int32_t x, int32_t y)
{
  uint8_t red;
  uint8_t green;
  uint8_t blue;

  /* Check arguments */
  if (pContext == NULL) return GLIB_ERROR_INVALID_ARGUMENT;
  if (!GLIB_rectContainsPoint(&pContext->clippingRegion, x, y)) return GLIB_ERROR_NOTHING_TO_DRAW;

  /* Translate color and draw pixel */
  GLIB_colorTranslate24bppInl(pContext->foregroundColor, &red, &green, &blue);
  return DMD_writeColor(x, y, red, green, blue, 1);
}

/**************************************************************************/
EMSTATUS GLIB_drawPixelColor(GLIB_Context_t *pContext, int32_t x, int32_t y,
                             uint32_t color)
{
  uint8_t red;
  uint8_t green;
  uint8_t blue;

  /* Check arguments */
  if (pContext == NULL) return GLIB_ERROR_INVALID_ARGUMENT;
  if (!GLIB_rectContainsPoint(&pContext->clippingRegion, x, y)) return GLIB_ERROR_NOTHING_TO_DRAW;

  /* Translate color and draw pixel */
  GLIB_colorTranslate24bppInl(color, &red, &green, &blue);
  return DMD_writeColor(x, y, red, green, blue, 1);
}

/**************************************************************************/
EMSTATUS GLIB_drawPixelRGB(GLIB_Context_t *pContext, int32_t x, int32_t y,
                           uint8_t red, uint8_t green, uint8_t blue)
{
  /* Check arguments */
  if (pContext == NULL) return GLIB_ERROR_INVALID_ARGUMENT;
  if (!GLIB_rectContainsPoint(&pContext->clippingRegion, x, y)) return GLIB_ERROR_NOTHING_TO_DRAW;

  /* Call Display driver function */
  return DMD_writeColor(x, y, red, green, blue, 1);
}