Merge pull request #42 from inmarket/master

GDISP and GWIN button changes

12 files changed, 2336 insertions, 1934 deletions

diff --git a/demos/modules/gadc/gfxconf.h b/demos/modules/gadc/gfxconf.h
index 58475fba..213152e4 100644
--- a/demos/modules/gadc/gfxconf.h
+++ b/demos/modules/gadc/gfxconf.h
@@ -41,7 +41,6 @@
 #define GDISP_NEED_MSGAPI		FALSE
 
 /* GDISP - builtin fonts */
-#define GDISP_OLD_FONT_DEFINITIONS		FALSE
 #define GDISP_INCLUDE_FONT_SMALL		FALSE
 #define GDISP_INCLUDE_FONT_LARGER		FALSE
 #define GDISP_INCLUDE_FONT_UI1			FALSE
diff --git a/demos/modules/gaudin/gfxconf.h b/demos/modules/gaudin/gfxconf.h
index 4222acb4..a4df2071 100644
--- a/demos/modules/gaudin/gfxconf.h
+++ b/demos/modules/gaudin/gfxconf.h
@@ -41,7 +41,6 @@
 #define GDISP_NEED_MSGAPI		FALSE
 
 /* GDISP - builtin fonts */
-#define GDISP_OLD_FONT_DEFINITIONS		FALSE
 #define GDISP_INCLUDE_FONT_SMALL		FALSE
 #define GDISP_INCLUDE_FONT_LARGER		FALSE
 #define GDISP_INCLUDE_FONT_UI1			FALSE
diff --git a/gfxconf.example.h b/gfxconf.example.h
index c53906d2..9db7d1b5 100644
--- a/gfxconf.example.h
+++ b/gfxconf.example.h
@@ -27,21 +27,22 @@
 #define GFX_USE_GMISC			FALSE
 
 /* Features for the GDISP subsystem */
-#define GDISP_NEED_VALIDATION	TRUE
-#define GDISP_NEED_CLIP			TRUE
-#define GDISP_NEED_TEXT			TRUE
-#define GDISP_NEED_CIRCLE		TRUE
-#define GDISP_NEED_ELLIPSE		TRUE
-#define GDISP_NEED_ARC			FALSE
-#define GDISP_NEED_SCROLL		FALSE
-#define GDISP_NEED_PIXELREAD	FALSE
-#define GDISP_NEED_CONTROL		FALSE
-#define GDISP_NEED_MULTITHREAD	FALSE
-#define GDISP_NEED_ASYNC		FALSE
-#define GDISP_NEED_MSGAPI		FALSE
+#define GDISP_NEED_VALIDATION		TRUE
+#define GDISP_NEED_CLIP				TRUE
+#define GDISP_NEED_TEXT				TRUE
+#define GDISP_NEED_CIRCLE			TRUE
+#define GDISP_NEED_ELLIPSE			TRUE
+#define GDISP_NEED_ARC				FALSE
+#define GDISP_NEED_CONVEX_POLYGON	FALSE
+#define GDISP_NEED_SCROLL			FALSE
+#define GDISP_NEED_PIXELREAD		FALSE
+#define GDISP_NEED_CONTROL			FALSE
+#define GDISP_NEED_QUERY			FALSE
+#define GDISP_NEED_MULTITHREAD		FALSE
+#define GDISP_NEED_ASYNC			FALSE
+#define GDISP_NEED_MSGAPI			FALSE
 
 /* GDISP - builtin fonts */
-#define GDISP_OLD_FONT_DEFINITIONS		FALSE
 #define GDISP_INCLUDE_FONT_SMALL		TRUE
 #define GDISP_INCLUDE_FONT_LARGER		TRUE
 #define GDISP_INCLUDE_FONT_UI1			TRUE
diff --git a/include/gdisp/gdisp.h b/include/gdisp/gdisp.h
index a9f15e0f..13937d16 100644
--- a/include/gdisp/gdisp.h
+++ b/include/gdisp/gdisp.h
@@ -48,10 +48,122 @@ typedef int16_t	coord_t;
 #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
  * @{
  */
@@ -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 */
-#include "gdisp/lld/gdisp_lld.h"
-
-/*===========================================================================*/
-/* Type definitions                                                          */
-/*===========================================================================*/
+#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_MONO
+	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
+	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
 
-/**
- * @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;
+/* 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
 
-/*===========================================================================*/
-/* External declarations.                                                    */
-/*===========================================================================*/
+#if GDISP_NEED_SCROLL && !GDISP_HARDWARE_SCROLL
+	#error "GDISP: Hardware scrolling is wanted but not supported."
+#endif
 
-#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
+#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
 extern "C" {
 #endif
 
-#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC
+#if GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC || defined(__DOXYGEN__)
 	/* These routines can be hardware accelerated
 	 *	- Do not add a routine here unless it has also been added to the hardware acceleration layer
 	 */
 
 	/* 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);
+
+	/**
+	 * @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);
 
 	/* 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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
 
 	/* 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
 
 	/* Circle Functions */
-	#if GDISP_NEED_CIRCLE
-	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);
+
+	#if GDISP_NEED_CIRCLE || 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);
+
+		/**
+		 * @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
 	
 	/* Ellipse Functions */
-	#if GDISP_NEED_ELLIPSE
-	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);
+
+	#if GDISP_NEED_ELLIPSE || 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);
+
+		/**
+		 * @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
 
 	/* 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);
-	void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t startangle, coord_t endangle, color_t color);
+
+	#if GDISP_NEED_ARC || 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 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
 
 	/* Basic Text Rendering Functions */
-	#if GDISP_NEED_TEXT
-	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);
+
+	#if GDISP_NEED_TEXT || 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);
+
+		/**
+		 * @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
 	
 	/* 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
 
 	/* 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
 
 	/* 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
 
 	/* 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
+	/* 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 */
 	#define gdispInit(gdisp)									gdisp_lld_init()
@@ -229,30 +642,214 @@ extern "C" {
  */
 
 /* 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);
 
+#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 */
-#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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @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);
+
+	/**
+	 * @brief	Release a font after use.
+	 *
+	 * @param[in] font		The font to release.
+	 *
+	 * @api
+	 */
 	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);
 #endif
 
 /* 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);
+
+	/**
+	 * @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);
 #endif
 
 /* 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);
 #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)
 
 /* 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))
+
+/**
+ * @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))
+
+/**
+ * @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))
+
+/**
+ * @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 gdispGetWidth()							((coord_t)(unsigned)gdispQuery(GDISP_QUERY_WIDTH))
-#define gdispGetHeight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_HEIGHT))
-#define gdispGetPowerMode()						((gdisp_powermode_t)(unsigned)gdispQuery(GDISP_QUERY_POWER))
-#define gdispGetOrientation()					((gdisp_orientation_t)(unsigned)gdispQuery(GDISP_QUERY_ORIENTATION))
-#define gdispGetBacklight()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_BACKLIGHT))
-#define gdispGetContrast()						((coord_t)(unsigned)gdispQuery(GDISP_QUERY_CONTRAST))
+/**
+ * @brief   Get the display width in pixels.
+ *
+ * @api
+ */
+#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 */
+
+/**
+ * @brief   Reset the clip area to the full screen
+ *
+ * @api
+ */
 #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 */
 /** @} */
-
diff --git a/include/gdisp/lld/emulation.c b/include/gdisp/lld/emulation.c
index de9acf23..572b2dcb 100644
--- a/include/gdisp/lld/emulation.c
+++ b/include/gdisp/lld/emulation.c
@@ -34,22 +34,13 @@
 #ifndef GDISP_EMULATION_C
 #define GDISP_EMULATION_C
 
-#if GFX_USE_GDISP /*|| defined(__DOXYGEN__) */
-
-#ifndef GDISP_LLD_NO_STRUCT
-	static struct GDISPDriver {
-		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
-		} GDISP;
-#endif
+#if GFX_USE_GDISP
+
+/* Include the low level driver information */
+#include "gdisp/lld/gdisp_lld.h"
+
+/* Declare the GDISP structure */
+GDISPDriver	GDISP;
 
 #if !GDISP_HARDWARE_CLEARS 
 	void gdisp_lld_clear(color_t color) {
@@ -670,17 +661,10 @@
 	}
 #endif
 
-#if !GDISP_HARDWARE_QUERY
+#if GDISP_NEED_QUERY && !GDISP_HARDWARE_QUERY
 void *gdisp_lld_query(unsigned what) {
-	switch(what) {
-	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;
-	}
+	(void) what;
+	return (void *)-1;
 }
 #endif
 
@@ -759,9 +743,11 @@ void *gdisp_lld_query(unsigned what) {
 				gdisp_lld_control(msg->control.what, msg->control.value);
 				break;
 		#endif
+		#if GDISP_NEED_QUERY
 			case GDISP_LLD_MSG_QUERY:
 				msg->query.result = gdisp_lld_query(msg->query.what);
 				break;
+		#endif
 		}
 	}
 #endif
diff --git a/include/gdisp/lld/gdisp_lld.h b/include/gdisp/lld/gdisp_lld.h
index d33beb09..f42ad2af 100644
--- a/include/gdisp/lld/gdisp_lld.h
+++ b/include/gdisp/lld/gdisp_lld.h
@@ -32,73 +32,6 @@
 #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.                                                             */
 /*===========================================================================*/
 
@@ -321,140 +254,6 @@
 /** @} */
 
 /*===========================================================================*/
-/* 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.                                                    */
 /*===========================================================================*/
 
@@ -515,7 +314,9 @@ extern "C" {
 	#endif
 
 	/* Query driver specific data */
+	#if GDISP_NEED_QUERY
 	extern void *gdisp_lld_query(unsigned what);
+	#endif
 
 	/* Clipping Functions */
 	#if GDISP_NEED_CLIP
diff --git a/include/gdisp/options.h b/include/gdisp/options.h
index 6ce079ef..78e48a0a 100644
--- a/include/gdisp/options.h
+++ b/include/gdisp/options.h
@@ -1,236 +1,247 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012, 2013

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    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

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/**

- * @file    include/gdisp/options.h

- * @brief   GDISP sub-system options header file.

- *

- * @addtogroup GDISP

- * @{

- */

-

-#ifndef _GDISP_OPTIONS_H

-#define _GDISP_OPTIONS_H

-

-/**

- * @name    GDISP Functionality to be included

- * @{

- */

-	/**

-	 * @brief   Should all operations be clipped to the screen and colors validated.

-	 * @details	Defaults to TRUE.

-	 * @note    If this is FALSE, any operations that extend beyond the

-	 *          edge of the screen will have undefined results. Any

-	 *			out-of-range colors will produce undefined results.

-	 * @note	If defined then all low level and high level GDISP driver routines

-	 *			must check the validity of inputs and do something sensible

-	 *			if they are out of range. It doesn't have to be efficient,

-	 *			just valid.

-	 */

-	#ifndef GDISP_NEED_VALIDATION

-		#define GDISP_NEED_VALIDATION	TRUE

-	#endif

-	/**

-	 * @brief   Are clipping functions needed.

-	 * @details	Defaults to TRUE

-	 */

-	#ifndef GDISP_NEED_CLIP

-		#define GDISP_NEED_CLIP			TRUE

-	#endif

-	/**

-	 * @brief   Are text functions needed.

-	 * @details	Defaults to TRUE

-	 */

-	#ifndef GDISP_NEED_TEXT

-		#define GDISP_NEED_TEXT			TRUE

-	#endif

-	/**

-	 * @brief   Are circle functions needed.

-	 * @details	Defaults to TRUE

-	 */

-	#ifndef GDISP_NEED_CIRCLE

-		#define GDISP_NEED_CIRCLE		TRUE

-	#endif

-	/**

-	 * @brief   Are ellipse functions needed.

-	 * @details	Defaults to TRUE

-	 */

-	#ifndef GDISP_NEED_ELLIPSE

-		#define GDISP_NEED_ELLIPSE		TRUE

-	#endif

-	/**

-	 * @brief   Are arc functions needed.

-	 * @details	Defaults to FALSE

-	 * @note	Requires the maths library to be included in the link. ie  -lm

-	 */

-	#ifndef GDISP_NEED_ARC

-		#define GDISP_NEED_ARC			FALSE

-	#endif

-	/**

-	 * @brief   Are scrolling functions needed.

-	 * @details	Defaults to FALSE

-	 * @note	This function must be supported by the low level GDISP driver

-	 * 			you have included in your project. If it isn't, defining this

-	 * 			option will cause a compile error.

-	 */

-	#ifndef GDISP_NEED_SCROLL

-		#define GDISP_NEED_SCROLL		FALSE

-	#endif

-	/**

-	 * @brief   Is the capability to read pixels back needed.

-	 * @details	Defaults to FALSE

-	 * @note	This function must be supported by the low level GDISP driver

-	 * 			you have included in your project. If it isn't, defining this

-	 * 			option will cause a compile error.

-	 */

-	#ifndef GDISP_NEED_PIXELREAD

-		#define GDISP_NEED_PIXELREAD	FALSE

-	#endif

-	/**

-	 * @brief   Control some aspect of the hardware operation.

-	 * @details	Defaults to FALSE

-	 * @note	This allows control of hardware specific features such as

-	 * 			screen rotation, backlight levels, contrast etc

-	 */

-	#ifndef GDISP_NEED_CONTROL

-		#define GDISP_NEED_CONTROL		FALSE

-	#endif

-	/**

-	 * @brief   Is the messaging api interface required.

-	 * @details	Defaults to FALSE

-	 */

-	#ifndef GDISP_NEED_MSGAPI

-		#define GDISP_NEED_MSGAPI		FALSE

-	#endif

-/**

- * @}

- *

- * @name    GDISP Multi-Threading Options

- * @{

- */

-	/**

-	 * @brief   Do the drawing functions need to be thread-safe.

-	 * @details	Defaults to FALSE

-	 * @note	Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make

-	 * 			the gdisp API thread-safe.

-	 * @note	This is more efficient than GDISP_NEED_ASYNC as it only

-	 * 			requires a context switch if something else is already

-	 * 			drawing.

-	 */

-	#ifndef GDISP_NEED_MULTITHREAD

-		#define GDISP_NEED_MULTITHREAD	FALSE

-	#endif

-	/**

-	 * @brief   Use asynchronous calls (multi-thread safe).

-	 * @details	Defaults to FALSE

-	 * @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

-	 *			drawing operations to continue in the background.

-	 */

-	#ifndef GDISP_NEED_ASYNC

-		#define GDISP_NEED_ASYNC		FALSE

-	#endif

-/**

- * @}

- *

- * @name    GDISP Fonts

- * @{

- */

-	/**

-	 * @brief   Include the old global font variable definitions

-	 * @details	Defaults to FALSE

-	 */

-	#ifndef GDISP_OLD_FONT_DEFINITIONS

-		#define GDISP_OLD_FONT_DEFINITIONS		FALSE

-	#endif

-	/**

-	 * @brief   Predefined built in fonts

-	 * @note	Turning off the ones you are not using can save program size.

-	 */

-	#ifndef GDISP_INCLUDE_FONT_SMALL

-		#define GDISP_INCLUDE_FONT_SMALL		TRUE

-	#endif

-	#ifndef GDISP_INCLUDE_FONT_LARGER

-		#define GDISP_INCLUDE_FONT_LARGER		TRUE

-	#endif

-	#ifndef GDISP_INCLUDE_FONT_UI1

-		#define GDISP_INCLUDE_FONT_UI1			TRUE

-	#endif

-	#ifndef GDISP_INCLUDE_FONT_UI2

-		#define GDISP_INCLUDE_FONT_UI2			TRUE

-	#endif

-	#ifndef GDISP_INCLUDE_FONT_LARGENUMBERS

-		#define GDISP_INCLUDE_FONT_LARGENUMBERS	TRUE

-	#endif

-

-/**

- * @}

- *

- * @name    GDISP Optional Sizing Parameters

- * @{

- */

-	/**

-	 * @brief   The maximum height of a font.

-	 * @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.

-	 */

-	#ifndef GDISP_MAX_FONT_HEIGHT

-		#define GDISP_MAX_FONT_HEIGHT	16

-	#endif

-/**

- * @}

- *

- * @name    GDISP Optional Low Level Driver Defines

- * @{

- */

-	/**

-	 * @brief   Use a custom board definition even if a board definition exists.

-	 * @details	Defaults to FALSE

-	 * @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.

-	 */

-	#ifndef GDISP_USE_CUSTOM_BOARD

-		#define GDISP_USE_CUSTOM_BOARD		FALSE

-	#endif

-	/**

-	 * @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.

-	 * @note	The list of GDISP low level drivers that allow these to be set are...

-	 *				WIN32, SSD1289, SSD1963, TestStub

-	 */

-	/* #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 */

-/** @} */

-

+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    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
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    include/gdisp/options.h
+ * @brief   GDISP sub-system options header file.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#ifndef _GDISP_OPTIONS_H
+#define _GDISP_OPTIONS_H
+
+/**
+ * @name    GDISP Functionality to be included
+ * @{
+ */
+	/**
+	 * @brief   Should all operations be clipped to the screen and colors validated.
+	 * @details	Defaults to TRUE.
+	 * @note    If this is FALSE, any operations that extend beyond the
+	 *          edge of the screen will have undefined results. Any
+	 *			out-of-range colors will produce undefined results.
+	 * @note	If defined then all low level and high level GDISP driver routines
+	 *			must check the validity of inputs and do something sensible
+	 *			if they are out of range. It doesn't have to be efficient,
+	 *			just valid.
+	 */
+	#ifndef GDISP_NEED_VALIDATION
+		#define GDISP_NEED_VALIDATION	TRUE
+	#endif
+	/**
+	 * @brief   Are clipping functions needed.
+	 * @details	Defaults to TRUE
+	 */
+	#ifndef GDISP_NEED_CLIP
+		#define GDISP_NEED_CLIP			TRUE
+	#endif
+	/**
+	 * @brief   Are text functions needed.
+	 * @details	Defaults to TRUE
+	 */
+	#ifndef GDISP_NEED_TEXT
+		#define GDISP_NEED_TEXT			TRUE
+	#endif
+	/**
+	 * @brief   Are circle functions needed.
+	 * @details	Defaults to TRUE
+	 */
+	#ifndef GDISP_NEED_CIRCLE
+		#define GDISP_NEED_CIRCLE		TRUE
+	#endif
+	/**
+	 * @brief   Are ellipse functions needed.
+	 * @details	Defaults to TRUE
+	 */
+	#ifndef GDISP_NEED_ELLIPSE
+		#define GDISP_NEED_ELLIPSE		TRUE
+	#endif
+	/**
+	 * @brief   Are arc functions needed.
+	 * @details	Defaults to FALSE
+	 * @note	Requires the maths library to be included in the link. ie  -lm
+	 */
+	#ifndef GDISP_NEED_ARC
+		#define GDISP_NEED_ARC			FALSE
+	#endif
+	/**
+	 * @brief   Are convex polygon functions needed.
+	 * @details	Defaults to FALSE
+	 * @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.
+	 */
+	#ifndef GDISP_NEED_CONVEX_POLYGON
+		#define GDISP_NEED_CONVEX_POLYGON		FALSE
+	#endif
+	/**
+	 * @brief   Are scrolling functions needed.
+	 * @details	Defaults to FALSE
+	 * @note	This function must be supported by the low level GDISP driver
+	 * 			you have included in your project. If it isn't, defining this
+	 * 			option will cause a compile error.
+	 */
+	#ifndef GDISP_NEED_SCROLL
+		#define GDISP_NEED_SCROLL		FALSE
+	#endif
+	/**
+	 * @brief   Is the capability to read pixels back needed.
+	 * @details	Defaults to FALSE
+	 * @note	This function must be supported by the low level GDISP driver
+	 * 			you have included in your project. If it isn't, defining this
+	 * 			option will cause a compile error.
+	 */
+	#ifndef GDISP_NEED_PIXELREAD
+		#define GDISP_NEED_PIXELREAD	FALSE
+	#endif
+	/**
+	 * @brief   Control some aspect of the hardware operation.
+	 * @details	Defaults to FALSE
+	 * @note	This allows control of hardware specific features such as
+	 * 			screen rotation, backlight levels, contrast etc
+	 */
+	#ifndef GDISP_NEED_CONTROL
+		#define GDISP_NEED_CONTROL		FALSE
+	#endif
+	/**
+	 * @brief   Query some aspect of the hardware operation.
+	 * @details	Defaults to FALSE
+	 * @note	This allows query of hardware specific features
+	 */
+	#ifndef GDISP_NEED_QUERY
+		#define GDISP_NEED_QUERY		FALSE
+	#endif
+	/**
+	 * @brief   Is the messaging api interface required.
+	 * @details	Defaults to FALSE
+	 */
+	#ifndef GDISP_NEED_MSGAPI
+		#define GDISP_NEED_MSGAPI		FALSE
+	#endif
+/**
+ * @}
+ *
+ * @name    GDISP Multi-Threading Options
+ * @{
+ */
+	/**
+	 * @brief   Do the drawing functions need to be thread-safe.
+	 * @details	Defaults to FALSE
+	 * @note	Both GDISP_NEED_MULTITHREAD and GDISP_NEED_ASYNC make
+	 * 			the gdisp API thread-safe.
+	 * @note	This is more efficient than GDISP_NEED_ASYNC as it only
+	 * 			requires a context switch if something else is already
+	 * 			drawing.
+	 */
+	#ifndef GDISP_NEED_MULTITHREAD
+		#define GDISP_NEED_MULTITHREAD	FALSE
+	#endif
+	/**
+	 * @brief   Use asynchronous calls (multi-thread safe).
+	 * @details	Defaults to FALSE
+	 * @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
+	 *			drawing operations to continue in the background.
+	 */
+	#ifndef GDISP_NEED_ASYNC
+		#define GDISP_NEED_ASYNC		FALSE
+	#endif
+/**
+ * @}
+ *
+ * @name    GDISP Fonts
+ * @{
+ */
+	/**
+	 * @brief   Predefined built in fonts
+	 * @note	Turning off the ones you are not using can save program size.
+	 */
+	#ifndef GDISP_INCLUDE_FONT_SMALL
+		#define GDISP_INCLUDE_FONT_SMALL		TRUE
+	#endif
+	#ifndef GDISP_INCLUDE_FONT_LARGER
+		#define GDISP_INCLUDE_FONT_LARGER		TRUE
+	#endif
+	#ifndef GDISP_INCLUDE_FONT_UI1
+		#define GDISP_INCLUDE_FONT_UI1			TRUE
+	#endif
+	#ifndef GDISP_INCLUDE_FONT_UI2
+		#define GDISP_INCLUDE_FONT_UI2			TRUE
+	#endif
+	#ifndef GDISP_INCLUDE_FONT_LARGENUMBERS
+		#define GDISP_INCLUDE_FONT_LARGENUMBERS	TRUE
+	#endif
+
+/**
+ * @}
+ *
+ * @name    GDISP Optional Sizing Parameters
+ * @{
+ */
+	/**
+	 * @brief   The maximum height of a font.
+	 * @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.
+	 */
+	#ifndef GDISP_MAX_FONT_HEIGHT
+		#define GDISP_MAX_FONT_HEIGHT	16
+	#endif
+/**
+ * @}
+ *
+ * @name    GDISP Optional Low Level Driver Defines
+ * @{
+ */
+	/**
+	 * @brief   Use a custom board definition even if a board definition exists.
+	 * @details	Defaults to FALSE
+	 * @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.
+	 */
+	#ifndef GDISP_USE_CUSTOM_BOARD
+		#define GDISP_USE_CUSTOM_BOARD		FALSE
+	#endif
+	/**
+	 * @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.
+	 * @note	The list of GDISP low level drivers that allow these to be set are...
+	 *				WIN32, SSD1289, SSD1963, TestStub
+	 */
+	/* #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 */
+/** @} */
+
diff --git a/include/gwin/button.h b/include/gwin/button.h
index 479f8628..36b05d83 100644
--- a/include/gwin/button.h
+++ b/include/gwin/button.h
@@ -1,194 +1,252 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012, 2013

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    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

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-/**

- * @file    include/gwin/button.h

- * @brief   GWIN Graphic window subsystem header file.

- *

- * @defgroup Button Button

- * @ingroup GWIN

- *

- * @details		GWIN allows it to easily create buttons with different styles

- *				and check for different meta states such as: PRESSED, CLICKED,

- *				RELEASED etc.

- *

- * @pre			GFX_USE_GWIN must be set to TRUE in your gfxconf.h

- * @pre			GWIN_NEED_BUTTON must be set to TRUE in your gfxconf.h

- * @{

- */

-

-#ifndef _GWIN_BUTTON_H

-#define _GWIN_BUTTON_H

-

-#if GWIN_NEED_BUTTON || defined(__DOXYGEN__)

-

-/*===========================================================================*/

-/* Driver constants.														 */

-/*===========================================================================*/

-

-#define GW_BUTTON				0x0002

-#define GEVENT_GWIN_BUTTON		(GEVENT_GWIN_FIRST+0)

-

-/*===========================================================================*/

-/* Type definitions                                                          */

-/*===========================================================================*/

-

-typedef struct GEventGWinButton_t {

-	GEventType		type;				// The type of this event (GEVENT_GWIN_BUTTON)

-	GHandle			button;				// The button that has been depressed (actually triggered on release)

-} GEventGWinButton;

-

-// There are currently no GEventGWinButton listening flags - use 0

-

-typedef enum GButtonShape_e {

-	GBTN_3D, GBTN_SQUARE, GBTN_ROUNDED, GBTN_ELLIPSE

-} GButtonShape;

-

-typedef struct GButtonStyle_t {

-	GButtonShape		shape;

-	color_t				color_up_edge;

-	color_t				color_up_fill;

-	color_t				color_up_txt;

-	color_t				color_dn_edge;

-	color_t				color_dn_fill;

-	color_t				color_dn_txt;

-} GButtonStyle;

-

-typedef enum GButtonType_e {

-	GBTN_NORMAL, GBTN_TOGGLE

-} GButtonType;

-

-typedef enum GButtonState_e {

-	GBTN_UP, GBTN_DOWN

-} GButtonState;

-

-// A button window

-typedef struct GButtonObject_t {

-	GWindowObject		gwin;

-

-	GButtonStyle		style;

-	GButtonState		state;

-	GButtonType			type;

-	const char *		txt;

-	GListener			listener;

-} GButtonObject;

-

-/*===========================================================================*/

-/* External declarations.                                                    */

-/*===========================================================================*/

-

-#ifdef __cplusplus

-extern "C" {

-#endif

-

-/**

- * @brief   Create a button window.

- * @return  NULL if there is no resultant drawing area, otherwise a window handle.

- *

- * @param[in] gb		The GButtonObject structure to initialise. If this is NULL the structure is dynamically allocated.

- * @param[in] x,y		The screen co-ordinates for the bottom left corner of the window

- * @param[in] width		The width of the window

- * @param[in] height	The height of the window

- * @param[in] font		The font to use

- * @param[in] type		The type of button

- * @note				The drawing color gets set to White and the background drawing color to Black.

- * @note				The dimensions and position may be changed to fit on the real screen.

- * @note				The button is not automatically drawn. Call gwinButtonDraw() after changing the button style or setting the text.

- *

- * @api

- */	

-GHandle gwinCreateButton(GButtonObject *gb, coord_t x, coord_t y, coord_t width, coord_t height, font_t font, GButtonType type);

-

-/**

- * @brief   Set the style of a button.

- * @details	The button style is defined by its shape and colours.

- *

- * @param[in] gh		The window handle (must be a button window)

- * @param[in] style		The button style to set.

- * @note				The button is not automatically redrawn. Call gwinButtonDraw() after changing the button style

- *

- * @api

- */

-void gwinSetButtonStyle(GHandle gh, const GButtonStyle *style);

-

-/**

- * @brief   Set the text of a button.

- *

- * @param[in] gh		The window handle (must be a button window)

- * @param[in] txt		The button text to set. This must be a constant string unless useAlloc is set.

- * @param[in] useAlloc	If TRUE the string specified will be copied into dynamically allocated memory.

- * @note				The button is not automatically redrawn. Call gwinButtonDraw() after changing the button text.

- *

- * @api

- */

-void gwinSetButtonText(GHandle gh, const char *txt, bool_t useAlloc);

-

-/**

- * @brief   Redraw the button.

- *

- * @param[in] gh		The window handle (must be a button window)

- *

- * @api

- */

-void gwinButtonDraw(GHandle gh);

-

-#define gwinGetButtonState(gh)		(((GButtonObject *)(gh))->state)

-

-/**

- * @brief Get the source handle of a button

- * @details Get the source handle of a button so the application can listen for events

- *

- * @param[in] gh	The Hanlde

- */

-#define gwinGetButtonSource(gh)		((GSourceHandle)(gh))

-

-#if defined(GINPUT_NEED_MOUSE) && GINPUT_NEED_MOUSE

-	/**

-	 * @brief	Attach a mouse source

-	 * @details	Attach a mouse source to a given button

-	 *

-	 * @param[in] gh	The button handle

-	 * @param[in] gsh	The source handle

-	 *

-	 * @return

-	 */

-	bool_t gwinAttachButtonMouseSource(GHandle gh, GSourceHandle gsh);

-#endif

-

-#if defined(GINPUT_NEED_TOGGLE) && GINPUT_NEED_TOGGLE

-	/**

-	 * @brief	Attach a toggle source

-	 * @details	Attach a toggle source to this button

-	 *

-	 * @gh		The button handle

-	 * @gsh		The source handle

-	 *

-	 * @return

-	 */

-	bool_t gwinAttachButtonToggleSource(GHandle gh, GSourceHandle gsh);

-#endif

-

-#ifdef __cplusplus

-}

-#endif

-

-#endif /* GWIN_NEED_BUTTON */

-

-#endif /* _GWIN_BUTTON_H */

-/** @} */

+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    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
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+/**
+ * @file    include/gwin/button.h
+ * @brief   GWIN Graphic window subsystem header file.
+ *
+ * @defgroup Button Button
+ * @ingroup GWIN
+ *
+ * @details		GWIN allows it to easily create buttons with different styles
+ *				and check for different meta states such as: PRESSED, CLICKED,
+ *				RELEASED etc.
+ *
+ * @pre			GFX_USE_GWIN must be set to TRUE in your gfxconf.h
+ * @pre			GWIN_NEED_BUTTON must be set to TRUE in your gfxconf.h
+ * @{
+ */
+
+#ifndef _GWIN_BUTTON_H
+#define _GWIN_BUTTON_H
+
+#if GWIN_NEED_BUTTON || defined(__DOXYGEN__)
+
+/*===========================================================================*/
+/* Driver constants.														 */
+/*===========================================================================*/
+
+#define GW_BUTTON				0x0002
+#define GEVENT_GWIN_BUTTON		(GEVENT_GWIN_FIRST+0)
+
+/*===========================================================================*/
+/* Type definitions                                                          */
+/*===========================================================================*/
+
+typedef struct GEventGWinButton_t {
+	GEventType		type;				// The type of this event (GEVENT_GWIN_BUTTON)
+	GHandle			button;				// The button that has been depressed (actually triggered on release)
+} GEventGWinButton;
+
+// There are currently no GEventGWinButton listening flags - use 0
+
+typedef enum GButtonShape_e {
+	GBTN_3D, GBTN_SQUARE, GBTN_ROUNDED, GBTN_ELLIPSE, GBTN_CUSTOM,
+	GBTN_ARROW_UP, GBTN_ARROW_DOWN, GBTN_ARROW_LEFT, GBTN_ARROW_RIGHT,
+} GButtonShape;
+
+typedef struct GButtonDrawStyle_t {
+	color_t				color_edge;
+	color_t				color_fill;
+	color_t				color_txt;
+} GButtonDrawStyle;
+
+typedef enum GButtonType_e {
+	GBTN_NORMAL, GBTN_TOGGLE
+} GButtonType;
+
+typedef enum GButtonState_e {
+	GBTN_UP, GBTN_DOWN
+} GButtonState;
+
+typedef void (*GButtonDrawFunction)(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param);
+
+// A button window
+typedef struct GButtonObject_t {
+	GWindowObject		gwin;
+
+	GButtonDrawStyle	up;
+	GButtonDrawStyle	dn;
+	GButtonState		state;
+	GButtonType			type;
+	const char			*txt;
+	GButtonDrawFunction	fn;
+	void				*param;
+	GListener			listener;
+} GButtonObject;
+
+/*===========================================================================*/
+/* External declarations.                                                    */
+/*===========================================================================*/
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @brief   Create a button window.
+ * @return  NULL if there is no resultant drawing area, otherwise a window handle.
+ *
+ * @param[in] gb		The GButtonObject structure to initialise. If this is NULL the structure is dynamically allocated.
+ * @param[in] x,y		The screen co-ordinates for the bottom left corner of the window
+ * @param[in] width		The width of the window
+ * @param[in] height	The height of the window
+ * @param[in] font		The font to use
+ * @param[in] type		The type of button
+ * @note				The drawing color gets set to White and the background drawing color to Black.
+ * @note				The dimensions and position may be changed to fit on the real screen.
+ * @note				The button is not automatically drawn. Call gwinButtonDraw() after changing the button style or setting the text.
+ *
+ * @api
+ */	
+GHandle gwinCreateButton(GButtonObject *gb, coord_t x, coord_t y, coord_t width, coord_t height, font_t font, GButtonType type);
+
+/**
+ * @brief   Set the style of a button.
+ * @details	The button style is defined by its shape and colours.
+ *
+ * @param[in] gh		The window handle (must be a button window)
+ * @param[in] shape		The shape of the button.
+ * @param[in] pUp		The styling for the button when in the up state.
+ * @param[in] pDown		The styling for the button when in the down state.
+ *
+ * @note				The button is not automatically redrawn. Call gwinButtonDraw() after changing the button style
+ * @note				The button style is copied into the internal button structure - there is no need to
+ * 						maintain a static style structures.
+ * @note				The pUp and pDown parameters can be NULL. If they are then the existing color styles
+ * 						are not changed for that button state.
+ *
+ * @api
+ */
+void gwinSetButtonStyle(GHandle gh, GButtonShape shape, const GButtonDrawStyle *pUp, const GButtonDrawStyle *pDown);
+
+/**
+ * @brief   Set the text of a button.
+ *
+ * @param[in] gh		The window handle (must be a button window)
+ * @param[in] txt		The button text to set. This must be a constant string unless useAlloc is set.
+ * @param[in] useAlloc	If TRUE the string specified will be copied into dynamically allocated memory.
+ * @note				The button is not automatically redrawn. Call gwinButtonDraw() after changing the button text.
+ *
+ * @api
+ */
+void gwinSetButtonText(GHandle gh, const char *txt, bool_t useAlloc);
+
+/**
+ * @brief   Redraw the button.
+ *
+ * @param[in] gh		The window handle (must be a button window)
+ *
+ * @api
+ */
+void gwinButtonDraw(GHandle gh);
+
+/**
+ * @brief   Set the callback routine to perform a custom button drawing.
+ *
+ * @param[in] gh		The window handle (must be a button window)
+ * @param[in] fn		The function to use to draw the button
+ * @param[in] param		A parameter to pass to the button drawing function
+ *
+ * @api
+ */
+void gwinSetButtonCustom(GHandle gh, GButtonDrawFunction fn, void *param);
+
+#define gwinGetButtonState(gh)		(((GButtonObject *)(gh))->state)
+
+/**
+ * @brief Get the source handle of a button
+ * @details Get the source handle of a button so the application can listen for events
+ *
+ * @param[in] gh	The window handle
+ *
+ * @api
+ */
+#define gwinGetButtonSource(gh)		((GSourceHandle)(gh))
+
+#if defined(GINPUT_NEED_MOUSE) && GINPUT_NEED_MOUSE
+	/**
+	 * @brief	Attach a mouse source
+	 * @details	Attach a mouse source to a given button
+	 *
+	 * @param[in] gh	The button handle
+	 * @param[in] gsh	The source handle
+	 *
+	 * @api
+	 */
+	bool_t gwinAttachButtonMouseSource(GHandle gh, GSourceHandle gsh);
+#endif
+
+#if defined(GINPUT_NEED_TOGGLE) && GINPUT_NEED_TOGGLE
+	/**
+	 * @brief	Attach a toggle source
+	 * @details	Attach a toggle source to this button
+	 *
+	 * @param[in] gh	The button handle
+	 * @param[in] gsh	The source handle
+	 *
+	 * @api
+	 */
+	bool_t gwinAttachButtonToggleSource(GHandle gh, GSourceHandle gsh);
+#endif
+
+/**
+ * @brief	Standard button drawing routines
+ * @details	These routines are called to draw the standard button styles.
+ *
+ * @param[in] gh		The button handle
+ * @param[in] isdown	Is the button currently down (depressed)
+ * @param[in] pstyle	The current drawing style for the state we are in
+ * @param[in] param		A parameter passed in from the user
+ *
+ * @note				In your custom button drawing function you may optionally call these
+ * 						standard functions and then draw your extra details on top.
+ * @note				The standard functions below ignore the param parameter. It is there
+ * 						only to ensure the functions match the GButtonDrawFunction type.
+ * @note				When called by a button press/release the framework ensure that it is
+ * 						a button object and sets up clipping to the button object window. These
+ * 						drawing routines then don't have to worry about explicitly doing that.
+ *
+ * @api
+ * @{
+ */
+void gwinButtonDraw_3D(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param);
+void gwinButtonDraw_Square(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param);
+#if GDISP_NEED_ARC || defined(__DOXYGEN__)
+	void gwinButtonDraw_Rounded(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param);
+#endif
+#if GDISP_NEED_ELLIPSE || defined(__DOXYGEN__)
+	void gwinButtonDraw_Ellipse(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param);
+#endif
+#if GDISP_NEED_CONVEX_POLYGON || defined(__DOXYGEN__)
+	void gwinButtonDraw_ArrowUp(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param);
+	void gwinButtonDraw_ArrowDown(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param);
+	void gwinButtonDraw_ArrowLeft(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param);
+	void gwinButtonDraw_ArrowRight(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param);
+#endif
+/** @} */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* GWIN_NEED_BUTTON */
+
+#endif /* _GWIN_BUTTON_H */
+/** @} */
diff --git a/releases.txt b/releases.txt
index c99d2b41..0097caac 100644
--- a/releases.txt
+++ b/releases.txt
@@ -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
 FEATURE:	Supporting all standard functions in GDISP Nokia6610GE8 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 ***
diff --git a/src/gdisp/fonts.c b/src/gdisp/fonts.c
index d69d6de0..a7c6d39a 100644
--- a/src/gdisp/fonts.c
+++ b/src/gdisp/fonts.c
@@ -1,780 +1,748 @@
-/*

-    ChibiOS/GFX - Copyright (C) 2012, 2013

-                 Joel Bodenmann aka Tectu <joel@unormal.org>

-

-    This file is part of ChibiOS/GFX.

-

-    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

-    the Free Software Foundation; either version 3 of the License, or

-    (at your option) any later version.

-

-    ChibiOS/GFX is distributed in the hope that it will be useful,

-    but WITHOUT ANY WARRANTY; without even the implied warranty of

-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

-    GNU General Public License for more details.

-

-    You should have received a copy of the GNU General Public License

-    along with this program.  If not, see <http://www.gnu.org/licenses/>.

-*/

-

-/**

- * @file    src/gdisp/fonts.c

- * @brief   GDISP Font Handling.

- *

- * @addtogroup GDISP

- * @{

- */

-

-#include "ch.h"

-#include "hal.h"

-#include "gfx.h"

-

-#if (GFX_USE_GDISP && GDISP_NEED_TEXT) || defined(__DOXYGEN__)

-

-#include "gdisp/fonts.h"

-

-#if GDISP_OLD_FONT_DEFINITIONS

-	#define FONT_DECL

-#else

-	#define FONT_DECL static

-#endif

-

-/* fontSmall - for side buttons */

-#if GDISP_INCLUDE_FONT_SMALL

-    /* Forward Declarations of internal arrays */

-    static const uint8_t        fontSmall_Widths[];

-    static const uint16_t       fontSmall_Offsets[];

-    static const fontcolumn_t   fontSmall_Data[];

-

-    FONT_DECL const struct font fontSmall = {

-									"Small",

-									11, 0, 14, 2, 2, 12, ' ', '~', 1, 1,

-									fontSmall_Widths,

-									fontSmall_Offsets,

-									fontSmall_Data};

-    FONT_DECL const struct font fontSmallDouble = {

-									"Small Double",

-									11, 0, 14, 2, 2, 12, ' ', '~', 2, 2,

-									fontSmall_Widths,

-									fontSmall_Offsets,

-									fontSmall_Data};

-    FONT_DECL const struct font fontSmallNarrow = {

-									"Small Narrow",

-									11, 0, 14, 2, 2, 12, ' ', '~', 1, 2,

-									fontSmall_Widths,

-									fontSmall_Offsets,

-									fontSmall_Data};

-

-	static const uint8_t fontSmall_Widths[] = {

-		2, 3, 6, 8, 7, 9, 7, 3, 4, 4, 5, 7, 4, 4, 3, 6,

-		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 4, 6, 7, 6, 7,

-		12, 8, 7, 8, 8, 7, 7, 8, 8, 3, 5, 8, 7, 9, 8, 8,

-		8, 8, 8, 7, 7, 8, 8, 12, 8, 8, 8, 4, 6, 4, 7, 7,

-		4, 7, 7, 7, 7, 7, 4, 7, 7, 3, 3, 7, 3, 9, 7, 7,

-		7, 7, 4, 6, 4, 7, 7, 9, 6, 6, 6, 5, 3, 5, 8, 0

-	};

-	static const uint16_t fontSmall_Offsets[] = {

-		0, 2, 5, 11, 19, 26, 35, 42,

-		45, 49, 53, 58, 65, 69, 73, 76,

-		82, 89, 96, 103, 110, 117, 124, 131,

-		138, 145, 152, 155, 159, 165, 172, 178,

-		185, 197, 205, 212, 220, 228, 235, 242,

-		250, 258, 261, 266, 274, 281, 290, 298,

-		306, 314, 322, 330, 337, 344, 352, 360,

-		372, 380, 388, 396, 400, 406, 410, 417,

-		424, 428, 435, 442, 449, 456, 463, 467,

-		474, 481, 484, 487, 494, 497, 506, 513,

-		520, 527, 534, 538, 544, 548, 555, 562,

-		571, 577, 583, 589, 594, 597, 602, 0

-	};

-	static const fontcolumn_t fontSmall_Data[] = {

-		/*   */	0x0000, 0x0000,

-		/* ! */	0x0000, 0x017F, 0x017F,

-		/* " */	0x0000, 0x0007, 0x0007, 0x0000, 0x0007, 0x0007,

-		/* # */	0x0000, 0x0044, 0x01FF, 0x01FF, 0x0044, 0x01FF, 0x01FF, 0x0044,

-		/* $ */	0x0000, 0x008C, 0x019E, 0x03FF, 0x03FF, 0x01E6, 0x00C4,

-		/* % */	0x0000, 0x0082, 0x00C7, 0x0065, 0x00B7, 0x01DA, 0x014C, 0x01C6, 0x0082,

-		/* & */	0x0000, 0x00E6, 0x01FF, 0x013F, 0x01E6, 0x01E0, 0x0120,

-		/* ' */	0x0000, 0x0007, 0x0007,

-		/* ( */	0x0000, 0x03FE, 0x07FF, 0x0401,

-		/* ) */	0x0000, 0x0401, 0x07FF, 0x03FE,

-		/* * */	0x0000, 0x000A, 0x000E, 0x000E, 0x000A,

-		/* + */	0x0000, 0x0020, 0x0020, 0x00F8, 0x00F8, 0x0020, 0x0020,

-		/* , */	0x0000, 0x0200, 0x0300, 0x0100,

-		/* - */	0x0000, 0x0020, 0x0020, 0x0020,

-		/* . */	0x0000, 0x0100, 0x0100,

-		/* / */	0x0000, 0x0180, 0x01E0, 0x0078, 0x001F, 0x0007,

-		/* 0 */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x01FF, 0x00FE,

-		/* 1 */	0x0000, 0x0002, 0x0002, 0x01FF, 0x01FF, 0x0000, 0x0000,

-		/* 2 */	0x0000, 0x0182, 0x01C3, 0x0161, 0x0131, 0x011F, 0x010E,

-		/* 3 */	0x0000, 0x0082, 0x0183, 0x0111, 0x0111, 0x01FF, 0x00EE,

-		/* 4 */	0x0000, 0x0060, 0x0078, 0x005E, 0x01FF, 0x01FF, 0x0040,

-		/* 5 */	0x0000, 0x009F, 0x019F, 0x0109, 0x0109, 0x01F9, 0x00F1,

-		/* 6 */	0x0000, 0x00FE, 0x01FF, 0x0111, 0x0111, 0x01F3, 0x00E2,

-		/* 7 */	0x0000, 0x0001, 0x01C1, 0x01F1, 0x003D, 0x000F, 0x0003,

-		/* 8 */	0x0000, 0x00EE, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE,

-		/* 9 */	0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01FF, 0x00FE,

-		/* : */	0x0000, 0x0108, 0x0108,

-		/* ; */	0x0000, 0x0200, 0x0308, 0x0108,

-		/* < */	0x0000, 0x0020, 0x0070, 0x00D8, 0x018C, 0x0104,

-		/* = */	0x0000, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050,

-		/* > */	0x0000, 0x0104, 0x018C, 0x00D8, 0x0070, 0x0020,

-		/* ? */	0x0000, 0x0002, 0x0003, 0x0161, 0x0171, 0x001F, 0x000E,

-		/* @ */	0x0000, 0x0078, 0x01FE, 0x0186, 0x0333, 0x0279, 0x0249, 0x0279, 0x027B, 0x0246, 0x007E, 0x0078,

-		/* A */	0x0180, 0x01F0, 0x007C, 0x004F, 0x004F, 0x007C, 0x01F0, 0x0180,

-		/* B */	0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE,

-		/* C */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x0183, 0x0082,

-		/* D */	0x0000, 0x01FF, 0x01FF, 0x0101, 0x0101, 0x0183, 0x00FE, 0x007C,

-		/* E */	0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x0111, 0x0101,

-		/* F */	0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x0001,

-		/* G */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0111, 0x0191, 0x01F3, 0x01F2,

-		/* H */	0x0000, 0x01FF, 0x01FF, 0x0010, 0x0010, 0x0010, 0x01FF, 0x01FF,

-		/* I */	0x0000, 0x01FF, 0x01FF,

-		/* J */	0x00C0, 0x01C0, 0x0100, 0x01FF, 0x00FF,

-		/* K */	0x0000, 0x01FF, 0x01FF, 0x003C, 0x0066, 0x00C3, 0x0181, 0x0100,

-		/* L */	0x0000, 0x01FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x0100,

-		/* M */	0x0000, 0x01FF, 0x01FF, 0x003C, 0x00F0, 0x00F0, 0x003C, 0x01FF, 0x01FF,

-		/* N */	0x0000, 0x01FF, 0x01FF, 0x001E, 0x0038, 0x00E0, 0x01FF, 0x01FF,

-		/* O */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x01FF, 0x00FE,

-		/* P */	0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x001F, 0x000E,

-		/* Q */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0141, 0x01C1, 0x03FF, 0x02FE,

-		/* R */	0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x01FF, 0x01EE,

-		/* S */	0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01F3, 0x00E2,

-		/* T */	0x0000, 0x0001, 0x0001, 0x01FF, 0x01FF, 0x0001, 0x0001,

-		/* U */	0x0000, 0x00FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x01FF, 0x00FF,

-		/* V */	0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x001F, 0x0003,

-		/* W */	0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x001F, 0x0003,

-		/* X */	0x0183, 0x01C7, 0x006C, 0x0038, 0x0038, 0x006C, 0x01C7, 0x0183,

-		/* Y */	0x0003, 0x0007, 0x000C, 0x01F8, 0x01F8, 0x000C, 0x0007, 0x0003,

-		/* Z */	0x0181, 0x01C1, 0x0161, 0x0131, 0x0119, 0x010D, 0x0107, 0x0103,

-		/* [ */	0x0000, 0x07FF, 0x07FF, 0x0401,

-		/* \ */	0x0000, 0x0007, 0x001F, 0x0078, 0x01E0, 0x0180,

-		/* ] */	0x0000, 0x0401, 0x07FF, 0x07FF,

-		/* ^ */	0x0000, 0x0002, 0x0003, 0x0001, 0x0001, 0x0003, 0x0002,

-		/* _ */	0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,

-		/* ` */	0x0000, 0x0001, 0x0003, 0x0002,

-		/* a */	0x0000, 0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0,

-		/* b */	0x0000, 0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0,

-		/* c */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x0198, 0x0090,

-		/* d */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF,

-		/* e */	0x0000, 0x00F0, 0x01F8, 0x0128, 0x0128, 0x01B8, 0x00B0,

-		/* f */	0x0000, 0x01FE, 0x01FF, 0x0009,

-		/* g */	0x0000, 0x04F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8,

-		/* h */	0x0000, 0x01FF, 0x01FF, 0x0018, 0x0008, 0x01F8, 0x01F0,

-		/* i */	0x0000, 0x01F9, 0x01F9,

-		/* j */	0x0000, 0x07F9, 0x07F9,

-		/* k */	0x0000, 0x01FF, 0x01FF, 0x0070, 0x00D8, 0x0188, 0x0100,

-		/* l */	0x0000, 0x01FF, 0x01FF,

-		/* m */	0x0000, 0x01F8, 0x01F8, 0x0008, 0x01F8, 0x01F8, 0x0008, 0x01F8, 0x01F0,

-		/* n */	0x0000, 0x01F8, 0x01F8, 0x0018, 0x0008, 0x01F8, 0x01F0,

-		/* o */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0,

-		/* p */	0x0000, 0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0,

-		/* q */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8,

-		/* r */	0x0000, 0x01F8, 0x01F8, 0x0008,

-		/* s */	0x0000, 0x0090, 0x01B8, 0x0168, 0x01D8, 0x0090,

-		/* t */	0x0000, 0x00FE, 0x01FE, 0x0108,

-		/* u */	0x0000, 0x00F8, 0x01F8, 0x0100, 0x0180, 0x01F8, 0x01F8,

-		/* v */	0x0000, 0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018,

-		/* w */	0x0000, 0x0078, 0x01F8, 0x01E0, 0x0078, 0x0078, 0x01E0, 0x01F8, 0x0078,

-		/* x */	0x0000, 0x0198, 0x01F8, 0x0060, 0x01F8, 0x0198,

-		/* y */	0x0400, 0x0478, 0x07F8, 0x0380, 0x00F8, 0x0078,

-		/* z */	0x0000, 0x0188, 0x01C8, 0x0168, 0x0138, 0x0118,

-		/* { */	0x0000, 0x0010, 0x01FF, 0x03EF, 0x0200,

-		/* | */	0x0000, 0x03FF, 0x03FF,

-		/* } */	0x0000, 0x0200, 0x03EF, 0x01FF, 0x0010,

-		/* ~ */	0x0000, 0x0004, 0x0006, 0x0002, 0x0006, 0x0004, 0x0006, 0x0002

-	};

-#endif

-

-/* fontLarger - Tahoma, 11, Bold */

-#if GDISP_INCLUDE_FONT_LARGER

-    /* Forward Declarations of internal arrays */

-    static const uint8_t        fontLarger_Widths[];

-    static const uint16_t       fontLarger_Offsets[];

-    static const fontcolumn_t   fontLarger_Data[];

-

-    FONT_DECL const struct font fontLarger = {

-									"Larger",

-									12, 1, 13, 2, 2, 13, ' ', '~', 1, 1,

-									fontLarger_Widths,

-									fontLarger_Offsets,

-									fontLarger_Data};

-    FONT_DECL const struct font fontLargerDouble = {

-									"Larger Double",

-									12, 1, 13, 2, 2, 13, ' ', '~', 2, 2,

-									fontLarger_Widths,

-									fontLarger_Offsets,

-									fontLarger_Data};

-    FONT_DECL const struct font fontLargerNarrow = {

-									"Larger Narrow",

-									12, 1, 13, 2, 2, 13, ' ', '~', 1, 2,

-									fontLarger_Widths,

-									fontLarger_Offsets,

-									fontLarger_Data};

-	static const uint8_t fontLarger_Widths[] = {

-		2, 3, 5, 8, 7, 13, 8, 2, 4, 4, 7, 8, 3, 4, 3, 5,

-		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 9, 8, 9, 6,

-		9, 8, 7, 7, 8, 6, 5, 7, 8, 4, 5, 7, 6, 10, 7, 8,

-		7, 8, 8, 7, 6, 7, 7, 11, 7, 6, 6, 4, 5, 4, 9, 8,

-		5, 6, 7, 5, 7, 6, 5, 7, 7, 2, 3, 6, 2, 10, 7, 7,

-		7, 7, 4, 5, 5, 7, 6, 10, 6, 6, 5, 6, 4, 6, 9, 0

-	};

-	static const uint16_t fontLarger_Offsets[] = {

-		0, 2, 5, 10, 18, 25, 38, 46,

-		48, 52, 56, 63, 71, 74, 78, 81,

-		86, 93, 100, 107, 114, 121, 128, 135,

-		142, 149, 156, 159, 162, 171, 179, 188,

-		194, 203, 211, 218, 225, 233, 239, 244,

-		251, 259, 263, 268, 275, 281, 291, 298,

-		306, 313, 321, 329, 336, 342, 349, 356,

-		367, 374, 380, 386, 390, 395, 399, 408,

-		416, 421, 427, 434, 439, 446, 452, 457,

-		464, 471, 473, 476, 482, 484, 494, 501,

-		508, 515, 522, 526, 531, 536, 543, 549,

-		559, 565, 571, 576, 582, 586, 592, 0

-	};

-	static const fontcolumn_t fontLarger_Data[] = {

-		/*   */	0x0000, 0x0000,

-		/* ! */	0x0000, 0x037E, 0x037E,

-		/* " */	0x0007, 0x0007, 0x0000, 0x0007, 0x0007,

-		/* # */	0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018,

-		/* $ */	0x0118, 0x023C, 0x0264, 0x0FFF, 0x0264, 0x03C4, 0x0188,

-		/* % */	0x001C, 0x003E, 0x0022, 0x023E, 0x011C, 0x00C0, 0x0020, 0x0018, 0x01C4, 0x03E2, 0x0220, 0x03E0,

-				0x01C0,

-		/* & */	0x01CC, 0x03FE, 0x0232, 0x0272, 0x03DE, 0x018C, 0x03E0, 0x0260,

-		/* ' */	0x0007, 0x0007,

-		/* ( */	0x01F8, 0x07FE, 0x0E07, 0x0801,

-		/* ) */	0x0801, 0x0E07, 0x07FE, 0x01F8,

-		/* * */	0x0000, 0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A,

-		/* + */	0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020,

-		/* , */	0x0000, 0x0F00, 0x0700,

-		/* - */	0x0020, 0x0020, 0x0020, 0x0020,

-		/* . */	0x0000, 0x0300, 0x0300,

-		/* / */	0x0C00, 0x0380, 0x0060, 0x001C, 0x0003,

-		/* 0 */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC,

-		/* 1 */	0x0000, 0x0204, 0x0204, 0x03FE, 0x03FE, 0x0200, 0x0200,

-		/* 2 */	0x0204, 0x0302, 0x0382, 0x02C2, 0x0262, 0x023E, 0x021C,

-		/* 3 */	0x0104, 0x0202, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,

-		/* 4 */	0x0060, 0x0050, 0x0048, 0x0044, 0x03FE, 0x03FE, 0x0040,

-		/* 5 */	0x0100, 0x021E, 0x021E, 0x0212, 0x0212, 0x03F2, 0x01E2,

-		/* 6 */	0x01F8, 0x03FC, 0x0216, 0x0212, 0x0212, 0x03F2, 0x01E0,

-		/* 7 */	0x0002, 0x0002, 0x0382, 0x03E2, 0x007A, 0x001E, 0x0006,

-		/* 8 */	0x01DC, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,

-		/* 9 */	0x003C, 0x027E, 0x0242, 0x0242, 0x0342, 0x01FE, 0x00FC,

-		/* : */	0x0000, 0x0318, 0x0318,

-		/* ; */	0x0000, 0x0F18, 0x0718,

-		/* < */	0x0000, 0x0060, 0x0060, 0x0090, 0x0090, 0x0108, 0x0108, 0x0204, 0x0204,

-		/* = */	0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090,

-		/* > */	0x0000, 0x0204, 0x0204, 0x0108, 0x0108, 0x0090, 0x0090, 0x0060, 0x0060,

-		/* ? */	0x0004, 0x0002, 0x0362, 0x0372, 0x001E, 0x000C,

-		/* @ */	0x01F8, 0x0204, 0x04F2, 0x05FA, 0x050A, 0x04FA, 0x05FA, 0x0104, 0x00F8,

-		/* A */	0x0380, 0x03F0, 0x00FC, 0x008E, 0x008E, 0x00FC, 0x03F0, 0x0380,

-		/* B */	0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,

-		/* C */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x018C,

-		/* D */	0x03FE, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0306, 0x01FC, 0x00F8,

-		/* E */	0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x0222,

-		/* F */	0x03FE, 0x03FE, 0x0022, 0x0022, 0x0022,

-		/* G */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0222, 0x03E2, 0x03EC,

-		/* H */	0x03FE, 0x03FE, 0x0020, 0x0020, 0x0020, 0x0020, 0x03FE, 0x03FE,

-		/* I */	0x0202, 0x03FE, 0x03FE, 0x0202,

-		/* J */	0x0200, 0x0202, 0x0202, 0x03FE, 0x01FE,

-		/* K */	0x03FE, 0x03FE, 0x0070, 0x00D8, 0x018C, 0x0306, 0x0202,

-		/* L */	0x03FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x0200,

-		/* M */	0x03FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x0030, 0x0018, 0x000C, 0x03FE, 0x03FE,

-		/* N */	0x03FE, 0x000E, 0x001C, 0x0070, 0x01E0, 0x0380, 0x03FE,

-		/* O */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC,

-		/* P */	0x03FE, 0x03FE, 0x0042, 0x0042, 0x0042, 0x007E, 0x003C,

-		/* Q */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0602, 0x0E02, 0x0BFE, 0x09FC,

-		/* R */	0x03FE, 0x03FE, 0x0022, 0x0062, 0x00E2, 0x01BE, 0x031C, 0x0200,

-		/* S */	0x019C, 0x023E, 0x0222, 0x0222, 0x0222, 0x03E2, 0x01CC,

-		/* T */	0x0002, 0x0002, 0x03FE, 0x03FE, 0x0002, 0x0002,

-		/* U */	0x01FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x03FE, 0x01FE,

-		/* V */	0x000E, 0x007E, 0x03F0, 0x0380, 0x03F0, 0x007E, 0x000E,

-		/* W */	0x001E, 0x00FE, 0x03E0, 0x03E0, 0x00FC, 0x000E, 0x00FC, 0x03E0, 0x03E0, 0x00FE, 0x001E,

-		/* X */	0x0306, 0x038E, 0x00F8, 0x0070, 0x00F8, 0x038E, 0x0306,

-		/* Y */	0x000E, 0x003E, 0x03F0, 0x03F0, 0x003E, 0x000E,

-		/* Z */	0x0382, 0x03C2, 0x0262, 0x0232, 0x021E, 0x020E,

-		/* [ */	0x0FFF, 0x0FFF, 0x0801, 0x0801,

-		/* \ */	0x0003, 0x001C, 0x0060, 0x0380, 0x0C00,

-		/* ] */	0x0801, 0x0801, 0x0FFF, 0x0FFF,

-		/* ^ */	0x0000, 0x0010, 0x0008, 0x0004, 0x0002, 0x0002, 0x0004, 0x0008, 0x0010,

-		/* _ */	0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800,

-		/* ` */	0x0000, 0x0000, 0x0001, 0x0003, 0x0002,

-		/* a */	0x0180, 0x03D0, 0x0248, 0x0248, 0x03F8, 0x03F0,

-		/* b */	0x03FF, 0x03FF, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0,

-		/* c */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208,

-		/* d */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x03FF, 0x03FF,

-		/* e */	0x01F0, 0x03F8, 0x0248, 0x0248, 0x0278, 0x0170,

-		/* f */	0x0008, 0x03FE, 0x03FF, 0x0009, 0x0001,

-		/* g */	0x01F0, 0x0BF8, 0x0A08, 0x0A08, 0x0908, 0x0FF8, 0x07F8,

-		/* h */	0x03FF, 0x03FF, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0,

-		/* i */	0x03FA, 0x03FA,

-		/* j */	0x0808, 0x0FFA, 0x07FA,

-		/* k */	0x03FF, 0x03FF, 0x00E0, 0x01B0, 0x0318, 0x0208,

-		/* l */	0x03FF, 0x03FF,

-		/* m */	0x03F8, 0x03F8, 0x0008, 0x0008, 0x03F8, 0x03F0, 0x0008, 0x0008, 0x03F8, 0x03F0,

-		/* n */	0x03F8, 0x03F8, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0,

-		/* o */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208, 0x03F8, 0x01F0,

-		/* p */	0x0FF8, 0x0FF8, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0,

-		/* q */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x0FF8, 0x0FF8,

-		/* r */	0x03F8, 0x03F8, 0x0010, 0x0018,

-		/* s */	0x0130, 0x0278, 0x0248, 0x03C8, 0x0190,

-		/* t */	0x0008, 0x01FE, 0x03FE, 0x0208, 0x0208,

-		/* u */	0x01F8, 0x03F8, 0x0200, 0x0200, 0x0100, 0x03F8, 0x03F8,

-		/* v */	0x0038, 0x00F8, 0x03C0, 0x03C0, 0x00F8, 0x0038,

-		/* w */	0x0018, 0x00F8, 0x03E0, 0x0380, 0x00F8, 0x00F8, 0x0380, 0x03E0, 0x00F8, 0x0018,

-		/* x */	0x0318, 0x03B8, 0x00E0, 0x00E0, 0x03B8, 0x0318,

-		/* y */	0x0038, 0x0CF8, 0x0FC0, 0x03C0, 0x00F8, 0x0038,

-		/* z */	0x0388, 0x03C8, 0x0268, 0x0238, 0x0218,

-		/* { */	0x0020, 0x0020, 0x07FE, 0x0FDF, 0x0801, 0x0801,

-		/* | */	0x0000, 0x0000, 0x0FFF, 0x0FFF,

-		/* } */	0x0801, 0x0801, 0x0FDF, 0x07FE, 0x0020, 0x0020,

-		/* ~ */	0x00E0, 0x0030, 0x0030, 0x0030, 0x0060, 0x00C0, 0x00C0, 0x00C0, 0x0070

-	};

-#endif

-

-/* fontUI1 - UI Font 1 Medium Bold */

-#if GDISP_INCLUDE_FONT_UI1

-	/* Forward Declarations of internal arrays */

-    static const uint8_t        fontUI1_Widths[];

-    static const uint16_t       fontUI1_Offsets[];

-    static const fontcolumn_t   fontUI1_Data[];

-

-    FONT_DECL const struct font fontUI1 = {

-									"UI1",

-									13, 0, 15, 2, 3, 13, ' ', '~', 1, 1,

-									fontUI1_Widths,

-									fontUI1_Offsets,

-									fontUI1_Data};

-    FONT_DECL const struct font fontUI1Double = {

-									"UI1 Double",

-									13, 0, 15, 2, 3, 13, ' ', '~', 2, 2,

-									fontUI1_Widths,

-									fontUI1_Offsets,

-									fontUI1_Data};

-    FONT_DECL const struct font fontUI1Narrow = {

-									"UI1 Narrow",

-									13, 0, 15, 2, 3, 13, ' ', '~', 1, 2,

-									fontUI1_Widths,

-									fontUI1_Offsets,

-									fontUI1_Data};

-

-	static const uint8_t fontUI1_Widths[] = {

-		3, 3, 6, 8, 7, 13, 9, 3, 5, 5, 6, 8, 3, 5, 3, 7,

-		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 8, 8, 8, 6,

-		10, 8, 7, 7, 8, 7, 7, 8, 8, 5, 5, 7, 7, 9, 8, 8,

-		7, 8, 8, 7, 8, 8, 7, 11, 7, 7, 7, 5, 7, 5, 9, 8,

-		5, 7, 7, 6, 7, 7, 5, 7, 7, 3, 4, 7, 3, 11, 7, 7,

-		7, 7, 6, 6, 5, 7, 7, 9, 7, 7, 6, 7, 4, 7, 8, 0

-	};

-	static const uint16_t fontUI1_Offsets[] = {

-		0, 3, 6, 12, 20, 27, 40, 49,

-		52, 57, 62, 68, 76, 79, 84, 87,

-		94, 101, 108, 115, 122, 129, 136, 143,

-		150, 157, 164, 167, 170, 178, 186, 194,

-		200, 210, 218, 225, 232, 240, 247, 254,

-		262, 270, 275, 280, 287, 294, 303, 311,

-		319, 326, 334, 342, 349, 357, 365, 372,

-		383, 390, 397, 404, 409, 416, 421, 430,

-		438, 443, 450, 457, 463, 470, 477, 482,

-		489, 496, 499, 503, 510, 513, 524, 531,

-		538, 545, 552, 558, 564, 569, 576, 583,

-		592, 599, 606, 612, 619, 623, 630, 0

-	};

-	static const fontcolumn_t fontUI1_Data[] = {

-		/*   */	0x0000, 0x0000, 0x0000,

-		/* ! */	0x0000, 0x02FC, 0x02FC,

-		/* " */	0x0000, 0x000E, 0x000E, 0x0000, 0x000E, 0x000E,

-		/* # */	0x0000, 0x0080, 0x0390, 0x00F0, 0x039C, 0x00F0, 0x009C, 0x0010,

-		/* $ */	0x0000, 0x0130, 0x0278, 0x0FC8, 0x027E, 0x03C8, 0x0190,

-		/* % */	0x0000, 0x0038, 0x007C, 0x0044, 0x007C, 0x0338, 0x00C0, 0x0030, 0x01CC, 0x03E0, 0x0220, 0x03E0,

-				0x01C0,

-		/* & */	0x0000, 0x01D8, 0x03FC, 0x0224, 0x027C, 0x02D8, 0x0180, 0x0360, 0x0220,

-		/* ' */	0x0000, 0x000E, 0x000E,

-		/* ( */	0x0000, 0x01F0, 0x07FC, 0x0E0E, 0x0802,

-		/* ) */	0x0000, 0x0802, 0x0E0E, 0x07FC, 0x01F0,

-		/* * */	0x0000, 0x0014, 0x0008, 0x003E, 0x0008, 0x0014,

-		/* + */	0x0000, 0x0040, 0x0040, 0x0040, 0x03F8, 0x0040, 0x0040, 0x0040,

-		/* , */	0x0000, 0x0F00, 0x0700,

-		/* - */	0x0000, 0x0040, 0x0040, 0x0040, 0x0040,

-		/* . */	0x0000, 0x0300, 0x0300,

-		/* / */	0x0000, 0x0C00, 0x0F00, 0x03E0, 0x00F8, 0x001E, 0x0006,

-		/* 0 */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x03FC, 0x01F8,

-		/* 1 */	0x0000, 0x0000, 0x0208, 0x03FC, 0x03FC, 0x0200, 0x0000,

-		/* 2 */	0x0000, 0x0308, 0x038C, 0x02C4, 0x0264, 0x023C, 0x0218,

-		/* 3 */	0x0000, 0x0108, 0x030C, 0x0224, 0x0224, 0x03FC, 0x01D8,

-		/* 4 */	0x0000, 0x00C0, 0x00A0, 0x0090, 0x03F8, 0x03FC, 0x0080,

-		/* 5 */	0x0000, 0x0100, 0x033C, 0x023C, 0x0224, 0x03E4, 0x01C4,

-		/* 6 */	0x0000, 0x01F0, 0x03F8, 0x022C, 0x0224, 0x03E4, 0x01C0,

-		/* 7 */	0x0000, 0x0004, 0x0304, 0x03C4, 0x00F4, 0x003C, 0x000C,

-		/* 8 */	0x0000, 0x01D8, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8,

-		/* 9 */	0x0000, 0x0038, 0x027C, 0x0244, 0x0344, 0x01FC, 0x00F8,

-		/* : */	0x0000, 0x0330, 0x0330,

-		/* ; */	0x0000, 0x0F30, 0x0730,

-		/* < */	0x0000, 0x0040, 0x00A0, 0x00A0, 0x0110, 0x0110, 0x0208, 0x0208,

-		/* = */	0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090,

-		/* > */	0x0000, 0x0208, 0x0208, 0x0110, 0x0110, 0x00A0, 0x00A0, 0x0040,

-		/* ? */	0x0000, 0x0008, 0x02C4, 0x02E4, 0x003C, 0x0018,

-		/* @ */	0x0000, 0x01F0, 0x0208, 0x04E4, 0x05F4, 0x0514, 0x05F4, 0x05F4, 0x0104, 0x00F8,

-		/* A */	0x0000, 0x0380, 0x03F0, 0x00FC, 0x008C, 0x00FC, 0x03F0, 0x0380,

-		/* B */	0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8,

-		/* C */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x0108,

-		/* D */	0x0000, 0x03FC, 0x03FC, 0x0204, 0x0204, 0x030C, 0x01F8, 0x00F0,

-		/* E */	0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x0224, 0x0224,

-		/* F */	0x0000, 0x03FC, 0x03FC, 0x0024, 0x0024, 0x0024, 0x0024,

-		/* G */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0244, 0x03C4, 0x03C8,

-		/* H */	0x0000, 0x03FC, 0x03FC, 0x0020, 0x0020, 0x0020, 0x03FC, 0x03FC,

-		/* I */	0x0000, 0x0204, 0x03FC, 0x03FC, 0x0204,

-		/* J */	0x0200, 0x0204, 0x0204, 0x03FC, 0x01FC,

-		/* K */	0x0000, 0x03FC, 0x03FC, 0x00F0, 0x0198, 0x030C, 0x0204,

-		/* L */	0x0000, 0x03FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x0200,

-		/* M */	0x0000, 0x03FC, 0x001C, 0x0038, 0x0070, 0x0020, 0x0010, 0x03F8, 0x03FC,

-		/* N */	0x0000, 0x03FC, 0x0018, 0x0030, 0x0060, 0x00C0, 0x0180, 0x03FC,

-		/* O */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x03FC, 0x01F8,

-		/* P */	0x0000, 0x03FC, 0x03FC, 0x0044, 0x0044, 0x007C, 0x0038,

-		/* Q */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0604, 0x0E04, 0x0BFC, 0x09F8,

-		/* R */	0x0000, 0x03FC, 0x03FC, 0x0044, 0x00C4, 0x01FC, 0x0338, 0x0200,

-		/* S */	0x0000, 0x0138, 0x027C, 0x0264, 0x0264, 0x03E4, 0x01C8,

-		/* T */	0x0004, 0x0004, 0x0004, 0x03FC, 0x03FC, 0x0004, 0x0004, 0x0004,

-		/* U */	0x0000, 0x01FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x03FC, 0x01FC,

-		/* V */	0x0000, 0x001C, 0x00FC, 0x03E0, 0x03E0, 0x00FC, 0x001C,

-		/* W */	0x0000, 0x001C, 0x00FC, 0x03E0, 0x03C0, 0x007C, 0x007C, 0x03C0, 0x03E0, 0x00FC, 0x001C,

-		/* X */	0x0000, 0x030C, 0x039C, 0x00F0, 0x00F0, 0x039C, 0x030C,

-		/* Y */	0x0000, 0x000C, 0x003C, 0x03F0, 0x03F0, 0x003C, 0x000C,

-		/* Z */	0x0000, 0x0384, 0x03C4, 0x02E4, 0x0274, 0x023C, 0x021C,

-		/* [ */	0x0000, 0x0FFE, 0x0FFE, 0x0802, 0x0802,

-		/* \ */	0x0000, 0x0006, 0x001E, 0x00F8, 0x03E0, 0x0F00, 0x0C00,

-		/* ] */	0x0000, 0x0802, 0x0802, 0x0FFE, 0x0FFE,

-		/* ^ */	0x0000, 0x0020, 0x0030, 0x0018, 0x000C, 0x000C, 0x0018, 0x0030, 0x0020,

-		/* _ */	0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800,

-		/* ` */	0x0000, 0x0000, 0x0002, 0x0006, 0x0004,

-		/* a */	0x0000, 0x0180, 0x03D0, 0x0250, 0x0250, 0x03F0, 0x03E0,

-		/* b */	0x0000, 0x03FE, 0x03FE, 0x0210, 0x0210, 0x03F0, 0x01E0,

-		/* c */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0210,

-		/* d */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03FE, 0x03FE,

-		/* e */	0x0000, 0x01E0, 0x03F0, 0x0250, 0x0250, 0x0270, 0x0160,

-		/* f */	0x0010, 0x03FC, 0x03FE, 0x0012, 0x0012,

-		/* g */	0x0000, 0x01E0, 0x0BF0, 0x0A10, 0x0A10, 0x0FF0, 0x07F0,

-		/* h */	0x0000, 0x03FE, 0x03FE, 0x0010, 0x0010, 0x03F0, 0x03E0,

-		/* i */	0x0000, 0x03F4, 0x03F4,

-		/* j */	0x0800, 0x0810, 0x0FF4, 0x07F4,

-		/* k */	0x0000, 0x03FE, 0x03FE, 0x00C0, 0x01E0, 0x0330, 0x0210,

-		/* l */	0x0000, 0x03FE, 0x03FE,

-		/* m */	0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0, 0x0010, 0x0010, 0x03F0, 0x03E0,

-		/* n */	0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0,

-		/* o */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03F0, 0x01E0,

-		/* p */	0x0000, 0x0FF0, 0x0FF0, 0x0210, 0x0210, 0x03F0, 0x01E0,

-		/* q */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0FF0, 0x0FF0,

-		/* r */	0x0000, 0x03F0, 0x03F0, 0x0020, 0x0030, 0x0030,

-		/* s */	0x0000, 0x0260, 0x02F0, 0x02D0, 0x03D0, 0x0190,

-		/* t */	0x0010, 0x01FC, 0x03FC, 0x0210, 0x0210,

-		/* u */	0x0000, 0x01F0, 0x03F0, 0x0200, 0x0200, 0x03F0, 0x03F0,

-		/* v */	0x0000, 0x0070, 0x01F0, 0x0380, 0x0380, 0x01F0, 0x0070,

-		/* w */	0x0000, 0x00F0, 0x03F0, 0x0300, 0x00F0, 0x00F0, 0x0300, 0x03F0, 0x00F0,

-		/* x */	0x0000, 0x0330, 0x03F0, 0x00C0, 0x00C0, 0x03F0, 0x0330,

-		/* y */	0x0000, 0x0030, 0x0CF0, 0x0FC0, 0x03C0, 0x00F0, 0x0030,

-		/* z */	0x0000, 0x0310, 0x0390, 0x02D0, 0x0270, 0x0230,

-		/* { */	0x0000, 0x0040, 0x0040, 0x07FC, 0x0FBE, 0x0802, 0x0802,

-		/* | */	0x0000, 0x0000, 0x0FFE, 0x0FFE,

-		/* } */	0x0000, 0x0802, 0x0802, 0x0FBE, 0x07FC, 0x0040, 0x0040,

-		/* ~ */	0x0000, 0x01C0, 0x0020, 0x0020, 0x00C0, 0x0100, 0x0100, 0x00E0

-	};

-#endif

-

-/* fontUI1 - UI Font 2 Medium Bold */

-#if GDISP_INCLUDE_FONT_UI2

-	/* Forward Declarations of internal arrays */

-	static const uint8_t        fontUI2_Widths[];

-	static const uint16_t       fontUI2_Offsets[];

-	static const fontcolumn_t   fontUI2_Data[];

-

-	FONT_DECL const struct font fontUI2 = {

-									"UI2",

-									11, 1, 13, 2, 2, 12, ' ', '~', 1, 1,

-									fontUI2_Widths,

-									fontUI2_Offsets,

-									fontUI2_Data};

-	FONT_DECL const struct font fontUI2Double = {

-									"UI2 Double",

-									11, 1, 13, 2, 2, 12, ' ', '~', 2, 2,

-									fontUI2_Widths,

-									fontUI2_Offsets,

-									fontUI2_Data};

-	FONT_DECL const struct font fontUI2Narrow = {

-									"UI2 Narrow",

-									11, 1, 13, 2, 2, 12, ' ', '~', 1, 2,

-									fontUI2_Widths,

-									fontUI2_Offsets,

-									fontUI2_Data};

-

-	static const uint8_t fontUI2_Widths[] = {

-		2, 2, 5, 8, 6, 12, 8, 2, 4, 4, 6, 8, 2, 4, 2, 5,

-		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 8, 8, 8, 5,

-		9, 7, 6, 6, 7, 5, 5, 7, 7, 4, 5, 6, 5, 9, 6, 7,

-		6, 7, 7, 6, 6, 7, 6, 10, 6, 6, 6, 4, 5, 4, 7, 7,

-		4, 6, 6, 5, 6, 6, 4, 6, 6, 2, 3, 6, 2, 10, 6, 6,

-		6, 6, 4, 5, 4, 6, 6, 8, 6, 6, 5, 6, 4, 6, 8, 0

-	};

-	static const uint16_t fontUI2_Offsets[] = {

-		0, 2, 4, 9, 17, 23, 35, 43,

-		45, 49, 53, 59, 67, 69, 73, 75,

-		80, 86, 92, 98, 104, 110, 116, 122,

-		128, 134, 140, 142, 144, 152, 160, 168,

-		173, 182, 189, 195, 201, 208, 213, 218,

-		225, 232, 236, 241, 247, 252, 261, 267,

-		274, 280, 287, 294, 300, 306, 313, 319,

-		329, 335, 341, 347, 351, 356, 360, 367,

-		374, 378, 384, 390, 395, 401, 407, 411,

-		417, 423, 425, 428, 434, 436, 446, 452,

-		458, 464, 470, 474, 479, 483, 489, 495,

-		503, 509, 515, 520, 526, 530, 536, 0

-	};

-	static const fontcolumn_t fontUI2_Data[] = {

-		/*   */	0x0000, 0x0000,

-		/* ! */	0x017E, 0x017E,

-		/* " */	0x0007, 0x0007, 0x0000, 0x0007, 0x0007,

-		/* # */	0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018,

-		/* $ */	0x0098, 0x013C, 0x07E4, 0x013F, 0x01E4, 0x00C8,

-		/* % */	0x001C, 0x003E, 0x0022, 0x003E, 0x019C, 0x0060, 0x0018, 0x00E6, 0x01F0, 0x0110, 0x01F0, 0x00E0,

-		/* & */	0x00EC, 0x01FE, 0x0112, 0x013E, 0x016C, 0x00C0, 0x01B0, 0x0110,

-		/* ' */	0x0007, 0x0007,

-		/* ( */	0x00F8, 0x03FE, 0x0707, 0x0401,

-		/* ) */	0x0401, 0x0707, 0x03FE, 0x00F8,

-		/* * */	0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A,

-		/* + */	0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020,

-		/* , */	0x0780, 0x0380,

-		/* - */	0x0020, 0x0020, 0x0020, 0x0020,

-		/* . */	0x0180, 0x0180,

-		/* / */	0x0600, 0x0180, 0x0070, 0x000C, 0x0003,

-		/* 0 */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x01FE, 0x00FC,

-		/* 1 */	0x0000, 0x0104, 0x01FE, 0x01FE, 0x0100, 0x0000,

-		/* 2 */	0x0184, 0x01C6, 0x0162, 0x0132, 0x011E, 0x010C,

-		/* 3 */	0x0084, 0x0186, 0x0112, 0x0112, 0x01FE, 0x00EC,

-		/* 4 */	0x0060, 0x0050, 0x0048, 0x01FC, 0x01FE, 0x0040,

-		/* 5 */	0x0080, 0x019E, 0x011E, 0x0112, 0x01F2, 0x00E2,

-		/* 6 */	0x00FC, 0x01FE, 0x0112, 0x0112, 0x01F2, 0x00E0,

-		/* 7 */	0x0002, 0x0002, 0x01C2, 0x01FA, 0x003E, 0x0006,

-		/* 8 */	0x00EC, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC,

-		/* 9 */	0x001C, 0x013E, 0x0122, 0x0122, 0x01FE, 0x00FC,

-		/* : */	0x0198, 0x0198,

-		/* ; */	0x0798, 0x0398,

-		/* < */	0x0000, 0x0020, 0x0050, 0x0050, 0x0088, 0x0088, 0x0104, 0x0104,

-		/* = */	0x0000, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048,

-		/* > */	0x0000, 0x0104, 0x0104, 0x0088, 0x0088, 0x0050, 0x0050, 0x0020,

-		/* ? */	0x0004, 0x0162, 0x0172, 0x001E, 0x000C,

-		/* @ */	0x00F8, 0x0104, 0x0272, 0x02FA, 0x028A, 0x027A, 0x02FA, 0x0084, 0x0078,

-		/* A */	0x01C0, 0x01F8, 0x007E, 0x0046, 0x007E, 0x01F8, 0x01C0,

-		/* B */	0x01FE, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC,

-		/* C */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x0102,

-		/* D */	0x01FE, 0x01FE, 0x0102, 0x0102, 0x0186, 0x00FC, 0x0078,

-		/* E */	0x01FE, 0x01FE, 0x0112, 0x0112, 0x0112,

-		/* F */	0x01FE, 0x01FE, 0x0012, 0x0012, 0x0012,

-		/* G */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x0122, 0x01E2, 0x01E2,

-		/* H */	0x01FE, 0x01FE, 0x0010, 0x0010, 0x0010, 0x01FE, 0x01FE,

-		/* I */	0x0102, 0x01FE, 0x01FE, 0x0102,

-		/* J */	0x0100, 0x0102, 0x0102, 0x01FE, 0x00FE,

-		/* K */	0x01FE, 0x01FE, 0x0078, 0x00CC, 0x0186, 0x0102,

-		/* L */	0x01FE, 0x01FE, 0x0100, 0x0100, 0x0100,

-		/* M */	0x01FE, 0x000E, 0x001C, 0x0038, 0x0030, 0x0018, 0x000C, 0x01FE, 0x01FE,

-		/* N */	0x01FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x01FE,

-		/* O */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x01FE, 0x00FC,

-		/* P */	0x01FE, 0x01FE, 0x0022, 0x0022, 0x003E, 0x001C,

-		/* Q */	0x00FC, 0x01FE, 0x0102, 0x0302, 0x0702, 0x05FE, 0x04FC,

-		/* R */	0x01FE, 0x01FE, 0x0022, 0x0062, 0x00FE, 0x019C, 0x0100,

-		/* S */	0x011C, 0x013E, 0x0132, 0x0132, 0x01F2, 0x00E2,

-		/* T */	0x0002, 0x0002, 0x01FE, 0x01FE, 0x0002, 0x0002,

-		/* U */	0x00FE, 0x01FE, 0x0100, 0x0100, 0x0100, 0x01FE, 0x00FE,

-		/* V */	0x000E, 0x007E, 0x01F0, 0x01F0, 0x007E, 0x000E,

-		/* W */	0x000E, 0x007E, 0x01F0, 0x01E0, 0x003E, 0x003E, 0x01E0, 0x01F0, 0x007E, 0x000E,

-		/* X */	0x0186, 0x01CE, 0x0078, 0x0078, 0x01CE, 0x0186,

-		/* Y */	0x0006, 0x001E, 0x01F8, 0x01F8, 0x001E, 0x0006,

-		/* Z */	0x01C2, 0x01E2, 0x0172, 0x013A, 0x011E, 0x010E,

-		/* [ */	0x07FF, 0x07FF, 0x0401, 0x0401,

-		/* \ */	0x0003, 0x000C, 0x0070, 0x0180, 0x0600,

-		/* ] */	0x0401, 0x0401, 0x07FF, 0x07FF,

-		/* ^ */	0x0010, 0x0008, 0x0004, 0x0002, 0x0004, 0x0008, 0x0010,

-		/* _ */	0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,

-		/* ` */	0x0000, 0x0001, 0x0003, 0x0002,

-		/* a */	0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0,

-		/* b */	0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0,

-		/* c */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x0108,

-		/* d */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF,

-		/* e */	0x00F0, 0x01F8, 0x0128, 0x0128, 0x0138, 0x0130,

-		/* f */	0x01FE, 0x01FF, 0x0009, 0x0001,

-		/* g */	0x00F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8,

-		/* h */	0x01FF, 0x01FF, 0x0008, 0x0008, 0x01F8, 0x01F0,

-		/* i */	0x01FA, 0x01FA,

-		/* j */	0x0408, 0x07FA, 0x03FA,

-		/* k */	0x01FF, 0x01FF, 0x0060, 0x00F0, 0x0198, 0x0108,

-		/* l */	0x01FF, 0x01FF,

-		/* m */	0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0, 0x0008, 0x0008, 0x01F8, 0x01F0,

-		/* n */	0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0,

-		/* o */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0,

-		/* p */	0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0,

-		/* q */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8,

-		/* r */	0x01F8, 0x01F8, 0x0010, 0x0018,

-		/* s */	0x0130, 0x0178, 0x0168, 0x01E8, 0x00C8,

-		/* t */	0x00FE, 0x01FE, 0x0108, 0x0108,

-		/* u */	0x00F8, 0x01F8, 0x0100, 0x0100, 0x01F8, 0x01F8,

-		/* v */	0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018,

-		/* w */	0x0078, 0x01F8, 0x01C0, 0x0078, 0x0078, 0x01C0, 0x01F8, 0x0078,

-		/* x */	0x0198, 0x01F8, 0x0060, 0x0060, 0x01F8, 0x0198,

-		/* y */	0x0018, 0x0678, 0x07E0, 0x01E0, 0x0078, 0x0018,

-		/* z */	0x0188, 0x01C8, 0x0168, 0x0138, 0x0118,

-		/* { */	0x0020, 0x0020, 0x03FE, 0x07DF, 0x0401, 0x0401,

-		/* | */	0x0000, 0x0000, 0x07FF, 0x07FF,

-		/* } */	0x0401, 0x0401, 0x07DF, 0x03FE, 0x0020, 0x0020,

-		/* ~ */	0x0060, 0x0010, 0x0010, 0x0030, 0x0060, 0x0040, 0x0040, 0x0030

-	};

-#endif

-

-/*

-	fontLargeNumbers:

-		Large numbers font, height = 16 (including the decenders)

-		Characters include:  0 - 9, -, +, ., %, :, Space, Comma

-*/

-#if GDISP_INCLUDE_FONT_LARGENUMBERS

-	/* Forward Declarations of internal arrays */

-    static const uint8_t        fontLargeNumbers_Widths[];

-    static const uint16_t       fontLargeNumbers_Offsets[];

-    static const fontcolumn_t   fontLargeNumbers_Data[];

-

-    FONT_DECL const struct font fontLargeNumbers = {

-									"LargeNumbers",

-									16, 2, 21, 1, 3, 15, '%', ':', 1, 1,

-									fontLargeNumbers_Widths,

-									fontLargeNumbers_Offsets,

-									fontLargeNumbers_Data};

-    FONT_DECL const struct font fontLargeNumbersDouble = {

-									"LargeNumbers Double",

-									16, 2, 21, 1, 3, 15, '%', ':', 2, 2,

-									fontLargeNumbers_Widths,

-									fontLargeNumbers_Offsets,

-									fontLargeNumbers_Data};

-    FONT_DECL const struct font fontLargeNumbersNarrow = {

-									"LargeNumbers Narrow", 16, 2, 21, 1, 3, 15, '%', ':', 1, 2,

-									fontLargeNumbers_Widths,

-									fontLargeNumbers_Offsets,

-									fontLargeNumbers_Data};

-

-	static const uint8_t fontLargeNumbers_Widths[] = {

-		15, 0, 0, 0, 0, 0, 11, 3, 6, 3, 0, 10, 10, 10, 10, 10,

-		10, 10, 10, 10, 10, 4, 0, 0

-	};

-	static const uint16_t fontLargeNumbers_Offsets[] = {

-		0, 0, 0, 0, 0, 0, 15, 26,

-		29, 35, 0, 38, 48, 58, 68, 78,

-		88, 98, 108, 118, 128, 138, 0, 0

-	};

-	static const fontcolumn_t fontLargeNumbers_Data[] = {

-		/* % */	0x007E, 0x00FF, 0x00C3, 0x80C3, 0xE0FF, 0x7C7E, 0x1F00, 0x07C0, 0x00F0, 0x7E3E, 0xFF0F, 0xC303,

-				0xC300, 0xFF00, 0x7E00,

-		/* + */	0x01C0, 0x01C0, 0x01C0, 0x01C0, 0x1FFC, 0x1FFC, 0x1FFC, 0x01C0, 0x01C0, 0x01C0, 0x01C0,

-		/* , */	0x7000, 0x7000, 0xF000,

-		/* - */	0x0700, 0x0700, 0x0700, 0x0700, 0x0700, 0x0700,

-		/* . */	0x7000, 0x7000, 0x7000,

-		/* 0 */	0x0FF8, 0x3FFE, 0x3FFE, 0x7007, 0x6003, 0x6003, 0x7007, 0x3FFE, 0x3FFE, 0x0FF8,

-		/* 1 */	0x0000, 0x0070, 0x0038, 0x0038, 0x001C, 0x7FFF, 0x7FFF, 0x7FFF, 0x0000, 0x0000,

-		/* 2 */	0x600C, 0x700E, 0x7C0F, 0x7E07, 0x6F03, 0x6783, 0x63C7, 0x61FF, 0x60FE, 0x603C,

-		/* 3 */	0x180C, 0x380E, 0x780F, 0x70C3, 0x60C3, 0x60E3, 0x71FF, 0x3FFE, 0x3F3C, 0x0E00,

-		/* 4 */	0x0F00, 0x0DC0, 0x0CE0, 0x0C38, 0x0C1E, 0x7FFF, 0x7FFF, 0x7FFF, 0x0C00, 0x0C00,

-		/* 5 */	0x18C0, 0x38FC, 0x78FF, 0x707F, 0x6063, 0x6063, 0x70E3, 0x3FE3, 0x3FC3, 0x0F80,

-		/* 6 */	0x0FF8, 0x3FFE, 0x3FFE, 0x70C7, 0x6063, 0x6063, 0x70E7, 0x3FEF, 0x3FC6, 0x0F04,

-		/* 7 */	0x0003, 0x0003, 0x7803, 0x7F03, 0x7FC3, 0x07F3, 0x00FB, 0x003F, 0x000F, 0x0007,

-		/* 8 */	0x1E1C, 0x3F3E, 0x7FFF, 0x71E7, 0x60C3, 0x60C3, 0x71E7, 0x7FFF, 0x3F3E, 0x1E1C,

-		/* 9 */	0x1078, 0x39FE, 0x7BFE, 0x7387, 0x6303, 0x6303, 0x7187, 0x3FFE, 0x3FFE, 0x0FF8,

-		/* : */	0x0000, 0x0E38, 0x0E38, 0x0E38

-	};

-#endif

-

-static const struct font *BuiltinFontTable[] = {

-	#if GDISP_INCLUDE_FONT_SMALL

-		&fontSmall, &fontSmallDouble, &fontSmallNarrow,

-	#endif

-	#if GDISP_INCLUDE_FONT_LARGER

-		&fontLarger, &fontLargerDouble, &fontLargerNarrow,

-	#endif

-	#if GDISP_INCLUDE_FONT_UI1

-		&fontUI1, &fontUI1Double, &fontUI1Narrow,

-	#endif

-	#if GDISP_INCLUDE_FONT_UI2

-		&fontUI2, &fontUI2Double, &fontUI2Narrow,

-	#endif

-	#if GDISP_INCLUDE_FONT_LARGENUMBERS

-		&fontLargeNumbers, &fontLargeNumbersDouble, &fontLargeNumbersNarrow,

-	#endif

-	};

-

-/**

- * Match a pattern against the font name.

- */

-static bool_t matchfont(const char *pattern, const char *name) {

-	while(1) {

-		switch (pattern[0]) {

-		case '*':

-			if (name[0] == 0)

-				return pattern[1] == 0;

-			if (pattern[1] == name[0])

-				pattern++;

-			else

-				name++;

-			break;

-		case 0:

-			return name[0] == 0;

-		default:

-			if (name[0] != pattern[0])

-				return FALSE;

-			pattern++;

-			name++;

-			break;

-		}

-	}

-}

-

-/**

- * @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) {

-	const struct font **p;

-

-	for(p = BuiltinFontTable; p < BuiltinFontTable+sizeof(BuiltinFontTable)/sizeof(BuiltinFontTable[0]); p++) {

-		if (matchfont(name, p[0]->name))

-			return p[0];

-	}

-	return 0;

-}

-

-/**

- * @brief	Release a font after use.

- *

- * @param[in] font		The font to release.

- *

- * @api

- */

-void gdispCloseFont(font_t font) {

-	(void) 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) {

-	return font->name;

-}

-

-#endif /* GFX_USE_GDISP && GDISP_NEED_TEXT */

-/** @} */

+/*
+    ChibiOS/GFX - Copyright (C) 2012, 2013
+                 Joel Bodenmann aka Tectu <joel@unormal.org>
+
+    This file is part of ChibiOS/GFX.
+
+    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
+    the Free Software Foundation; either version 3 of the License, or
+    (at your option) any later version.
+
+    ChibiOS/GFX is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+*/
+
+/**
+ * @file    src/gdisp/fonts.c
+ * @brief   GDISP Font Handling.
+ *
+ * @addtogroup GDISP
+ * @{
+ */
+
+#include "ch.h"
+#include "hal.h"
+#include "gfx.h"
+
+#if GFX_USE_GDISP && GDISP_NEED_TEXT
+
+#include "gdisp/fonts.h"
+
+/* fontSmall - for side buttons */
+#if GDISP_INCLUDE_FONT_SMALL
+    /* Forward Declarations of internal arrays */
+    static const uint8_t        fontSmall_Widths[];
+    static const uint16_t       fontSmall_Offsets[];
+    static const fontcolumn_t   fontSmall_Data[];
+
+    static const struct font fontSmall = {
+									"Small",
+									11, 0, 14, 2, 2, 12, ' ', '~', 1, 1,
+									fontSmall_Widths,
+									fontSmall_Offsets,
+									fontSmall_Data};
+    static const struct font fontSmallDouble = {
+									"Small Double",
+									11, 0, 14, 2, 2, 12, ' ', '~', 2, 2,
+									fontSmall_Widths,
+									fontSmall_Offsets,
+									fontSmall_Data};
+    static const struct font fontSmallNarrow = {
+									"Small Narrow",
+									11, 0, 14, 2, 2, 12, ' ', '~', 1, 2,
+									fontSmall_Widths,
+									fontSmall_Offsets,
+									fontSmall_Data};
+
+	static const uint8_t fontSmall_Widths[] = {
+		2, 3, 6, 8, 7, 9, 7, 3, 4, 4, 5, 7, 4, 4, 3, 6,
+		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 4, 6, 7, 6, 7,
+		12, 8, 7, 8, 8, 7, 7, 8, 8, 3, 5, 8, 7, 9, 8, 8,
+		8, 8, 8, 7, 7, 8, 8, 12, 8, 8, 8, 4, 6, 4, 7, 7,
+		4, 7, 7, 7, 7, 7, 4, 7, 7, 3, 3, 7, 3, 9, 7, 7,
+		7, 7, 4, 6, 4, 7, 7, 9, 6, 6, 6, 5, 3, 5, 8, 0
+	};
+	static const uint16_t fontSmall_Offsets[] = {
+		0, 2, 5, 11, 19, 26, 35, 42,
+		45, 49, 53, 58, 65, 69, 73, 76,
+		82, 89, 96, 103, 110, 117, 124, 131,
+		138, 145, 152, 155, 159, 165, 172, 178,
+		185, 197, 205, 212, 220, 228, 235, 242,
+		250, 258, 261, 266, 274, 281, 290, 298,
+		306, 314, 322, 330, 337, 344, 352, 360,
+		372, 380, 388, 396, 400, 406, 410, 417,
+		424, 428, 435, 442, 449, 456, 463, 467,
+		474, 481, 484, 487, 494, 497, 506, 513,
+		520, 527, 534, 538, 544, 548, 555, 562,
+		571, 577, 583, 589, 594, 597, 602, 0
+	};
+	static const fontcolumn_t fontSmall_Data[] = {
+		/*   */	0x0000, 0x0000,
+		/* ! */	0x0000, 0x017F, 0x017F,
+		/* " */	0x0000, 0x0007, 0x0007, 0x0000, 0x0007, 0x0007,
+		/* # */	0x0000, 0x0044, 0x01FF, 0x01FF, 0x0044, 0x01FF, 0x01FF, 0x0044,
+		/* $ */	0x0000, 0x008C, 0x019E, 0x03FF, 0x03FF, 0x01E6, 0x00C4,
+		/* % */	0x0000, 0x0082, 0x00C7, 0x0065, 0x00B7, 0x01DA, 0x014C, 0x01C6, 0x0082,
+		/* & */	0x0000, 0x00E6, 0x01FF, 0x013F, 0x01E6, 0x01E0, 0x0120,
+		/* ' */	0x0000, 0x0007, 0x0007,
+		/* ( */	0x0000, 0x03FE, 0x07FF, 0x0401,
+		/* ) */	0x0000, 0x0401, 0x07FF, 0x03FE,
+		/* * */	0x0000, 0x000A, 0x000E, 0x000E, 0x000A,
+		/* + */	0x0000, 0x0020, 0x0020, 0x00F8, 0x00F8, 0x0020, 0x0020,
+		/* , */	0x0000, 0x0200, 0x0300, 0x0100,
+		/* - */	0x0000, 0x0020, 0x0020, 0x0020,
+		/* . */	0x0000, 0x0100, 0x0100,
+		/* / */	0x0000, 0x0180, 0x01E0, 0x0078, 0x001F, 0x0007,
+		/* 0 */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x01FF, 0x00FE,
+		/* 1 */	0x0000, 0x0002, 0x0002, 0x01FF, 0x01FF, 0x0000, 0x0000,
+		/* 2 */	0x0000, 0x0182, 0x01C3, 0x0161, 0x0131, 0x011F, 0x010E,
+		/* 3 */	0x0000, 0x0082, 0x0183, 0x0111, 0x0111, 0x01FF, 0x00EE,
+		/* 4 */	0x0000, 0x0060, 0x0078, 0x005E, 0x01FF, 0x01FF, 0x0040,
+		/* 5 */	0x0000, 0x009F, 0x019F, 0x0109, 0x0109, 0x01F9, 0x00F1,
+		/* 6 */	0x0000, 0x00FE, 0x01FF, 0x0111, 0x0111, 0x01F3, 0x00E2,
+		/* 7 */	0x0000, 0x0001, 0x01C1, 0x01F1, 0x003D, 0x000F, 0x0003,
+		/* 8 */	0x0000, 0x00EE, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE,
+		/* 9 */	0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01FF, 0x00FE,
+		/* : */	0x0000, 0x0108, 0x0108,
+		/* ; */	0x0000, 0x0200, 0x0308, 0x0108,
+		/* < */	0x0000, 0x0020, 0x0070, 0x00D8, 0x018C, 0x0104,
+		/* = */	0x0000, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050, 0x0050,
+		/* > */	0x0000, 0x0104, 0x018C, 0x00D8, 0x0070, 0x0020,
+		/* ? */	0x0000, 0x0002, 0x0003, 0x0161, 0x0171, 0x001F, 0x000E,
+		/* @ */	0x0000, 0x0078, 0x01FE, 0x0186, 0x0333, 0x0279, 0x0249, 0x0279, 0x027B, 0x0246, 0x007E, 0x0078,
+		/* A */	0x0180, 0x01F0, 0x007C, 0x004F, 0x004F, 0x007C, 0x01F0, 0x0180,
+		/* B */	0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x01FF, 0x00EE,
+		/* C */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x0183, 0x0082,
+		/* D */	0x0000, 0x01FF, 0x01FF, 0x0101, 0x0101, 0x0183, 0x00FE, 0x007C,
+		/* E */	0x0000, 0x01FF, 0x01FF, 0x0111, 0x0111, 0x0111, 0x0101,
+		/* F */	0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x0001,
+		/* G */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0111, 0x0191, 0x01F3, 0x01F2,
+		/* H */	0x0000, 0x01FF, 0x01FF, 0x0010, 0x0010, 0x0010, 0x01FF, 0x01FF,
+		/* I */	0x0000, 0x01FF, 0x01FF,
+		/* J */	0x00C0, 0x01C0, 0x0100, 0x01FF, 0x00FF,
+		/* K */	0x0000, 0x01FF, 0x01FF, 0x003C, 0x0066, 0x00C3, 0x0181, 0x0100,
+		/* L */	0x0000, 0x01FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x0100,
+		/* M */	0x0000, 0x01FF, 0x01FF, 0x003C, 0x00F0, 0x00F0, 0x003C, 0x01FF, 0x01FF,
+		/* N */	0x0000, 0x01FF, 0x01FF, 0x001E, 0x0038, 0x00E0, 0x01FF, 0x01FF,
+		/* O */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0101, 0x0101, 0x01FF, 0x00FE,
+		/* P */	0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x001F, 0x000E,
+		/* Q */	0x0000, 0x00FE, 0x01FF, 0x0101, 0x0141, 0x01C1, 0x03FF, 0x02FE,
+		/* R */	0x0000, 0x01FF, 0x01FF, 0x0011, 0x0011, 0x0011, 0x01FF, 0x01EE,
+		/* S */	0x0000, 0x008E, 0x019F, 0x0111, 0x0111, 0x01F3, 0x00E2,
+		/* T */	0x0000, 0x0001, 0x0001, 0x01FF, 0x01FF, 0x0001, 0x0001,
+		/* U */	0x0000, 0x00FF, 0x01FF, 0x0100, 0x0100, 0x0100, 0x01FF, 0x00FF,
+		/* V */	0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x001F, 0x0003,
+		/* W */	0x0003, 0x001F, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x007C, 0x01E0, 0x01E0, 0x007C, 0x001F, 0x0003,
+		/* X */	0x0183, 0x01C7, 0x006C, 0x0038, 0x0038, 0x006C, 0x01C7, 0x0183,
+		/* Y */	0x0003, 0x0007, 0x000C, 0x01F8, 0x01F8, 0x000C, 0x0007, 0x0003,
+		/* Z */	0x0181, 0x01C1, 0x0161, 0x0131, 0x0119, 0x010D, 0x0107, 0x0103,
+		/* [ */	0x0000, 0x07FF, 0x07FF, 0x0401,
+		/* \ */	0x0000, 0x0007, 0x001F, 0x0078, 0x01E0, 0x0180,
+		/* ] */	0x0000, 0x0401, 0x07FF, 0x07FF,
+		/* ^ */	0x0000, 0x0002, 0x0003, 0x0001, 0x0001, 0x0003, 0x0002,
+		/* _ */	0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+		/* ` */	0x0000, 0x0001, 0x0003, 0x0002,
+		/* a */	0x0000, 0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0,
+		/* b */	0x0000, 0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* c */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x0198, 0x0090,
+		/* d */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF,
+		/* e */	0x0000, 0x00F0, 0x01F8, 0x0128, 0x0128, 0x01B8, 0x00B0,
+		/* f */	0x0000, 0x01FE, 0x01FF, 0x0009,
+		/* g */	0x0000, 0x04F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8,
+		/* h */	0x0000, 0x01FF, 0x01FF, 0x0018, 0x0008, 0x01F8, 0x01F0,
+		/* i */	0x0000, 0x01F9, 0x01F9,
+		/* j */	0x0000, 0x07F9, 0x07F9,
+		/* k */	0x0000, 0x01FF, 0x01FF, 0x0070, 0x00D8, 0x0188, 0x0100,
+		/* l */	0x0000, 0x01FF, 0x01FF,
+		/* m */	0x0000, 0x01F8, 0x01F8, 0x0008, 0x01F8, 0x01F8, 0x0008, 0x01F8, 0x01F0,
+		/* n */	0x0000, 0x01F8, 0x01F8, 0x0018, 0x0008, 0x01F8, 0x01F0,
+		/* o */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* p */	0x0000, 0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* q */	0x0000, 0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8,
+		/* r */	0x0000, 0x01F8, 0x01F8, 0x0008,
+		/* s */	0x0000, 0x0090, 0x01B8, 0x0168, 0x01D8, 0x0090,
+		/* t */	0x0000, 0x00FE, 0x01FE, 0x0108,
+		/* u */	0x0000, 0x00F8, 0x01F8, 0x0100, 0x0180, 0x01F8, 0x01F8,
+		/* v */	0x0000, 0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018,
+		/* w */	0x0000, 0x0078, 0x01F8, 0x01E0, 0x0078, 0x0078, 0x01E0, 0x01F8, 0x0078,
+		/* x */	0x0000, 0x0198, 0x01F8, 0x0060, 0x01F8, 0x0198,
+		/* y */	0x0400, 0x0478, 0x07F8, 0x0380, 0x00F8, 0x0078,
+		/* z */	0x0000, 0x0188, 0x01C8, 0x0168, 0x0138, 0x0118,
+		/* { */	0x0000, 0x0010, 0x01FF, 0x03EF, 0x0200,
+		/* | */	0x0000, 0x03FF, 0x03FF,
+		/* } */	0x0000, 0x0200, 0x03EF, 0x01FF, 0x0010,
+		/* ~ */	0x0000, 0x0004, 0x0006, 0x0002, 0x0006, 0x0004, 0x0006, 0x0002
+	};
+#endif
+
+/* fontLarger - Tahoma, 11, Bold */
+#if GDISP_INCLUDE_FONT_LARGER
+    /* Forward Declarations of internal arrays */
+    static const uint8_t        fontLarger_Widths[];
+    static const uint16_t       fontLarger_Offsets[];
+    static const fontcolumn_t   fontLarger_Data[];
+
+    static const struct font fontLarger = {
+									"Larger",
+									12, 1, 13, 2, 2, 13, ' ', '~', 1, 1,
+									fontLarger_Widths,
+									fontLarger_Offsets,
+									fontLarger_Data};
+    static const struct font fontLargerDouble = {
+									"Larger Double",
+									12, 1, 13, 2, 2, 13, ' ', '~', 2, 2,
+									fontLarger_Widths,
+									fontLarger_Offsets,
+									fontLarger_Data};
+    static const struct font fontLargerNarrow = {
+									"Larger Narrow",
+									12, 1, 13, 2, 2, 13, ' ', '~', 1, 2,
+									fontLarger_Widths,
+									fontLarger_Offsets,
+									fontLarger_Data};
+	static const uint8_t fontLarger_Widths[] = {
+		2, 3, 5, 8, 7, 13, 8, 2, 4, 4, 7, 8, 3, 4, 3, 5,
+		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 9, 8, 9, 6,
+		9, 8, 7, 7, 8, 6, 5, 7, 8, 4, 5, 7, 6, 10, 7, 8,
+		7, 8, 8, 7, 6, 7, 7, 11, 7, 6, 6, 4, 5, 4, 9, 8,
+		5, 6, 7, 5, 7, 6, 5, 7, 7, 2, 3, 6, 2, 10, 7, 7,
+		7, 7, 4, 5, 5, 7, 6, 10, 6, 6, 5, 6, 4, 6, 9, 0
+	};
+	static const uint16_t fontLarger_Offsets[] = {
+		0, 2, 5, 10, 18, 25, 38, 46,
+		48, 52, 56, 63, 71, 74, 78, 81,
+		86, 93, 100, 107, 114, 121, 128, 135,
+		142, 149, 156, 159, 162, 171, 179, 188,
+		194, 203, 211, 218, 225, 233, 239, 244,
+		251, 259, 263, 268, 275, 281, 291, 298,
+		306, 313, 321, 329, 336, 342, 349, 356,
+		367, 374, 380, 386, 390, 395, 399, 408,
+		416, 421, 427, 434, 439, 446, 452, 457,
+		464, 471, 473, 476, 482, 484, 494, 501,
+		508, 515, 522, 526, 531, 536, 543, 549,
+		559, 565, 571, 576, 582, 586, 592, 0
+	};
+	static const fontcolumn_t fontLarger_Data[] = {
+		/*   */	0x0000, 0x0000,
+		/* ! */	0x0000, 0x037E, 0x037E,
+		/* " */	0x0007, 0x0007, 0x0000, 0x0007, 0x0007,
+		/* # */	0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018,
+		/* $ */	0x0118, 0x023C, 0x0264, 0x0FFF, 0x0264, 0x03C4, 0x0188,
+		/* % */	0x001C, 0x003E, 0x0022, 0x023E, 0x011C, 0x00C0, 0x0020, 0x0018, 0x01C4, 0x03E2, 0x0220, 0x03E0,
+				0x01C0,
+		/* & */	0x01CC, 0x03FE, 0x0232, 0x0272, 0x03DE, 0x018C, 0x03E0, 0x0260,
+		/* ' */	0x0007, 0x0007,
+		/* ( */	0x01F8, 0x07FE, 0x0E07, 0x0801,
+		/* ) */	0x0801, 0x0E07, 0x07FE, 0x01F8,
+		/* * */	0x0000, 0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A,
+		/* + */	0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020,
+		/* , */	0x0000, 0x0F00, 0x0700,
+		/* - */	0x0020, 0x0020, 0x0020, 0x0020,
+		/* . */	0x0000, 0x0300, 0x0300,
+		/* / */	0x0C00, 0x0380, 0x0060, 0x001C, 0x0003,
+		/* 0 */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC,
+		/* 1 */	0x0000, 0x0204, 0x0204, 0x03FE, 0x03FE, 0x0200, 0x0200,
+		/* 2 */	0x0204, 0x0302, 0x0382, 0x02C2, 0x0262, 0x023E, 0x021C,
+		/* 3 */	0x0104, 0x0202, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,
+		/* 4 */	0x0060, 0x0050, 0x0048, 0x0044, 0x03FE, 0x03FE, 0x0040,
+		/* 5 */	0x0100, 0x021E, 0x021E, 0x0212, 0x0212, 0x03F2, 0x01E2,
+		/* 6 */	0x01F8, 0x03FC, 0x0216, 0x0212, 0x0212, 0x03F2, 0x01E0,
+		/* 7 */	0x0002, 0x0002, 0x0382, 0x03E2, 0x007A, 0x001E, 0x0006,
+		/* 8 */	0x01DC, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,
+		/* 9 */	0x003C, 0x027E, 0x0242, 0x0242, 0x0342, 0x01FE, 0x00FC,
+		/* : */	0x0000, 0x0318, 0x0318,
+		/* ; */	0x0000, 0x0F18, 0x0718,
+		/* < */	0x0000, 0x0060, 0x0060, 0x0090, 0x0090, 0x0108, 0x0108, 0x0204, 0x0204,
+		/* = */	0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090,
+		/* > */	0x0000, 0x0204, 0x0204, 0x0108, 0x0108, 0x0090, 0x0090, 0x0060, 0x0060,
+		/* ? */	0x0004, 0x0002, 0x0362, 0x0372, 0x001E, 0x000C,
+		/* @ */	0x01F8, 0x0204, 0x04F2, 0x05FA, 0x050A, 0x04FA, 0x05FA, 0x0104, 0x00F8,
+		/* A */	0x0380, 0x03F0, 0x00FC, 0x008E, 0x008E, 0x00FC, 0x03F0, 0x0380,
+		/* B */	0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x03FE, 0x01DC,
+		/* C */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x018C,
+		/* D */	0x03FE, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0306, 0x01FC, 0x00F8,
+		/* E */	0x03FE, 0x03FE, 0x0222, 0x0222, 0x0222, 0x0222,
+		/* F */	0x03FE, 0x03FE, 0x0022, 0x0022, 0x0022,
+		/* G */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0222, 0x03E2, 0x03EC,
+		/* H */	0x03FE, 0x03FE, 0x0020, 0x0020, 0x0020, 0x0020, 0x03FE, 0x03FE,
+		/* I */	0x0202, 0x03FE, 0x03FE, 0x0202,
+		/* J */	0x0200, 0x0202, 0x0202, 0x03FE, 0x01FE,
+		/* K */	0x03FE, 0x03FE, 0x0070, 0x00D8, 0x018C, 0x0306, 0x0202,
+		/* L */	0x03FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x0200,
+		/* M */	0x03FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x0030, 0x0018, 0x000C, 0x03FE, 0x03FE,
+		/* N */	0x03FE, 0x000E, 0x001C, 0x0070, 0x01E0, 0x0380, 0x03FE,
+		/* O */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0202, 0x0202, 0x03FE, 0x01FC,
+		/* P */	0x03FE, 0x03FE, 0x0042, 0x0042, 0x0042, 0x007E, 0x003C,
+		/* Q */	0x01FC, 0x03FE, 0x0202, 0x0202, 0x0602, 0x0E02, 0x0BFE, 0x09FC,
+		/* R */	0x03FE, 0x03FE, 0x0022, 0x0062, 0x00E2, 0x01BE, 0x031C, 0x0200,
+		/* S */	0x019C, 0x023E, 0x0222, 0x0222, 0x0222, 0x03E2, 0x01CC,
+		/* T */	0x0002, 0x0002, 0x03FE, 0x03FE, 0x0002, 0x0002,
+		/* U */	0x01FE, 0x03FE, 0x0200, 0x0200, 0x0200, 0x03FE, 0x01FE,
+		/* V */	0x000E, 0x007E, 0x03F0, 0x0380, 0x03F0, 0x007E, 0x000E,
+		/* W */	0x001E, 0x00FE, 0x03E0, 0x03E0, 0x00FC, 0x000E, 0x00FC, 0x03E0, 0x03E0, 0x00FE, 0x001E,
+		/* X */	0x0306, 0x038E, 0x00F8, 0x0070, 0x00F8, 0x038E, 0x0306,
+		/* Y */	0x000E, 0x003E, 0x03F0, 0x03F0, 0x003E, 0x000E,
+		/* Z */	0x0382, 0x03C2, 0x0262, 0x0232, 0x021E, 0x020E,
+		/* [ */	0x0FFF, 0x0FFF, 0x0801, 0x0801,
+		/* \ */	0x0003, 0x001C, 0x0060, 0x0380, 0x0C00,
+		/* ] */	0x0801, 0x0801, 0x0FFF, 0x0FFF,
+		/* ^ */	0x0000, 0x0010, 0x0008, 0x0004, 0x0002, 0x0002, 0x0004, 0x0008, 0x0010,
+		/* _ */	0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800,
+		/* ` */	0x0000, 0x0000, 0x0001, 0x0003, 0x0002,
+		/* a */	0x0180, 0x03D0, 0x0248, 0x0248, 0x03F8, 0x03F0,
+		/* b */	0x03FF, 0x03FF, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0,
+		/* c */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208,
+		/* d */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x03FF, 0x03FF,
+		/* e */	0x01F0, 0x03F8, 0x0248, 0x0248, 0x0278, 0x0170,
+		/* f */	0x0008, 0x03FE, 0x03FF, 0x0009, 0x0001,
+		/* g */	0x01F0, 0x0BF8, 0x0A08, 0x0A08, 0x0908, 0x0FF8, 0x07F8,
+		/* h */	0x03FF, 0x03FF, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0,
+		/* i */	0x03FA, 0x03FA,
+		/* j */	0x0808, 0x0FFA, 0x07FA,
+		/* k */	0x03FF, 0x03FF, 0x00E0, 0x01B0, 0x0318, 0x0208,
+		/* l */	0x03FF, 0x03FF,
+		/* m */	0x03F8, 0x03F8, 0x0008, 0x0008, 0x03F8, 0x03F0, 0x0008, 0x0008, 0x03F8, 0x03F0,
+		/* n */	0x03F8, 0x03F8, 0x0010, 0x0008, 0x0008, 0x03F8, 0x03F0,
+		/* o */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0208, 0x03F8, 0x01F0,
+		/* p */	0x0FF8, 0x0FF8, 0x0210, 0x0208, 0x0208, 0x03F8, 0x01F0,
+		/* q */	0x01F0, 0x03F8, 0x0208, 0x0208, 0x0108, 0x0FF8, 0x0FF8,
+		/* r */	0x03F8, 0x03F8, 0x0010, 0x0018,
+		/* s */	0x0130, 0x0278, 0x0248, 0x03C8, 0x0190,
+		/* t */	0x0008, 0x01FE, 0x03FE, 0x0208, 0x0208,
+		/* u */	0x01F8, 0x03F8, 0x0200, 0x0200, 0x0100, 0x03F8, 0x03F8,
+		/* v */	0x0038, 0x00F8, 0x03C0, 0x03C0, 0x00F8, 0x0038,
+		/* w */	0x0018, 0x00F8, 0x03E0, 0x0380, 0x00F8, 0x00F8, 0x0380, 0x03E0, 0x00F8, 0x0018,
+		/* x */	0x0318, 0x03B8, 0x00E0, 0x00E0, 0x03B8, 0x0318,
+		/* y */	0x0038, 0x0CF8, 0x0FC0, 0x03C0, 0x00F8, 0x0038,
+		/* z */	0x0388, 0x03C8, 0x0268, 0x0238, 0x0218,
+		/* { */	0x0020, 0x0020, 0x07FE, 0x0FDF, 0x0801, 0x0801,
+		/* | */	0x0000, 0x0000, 0x0FFF, 0x0FFF,
+		/* } */	0x0801, 0x0801, 0x0FDF, 0x07FE, 0x0020, 0x0020,
+		/* ~ */	0x00E0, 0x0030, 0x0030, 0x0030, 0x0060, 0x00C0, 0x00C0, 0x00C0, 0x0070
+	};
+#endif
+
+/* fontUI1 - UI Font 1 Medium Bold */
+#if GDISP_INCLUDE_FONT_UI1
+	/* Forward Declarations of internal arrays */
+    static const uint8_t        fontUI1_Widths[];
+    static const uint16_t       fontUI1_Offsets[];
+    static const fontcolumn_t   fontUI1_Data[];
+
+    static const struct font fontUI1 = {
+									"UI1",
+									13, 0, 15, 2, 3, 13, ' ', '~', 1, 1,
+									fontUI1_Widths,
+									fontUI1_Offsets,
+									fontUI1_Data};
+    static const struct font fontUI1Double = {
+									"UI1 Double",
+									13, 0, 15, 2, 3, 13, ' ', '~', 2, 2,
+									fontUI1_Widths,
+									fontUI1_Offsets,
+									fontUI1_Data};
+    static const struct font fontUI1Narrow = {
+									"UI1 Narrow",
+									13, 0, 15, 2, 3, 13, ' ', '~', 1, 2,
+									fontUI1_Widths,
+									fontUI1_Offsets,
+									fontUI1_Data};
+
+	static const uint8_t fontUI1_Widths[] = {
+		3, 3, 6, 8, 7, 13, 9, 3, 5, 5, 6, 8, 3, 5, 3, 7,
+		7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 3, 3, 8, 8, 8, 6,
+		10, 8, 7, 7, 8, 7, 7, 8, 8, 5, 5, 7, 7, 9, 8, 8,
+		7, 8, 8, 7, 8, 8, 7, 11, 7, 7, 7, 5, 7, 5, 9, 8,
+		5, 7, 7, 6, 7, 7, 5, 7, 7, 3, 4, 7, 3, 11, 7, 7,
+		7, 7, 6, 6, 5, 7, 7, 9, 7, 7, 6, 7, 4, 7, 8, 0
+	};
+	static const uint16_t fontUI1_Offsets[] = {
+		0, 3, 6, 12, 20, 27, 40, 49,
+		52, 57, 62, 68, 76, 79, 84, 87,
+		94, 101, 108, 115, 122, 129, 136, 143,
+		150, 157, 164, 167, 170, 178, 186, 194,
+		200, 210, 218, 225, 232, 240, 247, 254,
+		262, 270, 275, 280, 287, 294, 303, 311,
+		319, 326, 334, 342, 349, 357, 365, 372,
+		383, 390, 397, 404, 409, 416, 421, 430,
+		438, 443, 450, 457, 463, 470, 477, 482,
+		489, 496, 499, 503, 510, 513, 524, 531,
+		538, 545, 552, 558, 564, 569, 576, 583,
+		592, 599, 606, 612, 619, 623, 630, 0
+	};
+	static const fontcolumn_t fontUI1_Data[] = {
+		/*   */	0x0000, 0x0000, 0x0000,
+		/* ! */	0x0000, 0x02FC, 0x02FC,
+		/* " */	0x0000, 0x000E, 0x000E, 0x0000, 0x000E, 0x000E,
+		/* # */	0x0000, 0x0080, 0x0390, 0x00F0, 0x039C, 0x00F0, 0x009C, 0x0010,
+		/* $ */	0x0000, 0x0130, 0x0278, 0x0FC8, 0x027E, 0x03C8, 0x0190,
+		/* % */	0x0000, 0x0038, 0x007C, 0x0044, 0x007C, 0x0338, 0x00C0, 0x0030, 0x01CC, 0x03E0, 0x0220, 0x03E0,
+				0x01C0,
+		/* & */	0x0000, 0x01D8, 0x03FC, 0x0224, 0x027C, 0x02D8, 0x0180, 0x0360, 0x0220,
+		/* ' */	0x0000, 0x000E, 0x000E,
+		/* ( */	0x0000, 0x01F0, 0x07FC, 0x0E0E, 0x0802,
+		/* ) */	0x0000, 0x0802, 0x0E0E, 0x07FC, 0x01F0,
+		/* * */	0x0000, 0x0014, 0x0008, 0x003E, 0x0008, 0x0014,
+		/* + */	0x0000, 0x0040, 0x0040, 0x0040, 0x03F8, 0x0040, 0x0040, 0x0040,
+		/* , */	0x0000, 0x0F00, 0x0700,
+		/* - */	0x0000, 0x0040, 0x0040, 0x0040, 0x0040,
+		/* . */	0x0000, 0x0300, 0x0300,
+		/* / */	0x0000, 0x0C00, 0x0F00, 0x03E0, 0x00F8, 0x001E, 0x0006,
+		/* 0 */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x03FC, 0x01F8,
+		/* 1 */	0x0000, 0x0000, 0x0208, 0x03FC, 0x03FC, 0x0200, 0x0000,
+		/* 2 */	0x0000, 0x0308, 0x038C, 0x02C4, 0x0264, 0x023C, 0x0218,
+		/* 3 */	0x0000, 0x0108, 0x030C, 0x0224, 0x0224, 0x03FC, 0x01D8,
+		/* 4 */	0x0000, 0x00C0, 0x00A0, 0x0090, 0x03F8, 0x03FC, 0x0080,
+		/* 5 */	0x0000, 0x0100, 0x033C, 0x023C, 0x0224, 0x03E4, 0x01C4,
+		/* 6 */	0x0000, 0x01F0, 0x03F8, 0x022C, 0x0224, 0x03E4, 0x01C0,
+		/* 7 */	0x0000, 0x0004, 0x0304, 0x03C4, 0x00F4, 0x003C, 0x000C,
+		/* 8 */	0x0000, 0x01D8, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8,
+		/* 9 */	0x0000, 0x0038, 0x027C, 0x0244, 0x0344, 0x01FC, 0x00F8,
+		/* : */	0x0000, 0x0330, 0x0330,
+		/* ; */	0x0000, 0x0F30, 0x0730,
+		/* < */	0x0000, 0x0040, 0x00A0, 0x00A0, 0x0110, 0x0110, 0x0208, 0x0208,
+		/* = */	0x0000, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090, 0x0090,
+		/* > */	0x0000, 0x0208, 0x0208, 0x0110, 0x0110, 0x00A0, 0x00A0, 0x0040,
+		/* ? */	0x0000, 0x0008, 0x02C4, 0x02E4, 0x003C, 0x0018,
+		/* @ */	0x0000, 0x01F0, 0x0208, 0x04E4, 0x05F4, 0x0514, 0x05F4, 0x05F4, 0x0104, 0x00F8,
+		/* A */	0x0000, 0x0380, 0x03F0, 0x00FC, 0x008C, 0x00FC, 0x03F0, 0x0380,
+		/* B */	0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x03FC, 0x01D8,
+		/* C */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x0108,
+		/* D */	0x0000, 0x03FC, 0x03FC, 0x0204, 0x0204, 0x030C, 0x01F8, 0x00F0,
+		/* E */	0x0000, 0x03FC, 0x03FC, 0x0224, 0x0224, 0x0224, 0x0224,
+		/* F */	0x0000, 0x03FC, 0x03FC, 0x0024, 0x0024, 0x0024, 0x0024,
+		/* G */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0244, 0x03C4, 0x03C8,
+		/* H */	0x0000, 0x03FC, 0x03FC, 0x0020, 0x0020, 0x0020, 0x03FC, 0x03FC,
+		/* I */	0x0000, 0x0204, 0x03FC, 0x03FC, 0x0204,
+		/* J */	0x0200, 0x0204, 0x0204, 0x03FC, 0x01FC,
+		/* K */	0x0000, 0x03FC, 0x03FC, 0x00F0, 0x0198, 0x030C, 0x0204,
+		/* L */	0x0000, 0x03FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x0200,
+		/* M */	0x0000, 0x03FC, 0x001C, 0x0038, 0x0070, 0x0020, 0x0010, 0x03F8, 0x03FC,
+		/* N */	0x0000, 0x03FC, 0x0018, 0x0030, 0x0060, 0x00C0, 0x0180, 0x03FC,
+		/* O */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0204, 0x0204, 0x03FC, 0x01F8,
+		/* P */	0x0000, 0x03FC, 0x03FC, 0x0044, 0x0044, 0x007C, 0x0038,
+		/* Q */	0x0000, 0x01F8, 0x03FC, 0x0204, 0x0604, 0x0E04, 0x0BFC, 0x09F8,
+		/* R */	0x0000, 0x03FC, 0x03FC, 0x0044, 0x00C4, 0x01FC, 0x0338, 0x0200,
+		/* S */	0x0000, 0x0138, 0x027C, 0x0264, 0x0264, 0x03E4, 0x01C8,
+		/* T */	0x0004, 0x0004, 0x0004, 0x03FC, 0x03FC, 0x0004, 0x0004, 0x0004,
+		/* U */	0x0000, 0x01FC, 0x03FC, 0x0200, 0x0200, 0x0200, 0x03FC, 0x01FC,
+		/* V */	0x0000, 0x001C, 0x00FC, 0x03E0, 0x03E0, 0x00FC, 0x001C,
+		/* W */	0x0000, 0x001C, 0x00FC, 0x03E0, 0x03C0, 0x007C, 0x007C, 0x03C0, 0x03E0, 0x00FC, 0x001C,
+		/* X */	0x0000, 0x030C, 0x039C, 0x00F0, 0x00F0, 0x039C, 0x030C,
+		/* Y */	0x0000, 0x000C, 0x003C, 0x03F0, 0x03F0, 0x003C, 0x000C,
+		/* Z */	0x0000, 0x0384, 0x03C4, 0x02E4, 0x0274, 0x023C, 0x021C,
+		/* [ */	0x0000, 0x0FFE, 0x0FFE, 0x0802, 0x0802,
+		/* \ */	0x0000, 0x0006, 0x001E, 0x00F8, 0x03E0, 0x0F00, 0x0C00,
+		/* ] */	0x0000, 0x0802, 0x0802, 0x0FFE, 0x0FFE,
+		/* ^ */	0x0000, 0x0020, 0x0030, 0x0018, 0x000C, 0x000C, 0x0018, 0x0030, 0x0020,
+		/* _ */	0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800, 0x0800,
+		/* ` */	0x0000, 0x0000, 0x0002, 0x0006, 0x0004,
+		/* a */	0x0000, 0x0180, 0x03D0, 0x0250, 0x0250, 0x03F0, 0x03E0,
+		/* b */	0x0000, 0x03FE, 0x03FE, 0x0210, 0x0210, 0x03F0, 0x01E0,
+		/* c */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0210,
+		/* d */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03FE, 0x03FE,
+		/* e */	0x0000, 0x01E0, 0x03F0, 0x0250, 0x0250, 0x0270, 0x0160,
+		/* f */	0x0010, 0x03FC, 0x03FE, 0x0012, 0x0012,
+		/* g */	0x0000, 0x01E0, 0x0BF0, 0x0A10, 0x0A10, 0x0FF0, 0x07F0,
+		/* h */	0x0000, 0x03FE, 0x03FE, 0x0010, 0x0010, 0x03F0, 0x03E0,
+		/* i */	0x0000, 0x03F4, 0x03F4,
+		/* j */	0x0800, 0x0810, 0x0FF4, 0x07F4,
+		/* k */	0x0000, 0x03FE, 0x03FE, 0x00C0, 0x01E0, 0x0330, 0x0210,
+		/* l */	0x0000, 0x03FE, 0x03FE,
+		/* m */	0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0, 0x0010, 0x0010, 0x03F0, 0x03E0,
+		/* n */	0x0000, 0x03F0, 0x03F0, 0x0010, 0x0010, 0x03F0, 0x03E0,
+		/* o */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x03F0, 0x01E0,
+		/* p */	0x0000, 0x0FF0, 0x0FF0, 0x0210, 0x0210, 0x03F0, 0x01E0,
+		/* q */	0x0000, 0x01E0, 0x03F0, 0x0210, 0x0210, 0x0FF0, 0x0FF0,
+		/* r */	0x0000, 0x03F0, 0x03F0, 0x0020, 0x0030, 0x0030,
+		/* s */	0x0000, 0x0260, 0x02F0, 0x02D0, 0x03D0, 0x0190,
+		/* t */	0x0010, 0x01FC, 0x03FC, 0x0210, 0x0210,
+		/* u */	0x0000, 0x01F0, 0x03F0, 0x0200, 0x0200, 0x03F0, 0x03F0,
+		/* v */	0x0000, 0x0070, 0x01F0, 0x0380, 0x0380, 0x01F0, 0x0070,
+		/* w */	0x0000, 0x00F0, 0x03F0, 0x0300, 0x00F0, 0x00F0, 0x0300, 0x03F0, 0x00F0,
+		/* x */	0x0000, 0x0330, 0x03F0, 0x00C0, 0x00C0, 0x03F0, 0x0330,
+		/* y */	0x0000, 0x0030, 0x0CF0, 0x0FC0, 0x03C0, 0x00F0, 0x0030,
+		/* z */	0x0000, 0x0310, 0x0390, 0x02D0, 0x0270, 0x0230,
+		/* { */	0x0000, 0x0040, 0x0040, 0x07FC, 0x0FBE, 0x0802, 0x0802,
+		/* | */	0x0000, 0x0000, 0x0FFE, 0x0FFE,
+		/* } */	0x0000, 0x0802, 0x0802, 0x0FBE, 0x07FC, 0x0040, 0x0040,
+		/* ~ */	0x0000, 0x01C0, 0x0020, 0x0020, 0x00C0, 0x0100, 0x0100, 0x00E0
+	};
+#endif
+
+/* fontUI1 - UI Font 2 Medium Bold */
+#if GDISP_INCLUDE_FONT_UI2
+	/* Forward Declarations of internal arrays */
+	static const uint8_t        fontUI2_Widths[];
+	static const uint16_t       fontUI2_Offsets[];
+	static const fontcolumn_t   fontUI2_Data[];
+
+	static const struct font fontUI2 = {
+									"UI2",
+									11, 1, 13, 2, 2, 12, ' ', '~', 1, 1,
+									fontUI2_Widths,
+									fontUI2_Offsets,
+									fontUI2_Data};
+	static const struct font fontUI2Double = {
+									"UI2 Double",
+									11, 1, 13, 2, 2, 12, ' ', '~', 2, 2,
+									fontUI2_Widths,
+									fontUI2_Offsets,
+									fontUI2_Data};
+	static const struct font fontUI2Narrow = {
+									"UI2 Narrow",
+									11, 1, 13, 2, 2, 12, ' ', '~', 1, 2,
+									fontUI2_Widths,
+									fontUI2_Offsets,
+									fontUI2_Data};
+
+	static const uint8_t fontUI2_Widths[] = {
+		2, 2, 5, 8, 6, 12, 8, 2, 4, 4, 6, 8, 2, 4, 2, 5,
+		6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 2, 2, 8, 8, 8, 5,
+		9, 7, 6, 6, 7, 5, 5, 7, 7, 4, 5, 6, 5, 9, 6, 7,
+		6, 7, 7, 6, 6, 7, 6, 10, 6, 6, 6, 4, 5, 4, 7, 7,
+		4, 6, 6, 5, 6, 6, 4, 6, 6, 2, 3, 6, 2, 10, 6, 6,
+		6, 6, 4, 5, 4, 6, 6, 8, 6, 6, 5, 6, 4, 6, 8, 0
+	};
+	static const uint16_t fontUI2_Offsets[] = {
+		0, 2, 4, 9, 17, 23, 35, 43,
+		45, 49, 53, 59, 67, 69, 73, 75,
+		80, 86, 92, 98, 104, 110, 116, 122,
+		128, 134, 140, 142, 144, 152, 160, 168,
+		173, 182, 189, 195, 201, 208, 213, 218,
+		225, 232, 236, 241, 247, 252, 261, 267,
+		274, 280, 287, 294, 300, 306, 313, 319,
+		329, 335, 341, 347, 351, 356, 360, 367,
+		374, 378, 384, 390, 395, 401, 407, 411,
+		417, 423, 425, 428, 434, 436, 446, 452,
+		458, 464, 470, 474, 479, 483, 489, 495,
+		503, 509, 515, 520, 526, 530, 536, 0
+	};
+	static const fontcolumn_t fontUI2_Data[] = {
+		/*   */	0x0000, 0x0000,
+		/* ! */	0x017E, 0x017E,
+		/* " */	0x0007, 0x0007, 0x0000, 0x0007, 0x0007,
+		/* # */	0x00C0, 0x03D8, 0x00F8, 0x00DE, 0x03D8, 0x00F8, 0x00DE, 0x0018,
+		/* $ */	0x0098, 0x013C, 0x07E4, 0x013F, 0x01E4, 0x00C8,
+		/* % */	0x001C, 0x003E, 0x0022, 0x003E, 0x019C, 0x0060, 0x0018, 0x00E6, 0x01F0, 0x0110, 0x01F0, 0x00E0,
+		/* & */	0x00EC, 0x01FE, 0x0112, 0x013E, 0x016C, 0x00C0, 0x01B0, 0x0110,
+		/* ' */	0x0007, 0x0007,
+		/* ( */	0x00F8, 0x03FE, 0x0707, 0x0401,
+		/* ) */	0x0401, 0x0707, 0x03FE, 0x00F8,
+		/* * */	0x000A, 0x0004, 0x001F, 0x001F, 0x0004, 0x000A,
+		/* + */	0x0000, 0x0020, 0x0020, 0x0020, 0x01FC, 0x0020, 0x0020, 0x0020,
+		/* , */	0x0780, 0x0380,
+		/* - */	0x0020, 0x0020, 0x0020, 0x0020,
+		/* . */	0x0180, 0x0180,
+		/* / */	0x0600, 0x0180, 0x0070, 0x000C, 0x0003,
+		/* 0 */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x01FE, 0x00FC,
+		/* 1 */	0x0000, 0x0104, 0x01FE, 0x01FE, 0x0100, 0x0000,
+		/* 2 */	0x0184, 0x01C6, 0x0162, 0x0132, 0x011E, 0x010C,
+		/* 3 */	0x0084, 0x0186, 0x0112, 0x0112, 0x01FE, 0x00EC,
+		/* 4 */	0x0060, 0x0050, 0x0048, 0x01FC, 0x01FE, 0x0040,
+		/* 5 */	0x0080, 0x019E, 0x011E, 0x0112, 0x01F2, 0x00E2,
+		/* 6 */	0x00FC, 0x01FE, 0x0112, 0x0112, 0x01F2, 0x00E0,
+		/* 7 */	0x0002, 0x0002, 0x01C2, 0x01FA, 0x003E, 0x0006,
+		/* 8 */	0x00EC, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC,
+		/* 9 */	0x001C, 0x013E, 0x0122, 0x0122, 0x01FE, 0x00FC,
+		/* : */	0x0198, 0x0198,
+		/* ; */	0x0798, 0x0398,
+		/* < */	0x0000, 0x0020, 0x0050, 0x0050, 0x0088, 0x0088, 0x0104, 0x0104,
+		/* = */	0x0000, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048, 0x0048,
+		/* > */	0x0000, 0x0104, 0x0104, 0x0088, 0x0088, 0x0050, 0x0050, 0x0020,
+		/* ? */	0x0004, 0x0162, 0x0172, 0x001E, 0x000C,
+		/* @ */	0x00F8, 0x0104, 0x0272, 0x02FA, 0x028A, 0x027A, 0x02FA, 0x0084, 0x0078,
+		/* A */	0x01C0, 0x01F8, 0x007E, 0x0046, 0x007E, 0x01F8, 0x01C0,
+		/* B */	0x01FE, 0x01FE, 0x0112, 0x0112, 0x01FE, 0x00EC,
+		/* C */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x0102,
+		/* D */	0x01FE, 0x01FE, 0x0102, 0x0102, 0x0186, 0x00FC, 0x0078,
+		/* E */	0x01FE, 0x01FE, 0x0112, 0x0112, 0x0112,
+		/* F */	0x01FE, 0x01FE, 0x0012, 0x0012, 0x0012,
+		/* G */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x0122, 0x01E2, 0x01E2,
+		/* H */	0x01FE, 0x01FE, 0x0010, 0x0010, 0x0010, 0x01FE, 0x01FE,
+		/* I */	0x0102, 0x01FE, 0x01FE, 0x0102,
+		/* J */	0x0100, 0x0102, 0x0102, 0x01FE, 0x00FE,
+		/* K */	0x01FE, 0x01FE, 0x0078, 0x00CC, 0x0186, 0x0102,
+		/* L */	0x01FE, 0x01FE, 0x0100, 0x0100, 0x0100,
+		/* M */	0x01FE, 0x000E, 0x001C, 0x0038, 0x0030, 0x0018, 0x000C, 0x01FE, 0x01FE,
+		/* N */	0x01FE, 0x000E, 0x001C, 0x0038, 0x0070, 0x01FE,
+		/* O */	0x00FC, 0x01FE, 0x0102, 0x0102, 0x0102, 0x01FE, 0x00FC,
+		/* P */	0x01FE, 0x01FE, 0x0022, 0x0022, 0x003E, 0x001C,
+		/* Q */	0x00FC, 0x01FE, 0x0102, 0x0302, 0x0702, 0x05FE, 0x04FC,
+		/* R */	0x01FE, 0x01FE, 0x0022, 0x0062, 0x00FE, 0x019C, 0x0100,
+		/* S */	0x011C, 0x013E, 0x0132, 0x0132, 0x01F2, 0x00E2,
+		/* T */	0x0002, 0x0002, 0x01FE, 0x01FE, 0x0002, 0x0002,
+		/* U */	0x00FE, 0x01FE, 0x0100, 0x0100, 0x0100, 0x01FE, 0x00FE,
+		/* V */	0x000E, 0x007E, 0x01F0, 0x01F0, 0x007E, 0x000E,
+		/* W */	0x000E, 0x007E, 0x01F0, 0x01E0, 0x003E, 0x003E, 0x01E0, 0x01F0, 0x007E, 0x000E,
+		/* X */	0x0186, 0x01CE, 0x0078, 0x0078, 0x01CE, 0x0186,
+		/* Y */	0x0006, 0x001E, 0x01F8, 0x01F8, 0x001E, 0x0006,
+		/* Z */	0x01C2, 0x01E2, 0x0172, 0x013A, 0x011E, 0x010E,
+		/* [ */	0x07FF, 0x07FF, 0x0401, 0x0401,
+		/* \ */	0x0003, 0x000C, 0x0070, 0x0180, 0x0600,
+		/* ] */	0x0401, 0x0401, 0x07FF, 0x07FF,
+		/* ^ */	0x0010, 0x0008, 0x0004, 0x0002, 0x0004, 0x0008, 0x0010,
+		/* _ */	0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400, 0x0400,
+		/* ` */	0x0000, 0x0001, 0x0003, 0x0002,
+		/* a */	0x00C0, 0x01E8, 0x0128, 0x0128, 0x01F8, 0x01F0,
+		/* b */	0x01FF, 0x01FF, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* c */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x0108,
+		/* d */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x01FF, 0x01FF,
+		/* e */	0x00F0, 0x01F8, 0x0128, 0x0128, 0x0138, 0x0130,
+		/* f */	0x01FE, 0x01FF, 0x0009, 0x0001,
+		/* g */	0x00F0, 0x05F8, 0x0508, 0x0508, 0x07F8, 0x03F8,
+		/* h */	0x01FF, 0x01FF, 0x0008, 0x0008, 0x01F8, 0x01F0,
+		/* i */	0x01FA, 0x01FA,
+		/* j */	0x0408, 0x07FA, 0x03FA,
+		/* k */	0x01FF, 0x01FF, 0x0060, 0x00F0, 0x0198, 0x0108,
+		/* l */	0x01FF, 0x01FF,
+		/* m */	0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0, 0x0008, 0x0008, 0x01F8, 0x01F0,
+		/* n */	0x01F8, 0x01F8, 0x0008, 0x0008, 0x01F8, 0x01F0,
+		/* o */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* p */	0x07F8, 0x07F8, 0x0108, 0x0108, 0x01F8, 0x00F0,
+		/* q */	0x00F0, 0x01F8, 0x0108, 0x0108, 0x07F8, 0x07F8,
+		/* r */	0x01F8, 0x01F8, 0x0010, 0x0018,
+		/* s */	0x0130, 0x0178, 0x0168, 0x01E8, 0x00C8,
+		/* t */	0x00FE, 0x01FE, 0x0108, 0x0108,
+		/* u */	0x00F8, 0x01F8, 0x0100, 0x0100, 0x01F8, 0x01F8,
+		/* v */	0x0018, 0x0078, 0x01E0, 0x01E0, 0x0078, 0x0018,
+		/* w */	0x0078, 0x01F8, 0x01C0, 0x0078, 0x0078, 0x01C0, 0x01F8, 0x0078,
+		/* x */	0x0198, 0x01F8, 0x0060, 0x0060, 0x01F8, 0x0198,
+		/* y */	0x0018, 0x0678, 0x07E0, 0x01E0, 0x0078, 0x0018,
+		/* z */	0x0188, 0x01C8, 0x0168, 0x0138, 0x0118,
+		/* { */	0x0020, 0x0020, 0x03FE, 0x07DF, 0x0401, 0x0401,
+		/* | */	0x0000, 0x0000, 0x07FF, 0x07FF,
+		/* } */	0x0401, 0x0401, 0x07DF, 0x03FE, 0x0020, 0x0020,
+		/* ~ */	0x0060, 0x0010, 0x0010, 0x0030, 0x0060, 0x0040, 0x0040, 0x0030
+	};
+#endif
+
+/*
+	fontLargeNumbers:
+		Large numbers font, height = 16 (including the decenders)
+		Characters include:  0 - 9, -, +, ., %, :, Space, Comma
+*/
+#if GDISP_INCLUDE_FONT_LARGENUMBERS
+	/* Forward Declarations of internal arrays */
+    static const uint8_t        fontLargeNumbers_Widths[];
+    static const uint16_t       fontLargeNumbers_Offsets[];
+    static const fontcolumn_t   fontLargeNumbers_Data[];
+
+    static const struct font fontLargeNumbers = {
+									"LargeNumbers",
+									16, 2, 21, 1, 3, 15, '%', ':', 1, 1,
+									fontLargeNumbers_Widths,
+									fontLargeNumbers_Offsets,
+									fontLargeNumbers_Data};
+    static const struct font fontLargeNumbersDouble = {
+									"LargeNumbers Double",
+									16, 2, 21, 1, 3, 15, '%', ':', 2, 2,
+									fontLargeNumbers_Widths,
+									fontLargeNumbers_Offsets,
+									fontLargeNumbers_Data};
+    static const struct font fontLargeNumbersNarrow = {
+									"LargeNumbers Narrow", 16, 2, 21, 1, 3, 15, '%', ':', 1, 2,
+									fontLargeNumbers_Widths,
+									fontLargeNumbers_Offsets,
+									fontLargeNumbers_Data};
+
+	static const uint8_t fontLargeNumbers_Widths[] = {
+		15, 0, 0, 0, 0, 0, 11, 3, 6, 3, 0, 10, 10, 10, 10, 10,
+		10, 10, 10, 10, 10, 4, 0, 0
+	};
+	static const uint16_t fontLargeNumbers_Offsets[] = {
+		0, 0, 0, 0, 0, 0, 15, 26,
+		29, 35, 0, 38, 48, 58, 68, 78,
+		88, 98, 108, 118, 128, 138, 0, 0
+	};
+	static const fontcolumn_t fontLargeNumbers_Data[] = {
+		/* % */	0x007E, 0x00FF, 0x00C3, 0x80C3, 0xE0FF, 0x7C7E, 0x1F00, 0x07C0, 0x00F0, 0x7E3E, 0xFF0F, 0xC303,
+				0xC300, 0xFF00, 0x7E00,
+		/* + */	0x01C0, 0x01C0, 0x01C0, 0x01C0, 0x1FFC, 0x1FFC, 0x1FFC, 0x01C0, 0x01C0, 0x01C0, 0x01C0,
+		/* , */	0x7000, 0x7000, 0xF000,
+		/* - */	0x0700, 0x0700, 0x0700, 0x0700, 0x0700, 0x0700,
+		/* . */	0x7000, 0x7000, 0x7000,
+		/* 0 */	0x0FF8, 0x3FFE, 0x3FFE, 0x7007, 0x6003, 0x6003, 0x7007, 0x3FFE, 0x3FFE, 0x0FF8,
+		/* 1 */	0x0000, 0x0070, 0x0038, 0x0038, 0x001C, 0x7FFF, 0x7FFF, 0x7FFF, 0x0000, 0x0000,
+		/* 2 */	0x600C, 0x700E, 0x7C0F, 0x7E07, 0x6F03, 0x6783, 0x63C7, 0x61FF, 0x60FE, 0x603C,
+		/* 3 */	0x180C, 0x380E, 0x780F, 0x70C3, 0x60C3, 0x60E3, 0x71FF, 0x3FFE, 0x3F3C, 0x0E00,
+		/* 4 */	0x0F00, 0x0DC0, 0x0CE0, 0x0C38, 0x0C1E, 0x7FFF, 0x7FFF, 0x7FFF, 0x0C00, 0x0C00,
+		/* 5 */	0x18C0, 0x38FC, 0x78FF, 0x707F, 0x6063, 0x6063, 0x70E3, 0x3FE3, 0x3FC3, 0x0F80,
+		/* 6 */	0x0FF8, 0x3FFE, 0x3FFE, 0x70C7, 0x6063, 0x6063, 0x70E7, 0x3FEF, 0x3FC6, 0x0F04,
+		/* 7 */	0x0003, 0x0003, 0x7803, 0x7F03, 0x7FC3, 0x07F3, 0x00FB, 0x003F, 0x000F, 0x0007,
+		/* 8 */	0x1E1C, 0x3F3E, 0x7FFF, 0x71E7, 0x60C3, 0x60C3, 0x71E7, 0x7FFF, 0x3F3E, 0x1E1C,
+		/* 9 */	0x1078, 0x39FE, 0x7BFE, 0x7387, 0x6303, 0x6303, 0x7187, 0x3FFE, 0x3FFE, 0x0FF8,
+		/* : */	0x0000, 0x0E38, 0x0E38, 0x0E38
+	};
+#endif
+
+static const struct font *BuiltinFontTable[] = {
+	#if GDISP_INCLUDE_FONT_SMALL
+		&fontSmall, &fontSmallDouble, &fontSmallNarrow,
+	#endif
+	#if GDISP_INCLUDE_FONT_LARGER
+		&fontLarger, &fontLargerDouble, &fontLargerNarrow,
+	#endif
+	#if GDISP_INCLUDE_FONT_UI1
+		&fontUI1, &fontUI1Double, &fontUI1Narrow,
+	#endif
+	#if GDISP_INCLUDE_FONT_UI2
+		&fontUI2, &fontUI2Double, &fontUI2Narrow,
+	#endif
+	#if GDISP_INCLUDE_FONT_LARGENUMBERS
+		&fontLargeNumbers, &fontLargeNumbersDouble, &fontLargeNumbersNarrow,
+	#endif
+	};
+
+/**
+ * Match a pattern against the font name.
+ */
+static bool_t matchfont(const char *pattern, const char *name) {
+	while(1) {
+		switch (pattern[0]) {
+		case '*':
+			if (name[0] == 0)
+				return pattern[1] == 0;
+			if (pattern[1] == name[0])
+				pattern++;
+			else
+				name++;
+			break;
+		case 0:
+			return name[0] == 0;
+		default:
+			if (name[0] != pattern[0])
+				return FALSE;
+			pattern++;
+			name++;
+			break;
+		}
+	}
+}
+
+font_t gdispOpenFont(const char *name) {
+	const struct font **p;
+
+	for(p = BuiltinFontTable; p < BuiltinFontTable+sizeof(BuiltinFontTable)/sizeof(BuiltinFontTable[0]); p++) {
+		if (matchfont(name, p[0]->name))
+			return p[0];
+	}
+	return 0;
+}
+
+void gdispCloseFont(font_t font) {
+	(void) font;
+}
+
+const char *gdispGetFontName(font_t font) {
+	return font->name;
+}
+
+#endif /* GFX_USE_GDISP && GDISP_NEED_TEXT */
+/** @} */
diff --git a/src/gdisp/gdisp.c b/src/gdisp/gdisp.c
index 8cccad29..f18bb66f 100644
--- a/src/gdisp/gdisp.c
+++ b/src/gdisp/gdisp.c
@@ -29,12 +29,15 @@
 #include "hal.h"
 #include "gfx.h"
 
-#if GFX_USE_GDISP || defined(__DOXYGEN__)
+#if GFX_USE_GDISP
 
 #ifdef GDISP_NEED_TEXT
 	#include "gdisp/fonts.h"
 #endif
 
+/* Include the low level driver information */
+#include "gdisp/lld/gdisp_lld.h"
+
 /*===========================================================================*/
 /* Driver local definitions.                                                 */
 /*===========================================================================*/
@@ -135,16 +138,7 @@
 /* Driver exported functions.                                                */
 /*===========================================================================*/
 
-#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
-	 */
+#if GDISP_NEED_MULTITHREAD
 	bool_t gdispInit(void) {
 		bool_t	res;
 
@@ -187,16 +181,7 @@
 	}
 #endif
 
-#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
-	 */
+#if GDISP_NEED_MULTITHREAD
 	bool_t gdispIsBusy(void) {
 		return FALSE;
 	}
@@ -206,14 +191,7 @@
 	}
 #endif
 
-#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
-	 */
+#if GDISP_NEED_MULTITHREAD
 	void gdispClear(color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_clear(color);
@@ -227,15 +205,7 @@
 	}
 #endif
 
-#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
-	 */
+#if GDISP_NEED_MULTITHREAD
 	void gdispDrawPixel(coord_t x, coord_t y, color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_draw_pixel(x, y, color);
@@ -251,16 +221,7 @@
 	}
 #endif
 	
-#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
-	 */
+#if GDISP_NEED_MULTITHREAD
 	void gdispDrawLine(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_draw_line(x0, y0, x1, y1, color);
@@ -278,16 +239,7 @@
 	}
 #endif
 
-#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
-	 */
+#if GDISP_NEED_MULTITHREAD
 	void gdispFillArea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_fill_area(x, y, cx, cy, color);
@@ -305,25 +257,7 @@
 	}
 #endif
 	
-#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
-	 */
+#if GDISP_NEED_MULTITHREAD
 	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);
 		gdisp_lld_blit_area_ex(x, y, cx, cy, srcx, srcy, srccx, buffer);
@@ -344,15 +278,7 @@
 	}
 #endif
 	
-#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
-	 */
+#if (GDISP_NEED_CLIP && GDISP_NEED_MULTITHREAD)
 	void gdispSetClip(coord_t x, coord_t y, coord_t cx, coord_t cy) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_set_clip(x, y, cx, cy);
@@ -369,16 +295,7 @@
 	}
 #endif
 
-#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
-	 */
+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD)
 	void gdispDrawCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_draw_circle(x, y, radius, color);
@@ -395,16 +312,7 @@
 	}
 #endif
 	
-#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
-	 */
+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD)
 	void gdispFillCircle(coord_t x, coord_t y, coord_t radius, color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_fill_circle(x, y, radius, color);
@@ -421,16 +329,7 @@
 	}
 #endif
 
-#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
-	 */
+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD)
 	void gdispDrawEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_draw_ellipse(x, y, a, b, color);
@@ -448,16 +347,7 @@
 	}
 #endif
 	
-#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
-	 */
+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD)
 	void gdispFillEllipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_fill_ellipse(x, y, a, b, color);
@@ -475,18 +365,7 @@
 	}
 #endif
 
-#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
-	 */
+#if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD)
 	void gdispDrawArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_draw_arc(x, y, radius, start, end, color);
@@ -505,19 +384,7 @@
 	}
 #endif
 
-#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
-	 */
+#if (GDISP_NEED_ARC && GDISP_NEED_MULTITHREAD)
 	void gdispFillArc(coord_t x, coord_t y, coord_t radius, coord_t start, coord_t end, color_t color) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_fill_arc(x, y, radius, start, end, color);
@@ -536,17 +403,7 @@
 	}
 #endif
 
-#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
- */
+#if GDISP_NEED_ARC
 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) {
 		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
 
-#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
- */
+#if GDISP_NEED_ARC
 void gdispFillRoundedBox(coord_t x, coord_t y, coord_t cx, coord_t cy, coord_t radius, color_t color) {
 	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
 
-#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
-	 */
+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD)
 	void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {
 		chMtxLock(&gdispMutex);
 		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
 
-#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
-	 */
+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD)
 	void gdispFillChar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {
 		chMtxLock(&gdispMutex);
 		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
 	
-#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
-	 */
+#if (GDISP_NEED_PIXELREAD && (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC))
 	color_t gdispGetPixelColor(coord_t x, coord_t y) {
 		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
 
-#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
-	 */
+#if (GDISP_NEED_SCROLL && GDISP_NEED_MULTITHREAD)
 	void gdispVerticalScroll(coord_t x, coord_t y, coord_t cx, coord_t cy, int lines, color_t bgcolor) {
 		chMtxLock(&gdispMutex);
 		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
 
-#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
-	 */
+#if (GDISP_NEED_CONTROL && GDISP_NEED_MULTITHREAD)
 	void gdispControl(unsigned what, void *value) {
 		chMtxLock(&gdispMutex);
 		gdisp_lld_control(what, value);
 		chMtxUnlock();
-		chThdSleepMilliseconds(100);
 	}
 #elif GDISP_NEED_CONTROL && GDISP_NEED_ASYNC
 	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
 
-#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
-	 */
+#if (GDISP_NEED_MULTITHREAD || GDISP_NEED_ASYNC) && GDISP_NEED_QUERY
 	void *gdispQuery(unsigned what) {
 		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.                                               */
 /*===========================================================================*/
 
-/**
- * @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) {
 	/* No mutex required as we only call high level functions which have their own mutex */
 	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;
+
+		epnt = &pntarray[cnt-1];
+		for(p = pntarray; p < epnt; p++)
+			gdispDrawLine(p->x, p->y, p[1].x, p[1].y, color);
+		gdispDrawLine(p->x, p->y, pntarray->x, pntarray->y, color);
+	}
+
+	void gdispFillConvexPoly(const point *pntarray, unsigned cnt, color_t color) {
+		const point	*lpnt, *rpnt, *epnts;
+		fpcoord_t	lx, rx, lk, rk;
+		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 || 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
-	 */
+	#if GDISP_NEED_TEXT
 	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 */
 		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
 	
-#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
-	 */
+#if GDISP_NEED_TEXT
 	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 */
 		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
 	
-#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
-	 */
+#if GDISP_NEED_TEXT
 	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 */
 		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
 	
-#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
-	 */
+#if GDISP_NEED_TEXT
 	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 */
 		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
 	
-#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
-	 */
+#if GDISP_NEED_TEXT
 	coord_t gdispGetFontMetric(font_t font, fontmetric_t metric) {
 		/* No mutex required as we only read static data */
 		switch(metric) {
@@ -1181,32 +993,14 @@ void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
 	}
 #endif
 	
-#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
-	 */
+#if GDISP_NEED_TEXT
 	coord_t gdispGetCharWidth(char c, font_t font) {
 		/* No mutex required as we only read static data */
 		return _getCharWidth(font, c) * font->xscale;
 	}
 #endif
 	
-#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
-	 */
+#if GDISP_NEED_TEXT
 	coord_t gdispGetStringWidth(const char* str, font_t font) {
 		/* No mutex required as we only read static data */
 		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
 
-#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
-	 */
+#if (!defined(gdispPackPixels) && !defined(GDISP_PIXELFORMAT_CUSTOM))
 	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 */
 		#if defined(GDISP_PIXELFORMAT_RGB888)
diff --git a/src/gwin/button.c b/src/gwin/button.c
index 43bc80c6..e67e8c70 100644
--- a/src/gwin/button.c
+++ b/src/gwin/button.c
@@ -33,15 +33,23 @@
 
 #if (GFX_USE_GWIN && GWIN_NEED_BUTTON) || defined(__DOXYGEN__)
 
+/* Parameters for various shapes */
+#define RND_CNR_SIZE			5		// Rounded corner size for rounded buttons
+#define ARROWHEAD_DIVIDER		4		// A quarter of the height for the arrow head
+#define ARROWBODY_DIVIDER		4		// A quarter of the width for the arrow body
+
 #include <string.h>
 
 #include "gwin/internal.h"
 
-static const GButtonStyle GButtonDefaultStyle = {
-	GBTN_3D,
+#define GWIN_BUTTON_DEFAULT_SHAPE		GBTN_3D
+
+static const GButtonDrawStyle GButtonDefaultStyleUp = {
 	HTML2COLOR(0x404040),		// color_up_edge;
 	HTML2COLOR(0xE0E0E0),		// color_up_fill;
 	HTML2COLOR(0x000000),		// color_up_txt;
+	};
+static const GButtonDrawStyle GButtonDefaultStyleDown = {
 	HTML2COLOR(0x404040),		// color_dn_edge;
 	HTML2COLOR(0x808080),		// color_dn_fill;
 	HTML2COLOR(0x404040),		// color_dn_txt;
@@ -139,8 +147,10 @@ GHandle gwinCreateButton(GButtonObject *gb, coord_t x, coord_t y, coord_t width,
 	if (!(gb = (GButtonObject *)_gwinInit((GWindowObject *)gb, x, y, width, height, sizeof(GButtonObject))))
 		return 0;
 	gb->gwin.type = GW_BUTTON;
+	gb->fn = 0;
+	gb->param = 0;
 	gwinSetFont(&gb->gwin, font);
-	gwinSetButtonStyle(&gb->gwin, &GButtonDefaultStyle);
+	gwinSetButtonStyle(&gb->gwin, GWIN_BUTTON_DEFAULT_SHAPE, &GButtonDefaultStyleUp, &GButtonDefaultStyleDown);
 	gb->type = type;
 	gb->state = GBTN_UP;
 	gb->txt = "";
@@ -149,18 +159,41 @@ GHandle gwinCreateButton(GButtonObject *gb, coord_t x, coord_t y, coord_t width,
 	return (GHandle)gb;
 }
 
-void gwinSetButtonStyle(GHandle gh, const GButtonStyle *style) {
+void gwinSetButtonStyle(GHandle gh, GButtonShape shape, const GButtonDrawStyle *pUp, const GButtonDrawStyle *pDown) {
 	#define gbw		((GButtonObject *)gh)
 	if (gh->type != GW_BUTTON)
 		return;
-	
-	gbw->style.shape = style->shape;
-	gbw->style.color_up_edge = style->color_up_edge;
-	gbw->style.color_up_fill = style->color_up_fill;
-	gbw->style.color_dn_edge = style->color_dn_edge;
-	gbw->style.color_dn_fill = style->color_dn_fill;
-	gbw->style.color_up_txt = style->color_up_txt;
-	gbw->style.color_dn_txt = style->color_dn_txt;
+
+	switch(shape) {
+		case GBTN_SQUARE:		gbw->fn = gwinButtonDraw_Square;		break;
+		#if GDISP_NEED_ARC
+			case GBTN_ROUNDED:	gbw->fn = gwinButtonDraw_Rounded;		break;
+		#endif
+		#if GDISP_NEED_ELLIPSE
+			case GBTN_ELLIPSE:	gbw->fn = gwinButtonDraw_Ellipse;		break;
+		#endif
+
+		#if GDISP_NEED_CONVEX_POLYGON
+			case GBTN_ARROW_UP:		gbw->fn = gwinButtonDraw_ArrowUp;		break;
+			case GBTN_ARROW_DOWN:	gbw->fn = gwinButtonDraw_ArrowDown;		break;
+			case GBTN_ARROW_LEFT:	gbw->fn = gwinButtonDraw_ArrowLeft;		break;
+			case GBTN_ARROW_RIGHT:	gbw->fn = gwinButtonDraw_ArrowRight;	break;
+		#endif
+
+		case GBTN_CUSTOM:		if (gbw->fn)	break;		/* Fall Through */
+		case GBTN_3D:			/* Fall through */
+		default:				gbw->fn = gwinButtonDraw_3D;			break;
+	}
+	if (pUp) {
+		gbw->up.color_edge = pUp->color_edge;
+		gbw->up.color_fill = pUp->color_fill;
+		gbw->up.color_txt = pUp->color_txt;
+	}
+	if (pDown) {
+		gbw->dn.color_edge = pDown->color_edge;
+		gbw->dn.color_fill = pDown->color_fill;
+		gbw->dn.color_txt = pDown->color_txt;
+	}
 	#undef gbw
 }
 
@@ -193,12 +226,7 @@ void gwinSetButtonText(GHandle gh, const char *txt, bool_t useAlloc) {
 }
 
 void gwinButtonDraw(GHandle gh) {
-	color_t			cedge;
-	color_t			cfill;
-	color_t			ctxt;
-	const char *	txt;
 	#define gbw		((GButtonObject *)gh)
-	#define RND_CNR_SIZE	5
 	
 	if (gh->type != GW_BUTTON)
 		return;
@@ -206,55 +234,145 @@ void gwinButtonDraw(GHandle gh) {
 	#if GDISP_NEED_CLIP
 		gdispSetClip(gh->x, gh->y, gh->width, gh->height);
 	#endif
-	
-	// Get the text (safely)
-	txt = gh->font && gbw->txt ? gbw->txt : "";
-	
-	// Determine the colors to use
-	switch(gbw->state) {
-	case GBTN_DOWN:
-		cedge = gbw->style.color_dn_edge;
-		cfill = gbw->style.color_dn_fill;
-		ctxt = gbw->style.color_dn_txt;
-		break;
-	case GBTN_UP:	default:
-		cedge = gbw->style.color_up_edge;
-		cfill = gbw->style.color_up_fill;
-		ctxt = gbw->style.color_up_txt;
-		break;
-	}
-	
-	// Draw according to the shape specified.
-	switch(gbw->style.shape) {
+
+	gbw->fn(gh,
+			gbw->state == GBTN_DOWN,
+			gh->font && gbw->txt ? gbw->txt : "",
+			gbw->state == GBTN_DOWN ? &gbw->dn : &gbw->up,
+			gbw->param);
+
+	#undef gbw
+}
+
+void gwinSetButtonCustom(GHandle gh, GButtonDrawFunction fn, void *param) {
+	#define gbw		((GButtonObject *)gh)
+
+	if (gh->type != GW_BUTTON)
+		return;
+
+	gbw->fn = fn ? fn : gwinButtonDraw_3D;
+	gbw->param = param;
+
+	#undef gbw
+}
+
+void gwinButtonDraw_3D(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param) {
+	(void) isdown;
+	(void) param;
+
+	gdispFillStringBox(gh->x, gh->y, gh->width-1, gh->height-1, txt, gh->font, pstyle->color_txt, pstyle->color_fill, justifyCenter);
+	gdispDrawLine(gh->x+gh->width-1, gh->y, gh->x+gh->width-1, gh->y+gh->height-1, pstyle->color_edge);
+	gdispDrawLine(gh->x, gh->y+gh->height-1, gh->x+gh->width-2, gh->y+gh->height-1, pstyle->color_edge);
+}
+
+void gwinButtonDraw_Square(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param) {
+	(void) isdown;
+	(void) param;
+
+	gdispFillStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, pstyle->color_txt, pstyle->color_fill, justifyCenter);
+	gdispDrawBox(gh->x, gh->y, gh->width, gh->height, pstyle->color_edge);
+}
+
 #if GDISP_NEED_ARC
-	case GBTN_ROUNDED:
+	void gwinButtonDraw_Rounded(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param) {
+		(void) isdown;
+		(void) param;
+
 		if (gh->width >= 2*RND_CNR_SIZE+10) {
-			gdispFillRoundedBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, RND_CNR_SIZE-1, cfill);
-			gdispDrawStringBox(gh->x+1, gh->y+RND_CNR_SIZE, gh->width-2, gh->height-(2*RND_CNR_SIZE), txt, gh->font, ctxt, justifyCenter);
-			gdispDrawRoundedBox(gh->x, gh->y, gh->width, gh->height, RND_CNR_SIZE, cedge);
-			break;
+			gdispFillRoundedBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, RND_CNR_SIZE-1, pstyle->color_fill);
+			gdispDrawStringBox(gh->x+1, gh->y+RND_CNR_SIZE, gh->width-2, gh->height-(2*RND_CNR_SIZE), txt, gh->font, pstyle->color_txt, justifyCenter);
+			gdispDrawRoundedBox(gh->x, gh->y, gh->width, gh->height, RND_CNR_SIZE, pstyle->color_edge);
+		} else {
+			gdispFillStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, pstyle->color_txt, pstyle->color_fill, justifyCenter);
+			gdispDrawBox(gh->x, gh->y, gh->width, gh->height, pstyle->color_edge);
 		}
-		/* Fall Through */
+	}
 #endif
-	case GBTN_SQUARE:
-		gdispFillStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, ctxt, cfill, justifyCenter);
-		gdispDrawBox(gh->x, gh->y, gh->width, gh->height, cedge);
-		break;
+
 #if GDISP_NEED_ELLIPSE
-	case GBTN_ELLIPSE:
-		gdispFillEllipse(gh->x+1, gh->y+1, gh->width/2-1, gh->height/2-1, cfill);
-		gdispDrawStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, ctxt, justifyCenter);
-		gdispDrawEllipse(gh->x, gh->y, gh->width/2, gh->height/2, cedge);
-		break;
+	void gwinButtonDraw_Ellipse(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param) {
+		(void) isdown;
+		(void) param;
+
+		gdispFillEllipse(gh->x+1, gh->y+1, gh->width/2-1, gh->height/2-1, pstyle->color_fill);
+		gdispDrawStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, pstyle->color_txt, justifyCenter);
+		gdispDrawEllipse(gh->x, gh->y, gh->width/2, gh->height/2, pstyle->color_edge);
+	}
 #endif
-	case GBTN_3D:	default:
-		gdispFillStringBox(gh->x, gh->y, gh->width-1, gh->height-1, txt, gh->font, ctxt, cfill, justifyCenter);
-		gdispDrawLine(gh->x+gh->width-1, gh->y, gh->x+gh->width-1, gh->y+gh->height-1, cedge);
-		gdispDrawLine(gh->x, gh->y+gh->height-1, gh->x+gh->width-2, gh->y+gh->height-1, cedge);
-		break;
+
+#if GDISP_NEED_CONVEX_POLYGON
+	void gwinButtonDraw_ArrowUp(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param) {
+		(void) isdown;
+		(void) param;
+		point	arw[7];
+
+		arw[0].x = gh->x+gh->width/2; arw[0].y = gh->y;
+		arw[1].x = gh->x+gh->width-1; arw[1].y = gh->y+gh->height/ARROWHEAD_DIVIDER;
+		arw[2].x = gh->x+(gh->width + gh->width/ARROWBODY_DIVIDER)/2; arw[2].y = gh->y+gh->height/ARROWHEAD_DIVIDER;
+		arw[3].x = gh->x+(gh->width + gh->width/ARROWBODY_DIVIDER)/2; arw[3].y = gh->y+gh->height-1;
+		arw[4].x = gh->x+(gh->width - gh->width/ARROWBODY_DIVIDER)/2; arw[4].y = gh->y+gh->height-1;
+		arw[5].x = gh->x+(gh->width - gh->width/ARROWBODY_DIVIDER)/2; arw[5].y = gh->y+gh->height/ARROWHEAD_DIVIDER;
+		arw[6].x = gh->x; arw[6].y = gh->y+gh->height/ARROWHEAD_DIVIDER;
+
+		gdispFillConvexPoly(arw, 7, pstyle->color_fill);
+		gdispDrawPoly(arw, 7, pstyle->color_edge);
+		gdispDrawStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, pstyle->color_txt, justifyCenter);
 	}
-	#undef gbw
-}
+
+	void gwinButtonDraw_ArrowDown(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param) {
+		(void) isdown;
+		(void) param;
+		point	arw[7];
+
+		arw[0].x = gh->x+gh->width/2; arw[0].y = gh->y+gh->height-1;
+		arw[1].x = gh->x+gh->width-1; arw[1].y = gh->y+gh->height-1-gh->height/ARROWHEAD_DIVIDER;
+		arw[2].x = gh->x+(gh->width + gh->width/ARROWBODY_DIVIDER)/2; arw[2].y = gh->y+gh->height-1-gh->height/ARROWHEAD_DIVIDER;
+		arw[3].x = gh->x+(gh->width + gh->width/ARROWBODY_DIVIDER)/2; arw[3].y = gh->y;
+		arw[4].x = gh->x+(gh->width - gh->width/ARROWBODY_DIVIDER)/2; arw[4].y = gh->y;
+		arw[5].x = gh->x+(gh->width - gh->width/ARROWBODY_DIVIDER)/2; arw[5].y = gh->y+gh->height-1-gh->height/ARROWHEAD_DIVIDER;
+		arw[6].x = gh->x; arw[6].y = gh->y+gh->height-1-gh->height/ARROWHEAD_DIVIDER;
+
+		gdispFillConvexPoly(arw, 7, pstyle->color_fill);
+		gdispDrawPoly(arw, 7, pstyle->color_edge);
+		gdispDrawStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, pstyle->color_txt, justifyCenter);
+	}
+
+	void gwinButtonDraw_ArrowLeft(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param) {
+		(void) isdown;
+		(void) param;
+		point	arw[7];
+
+		arw[0].x = gh->x; arw[0].y = gh->y+gh->height/2;
+		arw[1].x = gh->x+gh->width/ARROWHEAD_DIVIDER; arw[1].y = gh->y;
+		arw[2].x = gh->x+gh->width/ARROWHEAD_DIVIDER; arw[2].y = gh->y+(gh->height - gh->height/ARROWBODY_DIVIDER)/2;
+		arw[3].x = gh->x+gh->width-1; arw[3].y = gh->y+(gh->height - gh->height/ARROWBODY_DIVIDER)/2;
+		arw[4].x = gh->x+gh->width-1; arw[4].y = gh->y+(gh->height + gh->height/ARROWBODY_DIVIDER)/2;
+		arw[5].x = gh->x+gh->width/ARROWHEAD_DIVIDER; arw[5].y = gh->y+(gh->height + gh->height/ARROWBODY_DIVIDER)/2;
+		arw[6].x = gh->x+gh->width/ARROWHEAD_DIVIDER; arw[6].y = gh->y+gh->height-1;
+
+		gdispFillConvexPoly(arw, 7, pstyle->color_fill);
+		gdispDrawPoly(arw, 7, pstyle->color_edge);
+		gdispDrawStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, pstyle->color_txt, justifyCenter);
+	}
+
+	void gwinButtonDraw_ArrowRight(GHandle gh, bool_t isdown, const char *txt, const GButtonDrawStyle *pstyle, void *param) {
+		(void) isdown;
+		(void) param;
+		point	arw[7];
+
+		arw[0].x = gh->x+gh->width-1; arw[0].y = gh->y+gh->height/2;
+		arw[1].x = gh->x+gh->width-1-gh->width/ARROWHEAD_DIVIDER; arw[1].y = gh->y;
+		arw[2].x = gh->x+gh->width-1-gh->width/ARROWHEAD_DIVIDER; arw[2].y = gh->y+(gh->height - gh->height/ARROWBODY_DIVIDER)/2;
+		arw[3].x = gh->x; arw[3].y = gh->y+(gh->height - gh->height/ARROWBODY_DIVIDER)/2;
+		arw[4].x = gh->x; arw[4].y = gh->y+(gh->height + gh->height/ARROWBODY_DIVIDER)/2;
+		arw[5].x = gh->x+gh->width-1-gh->width/ARROWHEAD_DIVIDER; arw[5].y = gh->y+(gh->height + gh->height/ARROWBODY_DIVIDER)/2;
+		arw[6].x = gh->x+gh->width-1-gh->width/ARROWHEAD_DIVIDER; arw[6].y = gh->y+gh->height-1;
+
+		gdispFillConvexPoly(arw, 7, pstyle->color_fill);
+		gdispDrawPoly(arw, 7, pstyle->color_edge);
+		gdispDrawStringBox(gh->x+1, gh->y+1, gh->width-2, gh->height-2, txt, gh->font, pstyle->color_txt, justifyCenter);
+	}
+#endif
 
 #if defined(GINPUT_NEED_MOUSE) && GINPUT_NEED_MOUSE
 	bool_t gwinAttachButtonMouseSource(GHandle gh, GSourceHandle gsh) {