From 37c1266a51da4456648bf3b3bbe7777692bd77ec Mon Sep 17 00:00:00 2001 From: Andrew Hannam Date: Sat, 4 Aug 2012 02:23:05 +1000 Subject: [PATCH] Fix fonts nd fix debug symbols Fixed fonts for draw/fill char/string. On my display I require GDISP_SOFTWARE_TEXTFILLDRAW for filled char/string but that may because my display blit may be broken. Also found that code in header files doesn't have debug symbols generated for it so I converted the include files that contained code into real C files and altered the halext.mk to match. --- halext/drivers/gdispNokia6610/gdisp_lld.c | 7 +- .../drivers/gdispNokia6610/gdisp_lld_config.h | 416 ++++++------ halext/drivers/gdispS6d1121/gdisp_lld.c | 8 +- halext/drivers/gdispSsd1289/gdisp_lld.c | 8 +- halext/drivers/gdispTestStub/gdisp_lld.c | 4 - halext/halext.mk | 4 +- halext/include/gdisp_fonts.h | 4 +- halext/src/gdisp.c | 12 +- halext/src/gdisp_emulation.c | 436 ++++++++++++ halext/src/gdisp_fonts.c | 621 ++++++++++++++++++ 10 files changed, 1287 insertions(+), 233 deletions(-) create mode 100644 halext/src/gdisp_emulation.c create mode 100644 halext/src/gdisp_fonts.c diff --git a/halext/drivers/gdispNokia6610/gdisp_lld.c b/halext/drivers/gdispNokia6610/gdisp_lld.c index ce2b250c..93b6478b 100644 --- a/halext/drivers/gdispNokia6610/gdisp_lld.c +++ b/halext/drivers/gdispNokia6610/gdisp_lld.c @@ -139,9 +139,6 @@ void Delay (unsigned long a) { /* Driver exported functions. */ /*===========================================================================*/ -/* Include the software emulation routines */ -#include "gdisp_lld_inc_emulation.c.h" - /* ---- Required Routines ---- */ /* The following 2 routines are required. @@ -645,6 +642,10 @@ void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color) { } #endif +#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__) + #include "gdisp_fonts.h" +#endif + #if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__) /** * @brief Draw a character using a transparent background. diff --git a/halext/drivers/gdispNokia6610/gdisp_lld_config.h b/halext/drivers/gdispNokia6610/gdisp_lld_config.h index 38788eea..713dabc8 100644 --- a/halext/drivers/gdispNokia6610/gdisp_lld_config.h +++ b/halext/drivers/gdispNokia6610/gdisp_lld_config.h @@ -1,208 +1,208 @@ -/* - ChibiOS/RT - Copyright (C) 2012 - Joel Bodenmann aka Tectu - - 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 . -*/ - -/** - * @file gdispNokia6610/gdisp_lld_config.h - * @brief GDISP Graphic Driver subsystem low level driver header for the Nokia6610 display. - * - * @addtogroup GDISP - * @{ - */ - -#ifndef _GDISP_LLD_CONFIG_H -#define _GDISP_LLD_CONFIG_H - -#if HAL_USE_GDISP || defined(__DOXYGEN__) - -/*===========================================================================*/ -/* Driver pre-compile time settings. */ -/*===========================================================================*/ - -/** - * @name GDISP hardware accelerated support - * @{ - */ - /** - * @brief Hardware supports changing the orientation. - * @details If set to @p FALSE a software stubb is provided. - */ - #define GDISP_HARDWARE_ORIENTATION FALSE - - /** - * @brief Hardware supports power control. - * @details If set to @p FALSE a software stubb is provided. - */ - #define GDISP_HARDWARE_POWERCONTROL FALSE - - /** - * @brief Hardware accelerated line drawing. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_LINES FALSE - - /** - * @brief Hardware accelerated box drawing. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_BOX FALSE - - /** - * @brief Hardware accelerated screen clears. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_CLEARS FALSE - - /** - * @brief Hardware accelerated rectangular fills. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_FILLS TRUE - - /** - * @brief Hardware accelerated fills from an image. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_BITFILLS TRUE - - /** - * @brief Hardware accelerated circles. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_CIRCLES FALSE - - /** - * @brief Hardware accelerated filled circles. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_CIRCLEFILLS FALSE - - /** - * @brief Hardware accelerated ellipses. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_ELLIPSES FALSE - - /** - * @brief Hardware accelerated filled ellipses. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_ELLIPSEFILLS FALSE - - /** - * @brief Hardware accelerated text drawing. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_TEXT FALSE - - /** - * @brief Hardware accelerated text drawing with a filled background. - * @details If set to @p FALSE software emulation is used. - */ - #define GDISP_HARDWARE_TEXTFILLS FALSE - - /** - * @brief Hardware accelerated scrolling. - * @details If set to @p FALSE there is no support for scrolling. - */ - #define GDISP_HARDWARE_SCROLL FALSE - - /** - * @brief Reading back of pixel values. - * @details If set to @p FALSE there is no support for pixel read-back. - */ - #define GDISP_HARDWARE_PIXELREAD FALSE -/** @} */ - -/** - * @name GDISP software algorithm choices - * @{ - */ - /** - * @brief For filled text drawing, use a background fill and then draw - * the text instead of using a blit or direct pixel drawing. - * @details If set to @p TRUE background fill and then text draw is used. - * @note This is ignored if hardware accelerated text is supported. - */ - #define GDISP_SOFTWARE_TEXTFILLDRAW FALSE - /** - * @brief For filled text drawing, when using a bitmap blit - * use a column by column buffer rather than a full character - * buffer to save memory at a small performance cost. - * @details If set to @p TRUE background fill one character column at a time. - * @note This is ignored if software text using blit is not being used. - */ - #define GDISP_SOFTWARE_TEXTBLITCOLUMN FALSE -/** @} */ - -/** - * @name GDISP pixel format choices - * @{ - */ - /** - * @brief The native pixel format for this device - * @note One of the following should be defined: - * GDISP_PIXELFORMAT_RGB565 - * GDISP_PIXELFORMAT_RGB888 - * GDISP_PIXELFORMAT_RGB444 - * GDISP_PIXELFORMAT_RGB332 - * GDISP_PIXELFORMAT_RGB666 - * GDISP_PIXELFORMAT_CUSTOM - * @note If you define GDISP_PIXELFORMAT_CUSTOM you need to also define - * color_t, RGB2COLOR(r,g,b), HTML2COLOR(h), - * RED_OF(c), GREEN_OF(c), BLUE_OF(c), - * COLOR(c) and MASKCOLOR. - */ - #define GDISP_PIXELFORMAT_RGB444 - - /** - * @brief Do pixels require packing for a blit - * @note Is only valid for a pixel format that doesn't fill it's datatype. ie formats: - * GDISP_PIXELFORMAT_RGB888 - * GDISP_PIXELFORMAT_RGB444 - * GDISP_PIXELFORMAT_RGB666 - * GDISP_PIXELFORMAT_CUSTOM - * @note If you use GDISP_PIXELFORMAT_CUSTOM and packed bit fills - * you need to also define @P gdispPackPixels(buf,cx,x,y,c) - * @note If you are using GDISP_HARDWARE_BITFILLS = FALSE then the pixel - * format must not be a packed format as the software blit does - * not support packed pixels - * @note Very few cases should actually require packed pixels as the low - * level driver can also pack on the fly as it is sending it - * to the graphics device. - */ - #define GDISP_PACKED_PIXELS FALSE - - /** - * @brief Do lines of pixels require packing for a blit - * @note Ignored if GDISP_PACKED_PIXELS is FALSE - */ - #define GDISP_PACKED_LINES FALSE - - /** - * @brief Do lines of pixels require packing for a blit - * @note Ignored if GDISP_PACKED_PIXELS is FALSE - */ - #define GDISP_PACKED_LINES FALSE -/** @} */ - -#endif /* HAL_USE_GDISP */ - -#endif /* _GDISP_LLD_CONFIG_H */ -/** @} */ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + 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 . +*/ + +/** + * @file gdispNokia6610/gdisp_lld_config.h + * @brief GDISP Graphic Driver subsystem low level driver header for the Nokia6610 display. + * + * @addtogroup GDISP + * @{ + */ + +#ifndef _GDISP_LLD_CONFIG_H +#define _GDISP_LLD_CONFIG_H + +#if HAL_USE_GDISP || defined(__DOXYGEN__) + +/*===========================================================================*/ +/* Driver pre-compile time settings. */ +/*===========================================================================*/ + +/** + * @name GDISP hardware accelerated support + * @{ + */ + /** + * @brief Hardware supports changing the orientation. + * @details If set to @p FALSE a software stubb is provided. + */ + #define GDISP_HARDWARE_ORIENTATION FALSE + + /** + * @brief Hardware supports power control. + * @details If set to @p FALSE a software stubb is provided. + */ + #define GDISP_HARDWARE_POWERCONTROL FALSE + + /** + * @brief Hardware accelerated line drawing. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_LINES FALSE + + /** + * @brief Hardware accelerated box drawing. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_BOX FALSE + + /** + * @brief Hardware accelerated screen clears. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_CLEARS FALSE + + /** + * @brief Hardware accelerated rectangular fills. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_FILLS TRUE + + /** + * @brief Hardware accelerated fills from an image. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_BITFILLS TRUE + + /** + * @brief Hardware accelerated circles. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_CIRCLES FALSE + + /** + * @brief Hardware accelerated filled circles. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_CIRCLEFILLS FALSE + + /** + * @brief Hardware accelerated ellipses. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_ELLIPSES FALSE + + /** + * @brief Hardware accelerated filled ellipses. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_ELLIPSEFILLS FALSE + + /** + * @brief Hardware accelerated text drawing. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_TEXT FALSE + + /** + * @brief Hardware accelerated text drawing with a filled background. + * @details If set to @p FALSE software emulation is used. + */ + #define GDISP_HARDWARE_TEXTFILLS FALSE + + /** + * @brief Hardware accelerated scrolling. + * @details If set to @p FALSE there is no support for scrolling. + */ + #define GDISP_HARDWARE_SCROLL FALSE + + /** + * @brief Reading back of pixel values. + * @details If set to @p FALSE there is no support for pixel read-back. + */ + #define GDISP_HARDWARE_PIXELREAD FALSE +/** @} */ + +/** + * @name GDISP software algorithm choices + * @{ + */ + /** + * @brief For filled text drawing, use a background fill and then draw + * the text instead of using a blit or direct pixel drawing. + * @details If set to @p TRUE background fill and then text draw is used. + * @note This is ignored if hardware accelerated text is supported. + */ + #define GDISP_SOFTWARE_TEXTFILLDRAW TRUE + /** + * @brief For filled text drawing, when using a bitmap blit + * use a column by column buffer rather than a full character + * buffer to save memory at a small performance cost. + * @details If set to @p TRUE background fill one character column at a time. + * @note This is ignored if software text using blit is not being used. + */ + #define GDISP_SOFTWARE_TEXTBLITCOLUMN FALSE +/** @} */ + +/** + * @name GDISP pixel format choices + * @{ + */ + /** + * @brief The native pixel format for this device + * @note One of the following should be defined: + * GDISP_PIXELFORMAT_RGB565 + * GDISP_PIXELFORMAT_RGB888 + * GDISP_PIXELFORMAT_RGB444 + * GDISP_PIXELFORMAT_RGB332 + * GDISP_PIXELFORMAT_RGB666 + * GDISP_PIXELFORMAT_CUSTOM + * @note If you define GDISP_PIXELFORMAT_CUSTOM you need to also define + * color_t, RGB2COLOR(r,g,b), HTML2COLOR(h), + * RED_OF(c), GREEN_OF(c), BLUE_OF(c), + * COLOR(c) and MASKCOLOR. + */ + #define GDISP_PIXELFORMAT_RGB444 + + /** + * @brief Do pixels require packing for a blit + * @note Is only valid for a pixel format that doesn't fill it's datatype. ie formats: + * GDISP_PIXELFORMAT_RGB888 + * GDISP_PIXELFORMAT_RGB444 + * GDISP_PIXELFORMAT_RGB666 + * GDISP_PIXELFORMAT_CUSTOM + * @note If you use GDISP_PIXELFORMAT_CUSTOM and packed bit fills + * you need to also define @P gdispPackPixels(buf,cx,x,y,c) + * @note If you are using GDISP_HARDWARE_BITFILLS = FALSE then the pixel + * format must not be a packed format as the software blit does + * not support packed pixels + * @note Very few cases should actually require packed pixels as the low + * level driver can also pack on the fly as it is sending it + * to the graphics device. + */ + #define GDISP_PACKED_PIXELS FALSE + + /** + * @brief Do lines of pixels require packing for a blit + * @note Ignored if GDISP_PACKED_PIXELS is FALSE + */ + #define GDISP_PACKED_LINES FALSE + + /** + * @brief Do lines of pixels require packing for a blit + * @note Ignored if GDISP_PACKED_PIXELS is FALSE + */ + #define GDISP_PACKED_LINES FALSE +/** @} */ + +#endif /* HAL_USE_GDISP */ + +#endif /* _GDISP_LLD_CONFIG_H */ +/** @} */ diff --git a/halext/drivers/gdispS6d1121/gdisp_lld.c b/halext/drivers/gdispS6d1121/gdisp_lld.c index 8b98222c..fd7339c2 100644 --- a/halext/drivers/gdispS6d1121/gdisp_lld.c +++ b/halext/drivers/gdispS6d1121/gdisp_lld.c @@ -29,7 +29,6 @@ #include "ch.h" #include "hal.h" #include "gdisp.h" -#include "gdisp_fonts.h" #if HAL_USE_GDISP || defined(__DOXYGEN__) @@ -72,9 +71,6 @@ /* Driver exported functions. */ /*===========================================================================*/ -/* Include the software emulation routines */ -#include "gdisp_lld_inc_emulation.c.h" - /* ---- Required Routines ---- */ /* The following 2 routines are required. @@ -535,6 +531,10 @@ void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color) { } #endif +#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__) + #include "gdisp_fonts.h" +#endif + #if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__) /** * @brief Draw a character using a transparent background. diff --git a/halext/drivers/gdispSsd1289/gdisp_lld.c b/halext/drivers/gdispSsd1289/gdisp_lld.c index ef19792c..a16eb7d7 100644 --- a/halext/drivers/gdispSsd1289/gdisp_lld.c +++ b/halext/drivers/gdispSsd1289/gdisp_lld.c @@ -29,7 +29,6 @@ #include "ch.h" #include "hal.h" #include "gdisp.h" -#include "gdisp_fonts.h" #if HAL_USE_GDISP || defined(__DOXYGEN__) @@ -72,9 +71,6 @@ /* Driver exported functions. */ /*===========================================================================*/ -/* Include the software emulation routines */ -#include "gdisp_lld_inc_emulation.c.h" - /* ---- Required Routines ---- */ /* The following 2 routines are required. @@ -467,6 +463,10 @@ void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color) { } #endif +#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__) + #include "gdisp_fonts.h" +#endif + #if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__) /** * @brief Draw a character using a transparent background. diff --git a/halext/drivers/gdispTestStub/gdisp_lld.c b/halext/drivers/gdispTestStub/gdisp_lld.c index 0281e498..6140d0d6 100644 --- a/halext/drivers/gdispTestStub/gdisp_lld.c +++ b/halext/drivers/gdispTestStub/gdisp_lld.c @@ -29,7 +29,6 @@ #include "ch.h" #include "hal.h" #include "gdisp.h" -#include "gdisp_fonts.h" #if HAL_USE_GDISP || defined(__DOXYGEN__) @@ -70,9 +69,6 @@ /* Driver exported functions. */ /*===========================================================================*/ -/* Include the software emulation routines */ -#include "gdisp_lld_inc_emulation.c.h" - /* ---- Required Routines ---- */ /* The following 2 routines are required. diff --git a/halext/halext.mk b/halext/halext.mk index f5f47157..b0e1b8df 100644 --- a/halext/halext.mk +++ b/halext/halext.mk @@ -1,6 +1,8 @@ # List of all the ChibiOS/RT META files, there is no need to remove the files # from this list, you can disable parts of the kernel by editing halconf.h. -HALSRC += ${CHIBIOS}/os/halext/src/gdisp.c +HALSRC += ${CHIBIOS}/os/halext/src/gdisp.c \ + ${CHIBIOS}/os/halext/src/gdisp_fonts.c \ + ${CHIBIOS}/os/halext/src/gdisp_emulation.c # Required include directories HALINC += ${CHIBIOS}/os/halext/include diff --git a/halext/include/gdisp_fonts.h b/halext/include/gdisp_fonts.h index d2f7e4e7..f22e75df 100644 --- a/halext/include/gdisp_fonts.h +++ b/halext/include/gdisp_fonts.h @@ -54,6 +54,8 @@ #error "GDISP: GDISP_MAX_FONT_HEIGHT must be either 16 or 32" #endif +typedef const fontcolumn_t * const pfontcolumn_t; + /** * @brief Internal font structure. * @note This structure is followed by: @@ -72,8 +74,8 @@ struct font { uint8_t maxWidth; char minChar; char maxChar; - const fontcolumn_t *(* const offsetTable); const uint8_t * const widthTable; + const fontcolumn_t * const (* const offsetTable); }; /** diff --git a/halext/src/gdisp.c b/halext/src/gdisp.c index f3aaf887..cd3a839b 100644 --- a/halext/src/gdisp.c +++ b/halext/src/gdisp.c @@ -25,15 +25,16 @@ * @addtogroup GDISP * @{ */ -#ifndef _GDISP_C -#define _GDISP_C - #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 */ @@ -58,10 +59,6 @@ /* Driver exported variables. */ /*===========================================================================*/ -#if GDISP_NEED_TEXT || defined(__DOXYGEN__) - #include "gdisp_inc_fonts.c.h" -#endif - /*===========================================================================*/ /* Driver local variables. */ /*===========================================================================*/ @@ -716,5 +713,4 @@ #endif #endif /* HAL_USE_GDISP */ -#endif /* GDISP_C */ /** @} */ diff --git a/halext/src/gdisp_emulation.c b/halext/src/gdisp_emulation.c new file mode 100644 index 00000000..528986c9 --- /dev/null +++ b/halext/src/gdisp_emulation.c @@ -0,0 +1,436 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + 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 . +*/ + +/* + 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_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 + #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, 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, j, 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 + +#endif /* HAL_USE_GDISP */ diff --git a/halext/src/gdisp_fonts.c b/halext/src/gdisp_fonts.c new file mode 100644 index 00000000..108a871f --- /dev/null +++ b/halext/src/gdisp_fonts.c @@ -0,0 +1,621 @@ +/* + ChibiOS/RT - Copyright (C) 2012 + Joel Bodenmann aka Tectu + + 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 . +*/ +/* + 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 + 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 + }; + static const fontcolumn_t const *fontSmall_Offsets[] = { + fontSmall_Data+ 0, fontSmall_Data+ 2, fontSmall_Data+ 5, fontSmall_Data+ 11, + fontSmall_Data+ 19, fontSmall_Data+ 26, fontSmall_Data+ 35, fontSmall_Data+ 42, + fontSmall_Data+ 45, fontSmall_Data+ 49, fontSmall_Data+ 53, fontSmall_Data+ 58, + fontSmall_Data+ 65, fontSmall_Data+ 69, fontSmall_Data+ 73, fontSmall_Data+ 76, + fontSmall_Data+ 82, fontSmall_Data+ 89, fontSmall_Data+ 96, fontSmall_Data+103, + fontSmall_Data+110, fontSmall_Data+117, fontSmall_Data+124, fontSmall_Data+131, + fontSmall_Data+138, fontSmall_Data+145, fontSmall_Data+152, fontSmall_Data+155, + fontSmall_Data+159, fontSmall_Data+165, fontSmall_Data+172, fontSmall_Data+178, + fontSmall_Data+185, fontSmall_Data+197, fontSmall_Data+205, fontSmall_Data+212, + fontSmall_Data+220, fontSmall_Data+228, fontSmall_Data+235, fontSmall_Data+242, + fontSmall_Data+250, fontSmall_Data+258, fontSmall_Data+261, fontSmall_Data+266, + fontSmall_Data+274, fontSmall_Data+281, fontSmall_Data+290, fontSmall_Data+298, + fontSmall_Data+306, fontSmall_Data+314, fontSmall_Data+322, fontSmall_Data+330, + fontSmall_Data+337, fontSmall_Data+344, fontSmall_Data+352, fontSmall_Data+360, + fontSmall_Data+372, fontSmall_Data+380, fontSmall_Data+388, fontSmall_Data+396, + fontSmall_Data+400, fontSmall_Data+406, fontSmall_Data+410, fontSmall_Data+417, + fontSmall_Data+424, fontSmall_Data+428, fontSmall_Data+435, fontSmall_Data+442, + fontSmall_Data+449, fontSmall_Data+456, fontSmall_Data+463, fontSmall_Data+467, + fontSmall_Data+474, fontSmall_Data+481, fontSmall_Data+484, fontSmall_Data+487, + fontSmall_Data+494, fontSmall_Data+497, fontSmall_Data+506, fontSmall_Data+513, + fontSmall_Data+520, fontSmall_Data+527, fontSmall_Data+534, fontSmall_Data+538, + fontSmall_Data+544, fontSmall_Data+548, fontSmall_Data+555, fontSmall_Data+562, + fontSmall_Data+571, fontSmall_Data+577, fontSmall_Data+583, fontSmall_Data+589, + fontSmall_Data+594, fontSmall_Data+597, fontSmall_Data+602 + }; + 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 + }; + const struct font fontSmall = { 11, 0, 14, 2, 2, 12, ' ', '~', fontSmall_Widths, fontSmall_Offsets}; +#endif + +/* fontLarger - Tahoma, 11, Bold */ +#if 1 + 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 + }; + static const fontcolumn_t const *fontLarger_Offsets[] = { + fontLarger_Data+ 0, fontLarger_Data+ 2, fontLarger_Data+ 5, fontLarger_Data+ 10, + fontLarger_Data+ 18, fontLarger_Data+ 25, fontLarger_Data+ 38, fontLarger_Data+ 46, + fontLarger_Data+ 48, fontLarger_Data+ 52, fontLarger_Data+ 56, fontLarger_Data+ 63, + fontLarger_Data+ 71, fontLarger_Data+ 74, fontLarger_Data+ 78, fontLarger_Data+ 81, + fontLarger_Data+ 86, fontLarger_Data+ 93, fontLarger_Data+100, fontLarger_Data+107, + fontLarger_Data+114, fontLarger_Data+121, fontLarger_Data+128, fontLarger_Data+135, + fontLarger_Data+142, fontLarger_Data+149, fontLarger_Data+156, fontLarger_Data+159, + fontLarger_Data+162, fontLarger_Data+171, fontLarger_Data+179, fontLarger_Data+188, + fontLarger_Data+194, fontLarger_Data+203, fontLarger_Data+211, fontLarger_Data+218, + fontLarger_Data+225, fontLarger_Data+233, fontLarger_Data+239, fontLarger_Data+244, + fontLarger_Data+251, fontLarger_Data+259, fontLarger_Data+263, fontLarger_Data+268, + fontLarger_Data+275, fontLarger_Data+281, fontLarger_Data+291, fontLarger_Data+298, + fontLarger_Data+306, fontLarger_Data+313, fontLarger_Data+321, fontLarger_Data+329, + fontLarger_Data+336, fontLarger_Data+342, fontLarger_Data+349, fontLarger_Data+356, + fontLarger_Data+367, fontLarger_Data+374, fontLarger_Data+380, fontLarger_Data+386, + fontLarger_Data+390, fontLarger_Data+395, fontLarger_Data+399, fontLarger_Data+408, + fontLarger_Data+416, fontLarger_Data+421, fontLarger_Data+427, fontLarger_Data+434, + fontLarger_Data+439, fontLarger_Data+446, fontLarger_Data+452, fontLarger_Data+457, + fontLarger_Data+464, fontLarger_Data+471, fontLarger_Data+473, fontLarger_Data+476, + fontLarger_Data+482, fontLarger_Data+484, fontLarger_Data+494, fontLarger_Data+501, + fontLarger_Data+508, fontLarger_Data+515, fontLarger_Data+522, fontLarger_Data+526, + fontLarger_Data+531, fontLarger_Data+536, fontLarger_Data+543, fontLarger_Data+549, + fontLarger_Data+559, fontLarger_Data+565, fontLarger_Data+571, fontLarger_Data+576, + fontLarger_Data+582, fontLarger_Data+586, fontLarger_Data+592 + }; + 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 + }; + const struct font fontLarger = { 12, 1, 13, 2, 2, 13, ' ', '~', fontLarger_Widths, fontLarger_Offsets}; +#endif + +/* fontUI1 - UI Font 1 Medium Bold */ +#if 1 + 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 + }; + static const fontcolumn_t const *fontUI1_Offsets[] = { + fontUI1_Data+ 0, fontUI1_Data+ 3, fontUI1_Data+ 6, fontUI1_Data+ 12, + fontUI1_Data+ 20, fontUI1_Data+ 27, fontUI1_Data+ 40, fontUI1_Data+ 49, + fontUI1_Data+ 52, fontUI1_Data+ 57, fontUI1_Data+ 62, fontUI1_Data+ 68, + fontUI1_Data+ 76, fontUI1_Data+ 79, fontUI1_Data+ 84, fontUI1_Data+ 87, + fontUI1_Data+ 94, fontUI1_Data+101, fontUI1_Data+108, fontUI1_Data+115, + fontUI1_Data+122, fontUI1_Data+129, fontUI1_Data+136, fontUI1_Data+143, + fontUI1_Data+150, fontUI1_Data+157, fontUI1_Data+164, fontUI1_Data+167, + fontUI1_Data+170, fontUI1_Data+178, fontUI1_Data+186, fontUI1_Data+194, + fontUI1_Data+200, fontUI1_Data+210, fontUI1_Data+218, fontUI1_Data+225, + fontUI1_Data+232, fontUI1_Data+240, fontUI1_Data+247, fontUI1_Data+254, + fontUI1_Data+262, fontUI1_Data+270, fontUI1_Data+275, fontUI1_Data+280, + fontUI1_Data+287, fontUI1_Data+294, fontUI1_Data+303, fontUI1_Data+311, + fontUI1_Data+319, fontUI1_Data+326, fontUI1_Data+334, fontUI1_Data+342, + fontUI1_Data+349, fontUI1_Data+357, fontUI1_Data+365, fontUI1_Data+372, + fontUI1_Data+383, fontUI1_Data+390, fontUI1_Data+397, fontUI1_Data+404, + fontUI1_Data+409, fontUI1_Data+416, fontUI1_Data+421, fontUI1_Data+430, + fontUI1_Data+438, fontUI1_Data+443, fontUI1_Data+450, fontUI1_Data+457, + fontUI1_Data+463, fontUI1_Data+470, fontUI1_Data+477, fontUI1_Data+482, + fontUI1_Data+489, fontUI1_Data+496, fontUI1_Data+499, fontUI1_Data+503, + fontUI1_Data+510, fontUI1_Data+513, fontUI1_Data+524, fontUI1_Data+531, + fontUI1_Data+538, fontUI1_Data+545, fontUI1_Data+552, fontUI1_Data+558, + fontUI1_Data+564, fontUI1_Data+569, fontUI1_Data+576, fontUI1_Data+583, + fontUI1_Data+592, fontUI1_Data+599, fontUI1_Data+606, fontUI1_Data+612, + fontUI1_Data+619, fontUI1_Data+623, fontUI1_Data+630 + }; + 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 + }; + const struct font fontUI1 = { 13, 0, 15, 2, 3, 13, ' ', '~', fontUI1_Widths, fontUI1_Offsets}; +#endif + +/* fontUI1 - UI Font 2 Medium Bold */ +#if 1 + 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 + }; + static const fontcolumn_t const *fontUI2_Offsets[] = { + fontUI2_Data+ 0, fontUI2_Data+ 2, fontUI2_Data+ 4, fontUI2_Data+ 9, + fontUI2_Data+ 17, fontUI2_Data+ 23, fontUI2_Data+ 35, fontUI2_Data+ 43, + fontUI2_Data+ 45, fontUI2_Data+ 49, fontUI2_Data+ 53, fontUI2_Data+ 59, + fontUI2_Data+ 67, fontUI2_Data+ 69, fontUI2_Data+ 73, fontUI2_Data+ 75, + fontUI2_Data+ 80, fontUI2_Data+ 86, fontUI2_Data+ 92, fontUI2_Data+ 98, + fontUI2_Data+104, fontUI2_Data+110, fontUI2_Data+116, fontUI2_Data+122, + fontUI2_Data+128, fontUI2_Data+134, fontUI2_Data+140, fontUI2_Data+142, + fontUI2_Data+144, fontUI2_Data+152, fontUI2_Data+160, fontUI2_Data+168, + fontUI2_Data+173, fontUI2_Data+182, fontUI2_Data+189, fontUI2_Data+195, + fontUI2_Data+201, fontUI2_Data+208, fontUI2_Data+213, fontUI2_Data+218, + fontUI2_Data+225, fontUI2_Data+232, fontUI2_Data+236, fontUI2_Data+241, + fontUI2_Data+247, fontUI2_Data+252, fontUI2_Data+261, fontUI2_Data+267, + fontUI2_Data+274, fontUI2_Data+280, fontUI2_Data+287, fontUI2_Data+294, + fontUI2_Data+300, fontUI2_Data+306, fontUI2_Data+313, fontUI2_Data+319, + fontUI2_Data+329, fontUI2_Data+335, fontUI2_Data+341, fontUI2_Data+347, + fontUI2_Data+351, fontUI2_Data+356, fontUI2_Data+360, fontUI2_Data+367, + fontUI2_Data+374, fontUI2_Data+378, fontUI2_Data+384, fontUI2_Data+390, + fontUI2_Data+395, fontUI2_Data+401, fontUI2_Data+407, fontUI2_Data+411, + fontUI2_Data+417, fontUI2_Data+423, fontUI2_Data+425, fontUI2_Data+428, + fontUI2_Data+434, fontUI2_Data+436, fontUI2_Data+446, fontUI2_Data+452, + fontUI2_Data+458, fontUI2_Data+464, fontUI2_Data+470, fontUI2_Data+474, + fontUI2_Data+479, fontUI2_Data+483, fontUI2_Data+489, fontUI2_Data+495, + fontUI2_Data+503, fontUI2_Data+509, fontUI2_Data+515, fontUI2_Data+520, + fontUI2_Data+526, fontUI2_Data+530, fontUI2_Data+536 + }; + 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 + }; + const struct font fontUI2 = { 11, 1, 13, 2, 2, 12, ' ', '~', fontUI2_Widths, fontUI2_Offsets}; +#endif + +/* + fontLargeNumbers: + Large numbers font, height = 16 (including the decenders) + Characters include: 0 - 9, -, +, ., %, :, Space, Comma +*/ +#if 1 + 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 + }; + static const fontcolumn_t const *fontLargeNumbers_Offsets[] = { + fontLargeNumbers_Data+0, 0, 0, 0, 0, 0, fontLargeNumbers_Data+15, fontLargeNumbers_Data+26, + fontLargeNumbers_Data+29, fontLargeNumbers_Data+35, 0, fontLargeNumbers_Data+38, + fontLargeNumbers_Data+48, fontLargeNumbers_Data+58, fontLargeNumbers_Data+68, fontLargeNumbers_Data+78, + fontLargeNumbers_Data+88, fontLargeNumbers_Data+98, fontLargeNumbers_Data+108, fontLargeNumbers_Data+118, + fontLargeNumbers_Data+128, fontLargeNumbers_Data+138 + }; + 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 + }; + const struct font fontLargeNumbers = { 16, 2, 21, 1, 3, 15, '%', ':', fontLargeNumbers_Widths, fontLargeNumbers_Offsets}; +#endif + +#endif /* GDISP_NEED_TEXT */ + +#endif /* HAL_USE_GDISP */