uGFX
/
ugfx
2
0
Fork 0
Code Issues 2 Pull Requests Projects Releases Wiki Activity

Revert "GDISP changes including polygon support" 

This reverts commit 269262ef9b.
ugfx_release_2.6
Andrew Hannam 2013-03-10 16:12:13 +10:00
parent 269262ef9b
commit 8a40457c86
9 changed files with 1680 additions and 1903 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
demos/modules/gadc/gfxconf.h
View File

@ -41,6 +41,7 @@
#define GDISP_NEED_MSGAPI FALSE #define GDISP_NEED_MSGAPI FALSE
/* GDISP - builtin fonts */ /* GDISP - builtin fonts */
#define GDISP_OLD_FONT_DEFINITIONS FALSE
#define GDISP_INCLUDE_FONT_SMALL FALSE #define GDISP_INCLUDE_FONT_SMALL FALSE
#define GDISP_INCLUDE_FONT_LARGER FALSE #define GDISP_INCLUDE_FONT_LARGER FALSE
#define GDISP_INCLUDE_FONT_UI1 FALSE #define GDISP_INCLUDE_FONT_UI1 FALSE

1
demos/modules/gaudin/gfxconf.h
View File

@ -41,6 +41,7 @@
#define GDISP_NEED_MSGAPI FALSE #define GDISP_NEED_MSGAPI FALSE
/* GDISP - builtin fonts */ /* GDISP - builtin fonts */
#define GDISP_OLD_FONT_DEFINITIONS FALSE
#define GDISP_INCLUDE_FONT_SMALL FALSE #define GDISP_INCLUDE_FONT_SMALL FALSE
#define GDISP_INCLUDE_FONT_LARGER FALSE #define GDISP_INCLUDE_FONT_LARGER FALSE
#define GDISP_INCLUDE_FONT_UI1 FALSE #define GDISP_INCLUDE_FONT_UI1 FALSE

27
gfxconf.example.h
View File

@ -27,22 +27,21 @@
#define GFX_USE_GMISC FALSE #define GFX_USE_GMISC FALSE
/* Features for the GDISP subsystem */ /* Features for the GDISP subsystem */
#define GDISP_NEED_VALIDATION TRUE #define GDISP_NEED_VALIDATION TRUE
#define GDISP_NEED_CLIP TRUE #define GDISP_NEED_CLIP TRUE
#define GDISP_NEED_TEXT TRUE #define GDISP_NEED_TEXT TRUE
#define GDISP_NEED_CIRCLE TRUE #define GDISP_NEED_CIRCLE TRUE
#define GDISP_NEED_ELLIPSE TRUE #define GDISP_NEED_ELLIPSE TRUE
#define GDISP_NEED_ARC FALSE #define GDISP_NEED_ARC FALSE
#define GDISP_NEED_CONVEX_POLYGON FALSE #define GDISP_NEED_SCROLL FALSE
#define GDISP_NEED_SCROLL FALSE #define GDISP_NEED_PIXELREAD FALSE
#define GDISP_NEED_PIXELREAD FALSE #define GDISP_NEED_CONTROL FALSE
#define GDISP_NEED_CONTROL FALSE #define GDISP_NEED_MULTITHREAD FALSE
#define GDISP_NEED_QUERY FALSE #define GDISP_NEED_ASYNC FALSE
#define GDISP_NEED_MULTITHREAD FALSE #define GDISP_NEED_MSGAPI FALSE
#define GDISP_NEED_ASYNC FALSE
#define GDISP_NEED_MSGAPI FALSE
/* GDISP - builtin fonts */ /* GDISP - builtin fonts */
#define GDISP_OLD_FONT_DEFINITIONS FALSE
#define GDISP_INCLUDE_FONT_SMALL TRUE #define GDISP_INCLUDE_FONT_SMALL TRUE
#define GDISP_INCLUDE_FONT_LARGER TRUE #define GDISP_INCLUDE_FONT_LARGER TRUE
#define GDISP_INCLUDE_FONT_UI1 TRUE #define GDISP_INCLUDE_FONT_UI1 TRUE

830
include/gdisp/gdisp.h
View File

@ -48,121 +48,9 @@ typedef int16_t coord_t;
#if GFX_USE_GDISP || defined(__DOXYGEN__) #if GFX_USE_GDISP || defined(__DOXYGEN__)
/*===========================================================================*/ /*===========================================================================*/
/* Include the low level driver configuration information */ /* Driver constants. */
/*===========================================================================*/ /*===========================================================================*/
#include "gdisp_lld_config.h"
/*===========================================================================*/
/* Type definitions */
/*===========================================================================*/
/**
* @brief The type for a fixed point coordinate.
* @details The top 16 bits are the integer component, the bottom 16 bits are the real component.
*/
typedef int32_t fpcoord_t;
/**
* @brief Macros to convert to and from a fixed point coord.
* @{
*/
#define COORD2FP(x) ((fpcoord_t)(x)<<16)
#define FP2COORD(x) ((coord_t)((x)>>16))
/* @} */
/**
* @brief Type for a 2D point on the screen.
*/
typedef struct point_t {
coord_t x, y;
} point;
/**
* @brief Type for the text justification.
*/
typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t;
/**
* @brief Type for the font metric.
*/
typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t;
/**
* @brief The type of a font.
*/
typedef const struct font *font_t;
/**
* @brief Type for the screen orientation.
*/
typedef enum orientation {GDISP_ROTATE_0, GDISP_ROTATE_90, GDISP_ROTATE_180, GDISP_ROTATE_270} gdisp_orientation_t;
/**
* @brief Type for the available power modes for the screen.
*/
typedef enum powermode {powerOff, powerSleep, powerDeepSleep, powerOn} gdisp_powermode_t;
/*
* This is not documented in Doxygen as it is meant to be a black-box.
* Applications should always use the routines and macros defined
* below to access it in case the implementation ever changed.
*/
typedef struct GDISPDriver_t {
coord_t Width;
coord_t Height;
gdisp_orientation_t Orientation;
gdisp_powermode_t Powermode;
uint8_t Backlight;
uint8_t Contrast;
#if GDISP_NEED_CLIP || GDISP_NEED_VALIDATION
coord_t clipx0, clipy0;
coord_t clipx1, clipy1; /* not inclusive */
#endif
} GDISPDriver;
extern GDISPDriver GDISP;
/*===========================================================================*/
/* Constants. */
/*===========================================================================*/
/**
* @brief Driver Control Constants
* @details Unsupported control codes are ignored.
* @note The value parameter should always be typecast to (void *).
* @note There are some predefined and some specific to the low level driver.
* @note GDISP_CONTROL_POWER - Takes a gdisp_powermode_t
* GDISP_CONTROL_ORIENTATION - Takes a gdisp_orientation_t
* GDISP_CONTROL_BACKLIGHT - Takes an int from 0 to 100. For a driver
* that only supports off/on anything other
* than zero is on.
* GDISP_CONTROL_CONTRAST - Takes an int from 0 to 100.
* GDISP_CONTROL_LLD - Low level driver control constants start at
* this value.
*/
#define GDISP_CONTROL_POWER 0
#define GDISP_CONTROL_ORIENTATION 1
#define GDISP_CONTROL_BACKLIGHT 2
#define GDISP_CONTROL_CONTRAST 3
#define GDISP_CONTROL_LLD 1000
/**
* @brief Driver Query Constants
* @details Unsupported query codes return (void *)-1.
* @note The result should be typecast the required type.
* @note GDISP_QUERY_LLD - Low level driver control constants start at
* this value.
*/
#define GDISP_QUERY_LLD 1000
/**
* @brief Driver Pixel Format Constants
*/
#define GDISP_PIXELFORMAT_MONO 1
#define GDISP_PIXELFORMAT_RGB565 565
#define GDISP_PIXELFORMAT_RGB888 888
#define GDISP_PIXELFORMAT_RGB444 444
#define GDISP_PIXELFORMAT_RGB332 332
#define GDISP_PIXELFORMAT_RGB666 666
#define GDISP_PIXELFORMAT_CUSTOM 99999
#define GDISP_PIXELFORMAT_ERROR 88888
/** /**
* @name Some basic colors * @name Some basic colors
* @{ * @{
@ -192,426 +80,125 @@ extern GDISPDriver GDISP;
/** @} */ /** @} */
/*===========================================================================*/ /*===========================================================================*/
/* Defines related to the pixel format */ /* Low Level Driver details and error checks. */
/*===========================================================================*/ /*===========================================================================*/
#if defined(__DOXYGEN__) /* Include the low level driver information */
/** #include "gdisp/lld/gdisp_lld.h"
* @brief The color of a pixel.
*/
typedef uint16_t color_t;
/**
* @brief Convert a number (of any type) to a color_t.
* @details Masks any invalid bits in the color
*/
#define COLOR(c) ((color_t)(c))
/**
* @brief Does the color_t type contain invalid bits that need masking.
*/
#define MASKCOLOR FALSE
/**
* @brief Convert red, green, blue (each 0 to 255) into a color value.
*/
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))
/**
* @brief Convert a 6 digit HTML code (hex) into a color value.
*/
#define HTML2COLOR(h) ((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))
/**
* @brief Extract the red component (0 to 255) of a color value.
*/
#define RED_OF(c) (((c) & 0xF800)>>8)
/**
* @brief Extract the green component (0 to 255) of a color value.
*/
#define GREEN_OF(c) (((c)&0x007E)>>3)
/**
* @brief Extract the blue component (0 to 255) of a color value.
*/
#define BLUE_OF(c) (((c)&0x001F)<<3)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_MONO /*===========================================================================*/
typedef uint8_t color_t; /* Type definitions */
#define COLOR(c) ((color_t)(c)) /*===========================================================================*/
#define MASKCOLOR FALSE
#define RGB2COLOR(r,g,b) ((r|g|b) ? 1 : 0)
#define HTML2COLOR(h) (h ? 1 : 0)
#define RED_OF(c) (c ? 255 : 0)
#define GREEN_OF(c) (c ? 255 : 0)
#define BLUE_OF(c) (c ? 255 : 0)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565
typedef uint16_t color_t;
#define COLOR(c) ((color_t)(c))
#define MASKCOLOR FALSE
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))
#define HTML2COLOR(h) ((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))
#define RED_OF(c) (((c) & 0xF800)>>8)
#define GREEN_OF(c) (((c)&0x07E0)>>3)
#define BLUE_OF(c) (((c)&0x001F)<<3)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888
typedef uint32_t color_t;
#define COLOR(c) ((color_t)(((c) & 0xFFFFFF)))
#define MASKCOLOR TRUE
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xFF)<<16) | (((g) & 0xFF) << 8) | ((b) & 0xFF)))
#define HTML2COLOR(h) ((color_t)(h))
#define RED_OF(c) (((c) & 0xFF0000)>>16)
#define GREEN_OF(c) (((c)&0x00FF00)>>8)
#define BLUE_OF(c) ((c)&0x0000FF)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB444
typedef uint16_t color_t;
#define COLOR(c) ((color_t)(((c) & 0x0FFF)))
#define MASKCOLOR TRUE
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF0)<<4) | ((g) & 0xF0) | (((b) & 0xF0)>>4)))
#define HTML2COLOR(h) ((color_t)((((h) & 0xF00000)>>12) | (((h) & 0x00F000)>>8) | (((h) & 0x0000F0)>>4)))
#define RED_OF(c) (((c) & 0x0F00)>>4)
#define GREEN_OF(c) ((c)&0x00F0)
#define BLUE_OF(c) (((c)&0x000F)<<4)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB332
typedef uint8_t color_t;
#define COLOR(c) ((color_t)(c))
#define MASKCOLOR FALSE
#define RGB2COLOR(r,g,b) ((color_t)(((r) & 0xE0) | (((g) & 0xE0)>>3) | (((b) & 0xC0)>>6)))
#define HTML2COLOR(h) ((color_t)((((h) & 0xE00000)>>16) | (((h) & 0x00E000)>>11) | (((h) & 0x0000C0)>>6)))
#define RED_OF(c) ((c) & 0xE0)
#define GREEN_OF(c) (((c)&0x1C)<<3)
#define BLUE_OF(c) (((c)&0x03)<<6)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB666
typedef uint32_t color_t;
#define COLOR(c) ((color_t)(((c) & 0x03FFFF)))
#define MASKCOLOR TRUE
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xFC)<<10) | (((g) & 0xFC)<<4) | (((b) & 0xFC)>>2)))
#define HTML2COLOR(h) ((color_t)((((h) & 0xFC0000)>>6) | (((h) & 0x00FC00)>>4) | (((h) & 0x0000FC)>>2)))
#define RED_OF(c) (((c) & 0x03F000)>>12)
#define GREEN_OF(c) (((c)&0x00FC00)>>8)
#define BLUE_OF(c) (((c)&0x00003F)<<2)
#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM
#error "GDISP: No supported pixel format has been specified."
#endif
/* Verify information for packed pixels and define a non-packed pixel macro */
#if !GDISP_PACKED_PIXELS
#define gdispPackPixels(buf,cx,x,y,c) { ((color_t *)(buf))[(y)*(cx)+(x)] = (c); }
#elif !GDISP_HARDWARE_BITFILLS
#error "GDISP: packed pixel formats are only supported for hardware accelerated drivers."
#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB888 \
&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB444 \
&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB666 \
&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM
#error "GDISP: A packed pixel format has been specified for an unsupported pixel format."
#endif
#if GDISP_NEED_SCROLL && !GDISP_HARDWARE_SCROLL
#error "GDISP: Hardware scrolling is wanted but not supported."
#endif
#if GDISP_NEED_PIXELREAD && !GDISP_HARDWARE_PIXELREAD
#error "GDISP: Pixel read-back is wanted but not supported."
#endif
/** /**
* @brief The type of a pixel. * @brief Type for the text justification.
*/ */
typedef color_t pixel_t; typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t;
/**
* @brief Type for the font metric.
*/
typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t;
/*===========================================================================*/
/* External declarations. */
/*===========================================================================*/
#if (GDISP_NEED_TEXT && GDISP_OLD_FONT_DEFINITIONS) || defined(__DOXYGEN__)
#if GDISP_INCLUDE_FONT_SMALL
extern const struct font fontSmall;
extern const struct font fontSmallDouble;
extern const struct font fontSmallNarrow;
#endif
#if GDISP_INCLUDE_FONT_LARGER
extern const struct font fontLarger;
extern const struct font fontLargerDouble;
extern const struct font fontLargerNarrow;
#endif
#if GDISP_INCLUDE_FONT_UI1
extern const struct font fontUI1;
extern const struct font fontUI1Double;
extern const struct font fontUI1Narrow;
#endif
#if GDISP_INCLUDE_FONT_UI2
extern const struct font fontUI2;
extern const struct font fontUI2Double;
extern const struct font fontUI2Narrow;
#endif
#if GDISP_INCLUDE_FONT_LARGENUMBERS
extern const struct font fontLargeNumbers;
extern const struct font fontLargeNumbersDouble;
extern const struct font fontLargeNumbersNarrow;
#endif
#endif
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC || defined(__DOXYGEN__) #if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC
/* These routines can be hardware accelerated /* These routines can be hardware accelerated
* - Do not add a routine here unless it has also been added to the hardware acceleration layer * - Do not add a routine here unless it has also been added to the hardware acceleration layer
*/ */
/* Base Functions */ /* Base Functions */
/**
* @brief GDISP Driver initialization.
* @details Must be called before any other gdisp function.
*
* @note This function is NOT currently implicitly invoked by @p halInit().
* It must be called manually.
*
* @return True if succeeded, False otherwise
*
* @api
*/
bool_t gdispInit(void); bool_t gdispInit(void);
/**
* @brief Test if the GDISP engine is currently drawing.
* @note This function will always return FALSE if
* GDISP_NEED_ASYNC is not defined.
*
* @return TRUE if gdisp is busy, FALSE otherwise
*
* @api
*/
bool_t gdispIsBusy(void); bool_t gdispIsBusy(void);
/* Drawing Functions */ /* Drawing Functions */
/**
* @brief Clear the display to the specified color.
*
* @param[in] color The color to use when clearing the screen
*
* @api
*/
void gdispClear(color_t color); void gdispClear(color_t color);
/**
* @brief Set a pixel in the specified color.
*
* @param[in] x,y The position to set the pixel.
* @param[in] color The color to use
*
* @api
*/
void gdispDrawPixel(coord_t x, coord_t y, color_t color); void gdispDrawPixel(coord_t x, coord_t y, color_t color);
/**
* @brief Draw a line.
*
* @param[in] x0,y0 The start position
* @param[in] x1,y1 The end position
* @param[in] color The color to use
*
* @api
*/
void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color); void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color);
/**
* @brief Fill an area with a color.
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the box (outside dimensions)
* @param[in] color The color to use
*
* @api
*/
void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color); void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
/**
* @brief Fill an area using the supplied bitmap.
* @details The bitmap is in the pixel format specified by the low level driver
* @note If a packed pixel format is used and the width doesn't
* match a whole number of bytes, the next line will start on a
* non-byte boundary (no end-of-line padding).
* @note If GDISP_NEED_ASYNC is defined then the buffer must be static
* or at least retained until this call has finished the blit. You can
* tell when all graphics drawing is finished by @p gdispIsBusy() going FALSE.
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the filled area
* @param[in] srcx,srcy The bitmap position to start the fill form
* @param[in] srccx The width of a line in the bitmap
* @param[in] buffer The bitmap in the driver's pixel format
*
* @api
*/
void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer); void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer);
/* Clipping Functions */ /* Clipping Functions */
#if GDISP_NEED_CLIP
#if GDISP_NEED_CLIP || defined(__DOXYGEN__) void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy);
/**
* @brief Clip all drawing to the defined area.
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the clip area
*
* @api
*/
void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy);
#endif #endif
/* Circle Functions */ /* Circle Functions */
#if GDISP_NEED_CIRCLE
#if GDISP_NEED_CIRCLE || defined(__DOXYGEN__) void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color);
/** void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color);
* @brief Draw a circle.
*
* @param[in] x,y The center of the circle
* @param[in] radius The radius of the circle
* @param[in] color The color to use
*
* @api
*/
void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color);
/**
* @brief Draw a filled circle.
*
* @param[in] x,y The center of the circle
* @param[in] radius The radius of the circle
* @param[in] color The color to use
*
* @api
*/
void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color);
#endif #endif
/* Ellipse Functions */ /* Ellipse Functions */
#if GDISP_NEED_ELLIPSE
#if GDISP_NEED_ELLIPSE || defined(__DOXYGEN__) void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
/** void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
* @brief Draw an ellipse.
*
* @param[in] x,y The center of the ellipse
* @param[in] a,b The dimensions of the ellipse
* @param[in] color The color to use
*
* @api
*/
void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
/**
* @brief Draw a filled ellipse.
*
* @param[in] x,y The center of the ellipse
* @param[in] a,b The dimensions of the ellipse
* @param[in] color The color to use
*
* @api
*/
void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color);
#endif #endif
/* Arc Functions */ /* Arc Functions */
#if GDISP_NEED_ARC
#if GDISP_NEED_ARC || defined(__DOXYGEN__) void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
/* void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
* @brief Draw an arc.
*
* @param[in] x0,y0 The center point
* @param[in] radius The radius of the arc
* @param[in] start The start angle (0 to 360)
* @param[in] end The end angle (0 to 360)
* @param[in] color The color of the arc
*
* @api
*/
void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
/*
* @brief Draw a filled arc.
* @note Not very efficient currently - does lots of overdrawing
*
* @param[in] x0,y0 The center point
* @param[in] radius The radius of the arc
* @param[in] start The start angle (0 to 360)
* @param[in] end The end angle (0 to 360)
* @param[in] color The color of the arc
*
* @api
*/
void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
#endif #endif
/* Basic Text Rendering Functions */ /* Basic Text Rendering Functions */
#if GDISP_NEED_TEXT
#if GDISP_NEED_TEXT || defined(__DOXYGEN__) void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color);
/** void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
* @brief Draw a text character.
*
* @param[in] x,y The position for the text
* @param[in] c The character to draw
* @param[in] font The font to use
* @param[in] color The color to use
*
* @api
*/
void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color);
/**
* @brief Draw a text character with a filled background.
*
* @param[in] x,y The position for the text
* @param[in] c The character to draw
* @param[in] font The font to use
* @param[in] color The color to use
* @param[in] bgcolor The background color to use
*
* @api
*/
void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor);
#endif #endif
/* Read a pixel Function */ /* Read a pixel Function */
#if GDISP_NEED_PIXELREAD
#if GDISP_NEED_PIXELREAD || defined(__DOXYGEN__) color_t gdispGetPixelColor(coord_t x, coord_t y);
/**
* @brief Get the color of a pixel.
* @return The color of the pixel.
*
* @param[in] x,y The position of the pixel
*
* @api
*/
color_t gdispGetPixelColor(coord_t x, coord_t y);
#endif #endif
/* Scrolling Function - clears the area scrolled out */ /* Scrolling Function - clears the area scrolled out */
#if GDISP_NEED_SCROLL
#if GDISP_NEED_SCROLL || defined(__DOXYGEN__) void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
/**
* @brief Scroll vertically a section of the screen.
* @pre GDISP_NEED_SCROLL must be set to TRUE in halconf.h
* @note Optional.
* @note If lines is >= cy, it is equivelent to a area fill with bgcolor.
*
* @param[in] x, y The start of the area to be scrolled
* @param[in] cx, cy The size of the area to be scrolled
* @param[in] lines The number of lines to scroll (Can be positive or negative)
* @param[in] bgcolor The color to fill the newly exposed area.
*
* @api
*/
void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor);
#endif #endif
/* Set driver specific control */ /* Set driver specific control */
#if GDISP_NEED_CONTROL
#if GDISP_NEED_CONTROL || defined(__DOXYGEN__) void gdispControl(unsigned what, void *value);
/**
* @brief Control hardware specific parts of the display. eg powermodes, backlight etc
* @pre The GDISP unit must have been initialised using @p gdispInit().
* @note Depending on the hardware implementation this function may not
* support some codes. They will be ignored.
*
* @param[in] what what you want to control
* @param[in] value The value to be assigned
*
* @api
*/
void gdispControl(unsigned what, void *value);
#endif #endif
/* Query driver specific data */ /* Query driver specific data */
void *gdispQuery(unsigned what);
#if GDISP_NEED_QUERY || defined(__DOXYGEN__)
/**
* @brief Query a property of the display.
* @pre The GDISP unit must have been initialised using @p gdispInit().
* @note The result must be typecast to the correct type.
* @note An unsupported query will return (void *)-1.
*
* @param[in] what What to query
*
* @api
*/
void *gdispQuery(unsigned what);
#endif
#else #else
/* Include the low level driver information */
#include "gdisp/lld/gdisp_lld.h"
/* The same as above but use the low level driver directly if no multi-thread support is needed */ /* The same as above but use the low level driver directly if no multi-thread support is needed */
#define gdispInit(gdisp) gdisp_lld_init() #define gdispInit(gdisp) gdisp_lld_init()
@ -642,214 +229,30 @@ extern "C" {
*/ */
/* Extra drawing functions */ /* Extra drawing functions */
/**
* @brief Draw a rectangular box.
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the box (outside dimensions)
* @param[in] color The color to use
*
* @api
*/
void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color); void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
#if GDISP_NEED_CONVEX_POLYGON || defined(__DOXYGEN__)
/**
* @brief Draw an enclosed polygon (convex, non-convex or complex).
*
* @param[in] pntarray An array of points
* @param[in] cnt The number of points in the array
* @param[in] color The color to use
*
* @api
*/
void gdispDrawPoly(const point *pntarray, unsigned cnt, color_t color);
/**
* @brief Fill a convex polygon
* @details Doesn't handle non-convex or complex polygons.
*
* @param[in] pntarray An array of points
* @param[in] cnt The number of points in the array
* @param[in] color The color to use
*
* @note Convex polygons are those that have no internal angles. That is;
* you can draw a line from any point on the polygon to any other point
* on the polygon without it going outside the polygon.
* @note This routine is designed to be very efficient with even simple display hardware.
*
* @api
*/
void gdispFillConvexPoly(const point *pntarray, unsigned cnt, color_t color);
#endif
/* Extra Text Functions */ /* Extra Text Functions */
#if GDISP_NEED_TEXT
#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
/**
* @brief Draw a text string.
*
* @param[in] x,y The position for the text
* @param[in] font The font to use
* @param[in] str The string to draw
* @param[in] color The color to use
*
* @api
*/
void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color); void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color);
/**
* @brief Draw a text string.
*
* @param[in] x,y The position for the text
* @param[in] str The string to draw
* @param[in] font The font to use
* @param[in] color The color to use
* @param[in] bgcolor The background color to use
*
* @api
*/
void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor); void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor);
/**
* @brief Draw a text string vertically centered within the specified box.
*
* @param[in] x,y The position for the text (need to define top-right or base-line - check code)
* @param[in] cx,cy The width and height of the box
* @param[in] str The string to draw
* @param[in] font The font to use
* @param[in] color The color to use
* @param[in] justify Justify the text left, center or right within the box
*
* @api
*/
void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, justify_t justify); void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, justify_t justify);
/**
* @brief Draw a text string vertically centered within the specified box. The box background is filled with the specified background color.
* @note The entire box is filled
*
* @param[in] x,y The position for the text (need to define top-right or base-line - check code)
* @param[in] cx,cy The width and height of the box
* @param[in] str The string to draw
* @param[in] font The font to use
* @param[in] color The color to use
* @param[in] bgcolor The background color to use
* @param[in] justify Justify the text left, center or right within the box
*
* @api
*/
void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgColor, justify_t justify); void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgColor, justify_t justify);
/**
* @brief Get a metric of a font.
* @return The metric requested in pixels.
*
* @param[in] font The font to test
* @param[in] metric The metric to measure
*
* @api
*/
coord_t gdispGetFontMetric(font_t font, fontmetric_t metric); coord_t gdispGetFontMetric(font_t font, fontmetric_t metric);
/**
* @brief Get the pixel width of a character.
* @return The width of the character in pixels. Does not include any between character padding.
*
* @param[in] c The character to draw
* @param[in] font The font to use
*
* @api
*/
coord_t gdispGetCharWidth(char c, font_t font); coord_t gdispGetCharWidth(char c, font_t font);
/**
* @brief Get the pixel width of a string.
* @return The width of the string in pixels.
*
* @param[in] str The string to measure
* @param[in] font The font to use
*
* @api
*/
coord_t gdispGetStringWidth(const char* str, font_t font); coord_t gdispGetStringWidth(const char* str, font_t font);
/**
* @brief Find a font and return it.
* @details The supplied name is matched against the font name. A '*' will replace 0 or more characters.
* @return Returns a font or NULL if no matching font could be found.
*
* @param[in] name The font name to find.
*
* @note Wildcard matching will match the shortest possible match.
*
* @api
*/
font_t gdispOpenFont(const char *name); font_t gdispOpenFont(const char *name);
/**
* @brief Release a font after use.
*
* @param[in] font The font to release.
*
* @api
*/
void gdispCloseFont(font_t font); void gdispCloseFont(font_t font);
/**
* @brief Get the name of the specified font.
* @returns The name of the font.
*
* @param[in] font The font to get the name for.
*
* @api
*/
const char *gdispGetFontName(font_t font); const char *gdispGetFontName(font_t font);
#endif #endif
/* Extra Arc Functions */ /* Extra Arc Functions */
#if GDISP_NEED_ARC
#if GDISP_NEED_ARC || defined(__DOXYGEN__)
/**
* @brief Draw a rectangular box with rounded corners
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the box (outside dimensions)
* @param[in] radius The radius of the rounded corners
* @param[in] color The color to use
*
* @api
*/
void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color); void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);
/**
* @brief Draw a filled rectangular box with rounded corners
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the box (outside dimensions)
* @param[in] radius The radius of the rounded corners
* @param[in] color The color to use
*
* @api
*/
void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color); void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color);
#endif #endif
/* Support routine for packed pixel formats */ /* Support routine for packed pixel formats */
#if !defined(gdispPackPixels) || defined(__DOXYGEN__) #ifndef gdispPackPixels
/**
* @brief Pack a pixel into a pixel buffer.
* @note This function performs no buffer boundary checking
* regardless of whether GDISP_NEED_CLIP has been specified.
*
* @param[in] buf The buffer to put the pixel in
* @param[in] cx The width of a pixel line
* @param[in] x, y The location of the pixel to place
* @param[in] color The color to put into the buffer
*
* @api
*/
void gdispPackPixels(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color); void gdispPackPixels(const pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);
#endif #endif
@ -861,99 +264,19 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
#define gdispBlitArea(x, y, cx, cy, buffer) gdispBlitAreaEx(x, y, cx, cy, 0, 0, cx, buffer) #define gdispBlitArea(x, y, cx, cy, buffer) gdispBlitAreaEx(x, y, cx, cy, 0, 0, cx, buffer)
/* Macro definitions for common gets and sets */ /* Macro definitions for common gets and sets */
/**
* @brief Set the display power mode.
* @note Ignored if not supported by the display.
*
* @param[in] powerMode The new power mode
*
* @api
*/
#define gdispSetPowerMode(powerMode) gdispControl(GDISP_CONTROL_POWER, (void *)(unsigned)(powerMode)) #define gdispSetPowerMode(powerMode) gdispControl(GDISP_CONTROL_POWER, (void *)(unsigned)(powerMode))
/**
* @brief Set the display orientation.
* @note Ignored if not supported by the display.
*
* @param[in] newOrientation The new orientation
*
* @api
*/
#define gdispSetOrientation(newOrientation) gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(unsigned)(newOrientation)) #define gdispSetOrientation(newOrientation) gdispControl(GDISP_CONTROL_ORIENTATION, (void *)(unsigned)(newOrientation))
/**
* @brief Set the display backlight.
* @note Ignored if not supported by the display.
*
* @param[in] percent The new brightness (0 - 100%)
*
* @note For displays that only support backlight off and on,
* 0 = off, anything else = on
*
* @api
*/
#define gdispSetBacklight(percent) gdispControl(GDISP_CONTROL_BACKLIGHT, (void *)(unsigned)(percent)) #define gdispSetBacklight(percent) gdispControl(GDISP_CONTROL_BACKLIGHT, (void *)(unsigned)(percent))
/**
* @brief Set the display contrast.
* @note Ignored if not supported by the display.
*
* @param[in] percent The new contrast (0 - 100%)
*
* @api
*/
#define gdispSetContrast(percent) gdispControl(GDISP_CONTROL_CONTRAST, (void *)(unsigned)(percent)) #define gdispSetContrast(percent) gdispControl(GDISP_CONTROL_CONTRAST, (void *)(unsigned)(percent))
/** #define gdispGetWidth() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH))
* @brief Get the display width in pixels. #define gdispGetHeight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT))
* #define gdispGetPowerMode() ((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER))
* @api #define gdispGetOrientation() ((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION))
*/ #define gdispGetBacklight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT))
#define gdispGetWidth() (GDISP.Width) #define gdispGetContrast() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST))
/**
* @brief Get the display height in pixels.
*
* @api
*/
#define gdispGetHeight() (GDISP.Height)
/**
* @brief Get the current display power mode.
*
* @api
*/
#define gdispGetPowerMode() (GDISP.Powermode)
/**
* @brief Get the current display orientation.
*
* @api
*/
#define gdispGetOrientation() (GDISP.Orientation)
/**
* @brief Get the current display backlight brightness.
*
* @api
*/
#define gdispGetBacklight() (GDISP.Backlight)
/**
* @brief Get the current display contrast.
*
* @api
*/
#define gdispGetContrast() (GDISP.Contrast)
/* More interesting macro's */ /* More interesting macro's */
/**
* @brief Reset the clip area to the full screen
*
* @api
*/
#define gdispUnsetClip() gdispSetClip(0,0,gdispGetWidth(),gdispGetHeight()) #define gdispUnsetClip() gdispSetClip(0,0,gdispGetWidth(),gdispGetHeight())
@ -965,3 +288,4 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color);
#endif /* _GDISP_H */ #endif /* _GDISP_H */
/** @} */ /** @} */

36
include/gdisp/lld/emulation.c
View File

@ -34,13 +34,22 @@
#ifndef GDISP_EMULATION_C #ifndef GDISP_EMULATION_C
#define GDISP_EMULATION_C #define GDISP_EMULATION_C
#if GFX_USE_GDISP #if GFX_USE_GDISP /*|| defined(__DOXYGEN__) */
/* Include the low level driver information */ #ifndef GDISP_LLD_NO_STRUCT
#include "gdisp/lld/gdisp_lld.h" static struct GDISPDriver {
coord_t Width;
/* Declare the GDISP structure */ coord_t Height;
GDISPDriver GDISP; gdisp_orientation_t Orientation;
gdisp_powermode_t Powermode;
uint8_t Backlight;
uint8_t Contrast;
#if GDISP_NEED_CLIP || GDISP_NEED_VALIDATION
coord_t clipx0, clipy0;
coord_t clipx1, clipy1; /* not inclusive */
#endif
} GDISP;
#endif
#if !GDISP_HARDWARE_CLEARS #if !GDISP_HARDWARE_CLEARS
void gdisp_lld_clear(color_t color) { void gdisp_lld_clear(color_t color) {
@ -661,10 +670,17 @@ GDISPDriver GDISP;
} }
#endif #endif
#if GDISP_NEED_QUERY && !GDISP_HARDWARE_QUERY #if !GDISP_HARDWARE_QUERY
void *gdisp_lld_query(unsigned what) { void *gdisp_lld_query(unsigned what) {
(void) what; switch(what) {
return (void *)-1; case GDISP_QUERY_WIDTH: return (void *)(unsigned)GDISP.Width;
case GDISP_QUERY_HEIGHT: return (void *)(unsigned)GDISP.Height;
case GDISP_QUERY_POWER: return (void *)(unsigned)GDISP.Powermode;
case GDISP_QUERY_ORIENTATION: return (void *)(unsigned)GDISP.Orientation;
case GDISP_QUERY_BACKLIGHT: return (void *)(unsigned)GDISP.Backlight;
case GDISP_QUERY_CONTRAST: return (void *)(unsigned)GDISP.Contrast;
default: return (void *)-1;
}
} }
#endif #endif
@ -743,11 +759,9 @@ void *gdisp_lld_query(unsigned what) {
gdisp_lld_control(msg->control.what, msg->control.value); gdisp_lld_control(msg->control.what, msg->control.value);
break; break;
#endif #endif
#if GDISP_NEED_QUERY
case GDISP_LLD_MSG_QUERY: case GDISP_LLD_MSG_QUERY:
msg->query.result = gdisp_lld_query(msg->query.what); msg->query.result = gdisp_lld_query(msg->query.what);
break; break;
#endif
} }
} }
#endif #endif

203
include/gdisp/lld/gdisp_lld.h
View File

@ -31,6 +31,73 @@
#if GFX_USE_GDISP || defined(__DOXYGEN__) #if GFX_USE_GDISP || defined(__DOXYGEN__)
/*===========================================================================*/
/* Low level driver configuration needs */
/*===========================================================================*/
/*===========================================================================*/
/* Include the low level driver configuration information */
/*===========================================================================*/
#include "gdisp_lld_config.h"
/*===========================================================================*/
/* Constants. */
/*===========================================================================*/
/**
* @brief Driver Control Constants
* @details Unsupported control codes are ignored.
* @note The value parameter should always be typecast to (void *).
* @note There are some predefined and some specific to the low level driver.
* @note GDISP_CONTROL_POWER - Takes a gdisp_powermode_t
* GDISP_CONTROL_ORIENTATION - Takes a gdisp_orientation_t
* GDISP_CONTROL_BACKLIGHT - Takes an int from 0 to 100. For a driver
* that only supports off/on anything other
* than zero is on.
* GDISP_CONTROL_CONTRAST - Takes an int from 0 to 100.
* GDISP_CONTROL_LLD - Low level driver control constants start at
* this value.
*/
#define GDISP_CONTROL_POWER 0
#define GDISP_CONTROL_ORIENTATION 1
#define GDISP_CONTROL_BACKLIGHT 2
#define GDISP_CONTROL_CONTRAST 3
#define GDISP_CONTROL_LLD 1000
/**
* @brief Driver Query Constants
* @details Unsupported query codes return (void *)-1.
* @note There are some predefined and some specific to the low level driver.
* @note The result should be typecast the required type.
* @note GDISP_QUERY_WIDTH - Gets the width of the screen
* GDISP_QUERY_HEIGHT - Gets the height of the screen
* GDISP_QUERY_POWER - Get the current powermode
* GDISP_QUERY_ORIENTATION - Get the current orientation
* GDISP_QUERY_BACKLIGHT - Get the backlight state (0 to 100)
* GDISP_QUERY_CONTRAST - Get the contrast.
* GDISP_QUERY_LLD - Low level driver control constants start at
* this value.
*/
#define GDISP_QUERY_WIDTH 0
#define GDISP_QUERY_HEIGHT 1
#define GDISP_QUERY_POWER 2
#define GDISP_QUERY_ORIENTATION 3
#define GDISP_QUERY_BACKLIGHT 4
#define GDISP_QUERY_CONTRAST 5
#define GDISP_QUERY_LLD 1000
/**
* @brief Driver Pixel Format Constants
*/
#define GDISP_PIXELFORMAT_RGB565 565
#define GDISP_PIXELFORMAT_RGB888 888
#define GDISP_PIXELFORMAT_RGB444 444
#define GDISP_PIXELFORMAT_RGB332 332
#define GDISP_PIXELFORMAT_RGB666 666
#define GDISP_PIXELFORMAT_CUSTOM 99999
#define GDISP_PIXELFORMAT_ERROR 88888
/*===========================================================================*/ /*===========================================================================*/
/* Error checks. */ /* Error checks. */
/*===========================================================================*/ /*===========================================================================*/
@ -253,6 +320,140 @@
#endif #endif
/** @} */ /** @} */
/*===========================================================================*/
/* Define the macro's for the various pixel formats */
/*===========================================================================*/
#if defined(__DOXYGEN__)
/**
* @brief The color of a pixel.
*/
typedef uint16_t color_t;
/**
* @brief Convert a number (of any type) to a color_t.
* @details Masks any invalid bits in the color
*/
#define COLOR(c) ((color_t)(c))
/**
* @brief Does the color_t type contain invalid bits that need masking.
*/
#define MASKCOLOR FALSE
/**
* @brief Convert red, green, blue (each 0 to 255) into a color value.
*/
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))
/**
* @brief Convert a 6 digit HTML code (hex) into a color value.
*/
#define HTML2COLOR(h) ((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))
/**
* @brief Extract the red component (0 to 255) of a color value.
*/
#define RED_OF(c) (((c) & 0xF800)>>8)
/**
* @brief Extract the green component (0 to 255) of a color value.
*/
#define GREEN_OF(c) (((c)&0x007E)>>3)
/**
* @brief Extract the blue component (0 to 255) of a color value.
*/
#define BLUE_OF(c) (((c)&0x001F)<<3)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB565
typedef uint16_t color_t;
#define COLOR(c) ((color_t)(c))
#define MASKCOLOR FALSE
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))
#define HTML2COLOR(h) ((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))
#define RED_OF(c) (((c) & 0xF800)>>8)
#define GREEN_OF(c) (((c)&0x07E0)>>3)
#define BLUE_OF(c) (((c)&0x001F)<<3)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888
typedef uint32_t color_t;
#define COLOR(c) ((color_t)(((c) & 0xFFFFFF)))
#define MASKCOLOR TRUE
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xFF)<<16) | (((g) & 0xFF) << 8) | ((b) & 0xFF)))
#define HTML2COLOR(h) ((color_t)(h))
#define RED_OF(c) (((c) & 0xFF0000)>>16)
#define GREEN_OF(c) (((c)&0x00FF00)>>8)
#define BLUE_OF(c) ((c)&0x0000FF)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB444
typedef uint16_t color_t;
#define COLOR(c) ((color_t)(((c) & 0x0FFF)))
#define MASKCOLOR TRUE
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF0)<<4) | ((g) & 0xF0) | (((b) & 0xF0)>>4)))
#define HTML2COLOR(h) ((color_t)((((h) & 0xF00000)>>12) | (((h) & 0x00F000)>>8) | (((h) & 0x0000F0)>>4)))
#define RED_OF(c) (((c) & 0x0F00)>>4)
#define GREEN_OF(c) ((c)&0x00F0)
#define BLUE_OF(c) (((c)&0x000F)<<4)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB332
typedef uint8_t color_t;
#define COLOR(c) ((color_t)(c))
#define MASKCOLOR FALSE
#define RGB2COLOR(r,g,b) ((color_t)(((r) & 0xE0) | (((g) & 0xE0)>>3) | (((b) & 0xC0)>>6)))
#define HTML2COLOR(h) ((color_t)((((h) & 0xE00000)>>16) | (((h) & 0x00E000)>>11) | (((h) & 0x0000C0)>>6)))
#define RED_OF(c) ((c) & 0xE0)
#define GREEN_OF(c) (((c)&0x1C)<<3)
#define BLUE_OF(c) (((c)&0x03)<<6)
#elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB666
typedef uint32_t color_t;
#define COLOR(c) ((color_t)(((c) & 0x03FFFF)))
#define MASKCOLOR TRUE
#define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xFC)<<10) | (((g) & 0xFC)<<4) | (((b) & 0xFC)>>2)))
#define HTML2COLOR(h) ((color_t)((((h) & 0xFC0000)>>6) | (((h) & 0x00FC00)>>4) | (((h) & 0x0000FC)>>2)))
#define RED_OF(c) (((c) & 0x03F000)>>12)
#define GREEN_OF(c) (((c)&0x00FC00)>>8)
#define BLUE_OF(c) (((c)&0x00003F)<<2)
#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM
#error "GDISP: No supported pixel format has been specified."
#endif
/* Verify information for packed pixels and define a non-packed pixel macro */
#if !GDISP_PACKED_PIXELS
#define gdispPackPixels(buf,cx,x,y,c) { ((color_t *)(buf))[(y)*(cx)+(x)] = (c); }
#elif !GDISP_HARDWARE_BITFILLS
#error "GDISP: packed pixel formats are only supported for hardware accelerated drivers."
#elif GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB888 \
&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB444 \
&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_RGB666 \
&& GDISP_PIXELFORMAT != GDISP_PIXELFORMAT_CUSTOM
#error "GDISP: A packed pixel format has been specified for an unsupported pixel format."
#endif
#if GDISP_NEED_SCROLL && !GDISP_HARDWARE_SCROLL
#error "GDISP: Hardware scrolling is wanted but not supported."
#endif
#if GDISP_NEED_PIXELREAD && !GDISP_HARDWARE_PIXELREAD
#error "GDISP: Pixel read-back is wanted but not supported."
#endif
/*===========================================================================*/
/* Driver types. */
/*===========================================================================*/
/**
* @brief The type of a pixel.
*/
typedef color_t pixel_t;
/**
* @brief The type of a font.
*/
typedef const struct font *font_t;
/**
* @brief Type for the screen orientation.
*/
typedef enum orientation {GDISP_ROTATE_0, GDISP_ROTATE_90, GDISP_ROTATE_180, GDISP_ROTATE_270} gdisp_orientation_t;
/**
* @brief Type for the available power modes for the screen.
*/
typedef enum powermode {powerOff, powerSleep, powerDeepSleep, powerOn} gdisp_powermode_t;
/*===========================================================================*/ /*===========================================================================*/
/* External declarations. */ /* External declarations. */
/*===========================================================================*/ /*===========================================================================*/
@ -314,9 +515,7 @@ extern "C" {
#endif #endif
/* Query driver specific data */ /* Query driver specific data */
#if GDISP_NEED_QUERY
extern void *gdisp_lld_query(unsigned what); extern void *gdisp_lld_query(unsigned what);
#endif
/* Clipping Functions */ /* Clipping Functions */
#if GDISP_NEED_CLIP #if GDISP_NEED_CLIP

483
include/gdisp/options.h
View File

@ -1,247 +1,236 @@
/* /*
ChibiOS/GFX - Copyright (C) 2012, 2013 ChibiOS/GFX - Copyright (C) 2012, 2013
Joel Bodenmann aka Tectu <joel@unormal.org> Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS/GFX. This file is part of ChibiOS/GFX.
ChibiOS/GFX is free software; you can redistribute it and/or modify ChibiOS/GFX is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or the Free Software Foundation; either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
ChibiOS/GFX is distributed in the hope that it will be useful, ChibiOS/GFX is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
/** /**
* @file include/gdisp/options.h * @file include/gdisp/options.h
* @brief GDISP sub-system options header file. * @brief GDISP sub-system options header file.
* *
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#ifndef _GDISP_OPTIONS_H #ifndef _GDISP_OPTIONS_H
#define _GDISP_OPTIONS_H #define _GDISP_OPTIONS_H
/** /**
* @name GDISP Functionality to be included * @name GDISP Functionality to be included
* @{ * @{
*/ */
/** /**
* @brief Should all operations be clipped to the screen and colors validated. * @brief Should all operations be clipped to the screen and colors validated.
* @details Defaults to TRUE. * @details Defaults to TRUE.
* @note If this is FALSE, any operations that extend beyond the * @note If this is FALSE, any operations that extend beyond the
* edge of the screen will have undefined results. Any * edge of the screen will have undefined results. Any
* out-of-range colors will produce undefined results. * out-of-range colors will produce undefined results.
* @note If defined then all low level and high level GDISP driver routines * @note If defined then all low level and high level GDISP driver routines
* must check the validity of inputs and do something sensible * must check the validity of inputs and do something sensible
* if they are out of range. It doesn't have to be efficient, * if they are out of range. It doesn't have to be efficient,
* just valid. * just valid.
*/ */
#ifndef GDISP_NEED_VALIDATION #ifndef GDISP_NEED_VALIDATION
#define GDISP_NEED_VALIDATION TRUE #define GDISP_NEED_VALIDATION TRUE
#endif #endif
/** /**
* @brief Are clipping functions needed. * @brief Are clipping functions needed.
* @details Defaults to TRUE * @details Defaults to TRUE
*/ */
#ifndef GDISP_NEED_CLIP #ifndef GDISP_NEED_CLIP
#define GDISP_NEED_CLIP TRUE #define GDISP_NEED_CLIP TRUE
#endif #endif
/** /**
* @brief Are text functions needed. * @brief Are text functions needed.
* @details Defaults to TRUE * @details Defaults to TRUE
*/ */
#ifndef GDISP_NEED_TEXT #ifndef GDISP_NEED_TEXT
#define GDISP_NEED_TEXT TRUE #define GDISP_NEED_TEXT TRUE
#endif #endif
/** /**
* @brief Are circle functions needed. * @brief Are circle functions needed.
* @details Defaults to TRUE * @details Defaults to TRUE
*/ */
#ifndef GDISP_NEED_CIRCLE #ifndef GDISP_NEED_CIRCLE
#define GDISP_NEED_CIRCLE TRUE #define GDISP_NEED_CIRCLE TRUE
#endif #endif
/** /**
* @brief Are ellipse functions needed. * @brief Are ellipse functions needed.
* @details Defaults to TRUE * @details Defaults to TRUE
*/ */
#ifndef GDISP_NEED_ELLIPSE #ifndef GDISP_NEED_ELLIPSE
#define GDISP_NEED_ELLIPSE TRUE #define GDISP_NEED_ELLIPSE TRUE
#endif #endif
/** /**
* @brief Are arc functions needed. * @brief Are arc functions needed.
* @details Defaults to FALSE * @details Defaults to FALSE
* @note Requires the maths library to be included in the link. ie -lm * @note Requires the maths library to be included in the link. ie -lm
*/ */
#ifndef GDISP_NEED_ARC #ifndef GDISP_NEED_ARC
#define GDISP_NEED_ARC FALSE #define GDISP_NEED_ARC FALSE
#endif #endif
/** /**
* @brief Are convex polygon functions needed. * @brief Are scrolling functions needed.
* @details Defaults to FALSE * @details Defaults to FALSE
* @note Convex polygons are those that have no internal angles. That is; * @note This function must be supported by the low level GDISP driver
* you can draw a line from any point on the polygon to any other point * you have included in your project. If it isn't, defining this
* on the polygon without it going outside the polygon. * option will cause a compile error.
*/ */
#ifndef GDISP_NEED_CONVEX_POLYGON #ifndef GDISP_NEED_SCROLL
#define GDISP_NEED_CONVEX_POLYGON FALSE #define GDISP_NEED_SCROLL FALSE
#endif #endif
/** /**
* @brief Are scrolling functions needed. * @brief Is the capability to read pixels back needed.
* @details Defaults to FALSE * @details Defaults to FALSE
* @note This function must be supported by the low level GDISP driver * @note This function must be supported by the low level GDISP driver
* you have included in your project. If it isn't, defining this * you have included in your project. If it isn't, defining this
* option will cause a compile error. * option will cause a compile error.
*/ */
#ifndef GDISP_NEED_SCROLL #ifndef GDISP_NEED_PIXELREAD
#define GDISP_NEED_SCROLL FALSE #define GDISP_NEED_PIXELREAD FALSE
#endif #endif
/** /**
* @brief Is the capability to read pixels back needed. * @brief Control some aspect of the hardware operation.
* @details Defaults to FALSE * @details Defaults to FALSE
* @note This function must be supported by the low level GDISP driver * @note This allows control of hardware specific features such as
* you have included in your project. If it isn't, defining this * screen rotation, backlight levels, contrast etc
* option will cause a compile error. */
*/ #ifndef GDISP_NEED_CONTROL
#ifndef GDISP_NEED_PIXELREAD #define GDISP_NEED_CONTROL FALSE
#define GDISP_NEED_PIXELREAD FALSE #endif
#endif /**
/** * @brief Is the messaging api interface required.
* @brief Control some aspect of the hardware operation. * @details Defaults to FALSE
* @details Defaults to FALSE */
* @note This allows control of hardware specific features such as #ifndef GDISP_NEED_MSGAPI
* screen rotation, backlight levels, contrast etc #define GDISP_NEED_MSGAPI FALSE
*/ #endif
#ifndef GDISP_NEED_CONTROL /**
#define GDISP_NEED_CONTROL FALSE * @}
#endif *
/** * @name GDISP Multi-Threading Options
* @brief Query some aspect of the hardware operation. * @{
* @details Defaults to FALSE */
* @note This allows query of hardware specific features /**
*/ * @brief Do the drawing functions need to be thread-safe.
#ifndef GDISP_NEED_QUERY * @details Defaults to FALSE
#define GDISP_NEED_QUERY FALSE * @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make
#endif * the gdisp API thread-safe.
/** * @note This is more efficient than GDISP_NEED_ASYNC as it only
* @brief Is the messaging api interface required. * requires a context switch if something else is already
* @details Defaults to FALSE * drawing.
*/ */
#ifndef GDISP_NEED_MSGAPI #ifndef GDISP_NEED_MULTITHREAD
#define GDISP_NEED_MSGAPI FALSE #define GDISP_NEED_MULTITHREAD FALSE
#endif #endif
/** /**
* @} * @brief Use asynchronous calls (multi-thread safe).
* * @details Defaults to FALSE
* @name GDISP Multi-Threading Options * @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make
* @{ * the gdisp API thread-safe.
*/ * @note Turning this on adds two context switches per transaction
/** * so it can significantly slow graphics drawing but it allows
* @brief Do the drawing functions need to be thread-safe. * drawing operations to continue in the background.
* @details Defaults to FALSE */
* @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make #ifndef GDISP_NEED_ASYNC
* the gdisp API thread-safe. #define GDISP_NEED_ASYNC FALSE
* @note This is more efficient than GDISP_NEED_ASYNC as it only #endif
* requires a context switch if something else is already /**
* drawing. * @}
*/ *
#ifndef GDISP_NEED_MULTITHREAD * @name GDISP Fonts
#define GDISP_NEED_MULTITHREAD FALSE * @{
#endif */
/** /**
* @brief Use asynchronous calls (multi-thread safe). * @brief Include the old global font variable definitions
* @details Defaults to FALSE * @details Defaults to FALSE
* @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make */
* the gdisp API thread-safe. #ifndef GDISP_OLD_FONT_DEFINITIONS
* @note Turning this on adds two context switches per transaction #define GDISP_OLD_FONT_DEFINITIONS FALSE
* so it can significantly slow graphics drawing but it allows #endif
* drawing operations to continue in the background. /**
*/ * @brief Predefined built in fonts
#ifndef GDISP_NEED_ASYNC * @note Turning off the ones you are not using can save program size.
#define GDISP_NEED_ASYNC FALSE */
#endif #ifndef GDISP_INCLUDE_FONT_SMALL
/** #define GDISP_INCLUDE_FONT_SMALL TRUE
* @} #endif
* #ifndef GDISP_INCLUDE_FONT_LARGER
* @name GDISP Fonts #define GDISP_INCLUDE_FONT_LARGER TRUE
* @{ #endif
*/ #ifndef GDISP_INCLUDE_FONT_UI1
/** #define GDISP_INCLUDE_FONT_UI1 TRUE
* @brief Predefined built in fonts #endif
* @note Turning off the ones you are not using can save program size. #ifndef GDISP_INCLUDE_FONT_UI2
*/ #define GDISP_INCLUDE_FONT_UI2 TRUE
#ifndef GDISP_INCLUDE_FONT_SMALL #endif
#define GDISP_INCLUDE_FONT_SMALL TRUE #ifndef GDISP_INCLUDE_FONT_LARGENUMBERS
#endif #define GDISP_INCLUDE_FONT_LARGENUMBERS TRUE
#ifndef GDISP_INCLUDE_FONT_LARGER #endif
#define GDISP_INCLUDE_FONT_LARGER TRUE
#endif /**
#ifndef GDISP_INCLUDE_FONT_UI1 * @}
#define GDISP_INCLUDE_FONT_UI1 TRUE *
#endif * @name GDISP Optional Sizing Parameters
#ifndef GDISP_INCLUDE_FONT_UI2 * @{
#define GDISP_INCLUDE_FONT_UI2 TRUE */
#endif /**
#ifndef GDISP_INCLUDE_FONT_LARGENUMBERS * @brief The maximum height of a font.
#define GDISP_INCLUDE_FONT_LARGENUMBERS TRUE * @details Either 16 or 32. Defaults to 16
#endif * @note Setting this to 32 causes the font tables to take
* twice the internal program memory. Don't do it unless
/** * you realy must define an unscaled font larger than 16 bits high.
* @} */
* #ifndef GDISP_MAX_FONT_HEIGHT
* @name GDISP Optional Sizing Parameters #define GDISP_MAX_FONT_HEIGHT 16
* @{ #endif
*/ /**
/** * @}
* @brief The maximum height of a font. *
* @details Either 16 or 32. Defaults to 16 * @name GDISP Optional Low Level Driver Defines
* @note Setting this to 32 causes the font tables to take * @{
* twice the internal program memory. Don't do it unless */
* you realy must define an unscaled font larger than 16 bits high. /**
*/ * @brief Use a custom board definition even if a board definition exists.
#ifndef GDISP_MAX_FONT_HEIGHT * @details Defaults to FALSE
#define GDISP_MAX_FONT_HEIGHT 16 * @details If TRUE, add gdisp_lld_board.h to your project directory and customise it.
#endif * @note Not all GDISP low level drivers currently use board definition files.
/** */
* @} #ifndef GDISP_USE_CUSTOM_BOARD
* #define GDISP_USE_CUSTOM_BOARD FALSE
* @name GDISP Optional Low Level Driver Defines #endif
* @{ /**
*/ * @brief Set the screen height and width.
/** * @note Ignored by some low level GDISP drivers, optional for others.
* @brief Use a custom board definition even if a board definition exists. * @note Where these values are allowed, a default is always provided be the low level driver.
* @details Defaults to FALSE * @note The list of GDISP low level drivers that allow these to be set are...
* @details If TRUE, add gdisp_lld_board.h to your project directory and customise it. * WIN32, SSD1289, SSD1963, TestStub
* @note Not all GDISP low level drivers currently use board definition files. */
*/ /* #define GDISP_SCREEN_WIDTH nnnn */
#ifndef GDISP_USE_CUSTOM_BOARD /* #define GDISP_SCREEN_HEIGHT nnnn */
#define GDISP_USE_CUSTOM_BOARD FALSE /**
#endif * @brief Define which bus interface to use.
/** * @details Only required by the SSD1963 driver.
* @brief Set the screen height and width. * @note This will be replaced eventually by board definition files
* @note Ignored by some low level GDISP drivers, optional for others. */
* @note Where these values are allowed, a default is always provided be the low level driver. /* #define GDISP_USE_FSMC */
* @note The list of GDISP low level drivers that allow these to be set are... /* #define GDISP_USE_GPIO */
* WIN32, SSD1289, SSD1963, TestStub /** @} */
*/
/* #define GDISP_SCREEN_WIDTH nnnn */ #endif /* _GDISP_OPTIONS_H */
/* #define GDISP_SCREEN_HEIGHT nnnn */ /** @} */
/**
* @brief Define which bus interface to use.
* @details Only required by the SSD1963 driver.
* @note This will be replaced eventually by board definition files
*/
/* #define GDISP_USE_FSMC */
/* #define GDISP_USE_GPIO */
/** @} */
#endif /* _GDISP_OPTIONS_H */
/** @} */

1528
src/gdisp/fonts.c
View File

File diff suppressed because it is too large Load Diff

474
src/gdisp/gdisp.c
View File

@ -29,15 +29,12 @@
#include "hal.h" #include "hal.h"
#include "gfx.h" #include "gfx.h"
#if GFX_USE_GDISP #if GFX_USE_GDISP || defined(__DOXYGEN__)
#ifdef GDISP_NEED_TEXT #ifdef GDISP_NEED_TEXT
#include "gdisp/fonts.h" #include "gdisp/fonts.h"
#endif #endif
/* Include the low level driver information */
#include "gdisp/lld/gdisp_lld.h"
/*===========================================================================*/ /*===========================================================================*/
/* Driver local definitions. */ /* Driver local definitions. */
/*===========================================================================*/ /*===========================================================================*/
@ -138,7 +135,16 @@
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
#if GDISP_NEED_MULTITHREAD #if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
/**
* @brief GDISP Driver initialization.
* @note This function is NOT currently implicitly invoked by @p halInit().
* It must be called manually.
*
* @return True if succeeded, False otherwise
*
* @init
*/
bool_t gdispInit(void) { bool_t gdispInit(void) {
bool_t res; bool_t res;
@ -181,7 +187,16 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD #if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
/**
* @brief Test if the GDISP engine is currently drawing.
* @note This function will always return FALSE if
* GDISP_NEED_ASYNC is not defined.
*
* @return TRUE if gdisp is busy, FALSE otherwise
*
* @init
*/
bool_t gdispIsBusy(void) { bool_t gdispIsBusy(void) {
return FALSE; return FALSE;
} }
@ -191,7 +206,14 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD #if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
/**
* @brief Clear the display to the specified color.
*
* @param[in] color The color to use when clearing the screen
*
* @api
*/
void gdispClear(color_t color) { void gdispClear(color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_clear(color); gdisp_lld_clear(color);
@ -205,7 +227,15 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD #if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
/**
* @brief Set a pixel in the specified color.
*
* @param[in] x,y The position to set the pixel.
* @param[in] color The color to use
*
* @api
*/
void gdispDrawPixel(coord_t x, coord_t y, color_t color) { void gdispDrawPixel(coord_t x, coord_t y, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_draw_pixel(x, y, color); gdisp_lld_draw_pixel(x, y, color);
@ -221,7 +251,16 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD #if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
/**
* @brief Draw a line.
*
* @param[in] x0,y0 The start position
* @param[in] x1,y1 The end position
* @param[in] color The color to use
*
* @api
*/
void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) { void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_draw_line(x0, y0, x1, y1, color); gdisp_lld_draw_line(x0, y0, x1, y1, color);
@ -239,7 +278,16 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD #if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
/**
* @brief Fill an area with a color.
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the box (outside dimensions)
* @param[in] color The color to use
*
* @api
*/
void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) { void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_fill_area(x, y, cx, cy, color); gdisp_lld_fill_area(x, y, cx, cy, color);
@ -257,7 +305,25 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD #if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
/**
* @brief Fill an area using the supplied bitmap.
* @details The bitmap is in the pixel format specified by the low level driver
* @note If a packed pixel format is used and the width doesn't
* match a whole number of bytes, the next line will start on a
* non-byte boundary (no end-of-line padding).
* @note If GDISP_NEED_ASYNC is defined then the buffer must be static
* or at least retained until this call has finished the blit. You can
* tell when all graphics drawing is finished by @p gdispIsBusy() going FALSE.
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the filled area
* @param[in] srcx,srcy The bitmap position to start the fill form
* @param[in] srccx The width of a line in the bitmap
* @param[in] buffer The bitmap in the driver's pixel format
*
* @api
*/
void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) { void gdispBlitAreaEx(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t srcx, coord_t srcy, coord_t srccx, const pixel_t *buffer) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_blit_area_ex(x, y, cx, cy, srcx, srcy, srccx, buffer); gdisp_lld_blit_area_ex(x, y, cx, cy, srcx, srcy, srccx, buffer);
@ -278,7 +344,15 @@
} }
#endif #endif
#if (GDISP_NEED_CLIP && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_CLIP && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/**
* @brief Clip all drawing to the defined area.
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the clip area
*
* @api
*/
void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy) { void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_set_clip(x, y, cx, cy); gdisp_lld_set_clip(x, y, cx, cy);
@ -295,7 +369,16 @@
} }
#endif #endif
#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/**
* @brief Draw a circle.
*
* @param[in] x,y The center of the circle
* @param[in] radius The radius of the circle
* @param[in] color The color to use
*
* @api
*/
void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color) { void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_draw_circle(x, y, radius, color); gdisp_lld_draw_circle(x, y, radius, color);
@ -312,7 +395,16 @@
} }
#endif #endif
#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/**
* @brief Draw a filled circle.
*
* @param[in] x,y The center of the circle
* @param[in] radius The radius of the circle
* @param[in] color The color to use
*
* @api
*/
void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color) { void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_fill_circle(x, y, radius, color); gdisp_lld_fill_circle(x, y, radius, color);
@ -329,7 +421,16 @@
} }
#endif #endif
#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/**
* @brief Draw an ellipse.
*
* @param[in] x,y The center of the ellipse
* @param[in] a,b The dimensions of the ellipse
* @param[in] color The color to use
*
* @api
*/
void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) { void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_draw_ellipse(x, y, a, b, color); gdisp_lld_draw_ellipse(x, y, a, b, color);
@ -347,7 +448,16 @@
} }
#endif #endif
#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/**
* @brief Draw a filled ellipse.
*
* @param[in] x,y The center of the ellipse
* @param[in] a,b The dimensions of the ellipse
* @param[in] color The color to use
*
* @api
*/
void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) { void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_fill_ellipse(x, y, a, b, color); gdisp_lld_fill_ellipse(x, y, a, b, color);
@ -365,7 +475,18 @@
} }
#endif #endif
#if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/*
* @brief Draw an arc.
*
* @param[in] x0,y0 The center point
* @param[in] radius The radius of the arc
* @param[in] start The start angle (0 to 360)
* @param[in] end The end angle (0 to 360)
* @param[in] color The color of the arc
*
* @api
*/
void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) { void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_draw_arc(x, y, radius, start, end, color); gdisp_lld_draw_arc(x, y, radius, start, end, color);
@ -384,7 +505,19 @@
} }
#endif #endif
#if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/*
* @brief Draw a filled arc.
* @note Not very efficient currently - does lots of overdrawing
*
* @param[in] x0,y0 The center point
* @param[in] radius The radius of the arc
* @param[in] start The start angle (0 to 360)
* @param[in] end The end angle (0 to 360)
* @param[in] color The color of the arc
*
* @api
*/
void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) { void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_fill_arc(x, y, radius, start, end, color); gdisp_lld_fill_arc(x, y, radius, start, end, color);
@ -403,7 +536,17 @@
} }
#endif #endif
#if GDISP_NEED_ARC #if GDISP_NEED_ARC || defined(__DOXYGEN__)
/**
* @brief Draw a rectangular box with rounded corners
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the box (outside dimensions)
* @param[in] radius The radius of the rounded corners
* @param[in] color The color to use
*
* @api
*/
void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color) { void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color) {
if (2*radius > cx || 2*radius > cy) { if (2*radius > cx || 2*radius > cy) {
gdispDrawBox(x, y, cx, cy, color); gdispDrawBox(x, y, cx, cy, color);
@ -420,7 +563,17 @@ void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
} }
#endif #endif
#if GDISP_NEED_ARC #if GDISP_NEED_ARC || defined(__DOXYGEN__)
/**
* @brief Draw a filled rectangular box with rounded corners
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the box (outside dimensions)
* @param[in] radius The radius of the rounded corners
* @param[in] color The color to use
*
* @api
*/
void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color) { void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color) {
coord_t radius2; coord_t radius2;
@ -439,7 +592,17 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
} }
#endif #endif
#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/**
* @brief Draw a text character.
*
* @param[in] x,y The position for the text
* @param[in] c The character to draw
* @param[in] font The font to use
* @param[in] color The color to use
*
* @api
*/
void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) { void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_draw_char(x, y, c, font, color); gdisp_lld_draw_char(x, y, c, font, color);
@ -457,7 +620,18 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
} }
#endif #endif
#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/**
* @brief Draw a text character with a filled background.
*
* @param[in] x,y The position for the text
* @param[in] c The character to draw
* @param[in] font The font to use
* @param[in] color The color to use
* @param[in] bgcolor The background color to use
*
* @api
*/
void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) { void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_fill_char(x, y, c, font, color, bgcolor); gdisp_lld_fill_char(x, y, c, font, color, bgcolor);
@ -476,7 +650,15 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
} }
#endif #endif
#if (GDISP_NEED_PIXELREAD && (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC)) #if (GDISP_NEED_PIXELREAD && (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC)) || defined(__DOXYGEN__)
/**
* @brief Get the color of a pixel.
* @return The color of the pixel.
*
* @param[in] x,y The position of the pixel
*
* @api
*/
color_t gdispGetPixelColor(coord_t x, coord_t y) { color_t gdispGetPixelColor(coord_t x, coord_t y) {
color_t c; color_t c;
@ -489,7 +671,20 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
} }
#endif #endif
#if (GDISP_NEED_SCROLL && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_SCROLL && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/**
* @brief Scroll vertically a section of the screen.
* @pre GDISP_NEED_SCROLL must be set to TRUE in halconf.h
* @note Optional.
* @note If lines is >= cy, it is equivelent to a area fill with bgcolor.
*
* @param[in] x, y The start of the area to be scrolled
* @param[in] cx, cy The size of the area to be scrolled
* @param[in] lines The number of lines to scroll (Can be positive or negative)
* @param[in] bgcolor The color to fill the newly exposed area.
*
* @api
*/
void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) { void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_vertical_scroll(x, y, cx, cy, lines, bgcolor); gdisp_lld_vertical_scroll(x, y, cx, cy, lines, bgcolor);
@ -508,11 +703,23 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
} }
#endif #endif
#if (GDISP_NEED_CONTROL && GDISP_NEED_MULTITHREAD) #if (GDISP_NEED_CONTROL && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
/**
* @brief Set the power mode for the display.
* @pre The GDISP unit must have been initialised using @p gdispInit().
* @note Depending on the hardware implementation this function may not
* support some codes. They will be ignored.
*
* @param[in] what what you want to control
* @param[in] value The value to be assigned
*
* @api
*/
void gdispControl(unsigned what, void *value) { void gdispControl(unsigned what, void *value) {
chMtxLock(&gdispMutex); chMtxLock(&gdispMutex);
gdisp_lld_control(what, value); gdisp_lld_control(what, value);
chMtxUnlock(); chMtxUnlock();
chThdSleepMilliseconds(100);
} }
#elif GDISP_NEED_CONTROL && GDISP_NEED_ASYNC #elif GDISP_NEED_CONTROL && GDISP_NEED_ASYNC
void gdispControl(unsigned what, void *value) { void gdispControl(unsigned what, void *value) {
@ -524,7 +731,17 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
} }
#endif #endif
#if (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC) && GDISP_NEED_QUERY #if (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC) || defined(__DOXYGEN__)
/**
* @brief Query a property of the display.
* @pre The GDISP unit must have been initialised using @p gdispInit().
* @note The result must be typecast to the correct type.
* @note An uunsupported query will return (void *)-1.
*
* @param[in] what What to query
*
* @api
*/
void *gdispQuery(unsigned what) { void *gdispQuery(unsigned what) {
void *res; void *res;
@ -539,6 +756,15 @@ void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
/* High Level Driver Routines. */ /* High Level Driver Routines. */
/*===========================================================================*/ /*===========================================================================*/
/**
* @brief Draw a rectangular box.
*
* @param[in] x,y The start position
* @param[in] cx,cy The size of the box (outside dimensions)
* @param[in] color The color to use
*
* @api
*/
void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) { void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
/* No mutex required as we only call high level functions which have their own mutex */ /* No mutex required as we only call high level functions which have their own mutex */
coord_t x1, y1; coord_t x1, y1;
@ -565,102 +791,18 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
} }
#if GDISP_NEED_CONVEX_POLYGON
void gdispDrawPoly(const point *pntarray, unsigned cnt, color_t color) {
const point *epnt, *p;
epnt = &pntarray[cnt-1]; #if GDISP_NEED_TEXT || defined(__DOXYGEN__)
for(p = pntarray; p < epnt; p++) /**
gdispDrawLine(p->x, p->y, p[1].x, p[1].y, color); * @brief Draw a text string.
gdispDrawLine(p->x, p->y, pntarray->x, pntarray->y, color); *
} * @param[in] x,y The position for the text
* @param[in] font The font to use
void gdispFillConvexPoly(const point *pntarray, unsigned cnt, color_t color) { * @param[in] str The string to draw
const point *lpnt, *rpnt, *epnts; * @param[in] color The color to use
fpcoord_t lx, rx, lk, rk; *
coord_t y, ymax, lxc, rxc; * @api
*/
epnts = &pntarray[cnt-1];
/* Find a top point */
rpnt = pntarray;
for(lpnt=pntarray+1; lpnt <= epnts; lpnt++) {
if (lpnt->y < rpnt->y)
rpnt = lpnt;
}
lx = rx = rpnt->x<<16;
y = rpnt->y;
/* Work out the slopes of the two attached line segs */
lpnt = rpnt <= pntarray ? epnts : rpnt-1;
while (lpnt->y == y) {
lx = lpnt->x<<16;
lpnt = lpnt <= pntarray ? epnts : lpnt-1;
if (!cnt--) return;
}
rpnt = rpnt >= epnts ? pntarray : rpnt+1;
while (rpnt->y == y) {
rx = rpnt->x<<16;
rpnt = rpnt >= epnts ? pntarray : rpnt+1;
if (!cnt--) return;
}
lk = (((fpcoord_t)(lpnt->x)<<16) - lx) / (lpnt->y - y);
rk = (((fpcoord_t)(rpnt->x)<<16) - rx) / (rpnt->y - y);
while(1) {
/* Determine our boundary */
ymax = rpnt->y < lpnt->y ? rpnt->y : lpnt->y;
/* Scan down the line segments until we hit a boundary */
for(; y < ymax; y++) {
lxc = lx>>16;
rxc = rx>>16;
/*
* Doesn't print the right hand point in order to allow polygon joining.
* Also ensures that we draw from left to right with the minimum number
* of pixels.
*/
if (lxc < rxc) {
if (rxc - lxc == 1)
gdispDrawPixel(lxc, y, color);
else
gdispDrawLine(lxc, y, rxc-1, y, color);
} else if (lxc > rxc) {
if (lxc - rxc == 1)
gdispDrawPixel(rxc, y, color);
else
gdispDrawLine(rxc, y, lxc-1, y, color);
}
lx += lk;
rx += rk;
}
if (!cnt--) return;
/* Replace the appropriate point */
if (ymax == lpnt->y) {
lpnt = lpnt <= pntarray ? epnts : lpnt-1;
while (lpnt->y == y) {
lx = lpnt->x<<16;
lpnt = lpnt <= pntarray ? epnts : lpnt-1;
if (!cnt--) return;
}
lk = (((fpcoord_t)(lpnt->x)<<16) - lx) / (lpnt->y - y);
} else {
rpnt = rpnt >= epnts ? pntarray : rpnt+1;
while (rpnt->y == y) {
rx = rpnt->x<<16;
rpnt = rpnt >= epnts ? pntarray : rpnt+1;
if (!cnt--) return;
}
rk = (((fpcoord_t)(rpnt->x)<<16) - rx) / (rpnt->y - y);
}
}
}
#endif
#if GDISP_NEED_TEXT
void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color) { void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color) {
/* No mutex required as we only call high level functions which have their own mutex */ /* No mutex required as we only call high level functions which have their own mutex */
coord_t w, p; coord_t w, p;
@ -692,7 +834,18 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT #if GDISP_NEED_TEXT || defined(__DOXYGEN__)
/**
* @brief Draw a text string.
*
* @param[in] x,y The position for the text
* @param[in] str The string to draw
* @param[in] font The font to use
* @param[in] color The color to use
* @param[in] bgcolor The background color to use
*
* @api
*/
void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor) { void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor) {
/* No mutex required as we only call high level functions which have their own mutex */ /* No mutex required as we only call high level functions which have their own mutex */
coord_t w, h, p; coord_t w, h, p;
@ -726,7 +879,19 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT #if GDISP_NEED_TEXT || defined(__DOXYGEN__)
/**
* @brief Draw a text string verticly centered within the specified box.
*
* @param[in] x,y The position for the text (need to define top-right or base-line - check code)
* @param[in] cx,cy The width and height of the box
* @param[in] str The string to draw
* @param[in] font The font to use
* @param[in] color The color to use
* @param[in] justify Justify the text left, center or right within the box
*
* @api
*/
void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, justify_t justify) { void gdispDrawStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, justify_t justify) {
/* No mutex required as we only call high level functions which have their own mutex */ /* No mutex required as we only call high level functions which have their own mutex */
coord_t w, h, p, ypos, xpos; coord_t w, h, p, ypos, xpos;
@ -846,7 +1011,21 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT #if GDISP_NEED_TEXT || defined(__DOXYGEN__)
/**
* @brief Draw a text string verticly centered within the specified box. The box background is filled with the specified background color.
* @note The entire box is filled
*
* @param[in] x,y The position for the text (need to define top-right or base-line - check code)
* @param[in] cx,cy The width and height of the box
* @param[in] str The string to draw
* @param[in] font The font to use
* @param[in] color The color to use
* @param[in] bgcolor The background color to use
* @param[in] justify Justify the text left, center or right within the box
*
* @api
*/
void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgcolor, justify_t justify) { void gdispFillStringBox(coord_t x, coord_t y, coord_t cx, coord_t cy, const char* str, font_t font, color_t color, color_t bgcolor, justify_t justify) {
/* No mutex required as we only call high level functions which have their own mutex */ /* No mutex required as we only call high level functions which have their own mutex */
coord_t w, h, p, ypos, xpos; coord_t w, h, p, ypos, xpos;
@ -978,7 +1157,16 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT #if GDISP_NEED_TEXT || defined(__DOXYGEN__)
/**
* @brief Get a metric of a font.
* @return The metric requested in pixels.
*
* @param[in] font The font to test
* @param[in] metric The metric to measure
*
* @api
*/
coord_t gdispGetFontMetric(font_t font, fontmetric_t metric) { coord_t gdispGetFontMetric(font_t font, fontmetric_t metric) {
/* No mutex required as we only read static data */ /* No mutex required as we only read static data */
switch(metric) { switch(metric) {
@ -993,14 +1181,32 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT #if GDISP_NEED_TEXT || defined(__DOXYGEN__)
/**
* @brief Get the pixel width of a character.
* @return The width of the character in pixels. Does not include any between character padding.
*
* @param[in] c The character to draw
* @param[in] font The font to use
*
* @api
*/
coord_t gdispGetCharWidth(char c, font_t font) { coord_t gdispGetCharWidth(char c, font_t font) {
/* No mutex required as we only read static data */ /* No mutex required as we only read static data */
return _getCharWidth(font, c) * font->xscale; return _getCharWidth(font, c) * font->xscale;
} }
#endif #endif
#if GDISP_NEED_TEXT #if GDISP_NEED_TEXT || defined(__DOXYGEN__)
/**
* @brief Get the pixel width of a string.
* @return The width of the string in pixels.
*
* @param[in] str The string to measure
* @param[in] font The font to use
*
* @api
*/
coord_t gdispGetStringWidth(const char* str, font_t font) { coord_t gdispGetStringWidth(const char* str, font_t font) {
/* No mutex required as we only read static data */ /* No mutex required as we only read static data */
coord_t w, p, x; coord_t w, p, x;
@ -1031,7 +1237,19 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if (!defined(gdispPackPixels) && !defined(GDISP_PIXELFORMAT_CUSTOM)) #if (!defined(gdispPackPixels) && !defined(GDISP_PIXELFORMAT_CUSTOM)) || defined(__DOXYGEN__)
/**
* @brief Pack a pixel into a pixel buffer.
* @note This function performs no buffer boundary checking
* regardless of whether GDISP_NEED_CLIP has been specified.
*
* @param[in] buf The buffer to put the pixel in
* @param[in] cx The width of a pixel line
* @param[in] x, y The location of the pixel to place
* @param[in] color The color to put into the buffer
*
* @api
*/
void gdispPackPixels(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color) { void gdispPackPixels(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color) {
/* No mutex required as we only read static data */ /* No mutex required as we only read static data */
#if defined(GDISP_PIXELFORMAT_RGB888) #if defined(GDISP_PIXELFORMAT_RGB888)