Extracted font structure definitions, re-organised some files, added gdispS6d1121 driver

Created gdisp_fonts.h to describe the internal structure of a font.
Moved template directory to templates and created a sub-folder for each
low level driver type.
Moved the pre-defined font data and emulation code into better
locations.
Changed the emulation code to be included in the low level driver (where
it should be) instead of the high level driver.
Added new low level driver gdispS6d1121 (someone please test)
Updated and added new readme's.

4 files changed, 1126 insertions, 7 deletions

diff --git a/halext/include/gdisp.h b/halext/include/gdisp.h
index 036f2fd4..12f9995c 100644
--- a/halext/include/gdisp.h
+++ b/halext/include/gdisp.h
@@ -256,7 +256,10 @@
 	#define gdispPackPixels(buf,cx,x,y,c)	{ ((color_t *)(buf))[(y)*(cx)+(x)] = (c); }
 #elif !GDISP_HARDWARE_BITFILLS
 	#error "GDISP: packed pixel formats are only supported for hardware accelerated drivers."
-#elif !defined(GDISP_PIXELFORMAT_RGB888) && !defined(GDISP_PIXELFORMAT_RGB444) && !defined(GDISP_PIXELFORMAT_RGB666) && !defined(GDISP_PIXELFORMAT_CUSTOM)
+#elif !defined(GDISP_PIXELFORMAT_RGB888) \
+		&& !defined(GDISP_PIXELFORMAT_RGB444) \
+		&& !defined(GDISP_PIXELFORMAT_RGB666) \
+		&& !defined(GDISP_PIXELFORMAT_CUSTOM)
 	#error "GDISP: A packed pixel format has been specified for an unsupported pixel format."
 #endif
 
@@ -382,20 +385,20 @@ extern "C" {
 
 #endif
 
-	/* Extra Text Functions */
-	#if GDISP_NEED_TEXT
+/* Extra Text Functions */
+#if GDISP_NEED_TEXT
 	void gdispDrawString(coord_t x, coord_t y, const char *str, font_t font, color_t color);
 	void gdispFillString(coord_t x, coord_t y, const char *str, font_t font, color_t color, color_t bgcolor);
 	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);
 	coord_t gdispGetFontMetric(font_t font, fontmetric_t metric);
 	coord_t gdispGetCharWidth(char c, font_t font);
 	coord_t gdispGetStringWidth(const char* str, font_t font);
-	#endif
+#endif
 
-	/* Support routine for packed pixel formats */
-	#ifndef gdispPackPixels
+/* Support routine for packed pixel formats */
+#ifndef gdispPackPixels
 	void gdispPackPixels(pixel_t *buf, coord_t cx, coord_t x, coord_t y, color_t color);
-	#endif
+#endif
 
 #ifdef __cplusplus
 }
diff --git a/halext/include/gdisp_fonts.h b/halext/include/gdisp_fonts.h
new file mode 100644
index 00000000..d1cad898
--- /dev/null
+++ b/halext/include/gdisp_fonts.h
@@ -0,0 +1,104 @@
+/*

+    ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,

+                 2011,2012 Giovanni Di Sirio.

+

+    This file is part of ChibiOS/RT.

+

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

+

+                                      ---

+

+    A special exception to the GPL can be applied should you wish to distribute

+    a combined work that includes ChibiOS/RT, without being obliged to provide

+    the source code for any proprietary components. See the file exception.txt

+    for full details of how and when the exception can be applied.

+*/

+/*

+   Concepts and parts of this file have been contributed by:

+		Joel Bodenmann aka Tectu	-> Maintainer

+		Andrew Hannam aka inmarket	-> Framework

+		Badger						-> console implementation and FSMC

+		Abhishek 					-> font rendering

+		Ben William					-> fastMath and lcdDrawEllipse()

+		Dongxu Li aka dxli			-> lcdDrawEllipse() filled option

+*/

+

+/**

+ * @file    gdisp_fonts.h

+ * @brief   GDISP internal font definitions.

+ * @details	This is not generally needed by an application. It is used

+ * 			by the low level drivers that need to understand a font.

+ *

+ * @addtogroup GDISP

+ * @{

+ */

+

+#ifndef _GDISP_FONTS_H

+#define _GDISP_FONTS_H

+

+/**

+ * @brief   The maximum height of a font.

+ * @details	Either 16 or 32. Defaults to 16

+ * @note	Setting this to 32 causes the font tables to take

+ *			twice the internal program memory.

+ */

+#ifndef GDISP_MAX_FONT_HEIGHT

+	#define GDISP_MAX_FONT_HEIGHT	16

+#endif

+

+/**

+ * @brief   The type of a font column.

+ * @note	Set by defining @p GDISP_MAX_FNT_HEIGHT appropriately.

+ */

+#if GDISP_MAX_FONT_HEIGHT == 16

+	typedef uint16_t	fontcolumn_t;

+#elif GDISP_MAX_FONT_HEIGHT == 32

+	typedef uint32_t	fontcolumn_t;

+#else

+	#error "GDISP: GDISP_MAX_FONT_HEIGHT must be either 16 or 32"

+#endif

+

+/**

+ * @brief   Internal font structure.

+ * @note	This structure is followed by:

+ *				1. An array of character widths (uint8_t)

+ *				2. An array of column data offsets (relative to the font structure)

+ *				3. Each characters array of column data (fontcolumn_t)

+ *			Each sub-structure must be padded to a multiple of 8 bytes

+ *			to allow the tables to work accross many different compilers.

+ */

+struct font {

+	uint8_t		height;

+	uint8_t		charPadding;

+	uint8_t		lineSpacing;

+	uint8_t		descenderHeight;

+	uint8_t		minWidth;

+	uint8_t		maxWidth;

+	char		minChar;

+	char		maxChar;

+	uint16_t	offsetTableOffset;

+	uint16_t	unused1;			/* ensure next field is padded to 8 byte boundary */

+	uint8_t		widthTable[];

+	};

+

+/**

+ * @brief   Macro's to get to the complex parts of the font structure.

+ */

+#define _getFontPart(f,o,t)		((t)(&((const uint8_t *)(f))[(o)]))

+#define _getCharWidth(f,c)		(((c) < (f)->minChar || (c) > (f)->maxChar) ? 0 : (f)->widthTable[c - (f)->minChar])

+#define _getCharOffset(f,c)		(_getFontPart((f), (f)->offsetTableOffset, const uint16_t *)[c - (f)->minChar])

+#define _getCharData(f,c)		_getFontPart((f), _getCharOffset((f),(c)), const fontcolumn_t *)

+

+#endif /* _GDISP_FONTS_H */

+/** @} */

diff --git a/halext/include/gdisp_inc_fonts.c.h b/halext/include/gdisp_inc_fonts.c.h
new file mode 100644
index 00000000..01869553
--- /dev/null
+++ b/halext/include/gdisp_inc_fonts.c.h
@@ -0,0 +1,580 @@
+/*
+    ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,
+                 2011,2012 Giovanni Di Sirio.
+
+    This file is part of ChibiOS/RT.
+
+    ChibiOS/RT 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/RT 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/>.
+
+                                      ---
+
+    A special exception to the GPL can be applied should you wish to distribute
+    a combined work that includes ChibiOS/RT, without being obliged to provide
+    the source code for any proprietary components. See the file exception.txt
+    for full details of how and when the exception can be applied.
+*/
+/*
+   Concepts and parts of this file have been contributed by:
+		Joel Bodenmann aka Tectu	-> Maintainer
+		Andrew Hannam aka inmarket	-> framework
+		Badger						-> console implementation and FSMC
+		Abhishek 					-> font rendering
+		Ben William					-> fastMath and lcdDrawEllipse()
+		Dongxu Li aka dxli			-> lcdDrawEllipse() filled option
+*/
+
+#include "gdisp_fonts.h"
+
+/*
+	Font tables included into gdisp.c
+*/
+
+/* Offset building macros */
+#define SF		sizeof(struct font)
+#define SC		sizeof(fontcolumn_t)
+
+/* fontSmall - for side buttons */
+#if 1
+	const struct font fontSmall = { 11, 0, 14, 2, 2, 12, ' ', '~', SF+96, 0};
+	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[] = {
+		SF+288+0*SC, SF+288+2*SC, SF+288+5*SC, SF+288+11*SC, SF+288+19*SC, SF+288+26*SC, SF+288+35*SC, SF+288+42*SC,
+		SF+288+45*SC, SF+288+49*SC, SF+288+53*SC, SF+288+58*SC, SF+288+65*SC, SF+288+69*SC, SF+288+73*SC, SF+288+76*SC,
+		SF+288+82*SC, SF+288+89*SC, SF+288+96*SC, SF+288+103*SC, SF+288+110*SC, SF+288+117*SC, SF+288+124*SC, SF+288+131*SC,
+		SF+288+138*SC, SF+288+145*SC, SF+288+152*SC, SF+288+155*SC, SF+288+159*SC, SF+288+165*SC, SF+288+172*SC, SF+288+178*SC,
+		SF+288+185*SC, SF+288+197*SC, SF+288+205*SC, SF+288+212*SC, SF+288+220*SC, SF+288+228*SC, SF+288+235*SC, SF+288+242*SC,
+		SF+288+250*SC, SF+288+258*SC, SF+288+261*SC, SF+288+266*SC, SF+288+274*SC, SF+288+281*SC, SF+288+290*SC, SF+288+298*SC,
+		SF+288+306*SC, SF+288+314*SC, SF+288+322*SC, SF+288+330*SC, SF+288+337*SC, SF+288+344*SC, SF+288+352*SC, SF+288+360*SC,
+		SF+288+372*SC, SF+288+380*SC, SF+288+388*SC, SF+288+396*SC, SF+288+400*SC, SF+288+406*SC, SF+288+410*SC, SF+288+417*SC,
+		SF+288+424*SC, SF+288+428*SC, SF+288+435*SC, SF+288+442*SC, SF+288+449*SC, SF+288+456*SC, SF+288+463*SC, SF+288+467*SC,
+		SF+288+474*SC, SF+288+481*SC, SF+288+484*SC, SF+288+487*SC, SF+288+494*SC, SF+288+497*SC, SF+288+506*SC, SF+288+513*SC,
+		SF+288+520*SC, SF+288+527*SC, SF+288+534*SC, SF+288+538*SC, SF+288+544*SC, SF+288+548*SC, SF+288+555*SC, SF+288+562*SC,
+		SF+288+571*SC, SF+288+577*SC, SF+288+583*SC, SF+288+589*SC, SF+288+594*SC, SF+288+597*SC, SF+288+602*SC, 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
+	const struct font fontLarger = { 12, 1, 13, 2, 2, 13, ' ', '~', SF+96, 0};
+	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[] = {
+		SF+288+0*SC, SF+288+2*SC, SF+288+5*SC, SF+288+10*SC, SF+288+18*SC, SF+288+25*SC, SF+288+38*SC, SF+288+46*SC,
+		SF+288+48*SC, SF+288+52*SC, SF+288+56*SC, SF+288+63*SC, SF+288+71*SC, SF+288+74*SC, SF+288+78*SC, SF+288+81*SC,
+		SF+288+86*SC, SF+288+93*SC, SF+288+100*SC, SF+288+107*SC, SF+288+114*SC, SF+288+121*SC, SF+288+128*SC, SF+288+135*SC,
+		SF+288+142*SC, SF+288+149*SC, SF+288+156*SC, SF+288+159*SC, SF+288+162*SC, SF+288+171*SC, SF+288+179*SC, SF+288+188*SC,
+		SF+288+194*SC, SF+288+203*SC, SF+288+211*SC, SF+288+218*SC, SF+288+225*SC, SF+288+233*SC, SF+288+239*SC, SF+288+244*SC,
+		SF+288+251*SC, SF+288+259*SC, SF+288+263*SC, SF+288+268*SC, SF+288+275*SC, SF+288+281*SC, SF+288+291*SC, SF+288+298*SC,
+		SF+288+306*SC, SF+288+313*SC, SF+288+321*SC, SF+288+329*SC, SF+288+336*SC, SF+288+342*SC, SF+288+349*SC, SF+288+356*SC,
+		SF+288+367*SC, SF+288+374*SC, SF+288+380*SC, SF+288+386*SC, SF+288+390*SC, SF+288+395*SC, SF+288+399*SC, SF+288+408*SC,
+		SF+288+416*SC, SF+288+421*SC, SF+288+427*SC, SF+288+434*SC, SF+288+439*SC, SF+288+446*SC, SF+288+452*SC, SF+288+457*SC,
+		SF+288+464*SC, SF+288+471*SC, SF+288+473*SC, SF+288+476*SC, SF+288+482*SC, SF+288+484*SC, SF+288+494*SC, SF+288+501*SC,
+		SF+288+508*SC, SF+288+515*SC, SF+288+522*SC, SF+288+526*SC, SF+288+531*SC, SF+288+536*SC, SF+288+543*SC, SF+288+549*SC,
+		SF+288+559*SC, SF+288+565*SC, SF+288+571*SC, SF+288+576*SC, SF+288+582*SC, SF+288+586*SC, SF+288+592*SC, 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
+	const struct font fontUI1 = { 13, 0, 15, 2, 3, 13, ' ', '~', SF+96, 0};
+	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[] = {
+		SF+288+0*SC, SF+288+3*SC, SF+288+6*SC, SF+288+12*SC, SF+288+20*SC, SF+288+27*SC, SF+288+40*SC, SF+288+49*SC,
+		SF+288+52*SC, SF+288+57*SC, SF+288+62*SC, SF+288+68*SC, SF+288+76*SC, SF+288+79*SC, SF+288+84*SC, SF+288+87*SC,
+		SF+288+94*SC, SF+288+101*SC, SF+288+108*SC, SF+288+115*SC, SF+288+122*SC, SF+288+129*SC, SF+288+136*SC, SF+288+143*SC,
+		SF+288+150*SC, SF+288+157*SC, SF+288+164*SC, SF+288+167*SC, SF+288+170*SC, SF+288+178*SC, SF+288+186*SC, SF+288+194*SC,
+		SF+288+200*SC, SF+288+210*SC, SF+288+218*SC, SF+288+225*SC, SF+288+232*SC, SF+288+240*SC, SF+288+247*SC, SF+288+254*SC,
+		SF+288+262*SC, SF+288+270*SC, SF+288+275*SC, SF+288+280*SC, SF+288+287*SC, SF+288+294*SC, SF+288+303*SC, SF+288+311*SC,
+		SF+288+319*SC, SF+288+326*SC, SF+288+334*SC, SF+288+342*SC, SF+288+349*SC, SF+288+357*SC, SF+288+365*SC, SF+288+372*SC,
+		SF+288+383*SC, SF+288+390*SC, SF+288+397*SC, SF+288+404*SC, SF+288+409*SC, SF+288+416*SC, SF+288+421*SC, SF+288+430*SC,
+		SF+288+438*SC, SF+288+443*SC, SF+288+450*SC, SF+288+457*SC, SF+288+463*SC, SF+288+470*SC, SF+288+477*SC, SF+288+482*SC,
+		SF+288+489*SC, SF+288+496*SC, SF+288+499*SC, SF+288+503*SC, SF+288+510*SC, SF+288+513*SC, SF+288+524*SC, SF+288+531*SC,
+		SF+288+538*SC, SF+288+545*SC, SF+288+552*SC, SF+288+558*SC, SF+288+564*SC, SF+288+569*SC, SF+288+576*SC, SF+288+583*SC,
+		SF+288+592*SC, SF+288+599*SC, SF+288+606*SC, SF+288+612*SC, SF+288+619*SC, SF+288+623*SC, SF+288+630*SC, 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
+	const struct font fontUI2 = { 11, 1, 13, 2, 2, 12, ' ', '~', SF+96, 0};
+	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[] = {
+		SF+288+0*SC, SF+288+2*SC, SF+288+4*SC, SF+288+9*SC, SF+288+17*SC, SF+288+23*SC, SF+288+35*SC, SF+288+43*SC,
+		SF+288+45*SC, SF+288+49*SC, SF+288+53*SC, SF+288+59*SC, SF+288+67*SC, SF+288+69*SC, SF+288+73*SC, SF+288+75*SC,
+		SF+288+80*SC, SF+288+86*SC, SF+288+92*SC, SF+288+98*SC, SF+288+104*SC, SF+288+110*SC, SF+288+116*SC, SF+288+122*SC,
+		SF+288+128*SC, SF+288+134*SC, SF+288+140*SC, SF+288+142*SC, SF+288+144*SC, SF+288+152*SC, SF+288+160*SC, SF+288+168*SC,
+		SF+288+173*SC, SF+288+182*SC, SF+288+189*SC, SF+288+195*SC, SF+288+201*SC, SF+288+208*SC, SF+288+213*SC, SF+288+218*SC,
+		SF+288+225*SC, SF+288+232*SC, SF+288+236*SC, SF+288+241*SC, SF+288+247*SC, SF+288+252*SC, SF+288+261*SC, SF+288+267*SC,
+		SF+288+274*SC, SF+288+280*SC, SF+288+287*SC, SF+288+294*SC, SF+288+300*SC, SF+288+306*SC, SF+288+313*SC, SF+288+319*SC,
+		SF+288+329*SC, SF+288+335*SC, SF+288+341*SC, SF+288+347*SC, SF+288+351*SC, SF+288+356*SC, SF+288+360*SC, SF+288+367*SC,
+		SF+288+374*SC, SF+288+378*SC, SF+288+384*SC, SF+288+390*SC, SF+288+395*SC, SF+288+401*SC, SF+288+407*SC, SF+288+411*SC,
+		SF+288+417*SC, SF+288+423*SC, SF+288+425*SC, SF+288+428*SC, SF+288+434*SC, SF+288+436*SC, SF+288+446*SC, SF+288+452*SC,
+		SF+288+458*SC, SF+288+464*SC, SF+288+470*SC, SF+288+474*SC, SF+288+479*SC, SF+288+483*SC, SF+288+489*SC, SF+288+495*SC,
+		SF+288+503*SC, SF+288+509*SC, SF+288+515*SC, SF+288+520*SC, SF+288+526*SC, SF+288+530*SC, SF+288+536*SC, 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
+	const struct font fontLargeNumbers = { 16, 2, 21, 1, 3, 15, '%', ':', SF+24, 0};
+	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[] = {
+		SF+72+0*SC, 0, 0, 0, 0, 0, SF+72+15*SC, SF+72+26*SC,
+		SF+72+29*SC, SF+72+35*SC, 0, SF+72+38*SC, SF+72+48*SC, SF+72+58*SC, SF+72+68*SC, SF+72+78*SC,
+		SF+72+88*SC, SF+72+98*SC, SF+72+108*SC, SF+72+118*SC, SF+72+128*SC, SF+72+138*SC, 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
diff --git a/halext/include/gdisp_lld_inc_emulation.c.h b/halext/include/gdisp_lld_inc_emulation.c.h
new file mode 100644
index 00000000..623e85a5
--- /dev/null
+++ b/halext/include/gdisp_lld_inc_emulation.c.h
@@ -0,0 +1,432 @@
+/*

+    ChibiOS/RT - Copyright (C) 2006,2007,2008,2009,2010,

+                 2011,2012 Giovanni Di Sirio.

+

+    This file is part of ChibiOS/RT.

+

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

+

+                                      ---

+

+    A special exception to the GPL can be applied should you wish to distribute

+    a combined work that includes ChibiOS/RT, without being obliged to provide

+    the source code for any proprietary components. See the file exception.txt

+    for full details of how and when the exception can be applied.

+*/

+/*

+   Concepts and parts of this file have been contributed by:

+		Joel Bodenmann aka Tectu	-> Maintainer

+		Andrew Hannam aka inmarket	-> Framework

+		Badger						-> console implementation and FSMC

+		Abhishek 					-> font rendering

+		Ben William					-> fastMath and lcdDrawEllipse()

+		Dongxu Li aka dxli			-> lcdDrawEllipse() filled option

+*/

+

+/*

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

+*/

+

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

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

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

+	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, i, j;

+

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

+		width = _getCharWidth(font, c);

+		if (!width) return;

+		

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

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

+			column = *ptr++;

+			

+			/* Draw each pixel */

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

+				if (column & 0x01)

+					gdisp_lld_drawpixel(x+i, y+j, 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;

+		

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

+		width = _getCharWidth(font, c);

+		if (!width) return;

+

+		/* 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, font->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;

+			

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

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

+

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

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

+				column = *ptr++;

+				

+				/* Draw each pixel */

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

+					gdispPackPixels(buf, 1, i, 0, (column & 0x01) ? color : bgcolor);

+				}

+

+				gdisp_lld_blitarea(x+i, y, 1, font->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;

+			

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

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

+			*/

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

+

+			#if GDISP_NEED_VALIDATION

+				/* Check our buffer is big enough */

+				if (width * font->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++) {

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

+				column = *ptr++;

+				

+				/* Draw each pixel */

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

+					gdispPackPixels(buf, width, i, j, (column & 0x01) ? color : bgcolor);

+				}

+			}

+

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

+			gdisp_lld_blitarea(x, y, width, font->height, buf);

+		}

+

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

+		#else

+		{

+			const fontcolumn_t	*ptr;

+			fontcolumn_t		column;

+			coord_t				i, j;

+			

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

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

+				column = *ptr++;

+				

+				/* Draw each pixel */

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

+					gdisp_lld_drawpixel(x+i, y+j, (column & 0x01) ? color : bgcolor);

+				}

+			}

+		}

+		#endif

+	}

+#endif