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.
ugfx_release_2.6
Andrew Hannam 2012-08-04 02:23:05 +10:00
parent 1888e57b62
commit 37c1266a51
10 changed files with 1287 additions and 233 deletions

View File

@ -139,9 +139,6 @@ void Delay (unsigned long a) {
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
/* Include the software emulation routines */
#include "gdisp_lld_inc_emulation.c.h"
/* ---- Required Routines ---- */ /* ---- Required Routines ---- */
/* /*
The following 2 routines are required. The following 2 routines are required.
@ -645,6 +642,10 @@ void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color) {
} }
#endif #endif
#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__)
#include "gdisp_fonts.h"
#endif
#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__) #if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__)
/** /**
* @brief Draw a character using a transparent background. * @brief Draw a character using a transparent background.

View File

@ -1,208 +1,208 @@
/* /*
ChibiOS/RT - Copyright (C) 2012 ChibiOS/RT - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org> Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS-LCD-Driver. This file is part of ChibiOS-LCD-Driver.
ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify 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 it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or the Free Software Foundation; either version 3 of the License, or
(at your option) any later version. (at your option) any later version.
ChibiOS-LCD-Driver is distributed in the hope that it will be useful, ChibiOS-LCD-Driver is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. along with this program. If not, see <http://www.gnu.org/licenses/>.
*/ */
/** /**
* @file gdispNokia6610/gdisp_lld_config.h * @file gdispNokia6610/gdisp_lld_config.h
* @brief GDISP Graphic Driver subsystem low level driver header for the Nokia6610 display. * @brief GDISP Graphic Driver subsystem low level driver header for the Nokia6610 display.
* *
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#ifndef _GDISP_LLD_CONFIG_H #ifndef _GDISP_LLD_CONFIG_H
#define _GDISP_LLD_CONFIG_H #define _GDISP_LLD_CONFIG_H
#if HAL_USE_GDISP || defined(__DOXYGEN__) #if HAL_USE_GDISP || defined(__DOXYGEN__)
/*===========================================================================*/ /*===========================================================================*/
/* Driver pre-compile time settings. */ /* Driver pre-compile time settings. */
/*===========================================================================*/ /*===========================================================================*/
/** /**
* @name GDISP hardware accelerated support * @name GDISP hardware accelerated support
* @{ * @{
*/ */
/** /**
* @brief Hardware supports changing the orientation. * @brief Hardware supports changing the orientation.
* @details If set to @p FALSE a software stubb is provided. * @details If set to @p FALSE a software stubb is provided.
*/ */
#define GDISP_HARDWARE_ORIENTATION FALSE #define GDISP_HARDWARE_ORIENTATION FALSE
/** /**
* @brief Hardware supports power control. * @brief Hardware supports power control.
* @details If set to @p FALSE a software stubb is provided. * @details If set to @p FALSE a software stubb is provided.
*/ */
#define GDISP_HARDWARE_POWERCONTROL FALSE #define GDISP_HARDWARE_POWERCONTROL FALSE
/** /**
* @brief Hardware accelerated line drawing. * @brief Hardware accelerated line drawing.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_LINES FALSE #define GDISP_HARDWARE_LINES FALSE
/** /**
* @brief Hardware accelerated box drawing. * @brief Hardware accelerated box drawing.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_BOX FALSE #define GDISP_HARDWARE_BOX FALSE
/** /**
* @brief Hardware accelerated screen clears. * @brief Hardware accelerated screen clears.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_CLEARS FALSE #define GDISP_HARDWARE_CLEARS FALSE
/** /**
* @brief Hardware accelerated rectangular fills. * @brief Hardware accelerated rectangular fills.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_FILLS TRUE #define GDISP_HARDWARE_FILLS TRUE
/** /**
* @brief Hardware accelerated fills from an image. * @brief Hardware accelerated fills from an image.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_BITFILLS TRUE #define GDISP_HARDWARE_BITFILLS TRUE
/** /**
* @brief Hardware accelerated circles. * @brief Hardware accelerated circles.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_CIRCLES FALSE #define GDISP_HARDWARE_CIRCLES FALSE
/** /**
* @brief Hardware accelerated filled circles. * @brief Hardware accelerated filled circles.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_CIRCLEFILLS FALSE #define GDISP_HARDWARE_CIRCLEFILLS FALSE
/** /**
* @brief Hardware accelerated ellipses. * @brief Hardware accelerated ellipses.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_ELLIPSES FALSE #define GDISP_HARDWARE_ELLIPSES FALSE
/** /**
* @brief Hardware accelerated filled ellipses. * @brief Hardware accelerated filled ellipses.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_ELLIPSEFILLS FALSE #define GDISP_HARDWARE_ELLIPSEFILLS FALSE
/** /**
* @brief Hardware accelerated text drawing. * @brief Hardware accelerated text drawing.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_TEXT FALSE #define GDISP_HARDWARE_TEXT FALSE
/** /**
* @brief Hardware accelerated text drawing with a filled background. * @brief Hardware accelerated text drawing with a filled background.
* @details If set to @p FALSE software emulation is used. * @details If set to @p FALSE software emulation is used.
*/ */
#define GDISP_HARDWARE_TEXTFILLS FALSE #define GDISP_HARDWARE_TEXTFILLS FALSE
/** /**
* @brief Hardware accelerated scrolling. * @brief Hardware accelerated scrolling.
* @details If set to @p FALSE there is no support for scrolling. * @details If set to @p FALSE there is no support for scrolling.
*/ */
#define GDISP_HARDWARE_SCROLL FALSE #define GDISP_HARDWARE_SCROLL FALSE
/** /**
* @brief Reading back of pixel values. * @brief Reading back of pixel values.
* @details If set to @p FALSE there is no support for pixel read-back. * @details If set to @p FALSE there is no support for pixel read-back.
*/ */
#define GDISP_HARDWARE_PIXELREAD FALSE #define GDISP_HARDWARE_PIXELREAD FALSE
/** @} */ /** @} */
/** /**
* @name GDISP software algorithm choices * @name GDISP software algorithm choices
* @{ * @{
*/ */
/** /**
* @brief For filled text drawing, use a background fill and then draw * @brief For filled text drawing, use a background fill and then draw
* the text instead of using a blit or direct pixel drawing. * 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. * @details If set to @p TRUE background fill and then text draw is used.
* @note This is ignored if hardware accelerated text is supported. * @note This is ignored if hardware accelerated text is supported.
*/ */
#define GDISP_SOFTWARE_TEXTFILLDRAW FALSE #define GDISP_SOFTWARE_TEXTFILLDRAW TRUE
/** /**
* @brief For filled text drawing, when using a bitmap blit * @brief For filled text drawing, when using a bitmap blit
* use a column by column buffer rather than a full character * use a column by column buffer rather than a full character
* buffer to save memory at a small performance cost. * buffer to save memory at a small performance cost.
* @details If set to @p TRUE background fill one character column at a time. * @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. * @note This is ignored if software text using blit is not being used.
*/ */
#define GDISP_SOFTWARE_TEXTBLITCOLUMN FALSE #define GDISP_SOFTWARE_TEXTBLITCOLUMN FALSE
/** @} */ /** @} */
/** /**
* @name GDISP pixel format choices * @name GDISP pixel format choices
* @{ * @{
*/ */
/** /**
* @brief The native pixel format for this device * @brief The native pixel format for this device
* @note One of the following should be defined: * @note One of the following should be defined:
* GDISP_PIXELFORMAT_RGB565 * GDISP_PIXELFORMAT_RGB565
* GDISP_PIXELFORMAT_RGB888 * GDISP_PIXELFORMAT_RGB888
* GDISP_PIXELFORMAT_RGB444 * GDISP_PIXELFORMAT_RGB444
* GDISP_PIXELFORMAT_RGB332 * GDISP_PIXELFORMAT_RGB332
* GDISP_PIXELFORMAT_RGB666 * GDISP_PIXELFORMAT_RGB666
* GDISP_PIXELFORMAT_CUSTOM * GDISP_PIXELFORMAT_CUSTOM
* @note If you define GDISP_PIXELFORMAT_CUSTOM you need to also define * @note If you define GDISP_PIXELFORMAT_CUSTOM you need to also define
* color_t, RGB2COLOR(r,g,b), HTML2COLOR(h), * color_t, RGB2COLOR(r,g,b), HTML2COLOR(h),
* RED_OF(c), GREEN_OF(c), BLUE_OF(c), * RED_OF(c), GREEN_OF(c), BLUE_OF(c),
* COLOR(c) and MASKCOLOR. * COLOR(c) and MASKCOLOR.
*/ */
#define GDISP_PIXELFORMAT_RGB444 #define GDISP_PIXELFORMAT_RGB444
/** /**
* @brief Do pixels require packing for a blit * @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: * @note Is only valid for a pixel format that doesn't fill it's datatype. ie formats:
* GDISP_PIXELFORMAT_RGB888 * GDISP_PIXELFORMAT_RGB888
* GDISP_PIXELFORMAT_RGB444 * GDISP_PIXELFORMAT_RGB444
* GDISP_PIXELFORMAT_RGB666 * GDISP_PIXELFORMAT_RGB666
* GDISP_PIXELFORMAT_CUSTOM * GDISP_PIXELFORMAT_CUSTOM
* @note If you use GDISP_PIXELFORMAT_CUSTOM and packed bit fills * @note If you use GDISP_PIXELFORMAT_CUSTOM and packed bit fills
* you need to also define @P gdispPackPixels(buf,cx,x,y,c) * you need to also define @P gdispPackPixels(buf,cx,x,y,c)
* @note If you are using GDISP_HARDWARE_BITFILLS = FALSE then the pixel * @note If you are using GDISP_HARDWARE_BITFILLS = FALSE then the pixel
* format must not be a packed format as the software blit does * format must not be a packed format as the software blit does
* not support packed pixels * not support packed pixels
* @note Very few cases should actually require packed pixels as the low * @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 * level driver can also pack on the fly as it is sending it
* to the graphics device. * to the graphics device.
*/ */
#define GDISP_PACKED_PIXELS FALSE #define GDISP_PACKED_PIXELS FALSE
/** /**
* @brief Do lines of pixels require packing for a blit * @brief Do lines of pixels require packing for a blit
* @note Ignored if GDISP_PACKED_PIXELS is FALSE * @note Ignored if GDISP_PACKED_PIXELS is FALSE
*/ */
#define GDISP_PACKED_LINES FALSE #define GDISP_PACKED_LINES FALSE
/** /**
* @brief Do lines of pixels require packing for a blit * @brief Do lines of pixels require packing for a blit
* @note Ignored if GDISP_PACKED_PIXELS is FALSE * @note Ignored if GDISP_PACKED_PIXELS is FALSE
*/ */
#define GDISP_PACKED_LINES FALSE #define GDISP_PACKED_LINES FALSE
/** @} */ /** @} */
#endif /* HAL_USE_GDISP */ #endif /* HAL_USE_GDISP */
#endif /* _GDISP_LLD_CONFIG_H */ #endif /* _GDISP_LLD_CONFIG_H */
/** @} */ /** @} */

View File

@ -29,7 +29,6 @@
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "gdisp.h" #include "gdisp.h"
#include "gdisp_fonts.h"
#if HAL_USE_GDISP || defined(__DOXYGEN__) #if HAL_USE_GDISP || defined(__DOXYGEN__)
@ -72,9 +71,6 @@
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
/* Include the software emulation routines */
#include "gdisp_lld_inc_emulation.c.h"
/* ---- Required Routines ---- */ /* ---- Required Routines ---- */
/* /*
The following 2 routines are required. The following 2 routines are required.
@ -535,6 +531,10 @@ void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color) {
} }
#endif #endif
#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__)
#include "gdisp_fonts.h"
#endif
#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__) #if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__)
/** /**
* @brief Draw a character using a transparent background. * @brief Draw a character using a transparent background.

View File

@ -29,7 +29,6 @@
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "gdisp.h" #include "gdisp.h"
#include "gdisp_fonts.h"
#if HAL_USE_GDISP || defined(__DOXYGEN__) #if HAL_USE_GDISP || defined(__DOXYGEN__)
@ -72,9 +71,6 @@
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
/* Include the software emulation routines */
#include "gdisp_lld_inc_emulation.c.h"
/* ---- Required Routines ---- */ /* ---- Required Routines ---- */
/* /*
The following 2 routines are required. The following 2 routines are required.
@ -467,6 +463,10 @@ void gdisp_lld_drawpixel(coord_t x, coord_t y, color_t color) {
} }
#endif #endif
#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__)
#include "gdisp_fonts.h"
#endif
#if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__) #if (GDISP_NEED_TEXT && GDISP_HARDWARE_TEXT) || defined(__DOXYGEN__)
/** /**
* @brief Draw a character using a transparent background. * @brief Draw a character using a transparent background.

View File

@ -29,7 +29,6 @@
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "gdisp.h" #include "gdisp.h"
#include "gdisp_fonts.h"
#if HAL_USE_GDISP || defined(__DOXYGEN__) #if HAL_USE_GDISP || defined(__DOXYGEN__)
@ -70,9 +69,6 @@
/* Driver exported functions. */ /* Driver exported functions. */
/*===========================================================================*/ /*===========================================================================*/
/* Include the software emulation routines */
#include "gdisp_lld_inc_emulation.c.h"
/* ---- Required Routines ---- */ /* ---- Required Routines ---- */
/* /*
The following 2 routines are required. The following 2 routines are required.

View File

@ -1,6 +1,8 @@
# List of all the ChibiOS/RT META files, there is no need to remove the files # 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. # 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 # Required include directories
HALINC += ${CHIBIOS}/os/halext/include HALINC += ${CHIBIOS}/os/halext/include

View File

@ -54,6 +54,8 @@
#error "GDISP: GDISP_MAX_FONT_HEIGHT must be either 16 or 32" #error "GDISP: GDISP_MAX_FONT_HEIGHT must be either 16 or 32"
#endif #endif
typedef const fontcolumn_t * const pfontcolumn_t;
/** /**
* @brief Internal font structure. * @brief Internal font structure.
* @note This structure is followed by: * @note This structure is followed by:
@ -72,8 +74,8 @@ struct font {
uint8_t maxWidth; uint8_t maxWidth;
char minChar; char minChar;
char maxChar; char maxChar;
const fontcolumn_t *(* const offsetTable);
const uint8_t * const widthTable; const uint8_t * const widthTable;
const fontcolumn_t * const (* const offsetTable);
}; };
/** /**

View File

@ -25,15 +25,16 @@
* @addtogroup GDISP * @addtogroup GDISP
* @{ * @{
*/ */
#ifndef _GDISP_C
#define _GDISP_C
#include "ch.h" #include "ch.h"
#include "hal.h" #include "hal.h"
#include "gdisp.h" #include "gdisp.h"
#if HAL_USE_GDISP || defined(__DOXYGEN__) #if HAL_USE_GDISP || defined(__DOXYGEN__)
#ifdef GDISP_NEED_TEXT
#include "gdisp_fonts.h"
#endif
#if GDISP_NEED_MULTITHREAD #if GDISP_NEED_MULTITHREAD
#warning "GDISP: Multithread support not complete" #warning "GDISP: Multithread support not complete"
#define MUTEX_INIT /* Not defined yet */ #define MUTEX_INIT /* Not defined yet */
@ -58,10 +59,6 @@
/* Driver exported variables. */ /* Driver exported variables. */
/*===========================================================================*/ /*===========================================================================*/
#if GDISP_NEED_TEXT || defined(__DOXYGEN__)
#include "gdisp_inc_fonts.c.h"
#endif
/*===========================================================================*/ /*===========================================================================*/
/* Driver local variables. */ /* Driver local variables. */
/*===========================================================================*/ /*===========================================================================*/
@ -716,5 +713,4 @@
#endif #endif
#endif /* HAL_USE_GDISP */ #endif /* HAL_USE_GDISP */
#endif /* GDISP_C */
/** @} */ /** @} */

View File

@ -0,0 +1,436 @@
/*
ChibiOS/RT - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS-LCD-Driver.
ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS-LCD-Driver is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
Emulation routines included into gdisp_lld.c
*/
/*
Even though this is a software emulation of a low level driver
most validation doesn't need to happen here as eventually
we call a real low level driver routine and if validation is
required - it will do it.
*/
#include "ch.h"
#include "hal.h"
#include "gdisp.h"
#if HAL_USE_GDISP || defined(__DOXYGEN__)
#ifdef UNUSED
#elif defined(__GNUC__)
# define UNUSED(x) UNUSED_ ## x __attribute__((unused))
#elif defined(__LCLINT__)
# define UNUSED(x) /*@unused@*/ x
#else
# define UNUSED(x) x
#endif
#if !GDISP_HARDWARE_POWERCONTROL
void gdisp_lld_setpowermode(gdisp_powermode_t UNUSED(powerMode)) {
}
#endif
#if !GDISP_HARDWARE_ORIENTATION
void gdisp_lld_setorientation(gdisp_orientation_t UNUSED(newOrientation)) {
}
#endif
#if !GDISP_HARDWARE_CLEARS
void gdisp_lld_clear(color_t color) {
gdisp_lld_fillarea(0, 0, GDISP.Width, GDISP.Height, color);
}
#endif
#if !GDISP_HARDWARE_LINES
void gdisp_lld_drawline(coord_t x0, coord_t y0, coord_t x1, coord_t y1, color_t color) {
int16_t dy, dx;
int16_t addx, addy;
int16_t P, diff, i;
#if GDISP_HARDWARE_FILLS || GDISP_HARDWARE_SCROLL
// speed improvement if vertical or horizontal
if (x0 == x1) {
if (y1 > y0)
gdisp_lld_fillarea(x0, y0, 1, y1-y0+1, color);
else
gdisp_lld_fillarea(x0, y1, 1, y0-y1+1, color);
return;
}
if (y0 == y1) {
if (x1 > x0)
gdisp_lld_fillarea(x0, y0, x1-x0+1, 1, color);
else
gdisp_lld_fillarea(x0, y1, x0-x1+1, 1, color);
return;
}
#endif
if (x1 >= x0) {
dx = x1 - x0;
addx = 1;
} else {
dx = x0 - x1;
addx = -1;
}
if (y1 >= y0) {
dy = y1 - y0;
addy = 1;
} else {
dy = y0 - y1;
addy = -1;
}
if (dx >= dy) {
dy *= 2;
P = dy - dx;
diff = P - dx;
for(i=0; i<=dx; ++i) {
gdisp_lld_drawpixel(x0, y0, color);
if (P < 0) {
P += dy;
x0 += addx;
} else {
P += diff;
x0 += addx;
y0 += addy;
}
}
} else {
dx *= 2;
P = dx - dy;
diff = P - dy;
for(i=0; i<=dy; ++i) {
gdisp_lld_drawpixel(x0, y0, color);
if (P < 0) {
P += dx;
y0 += addy;
} else {
P += diff;
x0 += addx;
y0 += addy;
}
}
}
}
#endif
#if !GDISP_HARDWARE_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 */

View File

@ -0,0 +1,621 @@
/*
ChibiOS/RT - Copyright (C) 2012
Joel Bodenmann aka Tectu <joel@unormal.org>
This file is part of ChibiOS-LCD-Driver.
ChibiOS-LCD-Driver is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
ChibiOS-LCD-Driver is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
Font tables included into gdisp.c
*/
#include "ch.h"
#include "hal.h"
#include "gdisp.h"
#if HAL_USE_GDISP || defined(__DOXYGEN__)
#if GDISP_NEED_TEXT
#include "gdisp_fonts.h"
/* fontSmall - for side buttons */
#if 1
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 */