Many changes including scaled fonts

Scaled fonts (independantly in x & y direction) based on normal sized
font. Effectively double sized and double height same width fonts come
free (or triple etc).
New routine for sending low level drivers hardware commands eg backlight
brightness, contrast
Power and Orientation moved to new routine.
Clean up on files to simplify low level driver file overheads.

4 files changed, 1875 insertions, 721 deletions

diff --git a/halext/src/gdisp-readme.txt b/halext/src/gdisp-readme.txt
index 1a9cda25..12b00e2c 100644
--- a/halext/src/gdisp-readme.txt
+++ b/halext/src/gdisp-readme.txt
@@ -1,9 +1,14 @@
-The new GDISP driver is an architecture independant rewrite of the GLCD interface. This new architecture independance should allow many new low level drivers to be easily added.

+The new GDISP driver is an architecture independant rewrite of the GLCD interface.

+This new architecture independance should allow many new low level drivers to be easily added.

 

-GDISP allows low-level driver hardware accelerated drawing routines while providing a software emulation if the low level driver can not provide it. A basic low level driver now only requires 2 routines to be written.

+GDISP allows low-level driver hardware accelerated drawing routines while providing a software emulation

+if the low level driver can not provide it. A basic low level driver now only requires 2 routines to be written.

 

-A glcd.h compatability file has been included that allow applications written to use the existing GLCD driver to use the GDISP driver with little or no change.

+A glcd.h compatability file has been included that allow applications written to use the existing GLCD driver to

+use the GDISP driver with little or no change.

 

 It is written in the ChibiOS style with ChibiOS style includes and documentation.

 

-It is encapsulated into a "halext" structure with appropriate readme's that allow for easy inclusion in any ChibiOS project. This structure can be seamlessly added to as new driver types are added and it supports low level drivers that are neither platform or board specific (although they can be).

+It is encapsulated into a "halext" structure with appropriate readme's that allow for easy inclusion in any

+ChibiOS project. This structure can be seamlessly added to as new driver types are added and it supports

+low level drivers that are neither platform or board specific (although they can be).

diff --git a/halext/src/gdisp.c b/halext/src/gdisp.c
index 94e3d898..4bbff695 100644
--- a/halext/src/gdisp.c
+++ b/halext/src/gdisp.c
@@ -1,717 +1,748 @@
-/*
-    ChibiOS/RT - Copyright (C) 2012
-                 Joel Bodenmann aka Tectu <joel@unormal.org>
-
-    This file is part of ChibiOS-LCD-Driver.
-
-    ChibiOS-LCD-Driver 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-LCD-Driver 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    gdisp.c
- * @brief   GDISP Driver code.
- *
- * @addtogroup GDISP
- * @{
- */
-
-#include "ch.h"
-#include "hal.h"
-#include "gdisp.h"
-
-#if HAL_USE_GDISP || defined(__DOXYGEN__)
-
-#if GDISP_NEED_MULTITHREAD
-	#warning "GDISP: Multithread support not complete"
-	#define MUTEX_INIT		/* Not defined yet */
-	#define MUTEX_ENTER		/* Not defined yet */
-	#define MUTEX_EXIT		/* Not defined yet */
-#endif
-
-/*===========================================================================*/
-/* Driver local definitions.                                                 */
-/*===========================================================================*/
-
-#ifdef UNUSED
-#elif defined(__GNUC__)
-# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
-#elif defined(__LCLINT__)
-# define UNUSED(x) /*@unused@*/ x
-#else
-# define UNUSED(x) x
-#endif
-
-/*===========================================================================*/
-/* Driver exported variables.                                                */
-/*===========================================================================*/
-
-#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
-	#include "gdisp_inc_fonts.c.h"
-#endif
-
-/*===========================================================================*/
-/* Driver local variables.                                                   */
-/*===========================================================================*/
-
-/*===========================================================================*/
-/* Driver local functions.                                                   */
-/*===========================================================================*/
-
-/*===========================================================================*/
-/* 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.
-	 *
-	 * @init
-	 */
-	void gdispInit(GDISPDriver * UNUSED(gdisp)) {
-		/* Initialise Mutex */
-		MUTEX_INIT
-
-		/* Initialise driver */
-		MUTEX_ENTER
-		gdisp_lld_init();
-		MUTEX_EXIT
-	}
-#endif
-
-#if 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 powerSleep. If not powerSleep is treated the same as powerOn.
-	 *          (sleep allows drawing to the display without the display updating).
-	 *
-	 * @param[in] powerMode The power mode to use
-	 *
-	 * @api
-	 */
-	void gdispSetPowerMode(gdisp_powermode_t powerMode) {
-		MUTEX_ENTER
-		gdisp_lld_setpowermode(powerMode);
-		MUTEX_EXIT
-	}
-#endif
-
-#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
-	/**
-	 * @brief   Set the orientation of the display.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 * @note    Depending on the hardware implementation this function may clear
-	 *			the display when changing its orientation.
-	 *
-	 * @param[in] newOrientation The new orientation to use
-	 *
-	 * @api
-	 */
-	void gdispSetOrientation(gdisp_orientation_t newOrientation) {
-		MUTEX_ENTER
-		gdisp_lld_setorientation(newOrientation);
-		MUTEX_EXIT
-	}
-#endif
-
-#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
-	/**
-	 * @brief   Clear the display to the specified color.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] color The color to use when clearing the screen
-	 *
-	 * @api
-	 */
-	void gdispClear(color_t color) {
-		MUTEX_ENTER
-		gdisp_lld_clear(color);
-		MUTEX_EXIT
-	}
-#endif
-
-#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
-	/**
-	 * @brief   Set a pixel in the specified color.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @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) {
-		MUTEX_ENTER
-		gdisp_lld_drawpixel(x, y, color);
-		MUTEX_EXIT
-	}
-#endif
-	
-#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a line.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @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) {
-		MUTEX_ENTER
-		gdisp_lld_drawline(x0, y0, x1, y1, color);
-		MUTEX_EXIT
-	}
-#endif
-	
-#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a rectangular box.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x0,y0   The start position
-	 * @param[in] cx,cy   The size of the box (outside dimensions)
-	 * @param[in] color   The color to use
-	 * @param[in] filled  Should the box should be filled
-	 *
-	 * @api
-	 */
-	void gdispDrawBox(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {
-		MUTEX_ENTER
-		gdisp_lld_drawbox(x, y, cx, cy, color);
-		MUTEX_EXIT
-	}
-#endif
-
-#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
-	/**
-	 * @brief   Fill an area with a color.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x0,y0   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) {
-		MUTEX_ENTER
-		gdisp_lld_fillarea(x, y, cx, cy, color);
-		MUTEX_EXIT
-	}
-#endif
-	
-#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)
-	/**
-	 * @brief   Fill an area using the supplied bitmap.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 * @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).
-	 *
-	 * @param[in] x0,y0   The start position
-	 * @param[in] cx,cy   The size of the filled area
-	 * @param[in] buffer  The bitmap in the driver's pixel format.
-	 *
-	 * @api
-	 */
-	void gdispBlitArea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer) {
-		MUTEX_ENTER
-		gdisp_lld_blitarea(x, y, cx, cy, buffer);
-		MUTEX_EXIT
-	}
-#endif
-	
-#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a circle.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x0,y0   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) {
-		MUTEX_ENTER
-		gdisp_lld_drawcircle(x, y, radius, color);
-		MUTEX_EXIT
-	}
-#endif
-	
-#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a filled circle.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x0,y0   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) {
-		MUTEX_ENTER
-		gdisp_lld_fillcircle(x, y, radius, color);
-		MUTEX_EXIT
-	}
-#endif
-
-#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw an ellipse.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x0,y0   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) {
-		MUTEX_ENTER
-		gdisp_lld_drawellipse(x, y, a, b, color);
-		MUTEX_EXIT
-	}
-#endif
-	
-#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a filled ellipse.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x0,y0   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) {
-		MUTEX_ENTER
-		gdisp_lld_fillellipse(x, y, a, b, color);
-		MUTEX_EXIT
-	}
-#endif
-
-#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a text character.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x,y     The position for the text
-	 * @param[in] c       The character to draw
-	 * @param[in] color   The color to use
-	 *
-	 * @api
-	 */
-	void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {
-		MUTEX_ENTER
-		gdisp_lld_drawchar(x, y, c, font, color);
-		MUTEX_EXIT
-	}
-#endif
-	
-#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a text character with a filled background.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x,y     The position for the text
-	 * @param[in] c       The character to draw
-	 * @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) {
-		MUTEX_ENTER
-		gdisp_lld_fillchar(x, y, c, font, color, bgcolor);
-		MUTEX_EXIT
-	}
-#endif
-	
-#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a text string.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x,y     The position for the text
-	 * @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) {
-		/* No mutex required as we only call high level functions which have their own mutex */
-		coord_t		w;
-		char		c;
-		int			first;
-		
-		first = 1;
-		while(*str) {
-			/* Get the next printable character */
-			c = *str++;
-			w = _getCharWidth(font, c);
-			if (!w) continue;
-			
-			/* Handle inter-character padding */
-			if (font->charPadding) {
-				if (!first)
-					x += font->charPadding;
-				else
-					first = 0;
-			}
-			
-			/* Print the character */
-			gdispDrawChar(x, y, c, font, color);
-			x += w;
-		}
-	}
-#endif
-	
-#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a text string.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 *
-	 * @param[in] x,y     The position for the text
-	 * @param[in] str     The string to draw
-	 * @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) {
-		/* No mutex required as we only call high level functions which have their own mutex */
-		coord_t		w;
-		char		c;
-		int			first;
-		
-		first = 1;
-		while(*str) {
-			/* Get the next printable character */
-			c = *str++;
-			w = _getCharWidth(font, c);
-			if (!w) continue;
-			
-			/* Handle inter-character padding */
-			if (font->charPadding) {
-				if (!first) {
-					gdispFillArea(x, y, font->charPadding, font->height, bgcolor);
-					x += font->charPadding;
-				} else
-					first = 0;
-			}
-
-			/* Print the character */
-			gdispFillChar(x, y, c, font, color, bgcolor);
-			x += w;
-		}
-	}
-#endif
-	
-#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
-	/**
-	 * @brief   Draw a text string verticly centered within the specified box.
-	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.
-	 * @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] str     The string to draw
-	 * @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 gdispDrawStringBox(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, ypos, xpos;
-		char		c;
-		int			first;
-		const char *rstr;
-		
-		/* Oops - font too large for the area */
-		if (font->height > cy) return;
-
-		/* See if we need to fill above the font */
-		ypos = (cy - font->height)/2;
-		if (ypos > 0) {
-			gdispFillArea(x, y, cx, ypos, bgcolor);
-			y += ypos;
-			cy -= ypos;
-		}
-		
-		/* See if we need to fill below the font */
-		ypos = cy - font->height;
-		if (ypos > 0) {
-			gdispFillArea(x, y+cy-ypos, cx, ypos, bgcolor);
-			cy -= ypos;
-		}
-		
-		/* get the start of the printable string and the xpos */
-		switch(justify) {
-		case justifyCenter:
-			/* Get the length of the entire string */
-			w = gdispGetStringWidth(str, font);
-			if (w <= cx)
-				xpos = x + (cx - w)/2;
-			else {
-				/* Calculate how much of the string we need to get rid of */
-				ypos = (w - cx)/2;
-				xpos = 0;
-				first = 1;
-				while(*str) {
-					/* Get the next printable character */
-					c = *str++;
-					w = _getCharWidth(font, c);
-					if (!w) continue;
-					
-					/* Handle inter-character padding */
-					if (font->charPadding) {
-						if (!first) {
-							xpos += font->charPadding;
-							if (xpos > ypos) break;
-						} else
-							first = 0;
-					}
-
-					/* Print the character */
-					xpos += w;
-					if (xpos > ypos) break;
-				}
-				xpos = ypos - xpos + x;
-			}
-			break;
-		case justifyRight:
-			/* Find the end of the string */
-			for(rstr = str; *str; str++);
-			xpos = x+cx - 2;
-			first = 1;
-			for(str--; str >= rstr; str--) {
-				/* Get the next printable character */
-				c = *str;
-				w = _getCharWidth(font, c);
-				if (!w) continue;
-				
-				/* Handle inter-character padding */
-				if (font->charPadding) {
-					if (!first) {
-						if (xpos - font->charPadding < x) break;
-						xpos -= font->charPadding;
-					} else
-						first = 0;
-				}
-
-				/* Print the character */
-				if (xpos - w < x) break;
-				xpos -= w;
-			}
-			str++;
-			break;
-		case justifyLeft:
-			/* Fall through */
-		default:
-			xpos = x+1;
-			break;
-		}
-		
-		/* Fill any space to the left */
-		if (x < xpos)
-			gdispFillArea(x, y, xpos-x, cy, bgcolor);
-		
-		/* Print characters until we run out of room */
-		first = 1;
-		while(*str) {
-			/* Get the next printable character */
-			c = *str++;
-			w = _getCharWidth(font, c);
-			if (!w) continue;
-			
-			/* Handle inter-character padding */
-			if (font->charPadding) {
-				if (!first) {
-					if (xpos + font->charPadding > x+cx) break;
-					gdispFillArea(xpos, y, font->charPadding, cy, bgcolor);
-					xpos += font->charPadding;
-				} else
-					first = 0;
-			}
-
-			/* Print the character */
-			if (xpos + w > x+cx) break;
-			gdispFillChar(xpos, y, c, font, color, bgcolor);
-			xpos += w;
-		}
-		
-		/* Fill any space to the right */
-		if (xpos < x+cx)
-			gdispFillArea(xpos, y, x+cx-xpos, cy, bgcolor);
-	}
-#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
-	 */
-	coord_t gdispGetFontMetric(font_t font, fontmetric_t metric) {
-		/* No mutex required as we only read static data */
-		switch(metric) {
-		case fontHeight:			return font->height;
-		case fontDescendersHeight:	return font->descenderHeight;
-		case fontLineSpacing:		return font->lineSpacing;
-		case fontCharPadding:		return font->charPadding;
-		case fontMinWidth:			return font->minWidth;
-		case fontMaxWidth:			return font->maxWidth;
-		}
-		return 0;
-	}
-#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
-	 */
-	coord_t gdispGetCharWidth(char c, font_t font) {
-		/* No mutex required as we only read static data */
-		return _getCharWidth(font, c);
-	}
-#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
-	 */
-	coord_t gdispGetStringWidth(const char* str, font_t font) {
-		/* No mutex required as we only read static data */
-		coord_t		w, x;
-		char		c;
-		int			first;
-		
-		first = 1;
-		x = 0;
-		while(*str) {
-			/* Get the next printable character */
-			c = *str++;
-			w = _getCharWidth(font, c);
-			if (!w) continue;
-			
-			/* Handle inter-character padding */
-			if (font->charPadding) {
-				if (!first)
-					x += font->charPadding;
-				else
-					first = 0;
-			}
-			
-			/* Add the character width */
-			x += w;
-		}
-		return x;
-	}
-#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_CLIPPING has been specified.
-	 *
-	 * @param[in] buf		The buffer to put the pixel in
-	 * @param[in] cx		The width of a pixel line
-	 * @param[in] x, y		The location of the pixel to place
-	 * @param[in] color		The color to put into the buffer
-	 *
-	 * @api
-	 */
-	void gdispPackPixels(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color) {
-		/* No mutex required as we only read static data */
-		#if defined(GDISP_PIXELFORMAT_RGB888)
-			#error "GDISP: Packed pixels not supported yet"
-		#elif defined(GDISP_PIXELFORMAT_RGB444)
-			#error "GDISP: Packed pixels not supported yet"
-		#elif defined(GDISP_PIXELFORMAT_RGB666)
-			#error "GDISP: Packed pixels not supported yet"
-		#elif
-			#error "GDISP: Unsupported packed pixel format"
-		#endif
-	}
-#endif
-
-#if (GDISP_NEED_PIXELREAD && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
-	/**
-	 * @brief   Get the color of a pixel.
-	 * @return  The color of the pixel.
-	 *
-	 * @param[in] x,y     The position of the pixel
-	 *
-	 * @api
-	 */
-	color_t gdispGetPixelColor(coord_t x, coord_t y) {
-		color_t		c;
-		
-		MUTEX_ENTER
-		c = gdisp_lld_getpixelcolor(x, y);
-		MUTEX_EXIT
-		
-		return c;
-	}
-#endif
-
-#if (GDISP_NEED_SCROLL && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)
-	/**
-	 * @brief   Scroll vertically a section of the screen.
-	 * @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) {
-		MUTEX_ENTER
-		gdisp_lld_verticalscroll(x, y, cx, cy, lines, bgcolor);
-		MUTEX_EXIT
-	}
-#endif
-
-#endif /* HAL_USE_GDISP */
-/** @} */
+/*

+    ChibiOS/RT - Copyright (C) 2012

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

+

+    This file is part of ChibiOS-LCD-Driver.

+

+    ChibiOS-LCD-Driver 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-LCD-Driver 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    gdisp.c

+ * @brief   GDISP Driver code.

+ *

+ * @addtogroup GDISP

+ * @{

+ */

+#include "ch.h"

+#include "hal.h"

+#include "gdisp.h"

+

+#if HAL_USE_GDISP || defined(__DOXYGEN__)

+

+#ifdef GDISP_NEED_TEXT

+	#include "gdisp_fonts.h"

+#endif

+

+#if GDISP_NEED_MULTITHREAD

+	#warning "GDISP: Multithread support not complete"

+	#define MUTEX_INIT		/* Not defined yet */

+	#define MUTEX_ENTER		/* Not defined yet */

+	#define MUTEX_EXIT		/* Not defined yet */

+#endif

+

+/*===========================================================================*/

+/* Driver local definitions.                                                 */

+/*===========================================================================*/

+

+#ifdef UNUSED

+#elif defined(__GNUC__)

+# define UNUSED(x) UNUSED_ ## x __attribute__((unused))

+#elif defined(__LCLINT__)

+# define UNUSED(x) /*@unused@*/ x

+#else

+# define UNUSED(x) x

+#endif

+

+/*===========================================================================*/

+/* Driver exported variables.                                                */

+/*===========================================================================*/

+

+/*===========================================================================*/

+/* Driver local variables.                                                   */

+/*===========================================================================*/

+

+/*===========================================================================*/

+/* Driver local functions.                                                   */

+/*===========================================================================*/

+

+/*===========================================================================*/

+/* 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.

+	 *

+	 * @init

+	 */

+	void gdispInit(GDISPDriver * UNUSED(gdisp)) {

+		/* Initialise Mutex */

+		MUTEX_INIT

+

+		/* Initialise driver */

+		MUTEX_ENTER

+		gdisp_lld_init();

+		MUTEX_EXIT

+	}

+#endif

+

+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)

+	/**

+	 * @brief   Set the orientation of the display.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 * @note    Depending on the hardware implementation this function may clear

+	 *			the display when changing its orientation.

+	 *

+	 * @param[in] newOrientation The new orientation to use

+	 *

+	 * @api

+	 */

+	void gdispSetOrientation(gdisp_orientation_t newOrientation) {

+		MUTEX_ENTER

+		gdisp_lld_setorientation(newOrientation);

+		MUTEX_EXIT

+	}

+#endif

+

+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)

+	/**

+	 * @brief   Clear the display to the specified color.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] color The color to use when clearing the screen

+	 *

+	 * @api

+	 */

+	void gdispClear(color_t color) {

+		MUTEX_ENTER

+		gdisp_lld_clear(color);

+		MUTEX_EXIT

+	}

+#endif

+

+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)

+	/**

+	 * @brief   Set a pixel in the specified color.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

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

+		MUTEX_ENTER

+		gdisp_lld_drawpixel(x, y, color);

+		MUTEX_EXIT

+	}

+#endif

+	

+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a line.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

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

+		MUTEX_ENTER

+		gdisp_lld_drawline(x0, y0, x1, y1, color);

+		MUTEX_EXIT

+	}

+#endif

+	

+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)

+	/**

+	 * @brief   Fill an area with a color.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x0,y0   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) {

+		MUTEX_ENTER

+		gdisp_lld_fillarea(x, y, cx, cy, color);

+		MUTEX_EXIT

+	}

+#endif

+	

+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)

+	/**

+	 * @brief   Fill an area using the supplied bitmap.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

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

+	 *

+	 * @param[in] x0,y0   The start position

+	 * @param[in] cx,cy   The size of the filled area

+	 * @param[in] buffer  The bitmap in the driver's pixel format.

+	 *

+	 * @api

+	 */

+	void gdispBlitArea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer) {

+		MUTEX_ENTER

+		gdisp_lld_blitarea(x, y, cx, cy, buffer);

+		MUTEX_EXIT

+	}

+#endif

+	

+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a circle.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x0,y0   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) {

+		MUTEX_ENTER

+		gdisp_lld_drawcircle(x, y, radius, color);

+		MUTEX_EXIT

+	}

+#endif

+	

+#if (GDISP_NEED_CIRCLE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a filled circle.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x0,y0   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) {

+		MUTEX_ENTER

+		gdisp_lld_fillcircle(x, y, radius, color);

+		MUTEX_EXIT

+	}

+#endif

+

+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw an ellipse.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x0,y0   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) {

+		MUTEX_ENTER

+		gdisp_lld_drawellipse(x, y, a, b, color);

+		MUTEX_EXIT

+	}

+#endif

+	

+#if (GDISP_NEED_ELLIPSE && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a filled ellipse.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x0,y0   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) {

+		MUTEX_ENTER

+		gdisp_lld_fillellipse(x, y, a, b, color);

+		MUTEX_EXIT

+	}

+#endif

+

+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a text character.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x,y     The position for the text

+	 * @param[in] c       The character to draw

+	 * @param[in] color   The color to use

+	 *

+	 * @api

+	 */

+	void gdispDrawChar(coord_t x, coord_t y, char c, font_t font, color_t color) {

+		MUTEX_ENTER

+		gdisp_lld_drawchar(x, y, c, font, color);

+		MUTEX_EXIT

+	}

+#endif

+	

+#if (GDISP_NEED_PIXELREAD && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Get the color of a pixel.

+	 * @return  The color of the pixel.

+	 *

+	 * @param[in] x,y     The position of the pixel

+	 *

+	 * @api

+	 */

+	color_t gdispGetPixelColor(coord_t x, coord_t y) {

+		color_t		c;

+

+		MUTEX_ENTER

+		c = gdisp_lld_getpixelcolor(x, y);

+		MUTEX_EXIT

+

+		return c;

+	}

+#endif

+

+#if (GDISP_NEED_SCROLL && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Scroll vertically a section of the screen.

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

+		MUTEX_ENTER

+		gdisp_lld_verticalscroll(x, y, cx, cy, lines, bgcolor);

+		MUTEX_EXIT

+	}

+#endif

+

+#if (GDISP_NEED_TEXT && GDISP_NEED_MULTITHREAD) || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a text character with a filled background.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x,y     The position for the text

+	 * @param[in] c       The character to draw

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

+		MUTEX_ENTER

+		gdisp_lld_fillchar(x, y, c, font, color, bgcolor);

+		MUTEX_EXIT

+	}

+#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 powerSleep. If not powerSleep is treated the same as powerOn.

+	 *          (sleep allows drawing to the display without the display updating).

+	 *

+	 * @param[in] powerMode The power mode to use

+	 *

+	 * @api

+	 */

+	void gdispControl(int what, void *value) {

+		MUTEX_ENTER

+		gdisp_lld_control(what, value);

+		MUTEX_EXIT

+	}

+#endif

+

+/*===========================================================================*/

+/* High Level Driver Routines.                                               */

+/*===========================================================================*/

+

+#if GDISP_NEED_MULTITHREAD || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a rectangular box.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x0,y0   The start position

+	 * @param[in] cx,cy   The size of the box (outside dimensions)

+	 * @param[in] color   The color to use

+	 * @param[in] filled  Should the box should be filled

+	 *

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

+

+		x1 = x+cx-1;

+		y1 = y+cy-1;

+

+		if (cx > 2) {

+			if (cy >= 1) {

+				gdisp_lld_drawline(x, y, x1, y, color);

+				if (cy >= 2) {

+					gdisp_lld_drawline(x, y1, x1, y1, color);

+					if (cy > 2) {

+						gdisp_lld_drawline(x, y+1, x, y1-1, color);

+						gdisp_lld_drawline(x1, y+1, x1, y1-1, color);

+					}

+				}

+			}

+		} else if (cx == 2) {

+			gdisp_lld_drawline(x, y, x, y1, color);

+			gdisp_lld_drawline(x1, y, x1, y1, color);

+		} else if (cx == 1) {

+			gdisp_lld_drawline(x, y, x, y1, color);

+		}

+	}

+#endif

+

+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a text string.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x,y     The position for the text

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

+		/* No mutex required as we only call high level functions which have their own mutex */

+		coord_t		w, p;

+		char		c;

+		int			first;

+		

+		first = 1;

+		p = font->charPadding * font->xscale;

+		while(*str) {

+			/* Get the next printable character */

+			c = *str++;

+			w = _getCharWidth(font, c) * font->xscale;

+			if (!w) continue;

+			

+			/* Handle inter-character padding */

+			if (p) {

+				if (!first)

+					x += p;

+				else

+					first = 0;

+			}

+			

+			/* Print the character */

+			gdispDrawChar(x, y, c, font, color);

+			x += w;

+		}

+	}

+#endif

+	

+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a text string.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 *

+	 * @param[in] x,y     The position for the text

+	 * @param[in] str     The string to draw

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

+		/* No mutex required as we only call high level functions which have their own mutex */

+		coord_t		w, h, p;

+		char		c;

+		int			first;

+		

+		first = 1;

+		h = font->height * font->yscale;

+		p = font->charPadding * font->xscale;

+		while(*str) {

+			/* Get the next printable character */

+			c = *str++;

+			w = _getCharWidth(font, c) * font->xscale;

+			if (!w) continue;

+			

+			/* Handle inter-character padding */

+			if (p) {

+				if (!first) {

+					gdispFillArea(x, y, p, h, bgcolor);

+					x += p;

+				} else

+					first = 0;

+			}

+

+			/* Print the character */

+			gdispFillChar(x, y, c, font, color, bgcolor);

+			x += w;

+		}

+	}

+#endif

+	

+#if GDISP_NEED_TEXT || defined(__DOXYGEN__)

+	/**

+	 * @brief   Draw a text string verticly centered within the specified box.

+	 * @pre     The GDISP unit must be in powerOn or powerSleep mode.

+	 * @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] str     The string to draw

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

+		/* No mutex required as we only call high level functions which have their own mutex */

+		coord_t		w, h, p, ypos, xpos;

+		char		c;

+		int			first;

+		const char *rstr;

+		

+		h = font->height * font->yscale;

+		p = font->charPadding * font->xscale;

+

+		/* Oops - font too large for the area */

+		if (h > cy) return;

+

+		/* See if we need to fill above the font */

+		ypos = (cy - h + 1)/2;

+		if (ypos > 0) {

+			gdispFillArea(x, y, cx, ypos, bgcolor);

+			y += ypos;

+			cy -= ypos;

+		}

+		

+		/* See if we need to fill below the font */

+		ypos = cy - h;

+		if (ypos > 0) {

+			gdispFillArea(x, y+cy-ypos, cx, ypos, bgcolor);

+			cy -= ypos;

+		}

+		

+		/* get the start of the printable string and the xpos */

+		switch(justify) {

+		case justifyCenter:

+			/* Get the length of the entire string */

+			w = gdispGetStringWidth(str, font);

+			if (w <= cx)

+				xpos = x + (cx - w)/2;

+			else {

+				/* Calculate how much of the string we need to get rid of */

+				ypos = (w - cx)/2;

+				xpos = 0;

+				first = 1;

+				while(*str) {

+					/* Get the next printable character */

+					c = *str++;

+					w = _getCharWidth(font, c) * font->xscale;

+					if (!w) continue;

+					

+					/* Handle inter-character padding */

+					if (p) {

+						if (!first) {

+							xpos += p;

+							if (xpos > ypos) break;

+						} else

+							first = 0;

+					}

+

+					/* Print the character */

+					xpos += w;

+					if (xpos > ypos) break;

+				}

+				xpos = ypos - xpos + x;

+			}

+			break;

+		case justifyRight:

+			/* Find the end of the string */

+			for(rstr = str; *str; str++);

+			xpos = x+cx - 2;

+			first = 1;

+			for(str--; str >= rstr; str--) {

+				/* Get the next printable character */

+				c = *str;

+				w = _getCharWidth(font, c) * font->xscale;

+				if (!w) continue;

+				

+				/* Handle inter-character padding */

+				if (p) {

+					if (!first) {

+						if (xpos - p < x) break;

+						xpos -= p;

+					} else

+						first = 0;

+				}

+

+				/* Print the character */

+				if (xpos - w < x) break;

+				xpos -= w;

+			}

+			str++;

+			break;

+		case justifyLeft:

+			/* Fall through */

+		default:

+			xpos = x+1;

+			break;

+		}

+		

+		/* Fill any space to the left */

+		if (x < xpos)

+			gdispFillArea(x, y, xpos-x, cy, bgcolor);

+		

+		/* Print characters until we run out of room */

+		first = 1;

+		while(*str) {

+			/* Get the next printable character */

+			c = *str++;

+			w = _getCharWidth(font, c) * font->xscale;

+			if (!w) continue;

+			

+			/* Handle inter-character padding */

+			if (p) {

+				if (!first) {

+					if (xpos + p > x+cx) break;

+					gdispFillArea(xpos, y, p, cy, bgcolor);

+					xpos += p;

+				} else

+					first = 0;

+			}

+

+			/* Print the character */

+			if (xpos + w > x+cx) break;

+			gdispFillChar(xpos, y, c, font, color, bgcolor);

+			xpos += w;

+		}

+		

+		/* Fill any space to the right */

+		if (xpos < x+cx)

+			gdispFillArea(xpos, y, x+cx-xpos, cy, bgcolor);

+	}

+#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

+	 */

+	coord_t gdispGetFontMetric(font_t font, fontmetric_t metric) {

+		/* No mutex required as we only read static data */

+		switch(metric) {

+		case fontHeight:			return font->height * font->yscale;

+		case fontDescendersHeight:	return font->descenderHeight * font->yscale;

+		case fontLineSpacing:		return font->lineSpacing * font->yscale;

+		case fontCharPadding:		return font->charPadding * font->xscale;

+		case fontMinWidth:			return font->minWidth * font->xscale;

+		case fontMaxWidth:			return font->maxWidth * font->xscale;

+		}

+		return 0;

+	}

+#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

+	 */

+	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

+	 */

+	coord_t gdispGetStringWidth(const char* str, font_t font) {

+		/* No mutex required as we only read static data */

+		coord_t		w, h, p, x;

+		char		c;

+		int			first;

+		

+		first = 1;

+		x = 0;

+		h = font->height * font->yscale;

+		p = font->charPadding * font->xscale;

+		while(*str) {

+			/* Get the next printable character */

+			c = *str++;

+			w = _getCharWidth(font, c)  * font->xscale;

+			if (!w) continue;

+			

+			/* Handle inter-character padding */

+			if (p) {

+				if (!first)

+					x += p;

+				else

+					first = 0;

+			}

+			

+			/* Add the character width */

+			x += w;

+		}

+		return x;

+	}

+#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_CLIPPING has been specified.

+	 *

+	 * @param[in] buf		The buffer to put the pixel in

+	 * @param[in] cx		The width of a pixel line

+	 * @param[in] x, y		The location of the pixel to place

+	 * @param[in] color		The color to put into the buffer

+	 *

+	 * @api

+	 */

+	void gdispPackPixels(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color) {

+		/* No mutex required as we only read static data */

+		#if defined(GDISP_PIXELFORMAT_RGB888)

+			#error "GDISP: Packed pixels not supported yet"

+		#elif defined(GDISP_PIXELFORMAT_RGB444)

+			#error "GDISP: Packed pixels not supported yet"

+		#elif defined(GDISP_PIXELFORMAT_RGB666)

+			#error "GDISP: Packed pixels not supported yet"

+		#elif

+			#error "GDISP: Unsupported packed pixel format"

+		#endif

+	}

+#endif

+

+#endif /* HAL_USE_GDISP */

+/** @} */

diff --git a/halext/src/gdisp_emulation.c b/halext/src/gdisp_emulation.c
new file mode 100644
index 00000000..26562e92
--- /dev/null
+++ b/halext/src/gdisp_emulation.c
@@ -0,0 +1,463 @@
+/*

+    ChibiOS/RT - Copyright (C) 2012

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

+

+    This file is part of ChibiOS-LCD-Driver.

+

+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.

+*/

+

+/*

+	Emulation routines included into gdisp_lld.c

+*/

+

+/*

+	Even though this is a software emulation of a low level driver

+	most validation doesn't need to happen here as eventually

+	we call a real low level driver routine and if validation is

+	required - it will do it.

+*/

+#include "ch.h"

+#include "hal.h"

+#include "gdisp.h"

+

+#if HAL_USE_GDISP || defined(__DOXYGEN__)

+

+#ifdef UNUSED

+#elif defined(__GNUC__)

+# define UNUSED(x) UNUSED_ ## x __attribute__((unused))

+#elif defined(__LCLINT__)

+# define UNUSED(x) /*@unused@*/ x

+#else

+# define UNUSED(x) x

+#endif

+

+#if !GDISP_HARDWARE_POWERCONTROL

+	void gdisp_lld_setpowermode(gdisp_powermode_t UNUSED(powerMode)) {

+	}

+#endif

+

+#if !GDISP_HARDWARE_ORIENTATION

+	void gdisp_lld_setorientation(gdisp_orientation_t UNUSED(newOrientation)) {

+	}

+#endif

+

+#if !GDISP_HARDWARE_CLEARS 

+	void gdisp_lld_clear(color_t color) {

+		gdisp_lld_fillarea(0, 0, GDISP.Width, GDISP.Height, color);

+	}

+#endif

+

+#if !GDISP_HARDWARE_LINES 

+	void gdisp_lld_drawline(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {

+		int16_t dy, dx;

+		int16_t addx, addy;

+		int16_t P, diff, i;

+

+		#if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL

+		// speed improvement if vertical or horizontal

+		if (x0 == x1) {

+			if (y1 > y0)

+				gdisp_lld_fillarea(x0, y0, 1, y1-y0+1, color);

+			else

+				gdisp_lld_fillarea(x0, y1, 1, y0-y1+1, color);

+			return;

+		}

+		if (y0 == y1) {

+			if (x1 > x0)

+				gdisp_lld_fillarea(x0, y0, x1-x0+1, 1, color);

+			else

+				gdisp_lld_fillarea(x0, y1, x0-x1+1, 1, color);

+			return;

+		}

+		#endif

+

+		if (x1 >= x0) {

+			dx = x1 - x0;

+			addx = 1;

+		} else {

+			dx = x0 - x1;

+			addx = -1;

+		}

+		if (y1 >= y0) {

+			dy = y1 - y0;

+			addy = 1;

+		} else {

+			dy = y0 - y1;

+			addy = -1;

+		}

+

+		if (dx >= dy) {

+			dy *= 2;

+			P = dy - dx;

+			diff = P - dx;

+

+			for(i=0; i<=dx; ++i) {

+				gdisp_lld_drawpixel(x0, y0, color);

+				if (P < 0) {

+					P  += dy;

+					x0 += addx;

+				} else {

+					P  += diff;

+					x0 += addx;

+					y0 += addy;

+				}

+			}

+		} else {

+			dx *= 2;

+			P = dx - dy;

+			diff = P - dy;

+

+			for(i=0; i<=dy; ++i) {

+				gdisp_lld_drawpixel(x0, y0, color);

+				if (P < 0) {

+					P  += dx;

+					y0 += addy;

+				} else {

+					P  += diff;

+					x0 += addx;

+					y0 += addy;

+				}

+			}

+		}

+	}

+#endif

+

+#if !GDISP_HARDWARE_FILLS

+	void gdisp_lld_fillarea(coord_t x, coord_t y, coord_t cx, coord_t cy, color_t color) {

+		#if GDISP_HARDWARE_SCROLL

+			gdisp_lld_verticalscroll(x, y, cx, cy, cy, color);

+		#elif GDISP_HARDWARE_LINES

+			coord_t x1, y1;

+			

+			x1 = x + cx - 1;

+			y1 = y + cy;

+			for(; y < y1; y++)

+				gdisp_lld_drawline(x, y, x1, y, color);

+		#else

+			coord_t x0, x1, y1;

+			

+			x0 = x;

+			x1 = x + cx;

+			y1 = y + cy;

+			for(; y < y1; y++)

+				for(x = x0; x < x1; x++)

+					gdisp_lld_drawpixel(x, y, color);

+		#endif

+	}

+#endif

+

+#if !GDISP_HARDWARE_BITFILLS

+	void gdisp_lld_blitarea(coord_t x, coord_t y, coord_t cx, coord_t cy, pixel_t *buffer) {

+			coord_t x0, x1, y1;

+			

+			x0 = x;

+			x1 = x + cx;

+			y1 = y + cy;

+			for(; y < y1; y++)

+				for(x = x0; x < x1; x++)

+					gdisp_lld_drawpixel(x, y, *buffer++);

+	}

+#endif

+

+#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLES

+	void gdisp_lld_drawcircle(coord_t x, coord_t y, coord_t radius, color_t color) {

+		int16_t a, b, P;

+

+		a = 0;

+		b = radius;

+		P = 1 - radius;

+

+		do {

+			gdisp_lld_drawpixel(a+x, b+y, color);

+			gdisp_lld_drawpixel(b+x, a+y, color);

+			gdisp_lld_drawpixel(x-a, b+y, color);

+			gdisp_lld_drawpixel(x-b, a+y, color);

+			gdisp_lld_drawpixel(b+x, y-a, color);

+			gdisp_lld_drawpixel(a+x, y-b, color);

+			gdisp_lld_drawpixel(x-a, y-b, color);

+			gdisp_lld_drawpixel(x-b, y-a, color);

+			if (P < 0)

+				P += 3 + 2*a++;

+			else

+				P += 5 + 2*(a++ - b--);

+		} while(a <= b);

+	}

+#endif

+

+#if GDISP_NEED_CIRCLE && !GDISP_HARDWARE_CIRCLEFILLS

+	void gdisp_lld_fillcircle(coord_t x, coord_t y, coord_t radius, color_t color) {

+		int16_t a, b, P;

+		

+		a = 0;

+		b = radius;

+		P = 1 - radius;

+

+		do {

+			gdisp_lld_drawline(x-a, y+b, x+a, y+b, color);

+			gdisp_lld_drawline(x-a, y-b, x+a, y-b, color);

+			gdisp_lld_drawline(x-b, y+a, x+b, y+a, color);

+			gdisp_lld_drawline(x-b, y-a, x+b, y-a, color);

+			if (P < 0)

+				P += 3 + 2*a++;

+			else

+				P += 5 + 2*(a++ - b--);

+		} while(a <= b);

+	}

+#endif

+

+#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSES

+	void gdisp_lld_drawellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {

+		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */

+		long a2 = a*a, b2 = b*b;

+		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

+

+		do {

+			gdisp_lld_drawpixel(x+dx, y+dy, color); /* I. Quadrant */

+			gdisp_lld_drawpixel(x-dx, y+dy, color); /* II. Quadrant */

+			gdisp_lld_drawpixel(x-dx, y-dy, color); /* III. Quadrant */

+			gdisp_lld_drawpixel(x+dx, y-dy, color); /* IV. Quadrant */

+

+			e2 = 2*err;

+			if(e2 <  (2*dx+1)*b2) {

+				dx++;

+				err += (2*dx+1)*b2;

+			}

+			if(e2 > -(2*dy-1)*a2) {

+				dy--;

+				err -= (2*dy-1)*a2;

+			}

+		} while(dy >= 0); 

+

+		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */

+			gdisp_lld_drawpixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */

+			gdisp_lld_drawpixel(x-dx, y, color);

+	   }   

+	}

+#endif

+

+#if GDISP_NEED_ELLIPSE && !GDISP_HARDWARE_ELLIPSEFILLS

+	void gdisp_lld_fillellipse(coord_t x, coord_t y, coord_t a, coord_t b, color_t color) {

+		int  dx = 0, dy = b; /* im I. Quadranten von links oben nach rechts unten */

+		long a2 = a*a, b2 = b*b;

+		long err = b2-(2*b-1)*a2, e2; /* Fehler im 1. Schritt */

+

+		do {

+			gdisp_lld_drawline(x-dx,y+dy,x+dx,y+dy, color);

+			gdisp_lld_drawline(x-dx,y-dy,x+dx,y-dy, color);

+

+			e2 = 2*err;

+			if(e2 <  (2*dx+1)*b2) {

+				dx++;

+				err += (2*dx+1)*b2;

+			}

+			if(e2 > -(2*dy-1)*a2) {

+				dy--;

+				err -= (2*dy-1)*a2;

+			}

+		} while(dy >= 0); 

+

+		while(dx++ < a) { /* fehlerhafter Abbruch bei flachen Ellipsen (b=1) */

+			gdisp_lld_drawpixel(x+dx, y, color); /* -> Spitze der Ellipse vollenden */

+			gdisp_lld_drawpixel(x-dx, y, color);

+	   }   

+	}

+#endif

+

+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

+	#include "gdisp_fonts.h"

+#endif

+

+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXT

+	void gdisp_lld_drawchar(coord_t x, coord_t y, char c, font_t font, color_t color) {

+		const fontcolumn_t	*ptr;

+		fontcolumn_t		column;

+		coord_t				width, height, xscale, yscale;

+		coord_t				i, j, xs, ys;

+

+		/* Check we actually have something to print */

+		width = _getCharWidth(font, c);

+		if (!width) return;

+		

+		xscale = font->xscale;

+		yscale = font->yscale;

+		height = font->height * yscale;

+		width *= xscale;

+

+		ptr = _getCharData(font, c);

+

+		/* Loop through the data and display. The font data is LSBit first, down the column */

+		for(i=0; i < width; i+=xscale) {

+			/* Get the font bitmap data for the column */

+			column = *ptr++;

+			

+			/* Draw each pixel */

+			for(j=0; j < height; j+=yscale, column >>= 1) {

+				if (column & 0x01) {

+					for(xs=0; xs < xscale; xs++)

+						for(ys=0; ys < yscale; ys++)

+							gdisp_lld_drawpixel(x+i+xs, y+j+ys, color);

+				}

+			}

+		}

+	}

+#endif

+

+#if GDISP_NEED_TEXT && !GDISP_HARDWARE_TEXTFILLS

+	void gdisp_lld_fillchar(coord_t x, coord_t y, char c, font_t font, color_t color, color_t bgcolor) {

+		coord_t			width, height;

+		coord_t			xscale, yscale;

+		

+		/* Check we actually have something to print */

+		width = _getCharWidth(font, c);

+		if (!width) return;

+

+		xscale = font->xscale;

+		yscale = font->yscale;

+		height = font->height * yscale;

+		width *= xscale;

+

+		/* Method 1: Use background fill and then draw the text */

+		#if GDISP_HARDWARE_TEXT || GDISP_SOFTWARE_TEXTFILLDRAW

+			

+			/* Fill the area */

+			gdisp_lld_fillarea(x, y, width, height, bgcolor);

+			

+			/* Draw the text */

+			gdisp_lld_drawchar(x, y, c, font, color);

+

+		/* Method 2: Create a single column bitmap and then blit it */

+		#elif GDISP_HARDWARE_BITFILLS && GDISP_SOFTWARE_TEXTBLITCOLUMN

+		{

+			const fontcolumn_t	*ptr;

+			fontcolumn_t		column;

+			coord_t				i, j, xs, ys;

+

+			/* Working buffer for fast non-transparent text rendering [patch by Badger]

+				This needs to be larger than the largest character we can print.

+				Assume the max is double sized by one column.

+			*/

+			static pixel_t		buf[sizeof(fontcolumn_t)*8*2];

+

+			#if GDISP_NEED_VALIDATION

+				/* Check our buffer is big enough */

+				if (height > sizeof(buf)/sizeof(buf[0]))	return;

+			#endif

+

+			ptr = _getCharData(font, c);

+

+			/* Loop through the data and display. The font data is LSBit first, down the column */

+			for(i = 0; i < width; i+=xscale) {

+				/* Get the font bitmap data for the column */

+				column = *ptr++;

+				

+				/* Draw each pixel */

+				for(j = 0; j < height; j+=yscale, column >>= 1) {

+					if (column & 0x01) {

+						for(ys=0; ys < yscale; ys++)

+							gdispPackPixels(buf, 1, j+ys, 0, color);

+					} else {

+						for(ys=0; ys < yscale; ys++)

+							gdispPackPixels(buf, 1, j+ys, 0, bgcolor);

+					}

+				}

+

+				for(xs=0; xs < xscale; xs++)

+					gdisp_lld_blitarea(x+i+xs, y, 1, height, buf);

+			}

+		}

+

+		/* Method 3: Create a character bitmap and then blit it */

+		#elif GDISP_HARDWARE_BITFILLS

+		{

+			const fontcolumn_t	*ptr;

+			fontcolumn_t		column;

+			coord_t				i, j, xs, ys;

+			

+			/* Working buffer for fast non-transparent text rendering [patch by Badger]

+				This needs to be larger than the largest character we can print.

+				Assume the max is double sized.

+			*/

+			static pixel_t		buf[20*(sizeof(fontcolumn_t)*8)*2];

+

+			#if GDISP_NEED_VALIDATION

+				/* Check our buffer is big enough */

+				if (width * height > sizeof(buf)/sizeof(buf[0]))	return;

+			#endif

+

+			ptr = _getCharData(font, c);

+

+			/* Loop through the data and display. The font data is LSBit first, down the column */

+			for(i = 0; i < width; i+=xscale) {

+				/* Get the font bitmap data for the column */

+				column = *ptr++;

+				

+				/* Draw each pixel */

+				for(j = 0; j < height; j+=yscale, column >>= 1) {

+					if (column & 0x01) {

+						for(xs=0; xs < xscale; xs++)

+							for(ys=0; ys < yscale; ys++)

+								gdispPackPixels(buf, width, i+xs, j+ys, color);

+					} else {

+						for(xs=0; xs < xscale; xs++)

+							for(ys=0; ys < yscale; ys++)

+								gdispPackPixels(buf, width, i+xs, j+ys, bgcolor);

+					}

+				}

+			}

+

+			/* [Patch by Badger] Write all in one stroke */

+			gdisp_lld_blitarea(x, y, width, height, buf);

+		}

+

+		/* Method 4: Draw pixel by pixel */

+		#else

+		{

+			const fontcolumn_t	*ptr;

+			fontcolumn_t		column;

+			coord_t				i, j, xs, ys;

+

+			ptr = _getCharData(font, c);

+

+			/* Loop through the data and display. The font data is LSBit first, down the column */

+			for(i = 0; i < width; i+=xscale) {

+				/* Get the font bitmap data for the column */

+				column = *ptr++;

+				

+				/* Draw each pixel */

+				for(j = 0; j < height; j+=yscale, column >>= 1) {

+					if (column & 0x01) {

+						for(xs=0; xs < xscale; xs++)

+							for(ys=0; ys < yscale; ys++)

+								gdisp_lld_drawpixel(x+i, y+j, color);

+					} else {

+						for(xs=0; xs < xscale; xs++)

+							for(ys=0; ys < yscale; ys++)

+								gdisp_lld_drawpixel(x+i, y+j, bgcolor);

+					}

+				}

+			}

+		}

+		#endif

+	}

+#endif

+

+

+#if GDISP_NEED_CONTROL && !GDISP_HARDWARE_CONTROL

+	void gdisp_lld_control(int UNUSED(what), void *UNUSED(value)) {

+		/* Ignore everything */

+	}

+#endif

+

+#endif  /* HAL_USE_GDISP */

diff --git a/halext/src/gdisp_fonts.c b/halext/src/gdisp_fonts.c
new file mode 100644
index 00000000..25a56526
--- /dev/null
+++ b/halext/src/gdisp_fonts.c
@@ -0,0 +1,655 @@
+/*

+    ChibiOS/RT - Copyright (C) 2012

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

+

+    This file is part of ChibiOS-LCD-Driver.

+

+    ChibiOS-LCD-Driver 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-LCD-Driver 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/>.

+*/

+/*

+	Font tables included into gdisp.c

+*/

+#include "ch.h"

+#include "hal.h"

+#include "gdisp.h"

+

+#if HAL_USE_GDISP || defined(__DOXYGEN__)

+

+#if GDISP_NEED_TEXT

+

+#include "gdisp_fonts.h"

+

+

+/* fontSmall - for side buttons */

+#if 1

+    /* Forward Declarations of internal arrays */

+    static const uint8_t        fontSmall_Widths[];

+    static const uint16_t       fontSmall_Offsets[];

+    static const fontcolumn_t   fontSmall_Data[];

+

+	const struct font fontSmall = { 11, 0, 14, 2, 2, 12, ' ', '~', 1, 1,

+	                                fontSmall_Widths,

+	                                fontSmall_Offsets,

+	                                fontSmall_Data};

+	const struct font fontSmallDouble = { 11, 0, 14, 2, 2, 12, ' ', '~', 2, 2,

+	                                fontSmall_Widths,

+	                                fontSmall_Offsets,

+	                                fontSmall_Data};

+	const struct font fontSmallNarrow = { 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 1

+    /* Forward Declarations of internal arrays */

+    static const uint8_t        fontLarger_Widths[];

+    static const uint16_t       fontLarger_Offsets[];

+    static const fontcolumn_t   fontLarger_Data[];

+

+	const struct font fontLarger = { 12, 1, 13, 2, 2, 13, ' ', '~', 1, 1,

+	                                 fontLarger_Widths,

+	                                 fontLarger_Offsets,

+	                                 fontLarger_Data};

+	const struct font fontLargerDouble = { 12, 1, 13, 2, 2, 13, ' ', '~', 2, 2,

+									 fontLarger_Widths,

+	                                 fontLarger_Offsets,

+	                                 fontLarger_Data};

+	const struct font fontLargerNarrow = { 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 1

+	/* Forward Declarations of internal arrays */

+    static const uint8_t        fontUI1_Widths[];

+    static const uint16_t       fontUI1_Offsets[];

+    static const fontcolumn_t   fontUI1_Data[];

+

+	const struct font fontUI1 = { 13, 0, 15, 2, 3, 13, ' ', '~', 1, 1,

+	                              fontUI1_Widths,

+	                              fontUI1_Offsets,

+	                              fontUI1_Data};

+	const struct font fontUI1Double = { 13, 0, 15, 2, 3, 13, ' ', '~', 2, 2,

+	                              fontUI1_Widths,

+	                              fontUI1_Offsets,

+	                              fontUI1_Data};

+	const struct font fontUI1Narrow = { 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 1

+	/* Forward Declarations of internal arrays */

+	static const uint8_t        fontUI2_Widths[];

+	static const uint16_t       fontUI2_Offsets[];

+	static const fontcolumn_t   fontUI2_Data[];

+

+	const struct font fontUI2 = { 11, 1, 13, 2, 2, 12, ' ', '~', 1, 1,

+	                              fontUI2_Widths,

+	                              fontUI2_Offsets,

+	                              fontUI2_Data};

+	const struct font fontUI2Double = { 11, 1, 13, 2, 2, 12, ' ', '~', 2, 2,

+	                              fontUI2_Widths,

+	                              fontUI2_Offsets,

+	                              fontUI2_Data};

+	const struct font fontUI2Narrow = { 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 1

+	/* Forward Declarations of internal arrays */

+    static const uint8_t        fontLargeNumbers_Widths[];

+    static const uint16_t       fontLargeNumbers_Offsets[];

+    static const fontcolumn_t   fontLargeNumbers_Data[];

+

+	const struct font fontLargeNumbers = { 16, 2, 21, 1, 3, 15, '%', ':', 1, 1,

+	                                       fontLargeNumbers_Widths,

+	                                       fontLargeNumbers_Offsets,

+	                                       fontLargeNumbers_Data};

+	const struct font fontLargeNumbersDouble = { 16, 2, 21, 1, 3, 15, '%', ':', 2, 2,

+	                                       fontLargeNumbers_Widths,

+	                                       fontLargeNumbers_Offsets,

+	                                       fontLargeNumbers_Data};

+	const struct font fontLargeNumbersNarrow = { 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

+

+#endif /* GDISP_NEED_TEXT */

+

+#endif /* HAL_USE_GDISP */