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

GDISP changes including polygon support

Browse Source 
Add polygon drawing
Add convex polygon filling
Start support for a monochrome display
Move gdisp doxygen to header file
Restructure the balance between gdisp.h and gdisp_lld.h
Remove old extern font definitions (now always use gdispOpenFont)
Make public the GDISP structure and change macros to suit (faster for
the application).
gdispQuery is now optional.
This commit is contained in:
Andrew Hannam 2013-03-10 16:14:32 +10:00
parent 8a40457c86
commit 40b390908c
10 changed files with 1905 additions and 1679 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -41,7 +41,6 @@
#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,7 +41,6 @@
#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,21 +27,22 @@
#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_SCROLL FALSE #define GDISP_NEED_CONVEX_POLYGON FALSE
#define GDISP_NEED_PIXELREAD FALSE #define GDISP_NEED_SCROLL FALSE
#define GDISP_NEED_CONTROL FALSE #define GDISP_NEED_PIXELREAD FALSE
#define GDISP_NEED_MULTITHREAD FALSE #define GDISP_NEED_CONTROL FALSE
#define GDISP_NEED_ASYNC FALSE #define GDISP_NEED_QUERY FALSE
#define GDISP_NEED_MSGAPI FALSE #define GDISP_NEED_MULTITHREAD 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

828
include/gdisp/gdisp.h
View File

@ -48,9 +48,121 @@ typedef int16_t coord_t;
#if GFX_USE_GDISP || defined(__DOXYGEN__) #if GFX_USE_GDISP || defined(__DOXYGEN__)
/*===========================================================================*/ /*===========================================================================*/
/* Driver constants. */ /* Include the low level driver configuration information */
/*===========================================================================*/ /*===========================================================================*/
#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
* @{ * @{
@ -80,125 +192,426 @@ typedef int16_t coord_t;
/** @} */ /** @} */
/*===========================================================================*/ /*===========================================================================*/
/* Low Level Driver details and error checks. */ /* Defines related to the pixel format */
/*===========================================================================*/ /*===========================================================================*/
/* Include the low level driver information */ #if defined(__DOXYGEN__)
#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
/* Type definitions */ typedef uint8_t color_t;
/*===========================================================================*/ #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
* @brief Type for the text justification. typedef uint16_t color_t;
*/ #define COLOR(c) ((color_t)(c))
typedef enum justify {justifyLeft, justifyCenter, justifyRight} justify_t; #define MASKCOLOR FALSE
/** #define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF8)<<8) | (((g) & 0xFC)<<3) | (((b) & 0xF8)>>3)))
* @brief Type for the font metric. #define HTML2COLOR(h) ((color_t)((((h) & 0xF80000)>>8) | (((h) & 0x00FC00)>>5) | (((h) & 0x0000F8)>>3)))
*/ #define RED_OF(c) (((c) & 0xF800)>>8)
typedef enum fontmetric {fontHeight, fontDescendersHeight, fontLineSpacing, fontCharPadding, fontMinWidth, fontMaxWidth} fontmetric_t; #define GREEN_OF(c) (((c)&0x07E0)>>3)
#define BLUE_OF(c) (((c)&0x001F)<<3)
/*===========================================================================*/ #elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB888
/* External declarations. */ 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)
#if (GDISP_NEED_TEXT && GDISP_OLD_FONT_DEFINITIONS) || defined(__DOXYGEN__) #elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB444
#if GDISP_INCLUDE_FONT_SMALL typedef uint16_t color_t;
extern const struct font fontSmall; #define COLOR(c) ((color_t)(((c) & 0x0FFF)))
extern const struct font fontSmallDouble; #define MASKCOLOR TRUE
extern const struct font fontSmallNarrow; #define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xF0)<<4) | ((g) & 0xF0) | (((b) & 0xF0)>>4)))
#endif #define HTML2COLOR(h) ((color_t)((((h) & 0xF00000)>>12) | (((h) & 0x00F000)>>8) | (((h) & 0x0000F0)>>4)))
#if GDISP_INCLUDE_FONT_LARGER #define RED_OF(c) (((c) & 0x0F00)>>4)
extern const struct font fontLarger; #define GREEN_OF(c) ((c)&0x00F0)
extern const struct font fontLargerDouble; #define BLUE_OF(c) (((c)&0x000F)<<4)
extern const struct font fontLargerNarrow;
#endif #elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB332
#if GDISP_INCLUDE_FONT_UI1 typedef uint8_t color_t;
extern const struct font fontUI1; #define COLOR(c) ((color_t)(c))
extern const struct font fontUI1Double; #define MASKCOLOR FALSE
extern const struct font fontUI1Narrow; #define RGB2COLOR(r,g,b) ((color_t)(((r) & 0xE0) | (((g) & 0xE0)>>3) | (((b) & 0xC0)>>6)))
#endif #define HTML2COLOR(h) ((color_t)((((h) & 0xE00000)>>16) | (((h) & 0x00E000)>>11) | (((h) & 0x0000C0)>>6)))
#if GDISP_INCLUDE_FONT_UI2 #define RED_OF(c) ((c) & 0xE0)
extern const struct font fontUI2; #define GREEN_OF(c) (((c)&0x1C)<<3)
extern const struct font fontUI2Double; #define BLUE_OF(c) (((c)&0x03)<<6)
extern const struct font fontUI2Narrow;
#endif #elif GDISP_PIXELFORMAT == GDISP_PIXELFORMAT_RGB666
#if GDISP_INCLUDE_FONT_LARGENUMBERS typedef uint32_t color_t;
extern const struct font fontLargeNumbers; #define COLOR(c) ((color_t)(((c) & 0x03FFFF)))
extern const struct font fontLargeNumbersDouble; #define MASKCOLOR TRUE
extern const struct font fontLargeNumbersNarrow; #define RGB2COLOR(r,g,b) ((color_t)((((r) & 0xFC)<<10) | (((g) & 0xFC)<<4) | (((b) & 0xFC)>>2)))
#endif #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 #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.
*/
typedef color_t pixel_t;
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC #if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC || defined(__DOXYGEN__)
/* 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
void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy); #if GDISP_NEED_CLIP || 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);
#endif #endif
/* Circle Functions */ /* Circle Functions */
#if GDISP_NEED_CIRCLE
void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color); #if GDISP_NEED_CIRCLE || defined(__DOXYGEN__)
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
void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color); #if GDISP_NEED_ELLIPSE || defined(__DOXYGEN__)
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
void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color); #if GDISP_NEED_ARC || defined(__DOXYGEN__)
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
void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color); #if GDISP_NEED_TEXT || defined(__DOXYGEN__)
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
color_t gdispGetPixelColor(coord_t x, coord_t y); #if GDISP_NEED_PIXELREAD || 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);
#endif #endif
/* Scrolling Function - clears the area scrolled out */ /* Scrolling Function - clears the area scrolled out */
#if GDISP_NEED_SCROLL
void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor); #if GDISP_NEED_SCROLL || 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);
#endif #endif
/* Set driver specific control */ /* Set driver specific control */
#if GDISP_NEED_CONTROL
void gdispControl(unsigned what, void *value); #if GDISP_NEED_CONTROL || defined(__DOXYGEN__)
/**
* @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()
@ -229,30 +642,214 @@ 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 */
#ifndef gdispPackPixels #if !defined(gdispPackPixels) || 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(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
@ -264,19 +861,99 @@ 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)) /**
#define gdispGetHeight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT)) * @brief Get the display width in pixels.
#define gdispGetPowerMode() ((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER)) *
#define gdispGetOrientation() ((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION)) * @api
#define gdispGetBacklight() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT)) */
#define gdispGetContrast() ((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST)) #define gdispGetWidth() (GDISP.Width)
/**
* @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())
@ -288,4 +965,3 @@ 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,22 +34,13 @@
#ifndef GDISP_EMULATION_C #ifndef GDISP_EMULATION_C
#define GDISP_EMULATION_C #define GDISP_EMULATION_C
#if GFX_USE_GDISP /*|| defined(__DOXYGEN__) */ #if GFX_USE_GDISP
#ifndef GDISP_LLD_NO_STRUCT /* Include the low level driver information */
static struct GDISPDriver { #include "gdisp/lld/gdisp_lld.h"
coord_t Width;
coord_t Height; /* Declare the GDISP structure */
gdisp_orientation_t Orientation; GDISPDriver GDISP;
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) {
@ -670,17 +661,10 @@
} }
#endif #endif
#if !GDISP_HARDWARE_QUERY #if GDISP_NEED_QUERY && !GDISP_HARDWARE_QUERY
void *gdisp_lld_query(unsigned what) { void *gdisp_lld_query(unsigned what) {
switch(what) { (void) what;
case GDISP_QUERY_WIDTH: return (void *)(unsigned)GDISP.Width; return (void *)-1;
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
@ -759,9 +743,11 @@ 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,73 +31,6 @@
#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. */
/*===========================================================================*/ /*===========================================================================*/
@ -320,140 +253,6 @@
#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. */
/*===========================================================================*/ /*===========================================================================*/
@ -515,7 +314,9 @@ 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,236 +1,247 @@
/* /*
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 scrolling functions needed. * @brief Are convex polygon functions needed.
* @details Defaults to FALSE * @details Defaults to FALSE
* @note This function must be supported by the low level GDISP driver * @note Convex polygons are those that have no internal angles. That is;
* you have included in your project. If it isn't, defining this * you can draw a line from any point on the polygon to any other point
* option will cause a compile error. * on the polygon without it going outside the polygon.
*/ */
#ifndef GDISP_NEED_SCROLL #ifndef GDISP_NEED_CONVEX_POLYGON
#define GDISP_NEED_SCROLL FALSE #define GDISP_NEED_CONVEX_POLYGON FALSE
#endif #endif
/** /**
* @brief Is the capability to read pixels back needed. * @brief Are scrolling functions 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_PIXELREAD #ifndef GDISP_NEED_SCROLL
#define GDISP_NEED_PIXELREAD FALSE #define GDISP_NEED_SCROLL FALSE
#endif #endif
/** /**
* @brief Control some aspect of the hardware operation. * @brief Is the capability to read pixels back needed.
* @details Defaults to FALSE * @details Defaults to FALSE
* @note This allows control of hardware specific features such as * @note This function must be supported by the low level GDISP driver
* screen rotation, backlight levels, contrast etc * you have included in your project. If it isn't, defining this
*/ * option will cause a compile error.
#ifndef GDISP_NEED_CONTROL */
#define GDISP_NEED_CONTROL FALSE #ifndef GDISP_NEED_PIXELREAD
#endif #define GDISP_NEED_PIXELREAD FALSE
/** #endif
* @brief Is the messaging api interface required. /**
* @details Defaults to FALSE * @brief Control some aspect of the hardware operation.
*/ * @details Defaults to FALSE
#ifndef GDISP_NEED_MSGAPI * @note This allows control of hardware specific features such as
#define GDISP_NEED_MSGAPI FALSE * screen rotation, backlight levels, contrast etc
#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. */
* @details Defaults to FALSE #ifndef GDISP_NEED_QUERY
* @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make #define GDISP_NEED_QUERY FALSE
* the gdisp API thread-safe. #endif
* @note This is more efficient than GDISP_NEED_ASYNC as it only /**
* requires a context switch if something else is already * @brief Is the messaging api interface required.
* drawing. * @details Defaults to FALSE
*/ */
#ifndef GDISP_NEED_MULTITHREAD #ifndef GDISP_NEED_MSGAPI
#define GDISP_NEED_MULTITHREAD FALSE #define GDISP_NEED_MSGAPI FALSE
#endif #endif
/** /**
* @brief Use asynchronous calls (multi-thread safe). * @}
* @details Defaults to FALSE *
* @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make * @name GDISP Multi-Threading Options
* 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 /**
* drawing operations to continue in the background. * @brief Do the drawing functions need to be thread-safe.
*/ * @details Defaults to FALSE
#ifndef GDISP_NEED_ASYNC * @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make
#define GDISP_NEED_ASYNC FALSE * the gdisp API thread-safe.
#endif * @note This is more efficient than GDISP_NEED_ASYNC as it only
/** * requires a context switch if something else is already
* @} * drawing.
* */
* @name GDISP Fonts #ifndef GDISP_NEED_MULTITHREAD
* @{ #define GDISP_NEED_MULTITHREAD FALSE
*/ #endif
/** /**
* @brief Include the old global font variable definitions * @brief Use asynchronous calls (multi-thread safe).
* @details Defaults to FALSE * @details Defaults to FALSE
*/ * @note Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make
#ifndef GDISP_OLD_FONT_DEFINITIONS * the gdisp API thread-safe.
#define GDISP_OLD_FONT_DEFINITIONS FALSE * @note Turning this on adds two context switches per transaction
#endif * so it can significantly slow graphics drawing but it allows
/** * drawing operations to continue in the background.
* @brief Predefined built in fonts */
* @note Turning off the ones you are not using can save program size. #ifndef GDISP_NEED_ASYNC
*/ #define GDISP_NEED_ASYNC FALSE
#ifndef GDISP_INCLUDE_FONT_SMALL #endif
#define GDISP_INCLUDE_FONT_SMALL TRUE /**
#endif * @}
#ifndef GDISP_INCLUDE_FONT_LARGER *
#define GDISP_INCLUDE_FONT_LARGER TRUE * @name GDISP Fonts
#endif * @{
#ifndef GDISP_INCLUDE_FONT_UI1 */
#define GDISP_INCLUDE_FONT_UI1 TRUE /**
#endif * @brief Predefined built in fonts
#ifndef GDISP_INCLUDE_FONT_UI2 * @note Turning off the ones you are not using can save program size.
#define GDISP_INCLUDE_FONT_UI2 TRUE */
#endif #ifndef GDISP_INCLUDE_FONT_SMALL
#ifndef GDISP_INCLUDE_FONT_LARGENUMBERS #define GDISP_INCLUDE_FONT_SMALL TRUE
#define GDISP_INCLUDE_FONT_LARGENUMBERS TRUE #endif
#endif #ifndef GDISP_INCLUDE_FONT_LARGER
#define GDISP_INCLUDE_FONT_LARGER TRUE
/** #endif
* @} #ifndef GDISP_INCLUDE_FONT_UI1
* #define GDISP_INCLUDE_FONT_UI1 TRUE
* @name GDISP Optional Sizing Parameters #endif
* @{ #ifndef GDISP_INCLUDE_FONT_UI2
*/ #define GDISP_INCLUDE_FONT_UI2 TRUE
/** #endif
* @brief The maximum height of a font. #ifndef GDISP_INCLUDE_FONT_LARGENUMBERS
* @details Either 16 or 32. Defaults to 16 #define GDISP_INCLUDE_FONT_LARGENUMBERS TRUE
* @note Setting this to 32 causes the font tables to take #endif
* 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 *
#define GDISP_MAX_FONT_HEIGHT 16 * @name GDISP Optional Sizing Parameters
#endif * @{
/** */
* @} /**
* * @brief The maximum height of a font.
* @name GDISP Optional Low Level Driver Defines * @details Either 16 or 32. Defaults to 16
* @{ * @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. */
* @details Defaults to FALSE #ifndef GDISP_MAX_FONT_HEIGHT
* @details If TRUE, add gdisp_lld_board.h to your project directory and customise it. #define GDISP_MAX_FONT_HEIGHT 16
* @note Not all GDISP low level drivers currently use board definition files. #endif
*/ /**
#ifndef GDISP_USE_CUSTOM_BOARD * @}
#define GDISP_USE_CUSTOM_BOARD FALSE *
#endif * @name GDISP Optional Low Level Driver Defines
/** * @{
* @brief Set the screen height and width. */
* @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. * @brief Use a custom board definition even if a board definition exists.
* @note The list of GDISP low level drivers that allow these to be set are... * @details Defaults to FALSE
* WIN32, SSD1289, SSD1963, TestStub * @details If TRUE, add gdisp_lld_board.h to your project directory and customise it.
*/ * @note Not all GDISP low level drivers currently use board definition files.
/* #define GDISP_SCREEN_WIDTH nnnn */ */
/* #define GDISP_SCREEN_HEIGHT nnnn */ #ifndef GDISP_USE_CUSTOM_BOARD
/** #define GDISP_USE_CUSTOM_BOARD FALSE
* @brief Define which bus interface to use. #endif
* @details Only required by the SSD1963 driver. /**
* @note This will be replaced eventually by board definition files * @brief Set the screen height and width.
*/ * @note Ignored by some low level GDISP drivers, optional for others.
/* #define GDISP_USE_FSMC */ * @note Where these values are allowed, a default is always provided be the low level driver.
/* #define GDISP_USE_GPIO */ * @note The list of GDISP low level drivers that allow these to be set are...
/** @} */ * WIN32, SSD1289, SSD1963, TestStub
*/
#endif /* _GDISP_OPTIONS_H */ /* #define GDISP_SCREEN_WIDTH nnnn */
/** @} */ /* #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 */
/** @} */

3
releases.txt
View File

@ -15,6 +15,9 @@ FEATURE: Implemented all four orientation modes for the ILI9320 GDISP driver
FIX: Renamed every '__inline' macro to 'inline' for compiler compatibilities FIX: Renamed every '__inline' macro to 'inline' for compiler compatibilities
FEATURE: Supporting all standard functions in GDISP Nokia6610GE8 driver FEATURE: Supporting all standard functions in GDISP Nokia6610GE8 driver
FEATURE: Added STMPE811 GINPUT driver FEATURE: Added STMPE811 GINPUT driver
FEATURE: Added gdispDrawPoly() and gdispFillConvexPoly()
FEATURE: Added arrow button style to GWIN buttons
FEATURE: Added the ability to specify a custom button drawing routine
*** changes after 1.4 *** *** changes after 1.4 ***

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,12 +29,15 @@
#include "hal.h" #include "hal.h"
#include "gfx.h" #include "gfx.h"
#if GFX_USE_GDISP || defined(__DOXYGEN__) #if GFX_USE_GDISP
#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. */
/*===========================================================================*/ /*===========================================================================*/
@ -135,16 +138,7 @@
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__) #if GDISP_NEED_MULTITHREAD
/**
* @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;
@ -187,16 +181,7 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__) #if GDISP_NEED_MULTITHREAD
/**
* @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;
} }
@ -206,14 +191,7 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__) #if GDISP_NEED_MULTITHREAD
/**
* @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);
@ -227,15 +205,7 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__) #if GDISP_NEED_MULTITHREAD
/**
* @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);
@ -251,16 +221,7 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__) #if GDISP_NEED_MULTITHREAD
/**
* @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);
@ -278,16 +239,7 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__) #if GDISP_NEED_MULTITHREAD
/**
* @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);
@ -305,25 +257,7 @@
} }
#endif #endif
#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__) #if GDISP_NEED_MULTITHREAD
/**
* @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);
@ -344,15 +278,7 @@
} }
#endif #endif
#if (GDISP_NEED_CLIP && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__) #if (GDISP_NEED_CLIP && GDISP_NEED_MULTITHREAD)
/**
* @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);
@ -369,16 +295,7 @@
} }
#endif #endif
#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__) #if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD)
/**
* @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);
@ -395,16 +312,7 @@
} }
#endif #endif
#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__) #if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD)
/**
* @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);
@ -421,16 +329,7 @@
} }
#endif #endif
#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__) #if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD)
/**
* @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);
@ -448,16 +347,7 @@
} }
#endif #endif
#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__) #if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD)
/**
* @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);
@ -475,18 +365,7 @@
} }
#endif #endif
#if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__) #if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD)
/*
* @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);
@ -505,19 +384,7 @@
} }
#endif #endif
#if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__) #if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD)
/*
* @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);
@ -536,17 +403,7 @@
} }
#endif #endif
#if GDISP_NEED_ARC || defined(__DOXYGEN__) #if GDISP_NEED_ARC
/**
* @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);
@ -563,17 +420,7 @@ void gdispDrawRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t r
} }
#endif #endif
#if GDISP_NEED_ARC || defined(__DOXYGEN__) #if GDISP_NEED_ARC
/**
* @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;
@ -592,17 +439,7 @@ 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) || defined(__DOXYGEN__) #if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD)
/**
* @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);
@ -620,18 +457,7 @@ 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) || defined(__DOXYGEN__) #if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD)
/**
* @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);
@ -650,15 +476,7 @@ 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)) || defined(__DOXYGEN__) #if (GDISP_NEED_PIXELREAD && (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC))
/**
* @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;
@ -671,20 +489,7 @@ 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) || defined(__DOXYGEN__) #if (GDISP_NEED_SCROLL && GDISP_NEED_MULTITHREAD)
/**
* @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);
@ -703,23 +508,11 @@ 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) || defined(__DOXYGEN__) #if (GDISP_NEED_CONTROL && GDISP_NEED_MULTITHREAD)
/**
* @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) {
@ -731,17 +524,7 @@ 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) || defined(__DOXYGEN__) #if (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC) && GDISP_NEED_QUERY
/**
* @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;
@ -756,15 +539,6 @@ 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;
@ -791,18 +565,102 @@ 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;
#if GDISP_NEED_TEXT || defined(__DOXYGEN__) epnt = &pntarray[cnt-1];
/** for(p = pntarray; p < epnt; p++)
* @brief Draw a text string. gdispDrawLine(p->x, p->y, p[1].x, p[1].y, color);
* 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
* @param[in] str The string to draw void gdispFillConvexPoly(const point *pntarray, unsigned cnt, color_t color) {
* @param[in] color The color to use const point *lpnt, *rpnt, *epnts;
* fpcoord_t lx, rx, lk, rk;
* @api coord_t y, ymax, lxc, rxc;
*/
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;
@ -834,18 +692,7 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT || defined(__DOXYGEN__) #if GDISP_NEED_TEXT
/**
* @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;
@ -879,19 +726,7 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT || defined(__DOXYGEN__) #if GDISP_NEED_TEXT
/**
* @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;
@ -1011,21 +846,7 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT || defined(__DOXYGEN__) #if GDISP_NEED_TEXT
/**
* @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;
@ -1157,16 +978,7 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT || defined(__DOXYGEN__) #if GDISP_NEED_TEXT
/**
* @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) {
@ -1181,32 +993,14 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
} }
#endif #endif
#if GDISP_NEED_TEXT || defined(__DOXYGEN__) #if GDISP_NEED_TEXT
/**
* @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 || defined(__DOXYGEN__) #if GDISP_NEED_TEXT
/**
* @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;
@ -1237,19 +1031,7 @@ 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)) || defined(__DOXYGEN__) #if (!defined(gdispPackPixels) && !defined(GDISP_PIXELFORMAT_CUSTOM))
/**
* @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)