diff options
Diffstat (limited to 'graphics')
31 files changed, 21441 insertions, 19800 deletions
diff --git a/graphics/VectorRenderer.cpp b/graphics/VectorRenderer.cpp index 4dbcd9845f..30ef9eeeeb 100644 --- a/graphics/VectorRenderer.cpp +++ b/graphics/VectorRenderer.cpp @@ -78,27 +78,29 @@ void VectorRenderer::stepGetPositions(const DrawStep &step, const Common::Rect & switch (step.xAlign) { case Graphics::DrawStep::kVectorAlignManual: - if (step.x >= 0) in_x = area.left + step.x; - else in_x = area.left + area.width() + step.x; // value relative to the opposite corner. + if (step.x >= 0) + in_x = area.left + step.x + step.padding.left; + else + in_x = area.left + area.width() + step.x + step.padding.left; // value relative to the opposite corner. break; case Graphics::DrawStep::kVectorAlignCenter: - in_x = area.left + (area.width() / 2) - (in_w / 2); + in_x = area.left + (area.width() / 2) - (in_w / 2) + ((step.padding.left + step.padding.right ) / 2); break; case Graphics::DrawStep::kVectorAlignLeft: - in_x = area.left; + in_x = area.left + step.padding.left; break; case Graphics::DrawStep::kVectorAlignRight: - in_x = area.left + area.width() - in_w; + in_x = area.left + area.width() - in_w - step.padding.right; break; default: error("Vertical alignment in horizontal data"); } } else { - in_x = area.left; + in_x = area.left + step.padding.left; in_w = area.width(); } @@ -107,27 +109,29 @@ void VectorRenderer::stepGetPositions(const DrawStep &step, const Common::Rect & switch (step.yAlign) { case Graphics::DrawStep::kVectorAlignManual: - if (step.y >= 0) in_y = area.top + step.y; - else in_y = area.top + area.height() + step.y; // relative + if (step.y >= 0) + in_y = area.top + step.y + step.padding.top; + else + in_y = area.top + area.height() + step.y + step.padding.top; // relative break; case Graphics::DrawStep::kVectorAlignCenter: - in_y = area.top + (area.height() / 2) - (in_h / 2); + in_y = area.top + (area.height() / 2) - (in_h / 2) + ((step.padding.top + step.padding.bottom ) / 2) ; break; case Graphics::DrawStep::kVectorAlignTop: - in_y = area.top; + in_y = area.top + step.padding.top; break; case Graphics::DrawStep::kVectorAlignBottom: - in_y = area.top + area.height() - in_h; + in_y = area.top + area.height() - in_h - step.padding.bottom; break; default: error("Horizontal alignment in vertical data"); } } else { - in_y = area.top; + in_y = area.top + step.padding.top; in_h = area.height(); } diff --git a/graphics/VectorRenderer.h b/graphics/VectorRenderer.h index ec8a8f7245..e98f4aa761 100644 --- a/graphics/VectorRenderer.h +++ b/graphics/VectorRenderer.h @@ -55,6 +55,8 @@ struct DrawStep { bool autoWidth, autoHeight; int16 x, y, w, h; /**< width, height and position, if not measured automatically. negative values mean counting from the opposite direction */ + + Common::Rect padding; enum VectorAlignment { kVectorAlignManual, @@ -491,7 +493,6 @@ protected: uint32 _dynamicData; /**< Dynamic data from the GUI Theme that modifies the drawing of the current shape */ int _gradientFactor; /**< Multiplication factor of the active gradient */ - int _gradientBytes[3]; /**< Color bytes of the active gradient, used to speed up calculation */ }; } // End of namespace Graphics diff --git a/graphics/VectorRendererSpec.cpp b/graphics/VectorRendererSpec.cpp index a2cb693b78..7817725664 100644 --- a/graphics/VectorRendererSpec.cpp +++ b/graphics/VectorRendererSpec.cpp @@ -77,7 +77,7 @@ inline frac_t fp_sqroot(uint32 x) { HELPER MACROS for Bresenham's circle drawing algorithm Note the proper spelling on this header. */ -#define __BE_ALGORITHM() { \ +#define BE_ALGORITHM() do { \ if (f >= 0) { \ y--; \ ddF_y += 2; \ @@ -87,37 +87,65 @@ inline frac_t fp_sqroot(uint32 x) { px += pitch; \ ddF_x += 2; \ f += ddF_x + 1; \ -} +} while(0) -#define __BE_DRAWCIRCLE(ptr1,ptr2,ptr3,ptr4,x,y,px,py) { \ +#define BE_DRAWCIRCLE_TOP(ptr1,ptr2,x,y,px,py) do { \ *(ptr1 + (y) - (px)) = color; \ *(ptr1 + (x) - (py)) = color; \ *(ptr2 - (x) - (py)) = color; \ *(ptr2 - (y) - (px)) = color; \ +} while (0) + +#define BE_DRAWCIRCLE_BOTTOM(ptr3,ptr4,x,y,px,py) do { \ *(ptr3 - (y) + (px)) = color; \ *(ptr3 - (x) + (py)) = color; \ *(ptr4 + (x) + (py)) = color; \ *(ptr4 + (y) + (px)) = color; \ -} +} while (0) + +#define BE_DRAWCIRCLE(ptr1,ptr2,ptr3,ptr4,x,y,px,py) do { \ + BE_DRAWCIRCLE_TOP(ptr1,ptr2,x,y,px,py); \ + BE_DRAWCIRCLE_BOTTOM(ptr3,ptr4,x,y,px,py); \ +} while (0) + +#define BE_DRAWCIRCLE_BCOLOR(ptr1,ptr2,ptr3,ptr4,x,y,px,py) do { \ + *(ptr1 + (y) - (px)) = color1; \ + *(ptr1 + (x) - (py)) = color1; \ + *(ptr2 - (x) - (py)) = color1; \ + *(ptr2 - (y) - (px)) = color1; \ + *(ptr3 - (y) + (px)) = color1; \ + *(ptr3 - (x) + (py)) = color1; \ + *(ptr4 + (x) + (py)) = color2; \ + *(ptr4 + (y) + (px)) = color2; \ +} while (0) -#define __BE_DRAWCIRCLE_XCOLOR(ptr1,ptr2,ptr3,ptr4,x,y,px,py) { \ +#define BE_DRAWCIRCLE_XCOLOR_TOP(ptr1,ptr2,x,y,px,py) do { \ *(ptr1 + (y) - (px)) = color1; \ *(ptr1 + (x) - (py)) = color2; \ *(ptr2 - (x) - (py)) = color2; \ *(ptr2 - (y) - (px)) = color1; \ +} while (0) + +#define BE_DRAWCIRCLE_XCOLOR_BOTTOM(ptr3,ptr4,x,y,px,py) do { \ *(ptr3 - (y) + (px)) = color3; \ *(ptr3 - (x) + (py)) = color4; \ *(ptr4 + (x) + (py)) = color4; \ *(ptr4 + (y) + (px)) = color3; \ -} +} while (0) + +#define BE_DRAWCIRCLE_XCOLOR(ptr1,ptr2,ptr3,ptr4,x,y,px,py) do { \ + BE_DRAWCIRCLE_XCOLOR_TOP(ptr1,ptr2,x,y,px,py); \ + BE_DRAWCIRCLE_XCOLOR_BOTTOM(ptr3,ptr4,x,y,px,py); \ +} while (0) + -#define __BE_RESET() { \ +#define BE_RESET() do { \ f = 1 - r; \ ddF_x = 0; ddF_y = -2 * r; \ x = 0; y = r; px = 0; py = pitch * r; \ -} +} while (0) -#define __TRIANGLE_MAINX() \ +#define TRIANGLE_MAINX() \ if (error_term >= 0) { \ ptr_right += pitch; \ ptr_left += pitch; \ @@ -128,7 +156,7 @@ inline frac_t fp_sqroot(uint32 x) { ptr_right++; \ ptr_left--; -#define __TRIANGLE_MAINY() \ +#define TRIANGLE_MAINY() \ if (error_term >= 0) { \ ptr_right++; \ ptr_left--; \ @@ -140,19 +168,63 @@ inline frac_t fp_sqroot(uint32 x) { ptr_left += pitch; /** HELPER MACROS for WU's circle drawing algorithm **/ -#define __WU_DRAWCIRCLE(ptr1,ptr2,ptr3,ptr4,x,y,px,py,a) { \ +#define WU_DRAWCIRCLE_TOP(ptr1,ptr2,x,y,px,py,a) do { \ this->blendPixelPtr(ptr1 + (y) - (px), color, a); \ this->blendPixelPtr(ptr1 + (x) - (py), color, a); \ this->blendPixelPtr(ptr2 - (x) - (py), color, a); \ this->blendPixelPtr(ptr2 - (y) - (px), color, a); \ +} while (0) + +#define WU_DRAWCIRCLE_BOTTOM(ptr3,ptr4,x,y,px,py,a) do { \ this->blendPixelPtr(ptr3 - (y) + (px), color, a); \ this->blendPixelPtr(ptr3 - (x) + (py), color, a); \ this->blendPixelPtr(ptr4 + (x) + (py), color, a); \ this->blendPixelPtr(ptr4 + (y) + (px), color, a); \ -} +} while (0) + +#define WU_DRAWCIRCLE(ptr1,ptr2,ptr3,ptr4,x,y,px,py,a) do { \ + WU_DRAWCIRCLE_TOP(ptr1,ptr2,x,y,px,py,a); \ + WU_DRAWCIRCLE_BOTTOM(ptr3,ptr4,x,y,px,py,a); \ +} while (0) + + +// Color depending on y +// Note: this is only for the outer pixels +#define WU_DRAWCIRCLE_XCOLOR_TOP(ptr1,ptr2,x,y,px,py,a,func) do { \ + this->func(ptr1 + (y) - (px), color1, a); \ + this->func(ptr1 + (x) - (py), color2, a); \ + this->func(ptr2 - (x) - (py), color2, a); \ + this->func(ptr2 - (y) - (px), color1, a); \ +} while (0) + +#define WU_DRAWCIRCLE_XCOLOR_BOTTOM(ptr3,ptr4,x,y,px,py,a,func) do { \ + this->func(ptr3 - (y) + (px), color3, a); \ + this->func(ptr3 - (x) + (py), color4, a); \ + this->func(ptr4 + (x) + (py), color4, a); \ + this->func(ptr4 + (y) + (px), color3, a); \ +} while (0) + +#define WU_DRAWCIRCLE_XCOLOR(ptr1,ptr2,ptr3,ptr4,x,y,px,py,a,func) do { \ + WU_DRAWCIRCLE_XCOLOR_TOP(ptr1,ptr2,x,y,px,py,a,func); \ + WU_DRAWCIRCLE_XCOLOR_BOTTOM(ptr3,ptr4,x,y,px,py,a,func); \ +} while (0) + +// Color depending on corner (tl,tr,bl: color1, br: color2) +// Note: this is only for the outer pixels +#define WU_DRAWCIRCLE_BCOLOR(ptr1,ptr2,ptr3,ptr4,x,y,px,py,a) do { \ + this->blendPixelPtr(ptr1 + (y) - (px), color1, a); \ + this->blendPixelPtr(ptr1 + (x) - (py), color1, a); \ + this->blendPixelPtr(ptr2 - (x) - (py), color1, a); \ + this->blendPixelPtr(ptr2 - (y) - (px), color1, a); \ + this->blendPixelPtr(ptr3 - (y) + (px), color1, a); \ + this->blendPixelPtr(ptr3 - (x) + (py), color1, a); \ + this->blendPixelPtr(ptr4 + (x) + (py), color2, a); \ + this->blendPixelPtr(ptr4 + (y) + (px), color2, a); \ +} while (0) + // optimized Wu's algorithm -#define __WU_ALGORITHM() { \ +#define WU_ALGORITHM() do { \ oldT = T; \ T = fp_sqroot(rsq - y*y) ^ 0xFFFF; \ py += pitch; \ @@ -160,8 +232,8 @@ inline frac_t fp_sqroot(uint32 x) { x--; px -= pitch; \ } \ a2 = (T >> 8); \ - a1 = ~a2 >> 4; \ -} + a1 = ~a2; \ +} while (0) namespace Graphics { @@ -169,7 +241,7 @@ namespace Graphics { /** * Fills several pixels in a row with a given color. * - * This is a replacement function for Common::set_to, using an unrolled + * This is a replacement function for Common::fill, using an unrolled * loop to maximize performance on most architectures. * This function may (and should) be overloaded in any child renderers * for portable platforms with platform-specific assembly code. @@ -224,17 +296,6 @@ VectorRenderer *createRenderer(int mode) { } template<typename PixelType> -void VectorRendererSpec<PixelType>:: -setGradientColors(uint8 r1, uint8 g1, uint8 b1, uint8 r2, uint8 g2, uint8 b2) { - _gradientEnd = _format.RGBToColor(r2, g2, b2); - _gradientStart = _format.RGBToColor(r1, g1, b1); - - Base::_gradientBytes[0] = (_gradientEnd & _redMask) - (_gradientStart & _redMask); - Base::_gradientBytes[1] = (_gradientEnd & _greenMask) - (_gradientStart & _greenMask); - Base::_gradientBytes[2] = (_gradientEnd & _blueMask) - (_gradientStart & _blueMask); -} - -template<typename PixelType> VectorRendererSpec<PixelType>:: VectorRendererSpec(PixelFormat format) : _format(format), @@ -246,6 +307,93 @@ VectorRendererSpec(PixelFormat format) : _bitmapAlphaColor = _format.RGBToColor(255, 0, 255); } +/**************************** + * Gradient-related methods * + ****************************/ + +template<typename PixelType> +void VectorRendererSpec<PixelType>:: +setGradientColors(uint8 r1, uint8 g1, uint8 b1, uint8 r2, uint8 g2, uint8 b2) { + _gradientEnd = _format.RGBToColor(r2, g2, b2); + _gradientStart = _format.RGBToColor(r1, g1, b1); + + _gradientBytes[0] = (_gradientEnd & _redMask) - (_gradientStart & _redMask); + _gradientBytes[1] = (_gradientEnd & _greenMask) - (_gradientStart & _greenMask); + _gradientBytes[2] = (_gradientEnd & _blueMask) - (_gradientStart & _blueMask); +} + +template<typename PixelType> +inline PixelType VectorRendererSpec<PixelType>:: +calcGradient(uint32 pos, uint32 max) { + PixelType output = 0; + pos = (MIN(pos * Base::_gradientFactor, max) << 12) / max; + + output |= ((_gradientStart & _redMask) + ((_gradientBytes[0] * pos) >> 12)) & _redMask; + output |= ((_gradientStart & _greenMask) + ((_gradientBytes[1] * pos) >> 12)) & _greenMask; + output |= ((_gradientStart & _blueMask) + ((_gradientBytes[2] * pos) >> 12)) & _blueMask; + output |= _alphaMask; + + return output; +} + +template<typename PixelType> +void VectorRendererSpec<PixelType>:: +precalcGradient(int h) { + PixelType prevcolor = 0, color; + + _gradCache.resize(0); + _gradIndexes.resize(0); + + for (int i = 0; i < h + 2; i++) { + color = calcGradient(i, h); + if (color != prevcolor || i == 0 || i > h - 1) { + prevcolor = color; + _gradCache.push_back(color); + _gradIndexes.push_back(i); + } + } +} + +template<typename PixelType> +void VectorRendererSpec<PixelType>:: +gradientFill(PixelType *ptr, int width, int x, int y) { + bool ox = ((y & 1) == 1); + int stripSize; + int curGrad = 0; + + while (_gradIndexes[curGrad + 1] <= y) + curGrad++; + + stripSize = _gradIndexes[curGrad + 1] - _gradIndexes[curGrad]; + + int grad = (((y - _gradIndexes[curGrad]) % stripSize) << 2) / stripSize; + + // Dithering: + // +--+ +--+ +--+ +--+ + // | | | | | *| | *| + // | | | *| |* | |**| + // +--+ +--+ +--+ +--+ + // 0 1 2 3 + if (grad == 0 || + _gradCache[curGrad] == _gradCache[curGrad + 1] || // no color change + stripSize < 2) { // the stip is small + colorFill<PixelType>(ptr, ptr + width, _gradCache[curGrad]); + } else if (grad == 3 && ox) { + colorFill<PixelType>(ptr, ptr + width, _gradCache[curGrad + 1]); + } else { + for (int j = x; j < x + width; j++, ptr++) { + bool oy = ((j & 1) == 1); + + if ((ox && oy) || + ((grad == 2 || grad == 3) && ox && !oy) || + (grad == 3 && oy)) + *ptr = _gradCache[curGrad + 1]; + else + *ptr = _gradCache[curGrad]; + } + } +} + template<typename PixelType> void VectorRendererSpec<PixelType>:: fillSurface() { @@ -259,9 +407,11 @@ fillSurface() { } else if (Base::_fillMode == kFillForeground) { colorFill<PixelType>((PixelType *)ptr, (PixelType *)(ptr + pitch * h), _fgColor); } else if (Base::_fillMode == kFillGradient) { - int i = h; - while (i--) { - colorFill<PixelType>((PixelType *)ptr, (PixelType *)(ptr + pitch), calcGradient(h - i, h)); + precalcGradient(h); + + for (int i = 0; i < h; i++) { + gradientFill((PixelType *)ptr, _activeSurface->w, 0, i); + ptr += pitch; } } @@ -369,18 +519,10 @@ applyScreenShading(GUI::ThemeEngine::ShadingStyle shadingStyle) { if (shadingStyle == GUI::ThemeEngine::kShadingDim) { - int n = (pixels + 7) >> 3; - switch (pixels % 8) { - case 0: do { - *ptr = (*ptr & colorMask) >> 1; ++ptr; - case 7: *ptr = (*ptr & colorMask) >> 1; ++ptr; - case 6: *ptr = (*ptr & colorMask) >> 1; ++ptr; - case 5: *ptr = (*ptr & colorMask) >> 1; ++ptr; - case 4: *ptr = (*ptr & colorMask) >> 1; ++ptr; - case 3: *ptr = (*ptr & colorMask) >> 1; ++ptr; - case 2: *ptr = (*ptr & colorMask) >> 1; ++ptr; - case 1: *ptr = (*ptr & colorMask) >> 1; ++ptr; - } while (--n > 0); + // TODO: Check how this interacts with kFeatureOverlaySupportsAlpha + for (int i = 0; i < pixels; ++i) { + *ptr = ((*ptr & colorMask) >> 1) | _alphaMask; + ++ptr; } } else if (shadingStyle == GUI::ThemeEngine::kShadingLuminance) { @@ -395,8 +537,8 @@ applyScreenShading(GUI::ThemeEngine::ShadingStyle shadingStyle) { template<typename PixelType> inline void VectorRendererSpec<PixelType>:: blendPixelPtr(PixelType *ptr, PixelType color, uint8 alpha) { - register int idst = *ptr; - register int isrc = color; + int idst = *ptr; + int isrc = color; *ptr = (PixelType)( (_redMask & ((idst & _redMask) + @@ -408,23 +550,53 @@ blendPixelPtr(PixelType *ptr, PixelType color, uint8 alpha) { (_blueMask & ((idst & _blueMask) + ((int)(((int)(isrc & _blueMask) - (int)(idst & _blueMask)) * alpha) >> 8))) | - (_alphaMask & ((idst & _alphaMask) + - ((alpha >> _format.aLoss) << _format.aShift) - - (((int)(idst & _alphaMask) * alpha) >> 8)))); + (idst & _alphaMask)); } template<typename PixelType> -inline PixelType VectorRendererSpec<PixelType>:: -calcGradient(uint32 pos, uint32 max) { - PixelType output = 0; - pos = (MIN(pos * Base::_gradientFactor, max) << 12) / max; +inline void VectorRendererSpec<PixelType>:: +blendPixelDestAlphaPtr(PixelType *ptr, PixelType color, uint8 alpha) { + int idst = *ptr; + // This function is only used for corner pixels in rounded rectangles, so + // the performance hit of this if shouldn't be too high. + // We're also ignoring the cases where dst has intermediate alpha. + if ((idst & _alphaMask) == 0) { + // set color and alpha channels + *ptr = (PixelType)(color & (_redMask | _greenMask | _blueMask)) | + ((alpha >> _format.aLoss) << _format.aShift); + } else { + // blend color with background + blendPixelPtr(ptr, color, alpha); + } +} - output |= ((_gradientStart & _redMask) + ((Base::_gradientBytes[0] * pos) >> 12)) & _redMask; - output |= ((_gradientStart & _greenMask) + ((Base::_gradientBytes[1] * pos) >> 12)) & _greenMask; - output |= ((_gradientStart & _blueMask) + ((Base::_gradientBytes[2] * pos) >> 12)) & _blueMask; - output |= _alphaMask; +template<typename PixelType> +inline void VectorRendererSpec<PixelType>:: +darkenFill(PixelType *ptr, PixelType *end) { + PixelType mask = (PixelType)((3 << _format.rShift) | (3 << _format.gShift) | (3 << _format.bShift)); - return output; + if (!g_system->hasFeature(OSystem::kFeatureOverlaySupportsAlpha)) { + // !kFeatureOverlaySupportsAlpha (but might have alpha bits) + + while (ptr != end) { + *ptr = ((*ptr & ~mask) >> 2) | _alphaMask; + ++ptr; + } + } else { + // kFeatureOverlaySupportsAlpha + // assuming at least 3 alpha bits + + mask |= 3 << _format.aShift; + PixelType addA = (PixelType)(255 >> _format.aLoss) << _format.aShift; + addA -= (addA >> 2); + + while (ptr != end) { + // Darken the colour, and increase the alpha + // (0% -> 75%, 100% -> 100%) + *ptr = (PixelType)(((*ptr & ~mask) >> 2) + addA); + ++ptr; + } + } } /******************************************************************** @@ -601,42 +773,16 @@ drawRoundedSquare(int x, int y, int r, int w, int h) { if ((r * 2) > w || (r * 2) > h) r = MIN(w /2, h / 2); + if (r <= 0) + return; + if (Base::_fillMode != kFillDisabled && Base::_shadowOffset && x + w + Base::_shadowOffset + 1 < Base::_activeSurface->w && y + h + Base::_shadowOffset + 1 < Base::_activeSurface->h) { drawRoundedSquareShadow(x, y, r, w, h, Base::_shadowOffset); } - switch (Base::_fillMode) { - case kFillDisabled: - if (Base::_strokeWidth) - drawRoundedSquareAlg(x, y, r, w, h, _fgColor, kFillDisabled); - break; - - case kFillForeground: - drawRoundedSquareAlg(x, y, r, w, h, _fgColor, kFillForeground); - break; - - case kFillBackground: - VectorRendererSpec::drawRoundedSquareAlg(x, y, r, w, h, _bgColor, kFillBackground); - drawRoundedSquareAlg(x, y, r, w, h, _fgColor, kFillDisabled); - break; - - case kFillGradient: - if (Base::_strokeWidth > 1) { - drawRoundedSquareAlg(x, y, r, w, h, _fgColor, kFillForeground); - VectorRendererSpec::drawRoundedSquareAlg(x + Base::_strokeWidth/2, y + Base::_strokeWidth/2, - r - Base::_strokeWidth/2, w - Base::_strokeWidth, h - Base::_strokeWidth, 0, kFillGradient); - } else { - VectorRendererSpec::drawRoundedSquareAlg(x, y, r, w, h, 0, kFillGradient); - if (Base::_strokeWidth) - drawRoundedSquareAlg(x, y, r, w, h, _fgColor, kFillDisabled); - } - break; - } - - if (Base::_bevel) - drawRoundedSquareFakeBevel(x, y, r, w, h, Base::_bevel); + drawRoundedSquareAlg(x, y, r, w, h, _fgColor, Base::_fillMode); } template<typename PixelType> @@ -655,10 +801,14 @@ drawTab(int x, int y, int r, int w, int h) { switch (Base::_fillMode) { case kFillDisabled: + // FIXME: Implement this return; case kFillGradient: case kFillBackground: + // FIXME: This is broken for the AA renderer. + // See the rounded rect alg for how to fix it. (The border should + // be drawn before the interior, both inside drawTabAlg.) drawTabAlg(x, y, w, h, r, (Base::_fillMode == kFillBackground) ? _bgColor : _fgColor, Base::_fillMode); if (Base::_strokeWidth) drawTabAlg(x, y, w, h, r, _fgColor, kFillDisabled, (Base::_dynamicData >> 16), (Base::_dynamicData & 0xFFFF)); @@ -693,25 +843,49 @@ drawTriangle(int x, int y, int w, int h, TriangleOrientation orient) { if (Base::_dynamicData != 0) orient = (TriangleOrientation)Base::_dynamicData; - int newW = w / 2; - if (newW % 2) newW++; + if (w == h) { + int newW = w; - switch (orient) { + switch (orient) { case kTriangleUp: case kTriangleDown: - drawTriangleFast(x + (newW / 2), y + (h / 2) - (newW / 2), newW, (orient == kTriangleDown), color, Base::_fillMode); + //drawTriangleFast(x, y, newW, (orient == kTriangleDown), color, Base::_fillMode); + drawTriangleVertAlg(x, y, newW, newW, (orient == kTriangleDown), color, Base::_fillMode); break; case kTriangleLeft: case kTriangleRight: case kTriangleAuto: break; - } + } + + if (Base::_strokeWidth > 0) + if (Base::_fillMode == kFillBackground || Base::_fillMode == kFillGradient) { + //drawTriangleFast(x, y, newW, (orient == kTriangleDown), _fgColor, kFillDisabled); + drawTriangleVertAlg(x, y, newW, newW, (orient == kTriangleDown), color, Base::_fillMode); + } + } else { + int newW = w; + int newH = h; + + switch (orient) { + case kTriangleUp: + case kTriangleDown: + drawTriangleVertAlg(x, y, newW, newH, (orient == kTriangleDown), color, Base::_fillMode); + break; + + case kTriangleLeft: + case kTriangleRight: + case kTriangleAuto: + break; + } - if (Base::_strokeWidth > 0) - if (Base::_fillMode == kFillBackground || Base::_fillMode == kFillGradient) { - drawTriangleFast(x + (newW / 2), y + (h / 2) - (newW / 2), newW, (orient == kTriangleDown), _fgColor, kFillDisabled); + if (Base::_strokeWidth > 0) { + if (Base::_fillMode == kFillBackground || Base::_fillMode == kFillGradient) { + drawTriangleVertAlg(x, y, newW, newH, (orient == kTriangleDown), _fgColor, kFillDisabled); + } } + } } @@ -746,22 +920,15 @@ drawTabAlg(int x1, int y1, int w, int h, int r, PixelType color, VectorRenderer: colorFill<PixelType>(ptr_fill + hp - sp + r, ptr_fill + w + hp + 1 - sp - r, color); sp += pitch; - __BE_RESET(); + BE_RESET(); r--; while (x++ < y) { - __BE_ALGORITHM(); - *(ptr_tr + (y) - (px)) = color; - *(ptr_tr + (x) - (py)) = color; - *(ptr_tl - (x) - (py)) = color; - *(ptr_tl - (y) - (px)) = color; + BE_ALGORITHM(); + BE_DRAWCIRCLE_TOP(ptr_tr, ptr_tl, x, y, px, py); - if (Base::_strokeWidth > 1) { - *(ptr_tr + (y) - (px - pitch)) = color; - *(ptr_tr + (x) - (py)) = color; - *(ptr_tl - (x) - (py)) = color; - *(ptr_tl - (y) - (px - pitch)) = color; - } + if (Base::_strokeWidth > 1) + BE_DRAWCIRCLE_TOP(ptr_tr, ptr_tl, x, y, px - pitch, py); } } @@ -790,33 +957,39 @@ drawTabAlg(int x1, int y1, int w, int h, int r, PixelType color, VectorRenderer: } } } else { - __BE_RESET(); + BE_RESET(); + + precalcGradient(long_h); PixelType color1, color2; color1 = color2 = color; while (x++ < y) { - __BE_ALGORITHM(); + BE_ALGORITHM(); if (fill_m == kFillGradient) { color1 = calcGradient(real_radius - x, long_h); color2 = calcGradient(real_radius - y, long_h); - } - colorFill<PixelType>(ptr_tl - x - py, ptr_tr + x - py, color2); - colorFill<PixelType>(ptr_tl - y - px, ptr_tr + y - px, color1); + gradientFill(ptr_tl - x - py, w - 2 * r + 2 * x, x1 + r - x - y, real_radius - y); + gradientFill(ptr_tl - y - px, w - 2 * r + 2 * y, x1 + r - y - x, real_radius - x); - *(ptr_tr + (y) - (px)) = color1; - *(ptr_tr + (x) - (py)) = color2; - *(ptr_tl - (x) - (py)) = color2; - *(ptr_tl - (y) - (px)) = color1; + BE_DRAWCIRCLE_XCOLOR_TOP(ptr_tr, ptr_tl, x, y, px, py); + } else { + colorFill<PixelType>(ptr_tl - x - py, ptr_tr + x - py, color); + colorFill<PixelType>(ptr_tl - y - px, ptr_tr + y - px, color); + + BE_DRAWCIRCLE_TOP(ptr_tr, ptr_tl, x, y, px, py); + } } ptr_fill += pitch * r; while (short_h--) { - if (fill_m == kFillGradient) - color = calcGradient(real_radius++, long_h); - colorFill<PixelType>(ptr_fill, ptr_fill + w + 1, color); + if (fill_m == kFillGradient) { + gradientFill(ptr_fill, w + 1, x1, real_radius++); + } else { + colorFill<PixelType>(ptr_fill, ptr_fill + w + 1, color); + } ptr_fill += pitch; } } @@ -910,8 +1083,9 @@ drawBevelSquareAlg(int x, int y, int w, int h, int bevel, PixelType top_color, P PixelType *ptr_fill = (PixelType *)_activeSurface->getBasePtr(x, y); if (fill) { + assert((_bgColor & ~_alphaMask) == 0); // only support black while (height--) { - blendFill(ptr_fill, ptr_fill + w, _bgColor, 200); + darkenFill(ptr_fill, ptr_fill + w); ptr_fill += pitch; } } @@ -1005,130 +1179,249 @@ drawLineAlg(int x1, int y1, int x2, int y2, int dx, int dy, PixelType color) { } /** VERTICAL TRIANGLE DRAWING ALGORITHM **/ +/** + FIXED POINT ARITHMETIC +**/ + +#define FIXED_POINT 1 + +#if FIXED_POINT +#define ipart(x) ((x) & ~0xFF) +// This is not really correct since gradient is not percentage, but [0..255] +#define rfpart(x) ((0x100 - ((x) & 0xFF)) * 100 >> 8) +//#define rfpart(x) (0x100 - ((x) & 0xFF)) +#else +#define ipart(x) ((int)x) +#define round(x) (ipart(x + 0.5)) +#define fpart(x) (x - ipart(x)) +#define rfpart(x) (int)((1 - fpart(x)) * 100) +#endif + template<typename PixelType> void VectorRendererSpec<PixelType>:: drawTriangleVertAlg(int x1, int y1, int w, int h, bool inverted, PixelType color, VectorRenderer::FillMode fill_m) { - int dx = w >> 1, dy = h, gradient_h = 0; int pitch = _activeSurface->pitch / _activeSurface->format.bytesPerPixel; - PixelType *ptr_right = 0, *ptr_left = 0; - - if (inverted) { - ptr_right = (PixelType *)_activeSurface->getBasePtr(x1, y1); - ptr_left = (PixelType *)_activeSurface->getBasePtr(x1 + w, y1); - } else { - ptr_right = ptr_left = (PixelType *)_activeSurface->getBasePtr(x1 + dx, y1); + int gradient_h = 0; + if (!inverted) { + pitch = -pitch; + y1 += h; } + + PixelType *ptr_right = (PixelType *)_activeSurface->getBasePtr(x1, y1); + PixelType *floor = ptr_right - 1; + PixelType *ptr_left = (PixelType *)_activeSurface->getBasePtr(x1 + w, y1); + + int x2 = x1 + w / 2; + int y2 = y1 + h; + +#if FIXED_POINT + int dx = (x2 - x1) << 8; + int dy = (y2 - y1) << 8; + + if (abs(dx) > abs(dy)) { +#else + double dx = (double)x2 - (double)x1; + double dy = (double)y2 - (double)y1; - if (dx > dy) { - int ddy = dy * 2; - int dysub = ddy - (dx * 2); - int error_term = ddy - dx; + if (fabs(dx) > fabs(dy)) { +#endif + while (floor++ != ptr_left) + blendPixelPtr(floor, color, 50); + +#if FIXED_POINT + int gradient = (dy << 8) / dx; + int intery = (y1 << 8) + gradient; +#else + double gradient = dy / dx; + double intery = y1 + gradient; +#endif - switch (fill_m) { - case kFillDisabled: - while (dx--) { - __TRIANGLE_MAINX(); - *ptr_right = color; - *ptr_left = color; + for (int x = x1 + 1; x < x2; x++) { +#if FIXED_POINT + if (intery + gradient > ipart(intery) + 0x100) { +#else + if (intery + gradient > ipart(intery) + 1) { +#endif + ptr_right++; + ptr_left--; } - colorFill<PixelType>(ptr_left, ptr_right, color); - break; - case kFillForeground: - case kFillBackground: - while (dx--) { - __TRIANGLE_MAINX(); - if (inverted) colorFill<PixelType>(ptr_right, ptr_left, color); - else colorFill<PixelType>(ptr_left, ptr_right, color); + ptr_left += pitch; + ptr_right += pitch; + + intery += gradient; + + switch (fill_m) { + case kFillDisabled: + *ptr_left = *ptr_right = color; + break; + case kFillForeground: + case kFillBackground: + colorFill<PixelType>(ptr_right + 1, ptr_left, color); + blendPixelPtr(ptr_right, color, rfpart(intery)); + blendPixelPtr(ptr_left, color, rfpart(intery)); + break; + case kFillGradient: + colorFill<PixelType>(ptr_right, ptr_left, calcGradient(gradient_h++, h)); + blendPixelPtr(ptr_right, color, rfpart(intery)); + blendPixelPtr(ptr_left, color, rfpart(intery)); + break; } - break; + } + + return; + } + +#if FIXED_POINT + if (abs(dx) < abs(dy)) { +#else + if (fabs(dx) < fabs(dy)) { +#endif + ptr_left--; + while (floor++ != ptr_left) + blendPixelPtr(floor, color, 50); + +#if FIXED_POINT + int gradient = (dx << 8) / (dy + 0x100); + int interx = (x1 << 8) + gradient; +#else + double gradient = dx / (dy+1); + double interx = x1 + gradient; +#endif - case kFillGradient: - while (dx--) { - __TRIANGLE_MAINX(); - if (inverted) colorFill<PixelType>(ptr_right, ptr_left, calcGradient(gradient_h++, h)); - else colorFill<PixelType>(ptr_left, ptr_right, calcGradient(gradient_h++, h)); + for (int y = y1 + 1; y < y2; y++) { +#if FIXED_POINT + if (interx + gradient > ipart(interx) + 0x100) { +#else + if (interx + gradient > ipart(interx) + 1) { +#endif + ptr_right++; + ptr_left--; + } + + ptr_left += pitch; + ptr_right += pitch; + + interx += gradient; + + switch (fill_m) { + case kFillDisabled: + *ptr_left = *ptr_right = color; + break; + case kFillForeground: + case kFillBackground: + colorFill<PixelType>(ptr_right + 1, ptr_left, color); + blendPixelPtr(ptr_right, color, rfpart(interx)); + blendPixelPtr(ptr_left, color, rfpart(interx)); + break; + case kFillGradient: + colorFill<PixelType>(ptr_right, ptr_left, calcGradient(gradient_h++, h)); + blendPixelPtr(ptr_right, color, rfpart(interx)); + blendPixelPtr(ptr_left, color, rfpart(interx)); + break; } - break; } - } else { - int ddx = dx * 2; - int dxsub = ddx - (dy * 2); - int error_term = ddx - dy; + + return; + } + + ptr_left--; + + while (floor++ != ptr_left) + blendPixelPtr(floor, color, 50); + +#if FIXED_POINT + int gradient = (dx / dy) << 8; + int interx = (x1 << 8) + gradient; +#else + double gradient = dx / dy; + double interx = x1 + gradient; +#endif + + for (int y = y1 + 1; y < y2; y++) { + ptr_right++; + ptr_left--; + + ptr_left += pitch; + ptr_right += pitch; + interx += gradient; + switch (fill_m) { case kFillDisabled: - while (dy--) { - __TRIANGLE_MAINY(); - *ptr_right = color; - *ptr_left = color; - } - colorFill<PixelType>(ptr_left, ptr_right, color); + *ptr_left = *ptr_right = color; break; - case kFillForeground: case kFillBackground: - while (dy--) { - __TRIANGLE_MAINY(); - if (inverted) colorFill<PixelType>(ptr_right, ptr_left, color); - else colorFill<PixelType>(ptr_left, ptr_right, color); - } + colorFill<PixelType>(ptr_right + 1, ptr_left, color); + blendPixelPtr(ptr_right, color, rfpart(interx)); + blendPixelPtr(ptr_left, color, rfpart(interx)); break; case kFillGradient: - while (dy--) { - __TRIANGLE_MAINY(); - if (inverted) colorFill<PixelType>(ptr_right, ptr_left, calcGradient(gradient_h++, h)); - else colorFill<PixelType>(ptr_left, ptr_right, calcGradient(gradient_h++, h)); - } + colorFill<PixelType>(ptr_right, ptr_left, calcGradient(gradient_h++, h)); + blendPixelPtr(ptr_right, color, rfpart(interx)); + blendPixelPtr(ptr_left, color, rfpart(interx)); break; } } + } - /** VERTICAL TRIANGLE DRAWING - FAST VERSION FOR SQUARED TRIANGLES */ template<typename PixelType> void VectorRendererSpec<PixelType>:: drawTriangleFast(int x1, int y1, int size, bool inverted, PixelType color, VectorRenderer::FillMode fill_m) { int pitch = _activeSurface->pitch / _activeSurface->format.bytesPerPixel; - int hstep = 0, dy = size; - bool grad = (fill_m == kFillGradient); - - PixelType *ptr_right = 0, *ptr_left = 0; - - if (x1 + size > Base::_activeSurface->w || x1 < 0 || - y1 + size > Base::_activeSurface->h || y1 < 0) - return; - - if (inverted) { - ptr_left = (PixelType *)_activeSurface->getBasePtr(x1, y1); - ptr_right = (PixelType *)_activeSurface->getBasePtr(x1 + size, y1); - } else { - ptr_left = (PixelType *)_activeSurface->getBasePtr(x1, y1 + size); - ptr_right = (PixelType *)_activeSurface->getBasePtr(x1 + size, y1 + size); + + if (!inverted) { pitch = -pitch; + y1 += size; } - - if (fill_m == kFillDisabled) { - while (ptr_left < ptr_right) { - *ptr_left = color; - *ptr_right = color; - ptr_left += pitch; - ptr_right += pitch; - if (hstep++ % 2) { - ptr_left++; - ptr_right--; - } + + int gradient_h = 0; + PixelType *ptr_right = (PixelType *)_activeSurface->getBasePtr(x1, y1); + PixelType *ptr_left = (PixelType *)_activeSurface->getBasePtr(x1 + size, y1); + int x2 = x1 + size / 2; + int y2 = y1 + size; + int deltaX = abs(x2 - x1); + int deltaY = abs(y2 - y1); + int signX = x1 < x2 ? 1 : -1; + int signY = y1 < y2 ? 1 : -1; + int error = deltaX - deltaY; + + colorFill<PixelType>(ptr_right, ptr_left, color); + + while (1) { + switch (fill_m) { + case kFillDisabled: + *ptr_left = *ptr_right = color; + break; + case kFillForeground: + case kFillBackground: + colorFill<PixelType>(ptr_right, ptr_left, color); + break; + case kFillGradient: + colorFill<PixelType>(ptr_right, ptr_left, calcGradient(gradient_h++, size)); + break; } - } else { - while (ptr_left < ptr_right) { - colorFill<PixelType>(ptr_left, ptr_right, grad ? calcGradient(dy--, size) : color); - ptr_left += pitch; + + if (x1 == x2 && y1 == y2) + break; + + int error2 = error * 2; + + if (error2 > -deltaY) { + error -= deltaY; + x1 += signX; + ptr_right += signX; + ptr_left += -signX; + } + + if (error2 < deltaX) { + error += deltaX; + y1 += signY; ptr_right += pitch; - if (hstep++ % 2) { - ptr_left++; - ptr_right--; - } + ptr_left += pitch; } } } @@ -1140,85 +1433,113 @@ drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, Vecto int f, ddF_x, ddF_y; int x, y, px, py; int pitch = _activeSurface->pitch / _activeSurface->format.bytesPerPixel; - int sw = 0, sp = 0, hp = h * pitch; - PixelType *ptr_tl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + r); - PixelType *ptr_tr = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + r); - PixelType *ptr_bl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + h - r); - PixelType *ptr_br = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + h - r); - PixelType *ptr_fill = (PixelType *)Base::_activeSurface->getBasePtr(x1, y1); - - int real_radius = r; - int short_h = h - (2 * r) + 2; - int long_h = h; - - if (fill_m == kFillDisabled) { - while (sw++ < Base::_strokeWidth) { - colorFill<PixelType>(ptr_fill + sp + r, ptr_fill + w + 1 + sp - r, color); - colorFill<PixelType>(ptr_fill + hp - sp + r, ptr_fill + w + hp + 1 - sp - r, color); - sp += pitch; + // TODO: Split this up into border, bevel and interior functions - __BE_RESET(); - r--; + if (fill_m != kFillDisabled) { + PixelType *ptr_tl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + r); + PixelType *ptr_tr = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + r); + PixelType *ptr_bl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + h - r); + PixelType *ptr_br = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + h - r); + PixelType *ptr_fill = (PixelType *)Base::_activeSurface->getBasePtr(x1, y1); - while (x++ < y) { - __BE_ALGORITHM(); - __BE_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py); + int real_radius = r; + int short_h = h - (2 * r) + 2; + int long_h = h; - if (Base::_strokeWidth > 1) { - __BE_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x - 1, y, px, py); - __BE_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px - pitch, py); - } - } - } + BE_RESET(); - ptr_fill += pitch * real_radius; - while (short_h--) { - colorFill<PixelType>(ptr_fill, ptr_fill + Base::_strokeWidth, color); - colorFill<PixelType>(ptr_fill + w - Base::_strokeWidth + 1, ptr_fill + w + 1, color); - ptr_fill += pitch; - } - } else { - __BE_RESET(); - PixelType color1, color2, color3, color4; + PixelType color1 = color; + if (fill_m == kFillBackground) + color1 = _bgColor; if (fill_m == kFillGradient) { + PixelType color2, color3, color4; + precalcGradient(long_h); + while (x++ < y) { - __BE_ALGORITHM(); + BE_ALGORITHM(); color1 = calcGradient(real_radius - x, long_h); color2 = calcGradient(real_radius - y, long_h); color3 = calcGradient(long_h - r + x, long_h); color4 = calcGradient(long_h - r + y, long_h); - colorFill<PixelType>(ptr_tl - x - py, ptr_tr + x - py, color2); - colorFill<PixelType>(ptr_tl - y - px, ptr_tr + y - px, color1); + gradientFill(ptr_tl - x - py, w - 2 * r + 2 * x, x1 + r - x - y, real_radius - y); + gradientFill(ptr_tl - y - px, w - 2 * r + 2 * y, x1 + r - y - x, real_radius - x); - colorFill<PixelType>(ptr_bl - x + py, ptr_br + x + py, color4); - colorFill<PixelType>(ptr_bl - y + px, ptr_br + y + px, color3); + gradientFill(ptr_bl - x + py, w - 2 * r + 2 * x, x1 + r - x - y, long_h - r + y); + gradientFill(ptr_bl - y + px, w - 2 * r + 2 * y, x1 + r - y - x, long_h - r + x); - __BE_DRAWCIRCLE_XCOLOR(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py); + BE_DRAWCIRCLE_XCOLOR(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py); } } else { while (x++ < y) { - __BE_ALGORITHM(); + BE_ALGORITHM(); - colorFill<PixelType>(ptr_tl - x - py, ptr_tr + x - py, color); - colorFill<PixelType>(ptr_tl - y - px, ptr_tr + y - px, color); + colorFill<PixelType>(ptr_tl - x - py, ptr_tr + x - py, color1); + colorFill<PixelType>(ptr_tl - y - px, ptr_tr + y - px, color1); - colorFill<PixelType>(ptr_bl - x + py, ptr_br + x + py, color); - colorFill<PixelType>(ptr_bl - y + px, ptr_br + y + px, color); + colorFill<PixelType>(ptr_bl - x + py, ptr_br + x + py, color1); + colorFill<PixelType>(ptr_bl - y + px, ptr_br + y + px, color1); // do not remove - messes up the drawing at lower resolutions - __BE_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py); + BE_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py); } } ptr_fill += pitch * r; while (short_h--) { - if (fill_m == kFillGradient) - color = calcGradient(real_radius++, long_h); - colorFill<PixelType>(ptr_fill, ptr_fill + w + 1, color); + if (fill_m == kFillGradient) { + gradientFill(ptr_fill, w + 1, x1, real_radius++); + } else { + colorFill<PixelType>(ptr_fill, ptr_fill + w + 1, color1); + } + ptr_fill += pitch; + } + } + + + if (Base::_strokeWidth) { + int sw = 0, sp = 0, hp = h * pitch; + + PixelType *ptr_tl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + r); + PixelType *ptr_tr = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + r); + PixelType *ptr_bl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + h - r); + PixelType *ptr_br = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + h - r); + PixelType *ptr_fill = (PixelType *)Base::_activeSurface->getBasePtr(x1, y1); + + int real_radius = r; + int short_h = h - (2 * r) + 2; + + // TODO: A gradient effect on the bevel + PixelType color1, color2; + color1 = Base::_bevel ? _bevelColor : color; + color2 = color; + + while (sw++ < Base::_strokeWidth) { + colorFill<PixelType>(ptr_fill + sp + r, ptr_fill + w + 1 + sp - r, color1); + colorFill<PixelType>(ptr_fill + hp - sp + r, ptr_fill + w + hp + 1 - sp - r, color2); + sp += pitch; + + BE_RESET(); + r--; + + while (x++ < y) { + BE_ALGORITHM(); + BE_DRAWCIRCLE_BCOLOR(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py); + + if (Base::_strokeWidth > 1) { + BE_DRAWCIRCLE_BCOLOR(ptr_tr, ptr_tl, ptr_bl, ptr_br, x - 1, y, px, py); + BE_DRAWCIRCLE_BCOLOR(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px - pitch, py); + } + } + } + + ptr_fill += pitch * real_radius; + while (short_h--) { + colorFill<PixelType>(ptr_fill, ptr_fill + Base::_strokeWidth, color1); + colorFill<PixelType>(ptr_fill + w - Base::_strokeWidth + 1, ptr_fill + w + 1, color2); ptr_fill += pitch; } } @@ -1235,7 +1556,7 @@ drawCircleAlg(int x1, int y1, int r, PixelType color, VectorRenderer::FillMode f if (fill_m == kFillDisabled) { while (sw++ < Base::_strokeWidth) { - __BE_RESET(); + BE_RESET(); r--; *(ptr + y) = color; @@ -1244,21 +1565,21 @@ drawCircleAlg(int x1, int y1, int r, PixelType color, VectorRenderer::FillMode f *(ptr - py) = color; while (x++ < y) { - __BE_ALGORITHM(); - __BE_DRAWCIRCLE(ptr, ptr, ptr, ptr, x, y, px, py); + BE_ALGORITHM(); + BE_DRAWCIRCLE(ptr, ptr, ptr, ptr, x, y, px, py); if (Base::_strokeWidth > 1) { - __BE_DRAWCIRCLE(ptr, ptr, ptr, ptr, x - 1, y, px, py); - __BE_DRAWCIRCLE(ptr, ptr, ptr, ptr, x, y, px - pitch, py); + BE_DRAWCIRCLE(ptr, ptr, ptr, ptr, x - 1, y, px, py); + BE_DRAWCIRCLE(ptr, ptr, ptr, ptr, x, y, px - pitch, py); } } } } else { colorFill<PixelType>(ptr - r, ptr + r, color); - __BE_RESET(); + BE_RESET(); while (x++ < y) { - __BE_ALGORITHM(); + BE_ALGORITHM(); colorFill<PixelType>(ptr - x + py, ptr + x + py, color); colorFill<PixelType>(ptr - x - py, ptr + x - py, color); colorFill<PixelType>(ptr - y + px, ptr + y + px, color); @@ -1330,7 +1651,7 @@ drawRoundedSquareShadow(int x1, int y1, int r, int w, int h, int blur) { int short_h = h - (2 * r) + 1; - __BE_RESET(); + BE_RESET(); // HACK: As we are drawing circles exploting 8-axis symmetry, // there are 4 pixels on each circle which are drawn twice. @@ -1339,7 +1660,7 @@ drawRoundedSquareShadow(int x1, int y1, int r, int w, int h, int blur) { uint32 hb = 0; while (x++ < y) { - __BE_ALGORITHM(); + BE_ALGORITHM(); if (((1 << x) & hb) == 0) { blendFill(ptr_tr - px - r, ptr_tr + y - px, 0, alpha); @@ -1360,64 +1681,6 @@ drawRoundedSquareShadow(int x1, int y1, int r, int w, int h, int blur) { } } -template<typename PixelType> -void VectorRendererSpec<PixelType>:: -drawRoundedSquareFakeBevel(int x1, int y1, int r, int w, int h, int amount) { - int x, y; - const int pitch = _activeSurface->pitch / _activeSurface->format.bytesPerPixel; - int px, py; - int sw = 0, sp = 0; - - uint32 rsq = r*r; - frac_t T = 0, oldT; - uint8 a1, a2; - - PixelType color = _bevelColor; //_format.RGBToColor(63, 60, 17); - - PixelType *ptr_tl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + r); - PixelType *ptr_tr = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + r); - PixelType *ptr_bl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + h - r); - PixelType *ptr_fill = (PixelType *)Base::_activeSurface->getBasePtr(x1, y1); - - int short_h = h - 2 * r; - - while (sw++ < amount) { - colorFill<PixelType>(ptr_fill + sp + r, ptr_fill + w + 1 + sp - r, color); - sp += pitch; - - x = r - (sw - 1); - y = 0; - T = 0; - px = pitch * x; - py = 0; - - while (x > y++) { - __WU_ALGORITHM(); - - blendPixelPtr(ptr_tr + (y) - (px - pitch), color, a2); - blendPixelPtr(ptr_tr + (x - 1) - (py), color, a2); - blendPixelPtr(ptr_tl - (x - 1) - (py), color, a2); - blendPixelPtr(ptr_tl - (y) - (px - pitch), color, a2); - blendPixelPtr(ptr_bl - (y) + (px - pitch), color, a2); - blendPixelPtr(ptr_bl - (x - 1) + (py), color, a2); - - blendPixelPtr(ptr_tr + (y) - (px), color, a1); - blendPixelPtr(ptr_tr + (x) - (py), color, a1); - blendPixelPtr(ptr_tl - (x) - (py), color, a1); - blendPixelPtr(ptr_tl - (y) - (px), color, a1); - blendPixelPtr(ptr_bl - (y) + (px), color, a1); - blendPixelPtr(ptr_bl - (x) + (py), color, a1); - } - } - - ptr_fill += pitch * r; - while (short_h-- >= 0) { - colorFill<PixelType>(ptr_fill, ptr_fill + amount, color); - ptr_fill += pitch; - } -} - - /******************************************************************************/ @@ -1480,28 +1743,26 @@ drawLineAlg(int x1, int y1, int x2, int y2, int dx, int dy, PixelType color) { Base::putPixel(x2, y2, color); } -/** ROUNDED SQUARES **/ +/** TAB ALGORITHM */ template<typename PixelType> void VectorRendererAA<PixelType>:: -drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, VectorRenderer::FillMode fill_m) { - int x, y; - const int pitch = Base::_activeSurface->pitch / Base::_activeSurface->format.bytesPerPixel; - int px, py; - int sw = 0, sp = 0, hp = h * pitch; +drawTabAlg(int x1, int y1, int w, int h, int r, PixelType color, VectorRenderer::FillMode fill_m, int baseLeft, int baseRight) { + int x, y, px, py; + int pitch = Base::_activeSurface->pitch / Base::_activeSurface->format.bytesPerPixel; + int sw = 0, sp = 0, hp = 0; - uint32 rsq = r*r; frac_t T = 0, oldT; uint8 a1, a2; + uint32 rsq = r*r; PixelType *ptr_tl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + r); PixelType *ptr_tr = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + r); - PixelType *ptr_bl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + h - r); - PixelType *ptr_br = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + h - r); PixelType *ptr_fill = (PixelType *)Base::_activeSurface->getBasePtr(x1, y1); - int short_h = h - 2 * r; + int real_radius = r; - if (fill_m == VectorRenderer::kFillDisabled) { + if (fill_m == Base::kFillDisabled) { + color = 0; while (sw++ < Base::_strokeWidth) { colorFill<PixelType>(ptr_fill + sp + r, ptr_fill + w + 1 + sp - r, color); colorFill<PixelType>(ptr_fill + hp - sp + r, ptr_fill + w + hp + 1 - sp - r, color); @@ -1513,48 +1774,265 @@ drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, Vecto px = pitch * x; py = 0; + while (x > y++) { - __WU_ALGORITHM(); + WU_ALGORITHM(); - if (sw != 1 && sw != Base::_strokeWidth) - a2 = a1 = 255; + // sw == 1: outside, sw = _strokeWidth: inside + if (sw != Base::_strokeWidth) + a2 = 255; - __WU_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, (x - 1), y, (px - pitch), py, a2); - __WU_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py, a1); + // inner arc + WU_DRAWCIRCLE_TOP(ptr_tr, ptr_tl, x, y, px, py, a2); + + if (sw == 1) // outer arc + WU_DRAWCIRCLE_TOP(ptr_tr, ptr_tl, x, y, px - pitch, py, a1); } } - ptr_fill += pitch * r; - while (short_h-- >= 0) { + int short_h = h - r + 2; + + ptr_fill += pitch * real_radius; + while (short_h--) { colorFill<PixelType>(ptr_fill, ptr_fill + Base::_strokeWidth, color); colorFill<PixelType>(ptr_fill + w - Base::_strokeWidth + 1, ptr_fill + w + 1, color); ptr_fill += pitch; } + + if (baseLeft) { + sw = 0; + ptr_fill = (PixelType *)Base::_activeSurface->getBasePtr(x1, y1 + h + 1); + while (sw++ < Base::_strokeWidth) { + colorFill<PixelType>(ptr_fill - baseLeft, ptr_fill, color); + ptr_fill += pitch; + } + } + + if (baseRight) { + sw = 0; + ptr_fill = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w, y1 + h + 1); + while (sw++ < Base::_strokeWidth) { + colorFill<PixelType>(ptr_fill, ptr_fill + baseRight, color); + ptr_fill += pitch; + } + } } else { - x = r; + PixelType color1, color2; + color1 = color2 = color; + + int long_h = h; + int short_h = h - real_radius + 2; + x = real_radius; y = 0; T = 0; px = pitch * x; py = 0; - while (x > 1 + y++) { - __WU_ALGORITHM(); + Base::precalcGradient(long_h); + + while (x > y++) { + WU_ALGORITHM(); + + if (fill_m == Base::kFillGradient) { + color1 = Base::calcGradient(real_radius - x, long_h); + color2 = Base::calcGradient(real_radius - y, long_h); + + Base::gradientFill(ptr_tl - x - py + 1, w - 2 * r + 2 * x - 1, x1 + r - x - y + 1, real_radius - y); + + // Only fill each horizontal line once (or we destroy + // the gradient effect at the edges) + if (T < oldT || y == 1) + Base::gradientFill(ptr_tl - y - px + 1, w - 2 * r + 2 * y - 1, x1 + r - y - x + 1, real_radius - x); + + WU_DRAWCIRCLE_XCOLOR_TOP(ptr_tr, ptr_tl, x, y, px, py, a1, Base::blendPixelPtr); + } else { + colorFill<PixelType>(ptr_tl - x - py + 1, ptr_tr + x - py, color); + if (T < oldT || y == 1) + colorFill<PixelType>(ptr_tl - y - px + 1, ptr_tr + y - px, color); + + WU_DRAWCIRCLE_TOP(ptr_tr, ptr_tl, x, y, px, py, a1); + } + } + + ptr_fill += pitch * r; + while (short_h--) { + if (fill_m == Base::kFillGradient) { + Base::gradientFill(ptr_fill, w + 1, x1, real_radius++); + } else { + colorFill<PixelType>(ptr_fill, ptr_fill + w + 1, color); + } + ptr_fill += pitch; + } + } +} + + +/** ROUNDED SQUARES **/ +template<typename PixelType> +void VectorRendererAA<PixelType>:: +drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, VectorRenderer::FillMode fill_m) { + int x, y; + const int pitch = Base::_activeSurface->pitch / Base::_activeSurface->format.bytesPerPixel; + int px, py; + + uint32 rsq = r*r; + frac_t T = 0, oldT; + uint8 a1, a2; + + // TODO: Split this up into border, bevel and interior functions - colorFill<PixelType>(ptr_tl - x - py, ptr_tr + x - py, color); - colorFill<PixelType>(ptr_tl - y - px, ptr_tr + y - px, color); + if (Base::_strokeWidth) { + PixelType *ptr_tl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + r); + PixelType *ptr_tr = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + r); + PixelType *ptr_bl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + h - r); + PixelType *ptr_br = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + h - r); + PixelType *ptr_fill = (PixelType *)Base::_activeSurface->getBasePtr(x1, y1); - colorFill<PixelType>(ptr_bl - x + py, ptr_br + x + py, color); - colorFill<PixelType>(ptr_bl - y + px, ptr_br + y + px, color); + int sw = 0, sp = 0; + int short_h = h - 2 * r; + int hp = h * pitch; - __WU_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py, a1); + int strokeWidth = Base::_strokeWidth; + // If we're going to fill the inside, draw a slightly thicker border + // so we can blend the inside on top of it. + if (fill_m != Base::kFillDisabled) strokeWidth++; + + // TODO: A gradient effect on the bevel + PixelType color1, color2; + color1 = Base::_bevel ? Base::_bevelColor : color; + color2 = color; + + + while (sw++ < strokeWidth) { + colorFill<PixelType>(ptr_fill + sp + r, ptr_fill + w + 1 + sp - r, color1); + colorFill<PixelType>(ptr_fill + hp - sp + r, ptr_fill + w + hp + 1 - sp - r, color2); + sp += pitch; + + x = r - (sw - 1); + y = 0; + T = 0; + px = pitch * x; + py = 0; + + while (x > y++) { + WU_ALGORITHM(); + + // sw == 1: outside, sw = _strokeWidth: inside + // We always draw the outer edge AAed, but the inner edge + // only when the inside isn't filled + if (sw != strokeWidth || fill_m != Base::kFillDisabled) + a2 = 255; + + // inner arc + WU_DRAWCIRCLE_BCOLOR(ptr_tr, ptr_tl, ptr_bl, ptr_br, (x - 1), y, (px - pitch), py, a2); + + if (sw == 1) // outer arc + WU_DRAWCIRCLE_BCOLOR(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py, a1); + } } ptr_fill += pitch * r; while (short_h-- >= 0) { - colorFill<PixelType>(ptr_fill, ptr_fill + w + 1, color); + colorFill<PixelType>(ptr_fill, ptr_fill + Base::_strokeWidth, color1); + colorFill<PixelType>(ptr_fill + w - Base::_strokeWidth + 1, ptr_fill + w + 1, color2); ptr_fill += pitch; } } + + r -= Base::_strokeWidth; + x1 += Base::_strokeWidth; + y1 += Base::_strokeWidth; + w -= 2*Base::_strokeWidth; + h -= 2*Base::_strokeWidth; + rsq = r*r; + + if (w <= 0 || h <= 0) + return; // Only border is visible + + if (fill_m != Base::kFillDisabled) { + if (fill_m == Base::kFillBackground) + color = Base::_bgColor; + + PixelType *ptr_tl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + r); + PixelType *ptr_tr = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + r); + PixelType *ptr_bl = (PixelType *)Base::_activeSurface->getBasePtr(x1 + r, y1 + h - r); + PixelType *ptr_br = (PixelType *)Base::_activeSurface->getBasePtr(x1 + w - r, y1 + h - r); + PixelType *ptr_fill = (PixelType *)Base::_activeSurface->getBasePtr(x1, y1); + + int short_h = h - 2 * r; + x = r; + y = 0; + T = 0; + px = pitch * x; + py = 0; + + if (fill_m == Base::kFillGradient) { + + Base::precalcGradient(h); + + PixelType color1, color2, color3, color4; + while (x > y++) { + WU_ALGORITHM(); + + color1 = Base::calcGradient(r - x, h); + color2 = Base::calcGradient(r - y, h); + color3 = Base::calcGradient(h - r + x, h); + color4 = Base::calcGradient(h - r + y, h); + + Base::gradientFill(ptr_tl - x - py + 1, w - 2 * r + 2 * x - 1, x1 + r - x - y + 1, r - y); + + // Only fill each horizontal line once (or we destroy + // the gradient effect at the edges) + if (T < oldT || y == 1) + Base::gradientFill(ptr_tl - y - px + 1, w - 2 * r + 2 * y - 1, x1 + r - y - x + 1, r - x); + + Base::gradientFill(ptr_bl - x + py + 1, w - 2 * r + 2 * x - 1, x1 + r - x - y + 1, h - r + y); + + // Only fill each horizontal line once (or we destroy + // the gradient effect at the edges) + if (T < oldT || y == 1) + Base::gradientFill(ptr_bl - y + px + 1, w - 2 * r + 2 * y - 1, x1 + r - y - x + 1, h - r + x); + + // This shape is used for dialog backgrounds. + // If we're drawing on top of an empty overlay background, + // and the overlay supports alpha, we have to do AA by + // setting the dest alpha channel, instead of blending with + // dest color channels. + if (!g_system->hasFeature(OSystem::kFeatureOverlaySupportsAlpha)) + WU_DRAWCIRCLE_XCOLOR(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py, a1, blendPixelPtr); + else + WU_DRAWCIRCLE_XCOLOR(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py, a1, blendPixelDestAlphaPtr); + } + + ptr_fill += pitch * r; + while (short_h-- >= 0) { + Base::gradientFill(ptr_fill, w + 1, x1, r++); + ptr_fill += pitch; + } + + } else { + + while (x > 1 + y++) { + WU_ALGORITHM(); + + colorFill<PixelType>(ptr_tl - x - py + 1, ptr_tr + x - py, color); + if (T < oldT || y == 1) + colorFill<PixelType>(ptr_tl - y - px + 1, ptr_tr + y - px, color); + + colorFill<PixelType>(ptr_bl - x + py + 1, ptr_br + x + py, color); + if (T < oldT || y == 1) + colorFill<PixelType>(ptr_bl - y + px + 1, ptr_br + y + px, color); + + WU_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py, a1); + } + + ptr_fill += pitch * r; + while (short_h-- >= 0) { + colorFill<PixelType>(ptr_fill, ptr_fill + w + 1, color); + ptr_fill += pitch; + } + } + } } /** CIRCLES **/ @@ -1585,13 +2063,13 @@ drawCircleAlg(int x1, int y1, int r, PixelType color, VectorRenderer::FillMode f *(ptr - px) = (PixelType)color; while (x > y++) { - __WU_ALGORITHM(); + WU_ALGORITHM(); if (sw != 1 && sw != Base::_strokeWidth) a2 = a1 = 255; - __WU_DRAWCIRCLE(ptr, ptr, ptr, ptr, (x - 1), y, (px - pitch), py, a2); - __WU_DRAWCIRCLE(ptr, ptr, ptr, ptr, x, y, px, py, a1); + WU_DRAWCIRCLE(ptr, ptr, ptr, ptr, (x - 1), y, (px - pitch), py, a2); + WU_DRAWCIRCLE(ptr, ptr, ptr, ptr, x, y, px, py, a1); } } } else { @@ -1603,14 +2081,14 @@ drawCircleAlg(int x1, int y1, int r, PixelType color, VectorRenderer::FillMode f py = 0; while (x > y++) { - __WU_ALGORITHM(); + WU_ALGORITHM(); colorFill<PixelType>(ptr - x + py, ptr + x + py, color); colorFill<PixelType>(ptr - x - py, ptr + x - py, color); colorFill<PixelType>(ptr - y + px, ptr + y + px, color); colorFill<PixelType>(ptr - y - px, ptr + y - px, color); - __WU_DRAWCIRCLE(ptr, ptr, ptr, ptr, x, y, px, py, a1); + WU_DRAWCIRCLE(ptr, ptr, ptr, ptr, x, y, px, py, a1); } } } diff --git a/graphics/VectorRendererSpec.h b/graphics/VectorRendererSpec.h index 3ba7d88e4e..4ed80cb55f 100644 --- a/graphics/VectorRendererSpec.h +++ b/graphics/VectorRendererSpec.h @@ -103,7 +103,7 @@ protected: * @param alpha Alpha intensity of the pixel (0-255) */ inline void blendPixel(int x, int y, PixelType color, uint8 alpha) { - blendPixelPtr((PixelType*)Base::_activeSurface->getBasePtr(x, y), color, alpha); + blendPixelPtr((PixelType *)Base::_activeSurface->getBasePtr(x, y), color, alpha); } /** @@ -121,6 +121,24 @@ protected: inline void blendPixelPtr(PixelType *ptr, PixelType color, uint8 alpha); /** + * Blends a single pixel on the surface in the given pixel pointer, using supplied color + * and Alpha intensity. + * If the destination pixel has 0 alpha, set the color and alpha channels, + * overwriting the destination pixel entirely. + * If the destination pixel has non-zero alpha, blend dest with src. + * + * This is implemented to prevent blendPixel() to calculate the surface pointer on each call. + * Optimized drawing algorithms should call this function when possible. + * + * @see blendPixel + * @param ptr Pointer to the pixel to blend on top of + * @param color Color of the pixel + * @param alpha Alpha intensity of the pixel (0-255) + */ + inline void blendPixelDestAlphaPtr(PixelType *ptr, PixelType color, uint8 alpha); + + + /** * PRIMITIVE DRAWING ALGORITHMS * * Generic algorithms for drawing all kinds of aliased primitive shapes. @@ -172,7 +190,6 @@ protected: */ virtual void drawSquareShadow(int x, int y, int w, int h, int blur); virtual void drawRoundedSquareShadow(int x, int y, int r, int w, int h, int blur); - virtual void drawRoundedSquareFakeBevel(int x, int y, int r, int w, int h, int amount); /** * Calculates the color gradient on a given point. @@ -185,6 +202,9 @@ protected: */ inline PixelType calcGradient(uint32 pos, uint32 max); + void precalcGradient(int h); + void gradientFill(PixelType *first, int width, int x, int y); + /** * Fills several pixels in a row with a given color and the specified alpha blending. * @@ -199,6 +219,8 @@ protected: while (first != last) blendPixelPtr(first++, color, alpha); } + void darkenFill(PixelType *first, PixelType *last); + const PixelFormat _format; const PixelType _redMask, _greenMask, _blueMask, _alphaMask; @@ -208,6 +230,11 @@ protected: PixelType _gradientStart; /**< Start color for the fill gradient */ PixelType _gradientEnd; /**< End color for the fill gradient */ + int _gradientBytes[3]; /**< Color bytes of the active gradient, used to speed up calculation */ + + Common::Array<PixelType> _gradCache; + Common::Array<int> _gradIndexes; + PixelType _bevelColor; PixelType _bitmapAlphaColor; }; @@ -270,6 +297,10 @@ protected: // VectorRenderer::applyConvolutionMatrix(VectorRenderer::kConvolutionHardBlur, // Common::Rect(x, y, x + w + blur * 2, y + h + blur * 2)); } + + virtual void drawTabAlg(int x, int y, int w, int h, int r, + PixelType color, VectorRenderer::FillMode fill_m, + int baseLeft = 0, int baseRight = 0); }; #endif diff --git a/graphics/cursorman.cpp b/graphics/cursorman.cpp index 1d4e482bf4..425714ea34 100644 --- a/graphics/cursorman.cpp +++ b/graphics/cursorman.cpp @@ -31,10 +31,10 @@ DECLARE_SINGLETON(Graphics::CursorManager); namespace Graphics { CursorManager::~CursorManager() { - for (int i = 0; i < _cursorStack.size(); ++i) + for (Common::Stack<Cursor *>::size_type i = 0; i < _cursorStack.size(); ++i) delete _cursorStack[i]; _cursorStack.clear(); - for (int i = 0; i < _cursorPaletteStack.size(); ++i) + for (Common::Stack<Palette *>::size_type i = 0; i < _cursorPaletteStack.size(); ++i) delete _cursorPaletteStack[i]; _cursorPaletteStack.clear(); } diff --git a/graphics/font.cpp b/graphics/font.cpp index 3f7152a95e..3b00cd8568 100644 --- a/graphics/font.cpp +++ b/graphics/font.cpp @@ -26,11 +26,20 @@ namespace Graphics { +int Font::getKerningOffset(byte left, byte right) const { + return 0; +} + int Font::getStringWidth(const Common::String &str) const { int space = 0; + uint last = 0; + + for (uint i = 0; i < str.size(); ++i) { + const uint cur = str[i]; + space += getCharWidth(cur) + getKerningOffset(last, cur); + last = cur; + } - for (uint i = 0; i < str.size(); ++i) - space += getCharWidth(str[i]); return space; } @@ -65,17 +74,22 @@ void Font::drawString(Surface *dst, const Common::String &sOld, int x, int y, in // for now. const int halfWidth = (w - ellipsisWidth) / 2; int w2 = 0; + uint last = 0; for (i = 0; i < s.size(); ++i) { - int charWidth = getCharWidth(s[i]); + const uint cur = s[i]; + int charWidth = getCharWidth(cur) + getKerningOffset(last, cur); if (w2 + charWidth > halfWidth) break; + last = cur; w2 += charWidth; - str += s[i]; + str += cur; } + // At this point we know that the first 'i' chars are together 'w2' // pixels wide. We took the first i-1, and add "..." to them. str += "..."; + last = '.'; // The original string is width wide. Of those we already skipped past // w2 pixels, which means (width - w2) remain. @@ -85,7 +99,9 @@ void Font::drawString(Surface *dst, const Common::String &sOld, int x, int y, in // (width + ellipsisWidth - w) int skip = width + ellipsisWidth - w; for (; i < s.size() && skip > 0; ++i) { - skip -= getCharWidth(s[i]); + const uint cur = s[i]; + skip -= getCharWidth(cur) + getKerningOffset(last, cur); + last = cur; } // Append the remaining chars, if any @@ -104,8 +120,12 @@ void Font::drawString(Surface *dst, const Common::String &sOld, int x, int y, in x = x + w - width; x += deltax; + uint last = 0; for (i = 0; i < str.size(); ++i) { - w = getCharWidth(str[i]); + const uint cur = str[i]; + x += getKerningOffset(last, cur); + last = cur; + w = getCharWidth(cur); if (x+w > rightX) break; if (x >= leftX) @@ -153,16 +173,18 @@ int Font::wordWrapText(const Common::String &str, int maxWidth, Common::Array<Co // of a line. If we encounter such a word, we have to wrap it over multiple // lines. + uint last = 0; for (Common::String::const_iterator x = str.begin(); x != str.end(); ++x) { const byte c = *x; - const int w = getCharWidth(c); + const int w = getCharWidth(c) + getKerningOffset(last, c); + last = c; const bool wouldExceedWidth = (lineWidth + tmpWidth + w > maxWidth); // If this char is a whitespace, then it represents a potential // 'wrap point' where wrapping could take place. Everything that // came before it can now safely be added to the line, as we know // that it will not have to be wrapped. - if (isspace(c)) { + if (Common::isSpace(c)) { line += tmpStr; lineWidth += tmpWidth; @@ -186,9 +208,11 @@ int Font::wordWrapText(const Common::String &str, int maxWidth, Common::Array<Co if (lineWidth > 0) { wrapper.add(line, lineWidth); // Trim left side - while (tmpStr.size() && isspace(static_cast<unsigned char>(tmpStr[0]))) { - tmpWidth -= getCharWidth(tmpStr[0]); + while (tmpStr.size() && Common::isSpace(tmpStr[0])) { tmpStr.deleteChar(0); + // This is not very fast, but it is the simplest way to + // assure we do not mess something up because of kerning. + tmpWidth = getStringWidth(tmpStr); } } else { wrapper.add(tmpStr, tmpWidth); diff --git a/graphics/font.h b/graphics/font.h index 9c0b4affc1..6819b42f52 100644 --- a/graphics/font.h +++ b/graphics/font.h @@ -73,6 +73,15 @@ public: virtual int getCharWidth(byte chr) const = 0; /** + * Query the kerning offset between two characters. + * + * @param left The left character. May be 0. + * @param right The right character. May be 0. + * @return The horizontal displacement. + */ + virtual int getKerningOffset(byte left, byte right) const; + + /** * Draw a character at a specific point on a surface. * * Note that the point describes the top left edge point of the diff --git a/graphics/fontman.cpp b/graphics/fontman.cpp index a10d27a2b0..8d967d595f 100644 --- a/graphics/fontman.cpp +++ b/graphics/fontman.cpp @@ -72,6 +72,20 @@ const struct { { 0, FontManager::kConsoleFont } }; +bool FontManager::setLocalizedFont(const Common::String &name) { + Common::String lowercaseName = name; + lowercaseName.toLowercase(); + + // We only update the localized font in case the name is properly assigned + // to a font. + if (_fontMap.contains(lowercaseName) && _fontMap.getVal(lowercaseName) != 0) { + _localizedFontName = lowercaseName; + return true; + } else { + return false; + } +} + bool FontManager::assignFontToName(const Common::String &name, const Font *font) { Common::String lowercaseName = name; lowercaseName.toLowercase(); @@ -79,19 +93,19 @@ bool FontManager::assignFontToName(const Common::String &name, const Font *font) return true; } -bool FontManager::setFont(FontUsage usage, const Font *font) { +bool FontManager::setFont(FontUsage usage, const BdfFont *font) { switch (usage) { case kConsoleFont: delete g_consolefont; - g_consolefont = (const BdfFont *)font; + g_consolefont = font; break; case kGUIFont: delete g_sysfont; - g_sysfont = (const BdfFont *)font; + g_sysfont = font; break; case kBigGUIFont: delete g_sysfont_big; - g_sysfont_big = (const BdfFont *)font; + g_sysfont_big = font; break; default: return false; @@ -103,6 +117,11 @@ void FontManager::removeFontName(const Common::String &name) { Common::String lowercaseName = name; lowercaseName.toLowercase(); _fontMap.erase(lowercaseName); + + // In case the current localized font is removed, we fall back to the + // default font again. + if (_localizedFontName == lowercaseName) + _localizedFontName.clear(); } const Font *FontManager::getFontByName(const Common::String &name) const { @@ -126,51 +145,16 @@ const Font *FontManager::getFontByUsage(FontUsage usage) const { case kBigGUIFont: return g_sysfont_big; case kLocalizedFont: - { - // First try to find a kBigGUIFont - Common::String fontName = getLocalizedFontNameByUsage(kBigGUIFont); - if (!fontName.empty()) { - const Font *font = getFontByName(fontName); - if (font) - return font; - } - // Try kGUIFont - fontName = getLocalizedFontNameByUsage(kGUIFont); - if (!fontName.empty()) { - const Font *font = getFontByName(fontName); - if (font) - return font; - } -#ifdef USE_TRANSLATION - // Accept any other font that has the charset in its name - for (Common::HashMap<Common::String, const Font *>::const_iterator it = _fontMap.begin() ; it != _fontMap.end() ; ++it) { - if (it->_key.contains(TransMan.getCurrentCharset())) - return it->_value; - } -#endif - // Fallback: return a non localized kGUIFont. - // Maybe we should return a null pointer instead? - return g_sysfont; - } + // By default use the big font as localized font + if (_localizedFontName.empty()) + return g_sysfont_big; + else + return _fontMap[_localizedFontName]; } return 0; } -Common::String FontManager::getLocalizedFontNameByUsage(FontUsage usage) const { - // We look for a name that matches the usage and that ends in .bdf. - // It should also not contain "-ascii" or "-iso-" in its name. - // We take the first name that matches. - for (int i = 0; builtinFontNames[i].name; i++) { - if (builtinFontNames[i].id == usage) { - Common::String fontName(builtinFontNames[i].name); - if (!fontName.contains("-ascii") && !fontName.contains("-iso-") && fontName.contains(".bdf")) - return genLocalizedFontFilename(fontName); - } - } - return Common::String(); -} - Common::String FontManager::genLocalizedFontFilename(const Common::String &filename) const { #ifndef USE_TRANSLATION return filename; diff --git a/graphics/fontman.h b/graphics/fontman.h index 09c1a198ff..42f7d856fa 100644 --- a/graphics/fontman.h +++ b/graphics/fontman.h @@ -32,6 +32,7 @@ namespace Graphics { class Font; +class BdfFont; class FontManager : public Common::Singleton<FontManager> { public: @@ -43,6 +44,14 @@ public: }; /** + * Sets the localized font name. + * + * @param name the name of the localized font. + * @return true when the font was present, false otherwise. + */ + bool setLocalizedFont(const Common::String &name); + + /** * Retrieve a font object based on its 'name'. * * @param name the name of the font to be retrieved. @@ -67,7 +76,7 @@ public: * @param font the font object * @return true on success, false on failure */ - bool setFont(FontUsage usage, const Font *font); + bool setFont(FontUsage usage, const BdfFont *font); /** * Removes binding from name to font @@ -96,22 +105,13 @@ public: //const Font *getFontBySize(int size???) const; -protected: - /** - * Get the name of the localized font for the given usage. There is no garanty that - * the font exists. If the usage is kLocalizedFont it returns an empty string. - * - * @param usage a FontUsage enum value indicating what the font will be used for. - * @return the name of a localized font or an empty string if no suitable font was found. - */ - Common::String getLocalizedFontNameByUsage(FontUsage usage) const; - private: friend class Common::Singleton<SingletonBaseType>; FontManager(); ~FontManager(); Common::HashMap<Common::String, const Font *> _fontMap; + Common::String _localizedFontName; }; diff --git a/graphics/fonts/bdf.cpp b/graphics/fonts/bdf.cpp index 58c48ed877..6d4befa37c 100644 --- a/graphics/fonts/bdf.cpp +++ b/graphics/fonts/bdf.cpp @@ -29,768 +29,594 @@ namespace Graphics { -void free_font(BdfFontData *pf); +BdfFont::BdfFont(const BdfFontData &data, DisposeAfterUse::Flag dispose) + : _data(data), _dispose(dispose) { +} BdfFont::~BdfFont() { - if (_font) { - free_font(_font); + if (_dispose == DisposeAfterUse::YES) { + for (int i = 0; i < _data.numCharacters; ++i) + delete[] _data.bitmaps[i]; + delete[] _data.bitmaps; + delete[] _data.advances; + delete[] _data.boxes; } } int BdfFont::getFontHeight() const { - return _desc.height; + return _data.height; } int BdfFont::getMaxCharWidth() const { - return _desc.maxwidth; + return _data.maxAdvance; } int BdfFont::getCharWidth(byte chr) const { - // If no width table is specified, return the maximum width - if (!_desc.width) - return _desc.maxwidth; - // If this character is not included in the font, use the default char. - if (chr < _desc.firstchar || _desc.firstchar + _desc.size < chr) { - chr = _desc.defaultchar; - } - return _desc.width[chr - _desc.firstchar]; + // In case all font have the same advance value, we use the maximum. + if (!_data.advances) + return _data.maxAdvance; + + const int ch = mapToIndex(chr); + // In case no mapping exists, we use the maximum advance. + if (ch < 0) + return _data.maxAdvance; + else + return _data.advances[ch]; } template<typename PixelType> -void drawCharIntern(byte *ptr, uint pitch, const bitmap_t *src, int h, int minX, int maxX, const PixelType color) { - const bitmap_t maxXMask = ~((1 << (16 - maxX)) - 1); - while (h-- > 0) { - bitmap_t buffer = READ_UINT16(src); - src++; - - buffer &= maxXMask; - buffer <<= minX; - PixelType *tmp = (PixelType *)ptr; - while (buffer != 0) { - if ((buffer & 0x8000) != 0) - *tmp = color; - tmp++; - buffer <<= 1; +void drawCharIntern(byte *ptr, uint pitch, const byte *src, int h, int width, int minX, int maxX, const PixelType color) { + byte data = 0; + while (h--) { + PixelType *dst = (PixelType *)ptr; + + for (int x = 0; x < width; ++x) { + if (!(x % 8)) + data = *src++; + + if (x >= minX && x <= maxX && (data & 0x80)) + dst[x] = color; + + data <<= 1; } ptr += pitch; } } +int BdfFont::mapToIndex(byte ch) const { + // Check whether the character is included + if (_data.firstCharacter <= ch && ch <= _data.firstCharacter + _data.numCharacters) { + if (_data.bitmaps[ch - _data.firstCharacter]) + return ch - _data.firstCharacter; + } + + return _data.defaultCharacter - _data.firstCharacter; +} + void BdfFont::drawChar(Surface *dst, byte chr, const int tx, const int ty, const uint32 color) const { assert(dst != 0); - // asserting _desc.maxwidth <= 50: let the theme designer decide what looks best - assert(_desc.bits != 0 && _desc.maxwidth <= 50); + // TODO: Where is the relation between the max advance being smaller or + // equal to 50 and the decision of the theme designer? + // asserting _data.maxAdvance <= 50: let the theme designer decide what looks best + assert(_data.maxAdvance <= 50); assert(dst->format.bytesPerPixel == 1 || dst->format.bytesPerPixel == 2); - // If this character is not included in the font, use the default char. - if (chr < _desc.firstchar || chr >= _desc.firstchar + _desc.size) { - chr = _desc.defaultchar; - } - - chr -= _desc.firstchar; + const int idx = mapToIndex(chr); + if (idx < 0) + return; - int bbw, bbh, bbx, bby; + int width, height, xOffset, yOffset; // Get the bounding box of the character - if (!_desc.bbx) { - bbw = _desc.fbbw; - bbh = _desc.fbbh; - bbx = _desc.fbbx; - bby = _desc.fbby; + if (!_data.boxes) { + width = _data.defaultBox.width; + height = _data.defaultBox.height; + xOffset = _data.defaultBox.xOffset; + yOffset = _data.defaultBox.yOffset; } else { - bbw = _desc.bbx[chr].w; - bbh = _desc.bbx[chr].h; - bbx = _desc.bbx[chr].x; - bby = _desc.bbx[chr].y; + width = _data.boxes[idx].width; + height = _data.boxes[idx].height; + xOffset = _data.boxes[idx].xOffset; + yOffset = _data.boxes[idx].yOffset; } - byte *ptr = (byte *)dst->getBasePtr(tx + bbx, ty + _desc.ascent - bby - bbh); + int y = ty + _data.ascent - yOffset - height; + int x = tx + xOffset; - const bitmap_t *tmp = _desc.bits + (_desc.offset ? _desc.offset[chr] : (chr * _desc.fbbh)); + const byte *src = _data.bitmaps[idx]; - int y = MIN(bbh, ty + _desc.ascent - bby); - tmp += bbh - y; - y -= MAX(0, ty + _desc.ascent - bby - dst->h); + const int bytesPerRow = (width + 7) / 8; + const int originalWidth = width; - if (dst->format.bytesPerPixel == 1) - drawCharIntern<byte>(ptr, dst->pitch, tmp, y, MAX(0, -(tx + bbx)), MIN(bbw, dst->w - tx - bbx), color); - else if (dst->format.bytesPerPixel == 2) - drawCharIntern<uint16>(ptr, dst->pitch, tmp, y, MAX(0, -(tx + bbx)), MIN(bbw, dst->w - tx - bbx), color); -} + // Make sure we do not draw outside the surface + if (y < 0) { + src -= y * bytesPerRow; + height += y; + y = 0; + } + if (y + height > dst->h) + height = dst->h - y; -#pragma mark - - -/* BEGIN font.h*/ -/* bitmap_t helper macros*/ -#define BITMAP_WORDS(x) (((x)+15)/16) /* image size in words*/ -#define BITMAP_BYTES(x) (BITMAP_WORDS(x)*sizeof(bitmap_t)) -#define BITMAP_BITSPERIMAGE (sizeof(bitmap_t) * 8) -#define BITMAP_BITVALUE(n) ((bitmap_t) (((bitmap_t) 1) << (n))) -#define BITMAP_FIRSTBIT (BITMAP_BITVALUE(BITMAP_BITSPERIMAGE - 1)) -#define BITMAP_TESTBIT(m) ((m) & BITMAP_FIRSTBIT) -#define BITMAP_SHIFTBIT(m) ((bitmap_t) ((m) << 1)) - -/* builtin C-based proportional/fixed font structure */ -/* based on The Microwindows Project http://microwindows.org */ -struct BdfFontData { - char *name; /* font name */ - int maxwidth; /* max width in pixels */ - int height; /* height in pixels */ - int ascent; /* ascent (baseline) height */ - int firstchar; /* first character in bitmap */ - int size; /* font size in glyphs */ - bitmap_t *bits; /* 16-bit right-padded bitmap data */ - unsigned long *offset; /* offsets into bitmap data */ - unsigned char *width; /* character widths or NULL if fixed */ - BBX *bbx; /* character bounding box or NULL if fixed */ - int defaultchar; /* default char (not glyph index) */ - long bits_size; /* # words of bitmap_t bits */ - - /* unused by runtime system, read in by convbdf */ - char *facename; /* facename of font */ - char *copyright; /* copyright info for loadable fonts */ - int pixel_size; - int descent; - int fbbw, fbbh, fbbx, fbby; -}; -/* END font.h */ - -#define isprefix(buf,str) (!strncmp(buf, str, strlen(str))) -#define strequal(s1,s2) (!strcmp(s1, s2)) - -#define EXTRA 300 - -int start_char = 0; -int limit_char = 255; - -BdfFontData *bdf_read_font(Common::SeekableReadStream &fp); -int bdf_read_header(Common::SeekableReadStream &fp, BdfFontData *pf); -int bdf_read_bitmaps(Common::SeekableReadStream &fp, BdfFontData *pf); -char *bdf_getline(Common::SeekableReadStream &fp, char *buf, int len); -bitmap_t bdf_hexval(unsigned char *buf); - -void free_font(BdfFontData *pf) { - if (!pf) + if (height <= 0) return; - free(pf->name); - free(pf->facename); - free(pf->copyright); - free(pf->bits); - free(pf->offset); - free(pf->width); - free(pf->bbx); - free(pf); -} - -/* build incore structure from .bdf file*/ -BdfFontData *bdf_read_font(Common::SeekableReadStream &fp) { - BdfFontData *pf; - uint32 pos = fp.pos(); - pf = (BdfFontData *)calloc(1, sizeof(BdfFontData)); - if (!pf) - goto errout; - - if (!bdf_read_header(fp, pf)) { - warning("Error reading font header"); - goto errout; + int xStart = 0; + if (x < 0) { + xStart = -x; + width += x; + x = 0; } - fp.seek(pos, SEEK_SET); + if (x + width > dst->w) + width = dst->w - x; - if (!bdf_read_bitmaps(fp, pf)) { - warning("Error reading font bitmaps"); - goto errout; - } + if (width <= 0) + return; - return pf; + const int xEnd = xStart + width - 1; -errout: - free_font(pf); - return NULL; + byte *ptr = (byte *)dst->getBasePtr(x, y); + + if (dst->format.bytesPerPixel == 1) + drawCharIntern<byte>(ptr, dst->pitch, src, height, originalWidth, xStart, xEnd, color); + else if (dst->format.bytesPerPixel == 2) + drawCharIntern<uint16>(ptr, dst->pitch, src, height, originalWidth, xStart, xEnd, color); } -/* read bdf font header information, return 0 on error*/ -int bdf_read_header(Common::SeekableReadStream &fp, BdfFontData *pf) { - int encoding = 0; - int nchars = 0, maxwidth, maxheight; - int firstchar = 65535; - int lastchar = -1; - char buf[256]; - char facename[256]; - char copyright[256]; - memset(facename, 0, sizeof(facename)); - memset(copyright, 0, sizeof(copyright)); - - /* set certain values to errors for later error checking*/ - pf->defaultchar = -1; - pf->ascent = -1; - pf->descent = -1; - - for (;;) { - if (!bdf_getline(fp, buf, sizeof(buf))) { - warning("Error: EOF on file"); - return 0; - } +namespace { - /* note: the way sscanf is used here ensures that a terminating null - character is automatically added. Refer to: - http://pubs.opengroup.org/onlinepubs/009695399/functions/fscanf.html */ +inline byte hexToInt(char c) { + if (c >= '0' && c <= '9') + return c - '0'; + else if (c >= 'A' && c <= 'F') + return c - 'A' + 10; + else if (c >= 'a' && c <= 'f') + return c - 'a' + 10; + else + return 0; +} - if (isprefix(buf, "FONT ")) { /* not required*/ - if (sscanf(buf, "FONT %[^\n]", facename) != 1) { - warning("Error: bad 'FONT'"); - return 0; - } +byte *loadCharacter(Common::SeekableReadStream &stream, int &encoding, int &advance, BdfBoundingBox &box) { + Common::String line; + byte *bitmap = 0; - pf->facename = strdup(facename); - continue; + while (true) { + line = stream.readLine(); + if (stream.err() || stream.eos()) { + warning("BdfFont::loadCharacter: Premature end of file"); + delete[] bitmap; + return 0; } - if (isprefix(buf, "COPYRIGHT ")) { /* not required*/ - if (sscanf(buf, "COPYRIGHT \"%[^\"]", copyright) != 1) { - warning("Error: bad 'COPYRIGHT'"); - return 0; - } - pf->copyright = strdup(copyright); - continue; - } - if (isprefix(buf, "DEFAULT_CHAR ")) { /* not required*/ - if (sscanf(buf, "DEFAULT_CHAR %d", &pf->defaultchar) != 1) { - warning("Error: bad 'DEFAULT_CHAR'"); + if (line.hasPrefix("ENCODING ")) { + if (sscanf(line.c_str(), "ENCODING %d", &encoding) != 1) { + warning("BdfFont::loadCharacter: Invalid ENCODING"); + delete[] bitmap; return 0; } - } - if (isprefix(buf, "FONT_DESCENT ")) { - if (sscanf(buf, "FONT_DESCENT %d", &pf->descent) != 1) { - warning("Error: bad 'FONT_DESCENT'"); + } else if (line.hasPrefix("DWIDTH ")) { + int yAdvance; + if (sscanf(line.c_str(), "DWIDTH %d %d", &advance, &yAdvance) != 2) { + warning("BdfFont::loadCharacter: Invalid DWIDTH"); + delete[] bitmap; return 0; } - continue; - } - if (isprefix(buf, "FONT_ASCENT ")) { - if (sscanf(buf, "FONT_ASCENT %d", &pf->ascent) != 1) { - warning("Error: bad 'FONT_ASCENT'"); + + if (yAdvance != 0) { + warning("BdfFont::loadCharacter: Character %d has an y advance of %d", encoding, yAdvance); + delete[] bitmap; return 0; } - continue; - } - if (isprefix(buf, "FONTBOUNDINGBOX ")) { - if (sscanf(buf, "FONTBOUNDINGBOX %d %d %d %d", - &pf->fbbw, &pf->fbbh, &pf->fbbx, &pf->fbby) != 4) { - warning("Error: bad 'FONTBOUNDINGBOX'"); + + if (advance < 0) { + warning("BdfFont::loadCharacter: Character %d has an x advance of %d", encoding, advance); + delete[] bitmap; return 0; } - continue; - } - if (isprefix(buf, "CHARS ")) { - if (sscanf(buf, "CHARS %d", &nchars) != 1) { - warning("Error: bad 'CHARS'"); + } else if (line.hasPrefix("BBX ")) { + int width, height, xOffset, yOffset; + if (sscanf(line.c_str(), "BBX %d %d %d %d", + &width, &height, &xOffset, &yOffset) != 4) { + warning("BdfFont::loadCharacter: Invalid BBX"); + delete[] bitmap; return 0; } - continue; - } - /* - * Reading ENCODING is necessary to get firstchar/lastchar - * which is needed to pre-calculate our offset and widths - * array sizes. - */ - if (isprefix(buf, "ENCODING ")) { - if (sscanf(buf, "ENCODING %d", &encoding) != 1) { - warning("Error: bad 'ENCODING'"); - return 0; - } - if (encoding >= 0 && - encoding <= limit_char && - encoding >= start_char) { - - if (firstchar > encoding) - firstchar = encoding; - if (lastchar < encoding) - lastchar = encoding; + box.width = width; + box.height = height; + box.xOffset = xOffset; + box.yOffset = yOffset; + } else if (line == "BITMAP") { + const uint bytesPerRow = (box.width + 7) / 8; + byte *dst = bitmap = new byte[box.height * bytesPerRow]; + + for (int y = 0; y < box.height; ++y) { + line = stream.readLine(); + if (stream.err() || stream.eos()) { + warning("BdfFont::loadCharacter: Premature end of file"); + delete[] bitmap; + return 0; + } + + if (line.size() != 2 * bytesPerRow) { + warning("BdfFont::loadCharacter: Pixel line has wrong size"); + delete[] bitmap; + return 0; + } + + for (uint x = 0; x < bytesPerRow; ++x) { + char nibble1 = line[x * 2 + 0]; + char nibble2 = line[x * 2 + 1]; + *dst++ = (hexToInt(nibble1) << 4) | hexToInt(nibble2); + } } - continue; + } else if (line == "ENDCHAR") { + return bitmap; } - if (strequal(buf, "ENDFONT")) - break; } - /* calc font height*/ - if (pf->ascent < 0 || pf->descent < 0 || firstchar < 0) { - warning("Error: Invalid BDF file, requires FONT_ASCENT/FONT_DESCENT/ENCODING"); - return 0; - } - pf->height = pf->ascent + pf->descent; - - /* calc default char*/ - if (pf->defaultchar < 0 || - pf->defaultchar < firstchar || - pf->defaultchar > limit_char) - pf->defaultchar = firstchar; - - /* calc font size (offset/width entries)*/ - pf->firstchar = firstchar; - pf->size = lastchar - firstchar + 1; - - /* use the font boundingbox to get initial maxwidth*/ - /*maxwidth = pf->fbbw - pf->fbbx;*/ - maxwidth = pf->fbbw; - maxheight = pf->fbbh; - - /* initially use font bounding box for bits allocation*/ - pf->bits_size = nchars * BITMAP_WORDS(maxwidth) * maxheight; - - /* allocate bits, offset, and width arrays*/ - pf->bits = (bitmap_t *)malloc(pf->bits_size * sizeof(bitmap_t) + EXTRA); - pf->offset = (unsigned long *)malloc(pf->size * sizeof(unsigned long)); - pf->width = (unsigned char *)malloc(pf->size * sizeof(unsigned char)); - pf->bbx = (BBX *)malloc(pf->size * sizeof(BBX)); - - if (!pf->bits || !pf->offset || !pf->width) { - warning("Error: no memory for font load"); - return 0; - } + delete[] bitmap; + return 0; +} - return 1; +void freeBitmaps(byte **bitmaps, int size) { + for (int i = 0; i < size; ++i) + delete[] bitmaps[i]; } -/* read bdf font bitmaps, return 0 on error*/ -int bdf_read_bitmaps(Common::SeekableReadStream &fp, BdfFontData *pf) { - long ofs = 0; - int maxwidth = 0; - int i, k, encoding = 0, width = 0; - int bbw = 0, bbh = 0, bbx = 0, bby = 0; - int proportional = 0; - int need_bbx = 0; - int encodetable = 0; - long l; - char buf[256]; - - /* initially mark offsets as not used*/ - for (i = 0; i < pf->size; ++i) - pf->offset[i] = (unsigned long)-1; - - for (;;) { - if (!bdf_getline(fp, buf, sizeof(buf))) { - warning("Error: EOF on file"); +} // End of anonymous namespace + +BdfFont *BdfFont::loadFont(Common::SeekableReadStream &stream) { + BdfFontData font; + memset(&font, 0, sizeof(font)); + font.ascent = -1; + font.defaultCharacter = -1; + + // We only load the first 256 characters + font.numCharacters = 256; + byte **bitmaps = new byte *[font.numCharacters]; + memset(bitmaps, 0, sizeof(byte *) * font.numCharacters); + byte *advances = new byte[font.numCharacters]; + BdfBoundingBox *boxes = new BdfBoundingBox[font.numCharacters]; + + int descent = -1; + + Common::String line; + while (true) { + line = stream.readLine(); + if (stream.err() || stream.eos()) { + warning("BdfFont::loadFont: Premature end of file"); + freeBitmaps(bitmaps, font.numCharacters); + delete[] bitmaps; + delete[] advances; + delete[] boxes; return 0; } - if (isprefix(buf, "STARTCHAR")) { - encoding = width = bbw = bbh = bbx = bby = -1; - continue; - } - if (isprefix(buf, "ENCODING ")) { - if (sscanf(buf, "ENCODING %d", &encoding) != 1) { - warning("Error: bad 'ENCODING'"); + + // Only parse and handle declarations we actually need + if (line.hasPrefix("FONTBOUNDINGBOX ")) { + int width, height, xOffset, yOffset; + if (sscanf(line.c_str(), "FONTBOUNDINGBOX %d %d %d %d", + &width, &height, &xOffset, &yOffset) != 4) { + warning("BdfFont::loadFont: Invalid FONTBOUNDINGBOX"); + freeBitmaps(bitmaps, font.numCharacters); + delete[] bitmaps; + delete[] advances; + delete[] boxes; return 0; } - if (encoding < start_char || encoding > limit_char) - encoding = -1; - continue; - } - if (isprefix(buf, "DWIDTH ")) { - if (sscanf(buf, "DWIDTH %d", &width) != 1) { - warning("Error: bad 'DWIDTH'"); + + font.defaultBox.width = width; + font.defaultBox.height = height; + font.defaultBox.xOffset = xOffset; + font.defaultBox.yOffset = yOffset; + } else if (line.hasPrefix("FONT_ASCENT ")) { + if (sscanf(line.c_str(), "FONT_ASCENT %d", &font.ascent) != 1) { + warning("BdfFont::loadFont: Invalid FONT_ASCENT"); + freeBitmaps(bitmaps, font.numCharacters); + delete[] bitmaps; + delete[] advances; + delete[] boxes; return 0; } - /* use font boundingbox width if DWIDTH <= 0*/ - if (width <= 0) - width = pf->fbbw - pf->fbbx; - continue; - } - if (isprefix(buf, "BBX ")) { - if (sscanf(buf, "BBX %d %d %d %d", &bbw, &bbh, &bbx, &bby) != 4) { - warning("Error: bad 'BBX'"); + } else if (line.hasPrefix("FONT_DESCENT ")) { + if (sscanf(line.c_str(), "FONT_DESCENT %d", &descent) != 1) { + warning("BdfFont::loadFont: Invalid FONT_DESCENT"); + freeBitmaps(bitmaps, font.numCharacters); + delete[] bitmaps; + delete[] advances; + delete[] boxes; return 0; } - continue; - } - if (strequal(buf, "BITMAP")) { - bitmap_t *ch_bitmap = pf->bits + ofs; - int ch_words; - - if (encoding < 0) - continue; - - /* set bits offset in encode map*/ - if (pf->offset[encoding - pf->firstchar] != (unsigned long)-1) { - warning("Error: duplicate encoding for character %d (0x%02x), ignoring duplicate", - encoding, encoding); - continue; + } else if (line.hasPrefix("DEFAULT_CHAR ")) { + if (sscanf(line.c_str(), "DEFAULT_CHAR %d", &font.defaultCharacter) != 1) { + warning("BdfFont::loadFont: Invalid DEFAULT_CHAR"); + freeBitmaps(bitmaps, font.numCharacters); + delete[] bitmaps; + delete[] advances; + delete[] boxes; + return 0; + } + } else if (line.hasPrefix("STARTCHAR ")) { + BdfBoundingBox box = font.defaultBox; + int encoding = -1; + int advance = -1; + byte *bitmap = loadCharacter(stream, encoding, advance, box); + + // Ignore all characters above 255. + if (encoding < -1 || encoding >= font.numCharacters) { + delete[] bitmap; + encoding = -1; } - pf->offset[encoding - pf->firstchar] = ofs; - pf->width[encoding - pf->firstchar] = width; - pf->bbx[encoding - pf->firstchar].w = bbw; - pf->bbx[encoding - pf->firstchar].h = bbh; - pf->bbx[encoding - pf->firstchar].x = bbx; - pf->bbx[encoding - pf->firstchar].y = bby; + // Calculate the max advance + if (encoding != -1 && advance > font.maxAdvance) + font.maxAdvance = advance; - if (width > maxwidth) - maxwidth = width; + if (!bitmap && encoding != -1) { + warning("BdfFont::loadFont: Character %d invalid", encoding); + freeBitmaps(bitmaps, font.numCharacters); + delete[] bitmaps; + delete[] advances; + delete[] boxes; + return 0; + } - /* clear bitmap*/ - memset(ch_bitmap, 0, BITMAP_BYTES(bbw) * bbh); + if (encoding != -1) { + bitmaps[encoding] = bitmap; + advances[encoding] = advance; + boxes[encoding] = box; + } + } else if (line == "ENDFONT") { + break; + } + } - ch_words = BITMAP_WORDS(bbw); + if (font.ascent < 0 || descent < 0) { + warning("BdfFont::loadFont: Invalid ascent or descent"); + freeBitmaps(bitmaps, font.numCharacters); + delete[] bitmaps; + delete[] advances; + delete[] boxes; + return 0; + } - /* read bitmaps*/ - for (i = 0; i < bbh; ++i) { - if (!bdf_getline(fp, buf, sizeof(buf))) { - warning("Error: EOF reading BITMAP data"); - return 0; - } - if (isprefix(buf, "ENDCHAR")) - break; - - for (k = 0; k < ch_words; ++k) { - bitmap_t value; - - value = bdf_hexval((unsigned char *)buf); - if (bbw > 8) { - WRITE_UINT16(ch_bitmap, value); - } else { - WRITE_UINT16(ch_bitmap, value << 8); - } - ch_bitmap++; - } - } + font.height = font.ascent + descent; + + font.bitmaps = bitmaps; + font.advances = advances; + font.boxes = boxes; + + int firstCharacter = font.numCharacters; + int lastCharacter = -1; + bool hasFixedBBox = true; + bool hasFixedAdvance = true; - ofs += ch_words * bbh; + for (int i = 0; i < font.numCharacters; ++i) { + if (!font.bitmaps[i]) continue; - } - if (strequal(buf, "ENDFONT")) - break; - } - /* set max width*/ - pf->maxwidth = maxwidth; + if (i < firstCharacter) + firstCharacter = i; - /* change unused offset/width values to default char values*/ - for (i = 0; i < pf->size; ++i) { - int defchar = pf->defaultchar - pf->firstchar; + if (i > lastCharacter) + lastCharacter = i; - if (pf->offset[i] == (unsigned long)-1) { - pf->offset[i] = pf->offset[defchar]; - pf->width[i] = pf->width[defchar]; - pf->bbx[i].w = pf->bbx[defchar].w; - pf->bbx[i].h = pf->bbx[defchar].h; - pf->bbx[i].x = pf->bbx[defchar].x; - pf->bbx[i].y = pf->bbx[defchar].y; - } - } + if (font.advances[i] != font.maxAdvance) + hasFixedAdvance = false; - /* determine whether font doesn't require encode table*/ - l = 0; - for (i = 0; i < pf->size; ++i) { - if (pf->offset[i] != (unsigned long)l) { - encodetable = 1; - break; - } - l += BITMAP_WORDS(pf->bbx[i].w) * pf->bbx[i].h; - } - if (!encodetable) { - free(pf->offset); - pf->offset = NULL; + const BdfBoundingBox &bbox = font.boxes[i]; + if (bbox.width != font.defaultBox.width + || bbox.height != font.defaultBox.height + || bbox.xOffset != font.defaultBox.xOffset + || bbox.yOffset != font.defaultBox.yOffset) + hasFixedBBox = false; } - /* determine whether font is fixed-width*/ - for (i = 0; i < pf->size; ++i) { - if (pf->width[i] != maxwidth) { - proportional = 1; - break; - } - } - if (!proportional) { - free(pf->width); - pf->width = NULL; + if (lastCharacter == -1) { + warning("BdfFont::loadFont: No glyphs found"); + delete[] font.bitmaps; + delete[] font.advances; + delete[] font.boxes; + return 0; } - /* determine if the font needs a bbx table */ - for (i = 0; i < pf->size; ++i) { - if (pf->bbx[i].w != pf->fbbw || pf->bbx[i].h != pf->fbbh || pf->bbx[i].x != pf->fbbx || pf->bbx[i].y != pf->fbby) { - need_bbx = 1; - break; - } - } - if (!need_bbx) { - free(pf->bbx); - pf->bbx = NULL; + // Free the advance table, in case all glyphs use the same advance + if (hasFixedAdvance) { + delete[] font.advances; + font.advances = 0; } - /* reallocate bits array to actual bits used*/ - if (ofs < pf->bits_size) { - bitmap_t *tmp = (bitmap_t *)realloc(pf->bits, ofs * sizeof(bitmap_t)); - if (tmp != NULL || ofs == 0) - pf->bits = tmp; - else - error("bdf_read_bitmaps: Error while reallocating memory"); - pf->bits_size = ofs; - } else { - if (ofs > pf->bits_size) { - warning("Warning: DWIDTH spec > max FONTBOUNDINGBOX"); - if (ofs > pf->bits_size + EXTRA) { - warning("Error: Not enough bits initially allocated"); - return 0; - } - pf->bits_size = ofs; - } + // Free the box table, in case all glyphs use the same box + if (hasFixedBBox) { + delete[] font.boxes; + font.boxes = 0; } - return 1; -} + // Adapt for the fact that we never use encoding 0. + if (font.defaultCharacter < firstCharacter + || font.defaultCharacter > lastCharacter) + font.defaultCharacter = -1; -/* read the next non-comment line, returns buf or NULL if EOF*/ -// TODO: Can we use SeekableReadStream::readLine instead? -char *bdf_getline(Common::SeekableReadStream &fp, char *buf, int len) { - int c; - char *b; - - for (;;) { - b = buf; - while (!fp.eos()) { - c = fp.readByte(); - if (c == '\r') - continue; - if (c == '\n') - break; - if (b - buf >= (len - 1)) - break; - *b++ = c; + font.firstCharacter = firstCharacter; + + const int charsAvailable = lastCharacter - firstCharacter + 1; + // Try to compact the tables + if (charsAvailable < font.numCharacters) { + byte **newBitmaps = new byte *[charsAvailable]; + boxes = 0; + advances = 0; + if (!hasFixedBBox) + boxes = new BdfBoundingBox[charsAvailable]; + if (!hasFixedAdvance) + advances = new byte[charsAvailable]; + + for (int i = 0; i < charsAvailable; ++i) { + const int encoding = i + firstCharacter; + if (font.bitmaps[encoding]) { + newBitmaps[i] = bitmaps[encoding]; + + if (!hasFixedBBox) + boxes[i] = font.boxes[encoding]; + if (!hasFixedAdvance) + advances[i] = font.advances[encoding]; + } else { + newBitmaps[i] = 0; + } } - *b = '\0'; - if (fp.eos() && b == buf) - return NULL; - if (b != buf && !isprefix(buf, "COMMENT")) - break; - } - return buf; -} -/* return hex value of buffer */ -bitmap_t bdf_hexval(unsigned char *buf) { - bitmap_t val = 0; - - for (unsigned char *ptr = buf; *ptr; ptr++) { - int c = *ptr; - - if (c >= '0' && c <= '9') - c -= '0'; - else if (c >= 'A' && c <= 'F') - c = c - 'A' + 10; - else if (c >= 'a' && c <= 'f') - c = c - 'a' + 10; - else - c = 0; - val = (val << 4) | c; - } - return val; -} + delete[] font.bitmaps; + font.bitmaps = newBitmaps; + delete[] font.advances; + font.advances = advances; + delete[] font.boxes; + font.boxes = boxes; -BdfFont *BdfFont::loadFont(Common::SeekableReadStream &stream) { - BdfFontData *data = bdf_read_font(stream); - if (!data || stream.err()) { - free_font(data); - return 0; + font.numCharacters = charsAvailable; } - BdfFontDesc desc; - desc.name = data->name; - desc.maxwidth = data->maxwidth; - desc.height = data->height; - desc.fbbw = data->fbbw; - desc.fbbh = data->fbbh; - desc.fbbx = data->fbbx; - desc.fbby = data->fbby; - desc.ascent = data->ascent; - desc.firstchar = data->firstchar; - desc.size = data->size; - desc.bits = data->bits; - desc.offset = data->offset; - desc.width = data->width; - desc.bbx = data->bbx; - desc.defaultchar = data->defaultchar; - desc.bits_size = data->bits_size; - - return new BdfFont(desc, data); + return new BdfFont(font, DisposeAfterUse::YES); } +#define BDF_FONTCACHE_TAG MKTAG('S', 'V', 'F', 'C') +#define BDF_FONTCACHE_VERSION 1 + bool BdfFont::cacheFontData(const BdfFont &font, const Common::String &filename) { Common::DumpFile cacheFile; if (!cacheFile.open(filename)) { - warning("Couldn't open file '%s' for writing", filename.c_str()); + warning("BdfFont::cacheFontData: Couldn't open file '%s' for writing", filename.c_str()); return false; } - cacheFile.writeUint16BE(font._desc.maxwidth); - cacheFile.writeUint16BE(font._desc.height); - cacheFile.writeUint16BE(font._desc.fbbw); - cacheFile.writeUint16BE(font._desc.fbbh); - cacheFile.writeSint16BE(font._desc.fbbx); - cacheFile.writeSint16BE(font._desc.fbby); - cacheFile.writeUint16BE(font._desc.ascent); - cacheFile.writeUint16BE(font._desc.firstchar); - cacheFile.writeUint16BE(font._desc.size); - cacheFile.writeUint16BE(font._desc.defaultchar); - cacheFile.writeUint32BE(font._desc.bits_size); - - for (long i = 0; i < font._desc.bits_size; ++i) { - cacheFile.writeUint16BE(font._desc.bits[i]); - } - - if (font._desc.offset) { - cacheFile.writeByte(1); - for (int i = 0; i < font._desc.size; ++i) { - cacheFile.writeUint32BE(font._desc.offset[i]); + const BdfFontData &data = font._data; + + cacheFile.writeUint32BE(BDF_FONTCACHE_TAG); + cacheFile.writeUint32BE(BDF_FONTCACHE_VERSION); + cacheFile.writeUint16BE(data.maxAdvance); + cacheFile.writeByte(data.height); + cacheFile.writeByte(data.defaultBox.width); + cacheFile.writeByte(data.defaultBox.height); + cacheFile.writeSByte(data.defaultBox.xOffset); + cacheFile.writeSByte(data.defaultBox.yOffset); + cacheFile.writeByte(data.ascent); + cacheFile.writeUint16BE(data.firstCharacter); + cacheFile.writeSint16BE(data.defaultCharacter); + cacheFile.writeUint16BE(data.numCharacters); + + for (int i = 0; i < data.numCharacters; ++i) { + const BdfBoundingBox &box = data.boxes ? data.boxes[i] : data.defaultBox; + if (data.bitmaps[i]) { + const int bytes = ((box.width + 7) / 8) * box.height; + cacheFile.writeUint32BE(bytes); + cacheFile.write(data.bitmaps[i], bytes); + } else { + cacheFile.writeUint32BE(0); } - } else { - cacheFile.writeByte(0); } - if (font._desc.width) { - cacheFile.writeByte(1); - for (int i = 0; i < font._desc.size; ++i) { - cacheFile.writeByte(font._desc.width[i]); - } + if (data.advances) { + cacheFile.writeByte(0xFF); + cacheFile.write(data.advances, data.numCharacters); } else { - cacheFile.writeByte(0); + cacheFile.writeByte(0x00); } - if (font._desc.bbx) { - cacheFile.writeByte(1); - for (int i = 0; i < font._desc.size; ++i) { - cacheFile.writeByte(font._desc.bbx[i].w); - cacheFile.writeByte(font._desc.bbx[i].h); - cacheFile.writeByte(font._desc.bbx[i].x); - cacheFile.writeByte(font._desc.bbx[i].y); + if (data.boxes) { + cacheFile.writeByte(0xFF); + + for (int i = 0; i < data.numCharacters; ++i) { + const BdfBoundingBox &box = data.boxes[i]; + cacheFile.writeByte(box.width); + cacheFile.writeByte(box.height); + cacheFile.writeSByte(box.xOffset); + cacheFile.writeSByte(box.yOffset); } } else { - cacheFile.writeByte(0); + cacheFile.writeByte(0x00); } return !cacheFile.err(); } BdfFont *BdfFont::loadFromCache(Common::SeekableReadStream &stream) { - BdfFont *font = 0; - - BdfFontData *data = (BdfFontData *)malloc(sizeof(BdfFontData)); - if (!data) + const uint32 magic = stream.readUint32BE(); + if (magic != BDF_FONTCACHE_TAG) return 0; - memset(data, 0, sizeof(BdfFontData)); - - data->maxwidth = stream.readUint16BE(); - data->height = stream.readUint16BE(); - data->fbbw = stream.readUint16BE(); - data->fbbh = stream.readUint16BE(); - data->fbbx = stream.readSint16BE(); - data->fbby = stream.readSint16BE(); - data->ascent = stream.readUint16BE(); - data->firstchar = stream.readUint16BE(); - data->size = stream.readUint16BE(); - data->defaultchar = stream.readUint16BE(); - data->bits_size = stream.readUint32BE(); - - data->bits = (bitmap_t *)malloc(sizeof(bitmap_t) * data->bits_size); - if (!data->bits) { - free(data); + const uint32 version = stream.readUint32BE(); + if (version != BDF_FONTCACHE_VERSION) return 0; - } - for (long i = 0; i < data->bits_size; ++i) { - data->bits[i] = stream.readUint16BE(); - } + BdfFontData data; - bool hasOffsetTable = (stream.readByte() != 0); - if (hasOffsetTable) { - data->offset = (unsigned long *)malloc(sizeof(unsigned long) * data->size); - if (!data->offset) { - free(data->bits); - free(data); - return 0; - } + data.maxAdvance = stream.readUint16BE(); + data.height = stream.readByte(); + data.defaultBox.width = stream.readByte(); + data.defaultBox.height = stream.readByte(); + data.defaultBox.xOffset = stream.readSByte(); + data.defaultBox.yOffset = stream.readSByte(); + data.ascent = stream.readByte(); + data.firstCharacter = stream.readUint16BE(); + data.defaultCharacter = stream.readSint16BE(); + data.numCharacters = stream.readUint16BE(); - for (int i = 0; i < data->size; ++i) { - data->offset[i] = stream.readUint32BE(); - } - } + if (stream.err() || stream.eos()) + return 0; - bool hasWidthTable = (stream.readByte() != 0); - if (hasWidthTable) { - data->width = (unsigned char *)malloc(sizeof(unsigned char) * data->size); - if (!data->width) { - free(data->bits); - free(data->offset); - free(data); + byte **bitmaps = new byte *[data.numCharacters]; + byte *advances = 0; + BdfBoundingBox *boxes = 0; + for (int i = 0; i < data.numCharacters; ++i) { + uint32 size = stream.readUint32BE(); + + if (stream.err() || stream.eos()) { + for (int j = 0; j < i; ++j) + delete[] bitmaps[i]; + delete[] bitmaps; return 0; } - for (int i = 0; i < data->size; ++i) { - data->width[i] = stream.readByte(); + if (size) { + bitmaps[i] = new byte[size]; + stream.read(bitmaps[i], size); + } else { + bitmaps[i] = 0; } } - bool hasBBXTable = (stream.readByte() != 0); - if (hasBBXTable) { - data->bbx = (BBX *)malloc(sizeof(BBX) * data->size); - if (!data->bbx) { - free(data->bits); - free(data->offset); - free(data->width); - free(data); - return 0; - } - for (int i = 0; i < data->size; ++i) { - data->bbx[i].w = (int8)stream.readByte(); - data->bbx[i].h = (int8)stream.readByte(); - data->bbx[i].x = (int8)stream.readByte(); - data->bbx[i].y = (int8)stream.readByte(); - } + if (stream.readByte() == 0xFF) { + advances = new byte[data.numCharacters]; + stream.read(advances, data.numCharacters); } - if (stream.err() || stream.eos()) { - free(data->bits); - free(data->offset); - free(data->width); - free(data); - return 0; + if (stream.readByte() == 0xFF) { + boxes = new BdfBoundingBox[data.numCharacters]; + for (int i = 0; i < data.numCharacters; ++i) { + boxes[i].width = stream.readByte(); + boxes[i].height = stream.readByte(); + boxes[i].xOffset = stream.readSByte(); + boxes[i].yOffset = stream.readSByte(); + } } - BdfFontDesc desc; - desc.name = data->name; - desc.maxwidth = data->maxwidth; - desc.height = data->height; - desc.fbbw = data->fbbw; - desc.fbbh = data->fbbh; - desc.fbbx = data->fbbx; - desc.fbby = data->fbby; - desc.ascent = data->ascent; - desc.firstchar = data->firstchar; - desc.size = data->size; - desc.bits = data->bits; - desc.offset = data->offset; - desc.width = data->width; - desc.bbx = data->bbx; - desc.defaultchar = data->defaultchar; - desc.bits_size = data->bits_size; - - font = new BdfFont(desc, data); - if (!font) { - free(data->bits); - free(data->offset); - free(data->width); - free(data); + if (stream.eos() || stream.err()) { + for (int i = 0; i < data.numCharacters; ++i) + delete[] bitmaps[i]; + delete[] bitmaps; + delete[] advances; + delete[] boxes; return 0; } - return font; + data.bitmaps = bitmaps; + data.advances = advances; + data.boxes = boxes; + return new BdfFont(data, DisposeAfterUse::YES); } } // End of namespace Graphics diff --git a/graphics/fonts/bdf.h b/graphics/fonts/bdf.h index 0d60693736..5b615cc043 100644 --- a/graphics/fonts/bdf.h +++ b/graphics/fonts/bdf.h @@ -23,6 +23,7 @@ #define GRAPHICS_FONTS_BDF_H #include "common/system.h" +#include "common/types.h" #include "graphics/font.h" @@ -32,42 +33,29 @@ class SeekableReadStream; namespace Graphics { -typedef uint16 bitmap_t; /* bitmap image unit size*/ - -struct BBX { - int8 w; - int8 h; - int8 x; - int8 y; +struct BdfBoundingBox { + uint8 width, height; + int8 xOffset, yOffset; }; -/* builtin C-based proportional/fixed font structure */ -/* based on The Microwindows Project http://microwindows.org */ -struct BdfFontDesc { - const char *name; /* font name */ - int maxwidth; /* max width in pixels */ - int height; /* height in pixels */ - int fbbw, fbbh, fbbx, fbby; /* max bounding box */ - int ascent; /* ascent (baseline) height */ - int firstchar; /* first character in bitmap */ - int size; /* font size in glyphs */ - const bitmap_t *bits; /* 16-bit right-padded bitmap data */ - const unsigned long *offset; /* offsets into bitmap data */ - const unsigned char *width; /* character widths or NULL if fixed */ - const BBX *bbx; /* character bounding box or NULL if fixed */ - int defaultchar; /* default char (not glyph index) */ - long bits_size; /* # words of bitmap_t bits */ -}; +struct BdfFontData { + int maxAdvance; + int height; + BdfBoundingBox defaultBox; + int ascent; -struct BdfFontData; + int firstCharacter; + int defaultCharacter; + int numCharacters; -class BdfFont : public Font { -protected: - BdfFontDesc _desc; - BdfFontData *_font; + const byte *const *bitmaps; + const byte *advances; + const BdfBoundingBox *boxes; +}; +class BdfFont : public Font { public: - BdfFont(const BdfFontDesc &desc, BdfFontData *font = 0) : _desc(desc), _font(font) {} + BdfFont(const BdfFontData &data, DisposeAfterUse::Flag dispose); ~BdfFont(); virtual int getFontHeight() const; @@ -79,12 +67,17 @@ public: static BdfFont *loadFont(Common::SeekableReadStream &stream); static bool cacheFontData(const BdfFont &font, const Common::String &filename); static BdfFont *loadFromCache(Common::SeekableReadStream &stream); +private: + int mapToIndex(byte ch) const; + + const BdfFontData _data; + const DisposeAfterUse::Flag _dispose; }; #define DEFINE_FONT(n) \ const BdfFont *n = 0; \ void create_##n() { \ - n = new BdfFont(desc); \ + n = new BdfFont(desc, DisposeAfterUse::YES); \ } #define FORWARD_DECLARE_FONT(n) \ diff --git a/graphics/fonts/consolefont.cpp b/graphics/fonts/consolefont.cpp index 5b4768327a..8244d75fc2 100644 --- a/graphics/fonts/consolefont.cpp +++ b/graphics/fonts/consolefont.cpp @@ -1,5654 +1,5867 @@ -/* Generated by convbdf on Sat Jun 17 01:37:46 2006. */ +// Generated by convbdf on Fri Jan 6 14:32:21 2012 #include "graphics/fonts/bdf.h" -/* Font information: - name: 5x8-L1 - facename: -Misc-Fixed-Medium-R-Normal--8-80-75-75-C-50-ISO8859-1 - w x h: 5x8 - bbx: 5 8 0 -1 - size: 256 - ascent: 7 - descent: 1 - first char: 0 (0x00) - last char: 255 (0xff) - default char: 0 (0x00) - proportional: no - Public domain font. Share and enjoy. -*/ +// Font information: +// Name: -Misc-Fixed-Medium-R-Normal--8-80-75-75-C-50-ISO8859-1 +// Size: 5x8 +// Box: 5 8 0 -1 +// Ascent: 7 +// First character: 0 +// Default character: 0 +// Characters: 256 +// Copyright: "Public domain font. Share and enjoy." namespace Graphics { -/* Font character bitmap data. */ -static const bitmap_t _font_bits[] = { - -/* Character 0 (0x00): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - | * | - |* | - | * | - |* | - | * * | - | | - +-----+ -*/ -0x0000, -0xa000, -0x1000, -0x8000, -0x1000, -0x8000, -0x5000, -0x0000, - -/* Character 1 (0x01): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | * | - | *** | - |*****| - | *** | - | * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x2000, -0x7000, -0xf800, -0x7000, -0x2000, -0x0000, - -/* Character 2 (0x02): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * * | - |* * *| - | * * | - |* * *| - | * * | - |* * *| - | * * | - |* * *| - +-----+ -*/ -0x5000, -0xa800, -0x5000, -0xa800, -0x5000, -0xa800, -0x5000, -0xa800, - -/* Character 3 (0x03): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* * | - |* * | - |*** | - |* * | - |* * | - | *** | - | * | - | * | - +-----+ -*/ -0xa000, -0xa000, -0xe000, -0xa000, -0xa000, -0x7000, -0x2000, -0x2000, - -/* Character 4 (0x04): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |*** | - |* | - |** | - |* ***| - |* * | - | ** | - | * | - | * | - +-----+ -*/ -0xe000, -0x8000, -0xc000, -0xb800, -0xa000, -0x3000, -0x2000, -0x2000, - -/* Character 5 (0x05): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* | - |* | - | ** | - | ** | - | * *| - | ** | - | * *| - +-----+ -*/ -0x6000, -0x8000, -0x8000, -0x6000, -0x3000, -0x2800, -0x3000, -0x2800, - -/* Character 6 (0x06): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* | - |* | - |* | - |*** | - | ***| - | * | - | ** | - | * | - +-----+ -*/ -0x8000, -0x8000, -0x8000, -0xe000, -0x3800, -0x2000, -0x3000, -0x2000, - -/* Character 7 (0x07): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * * | - | * | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x2000, -0x5000, -0x2000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 8 (0x08): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | * | - | *** | - | * | - | | - | *** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x2000, -0x7000, -0x2000, -0x0000, -0x7000, -0x0000, - -/* Character 9 (0x09): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* * | - |** * | - |* ** | - |* * | - | * | - | * | - | * | - | ***| - +-----+ -*/ -0x9000, -0xd000, -0xb000, -0x9000, -0x2000, -0x2000, -0x2000, -0x3800, - -/* Character 10 (0x0a): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* * | - |* * | - |* * | - | * | - | ***| - | * | - | * | - | * | - +-----+ -*/ -0xa000, -0xa000, -0xa000, -0x4000, -0x3800, -0x1000, -0x1000, -0x1000, - -/* Character 11 (0x0b): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | * | - |*** | - | | - | | - | | - | | - +-----+ -*/ -0x2000, -0x2000, -0x2000, -0xe000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 12 (0x0c): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |*** | - | * | - | * | - | * | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xe000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 13 (0x0d): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | ***| - | * | - | * | - | * | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x3800, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 14 (0x0e): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | * | - | ***| - | | - | | - | | - | | - +-----+ -*/ -0x2000, -0x2000, -0x2000, -0x3800, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 15 (0x0f): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | * | - |*****| - | * | - | * | - | * | - | * | - +-----+ -*/ -0x2000, -0x2000, -0x2000, -0xf800, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 16 (0x10): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |*****| - | | - | | - | | - | | - | | - | | - | | - +-----+ -*/ -0xf800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 17 (0x11): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |*****| - | | - | | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0xf800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 18 (0x12): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |*****| - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xf800, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 19 (0x13): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | | - | | - |*****| - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xf800, -0x0000, - -/* Character 20 (0x14): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | | - | | - | | - |*****| - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xf800, - -/* Character 21 (0x15): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | * | - | ***| - | * | - | * | - | * | - | * | - +-----+ -*/ -0x2000, -0x2000, -0x2000, -0x3800, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 22 (0x16): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | * | - |*** | - | * | - | * | - | * | - | * | - +-----+ -*/ -0x2000, -0x2000, -0x2000, -0xe000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 23 (0x17): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | * | - |*****| - | | - | | - | | - | | - +-----+ -*/ -0x2000, -0x2000, -0x2000, -0xf800, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 24 (0x18): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |*****| - | * | - | * | - | * | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xf800, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 25 (0x19): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - +-----+ -*/ -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 26 (0x1a): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x0000, -0x1000, -0x2000, -0x4000, -0x2000, -0x1000, -0x7000, -0x0000, - -/* Character 27 (0x1b): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x0000, -0x4000, -0x2000, -0x1000, -0x2000, -0x4000, -0x7000, -0x0000, - -/* Character 28 (0x1c): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |*****| - | * * | - | * * | - | * * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xf800, -0x5000, -0x5000, -0x5000, -0x0000, - -/* Character 29 (0x1d): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | * | - |**** | - | ** | - |**** | - | * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x2000, -0xf000, -0x6000, -0xf000, -0x4000, -0x0000, - -/* Character 30 (0x1e): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * * | - |*** | - | * | - | * * | - |* * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x5000, -0xe000, -0x4000, -0x5000, -0xa000, -0x0000, - -/* Character 31 (0x1f): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | * | - | | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 32 (0x20): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 33 (0x21): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | * | - | | - | * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, -0x2000, -0x0000, - -/* Character 34 (0x22): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * * | - | * * | - | * * | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x5000, -0x5000, -0x5000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 35 (0x23): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * * | - | * * | - |*****| - | * * | - |*****| - | * * | - | * * | - | | - +-----+ -*/ -0x5000, -0x5000, -0xf800, -0x5000, -0xf800, -0x5000, -0x5000, -0x0000, - -/* Character 36 (0x24): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | *** | - |* * | - | *** | - | * *| - | *** | - | * | - | | - +-----+ -*/ -0x2000, -0x7000, -0xa000, -0x7000, -0x2800, -0x7000, -0x2000, -0x0000, - -/* Character 37 (0x25): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * * | - | * | - | * * | - | * | - | | - | | - +-----+ -*/ -0x0000, -0x4000, -0x5000, -0x2000, -0x5000, -0x1000, -0x0000, -0x0000, - -/* Character 38 (0x26): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - |* * | - |* * | - | * | - |* * | - |* * | - | * * | - | | - +-----+ -*/ -0x4000, -0xa000, -0xa000, -0x4000, -0xa000, -0xa000, -0x5000, -0x0000, - -/* Character 39 (0x27): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x2000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 40 (0x28): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x4000, -0x4000, -0x4000, -0x4000, -0x2000, -0x0000, - -/* Character 41 (0x29): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x4000, -0x2000, -0x2000, -0x2000, -0x2000, -0x4000, -0x0000, - -/* Character 42 (0x2a): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - |* * | - | ** | - |**** | - | ** | - |* * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x9000, -0x6000, -0xf000, -0x6000, -0x9000, -0x0000, - -/* Character 43 (0x2b): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | * | - | * | - |*****| - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x2000, -0x2000, -0xf800, -0x2000, -0x2000, -0x0000, - -/* Character 44 (0x2c): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | | - | ** | - | * | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x3000, -0x2000, -0x4000, - -/* Character 45 (0x2d): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - |**** | - | | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0xf000, -0x0000, -0x0000, -0x0000, - -/* Character 46 (0x2e): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | | - | * | - | *** | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x2000, -0x7000, -0x2000, - -/* Character 47 (0x2f): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | * | - |* | - |* | - | | - +-----+ -*/ -0x0000, -0x1000, -0x1000, -0x2000, -0x4000, -0x8000, -0x8000, -0x0000, - -/* Character 48 (0x30): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * * | - | * * | - | * * | - | * * | - | * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x5000, -0x5000, -0x5000, -0x5000, -0x2000, -0x0000, - -/* Character 49 (0x31): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | ** | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x0000, -0x2000, -0x6000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 50 (0x32): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - | * | - | ** | - |* | - |**** | - | | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x1000, -0x6000, -0x8000, -0xf000, -0x0000, - -/* Character 51 (0x33): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |**** | - | * | - | ** | - | * | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0xf000, -0x2000, -0x6000, -0x1000, -0x9000, -0x6000, -0x0000, - -/* Character 52 (0x34): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | ** | - |* * | - |**** | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x6000, -0xa000, -0xf000, -0x2000, -0x2000, -0x0000, - -/* Character 53 (0x35): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |**** | - |* | - |*** | - | * | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0xf000, -0x8000, -0xe000, -0x1000, -0x9000, -0x6000, -0x0000, - -/* Character 54 (0x36): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* | - |*** | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0x6000, -0x8000, -0xe000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 55 (0x37): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |**** | - | * | - | * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0xf000, -0x1000, -0x2000, -0x2000, -0x4000, -0x4000, -0x0000, - -/* Character 56 (0x38): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - | ** | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x6000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 57 (0x39): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - |* * | - | *** | - | * | - | ** | - | | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x9000, -0x7000, -0x1000, -0x6000, -0x0000, - -/* Character 58 (0x3a): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | ** | - | ** | - | | - | ** | - | ** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x6000, -0x6000, -0x0000, -0x6000, -0x6000, -0x0000, - -/* Character 59 (0x3b): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | ** | - | ** | - | | - | ** | - | * | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x3000, -0x3000, -0x0000, -0x3000, -0x2000, -0x4000, - -/* Character 60 (0x3c): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x1000, -0x2000, -0x4000, -0x4000, -0x2000, -0x1000, -0x0000, - -/* Character 61 (0x3d): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |**** | - | | - |**** | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xf000, -0x0000, -0xf000, -0x0000, -0x0000, - -/* Character 62 (0x3e): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x4000, -0x2000, -0x1000, -0x1000, -0x2000, -0x4000, -0x0000, - -/* Character 63 (0x3f): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * * | - | * | - | * | - | | - | * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x5000, -0x1000, -0x2000, -0x0000, -0x2000, -0x0000, - -/* Character 64 (0x40): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - | * *| - |* **| - |* * *| - |* * *| - |* * | - | * | - | ** | - +-----+ -*/ -0x3000, -0x4800, -0x9800, -0xa800, -0xa800, -0x9000, -0x4000, -0x3000, - -/* Character 65 (0x41): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - |* * | - |**** | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x9000, -0xf000, -0x9000, -0x9000, -0x0000, - -/* Character 66 (0x42): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |*** | - |* * | - |*** | - |* * | - |* * | - |*** | - | | - +-----+ -*/ -0x0000, -0xe000, -0x9000, -0xe000, -0x9000, -0x9000, -0xe000, -0x0000, - -/* Character 67 (0x43): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - |* | - |* | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x8000, -0x8000, -0x9000, -0x6000, -0x0000, - -/* Character 68 (0x44): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |*** | - |* * | - |* * | - |* * | - |* * | - |*** | - | | - +-----+ -*/ -0x0000, -0xe000, -0x9000, -0x9000, -0x9000, -0x9000, -0xe000, -0x0000, - -/* Character 69 (0x45): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |**** | - |* | - |*** | - |* | - |* | - |**** | - | | - +-----+ -*/ -0x0000, -0xf000, -0x8000, -0xe000, -0x8000, -0x8000, -0xf000, -0x0000, - -/* Character 70 (0x46): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |**** | - |* | - |*** | - |* | - |* | - |* | - | | - +-----+ -*/ -0x0000, -0xf000, -0x8000, -0xe000, -0x8000, -0x8000, -0x8000, -0x0000, - -/* Character 71 (0x47): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - |* | - |* ** | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x8000, -0xb000, -0x9000, -0x6000, -0x0000, - -/* Character 72 (0x48): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - |* * | - |**** | - |* * | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0x9000, -0x9000, -0xf000, -0x9000, -0x9000, -0x9000, -0x0000, - -/* Character 73 (0x49): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - | * | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x0000, -0x7000, -0x2000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 74 (0x4a): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - | * | - | * | - | * | - |* * | - | * | - | | - +-----+ -*/ -0x0000, -0x7000, -0x2000, -0x2000, -0x2000, -0xa000, -0x4000, -0x0000, - -/* Character 75 (0x4b): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - |* * | - |** | - |* * | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0x9000, -0xa000, -0xc000, -0xa000, -0xa000, -0x9000, -0x0000, - -/* Character 76 (0x4c): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* | - |* | - |* | - |* | - |* | - |**** | - | | - +-----+ -*/ -0x0000, -0x8000, -0x8000, -0x8000, -0x8000, -0x8000, -0xf000, -0x0000, - -/* Character 77 (0x4d): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - |**** | - |**** | - |* * | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0x9000, -0xf000, -0xf000, -0x9000, -0x9000, -0x9000, -0x0000, - -/* Character 78 (0x4e): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - |** * | - |**** | - |* ** | - |* ** | - |* * | - | | - +-----+ -*/ -0x0000, -0x9000, -0xd000, -0xf000, -0xb000, -0xb000, -0x9000, -0x0000, - -/* Character 79 (0x4f): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 80 (0x50): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |*** | - |* * | - |* * | - |*** | - |* | - |* | - | | - +-----+ -*/ -0x0000, -0xe000, -0x9000, -0x9000, -0xe000, -0x8000, -0x8000, -0x0000, - -/* Character 81 (0x51): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - |* * | - |** * | - |* ** | - | ** | - | * | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x9000, -0xd000, -0xb000, -0x6000, -0x1000, - -/* Character 82 (0x52): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |*** | - |* * | - |* * | - |*** | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0xe000, -0x9000, -0x9000, -0xe000, -0x9000, -0x9000, -0x0000, - -/* Character 83 (0x53): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - | * | - | * | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x4000, -0x2000, -0x9000, -0x6000, -0x0000, - -/* Character 84 (0x54): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - | * | - | * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x7000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, - -/* Character 85 (0x55): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - |* * | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0x9000, -0x9000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 86 (0x56): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - |* * | - |* * | - |* * | - | ** | - | ** | - | | - +-----+ -*/ -0x0000, -0x9000, -0x9000, -0x9000, -0x9000, -0x6000, -0x6000, -0x0000, - -/* Character 87 (0x57): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - |* * | - |* * | - |**** | - |**** | - |* * | - | | - +-----+ -*/ -0x0000, -0x9000, -0x9000, -0x9000, -0xf000, -0xf000, -0x9000, -0x0000, - -/* Character 88 (0x58): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - |* * | - | ** | - | ** | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0x9000, -0x9000, -0x6000, -0x6000, -0x9000, -0x9000, -0x0000, - -/* Character 89 (0x59): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* *| - |* *| - | * * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x8800, -0x8800, -0x5000, -0x2000, -0x2000, -0x2000, -0x0000, - -/* Character 90 (0x5a): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |**** | - | * | - | * | - | * | - |* | - |**** | - | | - +-----+ -*/ -0x0000, -0xf000, -0x1000, -0x2000, -0x4000, -0x8000, -0xf000, -0x0000, - -/* Character 91 (0x5b): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - | * | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x0000, -0x7000, -0x4000, -0x4000, -0x4000, -0x4000, -0x7000, -0x0000, - -/* Character 92 (0x5c): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* | - |* | - | * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x8000, -0x8000, -0x4000, -0x2000, -0x1000, -0x1000, -0x0000, - -/* Character 93 (0x5d): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - | * | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x0000, -0x7000, -0x1000, -0x1000, -0x1000, -0x1000, -0x7000, -0x0000, - -/* Character 94 (0x5e): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * * | - | | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x2000, -0x5000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 95 (0x5f): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | | - | | - | | - |**** | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xf000, - -/* Character 96 (0x60): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x4000, -0x2000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 97 (0x61): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | *** | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x7000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 98 (0x62): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* | - |* | - |*** | - |* * | - |* * | - |*** | - | | - +-----+ -*/ -0x0000, -0x8000, -0x8000, -0xe000, -0x9000, -0x9000, -0xe000, -0x0000, - -/* Character 99 (0x63): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | ** | - | * | - | * | - | ** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x3000, -0x4000, -0x4000, -0x3000, -0x0000, - -/* Character 100 (0x64): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | *** | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x0000, -0x1000, -0x1000, -0x7000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 101 (0x65): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | ** | - |* ** | - |** | - | ** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x6000, -0xb000, -0xc000, -0x6000, -0x0000, - -/* Character 102 (0x66): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * * | - | * | - |*** | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x5000, -0x4000, -0xe000, -0x4000, -0x4000, -0x0000, - -/* Character 103 (0x67): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | ** | - |* * | - | *** | - | * | - | ** | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x6000, -0x9000, -0x7000, -0x1000, -0x6000, - -/* Character 104 (0x68): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* | - |* | - |*** | - |* * | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0x8000, -0x8000, -0xe000, -0x9000, -0x9000, -0x9000, -0x0000, - -/* Character 105 (0x69): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | | - | ** | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x0000, -0x2000, -0x0000, -0x6000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 106 (0x6a): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | | - | * | - | * | - | * | - | * * | - | * | - +-----+ -*/ -0x0000, -0x1000, -0x0000, -0x1000, -0x1000, -0x1000, -0x5000, -0x2000, - -/* Character 107 (0x6b): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* | - |* | - |* * | - |*** | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0x8000, -0x8000, -0x9000, -0xe000, -0x9000, -0x9000, -0x0000, - -/* Character 108 (0x6c): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - | * | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x0000, -0x6000, -0x2000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 109 (0x6d): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |** * | - |* * *| - |* * *| - |* * *| - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xd000, -0xa800, -0xa800, -0xa800, -0x0000, - -/* Character 110 (0x6e): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |*** | - |* * | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xe000, -0x9000, -0x9000, -0x9000, -0x0000, - -/* Character 111 (0x6f): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | ** | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x6000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 112 (0x70): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |*** | - |* * | - |*** | - |* | - |* | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xe000, -0x9000, -0xe000, -0x8000, -0x8000, - -/* Character 113 (0x71): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | *** | - |* * | - | *** | - | * | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x7000, -0x9000, -0x7000, -0x1000, -0x1000, - -/* Character 114 (0x72): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |* * | - |** * | - |* | - |* | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xa000, -0xd000, -0x8000, -0x8000, -0x0000, - -/* Character 115 (0x73): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | ** | - | ** | - | * | - | ** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x3000, -0x6000, -0x1000, -0x6000, -0x0000, - -/* Character 116 (0x74): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - |*** | - | * | - | * * | - | * | - | | - +-----+ -*/ -0x0000, -0x4000, -0x4000, -0xe000, -0x4000, -0x5000, -0x2000, -0x0000, - -/* Character 117 (0x75): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |* * | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x9000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 118 (0x76): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | * * | - | * * | - | * * | - | * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x5000, -0x5000, -0x5000, -0x2000, -0x0000, - -/* Character 119 (0x77): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |* *| - |* * *| - |* * *| - | * * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x8800, -0xa800, -0xa800, -0x5000, -0x0000, - -/* Character 120 (0x78): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |* * | - | ** | - | ** | - |* * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x9000, -0x6000, -0x6000, -0x9000, -0x0000, - -/* Character 121 (0x79): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |* * | - |* * | - | *** | - |* * | - | ** | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x9000, -0x9000, -0x7000, -0x9000, -0x6000, - -/* Character 122 (0x7a): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |**** | - | * | - | * | - |**** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xf000, -0x2000, -0x4000, -0xf000, -0x0000, - -/* Character 123 (0x7b): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - | * | - | * | - |** | - | * | - | * | - | ** | - | | - +-----+ -*/ -0x3000, -0x4000, -0x2000, -0xc000, -0x2000, -0x4000, -0x3000, -0x0000, - -/* Character 124 (0x7c): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, - -/* Character 125 (0x7d): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |** | - | * | - | * | - | ** | - | * | - | * | - |** | - | | - +-----+ -*/ -0xc000, -0x2000, -0x4000, -0x3000, -0x4000, -0x2000, -0xc000, -0x0000, - -/* Character 126 (0x7e): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * * | - |* * | - | | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x5000, -0xa000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 160 (0xa0): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 161 (0xa1): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | | - | * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x0000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, - -/* Character 162 (0xa2): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | * | - | *** | - |* * | - |* * | - | *** | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x2000, -0x7000, -0xa000, -0xa000, -0x7000, -0x2000, - -/* Character 163 (0xa3): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * * | - |*** | - | * | - | * * | - |* * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x5000, -0xe000, -0x4000, -0x5000, -0xa000, -0x0000, - -/* Character 164 (0xa4): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - |* *| - | *** | - | * * | - | *** | - |* *| - | | - +-----+ -*/ -0x0000, -0x0000, -0x8800, -0x7000, -0x5000, -0x7000, -0x8800, -0x0000, - -/* Character 165 (0xa5): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* *| - | * * | - |*****| - | * | - |*****| - | * | - | | - +-----+ -*/ -0x0000, -0x8800, -0x5000, -0xf800, -0x2000, -0xf800, -0x2000, -0x0000, - -/* Character 166 (0xa6): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | * | - | | - | * | - | * | - | * | - | | - +-----+ -*/ -0x2000, -0x2000, -0x2000, -0x0000, -0x2000, -0x2000, -0x2000, -0x0000, - -/* Character 167 (0xa7): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | *** | - |* | - |*** | - |* * | - | *** | - | * | - |*** | - | | - +-----+ -*/ -0x7000, -0x8000, -0xe000, -0x9000, -0x7000, -0x1000, -0xe000, -0x0000, - -/* Character 168 (0xa8): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * * | - | | - | | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x5000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 169 (0xa9): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - |* * *| - |** *| - |** *| - |* * *| - | *** | - | | - +-----+ -*/ -0x0000, -0x7000, -0xa800, -0xc800, -0xc800, -0xa800, -0x7000, -0x0000, - -/* Character 170 (0xaa): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - | * * | - | ** | - | | - | *** | - | | - | | - | | - +-----+ -*/ -0x3000, -0x5000, -0x3000, -0x0000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 171 (0xab): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | * * | - |* * | - | * * | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x5000, -0xa000, -0x5000, -0x0000, -0x0000, - -/* Character 172 (0xac): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | *** | - | * | - | * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7000, -0x1000, -0x1000, -0x0000, - -/* Character 173 (0xad): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | *** | - | | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 174 (0xae): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - |*** *| - |** **| - |*** *| - |** **| - | *** | - | | - +-----+ -*/ -0x0000, -0x7000, -0xe800, -0xd800, -0xe800, -0xd800, -0x7000, -0x0000, - -/* Character 175 (0xaf): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - | | - | | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x7000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 176 (0xb0): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * * | - | * | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x2000, -0x5000, -0x2000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 177 (0xb1): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | * | - | *** | - | * | - | | - | *** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x2000, -0x7000, -0x2000, -0x0000, -0x7000, -0x0000, - -/* Character 178 (0xb2): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * * | - | * | - | * | - | *** | - | | - | | - | | - +-----+ -*/ -0x2000, -0x5000, -0x1000, -0x2000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 179 (0xb3): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - | * | - | ** | - | * | - | ** | - | | - | | - | | - +-----+ -*/ -0x6000, -0x1000, -0x6000, -0x1000, -0x6000, -0x0000, -0x0000, -0x0000, - -/* Character 180 (0xb4): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | * | - | | - | | - | | - | | - | | - +-----+ -*/ -0x0000, -0x2000, -0x4000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 181 (0xb5): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |* * | - |* * | - |* * | - |*** | - |* | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x9000, -0x9000, -0x9000, -0xe000, -0x8000, - -/* Character 182 (0xb6): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ****| - |*** *| - |*** *| - | ** *| - | * *| - | * *| - | | - +-----+ -*/ -0x0000, -0x7800, -0xe800, -0xe800, -0x6800, -0x2800, -0x2800, -0x0000, - -/* Character 183 (0xb7): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | * | - | | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 184 (0xb8): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | | - | | - | * | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x2000, -0x4000, - -/* Character 185 (0xb9): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | ** | - | * | - | * | - | *** | - | | - | | - | | - +-----+ -*/ -0x2000, -0x6000, -0x2000, -0x2000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 186 (0xba): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * * | - | * | - | | - | *** | - | | - | | - | | - +-----+ -*/ -0x2000, -0x5000, -0x2000, -0x0000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 187 (0xbb): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |* * | - | * * | - |* * | - | | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xa000, -0x5000, -0xa000, -0x0000, -0x0000, - -/* Character 188 (0xbc): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* | - |* | - |* | - |* * | - | ** | - |**** | - | * | - | | - +-----+ -*/ -0x8000, -0x8000, -0x8000, -0xa000, -0x6000, -0xf000, -0x2000, -0x0000, - -/* Character 189 (0xbd): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* | - |* | - |* * | - |** * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x8000, -0x8000, -0xa000, -0xd000, -0x1000, -0x2000, -0x7000, -0x0000, - -/* Character 190 (0xbe): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* | - | * | - |* | - | ** | - |* * | - |**** | - | * | - | | - +-----+ -*/ -0x8000, -0x4000, -0x8000, -0x6000, -0xa000, -0xf000, -0x2000, -0x0000, - -/* Character 191 (0xbf): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * | - | | - | * | - | * | - | * * | - | * | - | | - +-----+ -*/ -0x0000, -0x2000, -0x0000, -0x2000, -0x4000, -0x5000, -0x2000, -0x0000, - -/* Character 192 (0xc0): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | ** | - |* * | - |**** | - |* * | - |* * | - | | - +-----+ -*/ -0x4000, -0x2000, -0x6000, -0x9000, -0xf000, -0x9000, -0x9000, -0x0000, - -/* Character 193 (0xc1): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | ** | - |* * | - |**** | - |* * | - |* * | - | | - +-----+ -*/ -0x2000, -0x4000, -0x6000, -0x9000, -0xf000, -0x9000, -0x9000, -0x0000, - -/* Character 194 (0xc2): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* * | - | ** | - |* * | - |**** | - |* * | - |* * | - | | - +-----+ -*/ -0x6000, -0x9000, -0x6000, -0x9000, -0xf000, -0x9000, -0x9000, -0x0000, - -/* Character 195 (0xc3): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * * | - |* * | - | ** | - |* * | - |**** | - |* * | - |* * | - | | - +-----+ -*/ -0x5000, -0xa000, -0x6000, -0x9000, -0xf000, -0x9000, -0x9000, -0x0000, - -/* Character 196 (0xc4): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* * | - | | - | ** | - |* * | - |**** | - |* * | - |* * | - | | - +-----+ -*/ -0x9000, -0x0000, -0x6000, -0x9000, -0xf000, -0x9000, -0x9000, -0x0000, - -/* Character 197 (0xc5): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* * | - | ** | - |* * | - |**** | - |* * | - |* * | - | | - +-----+ -*/ -0x6000, -0x9000, -0x6000, -0x9000, -0xf000, -0x9000, -0x9000, -0x0000, - -/* Character 198 (0xc6): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - |* * | - |* * | - |**** | - |* * | - |* ** | - | | - +-----+ -*/ -0x0000, -0x7000, -0xa000, -0xa000, -0xf000, -0xa000, -0xb000, -0x0000, - -/* Character 199 (0xc7): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - |* | - |* | - |* * | - | ** | - | * | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0x8000, -0x8000, -0x9000, -0x6000, -0x4000, - -/* Character 200 (0xc8): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - |**** | - |* | - |*** | - |* | - |**** | - | | - +-----+ -*/ -0x4000, -0x2000, -0xf000, -0x8000, -0xe000, -0x8000, -0xf000, -0x0000, - -/* Character 201 (0xc9): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - |**** | - |* | - |*** | - |* | - |**** | - | | - +-----+ -*/ -0x2000, -0x4000, -0xf000, -0x8000, -0xe000, -0x8000, -0xf000, -0x0000, - -/* Character 202 (0xca): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* * | - |**** | - |* | - |*** | - |* | - |**** | - | | - +-----+ -*/ -0x6000, -0x9000, -0xf000, -0x8000, -0xe000, -0x8000, -0xf000, -0x0000, - -/* Character 203 (0xcb): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* * | - | | - |**** | - |* | - |*** | - |* | - |**** | - | | - +-----+ -*/ -0x9000, -0x0000, -0xf000, -0x8000, -0xe000, -0x8000, -0xf000, -0x0000, - -/* Character 204 (0xcc): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | *** | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x4000, -0x2000, -0x7000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 205 (0xcd): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | *** | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x1000, -0x2000, -0x7000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 206 (0xce): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * * | - | *** | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x2000, -0x5000, -0x7000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 207 (0xcf): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * * | - | | - | *** | - | * | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x5000, -0x0000, -0x7000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 208 (0xd0): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - | * *| - |*** *| - | * *| - | * *| - | *** | - | | - +-----+ -*/ -0x0000, -0x7000, -0x4800, -0xe800, -0x4800, -0x4800, -0x7000, -0x0000, - -/* Character 209 (0xd1): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * * | - |* * | - |* * | - |** * | - |* ** | - |* * | - |* * | - | | - +-----+ -*/ -0x5000, -0xa000, -0x9000, -0xd000, -0xb000, -0x9000, -0x9000, -0x0000, - -/* Character 210 (0xd2): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | ** | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x4000, -0x2000, -0x6000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 211 (0xd3): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | ** | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x2000, -0x4000, -0x6000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 212 (0xd4): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* * | - | ** | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x6000, -0x9000, -0x6000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 213 (0xd5): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * * | - |* * | - | ** | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x5000, -0xa000, -0x6000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 214 (0xd6): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* * | - | | - | ** | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x9000, -0x0000, -0x6000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 215 (0xd7): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | | - | * * | - | * | - | * * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x5000, -0x2000, -0x5000, -0x0000, - -/* Character 216 (0xd8): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | *** | - |* ** | - |* ** | - |** * | - |** * | - |*** | - | | - +-----+ -*/ -0x0000, -0x7000, -0xb000, -0xb000, -0xd000, -0xd000, -0xe000, -0x0000, - -/* Character 217 (0xd9): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - |* * | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x4000, -0x2000, -0x9000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 218 (0xda): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - |* * | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x2000, -0x4000, -0x9000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 219 (0xdb): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* * | - |* * | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x6000, -0x9000, -0x9000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 220 (0xdc): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* * | - | | - |* * | - |* * | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x9000, -0x0000, -0x9000, -0x9000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 221 (0xdd): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - |* *| - | * * | - | * | - | * | - | * | - | | - +-----+ -*/ -0x1000, -0x2000, -0x8800, -0x5000, -0x2000, -0x2000, -0x2000, -0x0000, - -/* Character 222 (0xde): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* | - |*** | - |* * | - |* * | - |*** | - |* | - | | - +-----+ -*/ -0x0000, -0x8000, -0xe000, -0x9000, -0x9000, -0xe000, -0x8000, -0x0000, - -/* Character 223 (0xdf): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | ** | - |* * | - |* * | - |* * | - |* * | - |* * | - | | - +-----+ -*/ -0x0000, -0x6000, -0x9000, -0xa000, -0xa000, -0x9000, -0xa000, -0x0000, - -/* Character 224 (0xe0): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - | *** | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x4000, -0x2000, -0x0000, -0x7000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 225 (0xe1): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - | *** | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x2000, -0x4000, -0x0000, -0x7000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 226 (0xe2): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * * | - | | - | *** | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x2000, -0x5000, -0x0000, -0x7000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 227 (0xe3): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * * | - |* * | - | | - | *** | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x5000, -0xa000, -0x0000, -0x7000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 228 (0xe4): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * * | - | | - | *** | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x0000, -0x5000, -0x0000, -0x7000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 229 (0xe5): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* * | - | ** | - | *** | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x6000, -0x9000, -0x6000, -0x7000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 230 (0xe6): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - |**** | - | ** *| - |* ** | - | ****| - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0xf000, -0x6800, -0xb000, -0x7800, -0x0000, - -/* Character 231 (0xe7): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | ** | - | * | - | * | - | ** | - | * | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x3000, -0x4000, -0x4000, -0x3000, -0x2000, - -/* Character 232 (0xe8): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - | ** | - |* ** | - |** | - | ** | - | | - +-----+ -*/ -0x4000, -0x2000, -0x0000, -0x6000, -0xb000, -0xc000, -0x6000, -0x0000, - -/* Character 233 (0xe9): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - | ** | - |* ** | - |** | - | ** | - | | - +-----+ -*/ -0x2000, -0x4000, -0x0000, -0x6000, -0xb000, -0xc000, -0x6000, -0x0000, - -/* Character 234 (0xea): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* * | - | | - | ** | - |* ** | - |** | - | ** | - | | - +-----+ -*/ -0x6000, -0x9000, -0x0000, -0x6000, -0xb000, -0xc000, -0x6000, -0x0000, - -/* Character 235 (0xeb): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * * | - | | - | ** | - |* ** | - |** | - | ** | - | | - +-----+ -*/ -0x0000, -0x5000, -0x0000, -0x6000, -0xb000, -0xc000, -0x6000, -0x0000, - -/* Character 236 (0xec): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - | ** | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x4000, -0x2000, -0x0000, -0x6000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 237 (0xed): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - | ** | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x1000, -0x2000, -0x0000, -0x6000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 238 (0xee): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * * | - | | - | ** | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x2000, -0x5000, -0x0000, -0x6000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 239 (0xef): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | * * | - | | - | ** | - | * | - | * | - | *** | - | | - +-----+ -*/ -0x0000, -0x5000, -0x0000, -0x6000, -0x2000, -0x2000, -0x7000, -0x0000, - -/* Character 240 (0xf0): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - |* * | - | * | - |* * | - | * | - | *** | - |* * | - | ** | - | | - +-----+ -*/ -0xa000, -0x4000, -0xa000, -0x1000, -0x7000, -0x9000, -0x6000, -0x0000, - -/* Character 241 (0xf1): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * * | - |* * | - | | - |*** | - |* * | - |* * | - |* * | - | | - +-----+ -*/ -0x5000, -0xa000, -0x0000, -0xe000, -0x9000, -0x9000, -0x9000, -0x0000, - -/* Character 242 (0xf2): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - | ** | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x4000, -0x2000, -0x0000, -0x6000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 243 (0xf3): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - | ** | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x2000, -0x4000, -0x0000, -0x6000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 244 (0xf4): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* * | - | | - | ** | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x6000, -0x9000, -0x0000, -0x6000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 245 (0xf5): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * * | - |* * | - | | - | ** | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x5000, -0xa000, -0x0000, -0x6000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 246 (0xf6): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - | | - | ** | - |* * | - |* * | - | ** | - | | - +-----+ -*/ -0x0000, -0x9000, -0x0000, -0x6000, -0x9000, -0x9000, -0x6000, -0x0000, - -/* Character 247 (0xf7): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | * | - | | - | *** | - | | - | * | - | | - +-----+ -*/ -0x0000, -0x0000, -0x2000, -0x0000, -0x7000, -0x0000, -0x2000, -0x0000, - -/* Character 248 (0xf8): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - | | - | | - | *** | - |* ** | - |** * | - |*** | - | | - +-----+ -*/ -0x0000, -0x0000, -0x0000, -0x7000, -0xb000, -0xd000, -0xe000, -0x0000, - -/* Character 249 (0xf9): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - |* * | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x4000, -0x2000, -0x0000, -0x9000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 250 (0xfa): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - |* * | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x2000, -0x4000, -0x0000, -0x9000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 251 (0xfb): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | ** | - |* * | - | | - |* * | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x6000, -0x9000, -0x0000, -0x9000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 252 (0xfc): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - | | - |* * | - |* * | - |* * | - | *** | - | | - +-----+ -*/ -0x0000, -0x9000, -0x0000, -0x9000, -0x9000, -0x9000, -0x7000, -0x0000, - -/* Character 253 (0xfd): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | * | - | * | - | | - |* * | - |* * | - | *** | - |* * | - | ** | - +-----+ -*/ -0x2000, -0x4000, -0x0000, -0x9000, -0x9000, -0x7000, -0x9000, -0x6000, - -/* Character 254 (0xfe): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* | - |* | - |*** | - |* * | - |*** | - |* | - |* | - +-----+ -*/ -0x0000, -0x8000, -0x8000, -0xe000, -0x9000, -0xe000, -0x8000, -0x8000, - -/* Character 255 (0xff): - width 5 - bbx ( 5, 8, 0, -1 ) - - +-----+ - | | - |* * | - | | - |* * | - |* * | - | *** | - |* * | - | ** | - +-----+ -*/ -0x0000, -0x9000, -0x0000, -0x9000, -0x9000, -0x7000, -0x9000, -0x6000, -}; - -/* Character->glyph mapping. */ -static const unsigned long _sysfont_offset[] = { - 0, /* (0x00) */ - 8, /* (0x01) */ - 16, /* (0x02) */ - 24, /* (0x03) */ - 32, /* (0x04) */ - 40, /* (0x05) */ - 48, /* (0x06) */ - 56, /* (0x07) */ - 64, /* (0x08) */ - 72, /* (0x09) */ - 80, /* (0x0a) */ - 88, /* (0x0b) */ - 96, /* (0x0c) */ - 104, /* (0x0d) */ - 112, /* (0x0e) */ - 120, /* (0x0f) */ - 128, /* (0x10) */ - 136, /* (0x11) */ - 144, /* (0x12) */ - 152, /* (0x13) */ - 160, /* (0x14) */ - 168, /* (0x15) */ - 176, /* (0x16) */ - 184, /* (0x17) */ - 192, /* (0x18) */ - 200, /* (0x19) */ - 208, /* (0x1a) */ - 216, /* (0x1b) */ - 224, /* (0x1c) */ - 232, /* (0x1d) */ - 240, /* (0x1e) */ - 248, /* (0x1f) */ - 256, /* (0x20) */ - 264, /* (0x21) */ - 272, /* (0x22) */ - 280, /* (0x23) */ - 288, /* (0x24) */ - 296, /* (0x25) */ - 304, /* (0x26) */ - 312, /* (0x27) */ - 320, /* (0x28) */ - 328, /* (0x29) */ - 336, /* (0x2a) */ - 344, /* (0x2b) */ - 352, /* (0x2c) */ - 360, /* (0x2d) */ - 368, /* (0x2e) */ - 376, /* (0x2f) */ - 384, /* (0x30) */ - 392, /* (0x31) */ - 400, /* (0x32) */ - 408, /* (0x33) */ - 416, /* (0x34) */ - 424, /* (0x35) */ - 432, /* (0x36) */ - 440, /* (0x37) */ - 448, /* (0x38) */ - 456, /* (0x39) */ - 464, /* (0x3a) */ - 472, /* (0x3b) */ - 480, /* (0x3c) */ - 488, /* (0x3d) */ - 496, /* (0x3e) */ - 504, /* (0x3f) */ - 512, /* (0x40) */ - 520, /* (0x41) */ - 528, /* (0x42) */ - 536, /* (0x43) */ - 544, /* (0x44) */ - 552, /* (0x45) */ - 560, /* (0x46) */ - 568, /* (0x47) */ - 576, /* (0x48) */ - 584, /* (0x49) */ - 592, /* (0x4a) */ - 600, /* (0x4b) */ - 608, /* (0x4c) */ - 616, /* (0x4d) */ - 624, /* (0x4e) */ - 632, /* (0x4f) */ - 640, /* (0x50) */ - 648, /* (0x51) */ - 656, /* (0x52) */ - 664, /* (0x53) */ - 672, /* (0x54) */ - 680, /* (0x55) */ - 688, /* (0x56) */ - 696, /* (0x57) */ - 704, /* (0x58) */ - 712, /* (0x59) */ - 720, /* (0x5a) */ - 728, /* (0x5b) */ - 736, /* (0x5c) */ - 744, /* (0x5d) */ - 752, /* (0x5e) */ - 760, /* (0x5f) */ - 768, /* (0x60) */ - 776, /* (0x61) */ - 784, /* (0x62) */ - 792, /* (0x63) */ - 800, /* (0x64) */ - 808, /* (0x65) */ - 816, /* (0x66) */ - 824, /* (0x67) */ - 832, /* (0x68) */ - 840, /* (0x69) */ - 848, /* (0x6a) */ - 856, /* (0x6b) */ - 864, /* (0x6c) */ - 872, /* (0x6d) */ - 880, /* (0x6e) */ - 888, /* (0x6f) */ - 896, /* (0x70) */ - 904, /* (0x71) */ - 912, /* (0x72) */ - 920, /* (0x73) */ - 928, /* (0x74) */ - 936, /* (0x75) */ - 944, /* (0x76) */ - 952, /* (0x77) */ - 960, /* (0x78) */ - 968, /* (0x79) */ - 976, /* (0x7a) */ - 984, /* (0x7b) */ - 992, /* (0x7c) */ - 1000, /* (0x7d) */ - 1008, /* (0x7e) */ - 0, /* (0x7f) */ - 0, /* (0x80) */ - 0, /* (0x81) */ - 0, /* (0x82) */ - 0, /* (0x83) */ - 0, /* (0x84) */ - 0, /* (0x85) */ - 0, /* (0x86) */ - 0, /* (0x87) */ - 0, /* (0x88) */ - 0, /* (0x89) */ - 0, /* (0x8a) */ - 0, /* (0x8b) */ - 0, /* (0x8c) */ - 0, /* (0x8d) */ - 0, /* (0x8e) */ - 0, /* (0x8f) */ - 0, /* (0x90) */ - 0, /* (0x91) */ - 0, /* (0x92) */ - 0, /* (0x93) */ - 0, /* (0x94) */ - 0, /* (0x95) */ - 0, /* (0x96) */ - 0, /* (0x97) */ - 0, /* (0x98) */ - 0, /* (0x99) */ - 0, /* (0x9a) */ - 0, /* (0x9b) */ - 0, /* (0x9c) */ - 0, /* (0x9d) */ - 0, /* (0x9e) */ - 0, /* (0x9f) */ - 1016, /* (0xa0) */ - 1024, /* (0xa1) */ - 1032, /* (0xa2) */ - 1040, /* (0xa3) */ - 1048, /* (0xa4) */ - 1056, /* (0xa5) */ - 1064, /* (0xa6) */ - 1072, /* (0xa7) */ - 1080, /* (0xa8) */ - 1088, /* (0xa9) */ - 1096, /* (0xaa) */ - 1104, /* (0xab) */ - 1112, /* (0xac) */ - 1120, /* (0xad) */ - 1128, /* (0xae) */ - 1136, /* (0xaf) */ - 1144, /* (0xb0) */ - 1152, /* (0xb1) */ - 1160, /* (0xb2) */ - 1168, /* (0xb3) */ - 1176, /* (0xb4) */ - 1184, /* (0xb5) */ - 1192, /* (0xb6) */ - 1200, /* (0xb7) */ - 1208, /* (0xb8) */ - 1216, /* (0xb9) */ - 1224, /* (0xba) */ - 1232, /* (0xbb) */ - 1240, /* (0xbc) */ - 1248, /* (0xbd) */ - 1256, /* (0xbe) */ - 1264, /* (0xbf) */ - 1272, /* (0xc0) */ - 1280, /* (0xc1) */ - 1288, /* (0xc2) */ - 1296, /* (0xc3) */ - 1304, /* (0xc4) */ - 1312, /* (0xc5) */ - 1320, /* (0xc6) */ - 1328, /* (0xc7) */ - 1336, /* (0xc8) */ - 1344, /* (0xc9) */ - 1352, /* (0xca) */ - 1360, /* (0xcb) */ - 1368, /* (0xcc) */ - 1376, /* (0xcd) */ - 1384, /* (0xce) */ - 1392, /* (0xcf) */ - 1400, /* (0xd0) */ - 1408, /* (0xd1) */ - 1416, /* (0xd2) */ - 1424, /* (0xd3) */ - 1432, /* (0xd4) */ - 1440, /* (0xd5) */ - 1448, /* (0xd6) */ - 1456, /* (0xd7) */ - 1464, /* (0xd8) */ - 1472, /* (0xd9) */ - 1480, /* (0xda) */ - 1488, /* (0xdb) */ - 1496, /* (0xdc) */ - 1504, /* (0xdd) */ - 1512, /* (0xde) */ - 1520, /* (0xdf) */ - 1528, /* (0xe0) */ - 1536, /* (0xe1) */ - 1544, /* (0xe2) */ - 1552, /* (0xe3) */ - 1560, /* (0xe4) */ - 1568, /* (0xe5) */ - 1576, /* (0xe6) */ - 1584, /* (0xe7) */ - 1592, /* (0xe8) */ - 1600, /* (0xe9) */ - 1608, /* (0xea) */ - 1616, /* (0xeb) */ - 1624, /* (0xec) */ - 1632, /* (0xed) */ - 1640, /* (0xee) */ - 1648, /* (0xef) */ - 1656, /* (0xf0) */ - 1664, /* (0xf1) */ - 1672, /* (0xf2) */ - 1680, /* (0xf3) */ - 1688, /* (0xf4) */ - 1696, /* (0xf5) */ - 1704, /* (0xf6) */ - 1712, /* (0xf7) */ - 1720, /* (0xf8) */ - 1728, /* (0xf9) */ - 1736, /* (0xfa) */ - 1744, /* (0xfb) */ - 1752, /* (0xfc) */ - 1760, /* (0xfd) */ - 1768, /* (0xfe) */ - 1776, /* (0xff) */ -}; - -/* Exported structure definition. */ -static const BdfFontDesc desc = { - "5x8-L1", - 5, - 8, - 5, 8, 0, -1, - 7, +// Character 0 (0x00) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// | * | +// |* | +// | * | +// |* | +// | * * | +// | | +// +-----+ +static const byte glyph0[] = { + 0x00, + 0xA0, + 0x10, + 0x80, + 0x10, + 0x80, + 0x50, + 0x00 +}; + +// Character 1 (0x01) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | * | +// | *** | +// |*****| +// | *** | +// | * | +// | | +// +-----+ +static const byte glyph1[] = { + 0x00, + 0x00, + 0x20, + 0x70, + 0xF8, + 0x70, + 0x20, + 0x00 +}; + +// Character 2 (0x02) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * * | +// |* * *| +// | * * | +// |* * *| +// | * * | +// |* * *| +// | * * | +// |* * *| +// +-----+ +static const byte glyph2[] = { + 0x50, + 0xA8, + 0x50, + 0xA8, + 0x50, + 0xA8, + 0x50, + 0xA8 +}; + +// Character 3 (0x03) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* * | +// |* * | +// |*** | +// |* * | +// |* * | +// | *** | +// | * | +// | * | +// +-----+ +static const byte glyph3[] = { + 0xA0, + 0xA0, + 0xE0, + 0xA0, + 0xA0, + 0x70, + 0x20, + 0x20 +}; + +// Character 4 (0x04) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |*** | +// |* | +// |** | +// |* ***| +// |* * | +// | ** | +// | * | +// | * | +// +-----+ +static const byte glyph4[] = { + 0xE0, + 0x80, + 0xC0, + 0xB8, + 0xA0, + 0x30, + 0x20, + 0x20 +}; + +// Character 5 (0x05) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* | +// |* | +// | ** | +// | ** | +// | * *| +// | ** | +// | * *| +// +-----+ +static const byte glyph5[] = { + 0x60, + 0x80, + 0x80, + 0x60, + 0x30, + 0x28, + 0x30, + 0x28 +}; + +// Character 6 (0x06) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* | +// |* | +// |* | +// |*** | +// | ***| +// | * | +// | ** | +// | * | +// +-----+ +static const byte glyph6[] = { + 0x80, + 0x80, + 0x80, + 0xE0, + 0x38, + 0x20, + 0x30, + 0x20 +}; + +// Character 7 (0x07) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * * | +// | * | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph7[] = { + 0x00, + 0x20, + 0x50, + 0x20, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 8 (0x08) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | * | +// | *** | +// | * | +// | | +// | *** | +// | | +// +-----+ +static const byte glyph8[] = { + 0x00, + 0x00, + 0x20, + 0x70, + 0x20, + 0x00, + 0x70, + 0x00 +}; + +// Character 9 (0x09) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* * | +// |** * | +// |* ** | +// |* * | +// | * | +// | * | +// | * | +// | ***| +// +-----+ +static const byte glyph9[] = { + 0x90, + 0xD0, + 0xB0, + 0x90, + 0x20, + 0x20, + 0x20, + 0x38 +}; + +// Character 10 (0x0A) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* * | +// |* * | +// |* * | +// | * | +// | ***| +// | * | +// | * | +// | * | +// +-----+ +static const byte glyph10[] = { + 0xA0, + 0xA0, + 0xA0, + 0x40, + 0x38, + 0x10, + 0x10, + 0x10 +}; + +// Character 11 (0x0B) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | * | +// |*** | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph11[] = { + 0x20, + 0x20, + 0x20, + 0xE0, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 12 (0x0C) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |*** | +// | * | +// | * | +// | * | +// | * | +// +-----+ +static const byte glyph12[] = { + 0x00, + 0x00, + 0x00, + 0xE0, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 13 (0x0D) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | ***| +// | * | +// | * | +// | * | +// | * | +// +-----+ +static const byte glyph13[] = { + 0x00, + 0x00, + 0x00, + 0x38, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 14 (0x0E) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | * | +// | ***| +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph14[] = { + 0x20, + 0x20, + 0x20, + 0x38, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 15 (0x0F) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | * | +// |*****| +// | * | +// | * | +// | * | +// | * | +// +-----+ +static const byte glyph15[] = { + 0x20, + 0x20, + 0x20, + 0xF8, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 16 (0x10) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |*****| +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph16[] = { + 0xF8, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 17 (0x11) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |*****| +// | | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph17[] = { + 0x00, + 0xF8, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 18 (0x12) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |*****| +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph18[] = { + 0x00, + 0x00, + 0x00, + 0xF8, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 19 (0x13) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | | +// | | +// |*****| +// | | +// +-----+ +static const byte glyph19[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xF8, + 0x00 +}; + +// Character 20 (0x14) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// |*****| +// +-----+ +static const byte glyph20[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xF8 +}; + +// Character 21 (0x15) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | * | +// | ***| +// | * | +// | * | +// | * | +// | * | +// +-----+ +static const byte glyph21[] = { + 0x20, + 0x20, + 0x20, + 0x38, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 22 (0x16) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | * | +// |*** | +// | * | +// | * | +// | * | +// | * | +// +-----+ +static const byte glyph22[] = { + 0x20, + 0x20, + 0x20, + 0xE0, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 23 (0x17) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | * | +// |*****| +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph23[] = { + 0x20, + 0x20, + 0x20, + 0xF8, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 24 (0x18) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |*****| +// | * | +// | * | +// | * | +// | * | +// +-----+ +static const byte glyph24[] = { + 0x00, + 0x00, + 0x00, + 0xF8, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 25 (0x19) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// +-----+ +static const byte glyph25[] = { + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 26 (0x1A) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph26[] = { + 0x00, + 0x10, + 0x20, + 0x40, + 0x20, + 0x10, + 0x70, + 0x00 +}; + +// Character 27 (0x1B) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph27[] = { + 0x00, + 0x40, + 0x20, + 0x10, + 0x20, + 0x40, + 0x70, + 0x00 +}; + +// Character 28 (0x1C) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |*****| +// | * * | +// | * * | +// | * * | +// | | +// +-----+ +static const byte glyph28[] = { + 0x00, + 0x00, + 0x00, + 0xF8, + 0x50, + 0x50, + 0x50, + 0x00 +}; + +// Character 29 (0x1D) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | * | +// |**** | +// | ** | +// |**** | +// | * | +// | | +// +-----+ +static const byte glyph29[] = { + 0x00, + 0x00, + 0x20, + 0xF0, + 0x60, + 0xF0, + 0x40, + 0x00 +}; + +// Character 30 (0x1E) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * * | +// |*** | +// | * | +// | * * | +// |* * | +// | | +// +-----+ +static const byte glyph30[] = { + 0x00, + 0x20, + 0x50, + 0xE0, + 0x40, + 0x50, + 0xA0, + 0x00 +}; + +// Character 31 (0x1F) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | * | +// | | +// | | +// | | +// +-----+ +static const byte glyph31[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 32 (0x20) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph32[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 33 (0x21) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | * | +// | | +// | * | +// | | +// +-----+ +static const byte glyph33[] = { + 0x00, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00, + 0x20, + 0x00 +}; + +// Character 34 (0x22) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * * | +// | * * | +// | * * | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph34[] = { + 0x00, + 0x50, + 0x50, + 0x50, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 35 (0x23) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * * | +// | * * | +// |*****| +// | * * | +// |*****| +// | * * | +// | * * | +// | | +// +-----+ +static const byte glyph35[] = { + 0x50, + 0x50, + 0xF8, + 0x50, + 0xF8, + 0x50, + 0x50, + 0x00 +}; + +// Character 36 (0x24) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | *** | +// |* * | +// | *** | +// | * *| +// | *** | +// | * | +// | | +// +-----+ +static const byte glyph36[] = { + 0x20, + 0x70, + 0xA0, + 0x70, + 0x28, + 0x70, + 0x20, + 0x00 +}; + +// Character 37 (0x25) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * * | +// | * | +// | * * | +// | * | +// | | +// | | +// +-----+ +static const byte glyph37[] = { + 0x00, + 0x40, + 0x50, + 0x20, + 0x50, + 0x10, + 0x00, + 0x00 +}; + +// Character 38 (0x26) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// |* * | +// |* * | +// | * | +// |* * | +// |* * | +// | * * | +// | | +// +-----+ +static const byte glyph38[] = { + 0x40, + 0xA0, + 0xA0, + 0x40, + 0xA0, + 0xA0, + 0x50, + 0x00 +}; + +// Character 39 (0x27) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph39[] = { + 0x00, + 0x20, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 40 (0x28) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph40[] = { + 0x00, + 0x20, + 0x40, + 0x40, + 0x40, + 0x40, + 0x20, + 0x00 +}; + +// Character 41 (0x29) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph41[] = { + 0x00, + 0x40, + 0x20, + 0x20, + 0x20, + 0x20, + 0x40, + 0x00 +}; + +// Character 42 (0x2A) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// |* * | +// | ** | +// |**** | +// | ** | +// |* * | +// | | +// +-----+ +static const byte glyph42[] = { + 0x00, + 0x00, + 0x90, + 0x60, + 0xF0, + 0x60, + 0x90, + 0x00 +}; + +// Character 43 (0x2B) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | * | +// | * | +// |*****| +// | * | +// | * | +// | | +// +-----+ +static const byte glyph43[] = { + 0x00, + 0x00, + 0x20, + 0x20, + 0xF8, + 0x20, + 0x20, + 0x00 +}; + +// Character 44 (0x2C) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | | +// | ** | +// | * | +// | * | +// +-----+ +static const byte glyph44[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x30, + 0x20, + 0x40 +}; + +// Character 45 (0x2D) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// |**** | +// | | +// | | +// | | +// +-----+ +static const byte glyph45[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0xF0, + 0x00, + 0x00, + 0x00 +}; + +// Character 46 (0x2E) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | | +// | * | +// | *** | +// | * | +// +-----+ +static const byte glyph46[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x20, + 0x70, + 0x20 +}; + +// Character 47 (0x2F) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | * | +// |* | +// |* | +// | | +// +-----+ +static const byte glyph47[] = { + 0x00, + 0x10, + 0x10, + 0x20, + 0x40, + 0x80, + 0x80, + 0x00 +}; + +// Character 48 (0x30) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * * | +// | * * | +// | * * | +// | * * | +// | * | +// | | +// +-----+ +static const byte glyph48[] = { + 0x00, + 0x20, + 0x50, + 0x50, + 0x50, + 0x50, + 0x20, + 0x00 +}; + +// Character 49 (0x31) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | ** | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph49[] = { + 0x00, + 0x20, + 0x60, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 50 (0x32) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// | * | +// | ** | +// |* | +// |**** | +// | | +// +-----+ +static const byte glyph50[] = { + 0x00, + 0x60, + 0x90, + 0x10, + 0x60, + 0x80, + 0xF0, + 0x00 +}; + +// Character 51 (0x33) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |**** | +// | * | +// | ** | +// | * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph51[] = { + 0x00, + 0xF0, + 0x20, + 0x60, + 0x10, + 0x90, + 0x60, + 0x00 +}; + +// Character 52 (0x34) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | ** | +// |* * | +// |**** | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph52[] = { + 0x00, + 0x20, + 0x60, + 0xA0, + 0xF0, + 0x20, + 0x20, + 0x00 +}; + +// Character 53 (0x35) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |**** | +// |* | +// |*** | +// | * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph53[] = { + 0x00, + 0xF0, + 0x80, + 0xE0, + 0x10, + 0x90, + 0x60, + 0x00 +}; + +// Character 54 (0x36) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* | +// |*** | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph54[] = { + 0x00, + 0x60, + 0x80, + 0xE0, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 55 (0x37) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |**** | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph55[] = { + 0x00, + 0xF0, + 0x10, + 0x20, + 0x20, + 0x40, + 0x40, + 0x00 +}; + +// Character 56 (0x38) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// | ** | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph56[] = { + 0x00, + 0x60, + 0x90, + 0x60, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 57 (0x39) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// |* * | +// | *** | +// | * | +// | ** | +// | | +// +-----+ +static const byte glyph57[] = { + 0x00, + 0x60, + 0x90, + 0x90, + 0x70, + 0x10, + 0x60, + 0x00 +}; + +// Character 58 (0x3A) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | ** | +// | ** | +// | | +// | ** | +// | ** | +// | | +// +-----+ +static const byte glyph58[] = { + 0x00, + 0x00, + 0x60, + 0x60, + 0x00, + 0x60, + 0x60, + 0x00 +}; + +// Character 59 (0x3B) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | ** | +// | ** | +// | | +// | ** | +// | * | +// | * | +// +-----+ +static const byte glyph59[] = { + 0x00, + 0x00, + 0x30, + 0x30, + 0x00, + 0x30, + 0x20, + 0x40 +}; + +// Character 60 (0x3C) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph60[] = { + 0x00, + 0x10, + 0x20, + 0x40, + 0x40, + 0x20, + 0x10, + 0x00 +}; + +// Character 61 (0x3D) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |**** | +// | | +// |**** | +// | | +// | | +// +-----+ +static const byte glyph61[] = { + 0x00, + 0x00, + 0x00, + 0xF0, + 0x00, + 0xF0, + 0x00, + 0x00 +}; + +// Character 62 (0x3E) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph62[] = { + 0x00, + 0x40, + 0x20, + 0x10, + 0x10, + 0x20, + 0x40, + 0x00 +}; + +// Character 63 (0x3F) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * * | +// | * | +// | * | +// | | +// | * | +// | | +// +-----+ +static const byte glyph63[] = { + 0x00, + 0x20, + 0x50, + 0x10, + 0x20, + 0x00, + 0x20, + 0x00 +}; + +// Character 64 (0x40) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// | * *| +// |* **| +// |* * *| +// |* * *| +// |* * | +// | * | +// | ** | +// +-----+ +static const byte glyph64[] = { + 0x30, + 0x48, + 0x98, + 0xA8, + 0xA8, + 0x90, + 0x40, + 0x30 +}; + +// Character 65 (0x41) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// |* * | +// |**** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph65[] = { + 0x00, + 0x60, + 0x90, + 0x90, + 0xF0, + 0x90, + 0x90, + 0x00 +}; + +// Character 66 (0x42) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |*** | +// |* * | +// |*** | +// |* * | +// |* * | +// |*** | +// | | +// +-----+ +static const byte glyph66[] = { + 0x00, + 0xE0, + 0x90, + 0xE0, + 0x90, + 0x90, + 0xE0, + 0x00 +}; + +// Character 67 (0x43) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// |* | +// |* | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph67[] = { + 0x00, + 0x60, + 0x90, + 0x80, + 0x80, + 0x90, + 0x60, + 0x00 +}; + +// Character 68 (0x44) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |*** | +// |* * | +// |* * | +// |* * | +// |* * | +// |*** | +// | | +// +-----+ +static const byte glyph68[] = { + 0x00, + 0xE0, + 0x90, + 0x90, + 0x90, + 0x90, + 0xE0, + 0x00 +}; + +// Character 69 (0x45) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |**** | +// |* | +// |*** | +// |* | +// |* | +// |**** | +// | | +// +-----+ +static const byte glyph69[] = { + 0x00, + 0xF0, + 0x80, + 0xE0, + 0x80, + 0x80, + 0xF0, + 0x00 +}; + +// Character 70 (0x46) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |**** | +// |* | +// |*** | +// |* | +// |* | +// |* | +// | | +// +-----+ +static const byte glyph70[] = { + 0x00, + 0xF0, + 0x80, + 0xE0, + 0x80, + 0x80, + 0x80, + 0x00 +}; + +// Character 71 (0x47) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// |* | +// |* ** | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph71[] = { + 0x00, + 0x60, + 0x90, + 0x80, + 0xB0, + 0x90, + 0x60, + 0x00 +}; + +// Character 72 (0x48) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// |* * | +// |**** | +// |* * | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph72[] = { + 0x00, + 0x90, + 0x90, + 0xF0, + 0x90, + 0x90, + 0x90, + 0x00 +}; + +// Character 73 (0x49) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// | * | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph73[] = { + 0x00, + 0x70, + 0x20, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 74 (0x4A) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// | * | +// | * | +// | * | +// |* * | +// | * | +// | | +// +-----+ +static const byte glyph74[] = { + 0x00, + 0x70, + 0x20, + 0x20, + 0x20, + 0xA0, + 0x40, + 0x00 +}; + +// Character 75 (0x4B) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// |* * | +// |** | +// |* * | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph75[] = { + 0x00, + 0x90, + 0xA0, + 0xC0, + 0xA0, + 0xA0, + 0x90, + 0x00 +}; + +// Character 76 (0x4C) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* | +// |* | +// |* | +// |* | +// |* | +// |**** | +// | | +// +-----+ +static const byte glyph76[] = { + 0x00, + 0x80, + 0x80, + 0x80, + 0x80, + 0x80, + 0xF0, + 0x00 +}; + +// Character 77 (0x4D) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// |**** | +// |**** | +// |* * | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph77[] = { + 0x00, + 0x90, + 0xF0, + 0xF0, + 0x90, + 0x90, + 0x90, + 0x00 +}; + +// Character 78 (0x4E) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// |** * | +// |**** | +// |* ** | +// |* ** | +// |* * | +// | | +// +-----+ +static const byte glyph78[] = { + 0x00, + 0x90, + 0xD0, + 0xF0, + 0xB0, + 0xB0, + 0x90, + 0x00 +}; + +// Character 79 (0x4F) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph79[] = { + 0x00, + 0x60, + 0x90, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 80 (0x50) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |*** | +// |* * | +// |* * | +// |*** | +// |* | +// |* | +// | | +// +-----+ +static const byte glyph80[] = { + 0x00, + 0xE0, + 0x90, + 0x90, + 0xE0, + 0x80, + 0x80, + 0x00 +}; + +// Character 81 (0x51) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// |* * | +// |** * | +// |* ** | +// | ** | +// | * | +// +-----+ +static const byte glyph81[] = { + 0x00, + 0x60, + 0x90, + 0x90, + 0xD0, + 0xB0, + 0x60, + 0x10 +}; + +// Character 82 (0x52) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |*** | +// |* * | +// |* * | +// |*** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph82[] = { + 0x00, + 0xE0, + 0x90, + 0x90, + 0xE0, + 0x90, + 0x90, + 0x00 +}; + +// Character 83 (0x53) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// | * | +// | * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph83[] = { + 0x00, + 0x60, + 0x90, + 0x40, + 0x20, + 0x90, + 0x60, + 0x00 +}; + +// Character 84 (0x54) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph84[] = { + 0x00, + 0x70, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00 +}; + +// Character 85 (0x55) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph85[] = { + 0x00, + 0x90, + 0x90, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 86 (0x56) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// | ** | +// | ** | +// | | +// +-----+ +static const byte glyph86[] = { + 0x00, + 0x90, + 0x90, + 0x90, + 0x90, + 0x60, + 0x60, + 0x00 +}; + +// Character 87 (0x57) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// |* * | +// |* * | +// |**** | +// |**** | +// |* * | +// | | +// +-----+ +static const byte glyph87[] = { + 0x00, + 0x90, + 0x90, + 0x90, + 0xF0, + 0xF0, + 0x90, + 0x00 +}; + +// Character 88 (0x58) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// |* * | +// | ** | +// | ** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph88[] = { + 0x00, + 0x90, + 0x90, + 0x60, + 0x60, + 0x90, + 0x90, + 0x00 +}; + +// Character 89 (0x59) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* *| +// |* *| +// | * * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph89[] = { + 0x00, + 0x88, + 0x88, + 0x50, + 0x20, + 0x20, + 0x20, + 0x00 +}; + +// Character 90 (0x5A) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |**** | +// | * | +// | * | +// | * | +// |* | +// |**** | +// | | +// +-----+ +static const byte glyph90[] = { + 0x00, + 0xF0, + 0x10, + 0x20, + 0x40, + 0x80, + 0xF0, + 0x00 +}; + +// Character 91 (0x5B) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// | * | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph91[] = { + 0x00, + 0x70, + 0x40, + 0x40, + 0x40, + 0x40, + 0x70, + 0x00 +}; + +// Character 92 (0x5C) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* | +// |* | +// | * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph92[] = { + 0x00, + 0x80, + 0x80, + 0x40, + 0x20, + 0x10, + 0x10, + 0x00 +}; + +// Character 93 (0x5D) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// | * | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph93[] = { + 0x00, + 0x70, + 0x10, + 0x10, + 0x10, + 0x10, + 0x70, + 0x00 +}; + +// Character 94 (0x5E) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * * | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph94[] = { + 0x00, + 0x20, + 0x50, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 95 (0x5F) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// |**** | +// +-----+ +static const byte glyph95[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xF0 +}; + +// Character 96 (0x60) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph96[] = { + 0x00, + 0x40, + 0x20, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 97 (0x61) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | *** | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph97[] = { + 0x00, + 0x00, + 0x00, + 0x70, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 98 (0x62) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* | +// |* | +// |*** | +// |* * | +// |* * | +// |*** | +// | | +// +-----+ +static const byte glyph98[] = { + 0x00, + 0x80, + 0x80, + 0xE0, + 0x90, + 0x90, + 0xE0, + 0x00 +}; + +// Character 99 (0x63) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | ** | +// | * | +// | * | +// | ** | +// | | +// +-----+ +static const byte glyph99[] = { + 0x00, + 0x00, + 0x00, + 0x30, + 0x40, + 0x40, + 0x30, + 0x00 +}; + +// Character 100 (0x64) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | *** | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph100[] = { + 0x00, + 0x10, + 0x10, + 0x70, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 101 (0x65) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | ** | +// |* ** | +// |** | +// | ** | +// | | +// +-----+ +static const byte glyph101[] = { + 0x00, + 0x00, + 0x00, + 0x60, + 0xB0, + 0xC0, + 0x60, + 0x00 +}; + +// Character 102 (0x66) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * * | +// | * | +// |*** | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph102[] = { + 0x00, + 0x20, + 0x50, + 0x40, + 0xE0, + 0x40, + 0x40, + 0x00 +}; + +// Character 103 (0x67) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | ** | +// |* * | +// | *** | +// | * | +// | ** | +// +-----+ +static const byte glyph103[] = { + 0x00, + 0x00, + 0x00, + 0x60, + 0x90, + 0x70, + 0x10, + 0x60 +}; + +// Character 104 (0x68) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* | +// |* | +// |*** | +// |* * | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph104[] = { + 0x00, + 0x80, + 0x80, + 0xE0, + 0x90, + 0x90, + 0x90, + 0x00 +}; + +// Character 105 (0x69) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | | +// | ** | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph105[] = { + 0x00, + 0x20, + 0x00, + 0x60, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 106 (0x6A) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | | +// | * | +// | * | +// | * | +// | * * | +// | * | +// +-----+ +static const byte glyph106[] = { + 0x00, + 0x10, + 0x00, + 0x10, + 0x10, + 0x10, + 0x50, + 0x20 +}; + +// Character 107 (0x6B) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* | +// |* | +// |* * | +// |*** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph107[] = { + 0x00, + 0x80, + 0x80, + 0x90, + 0xE0, + 0x90, + 0x90, + 0x00 +}; + +// Character 108 (0x6C) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// | * | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph108[] = { + 0x00, + 0x60, + 0x20, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 109 (0x6D) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |** * | +// |* * *| +// |* * *| +// |* * *| +// | | +// +-----+ +static const byte glyph109[] = { + 0x00, + 0x00, + 0x00, + 0xD0, + 0xA8, + 0xA8, + 0xA8, + 0x00 +}; + +// Character 110 (0x6E) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |*** | +// |* * | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph110[] = { + 0x00, + 0x00, + 0x00, + 0xE0, + 0x90, + 0x90, + 0x90, + 0x00 +}; + +// Character 111 (0x6F) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | ** | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph111[] = { + 0x00, + 0x00, + 0x00, + 0x60, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 112 (0x70) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |*** | +// |* * | +// |*** | +// |* | +// |* | +// +-----+ +static const byte glyph112[] = { + 0x00, + 0x00, + 0x00, + 0xE0, + 0x90, + 0xE0, + 0x80, + 0x80 +}; + +// Character 113 (0x71) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | *** | +// |* * | +// | *** | +// | * | +// | * | +// +-----+ +static const byte glyph113[] = { + 0x00, + 0x00, + 0x00, + 0x70, + 0x90, + 0x70, + 0x10, + 0x10 +}; + +// Character 114 (0x72) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |* * | +// |** * | +// |* | +// |* | +// | | +// +-----+ +static const byte glyph114[] = { + 0x00, + 0x00, + 0x00, + 0xA0, + 0xD0, + 0x80, + 0x80, + 0x00 +}; + +// Character 115 (0x73) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | ** | +// | ** | +// | * | +// | ** | +// | | +// +-----+ +static const byte glyph115[] = { + 0x00, + 0x00, + 0x00, + 0x30, + 0x60, + 0x10, + 0x60, + 0x00 +}; + +// Character 116 (0x74) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// |*** | +// | * | +// | * * | +// | * | +// | | +// +-----+ +static const byte glyph116[] = { + 0x00, + 0x40, + 0x40, + 0xE0, + 0x40, + 0x50, + 0x20, + 0x00 +}; + +// Character 117 (0x75) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph117[] = { + 0x00, + 0x00, + 0x00, + 0x90, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 118 (0x76) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | * * | +// | * * | +// | * * | +// | * | +// | | +// +-----+ +static const byte glyph118[] = { + 0x00, + 0x00, + 0x00, + 0x50, + 0x50, + 0x50, + 0x20, + 0x00 +}; + +// Character 119 (0x77) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |* *| +// |* * *| +// |* * *| +// | * * | +// | | +// +-----+ +static const byte glyph119[] = { + 0x00, + 0x00, + 0x00, + 0x88, + 0xA8, + 0xA8, + 0x50, + 0x00 +}; + +// Character 120 (0x78) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |* * | +// | ** | +// | ** | +// |* * | +// | | +// +-----+ +static const byte glyph120[] = { + 0x00, + 0x00, + 0x00, + 0x90, + 0x60, + 0x60, + 0x90, + 0x00 +}; + +// Character 121 (0x79) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |* * | +// |* * | +// | *** | +// |* * | +// | ** | +// +-----+ +static const byte glyph121[] = { + 0x00, + 0x00, + 0x00, + 0x90, + 0x90, + 0x70, + 0x90, + 0x60 +}; + +// Character 122 (0x7A) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |**** | +// | * | +// | * | +// |**** | +// | | +// +-----+ +static const byte glyph122[] = { + 0x00, + 0x00, + 0x00, + 0xF0, + 0x20, + 0x40, + 0xF0, + 0x00 +}; + +// Character 123 (0x7B) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// | * | +// | * | +// |** | +// | * | +// | * | +// | ** | +// | | +// +-----+ +static const byte glyph123[] = { + 0x30, + 0x40, + 0x20, + 0xC0, + 0x20, + 0x40, + 0x30, + 0x00 +}; + +// Character 124 (0x7C) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph124[] = { + 0x00, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00 +}; + +// Character 125 (0x7D) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |** | +// | * | +// | * | +// | ** | +// | * | +// | * | +// |** | +// | | +// +-----+ +static const byte glyph125[] = { + 0xC0, + 0x20, + 0x40, + 0x30, + 0x40, + 0x20, + 0xC0, + 0x00 +}; + +// Character 126 (0x7E) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * * | +// |* * | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph126[] = { + 0x00, + 0x50, + 0xA0, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 160 (0xA0) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph160[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 161 (0xA1) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | | +// | * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph161[] = { + 0x00, + 0x20, + 0x00, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00 +}; + +// Character 162 (0xA2) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | * | +// | *** | +// |* * | +// |* * | +// | *** | +// | * | +// +-----+ +static const byte glyph162[] = { + 0x00, + 0x00, + 0x20, + 0x70, + 0xA0, + 0xA0, + 0x70, + 0x20 +}; + +// Character 163 (0xA3) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * * | +// |*** | +// | * | +// | * * | +// |* * | +// | | +// +-----+ +static const byte glyph163[] = { + 0x00, + 0x20, + 0x50, + 0xE0, + 0x40, + 0x50, + 0xA0, + 0x00 +}; + +// Character 164 (0xA4) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// |* *| +// | *** | +// | * * | +// | *** | +// |* *| +// | | +// +-----+ +static const byte glyph164[] = { + 0x00, + 0x00, + 0x88, + 0x70, + 0x50, + 0x70, + 0x88, + 0x00 +}; + +// Character 165 (0xA5) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* *| +// | * * | +// |*****| +// | * | +// |*****| +// | * | +// | | +// +-----+ +static const byte glyph165[] = { + 0x00, + 0x88, + 0x50, + 0xF8, + 0x20, + 0xF8, + 0x20, + 0x00 +}; + +// Character 166 (0xA6) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | * | +// | | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph166[] = { + 0x20, + 0x20, + 0x20, + 0x00, + 0x20, + 0x20, + 0x20, + 0x00 +}; + +// Character 167 (0xA7) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | *** | +// |* | +// |*** | +// |* * | +// | *** | +// | * | +// |*** | +// | | +// +-----+ +static const byte glyph167[] = { + 0x70, + 0x80, + 0xE0, + 0x90, + 0x70, + 0x10, + 0xE0, + 0x00 +}; + +// Character 168 (0xA8) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * * | +// | | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph168[] = { + 0x00, + 0x50, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 169 (0xA9) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// |* * *| +// |** *| +// |** *| +// |* * *| +// | *** | +// | | +// +-----+ +static const byte glyph169[] = { + 0x00, + 0x70, + 0xA8, + 0xC8, + 0xC8, + 0xA8, + 0x70, + 0x00 +}; + +// Character 170 (0xAA) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// | * * | +// | ** | +// | | +// | *** | +// | | +// | | +// | | +// +-----+ +static const byte glyph170[] = { + 0x30, + 0x50, + 0x30, + 0x00, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 171 (0xAB) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | * * | +// |* * | +// | * * | +// | | +// | | +// +-----+ +static const byte glyph171[] = { + 0x00, + 0x00, + 0x00, + 0x50, + 0xA0, + 0x50, + 0x00, + 0x00 +}; + +// Character 172 (0xAC) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | *** | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph172[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x70, + 0x10, + 0x10, + 0x00 +}; + +// Character 173 (0xAD) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | *** | +// | | +// | | +// | | +// +-----+ +static const byte glyph173[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 174 (0xAE) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// |*** *| +// |** **| +// |*** *| +// |** **| +// | *** | +// | | +// +-----+ +static const byte glyph174[] = { + 0x00, + 0x70, + 0xE8, + 0xD8, + 0xE8, + 0xD8, + 0x70, + 0x00 +}; + +// Character 175 (0xAF) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// | | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph175[] = { + 0x00, + 0x70, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 176 (0xB0) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * * | +// | * | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph176[] = { + 0x00, + 0x20, + 0x50, + 0x20, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 177 (0xB1) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | * | +// | *** | +// | * | +// | | +// | *** | +// | | +// +-----+ +static const byte glyph177[] = { + 0x00, + 0x00, + 0x20, + 0x70, + 0x20, + 0x00, + 0x70, + 0x00 +}; + +// Character 178 (0xB2) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * * | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// +-----+ +static const byte glyph178[] = { + 0x20, + 0x50, + 0x10, + 0x20, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 179 (0xB3) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// | * | +// | ** | +// | * | +// | ** | +// | | +// | | +// | | +// +-----+ +static const byte glyph179[] = { + 0x60, + 0x10, + 0x60, + 0x10, + 0x60, + 0x00, + 0x00, + 0x00 +}; + +// Character 180 (0xB4) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | * | +// | | +// | | +// | | +// | | +// | | +// +-----+ +static const byte glyph180[] = { + 0x00, + 0x20, + 0x40, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 181 (0xB5) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |* * | +// |* * | +// |* * | +// |*** | +// |* | +// +-----+ +static const byte glyph181[] = { + 0x00, + 0x00, + 0x00, + 0x90, + 0x90, + 0x90, + 0xE0, + 0x80 +}; + +// Character 182 (0xB6) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ****| +// |*** *| +// |*** *| +// | ** *| +// | * *| +// | * *| +// | | +// +-----+ +static const byte glyph182[] = { + 0x00, + 0x78, + 0xE8, + 0xE8, + 0x68, + 0x28, + 0x28, + 0x00 +}; + +// Character 183 (0xB7) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | * | +// | | +// | | +// | | +// +-----+ +static const byte glyph183[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 184 (0xB8) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | | +// | | +// | * | +// | * | +// +-----+ +static const byte glyph184[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x20, + 0x40 +}; + +// Character 185 (0xB9) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | ** | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// +-----+ +static const byte glyph185[] = { + 0x20, + 0x60, + 0x20, + 0x20, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 186 (0xBA) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * * | +// | * | +// | | +// | *** | +// | | +// | | +// | | +// +-----+ +static const byte glyph186[] = { + 0x20, + 0x50, + 0x20, + 0x00, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 187 (0xBB) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |* * | +// | * * | +// |* * | +// | | +// | | +// +-----+ +static const byte glyph187[] = { + 0x00, + 0x00, + 0x00, + 0xA0, + 0x50, + 0xA0, + 0x00, + 0x00 +}; + +// Character 188 (0xBC) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* | +// |* | +// |* | +// |* * | +// | ** | +// |**** | +// | * | +// | | +// +-----+ +static const byte glyph188[] = { + 0x80, + 0x80, + 0x80, + 0xA0, + 0x60, + 0xF0, + 0x20, + 0x00 +}; + +// Character 189 (0xBD) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* | +// |* | +// |* * | +// |** * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph189[] = { + 0x80, + 0x80, + 0xA0, + 0xD0, + 0x10, + 0x20, + 0x70, + 0x00 +}; + +// Character 190 (0xBE) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* | +// | * | +// |* | +// | ** | +// |* * | +// |**** | +// | * | +// | | +// +-----+ +static const byte glyph190[] = { + 0x80, + 0x40, + 0x80, + 0x60, + 0xA0, + 0xF0, + 0x20, + 0x00 +}; + +// Character 191 (0xBF) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * | +// | | +// | * | +// | * | +// | * * | +// | * | +// | | +// +-----+ +static const byte glyph191[] = { + 0x00, + 0x20, + 0x00, + 0x20, + 0x40, + 0x50, + 0x20, + 0x00 +}; + +// Character 192 (0xC0) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | ** | +// |* * | +// |**** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph192[] = { + 0x40, + 0x20, + 0x60, + 0x90, + 0xF0, + 0x90, + 0x90, + 0x00 +}; + +// Character 193 (0xC1) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | ** | +// |* * | +// |**** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph193[] = { + 0x20, + 0x40, + 0x60, + 0x90, + 0xF0, + 0x90, + 0x90, + 0x00 +}; + +// Character 194 (0xC2) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* * | +// | ** | +// |* * | +// |**** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph194[] = { + 0x60, + 0x90, + 0x60, + 0x90, + 0xF0, + 0x90, + 0x90, + 0x00 +}; + +// Character 195 (0xC3) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * * | +// |* * | +// | ** | +// |* * | +// |**** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph195[] = { + 0x50, + 0xA0, + 0x60, + 0x90, + 0xF0, + 0x90, + 0x90, + 0x00 +}; + +// Character 196 (0xC4) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* * | +// | | +// | ** | +// |* * | +// |**** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph196[] = { + 0x90, + 0x00, + 0x60, + 0x90, + 0xF0, + 0x90, + 0x90, + 0x00 +}; + +// Character 197 (0xC5) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* * | +// | ** | +// |* * | +// |**** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph197[] = { + 0x60, + 0x90, + 0x60, + 0x90, + 0xF0, + 0x90, + 0x90, + 0x00 +}; + +// Character 198 (0xC6) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// |* * | +// |* * | +// |**** | +// |* * | +// |* ** | +// | | +// +-----+ +static const byte glyph198[] = { + 0x00, + 0x70, + 0xA0, + 0xA0, + 0xF0, + 0xA0, + 0xB0, + 0x00 +}; + +// Character 199 (0xC7) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// |* | +// |* | +// |* * | +// | ** | +// | * | +// +-----+ +static const byte glyph199[] = { + 0x00, + 0x60, + 0x90, + 0x80, + 0x80, + 0x90, + 0x60, + 0x40 +}; + +// Character 200 (0xC8) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// |**** | +// |* | +// |*** | +// |* | +// |**** | +// | | +// +-----+ +static const byte glyph200[] = { + 0x40, + 0x20, + 0xF0, + 0x80, + 0xE0, + 0x80, + 0xF0, + 0x00 +}; + +// Character 201 (0xC9) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// |**** | +// |* | +// |*** | +// |* | +// |**** | +// | | +// +-----+ +static const byte glyph201[] = { + 0x20, + 0x40, + 0xF0, + 0x80, + 0xE0, + 0x80, + 0xF0, + 0x00 +}; + +// Character 202 (0xCA) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* * | +// |**** | +// |* | +// |*** | +// |* | +// |**** | +// | | +// +-----+ +static const byte glyph202[] = { + 0x60, + 0x90, + 0xF0, + 0x80, + 0xE0, + 0x80, + 0xF0, + 0x00 +}; + +// Character 203 (0xCB) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* * | +// | | +// |**** | +// |* | +// |*** | +// |* | +// |**** | +// | | +// +-----+ +static const byte glyph203[] = { + 0x90, + 0x00, + 0xF0, + 0x80, + 0xE0, + 0x80, + 0xF0, + 0x00 +}; + +// Character 204 (0xCC) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | *** | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph204[] = { + 0x40, + 0x20, + 0x70, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 205 (0xCD) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | *** | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph205[] = { + 0x10, + 0x20, + 0x70, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 206 (0xCE) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * * | +// | *** | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph206[] = { + 0x20, + 0x50, + 0x70, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 207 (0xCF) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * * | +// | | +// | *** | +// | * | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph207[] = { + 0x50, + 0x00, + 0x70, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 208 (0xD0) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// | * *| +// |*** *| +// | * *| +// | * *| +// | *** | +// | | +// +-----+ +static const byte glyph208[] = { + 0x00, + 0x70, + 0x48, + 0xE8, + 0x48, + 0x48, + 0x70, + 0x00 +}; + +// Character 209 (0xD1) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * * | +// |* * | +// |* * | +// |** * | +// |* ** | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph209[] = { + 0x50, + 0xA0, + 0x90, + 0xD0, + 0xB0, + 0x90, + 0x90, + 0x00 +}; + +// Character 210 (0xD2) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | ** | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph210[] = { + 0x40, + 0x20, + 0x60, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 211 (0xD3) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | ** | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph211[] = { + 0x20, + 0x40, + 0x60, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 212 (0xD4) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* * | +// | ** | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph212[] = { + 0x60, + 0x90, + 0x60, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 213 (0xD5) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * * | +// |* * | +// | ** | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph213[] = { + 0x50, + 0xA0, + 0x60, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 214 (0xD6) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* * | +// | | +// | ** | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph214[] = { + 0x90, + 0x00, + 0x60, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 215 (0xD7) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | | +// | * * | +// | * | +// | * * | +// | | +// +-----+ +static const byte glyph215[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x50, + 0x20, + 0x50, + 0x00 +}; + +// Character 216 (0xD8) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | *** | +// |* ** | +// |* ** | +// |** * | +// |** * | +// |*** | +// | | +// +-----+ +static const byte glyph216[] = { + 0x00, + 0x70, + 0xB0, + 0xB0, + 0xD0, + 0xD0, + 0xE0, + 0x00 +}; + +// Character 217 (0xD9) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// |* * | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph217[] = { + 0x40, + 0x20, + 0x90, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 218 (0xDA) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// |* * | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph218[] = { + 0x20, + 0x40, + 0x90, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 219 (0xDB) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph219[] = { + 0x60, + 0x90, + 0x90, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 220 (0xDC) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* * | +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph220[] = { + 0x90, + 0x00, + 0x90, + 0x90, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 221 (0xDD) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// |* *| +// | * * | +// | * | +// | * | +// | * | +// | | +// +-----+ +static const byte glyph221[] = { + 0x10, + 0x20, + 0x88, + 0x50, + 0x20, + 0x20, + 0x20, + 0x00 +}; + +// Character 222 (0xDE) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* | +// |*** | +// |* * | +// |* * | +// |*** | +// |* | +// | | +// +-----+ +static const byte glyph222[] = { + 0x00, + 0x80, + 0xE0, + 0x90, + 0x90, + 0xE0, + 0x80, + 0x00 +}; + +// Character 223 (0xDF) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | ** | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph223[] = { + 0x00, + 0x60, + 0x90, + 0xA0, + 0xA0, + 0x90, + 0xA0, + 0x00 +}; + +// Character 224 (0xE0) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// | *** | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph224[] = { + 0x40, + 0x20, + 0x00, + 0x70, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 225 (0xE1) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// | *** | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph225[] = { + 0x20, + 0x40, + 0x00, + 0x70, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 226 (0xE2) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph226[] = { + 0x20, + 0x50, + 0x00, + 0x70, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 227 (0xE3) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * * | +// |* * | +// | | +// | *** | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph227[] = { + 0x50, + 0xA0, + 0x00, + 0x70, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 228 (0xE4) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph228[] = { + 0x00, + 0x50, + 0x00, + 0x70, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 229 (0xE5) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* * | +// | ** | +// | *** | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph229[] = { + 0x60, + 0x90, + 0x60, + 0x70, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 230 (0xE6) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// |**** | +// | ** *| +// |* ** | +// | ****| +// | | +// +-----+ +static const byte glyph230[] = { + 0x00, + 0x00, + 0x00, + 0xF0, + 0x68, + 0xB0, + 0x78, + 0x00 +}; + +// Character 231 (0xE7) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | ** | +// | * | +// | * | +// | ** | +// | * | +// +-----+ +static const byte glyph231[] = { + 0x00, + 0x00, + 0x00, + 0x30, + 0x40, + 0x40, + 0x30, + 0x20 +}; + +// Character 232 (0xE8) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// | ** | +// |* ** | +// |** | +// | ** | +// | | +// +-----+ +static const byte glyph232[] = { + 0x40, + 0x20, + 0x00, + 0x60, + 0xB0, + 0xC0, + 0x60, + 0x00 +}; + +// Character 233 (0xE9) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// | ** | +// |* ** | +// |** | +// | ** | +// | | +// +-----+ +static const byte glyph233[] = { + 0x20, + 0x40, + 0x00, + 0x60, + 0xB0, + 0xC0, + 0x60, + 0x00 +}; + +// Character 234 (0xEA) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* * | +// | | +// | ** | +// |* ** | +// |** | +// | ** | +// | | +// +-----+ +static const byte glyph234[] = { + 0x60, + 0x90, + 0x00, + 0x60, + 0xB0, + 0xC0, + 0x60, + 0x00 +}; + +// Character 235 (0xEB) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * * | +// | | +// | ** | +// |* ** | +// |** | +// | ** | +// | | +// +-----+ +static const byte glyph235[] = { + 0x00, + 0x50, + 0x00, + 0x60, + 0xB0, + 0xC0, + 0x60, + 0x00 +}; + +// Character 236 (0xEC) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// | ** | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph236[] = { + 0x40, + 0x20, + 0x00, + 0x60, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 237 (0xED) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// | ** | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph237[] = { + 0x10, + 0x20, + 0x00, + 0x60, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 238 (0xEE) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * * | +// | | +// | ** | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph238[] = { + 0x20, + 0x50, + 0x00, + 0x60, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 239 (0xEF) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | * * | +// | | +// | ** | +// | * | +// | * | +// | *** | +// | | +// +-----+ +static const byte glyph239[] = { + 0x00, + 0x50, + 0x00, + 0x60, + 0x20, + 0x20, + 0x70, + 0x00 +}; + +// Character 240 (0xF0) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// |* * | +// | * | +// |* * | +// | * | +// | *** | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph240[] = { + 0xA0, + 0x40, + 0xA0, + 0x10, + 0x70, + 0x90, + 0x60, + 0x00 +}; + +// Character 241 (0xF1) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * * | +// |* * | +// | | +// |*** | +// |* * | +// |* * | +// |* * | +// | | +// +-----+ +static const byte glyph241[] = { + 0x50, + 0xA0, + 0x00, + 0xE0, + 0x90, + 0x90, + 0x90, + 0x00 +}; + +// Character 242 (0xF2) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// | ** | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph242[] = { + 0x40, + 0x20, + 0x00, + 0x60, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 243 (0xF3) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// | ** | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph243[] = { + 0x20, + 0x40, + 0x00, + 0x60, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 244 (0xF4) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* * | +// | | +// | ** | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph244[] = { + 0x60, + 0x90, + 0x00, + 0x60, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 245 (0xF5) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * * | +// |* * | +// | | +// | ** | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph245[] = { + 0x50, + 0xA0, + 0x00, + 0x60, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 246 (0xF6) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// | | +// | ** | +// |* * | +// |* * | +// | ** | +// | | +// +-----+ +static const byte glyph246[] = { + 0x00, + 0x90, + 0x00, + 0x60, + 0x90, + 0x90, + 0x60, + 0x00 +}; + +// Character 247 (0xF7) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | * | +// | | +// | *** | +// | | +// | * | +// | | +// +-----+ +static const byte glyph247[] = { + 0x00, + 0x00, + 0x20, + 0x00, + 0x70, + 0x00, + 0x20, + 0x00 +}; + +// Character 248 (0xF8) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// | | +// | | +// | *** | +// |* ** | +// |** * | +// |*** | +// | | +// +-----+ +static const byte glyph248[] = { + 0x00, + 0x00, + 0x00, + 0x70, + 0xB0, + 0xD0, + 0xE0, + 0x00 +}; + +// Character 249 (0xF9) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph249[] = { + 0x40, + 0x20, + 0x00, + 0x90, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 250 (0xFA) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph250[] = { + 0x20, + 0x40, + 0x00, + 0x90, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 251 (0xFB) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | ** | +// |* * | +// | | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph251[] = { + 0x60, + 0x90, + 0x00, + 0x90, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 252 (0xFC) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// | | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// +-----+ +static const byte glyph252[] = { + 0x00, + 0x90, + 0x00, + 0x90, + 0x90, + 0x90, + 0x70, + 0x00 +}; + +// Character 253 (0xFD) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | * | +// | * | +// | | +// |* * | +// |* * | +// | *** | +// |* * | +// | ** | +// +-----+ +static const byte glyph253[] = { + 0x20, + 0x40, + 0x00, + 0x90, + 0x90, + 0x70, + 0x90, + 0x60 +}; + +// Character 254 (0xFE) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* | +// |* | +// |*** | +// |* * | +// |*** | +// |* | +// |* | +// +-----+ +static const byte glyph254[] = { + 0x00, + 0x80, + 0x80, + 0xE0, + 0x90, + 0xE0, + 0x80, + 0x80 +}; + +// Character 255 (0xFF) +// Box: 5 8 0 -1 +// Advance: 5 +// +// +-----+ +// | | +// |* * | +// | | +// |* * | +// |* * | +// | *** | +// |* * | +// | ** | +// +-----+ +static const byte glyph255[] = { + 0x00, + 0x90, + 0x00, + 0x90, + 0x90, + 0x70, + 0x90, + 0x60 +}; + +// Bitmap pointer table +const byte *const bitmapTable[] = { + glyph0, + glyph1, + glyph2, + glyph3, + glyph4, + glyph5, + glyph6, + glyph7, + glyph8, + glyph9, + glyph10, + glyph11, + glyph12, + glyph13, + glyph14, + glyph15, + glyph16, + glyph17, + glyph18, + glyph19, + glyph20, + glyph21, + glyph22, + glyph23, + glyph24, + glyph25, + glyph26, + glyph27, + glyph28, + glyph29, + glyph30, + glyph31, + glyph32, + glyph33, + glyph34, + glyph35, + glyph36, + glyph37, + glyph38, + glyph39, + glyph40, + glyph41, + glyph42, + glyph43, + glyph44, + glyph45, + glyph46, + glyph47, + glyph48, + glyph49, + glyph50, + glyph51, + glyph52, + glyph53, + glyph54, + glyph55, + glyph56, + glyph57, + glyph58, + glyph59, + glyph60, + glyph61, + glyph62, + glyph63, + glyph64, + glyph65, + glyph66, + glyph67, + glyph68, + glyph69, + glyph70, + glyph71, + glyph72, + glyph73, + glyph74, + glyph75, + glyph76, + glyph77, + glyph78, + glyph79, + glyph80, + glyph81, + glyph82, + glyph83, + glyph84, + glyph85, + glyph86, + glyph87, + glyph88, + glyph89, + glyph90, + glyph91, + glyph92, + glyph93, + glyph94, + glyph95, + glyph96, + glyph97, + glyph98, + glyph99, + glyph100, + glyph101, + glyph102, + glyph103, + glyph104, + glyph105, + glyph106, + glyph107, + glyph108, + glyph109, + glyph110, + glyph111, + glyph112, + glyph113, + glyph114, + glyph115, + glyph116, + glyph117, + glyph118, + glyph119, + glyph120, + glyph121, + glyph122, + glyph123, + glyph124, + glyph125, + glyph126, + 0, + 0, + 0, + 0, + 0, 0, - 256, - _font_bits, - _sysfont_offset, - 0, /* fixed width*/ - 0, /* fixed bbox*/ 0, - sizeof(_font_bits)/sizeof(bitmap_t) + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + glyph160, + glyph161, + glyph162, + glyph163, + glyph164, + glyph165, + glyph166, + glyph167, + glyph168, + glyph169, + glyph170, + glyph171, + glyph172, + glyph173, + glyph174, + glyph175, + glyph176, + glyph177, + glyph178, + glyph179, + glyph180, + glyph181, + glyph182, + glyph183, + glyph184, + glyph185, + glyph186, + glyph187, + glyph188, + glyph189, + glyph190, + glyph191, + glyph192, + glyph193, + glyph194, + glyph195, + glyph196, + glyph197, + glyph198, + glyph199, + glyph200, + glyph201, + glyph202, + glyph203, + glyph204, + glyph205, + glyph206, + glyph207, + glyph208, + glyph209, + glyph210, + glyph211, + glyph212, + glyph213, + glyph214, + glyph215, + glyph216, + glyph217, + glyph218, + glyph219, + glyph220, + glyph221, + glyph222, + glyph223, + glyph224, + glyph225, + glyph226, + glyph227, + glyph228, + glyph229, + glyph230, + glyph231, + glyph232, + glyph233, + glyph234, + glyph235, + glyph236, + glyph237, + glyph238, + glyph239, + glyph240, + glyph241, + glyph242, + glyph243, + glyph244, + glyph245, + glyph246, + glyph247, + glyph248, + glyph249, + glyph250, + glyph251, + glyph252, + glyph253, + glyph254, + glyph255 +}; + +// Font structure +static const BdfFontData desc = { + 5, // Max advance + 8, // Height + { 5, 8, 0, -1 }, // Bounding box + 7, // Ascent + + 0, // First character + 0, // Default character + 256, // Characters + + bitmapTable, // Bitmaps + 0, // Advances + 0 // Boxes }; DEFINE_FONT(g_consolefont) diff --git a/graphics/fonts/newfont.cpp b/graphics/fonts/newfont.cpp index f02baba2de..10af1efb0c 100644 --- a/graphics/fonts/newfont.cpp +++ b/graphics/fonts/newfont.cpp @@ -1,7438 +1,7651 @@ -/* Generated by convbdf on Sat Jun 17 01:34:15 2006. */ +// Generated by convbdf on Fri Jan 6 14:33:07 2012 #include "graphics/fonts/bdf.h" -/* Font information: - name: clR6x12-L1 - facename: -Schumacher-Clean-Medium-R-Normal--12-120-75-75-C-60-ISO8859-1 - w x h: 6x12 - bbx: 6 12 0 -3 - size: 256 - ascent: 9 - descent: 3 - first char: 0 (0x00) - last char: 255 (0xff) - default char: 0 (0x00) - proportional: no - Copyright 1989 Dale Schumacher, 1999 Robert Brady. -*/ +// Font information: +// Name: -Schumacher-Clean-Medium-R-Normal--12-120-75-75-C-60-ISO8859-1 +// Size: 6x12 +// Box: 6 12 0 -3 +// Ascent: 9 +// First character: 0 +// Default character: 0 +// Characters: 256 +// Copyright: "Copyright 1989 Dale Schumacher, 1999 Robert Brady." namespace Graphics { -/* Font character bitmap data. */ -static const bitmap_t _font_bits[] = { - -/* Character 0 (0x00): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * * | - | | - |* * | - | | - |* * | - | | - |* * * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xa800, -0x0000, -0x8800, -0x0000, -0x8800, -0x0000, -0xa800, -0x0000, -0x0000, -0x0000, - -/* Character 1 (0x01): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | * | - | *** | - |***** | - | *** | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x2000, -0x7000, -0xf800, -0x7000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 2 (0x02): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - |* * * | - | * * *| - |* * * | - | * * *| - |* * * | - | * * *| - |* * * | - | * * *| - |* * * | - | * * *| - |* * * | - | * * *| - +------+ -*/ -0xa800, -0x5400, -0xa800, -0x5400, -0xa800, -0x5400, -0xa800, -0x5400, -0xa800, -0x5400, -0xa800, -0x5400, - -/* Character 3 (0x03): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |* * | - |* * | - |*** | - |* * | - |* ****| - | * | - | * | - | * | - | * | - | | - | | - +------+ -*/ -0x0000, -0xa000, -0xa000, -0xe000, -0xa000, -0xbc00, -0x0800, -0x0800, -0x0800, -0x0800, -0x0000, -0x0000, - -/* Character 4 (0x04): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |*** | - |* | - |** | - |* ***| - |* * | - | ***| - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0xe000, -0x8000, -0xc000, -0x9c00, -0x9000, -0x1c00, -0x1000, -0x1000, -0x0000, -0x0000, -0x0000, - -/* Character 5 (0x05): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | ** | - |* | - |* | - |* ** | - | *** *| - | ** | - | * *| - | * *| - | | - | | - | | - +------+ -*/ -0x0000, -0x6000, -0x8000, -0x8000, -0x9800, -0x7400, -0x1800, -0x1400, -0x1400, -0x0000, -0x0000, -0x0000, - -/* Character 6 (0x06): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |* | - |* | - |* | - |* ***| - |**** | - | ** | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x8000, -0x8000, -0x8000, -0x9c00, -0xf000, -0x1800, -0x1000, -0x1000, -0x0000, -0x0000, -0x0000, - -/* Character 7 (0x07): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | ** | - | * * | - | * * | - | ** | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x3000, -0x4800, -0x4800, -0x3000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 8 (0x08): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * | - | * | - |***** | - | * | - | * | - | | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x2000, -0x2000, -0xf800, -0x2000, -0x2000, -0x0000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 9 (0x09): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - |* * | - |*** | - |*** | - |*** | - |* ** | - | * | - | * | - | * | - | ***| - | | - | | - | | - +------+ -*/ -0xa000, -0xe000, -0xe000, -0xe000, -0xb000, -0x1000, -0x1000, -0x1000, -0x1c00, -0x0000, -0x0000, -0x0000, - -/* Character 10 (0x0a): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |* * | - |* * | - |* * | - | * ***| - | * * | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0xa000, -0xa000, -0xa000, -0x5c00, -0x4800, -0x0800, -0x0800, -0x0800, -0x0000, -0x0000, -0x0000, - -/* Character 11 (0x0b): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - |*** | - | | - | | - | | - | | - | | - +------+ -*/ -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0xe000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 12 (0x0c): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - |*** | - | * | - | * | - | * | - | * | - | * | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xe000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 13 (0x0d): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | ****| - | * | - | * | - | * | - | * | - | * | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x3f00, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 14 (0x0e): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - | ****| - | | - | | - | | - | | - | | - +------+ -*/ -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x3f00, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 15 (0x0f): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - |******| - | * | - | * | - | * | - | * | - | * | - +------+ -*/ -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0xff00, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 16 (0x10): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - |******| - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0xfc00, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 17 (0x11): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - |******| - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0xfc00, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 18 (0x12): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - |******| - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xfc00, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 19 (0x13): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | | - | | - |******| - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xfc00, -0x0000, -0x0000, -0x0000, - -/* Character 20 (0x14): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - |******| - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xfc00, - -/* Character 21 (0x15): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - | ****| - | * | - | * | - | * | - | * | - | * | - +------+ -*/ -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x3f00, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 22 (0x16): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - |*** | - | * | - | * | - | * | - | * | - | * | - +------+ -*/ -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0xe000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 23 (0x17): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - |******| - | | - | | - | | - | | - | | - +------+ -*/ -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0xff00, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 24 (0x18): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - |******| - | * | - | * | - | * | - | * | - | * | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xff00, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 25 (0x19): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - +------+ -*/ -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, - -/* Character 26 (0x1a): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | ** | - | ** | - |* | - | ** | - | ** | - | | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x1800, -0x6000, -0x8000, -0x6000, -0x1800, -0x0000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 27 (0x1b): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |** | - | ** | - | * | - | ** | - |** | - | | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xc000, -0x3000, -0x0800, -0x3000, -0xc000, -0x0000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 28 (0x1c): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |***** | - |* * | - |* * | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0xf800, -0x8800, -0x8800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 29 (0x1d): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * | - | * | - |***** | - | * | - |***** | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x1000, -0x1000, -0xf800, -0x2000, -0xf800, -0x4000, -0x4000, -0x0000, -0x0000, -0x0000, - -/* Character 30 (0x1e): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | ** | - | * * | - | * | - |*** | - | * | - | * | - | * * | - |* ** | - | | - | | - | | - +------+ -*/ -0x0000, -0x3000, -0x4800, -0x4000, -0xe000, -0x4000, -0x4000, -0x4800, -0xb000, -0x0000, -0x0000, -0x0000, - -/* Character 31 (0x1f): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | ** | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x3000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 32 (0x20): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 33 (0x21): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | * | - | * | - | * | - | * | - | | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 34 (0x22): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | * * | - | * * | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x5000, -0x5000, -0x5000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 35 (0x23): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * * | - | * * | - |***** | - | * * | - |***** | - | * * | - | * * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x5000, -0x5000, -0xf800, -0x5000, -0xf800, -0x5000, -0x5000, -0x0000, -0x0000, -0x0000, - -/* Character 36 (0x24): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * | - | **** | - |* * | - | *** | - | * * | - |**** | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x2000, -0x7800, -0xa000, -0x7000, -0x2800, -0xf000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 37 (0x25): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |** | - |** * | - | * | - | * | - | * | - |* ** | - | ** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xc000, -0xc800, -0x1000, -0x2000, -0x4000, -0x9800, -0x1800, -0x0000, -0x0000, -0x0000, - -/* Character 38 (0x26): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - |* | - |* | - | * | - |* * * | - |* * | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7000, -0x8000, -0x8000, -0x4000, -0xa800, -0x9000, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 39 (0x27): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | * | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 40 (0x28): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +------+ -*/ -0x0800, -0x1000, -0x1000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x1000, -0x1000, -0x0800, -0x0000, - -/* Character 41 (0x29): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +------+ -*/ -0x4000, -0x2000, -0x2000, -0x1000, -0x1000, -0x1000, -0x1000, -0x1000, -0x2000, -0x2000, -0x4000, -0x0000, - -/* Character 42 (0x2a): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | * | - |* * * | - | *** | - |* * * | - | * | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x2000, -0xa800, -0x7000, -0xa800, -0x2000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 43 (0x2b): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | * | - | * | - |***** | - | * | - | * | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x2000, -0x2000, -0xf800, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 44 (0x2c): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | | - | ** | - | ** | - | * | - | * | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x3000, -0x3000, -0x2000, -0x4000, -0x0000, - -/* Character 45 (0x2d): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - |***** | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xf800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 46 (0x2e): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | | - | ** | - | ** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x3000, -0x3000, -0x0000, -0x0000, -0x0000, - -/* Character 47 (0x2f): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - |* | - |* | - | | - | | - +------+ -*/ -0x0800, -0x0800, -0x1000, -0x1000, -0x2000, -0x2000, -0x4000, -0x4000, -0x8000, -0x8000, -0x0000, -0x0000, - -/* Character 48 (0x30): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | *** | - |* * | - |* ** | - |* * * | - |** * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x7000, -0x8800, -0x9800, -0xa800, -0xc800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 49 (0x31): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | ** | - | * | - | * | - | * | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x1000, -0x3000, -0x1000, -0x1000, -0x1000, -0x1000, -0x1000, -0x1000, -0x0000, -0x0000, -0x0000, - -/* Character 50 (0x32): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | *** | - |* * | - | * | - | * | - | * | - | * | - |* | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x7000, -0x8800, -0x0800, -0x1000, -0x2000, -0x4000, -0x8000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 51 (0x33): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | *** | - |* * | - | * | - | ** | - | * | - | * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x7000, -0x8800, -0x0800, -0x3000, -0x0800, -0x0800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 52 (0x34): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | ** | - | ** | - | * * | - | * * | - |***** | - | * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x1000, -0x3000, -0x3000, -0x5000, -0x5000, -0xf800, -0x1000, -0x3800, -0x0000, -0x0000, -0x0000, - -/* Character 53 (0x35): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |***** | - |* | - |* | - |**** | - | * | - | * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0xf800, -0x8000, -0x8000, -0xf000, -0x0800, -0x0800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 54 (0x36): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | ** | - | * | - |* | - |**** | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x3000, -0x4000, -0x8000, -0xf000, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 55 (0x37): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |***** | - |* * | - | * | - | * | - | * | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0xf800, -0x8800, -0x0800, -0x0800, -0x1000, -0x1000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 56 (0x38): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | *** | - |* * | - |* * | - | *** | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x7000, -0x8800, -0x8800, -0x7000, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 57 (0x39): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | *** | - |* * | - |* * | - |* * | - | **** | - | * | - | * | - | ** | - | | - | | - | | - +------+ -*/ -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x7800, -0x0800, -0x1000, -0x6000, -0x0000, -0x0000, -0x0000, - -/* Character 58 (0x3a): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | ** | - | ** | - | | - | | - | ** | - | ** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x3000, -0x3000, -0x0000, -0x0000, -0x3000, -0x3000, -0x0000, -0x0000, -0x0000, - -/* Character 59 (0x3b): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | ** | - | ** | - | | - | | - | ** | - | ** | - | * | - | * | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x3000, -0x3000, -0x0000, -0x0000, -0x3000, -0x3000, -0x2000, -0x4000, -0x0000, - -/* Character 60 (0x3c): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | **| - | ** | - |** | - | ** | - | **| - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0c00, -0x3000, -0xc000, -0x3000, -0x0c00, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 61 (0x3d): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |***** | - | | - |***** | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0xf800, -0x0000, -0xf800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 62 (0x3e): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - |** | - | ** | - | **| - | ** | - |** | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0xc000, -0x3000, -0x0c00, -0x3000, -0xc000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 63 (0x3f): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | *** | - |* * | - | * | - | * | - | * | - | * | - | | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x7000, -0x8800, -0x0800, -0x1000, -0x2000, -0x2000, -0x0000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 64 (0x40): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - |* * | - |* *** | - |* *** | - |* ** | - |* | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7000, -0x8800, -0xb800, -0xb800, -0xb000, -0x8000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 65 (0x41): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * | - | * * | - |* * | - |* * | - |***** | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x2000, -0x5000, -0x8800, -0x8800, -0xf800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 66 (0x42): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |**** | - |* * | - |* * | - |**** | - |* * | - |* * | - |**** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xf000, -0x8800, -0x8800, -0xf000, -0x8800, -0x8800, -0xf000, -0x0000, -0x0000, -0x0000, - -/* Character 67 (0x43): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - |* * | - |* | - |* | - |* | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7000, -0x8800, -0x8000, -0x8000, -0x8000, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 68 (0x44): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |*** | - |* * | - |* * | - |* * | - |* * | - |* * | - |*** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xe000, -0x9000, -0x8800, -0x8800, -0x8800, -0x9000, -0xe000, -0x0000, -0x0000, -0x0000, - -/* Character 69 (0x45): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |***** | - |* | - |* | - |**** | - |* | - |* | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xf800, -0x8000, -0x8000, -0xf000, -0x8000, -0x8000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 70 (0x46): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |***** | - |* | - |* | - |**** | - |* | - |* | - |* | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xf800, -0x8000, -0x8000, -0xf000, -0x8000, -0x8000, -0x8000, -0x0000, -0x0000, -0x0000, - -/* Character 71 (0x47): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - |* * | - |* | - |* ** | - |* * | - |* * | - | **** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7000, -0x8800, -0x8000, -0x9800, -0x8800, -0x8800, -0x7800, -0x0000, -0x0000, -0x0000, - -/* Character 72 (0x48): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - |* * | - |* * | - |***** | - |* * | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0x8800, -0x8800, -0xf800, -0x8800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 73 (0x49): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |***** | - | * | - | * | - | * | - | * | - | * | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xf800, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 74 (0x4a): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - | * | - | * | - | * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x3800, -0x0800, -0x0800, -0x0800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 75 (0x4b): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - |* * | - |* * | - |** | - |* * | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0x9000, -0xa000, -0xc000, -0xa000, -0x9000, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 76 (0x4c): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* | - |* | - |* | - |* | - |* | - |* | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8000, -0x8000, -0x8000, -0x8000, -0x8000, -0x8000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 77 (0x4d): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - |** ** | - |* * * | - |* * * | - |* * | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0xd800, -0xa800, -0xa800, -0x8800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 78 (0x4e): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - |** * | - |** * | - |* * * | - |* ** | - |* ** | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0xc800, -0xc800, -0xa800, -0x9800, -0x9800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 79 (0x4f): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - |* * | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 80 (0x50): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |**** | - |* * | - |* * | - |**** | - |* | - |* | - |* | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xf000, -0x8800, -0x8800, -0xf000, -0x8000, -0x8000, -0x8000, -0x0000, -0x0000, -0x0000, - -/* Character 81 (0x51): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - |* * | - |* * | - |* * | - |* * | - |* * | - | *** | - | ** | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x1800, -0x0000, -0x0000, - -/* Character 82 (0x52): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |**** | - |* * | - |* * | - |**** | - |* * | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xf000, -0x8800, -0x8800, -0xf000, -0xa000, -0x9000, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 83 (0x53): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - |* * | - |* | - | *** | - | * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7000, -0x8800, -0x8000, -0x7000, -0x0800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 84 (0x54): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |***** | - | * | - | * | - | * | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xf800, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 85 (0x55): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - |* * | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0x8800, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 86 (0x56): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - |* * | - |* * | - | * * | - | * * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0x8800, -0x8800, -0x5000, -0x5000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 87 (0x57): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - |* * | - |* * | - |* * * | - |* * * | - |** ** | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0x8800, -0x8800, -0xa800, -0xa800, -0xd800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 88 (0x58): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - |* * | - | * * | - | * | - | * * | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0x8800, -0x5000, -0x2000, -0x5000, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 89 (0x59): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - |* * | - | * * | - | * | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0x8800, -0x5000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 90 (0x5a): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |***** | - | * | - | * | - | * | - | * | - |* | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xf800, -0x0800, -0x1000, -0x2000, -0x4000, -0x8000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 91 (0x5b): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | *** | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | *** | - | | - +------+ -*/ -0x3800, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x3800, -0x0000, - -/* Character 92 (0x5c): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - |* | - |* | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | | - | | - +------+ -*/ -0x8000, -0x8000, -0x4000, -0x4000, -0x2000, -0x2000, -0x1000, -0x1000, -0x0800, -0x0800, -0x0000, -0x0000, - -/* Character 93 (0x5d): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | *** | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | *** | - | | - +------+ -*/ -0x7000, -0x1000, -0x1000, -0x1000, -0x1000, -0x1000, -0x1000, -0x1000, -0x1000, -0x1000, -0x7000, -0x0000, - -/* Character 94 (0x5e): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * * | - |* * | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x5000, -0x8800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 95 (0x5f): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | | - | | - | | - |******| - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0xfc00, -0x0000, -0x0000, - -/* Character 96 (0x60): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x1000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 97 (0x61): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | **** | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 98 (0x62): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |* | - |* | - |* | - |**** | - |* * | - |* * | - |* * | - |**** | - | | - | | - | | - +------+ -*/ -0x0000, -0x8000, -0x8000, -0x8000, -0xf000, -0x8800, -0x8800, -0x8800, -0xf000, -0x0000, -0x0000, -0x0000, - -/* Character 99 (0x63): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | **** | - |* | - |* | - |* | - | **** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7800, -0x8000, -0x8000, -0x8000, -0x7800, -0x0000, -0x0000, -0x0000, - -/* Character 100 (0x64): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | * | - | **** | - |* * | - |* * | - |* * | - | **** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0800, -0x0800, -0x0800, -0x7800, -0x8800, -0x8800, -0x8800, -0x7800, -0x0000, -0x0000, -0x0000, - -/* Character 101 (0x65): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | *** | - |* * | - |***** | - |* | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7000, -0x8800, -0xf800, -0x8000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 102 (0x66): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | *** | - | * | - | * | - |**** | - | * | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x3800, -0x4000, -0x4000, -0xf000, -0x4000, -0x4000, -0x4000, -0x4000, -0x0000, -0x0000, -0x0000, - -/* Character 103 (0x67): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | **** | - |* * | - |* * | - |* * | - | **** | - | * | - | * | - | *** | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7800, -0x8800, -0x8800, -0x8800, -0x7800, -0x0800, -0x0800, -0x7000, - -/* Character 104 (0x68): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |* | - |* | - |* | - |**** | - |* * | - |* * | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x8000, -0x8000, -0x8000, -0xf000, -0x8800, -0x8800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 105 (0x69): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | ** | - | * | - | * | - | * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x2000, -0x0000, -0x6000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 106 (0x6a): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | *** | - | * | - | * | - | * | - | * | - | * | - | * | - | *** | - +------+ -*/ -0x0000, -0x0800, -0x0800, -0x0000, -0x3800, -0x0800, -0x0800, -0x0800, -0x0800, -0x0800, -0x0800, -0x7000, - -/* Character 107 (0x6b): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | * | - | * * | - | * * | - | ** | - | * * | - | * * | - | | - | | - | | - +------+ -*/ -0x0000, -0x4000, -0x4000, -0x4000, -0x4800, -0x5000, -0x6000, -0x5000, -0x4800, -0x0000, -0x0000, -0x0000, - -/* Character 108 (0x6c): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | ** | - | * | - | * | - | * | - | * | - | * | - | * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x6000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 109 (0x6d): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |** * | - |* * * | - |* * * | - |* * * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0xd000, -0xa800, -0xa800, -0xa800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 110 (0x6e): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |* ** | - |** * | - |* * | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0xb000, -0xc800, -0x8800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 111 (0x6f): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | *** | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 112 (0x70): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |**** | - |* * | - |* * | - |* * | - |**** | - |* | - |* | - |* | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0xf000, -0x8800, -0x8800, -0x8800, -0xf000, -0x8000, -0x8000, -0x8000, - -/* Character 113 (0x71): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | **** | - |* * | - |* * | - |* * | - | **** | - | * | - | * | - | * | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7800, -0x8800, -0x8800, -0x8800, -0x7800, -0x0800, -0x0800, -0x0800, - -/* Character 114 (0x72): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | * ** | - | ** | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x5800, -0x6000, -0x4000, -0x4000, -0x4000, -0x0000, -0x0000, -0x0000, - -/* Character 115 (0x73): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | **** | - |* | - | *** | - | * | - |**** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7800, -0x8000, -0x7000, -0x0800, -0xf000, -0x0000, -0x0000, -0x0000, - -/* Character 116 (0x74): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | * | - | *** | - | * | - | * | - | * | - | ** | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x2000, -0x2000, -0x7000, -0x2000, -0x2000, -0x2000, -0x1800, -0x0000, -0x0000, -0x0000, - -/* Character 117 (0x75): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |* * | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x8800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 118 (0x76): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |** ** | - | * * | - | * * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0xd800, -0x5000, -0x5000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 119 (0x77): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |* * | - |* * * | - |* * * | - |* * * | - | * * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x8800, -0xa800, -0xa800, -0xa800, -0x5000, -0x0000, -0x0000, -0x0000, - -/* Character 120 (0x78): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |* * | - | * * | - | * | - | * * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x8800, -0x5000, -0x2000, -0x5000, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 121 (0x79): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |* * | - |* * | - |* * | - |* * | - | **** | - | * | - | * | - | *** | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x8800, -0x8800, -0x8800, -0x8800, -0x7800, -0x0800, -0x0800, -0x7000, - -/* Character 122 (0x7a): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |***** | - | * | - | * | - | * | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0xf800, -0x1000, -0x2000, -0x4000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 123 (0x7b): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +------+ -*/ -0x0800, -0x1000, -0x1000, -0x1000, -0x1000, -0x2000, -0x1000, -0x1000, -0x1000, -0x1000, -0x0800, -0x0000, - -/* Character 124 (0x7c): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +------+ -*/ -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, - -/* Character 125 (0x7d): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | * | - | | - +------+ -*/ -0x4000, -0x2000, -0x2000, -0x2000, -0x2000, -0x1000, -0x2000, -0x2000, -0x2000, -0x2000, -0x4000, -0x0000, - -/* Character 126 (0x7e): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | * | - |* * * | - | * | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x4000, -0xa800, -0x1000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 160 (0xa0): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 161 (0xa1): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | | - | * | - | * | - | * | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x0000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 162 (0xa2): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | * | - | *** | - |* * * | - |* * | - |* * * | - | *** | - | * | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x2000, -0x7000, -0xa800, -0xa000, -0xa800, -0x7000, -0x2000, -0x0000, -0x0000, - -/* Character 163 (0xa3): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | ** | - | * * | - | * | - |*** | - | * | - | * | - | * * | - |* ** | - | | - | | - | | - +------+ -*/ -0x0000, -0x3000, -0x4800, -0x4000, -0xe000, -0x4000, -0x4000, -0x4800, -0xb000, -0x0000, -0x0000, -0x0000, - -/* Character 164 (0xa4): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |* * | - | *** | - | * * | - | *** | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x8800, -0x7000, -0x5000, -0x7000, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 165 (0xa5): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |* * | - | * * | - | * | - | *** | - | * | - | *** | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x8800, -0x5000, -0x2000, -0x7000, -0x2000, -0x7000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 166 (0xa6): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * | - | * | - | * | - | | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x2000, -0x2000, -0x2000, -0x0000, -0x2000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 167 (0xa7): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | ** | - | * * | - | * | - | ** | - | * * | - | * * | - | * * | - | ** | - | * | - | * * | - | ** | - | | - +------+ -*/ -0x3000, -0x4800, -0x4000, -0x3000, -0x4800, -0x4800, -0x4800, -0x3000, -0x0800, -0x4800, -0x3000, -0x0000, - -/* Character 168 (0xa8): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | * * | - | | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x5000, -0x5000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 169 (0xa9): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | **** | - |* *| - |* ** *| - |* * *| - |* * *| - |* ** *| - |* *| - | **** | - | | - | | - | | - +------+ -*/ -0x0000, -0x7800, -0x8400, -0xb400, -0xa400, -0xa400, -0xb400, -0x8400, -0x7800, -0x0000, -0x0000, -0x0000, - -/* Character 170 (0xaa): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | ** | - | * | - | *** | - | * * | - | *** | - | | - | **** | - | | - | | - | | - | | - | | - +------+ -*/ -0x3000, -0x0800, -0x3800, -0x4800, -0x3800, -0x0000, -0x7800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 171 (0xab): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | * * | - | * * | - |* * | - | * * | - | * * | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x2800, -0x5000, -0xa000, -0x5000, -0x2800, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 172 (0xac): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | **** | - | * | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x7800, -0x0800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 173 (0xad): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | **** | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x7800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 174 (0xae): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | **** | - |* *| - |* ** *| - |* * **| - |* ** *| - |* * **| - |* *| - | **** | - | | - | | - | | - +------+ -*/ -0x0000, -0x7800, -0x8400, -0xb400, -0xac00, -0xb400, -0xac00, -0x8400, -0x7800, -0x0000, -0x0000, -0x0000, - -/* Character 175 (0xaf): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - |***** | - | | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0xf800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 176 (0xb0): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | ** | - | * * | - | * * | - | ** | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x3000, -0x4800, -0x4800, -0x3000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 177 (0xb1): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * | - | * | - |***** | - | * | - | * | - | | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x2000, -0x2000, -0xf800, -0x2000, -0x2000, -0x0000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 178 (0xb2): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | ** | - | * | - | * | - | * | - | *** | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x6000, -0x1000, -0x2000, -0x4000, -0x7000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 179 (0xb3): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | ** | - | * | - | * | - | * | - | ** | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x6000, -0x1000, -0x2000, -0x1000, -0x6000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 180 (0xb4): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x1000, -0x2000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 181 (0xb5): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |* * | - |* * | - |* * | - |** * | - |* ** | - |* | - |* | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x8800, -0x8800, -0x8800, -0xc800, -0xb000, -0x8000, -0x8000, -0x0000, - -/* Character 182 (0xb6): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | **** | - |*** * | - |*** * | - | ** * | - | * * | - | * * | - | * * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7800, -0xe800, -0xe800, -0x6800, -0x2800, -0x2800, -0x2800, -0x0000, -0x0000, -0x0000, - -/* Character 183 (0xb7): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | ** | - | | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x3000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 184 (0xb8): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | | - | | - | | - | | - | | - | * | - | * | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x1000, -0x2000, -0x0000, - -/* Character 185 (0xb9): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | ** | - | * | - | * | - | * | - | | - | | - | | - | | - | | - | | - | | - +------+ -*/ -0x2000, -0x6000, -0x2000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 186 (0xba): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | ** | - | * * | - | * * | - | * * | - | ** | - | | - | **** | - | | - | | - | | - | | - | | - +------+ -*/ -0x3000, -0x4800, -0x4800, -0x4800, -0x3000, -0x0000, -0x7800, -0x0000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 187 (0xbb): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - |* * | - | * * | - | * * | - | * * | - |* * | - | | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0xa000, -0x5000, -0x2800, -0x5000, -0xa000, -0x0000, -0x0000, -0x0000, -0x0000, - -/* Character 188 (0xbc): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | * | - | * * | - | * | - | * * | - | *** | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x4000, -0x4000, -0x4000, -0x4800, -0x1000, -0x2800, -0x3800, -0x0800, -0x0000, -0x0000, -0x0000, - -/* Character 189 (0xbd): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | * | - | *** | - | * | - | * | - | * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x4000, -0x4000, -0x4000, -0x7000, -0x0800, -0x1000, -0x2000, -0x3800, -0x0000, -0x0000, -0x0000, - -/* Character 190 (0xbe): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |** | - | * | - | * | - |** * | - | * | - | * * | - | *** | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0xc000, -0x4000, -0x2000, -0xc800, -0x1000, -0x2800, -0x3800, -0x0800, -0x0000, -0x0000, -0x0000, - -/* Character 191 (0xbf): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | | - | * | - | * | - | * | - |* | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x0000, -0x2000, -0x2000, -0x4000, -0x8000, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 192 (0xc0): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - | *** | - |* * | - |* * | - |***** | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x4000, -0x2000, -0x0000, -0x7000, -0x8800, -0x8800, -0xf800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 193 (0xc1): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - | *** | - |* * | - |* * | - |***** | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x1000, -0x2000, -0x0000, -0x7000, -0x8800, -0x8800, -0xf800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 194 (0xc2): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * * | - | | - | *** | - |* * | - |* * | - |***** | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x2000, -0x5000, -0x0000, -0x7000, -0x8800, -0x8800, -0xf800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 195 (0xc3): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * * | - | * * | - | | - | *** | - |* * | - |* * | - |***** | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x2800, -0x5000, -0x0000, -0x7000, -0x8800, -0x8800, -0xf800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 196 (0xc4): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | | - | *** | - |* * | - |* * | - |***** | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x5000, -0x0000, -0x7000, -0x8800, -0x8800, -0xf800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 197 (0xc5): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * * | - | * | - | *** | - |* * | - |* * | - |***** | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x2000, -0x5000, -0x2000, -0x7000, -0x8800, -0x8800, -0xf800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 198 (0xc6): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | **** | - |* * | - |* * | - |* *** | - |*** | - |* * | - |* *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7800, -0xa000, -0xa000, -0xb800, -0xe000, -0xa000, -0xb800, -0x0000, -0x0000, -0x0000, - -/* Character 199 (0xc7): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - |* * | - |* | - |* | - |* | - |* * | - | *** | - | * | - | * | - | | - +------+ -*/ -0x0000, -0x0000, -0x7000, -0x8800, -0x8000, -0x8000, -0x8000, -0x8800, -0x7000, -0x2000, -0x4000, -0x0000, - -/* Character 200 (0xc8): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - |***** | - |* | - |**** | - |* | - |* | - |***** | - | | - | | - | | - +------+ -*/ -0x4000, -0x2000, -0x0000, -0xf800, -0x8000, -0xf000, -0x8000, -0x8000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 201 (0xc9): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - |***** | - |* | - |**** | - |* | - |* | - |***** | - | | - | | - | | - +------+ -*/ -0x1000, -0x2000, -0x0000, -0xf800, -0x8000, -0xf000, -0x8000, -0x8000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 202 (0xca): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * * | - | | - |***** | - |* | - |**** | - |* | - |* | - |***** | - | | - | | - | | - +------+ -*/ -0x2000, -0x5000, -0x0000, -0xf800, -0x8000, -0xf000, -0x8000, -0x8000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 203 (0xcb): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | | - |***** | - |* | - |**** | - |* | - |* | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x5000, -0x0000, -0xf800, -0x8000, -0xf000, -0x8000, -0x8000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 204 (0xcc): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - |***** | - | * | - | * | - | * | - | * | - |***** | - | | - | | - | | - +------+ -*/ -0x4000, -0x2000, -0x0000, -0xf800, -0x2000, -0x2000, -0x2000, -0x2000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 205 (0xcd): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - |***** | - | * | - | * | - | * | - | * | - |***** | - | | - | | - | | - +------+ -*/ -0x1000, -0x2000, -0x0000, -0xf800, -0x2000, -0x2000, -0x2000, -0x2000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 206 (0xce): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * * | - | | - |***** | - | * | - | * | - | * | - | * | - |***** | - | | - | | - | | - +------+ -*/ -0x2000, -0x5000, -0x0000, -0xf800, -0x2000, -0x2000, -0x2000, -0x2000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 207 (0xcf): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | | - |***** | - | * | - | * | - | * | - | * | - |***** | - | | - | | - | | - +------+ -*/ -0x0000, -0x5000, -0x0000, -0xf800, -0x2000, -0x2000, -0x2000, -0x2000, -0xf800, -0x0000, -0x0000, -0x0000, - -/* Character 208 (0xd0): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | *** | - | * * | - | * *| - |*** *| - | * *| - | * * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x7000, -0x4800, -0x4400, -0xe400, -0x4400, -0x4800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 209 (0xd1): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * * | - | * * | - | | - |* * | - |** * | - |* * * | - |* ** | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x2800, -0x5000, -0x0000, -0x8800, -0xc800, -0xa800, -0x9800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 210 (0xd2): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - | *** | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x4000, -0x2000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 211 (0xd3): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - | *** | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x1000, -0x2000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 212 (0xd4): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * * | - | | - | *** | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x2000, -0x5000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 213 (0xd5): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * * | - | * * | - | | - | *** | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x2800, -0x5000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 214 (0xd6): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | | - | *** | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x5000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 215 (0xd7): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - |* * | - | * * | - | * | - | * * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x8800, -0x5000, -0x2000, -0x5000, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 216 (0xd8): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | **** | - |* ** | - |* * * | - |* * * | - |* * * | - |** * | - |**** | - |* | - | | - | | - +------+ -*/ -0x0000, -0x0800, -0x7800, -0x9800, -0xa800, -0xa800, -0xa800, -0xc800, -0xf000, -0x8000, -0x0000, -0x0000, - -/* Character 217 (0xd9): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - |* * | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x4000, -0x2000, -0x0000, -0x8800, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 218 (0xda): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - |* * | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x1000, -0x2000, -0x0000, -0x8800, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 219 (0xdb): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * * | - | | - |* * | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x2000, -0x5000, -0x0000, -0x8800, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 220 (0xdc): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | | - |* * | - |* * | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x5000, -0x0000, -0x8800, -0x8800, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 221 (0xdd): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * | - | | - |* * | - | * * | - | * | - | * | - | * | - | * | - | | - | | - | | - +------+ -*/ -0x1000, -0x2000, -0x0000, -0x8800, -0x5000, -0x2000, -0x2000, -0x2000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 222 (0xde): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |* | - |**** | - |* * | - |* * | - |* * | - |**** | - |* | - |* | - | | - | | - | | - +------+ -*/ -0x0000, -0x8000, -0xf000, -0x8800, -0x8800, -0x8800, -0xf000, -0x8000, -0x8000, -0x0000, -0x0000, -0x0000, - -/* Character 223 (0xdf): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | ** | - | * * | - | * * | - |** * | - | * * | - | * * | - | * * | - | * * | - | | - | | - | | - +------+ -*/ -0x0000, -0x3000, -0x4800, -0x4800, -0xd000, -0x5000, -0x4800, -0x4800, -0x5000, -0x0000, -0x0000, -0x0000, - -/* Character 224 (0xe0): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | **** | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x4000, -0x2000, -0x0000, -0x7800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 225 (0xe1): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | **** | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x1000, -0x2000, -0x0000, -0x7800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 226 (0xe2): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * * | - | | - | **** | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x5000, -0x0000, -0x7800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 227 (0xe3): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | * * | - | | - | **** | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x2800, -0x5000, -0x0000, -0x7800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 228 (0xe4): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * * | - | | - | **** | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x5000, -0x0000, -0x7800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 229 (0xe5): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | * | - | * * | - | * | - | | - | **** | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x2000, -0x5000, -0x2000, -0x0000, -0x7800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 230 (0xe6): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | *** | - | * * | - | *** | - |* * | - | **** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7000, -0x2800, -0x7000, -0xa000, -0x7800, -0x0000, -0x0000, -0x0000, - -/* Character 231 (0xe7): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | **** | - |* | - |* | - |* | - | **** | - | * | - | * | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x7800, -0x8000, -0x8000, -0x8000, -0x7800, -0x2000, -0x4000, -0x0000, - -/* Character 232 (0xe8): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | *** | - |* * | - |***** | - |* | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x4000, -0x2000, -0x0000, -0x7000, -0x8800, -0xf800, -0x8000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 233 (0xe9): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | *** | - |* * | - |***** | - |* | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x1000, -0x2000, -0x0000, -0x7000, -0x8800, -0xf800, -0x8000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 234 (0xea): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * * | - | | - | *** | - |* * | - |***** | - |* | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x5000, -0x0000, -0x7000, -0x8800, -0xf800, -0x8000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 235 (0xeb): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * * | - | | - | *** | - |* * | - |***** | - |* | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x5000, -0x0000, -0x7000, -0x8800, -0xf800, -0x8000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 236 (0xec): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | ** | - | * | - | * | - | * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x4000, -0x2000, -0x0000, -0x6000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 237 (0xed): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | ** | - | * | - | * | - | * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x4000, -0x0000, -0x6000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 238 (0xee): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * * | - | | - | ** | - | * | - | * | - | * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x5000, -0x0000, -0x6000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 239 (0xef): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * * | - | | - | ** | - | * | - | * | - | * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x5000, -0x0000, -0x6000, -0x2000, -0x2000, -0x2000, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 240 (0xf0): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | * | - | * * | - | * | - | **** | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x2800, -0x1000, -0x2800, -0x0800, -0x7800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 241 (0xf1): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | * * | - | | - |* ** | - |** * | - |* * | - |* * | - |* * | - | | - | | - | | - +------+ -*/ -0x0000, -0x2800, -0x5000, -0x0000, -0xb000, -0xc800, -0x8800, -0x8800, -0x8800, -0x0000, -0x0000, -0x0000, - -/* Character 242 (0xf2): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | *** | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x4000, -0x2000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 243 (0xf3): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - | *** | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x1000, -0x2000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 244 (0xf4): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * * | - | | - | *** | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x5000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 245 (0xf5): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * * | - | * * | - | | - | *** | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x2800, -0x5000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 246 (0xf6): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * * | - | | - | *** | - |* * | - |* * | - |* * | - | *** | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x5000, -0x0000, -0x7000, -0x8800, -0x8800, -0x8800, -0x7000, -0x0000, -0x0000, -0x0000, - -/* Character 247 (0xf7): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | | - | * | - | | - |***** | - | | - | * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0000, -0x2000, -0x0000, -0xf800, -0x0000, -0x2000, -0x0000, -0x0000, -0x0000, - -/* Character 248 (0xf8): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | | - | * | - | **** | - |* ** | - |* * * | - |** * | - |**** | - |* | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x0000, -0x0800, -0x7800, -0x9800, -0xa800, -0xc800, -0xf000, -0x8000, -0x0000, -0x0000, - -/* Character 249 (0xf9): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - |* * | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x4000, -0x2000, -0x0000, -0x8800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 250 (0xfa): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - |* * | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x1000, -0x2000, -0x0000, -0x8800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 251 (0xfb): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * * | - | | - |* * | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x2000, -0x5000, -0x0000, -0x8800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 252 (0xfc): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * * | - | | - |* * | - |* * | - |* * | - |* ** | - | ** * | - | | - | | - | | - +------+ -*/ -0x0000, -0x0000, -0x5000, -0x0000, -0x8800, -0x8800, -0x8800, -0x9800, -0x6800, -0x0000, -0x0000, -0x0000, - -/* Character 253 (0xfd): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | * | - | * | - | | - |* * | - |* * | - |* * | - |* * | - | **** | - | * | - | * | - | *** | - +------+ -*/ -0x0000, -0x1000, -0x2000, -0x0000, -0x8800, -0x8800, -0x8800, -0x8800, -0x7800, -0x0800, -0x0800, -0x7000, - -/* Character 254 (0xfe): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - |* | - |* | - |* | - |* ** | - |** * | - |* * | - |** * | - |* ** | - |* | - |* | - | | - +------+ -*/ -0x0000, -0x8000, -0x8000, -0x8000, -0xb000, -0xc800, -0x8800, -0xc800, -0xb000, -0x8000, -0x8000, -0x0000, - -/* Character 255 (0xff): - width 6 - bbx ( 6, 12, 0, -3 ) - - +------+ - | | - | | - | * * | - | | - |* * | - |* * | - |* * | - |* * | - | **** | - | * | - | * | - | *** | - +------+ -*/ -0x0000, -0x0000, -0x5000, -0x0000, -0x8800, -0x8800, -0x8800, -0x8800, -0x7800, -0x0800, -0x0800, -0x7000, -}; - -/* Character->glyph mapping. */ -static const unsigned long _sysfont_offset[] = { - 0, /* (0x00) */ - 12, /* (0x01) */ - 24, /* (0x02) */ - 36, /* (0x03) */ - 48, /* (0x04) */ - 60, /* (0x05) */ - 72, /* (0x06) */ - 84, /* (0x07) */ - 96, /* (0x08) */ - 108, /* (0x09) */ - 120, /* (0x0a) */ - 132, /* (0x0b) */ - 144, /* (0x0c) */ - 156, /* (0x0d) */ - 168, /* (0x0e) */ - 180, /* (0x0f) */ - 192, /* (0x10) */ - 204, /* (0x11) */ - 216, /* (0x12) */ - 228, /* (0x13) */ - 240, /* (0x14) */ - 252, /* (0x15) */ - 264, /* (0x16) */ - 276, /* (0x17) */ - 288, /* (0x18) */ - 300, /* (0x19) */ - 312, /* (0x1a) */ - 324, /* (0x1b) */ - 336, /* (0x1c) */ - 348, /* (0x1d) */ - 360, /* (0x1e) */ - 372, /* (0x1f) */ - 384, /* (0x20) */ - 396, /* (0x21) */ - 408, /* (0x22) */ - 420, /* (0x23) */ - 432, /* (0x24) */ - 444, /* (0x25) */ - 456, /* (0x26) */ - 468, /* (0x27) */ - 480, /* (0x28) */ - 492, /* (0x29) */ - 504, /* (0x2a) */ - 516, /* (0x2b) */ - 528, /* (0x2c) */ - 540, /* (0x2d) */ - 552, /* (0x2e) */ - 564, /* (0x2f) */ - 576, /* (0x30) */ - 588, /* (0x31) */ - 600, /* (0x32) */ - 612, /* (0x33) */ - 624, /* (0x34) */ - 636, /* (0x35) */ - 648, /* (0x36) */ - 660, /* (0x37) */ - 672, /* (0x38) */ - 684, /* (0x39) */ - 696, /* (0x3a) */ - 708, /* (0x3b) */ - 720, /* (0x3c) */ - 732, /* (0x3d) */ - 744, /* (0x3e) */ - 756, /* (0x3f) */ - 768, /* (0x40) */ - 780, /* (0x41) */ - 792, /* (0x42) */ - 804, /* (0x43) */ - 816, /* (0x44) */ - 828, /* (0x45) */ - 840, /* (0x46) */ - 852, /* (0x47) */ - 864, /* (0x48) */ - 876, /* (0x49) */ - 888, /* (0x4a) */ - 900, /* (0x4b) */ - 912, /* (0x4c) */ - 924, /* (0x4d) */ - 936, /* (0x4e) */ - 948, /* (0x4f) */ - 960, /* (0x50) */ - 972, /* (0x51) */ - 984, /* (0x52) */ - 996, /* (0x53) */ - 1008, /* (0x54) */ - 1020, /* (0x55) */ - 1032, /* (0x56) */ - 1044, /* (0x57) */ - 1056, /* (0x58) */ - 1068, /* (0x59) */ - 1080, /* (0x5a) */ - 1092, /* (0x5b) */ - 1104, /* (0x5c) */ - 1116, /* (0x5d) */ - 1128, /* (0x5e) */ - 1140, /* (0x5f) */ - 1152, /* (0x60) */ - 1164, /* (0x61) */ - 1176, /* (0x62) */ - 1188, /* (0x63) */ - 1200, /* (0x64) */ - 1212, /* (0x65) */ - 1224, /* (0x66) */ - 1236, /* (0x67) */ - 1248, /* (0x68) */ - 1260, /* (0x69) */ - 1272, /* (0x6a) */ - 1284, /* (0x6b) */ - 1296, /* (0x6c) */ - 1308, /* (0x6d) */ - 1320, /* (0x6e) */ - 1332, /* (0x6f) */ - 1344, /* (0x70) */ - 1356, /* (0x71) */ - 1368, /* (0x72) */ - 1380, /* (0x73) */ - 1392, /* (0x74) */ - 1404, /* (0x75) */ - 1416, /* (0x76) */ - 1428, /* (0x77) */ - 1440, /* (0x78) */ - 1452, /* (0x79) */ - 1464, /* (0x7a) */ - 1476, /* (0x7b) */ - 1488, /* (0x7c) */ - 1500, /* (0x7d) */ - 1512, /* (0x7e) */ - 0, /* (0x7f) */ - 0, /* (0x80) */ - 0, /* (0x81) */ - 0, /* (0x82) */ - 0, /* (0x83) */ - 0, /* (0x84) */ - 0, /* (0x85) */ - 0, /* (0x86) */ - 0, /* (0x87) */ - 0, /* (0x88) */ - 0, /* (0x89) */ - 0, /* (0x8a) */ - 0, /* (0x8b) */ - 0, /* (0x8c) */ - 0, /* (0x8d) */ - 0, /* (0x8e) */ - 0, /* (0x8f) */ - 0, /* (0x90) */ - 0, /* (0x91) */ - 0, /* (0x92) */ - 0, /* (0x93) */ - 0, /* (0x94) */ - 0, /* (0x95) */ - 0, /* (0x96) */ - 0, /* (0x97) */ - 0, /* (0x98) */ - 0, /* (0x99) */ - 0, /* (0x9a) */ - 0, /* (0x9b) */ - 0, /* (0x9c) */ - 0, /* (0x9d) */ - 0, /* (0x9e) */ - 0, /* (0x9f) */ - 1524, /* (0xa0) */ - 1536, /* (0xa1) */ - 1548, /* (0xa2) */ - 1560, /* (0xa3) */ - 1572, /* (0xa4) */ - 1584, /* (0xa5) */ - 1596, /* (0xa6) */ - 1608, /* (0xa7) */ - 1620, /* (0xa8) */ - 1632, /* (0xa9) */ - 1644, /* (0xaa) */ - 1656, /* (0xab) */ - 1668, /* (0xac) */ - 1680, /* (0xad) */ - 1692, /* (0xae) */ - 1704, /* (0xaf) */ - 1716, /* (0xb0) */ - 1728, /* (0xb1) */ - 1740, /* (0xb2) */ - 1752, /* (0xb3) */ - 1764, /* (0xb4) */ - 1776, /* (0xb5) */ - 1788, /* (0xb6) */ - 1800, /* (0xb7) */ - 1812, /* (0xb8) */ - 1824, /* (0xb9) */ - 1836, /* (0xba) */ - 1848, /* (0xbb) */ - 1860, /* (0xbc) */ - 1872, /* (0xbd) */ - 1884, /* (0xbe) */ - 1896, /* (0xbf) */ - 1908, /* (0xc0) */ - 1920, /* (0xc1) */ - 1932, /* (0xc2) */ - 1944, /* (0xc3) */ - 1956, /* (0xc4) */ - 1968, /* (0xc5) */ - 1980, /* (0xc6) */ - 1992, /* (0xc7) */ - 2004, /* (0xc8) */ - 2016, /* (0xc9) */ - 2028, /* (0xca) */ - 2040, /* (0xcb) */ - 2052, /* (0xcc) */ - 2064, /* (0xcd) */ - 2076, /* (0xce) */ - 2088, /* (0xcf) */ - 2100, /* (0xd0) */ - 2112, /* (0xd1) */ - 2124, /* (0xd2) */ - 2136, /* (0xd3) */ - 2148, /* (0xd4) */ - 2160, /* (0xd5) */ - 2172, /* (0xd6) */ - 2184, /* (0xd7) */ - 2196, /* (0xd8) */ - 2208, /* (0xd9) */ - 2220, /* (0xda) */ - 2232, /* (0xdb) */ - 2244, /* (0xdc) */ - 2256, /* (0xdd) */ - 2268, /* (0xde) */ - 2280, /* (0xdf) */ - 2292, /* (0xe0) */ - 2304, /* (0xe1) */ - 2316, /* (0xe2) */ - 2328, /* (0xe3) */ - 2340, /* (0xe4) */ - 2352, /* (0xe5) */ - 2364, /* (0xe6) */ - 2376, /* (0xe7) */ - 2388, /* (0xe8) */ - 2400, /* (0xe9) */ - 2412, /* (0xea) */ - 2424, /* (0xeb) */ - 2436, /* (0xec) */ - 2448, /* (0xed) */ - 2460, /* (0xee) */ - 2472, /* (0xef) */ - 2484, /* (0xf0) */ - 2496, /* (0xf1) */ - 2508, /* (0xf2) */ - 2520, /* (0xf3) */ - 2532, /* (0xf4) */ - 2544, /* (0xf5) */ - 2556, /* (0xf6) */ - 2568, /* (0xf7) */ - 2580, /* (0xf8) */ - 2592, /* (0xf9) */ - 2604, /* (0xfa) */ - 2616, /* (0xfb) */ - 2628, /* (0xfc) */ - 2640, /* (0xfd) */ - 2652, /* (0xfe) */ - 2664, /* (0xff) */ -}; - -/* Exported structure definition. */ -static const BdfFontDesc desc = { - "clR6x12-L1", - 6, - 12, - 6, 12, 0, -3, - 9, +// Character 0 (0x00) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * * | +// | | +// |* * | +// | | +// |* * | +// | | +// |* * * | +// | | +// | | +// | | +// +------+ +static const byte glyph0[] = { + 0x00, + 0x00, + 0xA8, + 0x00, + 0x88, + 0x00, + 0x88, + 0x00, + 0xA8, + 0x00, + 0x00, + 0x00 +}; + +// Character 1 (0x01) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | * | +// | *** | +// |***** | +// | *** | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph1[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x20, + 0x70, + 0xF8, + 0x70, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 2 (0x02) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// |* * * | +// | * * *| +// |* * * | +// | * * *| +// |* * * | +// | * * *| +// |* * * | +// | * * *| +// |* * * | +// | * * *| +// |* * * | +// | * * *| +// +------+ +static const byte glyph2[] = { + 0xA8, + 0x54, + 0xA8, + 0x54, + 0xA8, + 0x54, + 0xA8, + 0x54, + 0xA8, + 0x54, + 0xA8, + 0x54 +}; + +// Character 3 (0x03) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |* * | +// |* * | +// |*** | +// |* * | +// |* ****| +// | * | +// | * | +// | * | +// | * | +// | | +// | | +// +------+ +static const byte glyph3[] = { + 0x00, + 0xA0, + 0xA0, + 0xE0, + 0xA0, + 0xBC, + 0x08, + 0x08, + 0x08, + 0x08, + 0x00, + 0x00 +}; + +// Character 4 (0x04) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |*** | +// |* | +// |** | +// |* ***| +// |* * | +// | ***| +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph4[] = { + 0x00, + 0xE0, + 0x80, + 0xC0, + 0x9C, + 0x90, + 0x1C, + 0x10, + 0x10, + 0x00, + 0x00, + 0x00 +}; + +// Character 5 (0x05) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | ** | +// |* | +// |* | +// |* ** | +// | *** *| +// | ** | +// | * *| +// | * *| +// | | +// | | +// | | +// +------+ +static const byte glyph5[] = { + 0x00, + 0x60, + 0x80, + 0x80, + 0x98, + 0x74, + 0x18, + 0x14, + 0x14, + 0x00, + 0x00, + 0x00 +}; + +// Character 6 (0x06) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |* | +// |* | +// |* | +// |* ***| +// |**** | +// | ** | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph6[] = { + 0x00, + 0x80, + 0x80, + 0x80, + 0x9C, + 0xF0, + 0x18, + 0x10, + 0x10, + 0x00, + 0x00, + 0x00 +}; + +// Character 7 (0x07) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | ** | +// | * * | +// | * * | +// | ** | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph7[] = { + 0x00, + 0x30, + 0x48, + 0x48, + 0x30, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 8 (0x08) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * | +// | * | +// |***** | +// | * | +// | * | +// | | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph8[] = { + 0x00, + 0x00, + 0x20, + 0x20, + 0xF8, + 0x20, + 0x20, + 0x00, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 9 (0x09) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// |* * | +// |*** | +// |*** | +// |*** | +// |* ** | +// | * | +// | * | +// | * | +// | ***| +// | | +// | | +// | | +// +------+ +static const byte glyph9[] = { + 0xA0, + 0xE0, + 0xE0, + 0xE0, + 0xB0, + 0x10, + 0x10, + 0x10, + 0x1C, + 0x00, + 0x00, + 0x00 +}; + +// Character 10 (0x0A) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |* * | +// |* * | +// |* * | +// | * ***| +// | * * | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph10[] = { + 0x00, + 0xA0, + 0xA0, + 0xA0, + 0x5C, + 0x48, + 0x08, + 0x08, + 0x08, + 0x00, + 0x00, + 0x00 +}; + +// Character 11 (0x0B) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// |*** | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph11[] = { + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0xE0, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 12 (0x0C) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// |*** | +// | * | +// | * | +// | * | +// | * | +// | * | +// +------+ +static const byte glyph12[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xE0, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 13 (0x0D) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | ****| +// | * | +// | * | +// | * | +// | * | +// | * | +// +------+ +static const byte glyph13[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x3F, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 14 (0x0E) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | ****| +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph14[] = { + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x3F, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 15 (0x0F) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// |******| +// | * | +// | * | +// | * | +// | * | +// | * | +// +------+ +static const byte glyph15[] = { + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0xFF, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 16 (0x10) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// |******| +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph16[] = { + 0xFC, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 17 (0x11) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// |******| +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph17[] = { + 0x00, + 0x00, + 0x00, + 0xFC, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 18 (0x12) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// |******| +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph18[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xFC, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 19 (0x13) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// |******| +// | | +// | | +// | | +// +------+ +static const byte glyph19[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xFC, + 0x00, + 0x00, + 0x00 +}; + +// Character 20 (0x14) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// |******| +// +------+ +static const byte glyph20[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xFC +}; + +// Character 21 (0x15) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | ****| +// | * | +// | * | +// | * | +// | * | +// | * | +// +------+ +static const byte glyph21[] = { + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x3F, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 22 (0x16) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// |*** | +// | * | +// | * | +// | * | +// | * | +// | * | +// +------+ +static const byte glyph22[] = { + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0xE0, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 23 (0x17) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// |******| +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph23[] = { + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0xFF, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 24 (0x18) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// |******| +// | * | +// | * | +// | * | +// | * | +// | * | +// +------+ +static const byte glyph24[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xFF, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 25 (0x19) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// +------+ +static const byte glyph25[] = { + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20 +}; + +// Character 26 (0x1A) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | ** | +// | ** | +// |* | +// | ** | +// | ** | +// | | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph26[] = { + 0x00, + 0x00, + 0x18, + 0x60, + 0x80, + 0x60, + 0x18, + 0x00, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 27 (0x1B) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |** | +// | ** | +// | * | +// | ** | +// |** | +// | | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph27[] = { + 0x00, + 0x00, + 0xC0, + 0x30, + 0x08, + 0x30, + 0xC0, + 0x00, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 28 (0x1C) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |***** | +// |* * | +// |* * | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph28[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0xF8, + 0x88, + 0x88, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 29 (0x1D) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * | +// | * | +// |***** | +// | * | +// |***** | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph29[] = { + 0x00, + 0x00, + 0x10, + 0x10, + 0xF8, + 0x20, + 0xF8, + 0x40, + 0x40, + 0x00, + 0x00, + 0x00 +}; + +// Character 30 (0x1E) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | ** | +// | * * | +// | * | +// |*** | +// | * | +// | * | +// | * * | +// |* ** | +// | | +// | | +// | | +// +------+ +static const byte glyph30[] = { + 0x00, + 0x30, + 0x48, + 0x40, + 0xE0, + 0x40, + 0x40, + 0x48, + 0xB0, + 0x00, + 0x00, + 0x00 +}; + +// Character 31 (0x1F) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | ** | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph31[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x30, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 32 (0x20) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph32[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 33 (0x21) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph33[] = { + 0x00, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 34 (0x22) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | * * | +// | * * | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph34[] = { + 0x00, + 0x50, + 0x50, + 0x50, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 35 (0x23) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * * | +// | * * | +// |***** | +// | * * | +// |***** | +// | * * | +// | * * | +// | | +// | | +// | | +// +------+ +static const byte glyph35[] = { + 0x00, + 0x00, + 0x50, + 0x50, + 0xF8, + 0x50, + 0xF8, + 0x50, + 0x50, + 0x00, + 0x00, + 0x00 +}; + +// Character 36 (0x24) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * | +// | **** | +// |* * | +// | *** | +// | * * | +// |**** | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph36[] = { + 0x00, + 0x00, + 0x20, + 0x78, + 0xA0, + 0x70, + 0x28, + 0xF0, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 37 (0x25) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |** | +// |** * | +// | * | +// | * | +// | * | +// |* ** | +// | ** | +// | | +// | | +// | | +// +------+ +static const byte glyph37[] = { + 0x00, + 0x00, + 0xC0, + 0xC8, + 0x10, + 0x20, + 0x40, + 0x98, + 0x18, + 0x00, + 0x00, + 0x00 +}; + +// Character 38 (0x26) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// |* | +// |* | +// | * | +// |* * * | +// |* * | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph38[] = { + 0x00, + 0x00, + 0x70, + 0x80, + 0x80, + 0x40, + 0xA8, + 0x90, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 39 (0x27) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph39[] = { + 0x00, + 0x20, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 40 (0x28) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +------+ +static const byte glyph40[] = { + 0x08, + 0x10, + 0x10, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x10, + 0x10, + 0x08, + 0x00 +}; + +// Character 41 (0x29) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +------+ +static const byte glyph41[] = { + 0x40, + 0x20, + 0x20, + 0x10, + 0x10, + 0x10, + 0x10, + 0x10, + 0x20, + 0x20, + 0x40, + 0x00 +}; + +// Character 42 (0x2A) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | * | +// |* * * | +// | *** | +// |* * * | +// | * | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph42[] = { + 0x00, + 0x00, + 0x00, + 0x20, + 0xA8, + 0x70, + 0xA8, + 0x20, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 43 (0x2B) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | * | +// | * | +// |***** | +// | * | +// | * | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph43[] = { + 0x00, + 0x00, + 0x00, + 0x20, + 0x20, + 0xF8, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 44 (0x2C) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | ** | +// | ** | +// | * | +// | * | +// | | +// +------+ +static const byte glyph44[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x30, + 0x30, + 0x20, + 0x40, + 0x00 +}; + +// Character 45 (0x2D) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// |***** | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph45[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xF8, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 46 (0x2E) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | ** | +// | ** | +// | | +// | | +// | | +// +------+ +static const byte glyph46[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x30, + 0x30, + 0x00, + 0x00, + 0x00 +}; + +// Character 47 (0x2F) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// |* | +// |* | +// | | +// | | +// +------+ +static const byte glyph47[] = { + 0x08, + 0x08, + 0x10, + 0x10, + 0x20, + 0x20, + 0x40, + 0x40, + 0x80, + 0x80, + 0x00, + 0x00 +}; + +// Character 48 (0x30) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | *** | +// |* * | +// |* ** | +// |* * * | +// |** * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph48[] = { + 0x00, + 0x70, + 0x88, + 0x98, + 0xA8, + 0xC8, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 49 (0x31) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | ** | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph49[] = { + 0x00, + 0x10, + 0x30, + 0x10, + 0x10, + 0x10, + 0x10, + 0x10, + 0x10, + 0x00, + 0x00, + 0x00 +}; + +// Character 50 (0x32) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | *** | +// |* * | +// | * | +// | * | +// | * | +// | * | +// |* | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph50[] = { + 0x00, + 0x70, + 0x88, + 0x08, + 0x10, + 0x20, + 0x40, + 0x80, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 51 (0x33) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | *** | +// |* * | +// | * | +// | ** | +// | * | +// | * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph51[] = { + 0x00, + 0x70, + 0x88, + 0x08, + 0x30, + 0x08, + 0x08, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 52 (0x34) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | ** | +// | ** | +// | * * | +// | * * | +// |***** | +// | * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph52[] = { + 0x00, + 0x10, + 0x30, + 0x30, + 0x50, + 0x50, + 0xF8, + 0x10, + 0x38, + 0x00, + 0x00, + 0x00 +}; + +// Character 53 (0x35) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |***** | +// |* | +// |* | +// |**** | +// | * | +// | * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph53[] = { + 0x00, + 0xF8, + 0x80, + 0x80, + 0xF0, + 0x08, + 0x08, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 54 (0x36) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | ** | +// | * | +// |* | +// |**** | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph54[] = { + 0x00, + 0x30, + 0x40, + 0x80, + 0xF0, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 55 (0x37) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |***** | +// |* * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph55[] = { + 0x00, + 0xF8, + 0x88, + 0x08, + 0x08, + 0x10, + 0x10, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 56 (0x38) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | *** | +// |* * | +// |* * | +// | *** | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph56[] = { + 0x00, + 0x70, + 0x88, + 0x88, + 0x70, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 57 (0x39) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// | **** | +// | * | +// | * | +// | ** | +// | | +// | | +// | | +// +------+ +static const byte glyph57[] = { + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x78, + 0x08, + 0x10, + 0x60, + 0x00, + 0x00, + 0x00 +}; + +// Character 58 (0x3A) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | ** | +// | ** | +// | | +// | | +// | ** | +// | ** | +// | | +// | | +// | | +// +------+ +static const byte glyph58[] = { + 0x00, + 0x00, + 0x00, + 0x30, + 0x30, + 0x00, + 0x00, + 0x30, + 0x30, + 0x00, + 0x00, + 0x00 +}; + +// Character 59 (0x3B) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | ** | +// | ** | +// | | +// | | +// | ** | +// | ** | +// | * | +// | * | +// | | +// +------+ +static const byte glyph59[] = { + 0x00, + 0x00, + 0x00, + 0x30, + 0x30, + 0x00, + 0x00, + 0x30, + 0x30, + 0x20, + 0x40, + 0x00 +}; + +// Character 60 (0x3C) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | **| +// | ** | +// |** | +// | ** | +// | **| +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph60[] = { + 0x00, + 0x00, + 0x00, + 0x0C, + 0x30, + 0xC0, + 0x30, + 0x0C, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 61 (0x3D) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |***** | +// | | +// |***** | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph61[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0xF8, + 0x00, + 0xF8, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 62 (0x3E) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// |** | +// | ** | +// | **| +// | ** | +// |** | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph62[] = { + 0x00, + 0x00, + 0x00, + 0xC0, + 0x30, + 0x0C, + 0x30, + 0xC0, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 63 (0x3F) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | *** | +// |* * | +// | * | +// | * | +// | * | +// | * | +// | | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph63[] = { + 0x00, + 0x70, + 0x88, + 0x08, + 0x10, + 0x20, + 0x20, + 0x00, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 64 (0x40) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// |* * | +// |* *** | +// |* *** | +// |* ** | +// |* | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph64[] = { + 0x00, + 0x00, + 0x70, + 0x88, + 0xB8, + 0xB8, + 0xB0, + 0x80, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 65 (0x41) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * | +// | * * | +// |* * | +// |* * | +// |***** | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph65[] = { + 0x00, + 0x00, + 0x20, + 0x50, + 0x88, + 0x88, + 0xF8, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 66 (0x42) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |**** | +// |* * | +// |* * | +// |**** | +// |* * | +// |* * | +// |**** | +// | | +// | | +// | | +// +------+ +static const byte glyph66[] = { + 0x00, + 0x00, + 0xF0, + 0x88, + 0x88, + 0xF0, + 0x88, + 0x88, + 0xF0, + 0x00, + 0x00, + 0x00 +}; + +// Character 67 (0x43) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// |* * | +// |* | +// |* | +// |* | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph67[] = { + 0x00, + 0x00, + 0x70, + 0x88, + 0x80, + 0x80, + 0x80, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 68 (0x44) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |*** | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// |*** | +// | | +// | | +// | | +// +------+ +static const byte glyph68[] = { + 0x00, + 0x00, + 0xE0, + 0x90, + 0x88, + 0x88, + 0x88, + 0x90, + 0xE0, + 0x00, + 0x00, + 0x00 +}; + +// Character 69 (0x45) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |***** | +// |* | +// |* | +// |**** | +// |* | +// |* | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph69[] = { + 0x00, + 0x00, + 0xF8, + 0x80, + 0x80, + 0xF0, + 0x80, + 0x80, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 70 (0x46) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |***** | +// |* | +// |* | +// |**** | +// |* | +// |* | +// |* | +// | | +// | | +// | | +// +------+ +static const byte glyph70[] = { + 0x00, + 0x00, + 0xF8, + 0x80, + 0x80, + 0xF0, + 0x80, + 0x80, + 0x80, + 0x00, + 0x00, + 0x00 +}; + +// Character 71 (0x47) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// |* * | +// |* | +// |* ** | +// |* * | +// |* * | +// | **** | +// | | +// | | +// | | +// +------+ +static const byte glyph71[] = { + 0x00, + 0x00, + 0x70, + 0x88, + 0x80, + 0x98, + 0x88, + 0x88, + 0x78, + 0x00, + 0x00, + 0x00 +}; + +// Character 72 (0x48) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// |* * | +// |* * | +// |***** | +// |* * | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph72[] = { + 0x00, + 0x00, + 0x88, + 0x88, + 0x88, + 0xF8, + 0x88, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 73 (0x49) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |***** | +// | * | +// | * | +// | * | +// | * | +// | * | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph73[] = { + 0x00, + 0x00, + 0xF8, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 74 (0x4A) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// | * | +// | * | +// | * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph74[] = { + 0x00, + 0x00, + 0x38, + 0x08, + 0x08, + 0x08, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 75 (0x4B) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// |* * | +// |* * | +// |** | +// |* * | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph75[] = { + 0x00, + 0x00, + 0x88, + 0x90, + 0xA0, + 0xC0, + 0xA0, + 0x90, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 76 (0x4C) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* | +// |* | +// |* | +// |* | +// |* | +// |* | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph76[] = { + 0x00, + 0x00, + 0x80, + 0x80, + 0x80, + 0x80, + 0x80, + 0x80, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 77 (0x4D) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// |** ** | +// |* * * | +// |* * * | +// |* * | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph77[] = { + 0x00, + 0x00, + 0x88, + 0xD8, + 0xA8, + 0xA8, + 0x88, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 78 (0x4E) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// |** * | +// |** * | +// |* * * | +// |* ** | +// |* ** | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph78[] = { + 0x00, + 0x00, + 0x88, + 0xC8, + 0xC8, + 0xA8, + 0x98, + 0x98, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 79 (0x4F) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph79[] = { + 0x00, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 80 (0x50) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |**** | +// |* * | +// |* * | +// |**** | +// |* | +// |* | +// |* | +// | | +// | | +// | | +// +------+ +static const byte glyph80[] = { + 0x00, + 0x00, + 0xF0, + 0x88, + 0x88, + 0xF0, + 0x80, + 0x80, + 0x80, + 0x00, + 0x00, + 0x00 +}; + +// Character 81 (0x51) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | ** | +// | | +// | | +// +------+ +static const byte glyph81[] = { + 0x00, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x18, + 0x00, + 0x00 +}; + +// Character 82 (0x52) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |**** | +// |* * | +// |* * | +// |**** | +// |* * | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph82[] = { + 0x00, + 0x00, + 0xF0, + 0x88, + 0x88, + 0xF0, + 0xA0, + 0x90, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 83 (0x53) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// |* * | +// |* | +// | *** | +// | * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph83[] = { + 0x00, + 0x00, + 0x70, + 0x88, + 0x80, + 0x70, + 0x08, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 84 (0x54) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |***** | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph84[] = { + 0x00, + 0x00, + 0xF8, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 85 (0x55) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph85[] = { + 0x00, + 0x00, + 0x88, + 0x88, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 86 (0x56) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// |* * | +// |* * | +// | * * | +// | * * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph86[] = { + 0x00, + 0x00, + 0x88, + 0x88, + 0x88, + 0x50, + 0x50, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 87 (0x57) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// |* * | +// |* * | +// |* * * | +// |* * * | +// |** ** | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph87[] = { + 0x00, + 0x00, + 0x88, + 0x88, + 0x88, + 0xA8, + 0xA8, + 0xD8, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 88 (0x58) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// |* * | +// | * * | +// | * | +// | * * | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph88[] = { + 0x00, + 0x00, + 0x88, + 0x88, + 0x50, + 0x20, + 0x50, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 89 (0x59) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// |* * | +// | * * | +// | * | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph89[] = { + 0x00, + 0x00, + 0x88, + 0x88, + 0x50, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 90 (0x5A) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |***** | +// | * | +// | * | +// | * | +// | * | +// |* | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph90[] = { + 0x00, + 0x00, + 0xF8, + 0x08, + 0x10, + 0x20, + 0x40, + 0x80, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 91 (0x5B) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | *** | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | *** | +// | | +// +------+ +static const byte glyph91[] = { + 0x38, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x38, + 0x00 +}; + +// Character 92 (0x5C) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// |* | +// |* | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// | | +// +------+ +static const byte glyph92[] = { + 0x80, + 0x80, + 0x40, + 0x40, + 0x20, + 0x20, + 0x10, + 0x10, + 0x08, + 0x08, + 0x00, + 0x00 +}; + +// Character 93 (0x5D) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | *** | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | *** | +// | | +// +------+ +static const byte glyph93[] = { + 0x70, + 0x10, + 0x10, + 0x10, + 0x10, + 0x10, + 0x10, + 0x10, + 0x10, + 0x10, + 0x70, + 0x00 +}; + +// Character 94 (0x5E) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * * | +// |* * | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph94[] = { + 0x00, + 0x20, + 0x50, + 0x88, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 95 (0x5F) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// |******| +// | | +// | | +// +------+ +static const byte glyph95[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0xFC, + 0x00, + 0x00 +}; + +// Character 96 (0x60) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph96[] = { + 0x00, + 0x20, + 0x10, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 97 (0x61) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | **** | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph97[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x78, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 98 (0x62) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |* | +// |* | +// |* | +// |**** | +// |* * | +// |* * | +// |* * | +// |**** | +// | | +// | | +// | | +// +------+ +static const byte glyph98[] = { + 0x00, + 0x80, + 0x80, + 0x80, + 0xF0, + 0x88, + 0x88, + 0x88, + 0xF0, + 0x00, + 0x00, + 0x00 +}; + +// Character 99 (0x63) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | **** | +// |* | +// |* | +// |* | +// | **** | +// | | +// | | +// | | +// +------+ +static const byte glyph99[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x78, + 0x80, + 0x80, + 0x80, + 0x78, + 0x00, + 0x00, + 0x00 +}; + +// Character 100 (0x64) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | * | +// | **** | +// |* * | +// |* * | +// |* * | +// | **** | +// | | +// | | +// | | +// +------+ +static const byte glyph100[] = { + 0x00, + 0x08, + 0x08, + 0x08, + 0x78, + 0x88, + 0x88, + 0x88, + 0x78, + 0x00, + 0x00, + 0x00 +}; + +// Character 101 (0x65) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | *** | +// |* * | +// |***** | +// |* | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph101[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x70, + 0x88, + 0xF8, + 0x80, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 102 (0x66) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | *** | +// | * | +// | * | +// |**** | +// | * | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph102[] = { + 0x00, + 0x38, + 0x40, + 0x40, + 0xF0, + 0x40, + 0x40, + 0x40, + 0x40, + 0x00, + 0x00, + 0x00 +}; + +// Character 103 (0x67) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | **** | +// |* * | +// |* * | +// |* * | +// | **** | +// | * | +// | * | +// | *** | +// +------+ +static const byte glyph103[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x78, + 0x88, + 0x88, + 0x88, + 0x78, + 0x08, + 0x08, + 0x70 +}; + +// Character 104 (0x68) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |* | +// |* | +// |* | +// |**** | +// |* * | +// |* * | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph104[] = { + 0x00, + 0x80, + 0x80, + 0x80, + 0xF0, + 0x88, + 0x88, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 105 (0x69) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | ** | +// | * | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph105[] = { + 0x00, + 0x20, + 0x20, + 0x00, + 0x60, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 106 (0x6A) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | *** | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | *** | +// +------+ +static const byte glyph106[] = { + 0x00, + 0x08, + 0x08, + 0x00, + 0x38, + 0x08, + 0x08, + 0x08, + 0x08, + 0x08, + 0x08, + 0x70 +}; + +// Character 107 (0x6B) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | * | +// | * * | +// | * * | +// | ** | +// | * * | +// | * * | +// | | +// | | +// | | +// +------+ +static const byte glyph107[] = { + 0x00, + 0x40, + 0x40, + 0x40, + 0x48, + 0x50, + 0x60, + 0x50, + 0x48, + 0x00, + 0x00, + 0x00 +}; + +// Character 108 (0x6C) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | ** | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph108[] = { + 0x00, + 0x60, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 109 (0x6D) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |** * | +// |* * * | +// |* * * | +// |* * * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph109[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0xD0, + 0xA8, + 0xA8, + 0xA8, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 110 (0x6E) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |* ** | +// |** * | +// |* * | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph110[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0xB0, + 0xC8, + 0x88, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 111 (0x6F) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph111[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 112 (0x70) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |**** | +// |* * | +// |* * | +// |* * | +// |**** | +// |* | +// |* | +// |* | +// +------+ +static const byte glyph112[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0xF0, + 0x88, + 0x88, + 0x88, + 0xF0, + 0x80, + 0x80, + 0x80 +}; + +// Character 113 (0x71) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | **** | +// |* * | +// |* * | +// |* * | +// | **** | +// | * | +// | * | +// | * | +// +------+ +static const byte glyph113[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x78, + 0x88, + 0x88, + 0x88, + 0x78, + 0x08, + 0x08, + 0x08 +}; + +// Character 114 (0x72) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | * ** | +// | ** | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph114[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x58, + 0x60, + 0x40, + 0x40, + 0x40, + 0x00, + 0x00, + 0x00 +}; + +// Character 115 (0x73) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | **** | +// |* | +// | *** | +// | * | +// |**** | +// | | +// | | +// | | +// +------+ +static const byte glyph115[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x78, + 0x80, + 0x70, + 0x08, + 0xF0, + 0x00, + 0x00, + 0x00 +}; + +// Character 116 (0x74) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | * | +// | *** | +// | * | +// | * | +// | * | +// | ** | +// | | +// | | +// | | +// +------+ +static const byte glyph116[] = { + 0x00, + 0x20, + 0x20, + 0x20, + 0x70, + 0x20, + 0x20, + 0x20, + 0x18, + 0x00, + 0x00, + 0x00 +}; + +// Character 117 (0x75) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |* * | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph117[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x88, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 118 (0x76) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |** ** | +// | * * | +// | * * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph118[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0xD8, + 0x50, + 0x50, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 119 (0x77) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |* * | +// |* * * | +// |* * * | +// |* * * | +// | * * | +// | | +// | | +// | | +// +------+ +static const byte glyph119[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x88, + 0xA8, + 0xA8, + 0xA8, + 0x50, + 0x00, + 0x00, + 0x00 +}; + +// Character 120 (0x78) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |* * | +// | * * | +// | * | +// | * * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph120[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x88, + 0x50, + 0x20, + 0x50, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 121 (0x79) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// | **** | +// | * | +// | * | +// | *** | +// +------+ +static const byte glyph121[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x88, + 0x88, + 0x88, + 0x88, + 0x78, + 0x08, + 0x08, + 0x70 +}; + +// Character 122 (0x7A) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |***** | +// | * | +// | * | +// | * | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph122[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0xF8, + 0x10, + 0x20, + 0x40, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 123 (0x7B) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +------+ +static const byte glyph123[] = { + 0x08, + 0x10, + 0x10, + 0x10, + 0x10, + 0x20, + 0x10, + 0x10, + 0x10, + 0x10, + 0x08, + 0x00 +}; + +// Character 124 (0x7C) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +------+ +static const byte glyph124[] = { + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00 +}; + +// Character 125 (0x7D) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// +------+ +static const byte glyph125[] = { + 0x40, + 0x20, + 0x20, + 0x20, + 0x20, + 0x10, + 0x20, + 0x20, + 0x20, + 0x20, + 0x40, + 0x00 +}; + +// Character 126 (0x7E) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | * | +// |* * * | +// | * | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph126[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x40, + 0xA8, + 0x10, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 160 (0xA0) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph160[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 161 (0xA1) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | | +// | * | +// | * | +// | * | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph161[] = { + 0x00, + 0x20, + 0x00, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 162 (0xA2) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | * | +// | *** | +// |* * * | +// |* * | +// |* * * | +// | *** | +// | * | +// | | +// | | +// +------+ +static const byte glyph162[] = { + 0x00, + 0x00, + 0x00, + 0x20, + 0x70, + 0xA8, + 0xA0, + 0xA8, + 0x70, + 0x20, + 0x00, + 0x00 +}; + +// Character 163 (0xA3) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | ** | +// | * * | +// | * | +// |*** | +// | * | +// | * | +// | * * | +// |* ** | +// | | +// | | +// | | +// +------+ +static const byte glyph163[] = { + 0x00, + 0x30, + 0x48, + 0x40, + 0xE0, + 0x40, + 0x40, + 0x48, + 0xB0, + 0x00, + 0x00, + 0x00 +}; + +// Character 164 (0xA4) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |* * | +// | *** | +// | * * | +// | *** | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph164[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x88, + 0x70, + 0x50, + 0x70, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 165 (0xA5) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |* * | +// | * * | +// | * | +// | *** | +// | * | +// | *** | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph165[] = { + 0x00, + 0x00, + 0x88, + 0x50, + 0x20, + 0x70, + 0x20, + 0x70, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 166 (0xA6) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * | +// | * | +// | * | +// | | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph166[] = { + 0x00, + 0x00, + 0x20, + 0x20, + 0x20, + 0x00, + 0x20, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 167 (0xA7) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | ** | +// | * * | +// | * | +// | ** | +// | * * | +// | * * | +// | * * | +// | ** | +// | * | +// | * * | +// | ** | +// | | +// +------+ +static const byte glyph167[] = { + 0x30, + 0x48, + 0x40, + 0x30, + 0x48, + 0x48, + 0x48, + 0x30, + 0x08, + 0x48, + 0x30, + 0x00 +}; + +// Character 168 (0xA8) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | * * | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph168[] = { + 0x00, + 0x50, + 0x50, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 169 (0xA9) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | **** | +// |* *| +// |* ** *| +// |* * *| +// |* * *| +// |* ** *| +// |* *| +// | **** | +// | | +// | | +// | | +// +------+ +static const byte glyph169[] = { + 0x00, + 0x78, + 0x84, + 0xB4, + 0xA4, + 0xA4, + 0xB4, + 0x84, + 0x78, + 0x00, + 0x00, + 0x00 +}; + +// Character 170 (0xAA) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | ** | +// | * | +// | *** | +// | * * | +// | *** | +// | | +// | **** | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph170[] = { + 0x30, + 0x08, + 0x38, + 0x48, + 0x38, + 0x00, + 0x78, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 171 (0xAB) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | * * | +// | * * | +// |* * | +// | * * | +// | * * | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph171[] = { + 0x00, + 0x00, + 0x00, + 0x28, + 0x50, + 0xA0, + 0x50, + 0x28, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 172 (0xAC) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | **** | +// | * | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph172[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x78, + 0x08, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 173 (0xAD) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | **** | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph173[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x78, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 174 (0xAE) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | **** | +// |* *| +// |* ** *| +// |* * **| +// |* ** *| +// |* * **| +// |* *| +// | **** | +// | | +// | | +// | | +// +------+ +static const byte glyph174[] = { + 0x00, + 0x78, + 0x84, + 0xB4, + 0xAC, + 0xB4, + 0xAC, + 0x84, + 0x78, + 0x00, + 0x00, + 0x00 +}; + +// Character 175 (0xAF) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// |***** | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph175[] = { + 0x00, + 0x00, + 0xF8, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 176 (0xB0) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | ** | +// | * * | +// | * * | +// | ** | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph176[] = { + 0x00, + 0x30, + 0x48, + 0x48, + 0x30, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 177 (0xB1) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * | +// | * | +// |***** | +// | * | +// | * | +// | | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph177[] = { + 0x00, + 0x00, + 0x20, + 0x20, + 0xF8, + 0x20, + 0x20, + 0x00, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 178 (0xB2) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | ** | +// | * | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph178[] = { + 0x60, + 0x10, + 0x20, + 0x40, + 0x70, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 179 (0xB3) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | ** | +// | * | +// | * | +// | * | +// | ** | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph179[] = { + 0x60, + 0x10, + 0x20, + 0x10, + 0x60, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 180 (0xB4) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph180[] = { + 0x00, + 0x10, + 0x20, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 181 (0xB5) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |* * | +// |* * | +// |* * | +// |** * | +// |* ** | +// |* | +// |* | +// | | +// +------+ +static const byte glyph181[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x88, + 0x88, + 0x88, + 0xC8, + 0xB0, + 0x80, + 0x80, + 0x00 +}; + +// Character 182 (0xB6) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | **** | +// |*** * | +// |*** * | +// | ** * | +// | * * | +// | * * | +// | * * | +// | | +// | | +// | | +// +------+ +static const byte glyph182[] = { + 0x00, + 0x00, + 0x78, + 0xE8, + 0xE8, + 0x68, + 0x28, + 0x28, + 0x28, + 0x00, + 0x00, + 0x00 +}; + +// Character 183 (0xB7) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | ** | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph183[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x30, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 184 (0xB8) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// | * | +// | * | +// | | +// +------+ +static const byte glyph184[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x10, + 0x20, + 0x00 +}; + +// Character 185 (0xB9) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | ** | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph185[] = { + 0x20, + 0x60, + 0x20, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 186 (0xBA) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | ** | +// | * * | +// | * * | +// | * * | +// | ** | +// | | +// | **** | +// | | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph186[] = { + 0x30, + 0x48, + 0x48, + 0x48, + 0x30, + 0x00, + 0x78, + 0x00, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 187 (0xBB) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// |* * | +// | * * | +// | * * | +// | * * | +// |* * | +// | | +// | | +// | | +// | | +// +------+ +static const byte glyph187[] = { + 0x00, + 0x00, + 0x00, + 0xA0, + 0x50, + 0x28, + 0x50, + 0xA0, + 0x00, + 0x00, + 0x00, + 0x00 +}; + +// Character 188 (0xBC) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | * | +// | * * | +// | * | +// | * * | +// | *** | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph188[] = { + 0x00, + 0x40, + 0x40, + 0x40, + 0x48, + 0x10, + 0x28, + 0x38, + 0x08, + 0x00, + 0x00, + 0x00 +}; + +// Character 189 (0xBD) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | * | +// | *** | +// | * | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph189[] = { + 0x00, + 0x40, + 0x40, + 0x40, + 0x70, + 0x08, + 0x10, + 0x20, + 0x38, + 0x00, + 0x00, + 0x00 +}; + +// Character 190 (0xBE) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |** | +// | * | +// | * | +// |** * | +// | * | +// | * * | +// | *** | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph190[] = { + 0x00, + 0xC0, + 0x40, + 0x20, + 0xC8, + 0x10, + 0x28, + 0x38, + 0x08, + 0x00, + 0x00, + 0x00 +}; + +// Character 191 (0xBF) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | | +// | * | +// | * | +// | * | +// |* | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph191[] = { + 0x00, + 0x20, + 0x00, + 0x20, + 0x20, + 0x40, + 0x80, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 192 (0xC0) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// | *** | +// |* * | +// |* * | +// |***** | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph192[] = { + 0x40, + 0x20, + 0x00, + 0x70, + 0x88, + 0x88, + 0xF8, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 193 (0xC1) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// | *** | +// |* * | +// |* * | +// |***** | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph193[] = { + 0x10, + 0x20, + 0x00, + 0x70, + 0x88, + 0x88, + 0xF8, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 194 (0xC2) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// |***** | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph194[] = { + 0x20, + 0x50, + 0x00, + 0x70, + 0x88, + 0x88, + 0xF8, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 195 (0xC3) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * * | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// |***** | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph195[] = { + 0x28, + 0x50, + 0x00, + 0x70, + 0x88, + 0x88, + 0xF8, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 196 (0xC4) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// |***** | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph196[] = { + 0x00, + 0x50, + 0x00, + 0x70, + 0x88, + 0x88, + 0xF8, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 197 (0xC5) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * * | +// | * | +// | *** | +// |* * | +// |* * | +// |***** | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph197[] = { + 0x20, + 0x50, + 0x20, + 0x70, + 0x88, + 0x88, + 0xF8, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 198 (0xC6) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | **** | +// |* * | +// |* * | +// |* *** | +// |*** | +// |* * | +// |* *** | +// | | +// | | +// | | +// +------+ +static const byte glyph198[] = { + 0x00, + 0x00, + 0x78, + 0xA0, + 0xA0, + 0xB8, + 0xE0, + 0xA0, + 0xB8, + 0x00, + 0x00, + 0x00 +}; + +// Character 199 (0xC7) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// |* * | +// |* | +// |* | +// |* | +// |* * | +// | *** | +// | * | +// | * | +// | | +// +------+ +static const byte glyph199[] = { + 0x00, + 0x00, + 0x70, + 0x88, + 0x80, + 0x80, + 0x80, + 0x88, + 0x70, + 0x20, + 0x40, + 0x00 +}; + +// Character 200 (0xC8) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// |***** | +// |* | +// |**** | +// |* | +// |* | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph200[] = { + 0x40, + 0x20, + 0x00, + 0xF8, + 0x80, + 0xF0, + 0x80, + 0x80, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 201 (0xC9) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// |***** | +// |* | +// |**** | +// |* | +// |* | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph201[] = { + 0x10, + 0x20, + 0x00, + 0xF8, + 0x80, + 0xF0, + 0x80, + 0x80, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 202 (0xCA) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * * | +// | | +// |***** | +// |* | +// |**** | +// |* | +// |* | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph202[] = { + 0x20, + 0x50, + 0x00, + 0xF8, + 0x80, + 0xF0, + 0x80, + 0x80, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 203 (0xCB) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | | +// |***** | +// |* | +// |**** | +// |* | +// |* | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph203[] = { + 0x00, + 0x50, + 0x00, + 0xF8, + 0x80, + 0xF0, + 0x80, + 0x80, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 204 (0xCC) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// |***** | +// | * | +// | * | +// | * | +// | * | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph204[] = { + 0x40, + 0x20, + 0x00, + 0xF8, + 0x20, + 0x20, + 0x20, + 0x20, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 205 (0xCD) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// |***** | +// | * | +// | * | +// | * | +// | * | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph205[] = { + 0x10, + 0x20, + 0x00, + 0xF8, + 0x20, + 0x20, + 0x20, + 0x20, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 206 (0xCE) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * * | +// | | +// |***** | +// | * | +// | * | +// | * | +// | * | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph206[] = { + 0x20, + 0x50, + 0x00, + 0xF8, + 0x20, + 0x20, + 0x20, + 0x20, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 207 (0xCF) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | | +// |***** | +// | * | +// | * | +// | * | +// | * | +// |***** | +// | | +// | | +// | | +// +------+ +static const byte glyph207[] = { + 0x00, + 0x50, + 0x00, + 0xF8, + 0x20, + 0x20, + 0x20, + 0x20, + 0xF8, + 0x00, + 0x00, + 0x00 +}; + +// Character 208 (0xD0) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | *** | +// | * * | +// | * *| +// |*** *| +// | * *| +// | * * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph208[] = { + 0x00, + 0x00, + 0x70, + 0x48, + 0x44, + 0xE4, + 0x44, + 0x48, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 209 (0xD1) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * * | +// | * * | +// | | +// |* * | +// |** * | +// |* * * | +// |* ** | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph209[] = { + 0x28, + 0x50, + 0x00, + 0x88, + 0xC8, + 0xA8, + 0x98, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 210 (0xD2) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph210[] = { + 0x40, + 0x20, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 211 (0xD3) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph211[] = { + 0x10, + 0x20, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 212 (0xD4) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph212[] = { + 0x20, + 0x50, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 213 (0xD5) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * * | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph213[] = { + 0x28, + 0x50, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 214 (0xD6) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph214[] = { + 0x00, + 0x50, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 215 (0xD7) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// |* * | +// | * * | +// | * | +// | * * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph215[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x88, + 0x50, + 0x20, + 0x50, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 216 (0xD8) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | **** | +// |* ** | +// |* * * | +// |* * * | +// |* * * | +// |** * | +// |**** | +// |* | +// | | +// | | +// +------+ +static const byte glyph216[] = { + 0x00, + 0x08, + 0x78, + 0x98, + 0xA8, + 0xA8, + 0xA8, + 0xC8, + 0xF0, + 0x80, + 0x00, + 0x00 +}; + +// Character 217 (0xD9) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph217[] = { + 0x40, + 0x20, + 0x00, + 0x88, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 218 (0xDA) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph218[] = { + 0x10, + 0x20, + 0x00, + 0x88, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 219 (0xDB) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * * | +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph219[] = { + 0x20, + 0x50, + 0x00, + 0x88, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 220 (0xDC) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph220[] = { + 0x00, + 0x50, + 0x00, + 0x88, + 0x88, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 221 (0xDD) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * | +// | | +// |* * | +// | * * | +// | * | +// | * | +// | * | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph221[] = { + 0x10, + 0x20, + 0x00, + 0x88, + 0x50, + 0x20, + 0x20, + 0x20, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 222 (0xDE) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |* | +// |**** | +// |* * | +// |* * | +// |* * | +// |**** | +// |* | +// |* | +// | | +// | | +// | | +// +------+ +static const byte glyph222[] = { + 0x00, + 0x80, + 0xF0, + 0x88, + 0x88, + 0x88, + 0xF0, + 0x80, + 0x80, + 0x00, + 0x00, + 0x00 +}; + +// Character 223 (0xDF) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | ** | +// | * * | +// | * * | +// |** * | +// | * * | +// | * * | +// | * * | +// | * * | +// | | +// | | +// | | +// +------+ +static const byte glyph223[] = { + 0x00, + 0x30, + 0x48, + 0x48, + 0xD0, + 0x50, + 0x48, + 0x48, + 0x50, + 0x00, + 0x00, + 0x00 +}; + +// Character 224 (0xE0) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | **** | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph224[] = { + 0x00, + 0x40, + 0x20, + 0x00, + 0x78, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 225 (0xE1) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | **** | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph225[] = { + 0x00, + 0x10, + 0x20, + 0x00, + 0x78, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 226 (0xE2) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * * | +// | | +// | **** | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph226[] = { + 0x00, + 0x20, + 0x50, + 0x00, + 0x78, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 227 (0xE3) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | * * | +// | | +// | **** | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph227[] = { + 0x00, + 0x28, + 0x50, + 0x00, + 0x78, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 228 (0xE4) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * * | +// | | +// | **** | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph228[] = { + 0x00, + 0x00, + 0x50, + 0x00, + 0x78, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 229 (0xE5) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | * | +// | * * | +// | * | +// | | +// | **** | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph229[] = { + 0x20, + 0x50, + 0x20, + 0x00, + 0x78, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 230 (0xE6) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | *** | +// | * * | +// | *** | +// |* * | +// | **** | +// | | +// | | +// | | +// +------+ +static const byte glyph230[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x70, + 0x28, + 0x70, + 0xA0, + 0x78, + 0x00, + 0x00, + 0x00 +}; + +// Character 231 (0xE7) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | **** | +// |* | +// |* | +// |* | +// | **** | +// | * | +// | * | +// | | +// +------+ +static const byte glyph231[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x78, + 0x80, + 0x80, + 0x80, + 0x78, + 0x20, + 0x40, + 0x00 +}; + +// Character 232 (0xE8) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | *** | +// |* * | +// |***** | +// |* | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph232[] = { + 0x00, + 0x40, + 0x20, + 0x00, + 0x70, + 0x88, + 0xF8, + 0x80, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 233 (0xE9) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | *** | +// |* * | +// |***** | +// |* | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph233[] = { + 0x00, + 0x10, + 0x20, + 0x00, + 0x70, + 0x88, + 0xF8, + 0x80, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 234 (0xEA) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * * | +// | | +// | *** | +// |* * | +// |***** | +// |* | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph234[] = { + 0x00, + 0x20, + 0x50, + 0x00, + 0x70, + 0x88, + 0xF8, + 0x80, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 235 (0xEB) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * * | +// | | +// | *** | +// |* * | +// |***** | +// |* | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph235[] = { + 0x00, + 0x00, + 0x50, + 0x00, + 0x70, + 0x88, + 0xF8, + 0x80, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 236 (0xEC) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | ** | +// | * | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph236[] = { + 0x00, + 0x40, + 0x20, + 0x00, + 0x60, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 237 (0xED) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | ** | +// | * | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph237[] = { + 0x00, + 0x20, + 0x40, + 0x00, + 0x60, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 238 (0xEE) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * * | +// | | +// | ** | +// | * | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph238[] = { + 0x00, + 0x20, + 0x50, + 0x00, + 0x60, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 239 (0xEF) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * * | +// | | +// | ** | +// | * | +// | * | +// | * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph239[] = { + 0x00, + 0x00, + 0x50, + 0x00, + 0x60, + 0x20, + 0x20, + 0x20, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 240 (0xF0) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | * | +// | * * | +// | * | +// | **** | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph240[] = { + 0x00, + 0x28, + 0x10, + 0x28, + 0x08, + 0x78, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 241 (0xF1) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | * * | +// | | +// |* ** | +// |** * | +// |* * | +// |* * | +// |* * | +// | | +// | | +// | | +// +------+ +static const byte glyph241[] = { + 0x00, + 0x28, + 0x50, + 0x00, + 0xB0, + 0xC8, + 0x88, + 0x88, + 0x88, + 0x00, + 0x00, + 0x00 +}; + +// Character 242 (0xF2) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph242[] = { + 0x00, + 0x40, + 0x20, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 243 (0xF3) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph243[] = { + 0x00, + 0x10, + 0x20, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 244 (0xF4) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph244[] = { + 0x00, + 0x20, + 0x50, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 245 (0xF5) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * * | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph245[] = { + 0x00, + 0x28, + 0x50, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 246 (0xF6) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * * | +// | | +// | *** | +// |* * | +// |* * | +// |* * | +// | *** | +// | | +// | | +// | | +// +------+ +static const byte glyph246[] = { + 0x00, + 0x00, + 0x50, + 0x00, + 0x70, + 0x88, + 0x88, + 0x88, + 0x70, + 0x00, + 0x00, + 0x00 +}; + +// Character 247 (0xF7) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | | +// | * | +// | | +// |***** | +// | | +// | * | +// | | +// | | +// | | +// +------+ +static const byte glyph247[] = { + 0x00, + 0x00, + 0x00, + 0x00, + 0x20, + 0x00, + 0xF8, + 0x00, + 0x20, + 0x00, + 0x00, + 0x00 +}; + +// Character 248 (0xF8) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | | +// | * | +// | **** | +// |* ** | +// |* * * | +// |** * | +// |**** | +// |* | +// | | +// | | +// +------+ +static const byte glyph248[] = { + 0x00, + 0x00, + 0x00, + 0x08, + 0x78, + 0x98, + 0xA8, + 0xC8, + 0xF0, + 0x80, + 0x00, + 0x00 +}; + +// Character 249 (0xF9) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// |* * | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph249[] = { + 0x00, + 0x40, + 0x20, + 0x00, + 0x88, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 250 (0xFA) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// |* * | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph250[] = { + 0x00, + 0x10, + 0x20, + 0x00, + 0x88, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 251 (0xFB) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * * | +// | | +// |* * | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph251[] = { + 0x00, + 0x20, + 0x50, + 0x00, + 0x88, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 252 (0xFC) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * * | +// | | +// |* * | +// |* * | +// |* * | +// |* ** | +// | ** * | +// | | +// | | +// | | +// +------+ +static const byte glyph252[] = { + 0x00, + 0x00, + 0x50, + 0x00, + 0x88, + 0x88, + 0x88, + 0x98, + 0x68, + 0x00, + 0x00, + 0x00 +}; + +// Character 253 (0xFD) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | * | +// | * | +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// | **** | +// | * | +// | * | +// | *** | +// +------+ +static const byte glyph253[] = { + 0x00, + 0x10, + 0x20, + 0x00, + 0x88, + 0x88, + 0x88, + 0x88, + 0x78, + 0x08, + 0x08, + 0x70 +}; + +// Character 254 (0xFE) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// |* | +// |* | +// |* | +// |* ** | +// |** * | +// |* * | +// |** * | +// |* ** | +// |* | +// |* | +// | | +// +------+ +static const byte glyph254[] = { + 0x00, + 0x80, + 0x80, + 0x80, + 0xB0, + 0xC8, + 0x88, + 0xC8, + 0xB0, + 0x80, + 0x80, + 0x00 +}; + +// Character 255 (0xFF) +// Box: 6 12 0 -3 +// Advance: 6 +// +// +------+ +// | | +// | | +// | * * | +// | | +// |* * | +// |* * | +// |* * | +// |* * | +// | **** | +// | * | +// | * | +// | *** | +// +------+ +static const byte glyph255[] = { + 0x00, + 0x00, + 0x50, + 0x00, + 0x88, + 0x88, + 0x88, + 0x88, + 0x78, + 0x08, + 0x08, + 0x70 +}; + +// Bitmap pointer table +const byte *const bitmapTable[] = { + glyph0, + glyph1, + glyph2, + glyph3, + glyph4, + glyph5, + glyph6, + glyph7, + glyph8, + glyph9, + glyph10, + glyph11, + glyph12, + glyph13, + glyph14, + glyph15, + glyph16, + glyph17, + glyph18, + glyph19, + glyph20, + glyph21, + glyph22, + glyph23, + glyph24, + glyph25, + glyph26, + glyph27, + glyph28, + glyph29, + glyph30, + glyph31, + glyph32, + glyph33, + glyph34, + glyph35, + glyph36, + glyph37, + glyph38, + glyph39, + glyph40, + glyph41, + glyph42, + glyph43, + glyph44, + glyph45, + glyph46, + glyph47, + glyph48, + glyph49, + glyph50, + glyph51, + glyph52, + glyph53, + glyph54, + glyph55, + glyph56, + glyph57, + glyph58, + glyph59, + glyph60, + glyph61, + glyph62, + glyph63, + glyph64, + glyph65, + glyph66, + glyph67, + glyph68, + glyph69, + glyph70, + glyph71, + glyph72, + glyph73, + glyph74, + glyph75, + glyph76, + glyph77, + glyph78, + glyph79, + glyph80, + glyph81, + glyph82, + glyph83, + glyph84, + glyph85, + glyph86, + glyph87, + glyph88, + glyph89, + glyph90, + glyph91, + glyph92, + glyph93, + glyph94, + glyph95, + glyph96, + glyph97, + glyph98, + glyph99, + glyph100, + glyph101, + glyph102, + glyph103, + glyph104, + glyph105, + glyph106, + glyph107, + glyph108, + glyph109, + glyph110, + glyph111, + glyph112, + glyph113, + glyph114, + glyph115, + glyph116, + glyph117, + glyph118, + glyph119, + glyph120, + glyph121, + glyph122, + glyph123, + glyph124, + glyph125, + glyph126, + 0, + 0, + 0, + 0, + 0, 0, - 256, - _font_bits, - _sysfont_offset, - 0, /* fixed width*/ - 0, /* fixed bbox*/ 0, - sizeof(_font_bits)/sizeof(bitmap_t) + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + glyph160, + glyph161, + glyph162, + glyph163, + glyph164, + glyph165, + glyph166, + glyph167, + glyph168, + glyph169, + glyph170, + glyph171, + glyph172, + glyph173, + glyph174, + glyph175, + glyph176, + glyph177, + glyph178, + glyph179, + glyph180, + glyph181, + glyph182, + glyph183, + glyph184, + glyph185, + glyph186, + glyph187, + glyph188, + glyph189, + glyph190, + glyph191, + glyph192, + glyph193, + glyph194, + glyph195, + glyph196, + glyph197, + glyph198, + glyph199, + glyph200, + glyph201, + glyph202, + glyph203, + glyph204, + glyph205, + glyph206, + glyph207, + glyph208, + glyph209, + glyph210, + glyph211, + glyph212, + glyph213, + glyph214, + glyph215, + glyph216, + glyph217, + glyph218, + glyph219, + glyph220, + glyph221, + glyph222, + glyph223, + glyph224, + glyph225, + glyph226, + glyph227, + glyph228, + glyph229, + glyph230, + glyph231, + glyph232, + glyph233, + glyph234, + glyph235, + glyph236, + glyph237, + glyph238, + glyph239, + glyph240, + glyph241, + glyph242, + glyph243, + glyph244, + glyph245, + glyph246, + glyph247, + glyph248, + glyph249, + glyph250, + glyph251, + glyph252, + glyph253, + glyph254, + glyph255 +}; + +// Font structure +static const BdfFontData desc = { + 6, // Max advance + 12, // Height + { 6, 12, 0, -3 }, // Bounding box + 9, // Ascent + + 0, // First character + 0, // Default character + 256, // Characters + + bitmapTable, // Bitmaps + 0, // Advances + 0 // Boxes }; DEFINE_FONT(g_sysfont) diff --git a/graphics/fonts/newfont_big.cpp b/graphics/fonts/newfont_big.cpp index 59c54a4551..0e61068ade 100644 --- a/graphics/fonts/newfont_big.cpp +++ b/graphics/fonts/newfont_big.cpp @@ -1,5542 +1,5846 @@ -/* Generated by convbdf on Tue Jun 13 00:00:22 2006. */ +// Generated by convbdf on Fri Jan 6 14:33:14 2012 #include "graphics/fonts/bdf.h" -/* Font information: - name: helvB12-L1 - facename: -Adobe-Helvetica-Bold-R-Normal--12-120-75-75-P-70-ISO8859-1 - w x h: 13x14 - bbx: 13 15 -1 -3 - size: 224 - ascent: 11 - descent: 3 - first char: 32 (0x20) - last char: 255 (0xff) - default char: 32 (0x20) - proportional: yes - Copyright (c) 1984, 1987 Adobe Systems Incorporated. All Rights Reserved. Copyright (c) 1988, 1991 Digital Equipment Corporation. All Rights Reserved. -*/ +// Font information: +// Name: -Adobe-Helvetica-Bold-R-Normal--12-120-75-75-P-70-ISO8859-1 +// Size: 13x14 +// Box: 13 15 -1 -3 +// Ascent: 11 +// First character: 0 +// Default character: 0 +// Characters: 256 +// Copyright: "Copyright (c) 1984, 1987 Adobe Systems Incorporated. All Rights Reserved. Copyright (c) 1988, 1991 Digital Equipment Corporation. All Rights Reserved." namespace Graphics { -/* Font character bitmap data. */ -static const bitmap_t _font_bits[] = { - -/* Character 32 (0x20): - width 12 - bbx ( 1, 1, 0, 0 ) - - +-+ - | | - +-+ -*/ -0x0000, - -/* Character 33 (0x21): - width 8 - bbx ( 2, 9, 1, 0 ) - - +--+ - |**| - |**| - |**| - |**| - |**| - |* | - | | - |**| - |**| - +--+ -*/ -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0x8000, -0x0000, -0xc000, -0xc000, - -/* Character 34 (0x22): - width 9 - bbx ( 3, 3, 1, 6 ) - - +---+ - |* *| - |* *| - |* *| - +---+ -*/ -0xa000, -0xa000, -0xa000, - -/* Character 35 (0x23): - width 8 - bbx ( 7, 8, 0, 0 ) - - +-------+ - | * * | - | * * | - | ******| - | * * | - | * * | - |****** | - | * * | - | * * | - +-------+ -*/ -0x1400, -0x1400, -0x7e00, -0x2800, -0x2800, -0xfc00, -0x5000, -0x5000, - -/* Character 36 (0x24): - width 9 - bbx ( 6, 11, 0, -2 ) - - +------+ - | * | - | **** | - |** * *| - |** * | - | **** | - | ***| - |* * *| - |** * *| - | **** | - | * | - | * | - +------+ -*/ -0x1000, -0x7800, -0xd400, -0xd000, -0x7800, -0x1c00, -0x9400, -0xd400, -0x7800, -0x1000, -0x1000, - -/* Character 37 (0x25): - width 8 - bbx ( 11, 9, 0, 0 ) - - +-----------+ - | *** * | - |** ** ** | - |** ** * | - | *** * | - | * | - | * *** | - | * ** **| - | ** ** **| - | * *** | - +-----------+ -*/ -0x7100, -0xdb00, -0xda00, -0x7400, -0x0400, -0x09c0, -0x0b60, -0x1b60, -0x11c0, - -/* Character 38 (0x26): - width 7 - bbx ( 9, 9, 0, 0 ) - - +---------+ - | *** | - | ** ** | - | ** ** | - | *** | - | **** * | - |** **** | - |** ** | - |** **** | - | **** **| - +---------+ -*/ -0x3800, -0x6c00, -0x6c00, -0x3800, -0x7900, -0xcf00, -0xc600, -0xcf00, -0x7980, - -/* Character 39 (0x27): - width 10 - bbx ( 1, 3, 1, 6 ) - - +-+ - |*| - |*| - |*| - +-+ -*/ -0x8000, -0x8000, -0x8000, - -/* Character 40 (0x28): - width 9 - bbx ( 4, 12, 1, -3 ) - - +----+ - | **| - | ** | - | ** | - |** | - |** | - |** | - |** | - |** | - |** | - | ** | - | ** | - | **| - +----+ -*/ -0x3000, -0x6000, -0x6000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0x6000, -0x6000, -0x3000, - -/* Character 41 (0x29): - width 4 - bbx ( 4, 12, 1, -3 ) - - +----+ - |** | - | ** | - | ** | - | **| - | **| - | **| - | **| - | **| - | **| - | ** | - | ** | - |** | - +----+ -*/ -0xc000, -0x6000, -0x6000, -0x3000, -0x3000, -0x3000, -0x3000, -0x3000, -0x3000, -0x6000, -0x6000, -0xc000, - -/* Character 42 (0x2a): - width 7 - bbx ( 5, 4, 0, 5 ) - - +-----+ - | * | - |*****| - | *** | - | * * | - +-----+ -*/ -0x2000, -0xf800, -0x7000, -0x5000, - -/* Character 43 (0x2b): - width 9 - bbx ( 6, 5, 0, 1 ) - - +------+ - | ** | - | ** | - |******| - | ** | - | ** | - +------+ -*/ -0x3000, -0x3000, -0xfc00, -0x3000, -0x3000, - -/* Character 44 (0x2c): - width 7 - bbx ( 2, 4, 1, -2 ) - - +--+ - |**| - |**| - | *| - |* | - +--+ -*/ -0xc000, -0xc000, -0x4000, -0x8000, - -/* Character 45 (0x2d): - width 11 - bbx ( 4, 1, 0, 3 ) - - +----+ - |****| - +----+ -*/ -0xf000, - -/* Character 46 (0x2e): - width 9 - bbx ( 2, 2, 1, 0 ) - - +--+ - |**| - |**| - +--+ -*/ -0xc000, -0xc000, - -/* Character 47 (0x2f): - width 10 - bbx ( 4, 9, 0, 0 ) - - +----+ - | **| - | **| - | * | - | ** | - | ** | - | * | - | * | - |** | - |** | - +----+ -*/ -0x3000, -0x3000, -0x2000, -0x6000, -0x6000, -0x4000, -0x4000, -0xc000, -0xc000, - -/* Character 48 (0x30): - width 8 - bbx ( 6, 9, 0, 0 ) - - +------+ - | **** | - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 49 (0x31): - width 10 - bbx ( 4, 9, 0, 0 ) - - +----+ - | **| - |****| - | **| - | **| - | **| - | **| - | **| - | **| - | **| - +----+ -*/ -0x3000, -0xf000, -0x3000, -0x3000, -0x3000, -0x3000, -0x3000, -0x3000, -0x3000, - -/* Character 50 (0x32): - width 9 - bbx ( 6, 9, 0, 0 ) - - +------+ - | **** | - |** **| - | **| - | ** | - | ** | - | ** | - |** | - |** | - |******| - +------+ -*/ -0x7800, -0xcc00, -0x0c00, -0x1800, -0x3000, -0x6000, -0xc000, -0xc000, -0xfc00, - -/* Character 51 (0x33): - width 9 - bbx ( 6, 9, 0, 0 ) - - +------+ - | **** | - |** **| - | **| - | *** | - | **| - | **| - | **| - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0x0c00, -0x3800, -0x0c00, -0x0c00, -0x0c00, -0xcc00, -0x7800, - -/* Character 52 (0x34): - width 8 - bbx ( 7, 9, 0, 0 ) - - +-------+ - | ** | - | *** | - | * ** | - | * ** | - | * ** | - |* ** | - |*******| - | ** | - | ** | - +-------+ -*/ -0x0c00, -0x1c00, -0x2c00, -0x2c00, -0x4c00, -0x8c00, -0xfe00, -0x0c00, -0x0c00, - -/* Character 53 (0x35): - width 9 - bbx ( 6, 9, 0, 0 ) - - +------+ - | *****| - | ** | - |** | - |***** | - | **| - | **| - |** **| - |** **| - | **** | - +------+ -*/ -0x7c00, -0x6000, -0xc000, -0xf800, -0x0c00, -0x0c00, -0xcc00, -0xcc00, -0x7800, - -/* Character 54 (0x36): - width 8 - bbx ( 6, 9, 0, 0 ) - - +------+ - | **** | - |** **| - |** | - |** | - |***** | - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0xc000, -0xc000, -0xf800, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 55 (0x37): - width 10 - bbx ( 6, 9, 0, 0 ) - - +------+ - |******| - | **| - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - +------+ -*/ -0xfc00, -0x0c00, -0x1800, -0x1800, -0x3000, -0x3000, -0x3000, -0x6000, -0x6000, - -/* Character 56 (0x38): - width 8 - bbx ( 6, 9, 0, 0 ) - - +------+ - | **** | - |** **| - |** **| - | **** | - |** **| - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0xcc00, -0x7800, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 57 (0x39): - width 8 - bbx ( 6, 9, 0, 0 ) - - +------+ - | **** | - |** **| - |** **| - |** **| - | *****| - | **| - | **| - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0xcc00, -0xcc00, -0x7c00, -0x0c00, -0x0c00, -0xcc00, -0x7800, - -/* Character 58 (0x3a): - width 7 - bbx ( 2, 7, 1, 0 ) - - +--+ - |**| - |**| - | | - | | - | | - |**| - |**| - +--+ -*/ -0xc000, -0xc000, -0x0000, -0x0000, -0x0000, -0xc000, -0xc000, - -/* Character 59 (0x3b): - width 4 - bbx ( 2, 9, 1, -2 ) - - +--+ - |**| - |**| - | | - | | - | | - |**| - |**| - | *| - |* | - +--+ -*/ -0xc000, -0xc000, -0x0000, -0x0000, -0x0000, -0xc000, -0xc000, -0x4000, -0x8000, - -/* Character 60 (0x3c): - width 4 - bbx ( 5, 5, 1, 1 ) - - +-----+ - | **| - | *** | - |** | - | *** | - | **| - +-----+ -*/ -0x1800, -0x7000, -0xc000, -0x7000, -0x1800, - -/* Character 61 (0x3d): - width 4 - bbx ( 6, 3, 0, 2 ) - - +------+ - |******| - | | - |******| - +------+ -*/ -0xfc00, -0x0000, -0xfc00, - -/* Character 62 (0x3e): - width 7 - bbx ( 5, 5, 1, 1 ) - - +-----+ - |** | - | *** | - | **| - | *** | - |** | - +-----+ -*/ -0xc000, -0x7000, -0x1800, -0x7000, -0xc000, - -/* Character 63 (0x3f): - width 7 - bbx ( 6, 9, 1, 0 ) - - +------+ - | **** | - |** **| - |** **| - | ** | - | ** | - | ** | - | | - | ** | - | ** | - +------+ -*/ -0x7800, -0xcc00, -0xcc00, -0x1800, -0x3000, -0x3000, -0x0000, -0x3000, -0x3000, - -/* Character 64 (0x40): - width 4 - bbx ( 10, 10, 1, -1 ) - - +----------+ - | ***** | - | ** * | - | * *| - |* ** * *| - |* * * *| - |* * * *| - |* * ** * | - |* ** ** | - | * | - | ***** | - +----------+ -*/ -0x1f00, -0x6080, -0x4040, -0x8d40, -0x9240, -0xa240, -0xa680, -0x9b00, -0x4000, -0x3e00, - -/* Character 65 (0x41): - width 7 - bbx ( 8, 9, 0, 0 ) - - +--------+ - | ** | - | **** | - | * * | - | ** ** | - | ** ** | - | ****** | - |** **| - |** **| - |** **| - +--------+ -*/ -0x1800, -0x3c00, -0x2400, -0x6600, -0x6600, -0x7e00, -0xc300, -0xc300, -0xc300, - -/* Character 66 (0x42): - width 7 - bbx ( 7, 9, 1, 0 ) - - +-------+ - |****** | - |** **| - |** **| - |** **| - |****** | - |** **| - |** **| - |** **| - |****** | - +-------+ -*/ -0xfc00, -0xc600, -0xc600, -0xc600, -0xfc00, -0xc600, -0xc600, -0xc600, -0xfc00, - -/* Character 67 (0x43): - width 7 - bbx ( 7, 9, 1, 0 ) - - +-------+ - | **** | - | ** **| - |** | - |** | - |** | - |** | - |** | - | ** **| - | **** | - +-------+ -*/ -0x3c00, -0x6600, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0x6600, -0x3c00, - -/* Character 68 (0x44): - width 7 - bbx ( 7, 9, 1, 0 ) - - +-------+ - |***** | - |** ** | - |** **| - |** **| - |** **| - |** **| - |** **| - |** ** | - |***** | - +-------+ -*/ -0xf800, -0xcc00, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xcc00, -0xf800, - -/* Character 69 (0x45): - width 7 - bbx ( 6, 9, 1, 0 ) - - +------+ - |******| - |** | - |** | - |** | - |******| - |** | - |** | - |** | - |******| - +------+ -*/ -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, - -/* Character 70 (0x46): - width 5 - bbx ( 6, 9, 1, 0 ) - - +------+ - |******| - |** | - |** | - |** | - |***** | - |** | - |** | - |** | - |** | - +------+ -*/ -0xfc00, -0xc000, -0xc000, -0xc000, -0xf800, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 71 (0x47): - width 7 - bbx ( 8, 9, 1, 0 ) - - +--------+ - | ***** | - | ** **| - |** | - |** | - |** ****| - |** **| - |** **| - | ** **| - | **** *| - +--------+ -*/ -0x3e00, -0x6300, -0xc000, -0xc000, -0xcf00, -0xc300, -0xc300, -0x6300, -0x3d00, - -/* Character 72 (0x48): - width 7 - bbx ( 7, 9, 1, 0 ) - - +-------+ - |** **| - |** **| - |** **| - |** **| - |*******| - |** **| - |** **| - |** **| - |** **| - +-------+ -*/ -0xc600, -0xc600, -0xc600, -0xc600, -0xfe00, -0xc600, -0xc600, -0xc600, -0xc600, - -/* Character 73 (0x49): - width 3 - bbx ( 2, 9, 1, 0 ) - - +--+ - |**| - |**| - |**| - |**| - |**| - |**| - |**| - |**| - |**| - +--+ -*/ -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 74 (0x4a): - width 3 - bbx ( 6, 9, 0, 0 ) - - +------+ - | **| - | **| - | **| - | **| - | **| - | **| - |** **| - |** **| - | **** | - +------+ -*/ -0x0c00, -0x0c00, -0x0c00, -0x0c00, -0x0c00, -0x0c00, -0xcc00, -0xcc00, -0x7800, - -/* Character 75 (0x4b): - width 7 - bbx ( 8, 9, 1, 0 ) - - +--------+ - |** ** | - |** ** | - |** ** | - |**** | - |**** | - |** ** | - |** ** | - |** ** | - |** **| - +--------+ -*/ -0xc600, -0xcc00, -0xd800, -0xf000, -0xf000, -0xd800, -0xcc00, -0xc600, -0xc300, - -/* Character 76 (0x4c): - width 3 - bbx ( 6, 9, 1, 0 ) - - +------+ - |** | - |** | - |** | - |** | - |** | - |** | - |** | - |** | - |******| - +------+ -*/ -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xfc00, - -/* Character 77 (0x4d): - width 11 - bbx ( 9, 9, 1, 0 ) - - +---------+ - |** **| - |** **| - |*** ***| - |*** ***| - |**** ****| - |** * * **| - |** *** **| - |** * **| - |** * **| - +---------+ -*/ -0xc180, -0xc180, -0xe380, -0xe380, -0xf780, -0xd580, -0xdd80, -0xc980, -0xc980, - -/* Character 78 (0x4e): - width 7 - bbx ( 7, 9, 1, 0 ) - - +-------+ - |** **| - |*** **| - |*** **| - |** * **| - |** * **| - |** ***| - |** ***| - |** **| - |** **| - +-------+ -*/ -0xc600, -0xe600, -0xe600, -0xd600, -0xd600, -0xce00, -0xce00, -0xc600, -0xc600, - -/* Character 79 (0x4f): - width 7 - bbx ( 8, 9, 1, 0 ) - - +--------+ - | **** | - | ** ** | - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | **** | - +--------+ -*/ -0x3c00, -0x6600, -0xc300, -0xc300, -0xc300, -0xc300, -0xc300, -0x6600, -0x3c00, - -/* Character 80 (0x50): - width 7 - bbx ( 7, 9, 1, 0 ) - - +-------+ - |****** | - |** **| - |** **| - |** **| - |****** | - |** | - |** | - |** | - |** | - +-------+ -*/ -0xfc00, -0xc600, -0xc600, -0xc600, -0xfc00, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 81 (0x51): - width 7 - bbx ( 8, 9, 1, 0 ) - - +--------+ - | **** | - | ** ** | - |** **| - |** **| - |** **| - |** * **| - |** ****| - | ** ** | - | ******| - +--------+ -*/ -0x3c00, -0x6600, -0xc300, -0xc300, -0xc300, -0xcb00, -0xcf00, -0x6600, -0x3f00, - -/* Character 82 (0x52): - width 5 - bbx ( 7, 9, 1, 0 ) - - +-------+ - |****** | - |** **| - |** **| - |** **| - |****** | - |** ** | - |** **| - |** **| - |** **| - +-------+ -*/ -0xfc00, -0xc600, -0xc600, -0xc600, -0xfc00, -0xcc00, -0xc600, -0xc600, -0xc600, - -/* Character 83 (0x53): - width 7 - bbx ( 7, 9, 1, 0 ) - - +-------+ - | ***** | - |** **| - |** **| - | *** | - | *** | - | ***| - |** **| - |** **| - | ***** | - +-------+ -*/ -0x7c00, -0xc600, -0xc600, -0x7000, -0x1c00, -0x0e00, -0xc600, -0xc600, -0x7c00, - -/* Character 84 (0x54): - width 5 - bbx ( 8, 9, 0, 0 ) - - +--------+ - |********| - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - +--------+ -*/ -0xff00, -0x1800, -0x1800, -0x1800, -0x1800, -0x1800, -0x1800, -0x1800, -0x1800, - -/* Character 85 (0x55): - width 7 - bbx ( 7, 9, 1, 0 ) - - +-------+ - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | ***** | - +-------+ -*/ -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0x6c00, -0x7c00, - -/* Character 86 (0x56): - width 8 - bbx ( 8, 9, 0, 0 ) - - +--------+ - |** **| - |** **| - | ** ** | - | ** ** | - | ** ** | - | * * | - | **** | - | ** | - | ** | - +--------+ -*/ -0xc300, -0xc300, -0x6600, -0x6600, -0x6600, -0x2400, -0x3c00, -0x1800, -0x1800, - -/* Character 87 (0x57): - width 11 - bbx ( 10, 9, 0, 0 ) - - +----------+ - |** ** **| - |** ** **| - |** ** **| - | * ** * | - | ** ** ** | - | ** ** ** | - | ** ** | - | ** ** | - | ** ** | - +----------+ -*/ -0xccc0, -0xccc0, -0xccc0, -0x4c80, -0x6d80, -0x6d80, -0x3300, -0x3300, -0x3300, - -/* Character 88 (0x58): - width 7 - bbx ( 8, 9, 0, 0 ) - - +--------+ - |** **| - |** **| - | ** ** | - | **** | - | ** | - | **** | - | ** ** | - |** **| - |** **| - +--------+ -*/ -0xc300, -0xc300, -0x6600, -0x3c00, -0x1800, -0x3c00, -0x6600, -0xc300, -0xc300, - -/* Character 89 (0x59): - width 8 - bbx ( 8, 9, 0, 0 ) - - +--------+ - |** **| - |** **| - | ** ** | - | ** ** | - | **** | - | ** | - | ** | - | ** | - | ** | - +--------+ -*/ -0xc300, -0xc300, -0x6600, -0x6600, -0x3c00, -0x1800, -0x1800, -0x1800, -0x1800, - -/* Character 90 (0x5a): - width 6 - bbx ( 7, 9, 0, 0 ) - - +-------+ - |*******| - | **| - | ** | - | ** | - | ** | - | ** | - | ** | - |** | - |*******| - +-------+ -*/ -0xfe00, -0x0600, -0x0c00, -0x1800, -0x3000, -0x3000, -0x6000, -0xc000, -0xfe00, - -/* Character 91 (0x5b): - width 5 - bbx ( 3, 12, 1, -3 ) - - +---+ - |***| - |** | - |** | - |** | - |** | - |** | - |** | - |** | - |** | - |** | - |** | - |***| - +---+ -*/ -0xe000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xe000, - -/* Character 92 (0x5c): - width 4 - bbx ( 4, 9, 0, 0 ) - - +----+ - |** | - |** | - | * | - | ** | - | ** | - | * | - | * | - | **| - | **| - +----+ -*/ -0xc000, -0xc000, -0x4000, -0x6000, -0x6000, -0x2000, -0x2000, -0x3000, -0x3000, - -/* Character 93 (0x5d): - width 5 - bbx ( 3, 12, 0, -3 ) - - +---+ - |***| - | **| - | **| - | **| - | **| - | **| - | **| - | **| - | **| - | **| - | **| - |***| - +---+ -*/ -0xe000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0xe000, - -/* Character 94 (0x5e): - width 7 - bbx ( 7, 4, 0, 5 ) - - +-------+ - | * | - | *** | - | ** ** | - |** **| - +-------+ -*/ -0x1000, -0x3800, -0x6c00, -0xc600, - -/* Character 95 (0x5f): - width 4 - bbx ( 7, 1, 0, -3 ) - - +-------+ - |*******| - +-------+ -*/ -0xfe00, - -/* Character 96 (0x60): - width 4 - bbx ( 3, 2, 0, 8 ) - - +---+ - |** | - | **| - +---+ -*/ -0xc000, -0x6000, - -/* Character 97 (0x61): - width 4 - bbx ( 7, 7, 0, 0 ) - - +-------+ - | **** | - |** ** | - | ** | - | ***** | - |** ** | - |** ** | - | *** **| - +-------+ -*/ -0x7800, -0xcc00, -0x0c00, -0x7c00, -0xcc00, -0xcc00, -0x7600, - -/* Character 98 (0x62): - width 4 - bbx ( 6, 9, 0, 0 ) - - +------+ - |** | - |** | - |** ** | - |*** **| - |** **| - |** **| - |** **| - |*** **| - |** ** | - +------+ -*/ -0xc000, -0xc000, -0xd800, -0xec00, -0xcc00, -0xcc00, -0xcc00, -0xec00, -0xd800, - -/* Character 99 (0x63): - width 4 - bbx ( 6, 7, 0, 0 ) - - +------+ - | **** | - |** **| - |** | - |** | - |** | - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0xc000, -0xc000, -0xc000, -0xcc00, -0x7800, - -/* Character 100 (0x64): - width 4 - bbx ( 6, 9, 0, 0 ) - - +------+ - | **| - | **| - | ** **| - |** ***| - |** **| - |** **| - |** **| - |** ***| - | ** **| - +------+ -*/ -0x0c00, -0x0c00, -0x6c00, -0xdc00, -0xcc00, -0xcc00, -0xcc00, -0xdc00, -0x6c00, - -/* Character 101 (0x65): - width 4 - bbx ( 6, 7, 0, 0 ) - - +------+ - | **** | - |** **| - |** **| - |******| - |** | - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0xcc00, -0xfc00, -0xc000, -0xcc00, -0x7800, - -/* Character 102 (0x66): - width 4 - bbx ( 5, 9, 0, 0 ) - - +-----+ - | ***| - | ** | - |**** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - +-----+ -*/ -0x3800, -0x6000, -0xf000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, - -/* Character 103 (0x67): - width 4 - bbx ( 6, 10, 0, -3 ) - - +------+ - | ** **| - |** ***| - |** **| - |** **| - |** **| - |** ***| - | ** **| - | **| - |** **| - | **** | - +------+ -*/ -0x6c00, -0xdc00, -0xcc00, -0xcc00, -0xcc00, -0xdc00, -0x6c00, -0x0c00, -0xcc00, -0x7800, - -/* Character 104 (0x68): - width 4 - bbx ( 6, 9, 0, 0 ) - - +------+ - |** | - |** | - |** ** | - |*** **| - |** **| - |** **| - |** **| - |** **| - |** **| - +------+ -*/ -0xc000, -0xc000, -0xd800, -0xec00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, - -/* Character 105 (0x69): - width 4 - bbx ( 2, 9, 0, 0 ) - - +--+ - |**| - | | - |**| - |**| - |**| - |**| - |**| - |**| - |**| - +--+ -*/ -0xc000, -0x0000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 106 (0x6a): - width 4 - bbx ( 3, 12, -1, -3 ) - - +---+ - | **| - | | - | **| - | **| - | **| - | **| - | **| - | **| - | **| - | **| - | **| - |** | - +---+ -*/ -0x6000, -0x0000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0xc000, - -/* Character 107 (0x6b): - width 4 - bbx ( 7, 9, 0, 0 ) - - +-------+ - |** | - |** | - |** ** | - |** ** | - |**** | - |**** | - |** ** | - |** ** | - |** **| - +-------+ -*/ -0xc000, -0xc000, -0xcc00, -0xd800, -0xf000, -0xf000, -0xd800, -0xcc00, -0xc600, - -/* Character 108 (0x6c): - width 4 - bbx ( 2, 9, 0, 0 ) - - +--+ - |**| - |**| - |**| - |**| - |**| - |**| - |**| - |**| - |**| - +--+ -*/ -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 109 (0x6d): - width 4 - bbx ( 10, 7, 0, 0 ) - - +----------+ - |* *** *** | - |** ** **| - |** ** **| - |** ** **| - |** ** **| - |** ** **| - |** ** **| - +----------+ -*/ -0xbb80, -0xccc0, -0xccc0, -0xccc0, -0xccc0, -0xccc0, -0xccc0, - -/* Character 110 (0x6e): - width 4 - bbx ( 6, 7, 0, 0 ) - - +------+ - |** ** | - |*** **| - |** **| - |** **| - |** **| - |** **| - |** **| - +------+ -*/ -0xd800, -0xec00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, - -/* Character 111 (0x6f): - width 4 - bbx ( 6, 7, 0, 0 ) - - +------+ - | **** | - |** **| - |** **| - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 112 (0x70): - width 4 - bbx ( 6, 10, 0, -3 ) - - +------+ - |** ** | - |*** **| - |** **| - |** **| - |** **| - |*** **| - |** ** | - |** | - |** | - |** | - +------+ -*/ -0xd800, -0xec00, -0xcc00, -0xcc00, -0xcc00, -0xec00, -0xd800, -0xc000, -0xc000, -0xc000, - -/* Character 113 (0x71): - width 4 - bbx ( 6, 10, 0, -3 ) - - +------+ - | *** *| - |** ***| - |** **| - |** **| - |** **| - |** ***| - | ** **| - | **| - | **| - | **| - +------+ -*/ -0x7400, -0xdc00, -0xcc00, -0xcc00, -0xcc00, -0xdc00, -0x6c00, -0x0c00, -0x0c00, -0x0c00, - -/* Character 114 (0x72): - width 4 - bbx ( 5, 7, 0, 0 ) - - +-----+ - |** **| - |*****| - |*** | - |** | - |** | - |** | - |** | - +-----+ -*/ -0xd800, -0xf800, -0xe000, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 115 (0x73): - width 4 - bbx ( 6, 7, 0, 0 ) - - +------+ - | **** | - |** **| - |*** | - | *** | - | ***| - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0xe000, -0x3800, -0x1c00, -0xcc00, -0x7800, - -/* Character 116 (0x74): - width 4 - bbx ( 5, 9, 0, 0 ) - - +-----+ - | ** | - | ** | - |**** | - | ** | - | ** | - | ** | - | ** | - | ** *| - | ** | - +-----+ -*/ -0x6000, -0x6000, -0xf000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6800, -0x3000, - -/* Character 117 (0x75): - width 4 - bbx ( 6, 7, 0, 0 ) - - +------+ - |** **| - |** **| - |** **| - |** **| - |** **| - |** ***| - | ** **| - +------+ -*/ -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xdc00, -0x6c00, - -/* Character 118 (0x76): - width 4 - bbx ( 7, 7, 0, 0 ) - - +-------+ - |** **| - |** **| - | ** ** | - | ** ** | - | *** | - | *** | - | * | - +-------+ -*/ -0xc600, -0xc600, -0x6c00, -0x6c00, -0x3800, -0x3800, -0x1000, - -/* Character 119 (0x77): - width 4 - bbx ( 10, 7, 0, 0 ) - - +----------+ - |** ** **| - |** ** **| - | ** ** ** | - | ** ** ** | - | ** ** ** | - | ** ** | - | ** ** | - +----------+ -*/ -0xccc0, -0xccc0, -0x6d80, -0x6d80, -0x6d80, -0x3300, -0x3300, - -/* Character 120 (0x78): - width 4 - bbx ( 6, 7, 0, 0 ) - - +------+ - |** **| - |** **| - | **** | - | ** | - | **** | - |** **| - |** **| - +------+ -*/ -0xcc00, -0xcc00, -0x7800, -0x3000, -0x7800, -0xcc00, -0xcc00, - -/* Character 121 (0x79): - width 4 - bbx ( 7, 10, 0, -3 ) - - +-------+ - |** **| - |** **| - | ** ** | - | ** ** | - | *** | - | *** | - | ** | - | * | - | ** | - | ** | - +-------+ -*/ -0xc600, -0xc600, -0x6c00, -0x6c00, -0x3800, -0x3800, -0x1800, -0x1000, -0x3000, -0x6000, - -/* Character 122 (0x7a): - width 4 - bbx ( 5, 7, 0, 0 ) - - +-----+ - |*****| - | **| - | ** | - | * | - | ** | - |** | - |*****| - +-----+ -*/ -0xf800, -0x1800, -0x3000, -0x2000, -0x6000, -0xc000, -0xf800, - -/* Character 123 (0x7b): - width 4 - bbx ( 4, 12, 0, -3 ) - - +----+ - | **| - | ** | - | ** | - | ** | - | ** | - |** | - | ** | - | ** | - | ** | - | ** | - | ** | - | **| - +----+ -*/ -0x3000, -0x6000, -0x6000, -0x6000, -0x6000, -0xc000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x3000, - -/* Character 124 (0x7c): - width 4 - bbx ( 2, 12, 1, -3 ) - - +--+ - |**| - |**| - |**| - |**| - |**| - |**| - |**| - |**| - |**| - |**| - |**| - |**| - +--+ -*/ -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 125 (0x7d): - width 4 - bbx ( 4, 12, 0, -3 ) - - +----+ - |** | - | ** | - | ** | - | ** | - | ** | - | **| - | ** | - | ** | - | ** | - | ** | - | ** | - |** | - +----+ -*/ -0xc000, -0x6000, -0x6000, -0x6000, -0x6000, -0x3000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0xc000, - -/* Character 126 (0x7e): - width 4 - bbx ( 7, 2, 0, 3 ) - - +-------+ - | *** **| - |** *** | - +-------+ -*/ -0x7600, -0xdc00, - -/* Character 160 (0xa0): - width 8 - bbx ( 1, 1, 0, 0 ) - - +-+ - | | - +-+ -*/ -0x0000, - -/* Character 161 (0xa1): - width 8 - bbx ( 2, 10, 1, -3 ) - - +--+ - |**| - |**| - | | - | *| - |**| - |**| - |**| - |**| - |**| - |**| - +--+ -*/ -0xc000, -0xc000, -0x0000, -0x4000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 162 (0xa2): - width 8 - bbx ( 6, 9, 0, -1 ) - - +------+ - | * | - | **** | - |** ***| - |* * | - |* * | - |* * | - |*** **| - | **** | - | * | - +------+ -*/ -0x1000, -0x7800, -0xdc00, -0x9000, -0xa000, -0xa000, -0xec00, -0x7800, -0x4000, - -/* Character 163 (0xa3): - width 8 - bbx ( 6, 9, 0, 0 ) - - +------+ - | *** | - | ** **| - | ** | - | ** | - |***** | - | ** | - | ** | - |*** **| - |** ** | - +------+ -*/ -0x3800, -0x6c00, -0x6000, -0x6000, -0xf800, -0x6000, -0x6000, -0xec00, -0xd800, - -/* Character 164 (0xa4): - width 8 - bbx ( 6, 6, 0, 1 ) - - +------+ - |** **| - | **** | - | * * | - | * * | - | **** | - |** **| - +------+ -*/ -0xcc00, -0x7800, -0x4800, -0x4800, -0x7800, -0xcc00, - -/* Character 165 (0xa5): - width 8 - bbx ( 6, 9, 0, 0 ) - - +------+ - |** **| - |** **| - | * * | - |******| - | ** | - |******| - | ** | - | ** | - | ** | - +------+ -*/ -0xcc00, -0xcc00, -0x4800, -0xfc00, -0x3000, -0xfc00, -0x3000, -0x3000, -0x3000, - -/* Character 166 (0xa6): - width 13 - bbx ( 2, 11, 1, -2 ) - - +--+ - |**| - |**| - |**| - |**| - | | - | | - |**| - |**| - |**| - |**| - |**| - +--+ -*/ -0xc000, -0xc000, -0xc000, -0xc000, -0x0000, -0x0000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 167 (0xa7): - width 8 - bbx ( 6, 12, 0, -3 ) - - +------+ - | **** | - |** **| - |*** | - | *** | - |** ** | - |** **| - |** **| - | ** **| - | *** | - | ***| - |** **| - | **** | - +------+ -*/ -0x7800, -0xcc00, -0xe000, -0x7000, -0xd800, -0xcc00, -0xcc00, -0x6c00, -0x3800, -0x1c00, -0xcc00, -0x7800, - -/* Character 168 (0xa8): - width 8 - bbx ( 5, 1, 0, 8 ) - - +-----+ - |** **| - +-----+ -*/ -0xd800, - -/* Character 169 (0xa9): - width 8 - bbx ( 9, 9, 1, 0 ) - - +---------+ - | ***** | - | * * | - |* *** *| - |* * * *| - |* * *| - |* * * *| - |* *** *| - | * * | - | ***** | - +---------+ -*/ -0x3e00, -0x4100, -0x9c80, -0xa280, -0xa080, -0xa280, -0x9c80, -0x4100, -0x3e00, - -/* Character 170 (0xaa): - width 8 - bbx ( 4, 6, 1, 3 ) - - +----+ - |*** | - | **| - |****| - |* **| - | | - |****| - +----+ -*/ -0xe000, -0x3000, -0xf000, -0xb000, -0x0000, -0xf000, - -/* Character 171 (0xab): - width 8 - bbx ( 6, 5, 1, 1 ) - - +------+ - | * *| - | ** **| - |** ** | - | ** **| - | * *| - +------+ -*/ -0x2400, -0x6c00, -0xd800, -0x6c00, -0x2400, - -/* Character 172 (0xac): - width 4 - bbx ( 6, 4, 1, 2 ) - - +------+ - |******| - | *| - | *| - | *| - +------+ -*/ -0xfc00, -0x0400, -0x0400, -0x0400, - -/* Character 173 (0xad): - width 4 - bbx ( 4, 1, 0, 3 ) - - +----+ - |****| - +----+ -*/ -0xf000, - -/* Character 174 (0xae): - width 4 - bbx ( 9, 9, 1, 0 ) - - +---------+ - | ***** | - | * * | - |* *** *| - |* * * *| - |* ** *| - |* * * *| - |* * * *| - | * * | - | ***** | - +---------+ -*/ -0x3e00, -0x4100, -0x9c80, -0x9480, -0x9880, -0x9480, -0x9480, -0x4100, -0x3e00, - -/* Character 175 (0xaf): - width 4 - bbx ( 4, 1, 0, 8 ) - - +----+ - |****| - +----+ -*/ -0xf000, - -/* Character 176 (0xb0): - width 9 - bbx ( 4, 4, 0, 4 ) - - +----+ - | ** | - |* *| - |* *| - | ** | - +----+ -*/ -0x6000, -0x9000, -0x9000, -0x6000, - -/* Character 177 (0xb1): - width 9 - bbx ( 6, 7, 0, 0 ) - - +------+ - | ** | - | ** | - |******| - | ** | - | ** | - | | - |******| - +------+ -*/ -0x3000, -0x3000, -0xfc00, -0x3000, -0x3000, -0x0000, -0xfc00, - -/* Character 178 (0xb2): - width 10 - bbx ( 4, 5, 0, 4 ) - - +----+ - | ** | - |* **| - | ** | - |** | - |****| - +----+ -*/ -0x6000, -0xb000, -0x6000, -0xc000, -0xf000, - -/* Character 179 (0xb3): - width 10 - bbx ( 4, 5, 0, 4 ) - - +----+ - | ** | - |* **| - | ** | - | **| - |*** | - +----+ -*/ -0x6000, -0xb000, -0x6000, -0x3000, -0xe000, - -/* Character 180 (0xb4): - width 10 - bbx ( 3, 2, 0, 8 ) - - +---+ - | **| - |** | - +---+ -*/ -0x6000, -0xc000, - -/* Character 181 (0xb5): - width 10 - bbx ( 6, 10, 0, -3 ) - - +------+ - |** **| - |** **| - |** **| - |** **| - |** **| - |** ***| - |*** **| - |** | - |** | - |** | - +------+ -*/ -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xdc00, -0xec00, -0xc000, -0xc000, -0xc000, - -/* Character 182 (0xb6): - width 10 - bbx ( 7, 12, 0, -3 ) - - +-------+ - | *****| - | *** * | - |**** * | - |**** * | - |**** * | - | *** * | - | ** * | - | * * | - | * * | - | * * | - | * * | - | * * | - +-------+ -*/ -0x3e00, -0x7400, -0xf400, -0xf400, -0xf400, -0x7400, -0x3400, -0x1400, -0x1400, -0x1400, -0x1400, -0x1400, - -/* Character 183 (0xb7): - width 7 - bbx ( 2, 2, 1, 3 ) - - +--+ - |**| - |**| - +--+ -*/ -0xc000, -0xc000, - -/* Character 184 (0xb8): - width 10 - bbx ( 4, 4, 0, -3 ) - - +----+ - | ** | - | **| - | **| - |*** | - +----+ -*/ -0x6000, -0x3000, -0x3000, -0xe000, - -/* Character 185 (0xb9): - width 9 - bbx ( 3, 5, 0, 4 ) - - +---+ - | **| - |***| - | **| - | **| - | **| - +---+ -*/ -0x6000, -0xe000, -0x6000, -0x6000, -0x6000, - -/* Character 186 (0xba): - width 9 - bbx ( 4, 6, 1, 3 ) - - +----+ - | ** | - |** *| - |** *| - | ** | - | | - |****| - +----+ -*/ -0x6000, -0xd000, -0xd000, -0x6000, -0x0000, -0xf000, - -/* Character 187 (0xbb): - width 9 - bbx ( 6, 5, 1, 1 ) - - +------+ - |* * | - |** ** | - | ** **| - |** ** | - |* * | - +------+ -*/ -0x9000, -0xd800, -0x6c00, -0xd800, -0x9000, - -/* Character 188 (0xbc): - width 9 - bbx ( 10, 9, 0, 0 ) - - +----------+ - | ** ** | - |*** ** | - | ** ** | - | ** ** | - | ** ** ** | - | * *** | - | ** * * | - | ** *****| - | ** ** | - +----------+ -*/ -0x6300, -0xe600, -0x6600, -0x6c00, -0x6d80, -0x0b80, -0x1a80, -0x37c0, -0x3180, - -/* Character 189 (0xbd): - width 8 - bbx ( 10, 9, 0, 0 ) - - +----------+ - | ** ** | - |*** ** | - | ** ** | - | ** ** | - | ** ** ** | - | * * **| - | ** ** | - | ** ** | - | ** ****| - +----------+ -*/ -0x6300, -0xe600, -0x6600, -0x6c00, -0x6d80, -0x0ac0, -0x1980, -0x3300, -0x33c0, - -/* Character 190 (0xbe): - width 8 - bbx ( 10, 9, 0, 0 ) - - +----------+ - | ** ** | - |* ** ** | - | ** ** | - | ** ** | - |*** ** ** | - | * *** | - | ** * * | - | ** *****| - | ** ** | - +----------+ -*/ -0x6300, -0xb300, -0x6600, -0x3600, -0xed80, -0x0b80, -0x1a80, -0x37c0, -0x3180, - -/* Character 191 (0xbf): - width 8 - bbx ( 6, 10, 1, -3 ) - - +------+ - | ** | - | ** | - | | - | ** | - | ** | - | ** | - | ** | - |** **| - |** **| - | **** | - +------+ -*/ -0x3000, -0x3000, -0x0000, -0x3000, -0x3000, -0x3000, -0x6000, -0xcc00, -0xcc00, -0x7800, - -/* Character 192 (0xc0): - width 7 - bbx ( 8, 12, 0, 0 ) - - +--------+ - | ** | - | ** | - | | - | ** | - | ** | - | **** | - | * * | - | ** ** | - | ****** | - |** **| - |** **| - |** **| - +--------+ -*/ -0x3000, -0x1800, -0x0000, -0x1800, -0x1800, -0x3c00, -0x2400, -0x6600, -0x7e00, -0xc300, -0xc300, -0xc300, - -/* Character 193 (0xc1): - width 7 - bbx ( 8, 12, 0, 0 ) - - +--------+ - | ** | - | ** | - | | - | ** | - | ** | - | **** | - | * * | - | ** ** | - | ****** | - |** **| - |** **| - |** **| - +--------+ -*/ -0x0c00, -0x1800, -0x0000, -0x1800, -0x1800, -0x3c00, -0x2400, -0x6600, -0x7e00, -0xc300, -0xc300, -0xc300, - -/* Character 194 (0xc2): - width 7 - bbx ( 8, 12, 0, 0 ) - - +--------+ - | *** | - | ** ** | - | | - | ** | - | ** | - | **** | - | * * | - | ** ** | - | ****** | - |** **| - |** **| - |** **| - +--------+ -*/ -0x1c00, -0x3600, -0x0000, -0x1800, -0x1800, -0x3c00, -0x2400, -0x6600, -0x7e00, -0xc300, -0xc300, -0xc300, - -/* Character 195 (0xc3): - width 7 - bbx ( 8, 12, 0, 0 ) - - +--------+ - | ** * | - | * ** | - | | - | ** | - | ** | - | **** | - | * * | - | ** ** | - | ****** | - |** **| - |** **| - |** **| - +--------+ -*/ -0x1a00, -0x2c00, -0x0000, -0x1800, -0x1800, -0x3c00, -0x2400, -0x6600, -0x7e00, -0xc300, -0xc300, -0xc300, - -/* Character 196 (0xc4): - width 7 - bbx ( 8, 11, 0, 0 ) - - +--------+ - | ** ** | - | | - | ** | - | ** | - | **** | - | * * | - | ** ** | - | ****** | - |** **| - |** **| - |** **| - +--------+ -*/ -0x3600, -0x0000, -0x1800, -0x1800, -0x3c00, -0x2400, -0x6600, -0x7e00, -0xc300, -0xc300, -0xc300, - -/* Character 197 (0xc5): - width 7 - bbx ( 8, 12, 0, 0 ) - - +--------+ - | ** | - | * * | - | ** | - | ** | - | ** | - | **** | - | * * | - | ** ** | - | ****** | - |** **| - |** **| - |** **| - +--------+ -*/ -0x1800, -0x2400, -0x1800, -0x1800, -0x1800, -0x3c00, -0x2400, -0x6600, -0x7e00, -0xc300, -0xc300, -0xc300, - -/* Character 198 (0xc6): - width 11 - bbx ( 11, 9, 1, 0 ) - - +-----------+ - | ********| - | ** ** | - | * ** | - | ** ** | - | ** ******| - | ****** | - |** ** | - |** ** | - |** ******| - +-----------+ -*/ -0x1fe0, -0x3600, -0x2600, -0x6600, -0x67e0, -0x7e00, -0xc600, -0xc600, -0xc7e0, - -/* Character 199 (0xc7): - width 7 - bbx ( 7, 12, 1, -3 ) - - +-------+ - | **** | - | ** **| - |** | - |** | - |** | - |** | - |** | - | ** **| - | **** | - | ** | - | ** | - | *** | - +-------+ -*/ -0x3c00, -0x6600, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0x6600, -0x3c00, -0x1800, -0x1800, -0x7000, - -/* Character 200 (0xc8): - width 7 - bbx ( 6, 12, 1, 0 ) - - +------+ - | ** | - | ** | - | | - |******| - |** | - |** | - |** | - |******| - |** | - |** | - |** | - |******| - +------+ -*/ -0x6000, -0x3000, -0x0000, -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, - -/* Character 201 (0xc9): - width 7 - bbx ( 6, 12, 1, 0 ) - - +------+ - | ** | - | ** | - | | - |******| - |** | - |** | - |** | - |******| - |** | - |** | - |** | - |******| - +------+ -*/ -0x1800, -0x3000, -0x0000, -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, - -/* Character 202 (0xca): - width 7 - bbx ( 6, 12, 1, 0 ) - - +------+ - | *** | - | ** **| - | | - |******| - |** | - |** | - |** | - |******| - |** | - |** | - |** | - |******| - +------+ -*/ -0x3800, -0x6c00, -0x0000, -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, - -/* Character 203 (0xcb): - width 7 - bbx ( 6, 11, 1, 0 ) - - +------+ - | ** **| - | | - |******| - |** | - |** | - |** | - |******| - |** | - |** | - |** | - |******| - +------+ -*/ -0x6c00, -0x0000, -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, -0xc000, -0xc000, -0xc000, -0xfc00, - -/* Character 204 (0xcc): - width 3 - bbx ( 3, 12, 0, 0 ) - - +---+ - |** | - | **| - | | - | **| - | **| - | **| - | **| - | **| - | **| - | **| - | **| - | **| - +---+ -*/ -0xc000, -0x6000, -0x0000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, - -/* Character 205 (0xcd): - width 3 - bbx ( 3, 12, 1, 0 ) - - +---+ - | **| - |** | - | | - |** | - |** | - |** | - |** | - |** | - |** | - |** | - |** | - |** | - +---+ -*/ -0x6000, -0xc000, -0x0000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 206 (0xce): - width 3 - bbx ( 5, 12, 0, 0 ) - - +-----+ - | *** | - |** **| - | | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - +-----+ -*/ -0x7000, -0xd800, -0x0000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, - -/* Character 207 (0xcf): - width 3 - bbx ( 5, 11, 0, 0 ) - - +-----+ - |** **| - | | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - +-----+ -*/ -0xd800, -0x0000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, - -/* Character 208 (0xd0): - width 7 - bbx ( 8, 9, 0, 0 ) - - +--------+ - | ***** | - | ** ** | - | ** **| - | ** **| - |**** **| - | ** **| - | ** **| - | ** ** | - | ***** | - +--------+ -*/ -0x7c00, -0x6600, -0x6300, -0x6300, -0xf300, -0x6300, -0x6300, -0x6600, -0x7c00, - -/* Character 209 (0xd1): - width 7 - bbx ( 7, 12, 1, 0 ) - - +-------+ - | ** * | - | * ** | - | | - |** **| - |** **| - |*** **| - |*** **| - |**** **| - |** ***| - |** ***| - |** **| - |** **| - +-------+ -*/ -0x3400, -0x5800, -0x0000, -0xc600, -0xc600, -0xe600, -0xe600, -0xf600, -0xce00, -0xce00, -0xc600, -0xc600, - -/* Character 210 (0xd2): - width 7 - bbx ( 8, 12, 1, 0 ) - - +--------+ - | ** | - | ** | - | | - | **** | - | ** ** | - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | **** | - +--------+ -*/ -0x3000, -0x1800, -0x0000, -0x3c00, -0x6600, -0xc300, -0xc300, -0xc300, -0xc300, -0xc300, -0x6600, -0x3c00, - -/* Character 211 (0xd3): - width 7 - bbx ( 8, 12, 1, 0 ) - - +--------+ - | ** | - | ** | - | | - | **** | - | ** ** | - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | **** | - +--------+ -*/ -0x0c00, -0x1800, -0x0000, -0x3c00, -0x6600, -0xc300, -0xc300, -0xc300, -0xc300, -0xc300, -0x6600, -0x3c00, - -/* Character 212 (0xd4): - width 7 - bbx ( 8, 12, 1, 0 ) - - +--------+ - | *** | - | ** ** | - | | - | **** | - | ** ** | - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | **** | - +--------+ -*/ -0x1c00, -0x3600, -0x0000, -0x3c00, -0x6600, -0xc300, -0xc300, -0xc300, -0xc300, -0xc300, -0x6600, -0x3c00, - -/* Character 213 (0xd5): - width 7 - bbx ( 8, 12, 1, 0 ) - - +--------+ - | ** * | - | * ** | - | | - | **** | - | ** ** | - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | **** | - +--------+ -*/ -0x1a00, -0x2c00, -0x0000, -0x3c00, -0x6600, -0xc300, -0xc300, -0xc300, -0xc300, -0xc300, -0x6600, -0x3c00, - -/* Character 214 (0xd6): - width 7 - bbx ( 8, 11, 1, 0 ) - - +--------+ - | ** ** | - | | - | **** | - | ** ** | - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | **** | - +--------+ -*/ -0x6600, -0x0000, -0x3c00, -0x6600, -0xc300, -0xc300, -0xc300, -0xc300, -0xc300, -0x6600, -0x3c00, - -/* Character 215 (0xd7): - width 7 - bbx ( 6, 5, 0, 1 ) - - +------+ - |** **| - | **** | - | ** | - | **** | - |** **| - +------+ -*/ -0xcc00, -0x7800, -0x3000, -0x7800, -0xcc00, - -/* Character 216 (0xd8): - width 7 - bbx ( 8, 10, 1, -1 ) - - +--------+ - | **** *| - | ** ** | - |** ****| - |** * **| - |** ** **| - |** * **| - |**** **| - | ** ** | - | ***** | - |* | - +--------+ -*/ -0x3d00, -0x6600, -0xcf00, -0xcb00, -0xdb00, -0xd300, -0xf300, -0x6600, -0x7c00, -0x8000, - -/* Character 217 (0xd9): - width 7 - bbx ( 7, 12, 1, 0 ) - - +-------+ - | ** | - | ** | - | | - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | ***** | - +-------+ -*/ -0x3000, -0x1800, -0x0000, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0x6c00, -0x7c00, - -/* Character 218 (0xda): - width 7 - bbx ( 7, 12, 1, 0 ) - - +-------+ - | ** | - | ** | - | | - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | ***** | - +-------+ -*/ -0x0c00, -0x1800, -0x0000, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0x6c00, -0x7c00, - -/* Character 219 (0xdb): - width 7 - bbx ( 7, 12, 1, 0 ) - - +-------+ - | *** | - | ** ** | - | | - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | ***** | - +-------+ -*/ -0x3800, -0x6c00, -0x0000, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0x6c00, -0x7c00, - -/* Character 220 (0xdc): - width 7 - bbx ( 7, 11, 1, 0 ) - - +-------+ - | ** ** | - | | - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - |** **| - | ** ** | - | ***** | - +-------+ -*/ -0x6c00, -0x0000, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0xc600, -0x6c00, -0x7c00, - -/* Character 221 (0xdd): - width 8 - bbx ( 8, 12, 0, 0 ) - - +--------+ - | ** | - | ** | - | | - |** **| - |** **| - | ** ** | - | ** ** | - | * * | - | **** | - | ** | - | ** | - | ** | - +--------+ -*/ -0x0c00, -0x1800, -0x0000, -0xc300, -0xc300, -0x6600, -0x6600, -0x2400, -0x3c00, -0x1800, -0x1800, -0x1800, - -/* Character 222 (0xde): - width 7 - bbx ( 7, 9, 1, 0 ) - - +-------+ - |** | - |** | - |****** | - |** **| - |** **| - |** **| - |****** | - |** | - |** | - +-------+ -*/ -0xc000, -0xc000, -0xfc00, -0xc600, -0xc600, -0xc600, -0xfc00, -0xc000, -0xc000, - -/* Character 223 (0xdf): - width 8 - bbx ( 6, 9, 1, 0 ) - - +------+ - | **** | - |** **| - |** **| - |** **| - |** ** | - |** **| - |** **| - |** **| - |** ** | - +------+ -*/ -0x7800, -0xcc00, -0xcc00, -0xcc00, -0xd800, -0xcc00, -0xcc00, -0xcc00, -0xd800, - -/* Character 224 (0xe0): - width 0 - bbx ( 7, 10, 0, 0 ) - - +-------+ - | ** | - | ** | - | | - | **** | - |** ** | - | ** | - | ***** | - |** ** | - |** ** | - | *** **| - +-------+ -*/ -0x3000, -0x1800, -0x0000, -0x7800, -0xcc00, -0x0c00, -0x7c00, -0xcc00, -0xcc00, -0x7600, - -/* Character 225 (0xe1): - width 0 - bbx ( 7, 10, 0, 0 ) - - +-------+ - | ** | - | ** | - | | - | **** | - |** ** | - | ** | - | ***** | - |** ** | - |** ** | - | *** **| - +-------+ -*/ -0x1800, -0x3000, -0x0000, -0x7800, -0xcc00, -0x0c00, -0x7c00, -0xcc00, -0xcc00, -0x7600, - -/* Character 226 (0xe2): - width 0 - bbx ( 7, 10, 0, 0 ) - - +-------+ - | *** | - | ** ** | - | | - | **** | - |** ** | - | ** | - | ***** | - |** ** | - |** ** | - | *** **| - +-------+ -*/ -0x3800, -0x6c00, -0x0000, -0x7800, -0xcc00, -0x0c00, -0x7c00, -0xcc00, -0xcc00, -0x7600, - -/* Character 227 (0xe3): - width 0 - bbx ( 7, 10, 0, 0 ) - - +-------+ - | ** * | - | * ** | - | | - | **** | - |** ** | - | ** | - | ***** | - |** ** | - |** ** | - | *** **| - +-------+ -*/ -0x3400, -0x5800, -0x0000, -0x7800, -0xcc00, -0x0c00, -0x7c00, -0xcc00, -0xcc00, -0x7600, - -/* Character 228 (0xe4): - width 137 - bbx ( 7, 9, 0, 0 ) - - +-------+ - | ** ** | - | | - | **** | - |** ** | - | ** | - | ***** | - |** ** | - |** ** | - | *** **| - +-------+ -*/ -0x6c00, -0x0000, -0x7800, -0xcc00, -0x0c00, -0x7c00, -0xcc00, -0xcc00, -0x7600, - -/* Character 229 (0xe5): - width 3 - bbx ( 7, 11, 0, 0 ) - - +-------+ - | ** | - | * * | - | ** | - | | - | **** | - |** ** | - | ** | - | ***** | - |** ** | - |** ** | - | *** **| - +-------+ -*/ -0x3000, -0x4800, -0x3000, -0x0000, -0x7800, -0xcc00, -0x0c00, -0x7c00, -0xcc00, -0xcc00, -0x7600, - -/* Character 230 (0xe6): - width 0 - bbx ( 10, 7, 0, 0 ) - - +----------+ - | *** **** | - |** ** **| - | ** **| - | *********| - |** ** | - |** ** **| - | *** **** | - +----------+ -*/ -0x7780, -0xccc0, -0x0cc0, -0x7fc0, -0xcc00, -0xccc0, -0x7780, - -/* Character 231 (0xe7): - width 0 - bbx ( 6, 10, 0, -3 ) - - +------+ - | **** | - |** **| - |** | - |** | - |** | - |** **| - | **** | - | * | - | ** | - | *** | - +------+ -*/ -0x7800, -0xcc00, -0xc000, -0xc000, -0xc000, -0xcc00, -0x7800, -0x1000, -0x1800, -0x7000, - -/* Character 232 (0xe8): - width 1 - bbx ( 6, 10, 0, 0 ) - - +------+ - | ** | - | ** | - | | - | **** | - |** **| - |** **| - |******| - |** | - |** **| - | **** | - +------+ -*/ -0x6000, -0x3000, -0x0000, -0x7800, -0xcc00, -0xcc00, -0xfc00, -0xc000, -0xcc00, -0x7800, - -/* Character 233 (0xe9): - width 1 - bbx ( 6, 10, 0, 0 ) - - +------+ - | ** | - | ** | - | | - | **** | - |** **| - |** **| - |******| - |** | - |** **| - | **** | - +------+ -*/ -0x1800, -0x3000, -0x0000, -0x7800, -0xcc00, -0xcc00, -0xfc00, -0xc000, -0xcc00, -0x7800, - -/* Character 234 (0xea): - width 0 - bbx ( 6, 10, 0, 0 ) - - +------+ - | *** | - | ** **| - | | - | **** | - |** **| - |** **| - |******| - |** | - |** **| - | **** | - +------+ -*/ -0x3800, -0x6c00, -0x0000, -0x7800, -0xcc00, -0xcc00, -0xfc00, -0xc000, -0xcc00, -0x7800, - -/* Character 235 (0xeb): - width 0 - bbx ( 6, 9, 0, 0 ) - - +------+ - | ** **| - | | - | **** | - |** **| - |** **| - |******| - |** | - |** **| - | **** | - +------+ -*/ -0x6c00, -0x0000, -0x7800, -0xcc00, -0xcc00, -0xfc00, -0xc000, -0xcc00, -0x7800, - -/* Character 236 (0xec): - width 2 - bbx ( 3, 10, -1, 0 ) - - +---+ - |** | - | **| - | | - | **| - | **| - | **| - | **| - | **| - | **| - | **| - +---+ -*/ -0xc000, -0x6000, -0x0000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, - -/* Character 237 (0xed): - width 9 - bbx ( 3, 10, 0, 0 ) - - +---+ - | **| - |** | - | | - |** | - |** | - |** | - |** | - |** | - |** | - |** | - +---+ -*/ -0x6000, -0xc000, -0x0000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, -0xc000, - -/* Character 238 (0xee): - width 1 - bbx ( 5, 10, -1, 0 ) - - +-----+ - | *** | - |** **| - | | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - +-----+ -*/ -0x7000, -0xd800, -0x0000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, - -/* Character 239 (0xef): - width 0 - bbx ( 5, 9, -1, 0 ) - - +-----+ - |** **| - | | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - | ** | - +-----+ -*/ -0xd800, -0x0000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, -0x6000, - -/* Character 240 (0xf0): - width 3 - bbx ( 6, 10, 0, 0 ) - - +------+ - |** ** | - | *** | - |* * | - | ** | - | *****| - |** **| - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0xd800, -0x7000, -0x9000, -0x1800, -0x7c00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 241 (0xf1): - width 3 - bbx ( 6, 10, 0, 0 ) - - +------+ - | ** *| - | * ** | - | | - |** ** | - |*** **| - |** **| - |** **| - |** **| - |** **| - |** **| - +------+ -*/ -0x3400, -0x5800, -0x0000, -0xd800, -0xec00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, - -/* Character 242 (0xf2): - width 1 - bbx ( 6, 10, 0, 0 ) - - +------+ - | ** | - | ** | - | | - | **** | - |** **| - |** **| - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0x6000, -0x3000, -0x0000, -0x7800, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 243 (0xf3): - width 6 - bbx ( 6, 10, 0, 0 ) - - +------+ - | ** | - | ** | - | | - | **** | - |** **| - |** **| - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0x1800, -0x3000, -0x0000, -0x7800, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 244 (0xf4): - width 7 - bbx ( 6, 10, 0, 0 ) - - +------+ - | *** | - | ** **| - | | - | **** | - |** **| - |** **| - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0x3800, -0x6c00, -0x0000, -0x7800, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 245 (0xf5): - width 8 - bbx ( 6, 10, 0, 0 ) - - +------+ - | ** *| - | * ** | - | | - | **** | - |** **| - |** **| - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0x3400, -0x5800, -0x0000, -0x7800, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 246 (0xf6): - width 0 - bbx ( 6, 9, 0, 0 ) - - +------+ - | ** **| - | | - | **** | - |** **| - |** **| - |** **| - |** **| - |** **| - | **** | - +------+ -*/ -0x6c00, -0x0000, -0x7800, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0x7800, - -/* Character 247 (0xf7): - width 0 - bbx ( 6, 5, 0, 1 ) - - +------+ - | ** | - | | - |******| - | | - | ** | - +------+ -*/ -0x3000, -0x0000, -0xfc00, -0x0000, -0x3000, - -/* Character 248 (0xf8): - width 6 - bbx ( 8, 7, -1, 0 ) - - +--------+ - | **** *| - | ** ** | - | ** *** | - | *** ** | - | ** ** | - | ** ** | - |* **** | - +--------+ -*/ -0x3d00, -0x6600, -0x6e00, -0x7600, -0x6600, -0x6600, -0xbc00, - -/* Character 249 (0xf9): - width 11 - bbx ( 6, 10, 0, 0 ) - - +------+ - | ** | - | ** | - | | - |** **| - |** **| - |** **| - |** **| - |** **| - |** ***| - | ** **| - +------+ -*/ -0x6000, -0x3000, -0x0000, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xdc00, -0x6c00, - -/* Character 250 (0xfa): - width 0 - bbx ( 6, 10, 0, 0 ) - - +------+ - | ** | - | ** | - | | - |** **| - |** **| - |** **| - |** **| - |** **| - |** ***| - | ** **| - +------+ -*/ -0x1800, -0x3000, -0x0000, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xdc00, -0x6c00, - -/* Character 251 (0xfb): - width 254 - bbx ( 6, 10, 0, 0 ) - - +------+ - | *** | - | ** **| - | | - |** **| - |** **| - |** **| - |** **| - |** **| - |** ***| - | ** **| - +------+ -*/ -0x3800, -0x6c00, -0x0000, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xdc00, -0x6c00, - -/* Character 252 (0xfc): - width 11 - bbx ( 6, 9, 0, 0 ) - - +------+ - | ** **| - | | - |** **| - |** **| - |** **| - |** **| - |** **| - |** ***| - | ** **| - +------+ -*/ -0x6c00, -0x0000, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xcc00, -0xdc00, -0x6c00, - -/* Character 253 (0xfd): - width 9 - bbx ( 7, 13, 0, -3 ) - - +-------+ - | ** | - | ** | - | | - |** **| - |** **| - | ** ** | - | ** ** | - | *** | - | *** | - | ** | - | * | - | ** | - | ** | - +-------+ -*/ -0x0c00, -0x1800, -0x0000, -0xc600, -0xc600, -0x6c00, -0x6c00, -0x3800, -0x3800, -0x1800, -0x1000, -0x3000, -0x6000, - -/* Character 254 (0xfe): - width 0 - bbx ( 6, 12, 0, -3 ) - - +------+ - |** | - |** | - |** ** | - |*** **| - |** **| - |** **| - |** **| - |*** **| - |** ** | - |** | - |** | - |** | - +------+ -*/ -0xc000, -0xc000, -0xd800, -0xec00, -0xcc00, -0xcc00, -0xcc00, -0xec00, -0xd800, -0xc000, -0xc000, -0xc000, - -/* Character 255 (0xff): - width 0 - bbx ( 7, 12, 0, -3 ) - - +-------+ - | ** ** | - | | - |** **| - |** **| - | ** ** | - | ** ** | - | *** | - | *** | - | ** | - | * | - | ** | - | ** | - +-------+ -*/ -0x6c00, -0x0000, -0xc600, -0xc600, -0x6c00, -0x6c00, -0x3800, -0x3800, -0x1800, -0x1000, -0x3000, -0x6000, -}; - -/* Character->glyph mapping. */ -static const unsigned long _sysfont_offset[] = { - 0, /* (0x20) */ - 1, /* (0x21) */ - 10, /* (0x22) */ - 13, /* (0x23) */ - 21, /* (0x24) */ - 32, /* (0x25) */ - 41, /* (0x26) */ - 50, /* (0x27) */ - 53, /* (0x28) */ - 65, /* (0x29) */ - 77, /* (0x2a) */ - 81, /* (0x2b) */ - 86, /* (0x2c) */ - 90, /* (0x2d) */ - 91, /* (0x2e) */ - 93, /* (0x2f) */ - 102, /* (0x30) */ - 111, /* (0x31) */ - 120, /* (0x32) */ - 129, /* (0x33) */ - 138, /* (0x34) */ - 147, /* (0x35) */ - 156, /* (0x36) */ - 165, /* (0x37) */ - 174, /* (0x38) */ - 183, /* (0x39) */ - 192, /* (0x3a) */ - 199, /* (0x3b) */ - 208, /* (0x3c) */ - 213, /* (0x3d) */ - 216, /* (0x3e) */ - 221, /* (0x3f) */ - 230, /* (0x40) */ - 240, /* (0x41) */ - 249, /* (0x42) */ - 258, /* (0x43) */ - 267, /* (0x44) */ - 276, /* (0x45) */ - 285, /* (0x46) */ - 294, /* (0x47) */ - 303, /* (0x48) */ - 312, /* (0x49) */ - 321, /* (0x4a) */ - 330, /* (0x4b) */ - 339, /* (0x4c) */ - 348, /* (0x4d) */ - 357, /* (0x4e) */ - 366, /* (0x4f) */ - 375, /* (0x50) */ - 384, /* (0x51) */ - 393, /* (0x52) */ - 402, /* (0x53) */ - 411, /* (0x54) */ - 420, /* (0x55) */ - 429, /* (0x56) */ - 438, /* (0x57) */ - 447, /* (0x58) */ - 456, /* (0x59) */ - 465, /* (0x5a) */ - 474, /* (0x5b) */ - 486, /* (0x5c) */ - 495, /* (0x5d) */ - 507, /* (0x5e) */ - 511, /* (0x5f) */ - 512, /* (0x60) */ - 514, /* (0x61) */ - 521, /* (0x62) */ - 530, /* (0x63) */ - 537, /* (0x64) */ - 546, /* (0x65) */ - 553, /* (0x66) */ - 562, /* (0x67) */ - 572, /* (0x68) */ - 581, /* (0x69) */ - 590, /* (0x6a) */ - 602, /* (0x6b) */ - 611, /* (0x6c) */ - 620, /* (0x6d) */ - 627, /* (0x6e) */ - 634, /* (0x6f) */ - 641, /* (0x70) */ - 651, /* (0x71) */ - 661, /* (0x72) */ - 668, /* (0x73) */ - 675, /* (0x74) */ - 684, /* (0x75) */ - 691, /* (0x76) */ - 698, /* (0x77) */ - 705, /* (0x78) */ - 712, /* (0x79) */ - 722, /* (0x7a) */ - 729, /* (0x7b) */ - 741, /* (0x7c) */ - 753, /* (0x7d) */ - 765, /* (0x7e) */ - 0, /* (0x7f) */ - 0, /* (0x80) */ - 0, /* (0x81) */ - 0, /* (0x82) */ - 0, /* (0x83) */ - 0, /* (0x84) */ - 0, /* (0x85) */ - 0, /* (0x86) */ - 0, /* (0x87) */ - 0, /* (0x88) */ - 0, /* (0x89) */ - 0, /* (0x8a) */ - 0, /* (0x8b) */ - 0, /* (0x8c) */ - 0, /* (0x8d) */ - 0, /* (0x8e) */ - 0, /* (0x8f) */ - 0, /* (0x90) */ - 0, /* (0x91) */ - 0, /* (0x92) */ - 0, /* (0x93) */ - 0, /* (0x94) */ - 0, /* (0x95) */ - 0, /* (0x96) */ - 0, /* (0x97) */ - 0, /* (0x98) */ - 0, /* (0x99) */ - 0, /* (0x9a) */ - 0, /* (0x9b) */ - 0, /* (0x9c) */ - 0, /* (0x9d) */ - 0, /* (0x9e) */ - 0, /* (0x9f) */ - 767, /* (0xa0) */ - 768, /* (0xa1) */ - 778, /* (0xa2) */ - 787, /* (0xa3) */ - 796, /* (0xa4) */ - 802, /* (0xa5) */ - 811, /* (0xa6) */ - 822, /* (0xa7) */ - 834, /* (0xa8) */ - 835, /* (0xa9) */ - 844, /* (0xaa) */ - 850, /* (0xab) */ - 855, /* (0xac) */ - 859, /* (0xad) */ - 860, /* (0xae) */ - 869, /* (0xaf) */ - 870, /* (0xb0) */ - 874, /* (0xb1) */ - 881, /* (0xb2) */ - 886, /* (0xb3) */ - 891, /* (0xb4) */ - 893, /* (0xb5) */ - 903, /* (0xb6) */ - 915, /* (0xb7) */ - 917, /* (0xb8) */ - 921, /* (0xb9) */ - 926, /* (0xba) */ - 932, /* (0xbb) */ - 937, /* (0xbc) */ - 946, /* (0xbd) */ - 955, /* (0xbe) */ - 964, /* (0xbf) */ - 974, /* (0xc0) */ - 986, /* (0xc1) */ - 998, /* (0xc2) */ - 1010, /* (0xc3) */ - 1022, /* (0xc4) */ - 1033, /* (0xc5) */ - 1045, /* (0xc6) */ - 1054, /* (0xc7) */ - 1066, /* (0xc8) */ - 1078, /* (0xc9) */ - 1090, /* (0xca) */ - 1102, /* (0xcb) */ - 1113, /* (0xcc) */ - 1125, /* (0xcd) */ - 1137, /* (0xce) */ - 1149, /* (0xcf) */ - 1160, /* (0xd0) */ - 1169, /* (0xd1) */ - 1181, /* (0xd2) */ - 1193, /* (0xd3) */ - 1205, /* (0xd4) */ - 1217, /* (0xd5) */ - 1229, /* (0xd6) */ - 1240, /* (0xd7) */ - 1245, /* (0xd8) */ - 1255, /* (0xd9) */ - 1267, /* (0xda) */ - 1279, /* (0xdb) */ - 1291, /* (0xdc) */ - 1302, /* (0xdd) */ - 1314, /* (0xde) */ - 1323, /* (0xdf) */ - 1332, /* (0xe0) */ - 1342, /* (0xe1) */ - 1352, /* (0xe2) */ - 1362, /* (0xe3) */ - 1372, /* (0xe4) */ - 1381, /* (0xe5) */ - 1392, /* (0xe6) */ - 1399, /* (0xe7) */ - 1409, /* (0xe8) */ - 1419, /* (0xe9) */ - 1429, /* (0xea) */ - 1439, /* (0xeb) */ - 1448, /* (0xec) */ - 1458, /* (0xed) */ - 1468, /* (0xee) */ - 1478, /* (0xef) */ - 1487, /* (0xf0) */ - 1497, /* (0xf1) */ - 1507, /* (0xf2) */ - 1517, /* (0xf3) */ - 1527, /* (0xf4) */ - 1537, /* (0xf5) */ - 1547, /* (0xf6) */ - 1556, /* (0xf7) */ - 1561, /* (0xf8) */ - 1568, /* (0xf9) */ - 1578, /* (0xfa) */ - 1588, /* (0xfb) */ - 1598, /* (0xfc) */ - 1607, /* (0xfd) */ - 1620, /* (0xfe) */ - 1632, /* (0xff) */ -}; - -/* Character width data. */ -static const unsigned char _sysfont_width[] = { - 4, /* (0x20) */ - 4, /* (0x21) */ - 5, /* (0x22) */ - 8, /* (0x23) */ - 7, /* (0x24) */ - 12, /* (0x25) */ - 9, /* (0x26) */ - 3, /* (0x27) */ - 6, /* (0x28) */ - 6, /* (0x29) */ - 6, /* (0x2a) */ - 7, /* (0x2b) */ - 4, /* (0x2c) */ - 5, /* (0x2d) */ - 4, /* (0x2e) */ - 4, /* (0x2f) */ - 7, /* (0x30) */ - 7, /* (0x31) */ - 7, /* (0x32) */ - 7, /* (0x33) */ - 7, /* (0x34) */ - 7, /* (0x35) */ - 7, /* (0x36) */ - 7, /* (0x37) */ - 7, /* (0x38) */ - 7, /* (0x39) */ - 4, /* (0x3a) */ - 4, /* (0x3b) */ - 7, /* (0x3c) */ - 7, /* (0x3d) */ - 7, /* (0x3e) */ - 8, /* (0x3f) */ - 12, /* (0x40) */ - 8, /* (0x41) */ - 9, /* (0x42) */ - 8, /* (0x43) */ - 9, /* (0x44) */ - 8, /* (0x45) */ - 7, /* (0x46) */ - 10, /* (0x47) */ - 9, /* (0x48) */ - 4, /* (0x49) */ - 7, /* (0x4a) */ - 9, /* (0x4b) */ - 7, /* (0x4c) */ - 11, /* (0x4d) */ - 9, /* (0x4e) */ - 10, /* (0x4f) */ - 8, /* (0x50) */ - 10, /* (0x51) */ - 9, /* (0x52) */ - 9, /* (0x53) */ - 8, /* (0x54) */ - 9, /* (0x55) */ - 8, /* (0x56) */ - 10, /* (0x57) */ - 8, /* (0x58) */ - 8, /* (0x59) */ - 7, /* (0x5a) */ - 4, /* (0x5b) */ - 4, /* (0x5c) */ - 4, /* (0x5d) */ - 7, /* (0x5e) */ - 7, /* (0x5f) */ - 4, /* (0x60) */ - 7, /* (0x61) */ - 7, /* (0x62) */ - 7, /* (0x63) */ - 7, /* (0x64) */ - 7, /* (0x65) */ - 5, /* (0x66) */ - 7, /* (0x67) */ - 7, /* (0x68) */ - 3, /* (0x69) */ - 3, /* (0x6a) */ - 7, /* (0x6b) */ - 3, /* (0x6c) */ - 11, /* (0x6d) */ - 7, /* (0x6e) */ - 7, /* (0x6f) */ - 7, /* (0x70) */ - 7, /* (0x71) */ - 5, /* (0x72) */ - 7, /* (0x73) */ - 5, /* (0x74) */ - 7, /* (0x75) */ - 8, /* (0x76) */ - 11, /* (0x77) */ - 7, /* (0x78) */ - 8, /* (0x79) */ - 6, /* (0x7a) */ - 5, /* (0x7b) */ - 4, /* (0x7c) */ - 5, /* (0x7d) */ - 7, /* (0x7e) */ - 4, /* (0x7f) */ - 4, /* (0x80) */ - 4, /* (0x81) */ - 4, /* (0x82) */ - 4, /* (0x83) */ - 4, /* (0x84) */ - 4, /* (0x85) */ - 4, /* (0x86) */ - 4, /* (0x87) */ - 4, /* (0x88) */ - 4, /* (0x89) */ - 4, /* (0x8a) */ - 4, /* (0x8b) */ - 4, /* (0x8c) */ - 4, /* (0x8d) */ - 4, /* (0x8e) */ - 4, /* (0x8f) */ - 4, /* (0x90) */ - 4, /* (0x91) */ - 4, /* (0x92) */ - 4, /* (0x93) */ - 4, /* (0x94) */ - 4, /* (0x95) */ - 4, /* (0x96) */ - 4, /* (0x97) */ - 4, /* (0x98) */ - 4, /* (0x99) */ - 4, /* (0x9a) */ - 4, /* (0x9b) */ - 4, /* (0x9c) */ - 4, /* (0x9d) */ - 4, /* (0x9e) */ - 4, /* (0x9f) */ - 4, /* (0xa0) */ - 4, /* (0xa1) */ - 7, /* (0xa2) */ - 7, /* (0xa3) */ - 7, /* (0xa4) */ - 7, /* (0xa5) */ - 4, /* (0xa6) */ - 7, /* (0xa7) */ - 5, /* (0xa8) */ - 11, /* (0xa9) */ - 6, /* (0xaa) */ - 8, /* (0xab) */ - 8, /* (0xac) */ - 5, /* (0xad) */ - 11, /* (0xae) */ - 4, /* (0xaf) */ - 5, /* (0xb0) */ - 7, /* (0xb1) */ - 4, /* (0xb2) */ - 4, /* (0xb3) */ - 4, /* (0xb4) */ - 7, /* (0xb5) */ - 7, /* (0xb6) */ - 4, /* (0xb7) */ - 4, /* (0xb8) */ - 4, /* (0xb9) */ - 6, /* (0xba) */ - 8, /* (0xbb) */ - 10, /* (0xbc) */ - 10, /* (0xbd) */ - 10, /* (0xbe) */ - 8, /* (0xbf) */ - 8, /* (0xc0) */ - 8, /* (0xc1) */ - 8, /* (0xc2) */ - 8, /* (0xc3) */ - 8, /* (0xc4) */ - 8, /* (0xc5) */ - 13, /* (0xc6) */ - 8, /* (0xc7) */ - 8, /* (0xc8) */ - 8, /* (0xc9) */ - 8, /* (0xca) */ - 8, /* (0xcb) */ - 4, /* (0xcc) */ - 4, /* (0xcd) */ - 4, /* (0xce) */ - 4, /* (0xcf) */ - 9, /* (0xd0) */ - 9, /* (0xd1) */ - 10, /* (0xd2) */ - 10, /* (0xd3) */ - 10, /* (0xd4) */ - 10, /* (0xd5) */ - 10, /* (0xd6) */ - 7, /* (0xd7) */ - 10, /* (0xd8) */ - 9, /* (0xd9) */ - 9, /* (0xda) */ - 9, /* (0xdb) */ - 9, /* (0xdc) */ - 8, /* (0xdd) */ - 8, /* (0xde) */ - 8, /* (0xdf) */ - 7, /* (0xe0) */ - 7, /* (0xe1) */ - 7, /* (0xe2) */ - 7, /* (0xe3) */ - 7, /* (0xe4) */ - 7, /* (0xe5) */ - 11, /* (0xe6) */ - 7, /* (0xe7) */ - 7, /* (0xe8) */ - 7, /* (0xe9) */ - 7, /* (0xea) */ - 7, /* (0xeb) */ - 3, /* (0xec) */ - 3, /* (0xed) */ - 3, /* (0xee) */ - 3, /* (0xef) */ - 7, /* (0xf0) */ - 7, /* (0xf1) */ - 7, /* (0xf2) */ - 7, /* (0xf3) */ - 7, /* (0xf4) */ - 7, /* (0xf5) */ - 7, /* (0xf6) */ - 7, /* (0xf7) */ - 7, /* (0xf8) */ - 7, /* (0xf9) */ - 7, /* (0xfa) */ - 7, /* (0xfb) */ - 7, /* (0xfc) */ - 8, /* (0xfd) */ - 7, /* (0xfe) */ - 8, /* (0xff) */ -}; - -/* Bounding box data. */ -static const BBX _sysfont_bbx[] = { - { 1, 1, 0, 0 }, /* (0x20) */ - { 2, 9, 1, 0 }, /* (0x21) */ - { 3, 3, 1, 6 }, /* (0x22) */ - { 7, 8, 0, 0 }, /* (0x23) */ - { 6, 11, 0, -2 }, /* (0x24) */ - { 11, 9, 0, 0 }, /* (0x25) */ - { 9, 9, 0, 0 }, /* (0x26) */ - { 1, 3, 1, 6 }, /* (0x27) */ - { 4, 12, 1, -3 }, /* (0x28) */ - { 4, 12, 1, -3 }, /* (0x29) */ - { 5, 4, 0, 5 }, /* (0x2a) */ - { 6, 5, 0, 1 }, /* (0x2b) */ - { 2, 4, 1, -2 }, /* (0x2c) */ - { 4, 1, 0, 3 }, /* (0x2d) */ - { 2, 2, 1, 0 }, /* (0x2e) */ - { 4, 9, 0, 0 }, /* (0x2f) */ - { 6, 9, 0, 0 }, /* (0x30) */ - { 4, 9, 0, 0 }, /* (0x31) */ - { 6, 9, 0, 0 }, /* (0x32) */ - { 6, 9, 0, 0 }, /* (0x33) */ - { 7, 9, 0, 0 }, /* (0x34) */ - { 6, 9, 0, 0 }, /* (0x35) */ - { 6, 9, 0, 0 }, /* (0x36) */ - { 6, 9, 0, 0 }, /* (0x37) */ - { 6, 9, 0, 0 }, /* (0x38) */ - { 6, 9, 0, 0 }, /* (0x39) */ - { 2, 7, 1, 0 }, /* (0x3a) */ - { 2, 9, 1, -2 }, /* (0x3b) */ - { 5, 5, 1, 1 }, /* (0x3c) */ - { 6, 3, 0, 2 }, /* (0x3d) */ - { 5, 5, 1, 1 }, /* (0x3e) */ - { 6, 9, 1, 0 }, /* (0x3f) */ - { 10, 10, 1, -1 }, /* (0x40) */ - { 8, 9, 0, 0 }, /* (0x41) */ - { 7, 9, 1, 0 }, /* (0x42) */ - { 7, 9, 1, 0 }, /* (0x43) */ - { 7, 9, 1, 0 }, /* (0x44) */ - { 6, 9, 1, 0 }, /* (0x45) */ - { 6, 9, 1, 0 }, /* (0x46) */ - { 8, 9, 1, 0 }, /* (0x47) */ - { 7, 9, 1, 0 }, /* (0x48) */ - { 2, 9, 1, 0 }, /* (0x49) */ - { 6, 9, 0, 0 }, /* (0x4a) */ - { 8, 9, 1, 0 }, /* (0x4b) */ - { 6, 9, 1, 0 }, /* (0x4c) */ - { 9, 9, 1, 0 }, /* (0x4d) */ - { 7, 9, 1, 0 }, /* (0x4e) */ - { 8, 9, 1, 0 }, /* (0x4f) */ - { 7, 9, 1, 0 }, /* (0x50) */ - { 8, 9, 1, 0 }, /* (0x51) */ - { 7, 9, 1, 0 }, /* (0x52) */ - { 7, 9, 1, 0 }, /* (0x53) */ - { 8, 9, 0, 0 }, /* (0x54) */ - { 7, 9, 1, 0 }, /* (0x55) */ - { 8, 9, 0, 0 }, /* (0x56) */ - { 10, 9, 0, 0 }, /* (0x57) */ - { 8, 9, 0, 0 }, /* (0x58) */ - { 8, 9, 0, 0 }, /* (0x59) */ - { 7, 9, 0, 0 }, /* (0x5a) */ - { 3, 12, 1, -3 }, /* (0x5b) */ - { 4, 9, 0, 0 }, /* (0x5c) */ - { 3, 12, 0, -3 }, /* (0x5d) */ - { 7, 4, 0, 5 }, /* (0x5e) */ - { 7, 1, 0, -3 }, /* (0x5f) */ - { 3, 2, 0, 8 }, /* (0x60) */ - { 7, 7, 0, 0 }, /* (0x61) */ - { 6, 9, 0, 0 }, /* (0x62) */ - { 6, 7, 0, 0 }, /* (0x63) */ - { 6, 9, 0, 0 }, /* (0x64) */ - { 6, 7, 0, 0 }, /* (0x65) */ - { 5, 9, 0, 0 }, /* (0x66) */ - { 6, 10, 0, -3 }, /* (0x67) */ - { 6, 9, 0, 0 }, /* (0x68) */ - { 2, 9, 0, 0 }, /* (0x69) */ - { 3, 12, -1, -3 }, /* (0x6a) */ - { 7, 9, 0, 0 }, /* (0x6b) */ - { 2, 9, 0, 0 }, /* (0x6c) */ - { 10, 7, 0, 0 }, /* (0x6d) */ - { 6, 7, 0, 0 }, /* (0x6e) */ - { 6, 7, 0, 0 }, /* (0x6f) */ - { 6, 10, 0, -3 }, /* (0x70) */ - { 6, 10, 0, -3 }, /* (0x71) */ - { 5, 7, 0, 0 }, /* (0x72) */ - { 6, 7, 0, 0 }, /* (0x73) */ - { 5, 9, 0, 0 }, /* (0x74) */ - { 6, 7, 0, 0 }, /* (0x75) */ - { 7, 7, 0, 0 }, /* (0x76) */ - { 10, 7, 0, 0 }, /* (0x77) */ - { 6, 7, 0, 0 }, /* (0x78) */ - { 7, 10, 0, -3 }, /* (0x79) */ - { 5, 7, 0, 0 }, /* (0x7a) */ - { 4, 12, 0, -3 }, /* (0x7b) */ - { 2, 12, 1, -3 }, /* (0x7c) */ - { 4, 12, 0, -3 }, /* (0x7d) */ - { 7, 2, 0, 3 }, /* (0x7e) */ - { 1, 1, 0, 0 }, /* (0x7f) */ - { 1, 1, 0, 0 }, /* (0x80) */ - { 1, 1, 0, 0 }, /* (0x81) */ - { 1, 1, 0, 0 }, /* (0x82) */ - { 1, 1, 0, 0 }, /* (0x83) */ - { 1, 1, 0, 0 }, /* (0x84) */ - { 1, 1, 0, 0 }, /* (0x85) */ - { 1, 1, 0, 0 }, /* (0x86) */ - { 1, 1, 0, 0 }, /* (0x87) */ - { 1, 1, 0, 0 }, /* (0x88) */ - { 1, 1, 0, 0 }, /* (0x89) */ - { 1, 1, 0, 0 }, /* (0x8a) */ - { 1, 1, 0, 0 }, /* (0x8b) */ - { 1, 1, 0, 0 }, /* (0x8c) */ - { 1, 1, 0, 0 }, /* (0x8d) */ - { 1, 1, 0, 0 }, /* (0x8e) */ - { 1, 1, 0, 0 }, /* (0x8f) */ - { 1, 1, 0, 0 }, /* (0x90) */ - { 1, 1, 0, 0 }, /* (0x91) */ - { 1, 1, 0, 0 }, /* (0x92) */ - { 1, 1, 0, 0 }, /* (0x93) */ - { 1, 1, 0, 0 }, /* (0x94) */ - { 1, 1, 0, 0 }, /* (0x95) */ - { 1, 1, 0, 0 }, /* (0x96) */ - { 1, 1, 0, 0 }, /* (0x97) */ - { 1, 1, 0, 0 }, /* (0x98) */ - { 1, 1, 0, 0 }, /* (0x99) */ - { 1, 1, 0, 0 }, /* (0x9a) */ - { 1, 1, 0, 0 }, /* (0x9b) */ - { 1, 1, 0, 0 }, /* (0x9c) */ - { 1, 1, 0, 0 }, /* (0x9d) */ - { 1, 1, 0, 0 }, /* (0x9e) */ - { 1, 1, 0, 0 }, /* (0x9f) */ - { 1, 1, 0, 0 }, /* (0xa0) */ - { 2, 10, 1, -3 }, /* (0xa1) */ - { 6, 9, 0, -1 }, /* (0xa2) */ - { 6, 9, 0, 0 }, /* (0xa3) */ - { 6, 6, 0, 1 }, /* (0xa4) */ - { 6, 9, 0, 0 }, /* (0xa5) */ - { 2, 11, 1, -2 }, /* (0xa6) */ - { 6, 12, 0, -3 }, /* (0xa7) */ - { 5, 1, 0, 8 }, /* (0xa8) */ - { 9, 9, 1, 0 }, /* (0xa9) */ - { 4, 6, 1, 3 }, /* (0xaa) */ - { 6, 5, 1, 1 }, /* (0xab) */ - { 6, 4, 1, 2 }, /* (0xac) */ - { 4, 1, 0, 3 }, /* (0xad) */ - { 9, 9, 1, 0 }, /* (0xae) */ - { 4, 1, 0, 8 }, /* (0xaf) */ - { 4, 4, 0, 4 }, /* (0xb0) */ - { 6, 7, 0, 0 }, /* (0xb1) */ - { 4, 5, 0, 4 }, /* (0xb2) */ - { 4, 5, 0, 4 }, /* (0xb3) */ - { 3, 2, 0, 8 }, /* (0xb4) */ - { 6, 10, 0, -3 }, /* (0xb5) */ - { 7, 12, 0, -3 }, /* (0xb6) */ - { 2, 2, 1, 3 }, /* (0xb7) */ - { 4, 4, 0, -3 }, /* (0xb8) */ - { 3, 5, 0, 4 }, /* (0xb9) */ - { 4, 6, 1, 3 }, /* (0xba) */ - { 6, 5, 1, 1 }, /* (0xbb) */ - { 10, 9, 0, 0 }, /* (0xbc) */ - { 10, 9, 0, 0 }, /* (0xbd) */ - { 10, 9, 0, 0 }, /* (0xbe) */ - { 6, 10, 1, -3 }, /* (0xbf) */ - { 8, 12, 0, 0 }, /* (0xc0) */ - { 8, 12, 0, 0 }, /* (0xc1) */ - { 8, 12, 0, 0 }, /* (0xc2) */ - { 8, 12, 0, 0 }, /* (0xc3) */ - { 8, 11, 0, 0 }, /* (0xc4) */ - { 8, 12, 0, 0 }, /* (0xc5) */ - { 11, 9, 1, 0 }, /* (0xc6) */ - { 7, 12, 1, -3 }, /* (0xc7) */ - { 6, 12, 1, 0 }, /* (0xc8) */ - { 6, 12, 1, 0 }, /* (0xc9) */ - { 6, 12, 1, 0 }, /* (0xca) */ - { 6, 11, 1, 0 }, /* (0xcb) */ - { 3, 12, 0, 0 }, /* (0xcc) */ - { 3, 12, 1, 0 }, /* (0xcd) */ - { 5, 12, 0, 0 }, /* (0xce) */ - { 5, 11, 0, 0 }, /* (0xcf) */ - { 8, 9, 0, 0 }, /* (0xd0) */ - { 7, 12, 1, 0 }, /* (0xd1) */ - { 8, 12, 1, 0 }, /* (0xd2) */ - { 8, 12, 1, 0 }, /* (0xd3) */ - { 8, 12, 1, 0 }, /* (0xd4) */ - { 8, 12, 1, 0 }, /* (0xd5) */ - { 8, 11, 1, 0 }, /* (0xd6) */ - { 6, 5, 0, 1 }, /* (0xd7) */ - { 8, 10, 1, -1 }, /* (0xd8) */ - { 7, 12, 1, 0 }, /* (0xd9) */ - { 7, 12, 1, 0 }, /* (0xda) */ - { 7, 12, 1, 0 }, /* (0xdb) */ - { 7, 11, 1, 0 }, /* (0xdc) */ - { 8, 12, 0, 0 }, /* (0xdd) */ - { 7, 9, 1, 0 }, /* (0xde) */ - { 6, 9, 1, 0 }, /* (0xdf) */ - { 7, 10, 0, 0 }, /* (0xe0) */ - { 7, 10, 0, 0 }, /* (0xe1) */ - { 7, 10, 0, 0 }, /* (0xe2) */ - { 7, 10, 0, 0 }, /* (0xe3) */ - { 7, 9, 0, 0 }, /* (0xe4) */ - { 7, 11, 0, 0 }, /* (0xe5) */ - { 10, 7, 0, 0 }, /* (0xe6) */ - { 6, 10, 0, -3 }, /* (0xe7) */ - { 6, 10, 0, 0 }, /* (0xe8) */ - { 6, 10, 0, 0 }, /* (0xe9) */ - { 6, 10, 0, 0 }, /* (0xea) */ - { 6, 9, 0, 0 }, /* (0xeb) */ - { 3, 10, -1, 0 }, /* (0xec) */ - { 3, 10, 0, 0 }, /* (0xed) */ - { 5, 10, -1, 0 }, /* (0xee) */ - { 5, 9, -1, 0 }, /* (0xef) */ - { 6, 10, 0, 0 }, /* (0xf0) */ - { 6, 10, 0, 0 }, /* (0xf1) */ - { 6, 10, 0, 0 }, /* (0xf2) */ - { 6, 10, 0, 0 }, /* (0xf3) */ - { 6, 10, 0, 0 }, /* (0xf4) */ - { 6, 10, 0, 0 }, /* (0xf5) */ - { 6, 9, 0, 0 }, /* (0xf6) */ - { 6, 5, 0, 1 }, /* (0xf7) */ - { 8, 7, -1, 0 }, /* (0xf8) */ - { 6, 10, 0, 0 }, /* (0xf9) */ - { 6, 10, 0, 0 }, /* (0xfa) */ - { 6, 10, 0, 0 }, /* (0xfb) */ - { 6, 9, 0, 0 }, /* (0xfc) */ - { 7, 13, 0, -3 }, /* (0xfd) */ - { 6, 12, 0, -3 }, /* (0xfe) */ - { 7, 12, 0, -3 }, /* (0xff) */ -}; - -/* Exported structure definition. */ -static const BdfFontDesc desc = { - "helvB12-L1", +// Character 0 (0x00) +// Box: 7 9 1 0 +// Advance: 9 +// +// +-------+ +// |* * * *| +// | | +// |* *| +// | | +// |* *| +// | | +// |* *| +// | | +// |* * * *| +// +-------+ +static const byte glyph0[] = { + 0xAA, + 0x00, + 0x82, + 0x00, + 0x82, + 0x00, + 0x82, + 0x00, + 0xAA +}; + +// Character 32 (0x20) +// Box: 1 1 0 0 +// Advance: 4 +// +// +-+ +// | | +// +-+ +static const byte glyph32[] = { + 0x00 +}; + +// Character 33 (0x21) +// Box: 2 9 1 0 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// |**| +// |**| +// |**| +// |* | +// | | +// |**| +// |**| +// +--+ +static const byte glyph33[] = { + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0x80, + 0x00, + 0xC0, + 0xC0 +}; + +// Character 34 (0x22) +// Box: 3 3 1 6 +// Advance: 5 +// +// +---+ +// |* *| +// |* *| +// |* *| +// +---+ +static const byte glyph34[] = { + 0xA0, + 0xA0, + 0xA0 +}; + +// Character 35 (0x23) +// Box: 7 8 0 0 +// Advance: 8 +// +// +-------+ +// | * * | +// | * * | +// | ******| +// | * * | +// | * * | +// |****** | +// | * * | +// | * * | +// +-------+ +static const byte glyph35[] = { + 0x14, + 0x14, + 0x7E, + 0x28, + 0x28, + 0xFC, + 0x50, + 0x50 +}; + +// Character 36 (0x24) +// Box: 6 11 0 -2 +// Advance: 7 +// +// +------+ +// | * | +// | **** | +// |** * *| +// |** * | +// | **** | +// | ***| +// |* * *| +// |** * *| +// | **** | +// | * | +// | * | +// +------+ +static const byte glyph36[] = { + 0x10, + 0x78, + 0xD4, + 0xD0, + 0x78, + 0x1C, + 0x94, + 0xD4, + 0x78, + 0x10, + 0x10 +}; + +// Character 37 (0x25) +// Box: 11 9 0 0 +// Advance: 12 +// +// +-----------+ +// | *** * | +// |** ** ** | +// |** ** * | +// | *** * | +// | * | +// | * *** | +// | * ** **| +// | ** ** **| +// | * *** | +// +-----------+ +static const byte glyph37[] = { + 0x71, 0x00, + 0xDB, 0x00, + 0xDA, 0x00, + 0x74, 0x00, + 0x04, 0x00, + 0x09, 0xC0, + 0x0B, 0x60, + 0x1B, 0x60, + 0x11, 0xC0 +}; + +// Character 38 (0x26) +// Box: 9 9 0 0 +// Advance: 9 +// +// +---------+ +// | *** | +// | ** ** | +// | ** ** | +// | *** | +// | **** * | +// |** **** | +// |** ** | +// |** **** | +// | **** **| +// +---------+ +static const byte glyph38[] = { + 0x38, 0x00, + 0x6C, 0x00, + 0x6C, 0x00, + 0x38, 0x00, + 0x79, 0x00, + 0xCF, 0x00, + 0xC6, 0x00, + 0xCF, 0x00, + 0x79, 0x80 +}; + +// Character 39 (0x27) +// Box: 1 3 1 6 +// Advance: 3 +// +// +-+ +// |*| +// |*| +// |*| +// +-+ +static const byte glyph39[] = { + 0x80, + 0x80, + 0x80 +}; + +// Character 40 (0x28) +// Box: 4 12 1 -3 +// Advance: 6 +// +// +----+ +// | **| +// | ** | +// | ** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// | ** | +// | ** | +// | **| +// +----+ +static const byte glyph40[] = { + 0x30, + 0x60, + 0x60, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0x60, + 0x60, + 0x30 +}; + +// Character 41 (0x29) +// Box: 4 12 1 -3 +// Advance: 6 +// +// +----+ +// |** | +// | ** | +// | ** | +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | ** | +// | ** | +// |** | +// +----+ +static const byte glyph41[] = { + 0xC0, + 0x60, + 0x60, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x60, + 0x60, + 0xC0 +}; + +// Character 42 (0x2A) +// Box: 5 4 0 5 +// Advance: 6 +// +// +-----+ +// | * | +// |*****| +// | *** | +// | * * | +// +-----+ +static const byte glyph42[] = { + 0x20, + 0xF8, + 0x70, + 0x50 +}; + +// Character 43 (0x2B) +// Box: 6 5 0 1 +// Advance: 7 +// +// +------+ +// | ** | +// | ** | +// |******| +// | ** | +// | ** | +// +------+ +static const byte glyph43[] = { + 0x30, + 0x30, + 0xFC, + 0x30, + 0x30 +}; + +// Character 44 (0x2C) +// Box: 2 4 1 -2 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// | *| +// |* | +// +--+ +static const byte glyph44[] = { + 0xC0, + 0xC0, + 0x40, + 0x80 +}; + +// Character 45 (0x2D) +// Box: 4 1 0 3 +// Advance: 5 +// +// +----+ +// |****| +// +----+ +static const byte glyph45[] = { + 0xF0 +}; + +// Character 46 (0x2E) +// Box: 2 2 1 0 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// +--+ +static const byte glyph46[] = { + 0xC0, + 0xC0 +}; + +// Character 47 (0x2F) +// Box: 4 9 0 0 +// Advance: 4 +// +// +----+ +// | **| +// | **| +// | * | +// | ** | +// | ** | +// | * | +// | * | +// |** | +// |** | +// +----+ +static const byte glyph47[] = { + 0x30, + 0x30, + 0x20, + 0x60, + 0x60, + 0x40, + 0x40, + 0xC0, + 0xC0 +}; + +// Character 48 (0x30) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph48[] = { + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 49 (0x31) +// Box: 4 9 0 0 +// Advance: 7 +// +// +----+ +// | **| +// |****| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// +----+ +static const byte glyph49[] = { + 0x30, + 0xF0, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30, + 0x30 +}; + +// Character 50 (0x32) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// | **| +// | ** | +// | ** | +// | ** | +// |** | +// |** | +// |******| +// +------+ +static const byte glyph50[] = { + 0x78, + 0xCC, + 0x0C, + 0x18, + 0x30, + 0x60, + 0xC0, + 0xC0, + 0xFC +}; + +// Character 51 (0x33) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// | **| +// | *** | +// | **| +// | **| +// | **| +// |** **| +// | **** | +// +------+ +static const byte glyph51[] = { + 0x78, + 0xCC, + 0x0C, + 0x38, + 0x0C, + 0x0C, + 0x0C, + 0xCC, + 0x78 +}; + +// Character 52 (0x34) +// Box: 7 9 0 0 +// Advance: 7 +// +// +-------+ +// | ** | +// | *** | +// | * ** | +// | * ** | +// | * ** | +// |* ** | +// |*******| +// | ** | +// | ** | +// +-------+ +static const byte glyph52[] = { + 0x0C, + 0x1C, + 0x2C, + 0x2C, + 0x4C, + 0x8C, + 0xFE, + 0x0C, + 0x0C +}; + +// Character 53 (0x35) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | *****| +// | ** | +// |** | +// |***** | +// | **| +// | **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph53[] = { + 0x7C, + 0x60, + 0xC0, + 0xF8, + 0x0C, + 0x0C, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 54 (0x36) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |** | +// |** | +// |***** | +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph54[] = { + 0x78, + 0xCC, + 0xC0, + 0xC0, + 0xF8, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 55 (0x37) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// |******| +// | **| +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// +------+ +static const byte glyph55[] = { + 0xFC, + 0x0C, + 0x18, + 0x18, + 0x30, + 0x30, + 0x30, + 0x60, + 0x60 +}; + +// Character 56 (0x38) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |** **| +// | **** | +// |** **| +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph56[] = { + 0x78, + 0xCC, + 0xCC, + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 57 (0x39) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |** **| +// |** **| +// | *****| +// | **| +// | **| +// |** **| +// | **** | +// +------+ +static const byte glyph57[] = { + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0x7C, + 0x0C, + 0x0C, + 0xCC, + 0x78 +}; + +// Character 58 (0x3A) +// Box: 2 7 1 0 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// | | +// | | +// | | +// |**| +// |**| +// +--+ +static const byte glyph58[] = { + 0xC0, + 0xC0, + 0x00, + 0x00, + 0x00, + 0xC0, + 0xC0 +}; + +// Character 59 (0x3B) +// Box: 2 9 1 -2 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// | | +// | | +// | | +// |**| +// |**| +// | *| +// |* | +// +--+ +static const byte glyph59[] = { + 0xC0, + 0xC0, + 0x00, + 0x00, + 0x00, + 0xC0, + 0xC0, + 0x40, + 0x80 +}; + +// Character 60 (0x3C) +// Box: 5 5 1 1 +// Advance: 7 +// +// +-----+ +// | **| +// | *** | +// |** | +// | *** | +// | **| +// +-----+ +static const byte glyph60[] = { + 0x18, + 0x70, + 0xC0, + 0x70, + 0x18 +}; + +// Character 61 (0x3D) +// Box: 6 3 0 2 +// Advance: 7 +// +// +------+ +// |******| +// | | +// |******| +// +------+ +static const byte glyph61[] = { + 0xFC, + 0x00, + 0xFC +}; + +// Character 62 (0x3E) +// Box: 5 5 1 1 +// Advance: 7 +// +// +-----+ +// |** | +// | *** | +// | **| +// | *** | +// |** | +// +-----+ +static const byte glyph62[] = { + 0xC0, + 0x70, + 0x18, + 0x70, + 0xC0 +}; + +// Character 63 (0x3F) +// Box: 6 9 1 0 +// Advance: 8 +// +// +------+ +// | **** | +// |** **| +// |** **| +// | ** | +// | ** | +// | ** | +// | | +// | ** | +// | ** | +// +------+ +static const byte glyph63[] = { + 0x78, + 0xCC, + 0xCC, + 0x18, + 0x30, + 0x30, + 0x00, + 0x30, + 0x30 +}; + +// Character 64 (0x40) +// Box: 10 10 1 -1 +// Advance: 12 +// +// +----------+ +// | ***** | +// | ** * | +// | * *| +// |* ** * *| +// |* * * *| +// |* * * *| +// |* * ** * | +// |* ** ** | +// | * | +// | ***** | +// +----------+ +static const byte glyph64[] = { + 0x1F, 0x00, + 0x60, 0x80, + 0x40, 0x40, + 0x8D, 0x40, + 0x92, 0x40, + 0xA2, 0x40, + 0xA6, 0x80, + 0x9B, 0x00, + 0x40, 0x00, + 0x3E, 0x00 +}; + +// Character 65 (0x41) +// Box: 8 9 0 0 +// Advance: 8 +// +// +--------+ +// | ** | +// | **** | +// | * * | +// | ** ** | +// | ** ** | +// | ****** | +// |** **| +// |** **| +// |** **| +// +--------+ +static const byte glyph65[] = { + 0x18, + 0x3C, + 0x24, + 0x66, + 0x66, + 0x7E, + 0xC3, + 0xC3, + 0xC3 +}; + +// Character 66 (0x42) +// Box: 7 9 1 0 +// Advance: 9 +// +// +-------+ +// |****** | +// |** **| +// |** **| +// |** **| +// |****** | +// |** **| +// |** **| +// |** **| +// |****** | +// +-------+ +static const byte glyph66[] = { + 0xFC, + 0xC6, + 0xC6, + 0xC6, + 0xFC, + 0xC6, + 0xC6, + 0xC6, + 0xFC +}; + +// Character 67 (0x43) +// Box: 7 9 1 0 +// Advance: 8 +// +// +-------+ +// | **** | +// | ** **| +// |** | +// |** | +// |** | +// |** | +// |** | +// | ** **| +// | **** | +// +-------+ +static const byte glyph67[] = { + 0x3C, + 0x66, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0x66, + 0x3C +}; + +// Character 68 (0x44) +// Box: 7 9 1 0 +// Advance: 9 +// +// +-------+ +// |***** | +// |** ** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** ** | +// |***** | +// +-------+ +static const byte glyph68[] = { + 0xF8, + 0xCC, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xCC, + 0xF8 +}; + +// Character 69 (0x45) +// Box: 6 9 1 0 +// Advance: 8 +// +// +------+ +// |******| +// |** | +// |** | +// |** | +// |******| +// |** | +// |** | +// |** | +// |******| +// +------+ +static const byte glyph69[] = { + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC +}; + +// Character 70 (0x46) +// Box: 6 9 1 0 +// Advance: 7 +// +// +------+ +// |******| +// |** | +// |** | +// |** | +// |***** | +// |** | +// |** | +// |** | +// |** | +// +------+ +static const byte glyph70[] = { + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xF8, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 71 (0x47) +// Box: 8 9 1 0 +// Advance: 10 +// +// +--------+ +// | ***** | +// | ** **| +// |** | +// |** | +// |** ****| +// |** **| +// |** **| +// | ** **| +// | **** *| +// +--------+ +static const byte glyph71[] = { + 0x3E, + 0x63, + 0xC0, + 0xC0, + 0xCF, + 0xC3, + 0xC3, + 0x63, + 0x3D +}; + +// Character 72 (0x48) +// Box: 7 9 1 0 +// Advance: 9 +// +// +-------+ +// |** **| +// |** **| +// |** **| +// |** **| +// |*******| +// |** **| +// |** **| +// |** **| +// |** **| +// +-------+ +static const byte glyph72[] = { + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xFE, + 0xC6, + 0xC6, + 0xC6, + 0xC6 +}; + +// Character 73 (0x49) +// Box: 2 9 1 0 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// +--+ +static const byte glyph73[] = { + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 74 (0x4A) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph74[] = { + 0x0C, + 0x0C, + 0x0C, + 0x0C, + 0x0C, + 0x0C, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 75 (0x4B) +// Box: 8 9 1 0 +// Advance: 9 +// +// +--------+ +// |** ** | +// |** ** | +// |** ** | +// |**** | +// |**** | +// |** ** | +// |** ** | +// |** ** | +// |** **| +// +--------+ +static const byte glyph75[] = { + 0xC6, + 0xCC, + 0xD8, + 0xF0, + 0xF0, + 0xD8, + 0xCC, + 0xC6, + 0xC3 +}; + +// Character 76 (0x4C) +// Box: 6 9 1 0 +// Advance: 7 +// +// +------+ +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |******| +// +------+ +static const byte glyph76[] = { + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xFC +}; + +// Character 77 (0x4D) +// Box: 9 9 1 0 +// Advance: 11 +// +// +---------+ +// |** **| +// |** **| +// |*** ***| +// |*** ***| +// |**** ****| +// |** * * **| +// |** *** **| +// |** * **| +// |** * **| +// +---------+ +static const byte glyph77[] = { + 0xC1, 0x80, + 0xC1, 0x80, + 0xE3, 0x80, + 0xE3, 0x80, + 0xF7, 0x80, + 0xD5, 0x80, + 0xDD, 0x80, + 0xC9, 0x80, + 0xC9, 0x80 +}; + +// Character 78 (0x4E) +// Box: 7 9 1 0 +// Advance: 9 +// +// +-------+ +// |** **| +// |*** **| +// |*** **| +// |** * **| +// |** * **| +// |** ***| +// |** ***| +// |** **| +// |** **| +// +-------+ +static const byte glyph78[] = { + 0xC6, + 0xE6, + 0xE6, + 0xD6, + 0xD6, + 0xCE, + 0xCE, + 0xC6, + 0xC6 +}; + +// Character 79 (0x4F) +// Box: 8 9 1 0 +// Advance: 10 +// +// +--------+ +// | **** | +// | ** ** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | **** | +// +--------+ +static const byte glyph79[] = { + 0x3C, + 0x66, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0x66, + 0x3C +}; + +// Character 80 (0x50) +// Box: 7 9 1 0 +// Advance: 8 +// +// +-------+ +// |****** | +// |** **| +// |** **| +// |** **| +// |****** | +// |** | +// |** | +// |** | +// |** | +// +-------+ +static const byte glyph80[] = { + 0xFC, + 0xC6, + 0xC6, + 0xC6, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 81 (0x51) +// Box: 8 9 1 0 +// Advance: 10 +// +// +--------+ +// | **** | +// | ** ** | +// |** **| +// |** **| +// |** **| +// |** * **| +// |** ****| +// | ** ** | +// | ******| +// +--------+ +static const byte glyph81[] = { + 0x3C, + 0x66, + 0xC3, + 0xC3, + 0xC3, + 0xCB, + 0xCF, + 0x66, + 0x3F +}; + +// Character 82 (0x52) +// Box: 7 9 1 0 +// Advance: 9 +// +// +-------+ +// |****** | +// |** **| +// |** **| +// |** **| +// |****** | +// |** ** | +// |** **| +// |** **| +// |** **| +// +-------+ +static const byte glyph82[] = { + 0xFC, + 0xC6, + 0xC6, + 0xC6, + 0xFC, + 0xCC, + 0xC6, + 0xC6, + 0xC6 +}; + +// Character 83 (0x53) +// Box: 7 9 1 0 +// Advance: 9 +// +// +-------+ +// | ***** | +// |** **| +// |** **| +// | *** | +// | *** | +// | ***| +// |** **| +// |** **| +// | ***** | +// +-------+ +static const byte glyph83[] = { + 0x7C, + 0xC6, + 0xC6, + 0x70, + 0x1C, + 0x0E, + 0xC6, + 0xC6, + 0x7C +}; + +// Character 84 (0x54) +// Box: 8 9 0 0 +// Advance: 8 +// +// +--------+ +// |********| +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// +--------+ +static const byte glyph84[] = { + 0xFF, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18, + 0x18 +}; + +// Character 85 (0x55) +// Box: 7 9 1 0 +// Advance: 9 +// +// +-------+ +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | ***** | +// +-------+ +static const byte glyph85[] = { + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0x6C, + 0x7C +}; + +// Character 86 (0x56) +// Box: 8 9 0 0 +// Advance: 8 +// +// +--------+ +// |** **| +// |** **| +// | ** ** | +// | ** ** | +// | ** ** | +// | * * | +// | **** | +// | ** | +// | ** | +// +--------+ +static const byte glyph86[] = { + 0xC3, + 0xC3, + 0x66, + 0x66, + 0x66, + 0x24, + 0x3C, + 0x18, + 0x18 +}; + +// Character 87 (0x57) +// Box: 10 9 0 0 +// Advance: 10 +// +// +----------+ +// |** ** **| +// |** ** **| +// |** ** **| +// | * ** * | +// | ** ** ** | +// | ** ** ** | +// | ** ** | +// | ** ** | +// | ** ** | +// +----------+ +static const byte glyph87[] = { + 0xCC, 0xC0, + 0xCC, 0xC0, + 0xCC, 0xC0, + 0x4C, 0x80, + 0x6D, 0x80, + 0x6D, 0x80, + 0x33, 0x00, + 0x33, 0x00, + 0x33, 0x00 +}; + +// Character 88 (0x58) +// Box: 8 9 0 0 +// Advance: 8 +// +// +--------+ +// |** **| +// |** **| +// | ** ** | +// | **** | +// | ** | +// | **** | +// | ** ** | +// |** **| +// |** **| +// +--------+ +static const byte glyph88[] = { + 0xC3, + 0xC3, + 0x66, + 0x3C, + 0x18, + 0x3C, + 0x66, + 0xC3, + 0xC3 +}; + +// Character 89 (0x59) +// Box: 8 9 0 0 +// Advance: 8 +// +// +--------+ +// |** **| +// |** **| +// | ** ** | +// | ** ** | +// | **** | +// | ** | +// | ** | +// | ** | +// | ** | +// +--------+ +static const byte glyph89[] = { + 0xC3, + 0xC3, + 0x66, + 0x66, + 0x3C, + 0x18, + 0x18, + 0x18, + 0x18 +}; + +// Character 90 (0x5A) +// Box: 7 9 0 0 +// Advance: 7 +// +// +-------+ +// |*******| +// | **| +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// |** | +// |*******| +// +-------+ +static const byte glyph90[] = { + 0xFE, + 0x06, + 0x0C, + 0x18, + 0x30, + 0x30, + 0x60, + 0xC0, + 0xFE +}; + +// Character 91 (0x5B) +// Box: 3 12 1 -3 +// Advance: 4 +// +// +---+ +// |***| +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |***| +// +---+ +static const byte glyph91[] = { + 0xE0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xE0 +}; + +// Character 92 (0x5C) +// Box: 4 9 0 0 +// Advance: 4 +// +// +----+ +// |** | +// |** | +// | * | +// | ** | +// | ** | +// | * | +// | * | +// | **| +// | **| +// +----+ +static const byte glyph92[] = { + 0xC0, + 0xC0, + 0x40, + 0x60, + 0x60, + 0x20, + 0x20, + 0x30, + 0x30 +}; + +// Character 93 (0x5D) +// Box: 3 12 0 -3 +// Advance: 4 +// +// +---+ +// |***| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// |***| +// +---+ +static const byte glyph93[] = { + 0xE0, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0xE0 +}; + +// Character 94 (0x5E) +// Box: 7 4 0 5 +// Advance: 7 +// +// +-------+ +// | * | +// | *** | +// | ** ** | +// |** **| +// +-------+ +static const byte glyph94[] = { + 0x10, + 0x38, + 0x6C, + 0xC6 +}; + +// Character 95 (0x5F) +// Box: 7 1 0 -3 +// Advance: 7 +// +// +-------+ +// |*******| +// +-------+ +static const byte glyph95[] = { + 0xFE +}; + +// Character 96 (0x60) +// Box: 3 2 0 8 +// Advance: 4 +// +// +---+ +// |** | +// | **| +// +---+ +static const byte glyph96[] = { + 0xC0, + 0x60 +}; + +// Character 97 (0x61) +// Box: 7 7 0 0 +// Advance: 7 +// +// +-------+ +// | **** | +// |** ** | +// | ** | +// | ***** | +// |** ** | +// |** ** | +// | *** **| +// +-------+ +static const byte glyph97[] = { + 0x78, + 0xCC, + 0x0C, + 0x7C, + 0xCC, + 0xCC, + 0x76 +}; + +// Character 98 (0x62) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// |** | +// |** | +// |** ** | +// |*** **| +// |** **| +// |** **| +// |** **| +// |*** **| +// |** ** | +// +------+ +static const byte glyph98[] = { + 0xC0, + 0xC0, + 0xD8, + 0xEC, + 0xCC, + 0xCC, + 0xCC, + 0xEC, + 0xD8 +}; + +// Character 99 (0x63) +// Box: 6 7 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |** | +// |** | +// |** | +// |** **| +// | **** | +// +------+ +static const byte glyph99[] = { + 0x78, + 0xCC, + 0xC0, + 0xC0, + 0xC0, + 0xCC, + 0x78 +}; + +// Character 100 (0x64) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | **| +// | **| +// | ** **| +// |** ***| +// |** **| +// |** **| +// |** **| +// |** ***| +// | ** **| +// +------+ +static const byte glyph100[] = { + 0x0C, + 0x0C, + 0x6C, + 0xDC, + 0xCC, + 0xCC, + 0xCC, + 0xDC, + 0x6C +}; + +// Character 101 (0x65) +// Box: 6 7 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |** **| +// |******| +// |** | +// |** **| +// | **** | +// +------+ +static const byte glyph101[] = { + 0x78, + 0xCC, + 0xCC, + 0xFC, + 0xC0, + 0xCC, + 0x78 +}; + +// Character 102 (0x66) +// Box: 5 9 0 0 +// Advance: 5 +// +// +-----+ +// | ***| +// | ** | +// |**** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// +-----+ +static const byte glyph102[] = { + 0x38, + 0x60, + 0xF0, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60 +}; + +// Character 103 (0x67) +// Box: 6 10 0 -3 +// Advance: 7 +// +// +------+ +// | ** **| +// |** ***| +// |** **| +// |** **| +// |** **| +// |** ***| +// | ** **| +// | **| +// |** **| +// | **** | +// +------+ +static const byte glyph103[] = { + 0x6C, + 0xDC, + 0xCC, + 0xCC, + 0xCC, + 0xDC, + 0x6C, + 0x0C, + 0xCC, + 0x78 +}; + +// Character 104 (0x68) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// |** | +// |** | +// |** ** | +// |*** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// +------+ +static const byte glyph104[] = { + 0xC0, + 0xC0, + 0xD8, + 0xEC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC +}; + +// Character 105 (0x69) +// Box: 2 9 0 0 +// Advance: 3 +// +// +--+ +// |**| +// | | +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// +--+ +static const byte glyph105[] = { + 0xC0, + 0x00, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 106 (0x6A) +// Box: 3 12 -1 -3 +// Advance: 3 +// +// +---+ +// | **| +// | | +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// |** | +// +---+ +static const byte glyph106[] = { + 0x60, + 0x00, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0xC0 +}; + +// Character 107 (0x6B) +// Box: 7 9 0 0 +// Advance: 7 +// +// +-------+ +// |** | +// |** | +// |** ** | +// |** ** | +// |**** | +// |**** | +// |** ** | +// |** ** | +// |** **| +// +-------+ +static const byte glyph107[] = { + 0xC0, + 0xC0, + 0xCC, + 0xD8, + 0xF0, + 0xF0, + 0xD8, + 0xCC, + 0xC6 +}; + +// Character 108 (0x6C) +// Box: 2 9 0 0 +// Advance: 3 +// +// +--+ +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// +--+ +static const byte glyph108[] = { + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 109 (0x6D) +// Box: 10 7 0 0 +// Advance: 11 +// +// +----------+ +// |* *** *** | +// |** ** **| +// |** ** **| +// |** ** **| +// |** ** **| +// |** ** **| +// |** ** **| +// +----------+ +static const byte glyph109[] = { + 0xBB, 0x80, + 0xCC, 0xC0, + 0xCC, 0xC0, + 0xCC, 0xC0, + 0xCC, 0xC0, + 0xCC, 0xC0, + 0xCC, 0xC0 +}; + +// Character 110 (0x6E) +// Box: 6 7 0 0 +// Advance: 7 +// +// +------+ +// |** ** | +// |*** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// +------+ +static const byte glyph110[] = { + 0xD8, + 0xEC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC +}; + +// Character 111 (0x6F) +// Box: 6 7 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph111[] = { + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 112 (0x70) +// Box: 6 10 0 -3 +// Advance: 7 +// +// +------+ +// |** ** | +// |*** **| +// |** **| +// |** **| +// |** **| +// |*** **| +// |** ** | +// |** | +// |** | +// |** | +// +------+ +static const byte glyph112[] = { + 0xD8, + 0xEC, + 0xCC, + 0xCC, + 0xCC, + 0xEC, + 0xD8, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 113 (0x71) +// Box: 6 10 0 -3 +// Advance: 7 +// +// +------+ +// | *** *| +// |** ***| +// |** **| +// |** **| +// |** **| +// |** ***| +// | ** **| +// | **| +// | **| +// | **| +// +------+ +static const byte glyph113[] = { + 0x74, + 0xDC, + 0xCC, + 0xCC, + 0xCC, + 0xDC, + 0x6C, + 0x0C, + 0x0C, + 0x0C +}; + +// Character 114 (0x72) +// Box: 5 7 0 0 +// Advance: 5 +// +// +-----+ +// |** **| +// |*****| +// |*** | +// |** | +// |** | +// |** | +// |** | +// +-----+ +static const byte glyph114[] = { + 0xD8, + 0xF8, + 0xE0, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 115 (0x73) +// Box: 6 7 0 0 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |*** | +// | *** | +// | ***| +// |** **| +// | **** | +// +------+ +static const byte glyph115[] = { + 0x78, + 0xCC, + 0xE0, + 0x38, + 0x1C, + 0xCC, + 0x78 +}; + +// Character 116 (0x74) +// Box: 5 9 0 0 +// Advance: 5 +// +// +-----+ +// | ** | +// | ** | +// |**** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** *| +// | ** | +// +-----+ +static const byte glyph116[] = { + 0x60, + 0x60, + 0xF0, + 0x60, + 0x60, + 0x60, + 0x60, + 0x68, + 0x30 +}; + +// Character 117 (0x75) +// Box: 6 7 0 0 +// Advance: 7 +// +// +------+ +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** ***| +// | ** **| +// +------+ +static const byte glyph117[] = { + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xDC, + 0x6C +}; + +// Character 118 (0x76) +// Box: 7 7 0 0 +// Advance: 8 +// +// +-------+ +// |** **| +// |** **| +// | ** ** | +// | ** ** | +// | *** | +// | *** | +// | * | +// +-------+ +static const byte glyph118[] = { + 0xC6, + 0xC6, + 0x6C, + 0x6C, + 0x38, + 0x38, + 0x10 +}; + +// Character 119 (0x77) +// Box: 10 7 0 0 +// Advance: 11 +// +// +----------+ +// |** ** **| +// |** ** **| +// | ** ** ** | +// | ** ** ** | +// | ** ** ** | +// | ** ** | +// | ** ** | +// +----------+ +static const byte glyph119[] = { + 0xCC, 0xC0, + 0xCC, 0xC0, + 0x6D, 0x80, + 0x6D, 0x80, + 0x6D, 0x80, + 0x33, 0x00, + 0x33, 0x00 +}; + +// Character 120 (0x78) +// Box: 6 7 0 0 +// Advance: 7 +// +// +------+ +// |** **| +// |** **| +// | **** | +// | ** | +// | **** | +// |** **| +// |** **| +// +------+ +static const byte glyph120[] = { + 0xCC, + 0xCC, + 0x78, + 0x30, + 0x78, + 0xCC, + 0xCC +}; + +// Character 121 (0x79) +// Box: 7 10 0 -3 +// Advance: 8 +// +// +-------+ +// |** **| +// |** **| +// | ** ** | +// | ** ** | +// | *** | +// | *** | +// | ** | +// | * | +// | ** | +// | ** | +// +-------+ +static const byte glyph121[] = { + 0xC6, + 0xC6, + 0x6C, + 0x6C, + 0x38, + 0x38, + 0x18, + 0x10, + 0x30, + 0x60 +}; + +// Character 122 (0x7A) +// Box: 5 7 0 0 +// Advance: 6 +// +// +-----+ +// |*****| +// | **| +// | ** | +// | * | +// | ** | +// |** | +// |*****| +// +-----+ +static const byte glyph122[] = { + 0xF8, + 0x18, + 0x30, + 0x20, + 0x60, + 0xC0, + 0xF8 +}; + +// Character 123 (0x7B) +// Box: 4 12 0 -3 +// Advance: 5 +// +// +----+ +// | **| +// | ** | +// | ** | +// | ** | +// | ** | +// |** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | **| +// +----+ +static const byte glyph123[] = { + 0x30, + 0x60, + 0x60, + 0x60, + 0x60, + 0xC0, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x30 +}; + +// Character 124 (0x7C) +// Box: 2 12 1 -3 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// +--+ +static const byte glyph124[] = { + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 125 (0x7D) +// Box: 4 12 0 -3 +// Advance: 5 +// +// +----+ +// |** | +// | ** | +// | ** | +// | ** | +// | ** | +// | **| +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// |** | +// +----+ +static const byte glyph125[] = { + 0xC0, + 0x60, + 0x60, + 0x60, + 0x60, + 0x30, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0xC0 +}; + +// Character 126 (0x7E) +// Box: 7 2 0 3 +// Advance: 7 +// +// +-------+ +// | *** **| +// |** *** | +// +-------+ +static const byte glyph126[] = { + 0x76, + 0xDC +}; + +// Character 160 (0xA0) +// Box: 1 1 0 0 +// Advance: 4 +// +// +-+ +// | | +// +-+ +static const byte glyph160[] = { + 0x00 +}; + +// Character 161 (0xA1) +// Box: 2 10 1 -3 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// | | +// | *| +// |**| +// |**| +// |**| +// |**| +// |**| +// |**| +// +--+ +static const byte glyph161[] = { + 0xC0, + 0xC0, + 0x00, + 0x40, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 162 (0xA2) +// Box: 6 9 0 -1 +// Advance: 7 +// +// +------+ +// | * | +// | **** | +// |** ***| +// |* * | +// |* * | +// |* * | +// |*** **| +// | **** | +// | * | +// +------+ +static const byte glyph162[] = { + 0x10, + 0x78, + 0xDC, + 0x90, + 0xA0, + 0xA0, + 0xEC, + 0x78, + 0x40 +}; + +// Character 163 (0xA3) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | *** | +// | ** **| +// | ** | +// | ** | +// |***** | +// | ** | +// | ** | +// |*** **| +// |** ** | +// +------+ +static const byte glyph163[] = { + 0x38, + 0x6C, + 0x60, + 0x60, + 0xF8, + 0x60, + 0x60, + 0xEC, + 0xD8 +}; + +// Character 164 (0xA4) +// Box: 6 6 0 1 +// Advance: 7 +// +// +------+ +// |** **| +// | **** | +// | * * | +// | * * | +// | **** | +// |** **| +// +------+ +static const byte glyph164[] = { + 0xCC, + 0x78, + 0x48, + 0x48, + 0x78, + 0xCC +}; + +// Character 165 (0xA5) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// |** **| +// |** **| +// | * * | +// |******| +// | ** | +// |******| +// | ** | +// | ** | +// | ** | +// +------+ +static const byte glyph165[] = { + 0xCC, + 0xCC, + 0x48, + 0xFC, + 0x30, + 0xFC, + 0x30, + 0x30, + 0x30 +}; + +// Character 166 (0xA6) +// Box: 2 11 1 -2 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// |**| +// |**| +// | | +// | | +// |**| +// |**| +// |**| +// |**| +// |**| +// +--+ +static const byte glyph166[] = { + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0x00, + 0x00, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 167 (0xA7) +// Box: 6 12 0 -3 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |*** | +// | *** | +// |** ** | +// |** **| +// |** **| +// | ** **| +// | *** | +// | ***| +// |** **| +// | **** | +// +------+ +static const byte glyph167[] = { + 0x78, + 0xCC, + 0xE0, + 0x70, + 0xD8, + 0xCC, + 0xCC, + 0x6C, + 0x38, + 0x1C, + 0xCC, + 0x78 +}; + +// Character 168 (0xA8) +// Box: 5 1 0 8 +// Advance: 5 +// +// +-----+ +// |** **| +// +-----+ +static const byte glyph168[] = { + 0xD8 +}; + +// Character 169 (0xA9) +// Box: 9 9 1 0 +// Advance: 11 +// +// +---------+ +// | ***** | +// | * * | +// |* *** *| +// |* * * *| +// |* * *| +// |* * * *| +// |* *** *| +// | * * | +// | ***** | +// +---------+ +static const byte glyph169[] = { + 0x3E, 0x00, + 0x41, 0x00, + 0x9C, 0x80, + 0xA2, 0x80, + 0xA0, 0x80, + 0xA2, 0x80, + 0x9C, 0x80, + 0x41, 0x00, + 0x3E, 0x00 +}; + +// Character 170 (0xAA) +// Box: 4 6 1 3 +// Advance: 6 +// +// +----+ +// |*** | +// | **| +// |****| +// |* **| +// | | +// |****| +// +----+ +static const byte glyph170[] = { + 0xE0, + 0x30, + 0xF0, + 0xB0, + 0x00, + 0xF0 +}; + +// Character 171 (0xAB) +// Box: 6 5 1 1 +// Advance: 8 +// +// +------+ +// | * *| +// | ** **| +// |** ** | +// | ** **| +// | * *| +// +------+ +static const byte glyph171[] = { + 0x24, + 0x6C, + 0xD8, + 0x6C, + 0x24 +}; + +// Character 172 (0xAC) +// Box: 6 4 1 2 +// Advance: 8 +// +// +------+ +// |******| +// | *| +// | *| +// | *| +// +------+ +static const byte glyph172[] = { + 0xFC, + 0x04, + 0x04, + 0x04 +}; + +// Character 173 (0xAD) +// Box: 4 1 0 3 +// Advance: 5 +// +// +----+ +// |****| +// +----+ +static const byte glyph173[] = { + 0xF0 +}; + +// Character 174 (0xAE) +// Box: 9 9 1 0 +// Advance: 11 +// +// +---------+ +// | ***** | +// | * * | +// |* *** *| +// |* * * *| +// |* ** *| +// |* * * *| +// |* * * *| +// | * * | +// | ***** | +// +---------+ +static const byte glyph174[] = { + 0x3E, 0x00, + 0x41, 0x00, + 0x9C, 0x80, + 0x94, 0x80, + 0x98, 0x80, + 0x94, 0x80, + 0x94, 0x80, + 0x41, 0x00, + 0x3E, 0x00 +}; + +// Character 175 (0xAF) +// Box: 4 1 0 8 +// Advance: 4 +// +// +----+ +// |****| +// +----+ +static const byte glyph175[] = { + 0xF0 +}; + +// Character 176 (0xB0) +// Box: 4 4 0 4 +// Advance: 5 +// +// +----+ +// | ** | +// |* *| +// |* *| +// | ** | +// +----+ +static const byte glyph176[] = { + 0x60, + 0x90, + 0x90, + 0x60 +}; + +// Character 177 (0xB1) +// Box: 6 7 0 0 +// Advance: 7 +// +// +------+ +// | ** | +// | ** | +// |******| +// | ** | +// | ** | +// | | +// |******| +// +------+ +static const byte glyph177[] = { + 0x30, + 0x30, + 0xFC, + 0x30, + 0x30, + 0x00, + 0xFC +}; + +// Character 178 (0xB2) +// Box: 4 5 0 4 +// Advance: 4 +// +// +----+ +// | ** | +// |* **| +// | ** | +// |** | +// |****| +// +----+ +static const byte glyph178[] = { + 0x60, + 0xB0, + 0x60, + 0xC0, + 0xF0 +}; + +// Character 179 (0xB3) +// Box: 4 5 0 4 +// Advance: 4 +// +// +----+ +// | ** | +// |* **| +// | ** | +// | **| +// |*** | +// +----+ +static const byte glyph179[] = { + 0x60, + 0xB0, + 0x60, + 0x30, + 0xE0 +}; + +// Character 180 (0xB4) +// Box: 3 2 0 8 +// Advance: 4 +// +// +---+ +// | **| +// |** | +// +---+ +static const byte glyph180[] = { + 0x60, + 0xC0 +}; + +// Character 181 (0xB5) +// Box: 6 10 0 -3 +// Advance: 7 +// +// +------+ +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** ***| +// |*** **| +// |** | +// |** | +// |** | +// +------+ +static const byte glyph181[] = { + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xDC, + 0xEC, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 182 (0xB6) +// Box: 7 12 0 -3 +// Advance: 7 +// +// +-------+ +// | *****| +// | *** * | +// |**** * | +// |**** * | +// |**** * | +// | *** * | +// | ** * | +// | * * | +// | * * | +// | * * | +// | * * | +// | * * | +// +-------+ +static const byte glyph182[] = { + 0x3E, + 0x74, + 0xF4, + 0xF4, + 0xF4, + 0x74, + 0x34, + 0x14, + 0x14, + 0x14, + 0x14, + 0x14 +}; + +// Character 183 (0xB7) +// Box: 2 2 1 3 +// Advance: 4 +// +// +--+ +// |**| +// |**| +// +--+ +static const byte glyph183[] = { + 0xC0, + 0xC0 +}; + +// Character 184 (0xB8) +// Box: 4 4 0 -3 +// Advance: 4 +// +// +----+ +// | ** | +// | **| +// | **| +// |*** | +// +----+ +static const byte glyph184[] = { + 0x60, + 0x30, + 0x30, + 0xE0 +}; + +// Character 185 (0xB9) +// Box: 3 5 0 4 +// Advance: 4 +// +// +---+ +// | **| +// |***| +// | **| +// | **| +// | **| +// +---+ +static const byte glyph185[] = { + 0x60, + 0xE0, + 0x60, + 0x60, + 0x60 +}; + +// Character 186 (0xBA) +// Box: 4 6 1 3 +// Advance: 6 +// +// +----+ +// | ** | +// |** *| +// |** *| +// | ** | +// | | +// |****| +// +----+ +static const byte glyph186[] = { + 0x60, + 0xD0, + 0xD0, + 0x60, + 0x00, + 0xF0 +}; + +// Character 187 (0xBB) +// Box: 6 5 1 1 +// Advance: 8 +// +// +------+ +// |* * | +// |** ** | +// | ** **| +// |** ** | +// |* * | +// +------+ +static const byte glyph187[] = { + 0x90, + 0xD8, + 0x6C, + 0xD8, + 0x90 +}; + +// Character 188 (0xBC) +// Box: 10 9 0 0 +// Advance: 10 +// +// +----------+ +// | ** ** | +// |*** ** | +// | ** ** | +// | ** ** | +// | ** ** ** | +// | * *** | +// | ** * * | +// | ** *****| +// | ** ** | +// +----------+ +static const byte glyph188[] = { + 0x63, 0x00, + 0xE6, 0x00, + 0x66, 0x00, + 0x6C, 0x00, + 0x6D, 0x80, + 0x0B, 0x80, + 0x1A, 0x80, + 0x37, 0xC0, + 0x31, 0x80 +}; + +// Character 189 (0xBD) +// Box: 10 9 0 0 +// Advance: 10 +// +// +----------+ +// | ** ** | +// |*** ** | +// | ** ** | +// | ** ** | +// | ** ** ** | +// | * * **| +// | ** ** | +// | ** ** | +// | ** ****| +// +----------+ +static const byte glyph189[] = { + 0x63, 0x00, + 0xE6, 0x00, + 0x66, 0x00, + 0x6C, 0x00, + 0x6D, 0x80, + 0x0A, 0xC0, + 0x19, 0x80, + 0x33, 0x00, + 0x33, 0xC0 +}; + +// Character 190 (0xBE) +// Box: 10 9 0 0 +// Advance: 10 +// +// +----------+ +// | ** ** | +// |* ** ** | +// | ** ** | +// | ** ** | +// |*** ** ** | +// | * *** | +// | ** * * | +// | ** *****| +// | ** ** | +// +----------+ +static const byte glyph190[] = { + 0x63, 0x00, + 0xB3, 0x00, + 0x66, 0x00, + 0x36, 0x00, + 0xED, 0x80, + 0x0B, 0x80, + 0x1A, 0x80, + 0x37, 0xC0, + 0x31, 0x80 +}; + +// Character 191 (0xBF) +// Box: 6 10 1 -3 +// Advance: 8 +// +// +------+ +// | ** | +// | ** | +// | | +// | ** | +// | ** | +// | ** | +// | ** | +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph191[] = { + 0x30, + 0x30, + 0x00, + 0x30, + 0x30, + 0x30, + 0x60, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 192 (0xC0) +// Box: 8 12 0 0 +// Advance: 8 +// +// +--------+ +// | ** | +// | ** | +// | | +// | ** | +// | ** | +// | **** | +// | * * | +// | ** ** | +// | ****** | +// |** **| +// |** **| +// |** **| +// +--------+ +static const byte glyph192[] = { + 0x30, + 0x18, + 0x00, + 0x18, + 0x18, + 0x3C, + 0x24, + 0x66, + 0x7E, + 0xC3, + 0xC3, + 0xC3 +}; + +// Character 193 (0xC1) +// Box: 8 12 0 0 +// Advance: 8 +// +// +--------+ +// | ** | +// | ** | +// | | +// | ** | +// | ** | +// | **** | +// | * * | +// | ** ** | +// | ****** | +// |** **| +// |** **| +// |** **| +// +--------+ +static const byte glyph193[] = { + 0x0C, + 0x18, + 0x00, + 0x18, + 0x18, + 0x3C, + 0x24, + 0x66, + 0x7E, + 0xC3, + 0xC3, + 0xC3 +}; + +// Character 194 (0xC2) +// Box: 8 12 0 0 +// Advance: 8 +// +// +--------+ +// | *** | +// | ** ** | +// | | +// | ** | +// | ** | +// | **** | +// | * * | +// | ** ** | +// | ****** | +// |** **| +// |** **| +// |** **| +// +--------+ +static const byte glyph194[] = { + 0x1C, + 0x36, + 0x00, + 0x18, + 0x18, + 0x3C, + 0x24, + 0x66, + 0x7E, + 0xC3, + 0xC3, + 0xC3 +}; + +// Character 195 (0xC3) +// Box: 8 12 0 0 +// Advance: 8 +// +// +--------+ +// | ** * | +// | * ** | +// | | +// | ** | +// | ** | +// | **** | +// | * * | +// | ** ** | +// | ****** | +// |** **| +// |** **| +// |** **| +// +--------+ +static const byte glyph195[] = { + 0x1A, + 0x2C, + 0x00, + 0x18, + 0x18, + 0x3C, + 0x24, + 0x66, + 0x7E, + 0xC3, + 0xC3, + 0xC3 +}; + +// Character 196 (0xC4) +// Box: 8 11 0 0 +// Advance: 8 +// +// +--------+ +// | ** ** | +// | | +// | ** | +// | ** | +// | **** | +// | * * | +// | ** ** | +// | ****** | +// |** **| +// |** **| +// |** **| +// +--------+ +static const byte glyph196[] = { + 0x36, + 0x00, + 0x18, + 0x18, + 0x3C, + 0x24, + 0x66, + 0x7E, + 0xC3, + 0xC3, + 0xC3 +}; + +// Character 197 (0xC5) +// Box: 8 12 0 0 +// Advance: 8 +// +// +--------+ +// | ** | +// | * * | +// | ** | +// | ** | +// | ** | +// | **** | +// | * * | +// | ** ** | +// | ****** | +// |** **| +// |** **| +// |** **| +// +--------+ +static const byte glyph197[] = { + 0x18, + 0x24, + 0x18, + 0x18, + 0x18, + 0x3C, + 0x24, + 0x66, + 0x7E, + 0xC3, + 0xC3, + 0xC3 +}; + +// Character 198 (0xC6) +// Box: 11 9 1 0 +// Advance: 13 +// +// +-----------+ +// | ********| +// | ** ** | +// | * ** | +// | ** ** | +// | ** ******| +// | ****** | +// |** ** | +// |** ** | +// |** ******| +// +-----------+ +static const byte glyph198[] = { + 0x1F, 0xE0, + 0x36, 0x00, + 0x26, 0x00, + 0x66, 0x00, + 0x67, 0xE0, + 0x7E, 0x00, + 0xC6, 0x00, + 0xC6, 0x00, + 0xC7, 0xE0 +}; + +// Character 199 (0xC7) +// Box: 7 12 1 -3 +// Advance: 8 +// +// +-------+ +// | **** | +// | ** **| +// |** | +// |** | +// |** | +// |** | +// |** | +// | ** **| +// | **** | +// | ** | +// | ** | +// | *** | +// +-------+ +static const byte glyph199[] = { + 0x3C, + 0x66, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0x66, + 0x3C, + 0x18, + 0x18, + 0x70 +}; + +// Character 200 (0xC8) +// Box: 6 12 1 0 +// Advance: 8 +// +// +------+ +// | ** | +// | ** | +// | | +// |******| +// |** | +// |** | +// |** | +// |******| +// |** | +// |** | +// |** | +// |******| +// +------+ +static const byte glyph200[] = { + 0x60, + 0x30, + 0x00, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC +}; + +// Character 201 (0xC9) +// Box: 6 12 1 0 +// Advance: 8 +// +// +------+ +// | ** | +// | ** | +// | | +// |******| +// |** | +// |** | +// |** | +// |******| +// |** | +// |** | +// |** | +// |******| +// +------+ +static const byte glyph201[] = { + 0x18, + 0x30, + 0x00, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC +}; + +// Character 202 (0xCA) +// Box: 6 12 1 0 +// Advance: 8 +// +// +------+ +// | *** | +// | ** **| +// | | +// |******| +// |** | +// |** | +// |** | +// |******| +// |** | +// |** | +// |** | +// |******| +// +------+ +static const byte glyph202[] = { + 0x38, + 0x6C, + 0x00, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC +}; + +// Character 203 (0xCB) +// Box: 6 11 1 0 +// Advance: 8 +// +// +------+ +// | ** **| +// | | +// |******| +// |** | +// |** | +// |** | +// |******| +// |** | +// |** | +// |** | +// |******| +// +------+ +static const byte glyph203[] = { + 0x6C, + 0x00, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC, + 0xC0, + 0xC0, + 0xC0, + 0xFC +}; + +// Character 204 (0xCC) +// Box: 3 12 0 0 +// Advance: 4 +// +// +---+ +// |** | +// | **| +// | | +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// +---+ +static const byte glyph204[] = { + 0xC0, + 0x60, + 0x00, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60 +}; + +// Character 205 (0xCD) +// Box: 3 12 1 0 +// Advance: 4 +// +// +---+ +// | **| +// |** | +// | | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// +---+ +static const byte glyph205[] = { + 0x60, + 0xC0, + 0x00, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 206 (0xCE) +// Box: 5 12 0 0 +// Advance: 4 +// +// +-----+ +// | *** | +// |** **| +// | | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// +-----+ +static const byte glyph206[] = { + 0x70, + 0xD8, + 0x00, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60 +}; + +// Character 207 (0xCF) +// Box: 5 11 0 0 +// Advance: 4 +// +// +-----+ +// |** **| +// | | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// +-----+ +static const byte glyph207[] = { + 0xD8, + 0x00, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60 +}; + +// Character 208 (0xD0) +// Box: 8 9 0 0 +// Advance: 9 +// +// +--------+ +// | ***** | +// | ** ** | +// | ** **| +// | ** **| +// |**** **| +// | ** **| +// | ** **| +// | ** ** | +// | ***** | +// +--------+ +static const byte glyph208[] = { + 0x7C, + 0x66, + 0x63, + 0x63, + 0xF3, + 0x63, + 0x63, + 0x66, + 0x7C +}; + +// Character 209 (0xD1) +// Box: 7 12 1 0 +// Advance: 9 +// +// +-------+ +// | ** * | +// | * ** | +// | | +// |** **| +// |** **| +// |*** **| +// |*** **| +// |**** **| +// |** ***| +// |** ***| +// |** **| +// |** **| +// +-------+ +static const byte glyph209[] = { + 0x34, + 0x58, + 0x00, + 0xC6, + 0xC6, + 0xE6, + 0xE6, + 0xF6, + 0xCE, + 0xCE, + 0xC6, + 0xC6 +}; + +// Character 210 (0xD2) +// Box: 8 12 1 0 +// Advance: 10 +// +// +--------+ +// | ** | +// | ** | +// | | +// | **** | +// | ** ** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | **** | +// +--------+ +static const byte glyph210[] = { + 0x30, + 0x18, + 0x00, + 0x3C, + 0x66, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0x66, + 0x3C +}; + +// Character 211 (0xD3) +// Box: 8 12 1 0 +// Advance: 10 +// +// +--------+ +// | ** | +// | ** | +// | | +// | **** | +// | ** ** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | **** | +// +--------+ +static const byte glyph211[] = { + 0x0C, + 0x18, + 0x00, + 0x3C, + 0x66, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0x66, + 0x3C +}; + +// Character 212 (0xD4) +// Box: 8 12 1 0 +// Advance: 10 +// +// +--------+ +// | *** | +// | ** ** | +// | | +// | **** | +// | ** ** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | **** | +// +--------+ +static const byte glyph212[] = { + 0x1C, + 0x36, + 0x00, + 0x3C, + 0x66, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0x66, + 0x3C +}; + +// Character 213 (0xD5) +// Box: 8 12 1 0 +// Advance: 10 +// +// +--------+ +// | ** * | +// | * ** | +// | | +// | **** | +// | ** ** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | **** | +// +--------+ +static const byte glyph213[] = { + 0x1A, + 0x2C, + 0x00, + 0x3C, + 0x66, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0x66, + 0x3C +}; + +// Character 214 (0xD6) +// Box: 8 11 1 0 +// Advance: 10 +// +// +--------+ +// | ** ** | +// | | +// | **** | +// | ** ** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | **** | +// +--------+ +static const byte glyph214[] = { + 0x66, + 0x00, + 0x3C, + 0x66, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0xC3, + 0x66, + 0x3C +}; + +// Character 215 (0xD7) +// Box: 6 5 0 1 +// Advance: 7 +// +// +------+ +// |** **| +// | **** | +// | ** | +// | **** | +// |** **| +// +------+ +static const byte glyph215[] = { + 0xCC, + 0x78, + 0x30, + 0x78, + 0xCC +}; + +// Character 216 (0xD8) +// Box: 8 10 1 -1 +// Advance: 10 +// +// +--------+ +// | **** *| +// | ** ** | +// |** ****| +// |** * **| +// |** ** **| +// |** * **| +// |**** **| +// | ** ** | +// | ***** | +// |* | +// +--------+ +static const byte glyph216[] = { + 0x3D, + 0x66, + 0xCF, + 0xCB, + 0xDB, + 0xD3, + 0xF3, + 0x66, + 0x7C, + 0x80 +}; + +// Character 217 (0xD9) +// Box: 7 12 1 0 +// Advance: 9 +// +// +-------+ +// | ** | +// | ** | +// | | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | ***** | +// +-------+ +static const byte glyph217[] = { + 0x30, + 0x18, + 0x00, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0x6C, + 0x7C +}; + +// Character 218 (0xDA) +// Box: 7 12 1 0 +// Advance: 9 +// +// +-------+ +// | ** | +// | ** | +// | | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | ***** | +// +-------+ +static const byte glyph218[] = { + 0x0C, + 0x18, + 0x00, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0x6C, + 0x7C +}; + +// Character 219 (0xDB) +// Box: 7 12 1 0 +// Advance: 9 +// +// +-------+ +// | *** | +// | ** ** | +// | | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | ***** | +// +-------+ +static const byte glyph219[] = { + 0x38, + 0x6C, + 0x00, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0x6C, + 0x7C +}; + +// Character 220 (0xDC) +// Box: 7 11 1 0 +// Advance: 9 +// +// +-------+ +// | ** ** | +// | | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | ** ** | +// | ***** | +// +-------+ +static const byte glyph220[] = { + 0x6C, + 0x00, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0xC6, + 0x6C, + 0x7C +}; + +// Character 221 (0xDD) +// Box: 8 12 0 0 +// Advance: 8 +// +// +--------+ +// | ** | +// | ** | +// | | +// |** **| +// |** **| +// | ** ** | +// | ** ** | +// | * * | +// | **** | +// | ** | +// | ** | +// | ** | +// +--------+ +static const byte glyph221[] = { + 0x0C, + 0x18, + 0x00, + 0xC3, + 0xC3, + 0x66, + 0x66, + 0x24, + 0x3C, + 0x18, + 0x18, + 0x18 +}; + +// Character 222 (0xDE) +// Box: 7 9 1 0 +// Advance: 8 +// +// +-------+ +// |** | +// |** | +// |****** | +// |** **| +// |** **| +// |** **| +// |****** | +// |** | +// |** | +// +-------+ +static const byte glyph222[] = { + 0xC0, + 0xC0, + 0xFC, + 0xC6, + 0xC6, + 0xC6, + 0xFC, + 0xC0, + 0xC0 +}; + +// Character 223 (0xDF) +// Box: 6 9 1 0 +// Advance: 8 +// +// +------+ +// | **** | +// |** **| +// |** **| +// |** **| +// |** ** | +// |** **| +// |** **| +// |** **| +// |** ** | +// +------+ +static const byte glyph223[] = { + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0xD8, + 0xCC, + 0xCC, + 0xCC, + 0xD8 +}; + +// Character 224 (0xE0) +// Box: 7 10 0 0 +// Advance: 7 +// +// +-------+ +// | ** | +// | ** | +// | | +// | **** | +// |** ** | +// | ** | +// | ***** | +// |** ** | +// |** ** | +// | *** **| +// +-------+ +static const byte glyph224[] = { + 0x30, + 0x18, + 0x00, + 0x78, + 0xCC, + 0x0C, + 0x7C, + 0xCC, + 0xCC, + 0x76 +}; + +// Character 225 (0xE1) +// Box: 7 10 0 0 +// Advance: 7 +// +// +-------+ +// | ** | +// | ** | +// | | +// | **** | +// |** ** | +// | ** | +// | ***** | +// |** ** | +// |** ** | +// | *** **| +// +-------+ +static const byte glyph225[] = { + 0x18, + 0x30, + 0x00, + 0x78, + 0xCC, + 0x0C, + 0x7C, + 0xCC, + 0xCC, + 0x76 +}; + +// Character 226 (0xE2) +// Box: 7 10 0 0 +// Advance: 7 +// +// +-------+ +// | *** | +// | ** ** | +// | | +// | **** | +// |** ** | +// | ** | +// | ***** | +// |** ** | +// |** ** | +// | *** **| +// +-------+ +static const byte glyph226[] = { + 0x38, + 0x6C, + 0x00, + 0x78, + 0xCC, + 0x0C, + 0x7C, + 0xCC, + 0xCC, + 0x76 +}; + +// Character 227 (0xE3) +// Box: 7 10 0 0 +// Advance: 7 +// +// +-------+ +// | ** * | +// | * ** | +// | | +// | **** | +// |** ** | +// | ** | +// | ***** | +// |** ** | +// |** ** | +// | *** **| +// +-------+ +static const byte glyph227[] = { + 0x34, + 0x58, + 0x00, + 0x78, + 0xCC, + 0x0C, + 0x7C, + 0xCC, + 0xCC, + 0x76 +}; + +// Character 228 (0xE4) +// Box: 7 9 0 0 +// Advance: 7 +// +// +-------+ +// | ** ** | +// | | +// | **** | +// |** ** | +// | ** | +// | ***** | +// |** ** | +// |** ** | +// | *** **| +// +-------+ +static const byte glyph228[] = { + 0x6C, + 0x00, + 0x78, + 0xCC, + 0x0C, + 0x7C, + 0xCC, + 0xCC, + 0x76 +}; + +// Character 229 (0xE5) +// Box: 7 11 0 0 +// Advance: 7 +// +// +-------+ +// | ** | +// | * * | +// | ** | +// | | +// | **** | +// |** ** | +// | ** | +// | ***** | +// |** ** | +// |** ** | +// | *** **| +// +-------+ +static const byte glyph229[] = { + 0x30, + 0x48, + 0x30, + 0x00, + 0x78, + 0xCC, + 0x0C, + 0x7C, + 0xCC, + 0xCC, + 0x76 +}; + +// Character 230 (0xE6) +// Box: 10 7 0 0 +// Advance: 11 +// +// +----------+ +// | *** **** | +// |** ** **| +// | ** **| +// | *********| +// |** ** | +// |** ** **| +// | *** **** | +// +----------+ +static const byte glyph230[] = { + 0x77, 0x80, + 0xCC, 0xC0, + 0x0C, 0xC0, + 0x7F, 0xC0, + 0xCC, 0x00, + 0xCC, 0xC0, + 0x77, 0x80 +}; + +// Character 231 (0xE7) +// Box: 6 10 0 -3 +// Advance: 7 +// +// +------+ +// | **** | +// |** **| +// |** | +// |** | +// |** | +// |** **| +// | **** | +// | * | +// | ** | +// | *** | +// +------+ +static const byte glyph231[] = { + 0x78, + 0xCC, + 0xC0, + 0xC0, + 0xC0, + 0xCC, + 0x78, + 0x10, + 0x18, + 0x70 +}; + +// Character 232 (0xE8) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | ** | +// | ** | +// | | +// | **** | +// |** **| +// |** **| +// |******| +// |** | +// |** **| +// | **** | +// +------+ +static const byte glyph232[] = { + 0x60, + 0x30, + 0x00, + 0x78, + 0xCC, + 0xCC, + 0xFC, + 0xC0, + 0xCC, + 0x78 +}; + +// Character 233 (0xE9) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | ** | +// | ** | +// | | +// | **** | +// |** **| +// |** **| +// |******| +// |** | +// |** **| +// | **** | +// +------+ +static const byte glyph233[] = { + 0x18, + 0x30, + 0x00, + 0x78, + 0xCC, + 0xCC, + 0xFC, + 0xC0, + 0xCC, + 0x78 +}; + +// Character 234 (0xEA) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | *** | +// | ** **| +// | | +// | **** | +// |** **| +// |** **| +// |******| +// |** | +// |** **| +// | **** | +// +------+ +static const byte glyph234[] = { + 0x38, + 0x6C, + 0x00, + 0x78, + 0xCC, + 0xCC, + 0xFC, + 0xC0, + 0xCC, + 0x78 +}; + +// Character 235 (0xEB) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | ** **| +// | | +// | **** | +// |** **| +// |** **| +// |******| +// |** | +// |** **| +// | **** | +// +------+ +static const byte glyph235[] = { + 0x6C, + 0x00, + 0x78, + 0xCC, + 0xCC, + 0xFC, + 0xC0, + 0xCC, + 0x78 +}; + +// Character 236 (0xEC) +// Box: 3 10 -1 0 +// Advance: 3 +// +// +---+ +// |** | +// | **| +// | | +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// | **| +// +---+ +static const byte glyph236[] = { + 0xC0, + 0x60, + 0x00, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60 +}; + +// Character 237 (0xED) +// Box: 3 10 0 0 +// Advance: 3 +// +// +---+ +// | **| +// |** | +// | | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// |** | +// +---+ +static const byte glyph237[] = { + 0x60, + 0xC0, + 0x00, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 238 (0xEE) +// Box: 5 10 -1 0 +// Advance: 3 +// +// +-----+ +// | *** | +// |** **| +// | | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// +-----+ +static const byte glyph238[] = { + 0x70, + 0xD8, + 0x00, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60 +}; + +// Character 239 (0xEF) +// Box: 5 9 -1 0 +// Advance: 3 +// +// +-----+ +// |** **| +// | | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// | ** | +// +-----+ +static const byte glyph239[] = { + 0xD8, + 0x00, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60, + 0x60 +}; + +// Character 240 (0xF0) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// |** ** | +// | *** | +// |* * | +// | ** | +// | *****| +// |** **| +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph240[] = { + 0xD8, + 0x70, + 0x90, + 0x18, + 0x7C, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 241 (0xF1) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | ** *| +// | * ** | +// | | +// |** ** | +// |*** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// +------+ +static const byte glyph241[] = { + 0x34, + 0x58, + 0x00, + 0xD8, + 0xEC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC +}; + +// Character 242 (0xF2) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | ** | +// | ** | +// | | +// | **** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph242[] = { + 0x60, + 0x30, + 0x00, + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 243 (0xF3) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | ** | +// | ** | +// | | +// | **** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph243[] = { + 0x18, + 0x30, + 0x00, + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 244 (0xF4) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | *** | +// | ** **| +// | | +// | **** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph244[] = { + 0x38, + 0x6C, + 0x00, + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 245 (0xF5) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | ** *| +// | * ** | +// | | +// | **** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph245[] = { + 0x34, + 0x58, + 0x00, + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 246 (0xF6) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | ** **| +// | | +// | **** | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// | **** | +// +------+ +static const byte glyph246[] = { + 0x6C, + 0x00, + 0x78, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0x78 +}; + +// Character 247 (0xF7) +// Box: 6 5 0 1 +// Advance: 7 +// +// +------+ +// | ** | +// | | +// |******| +// | | +// | ** | +// +------+ +static const byte glyph247[] = { + 0x30, + 0x00, + 0xFC, + 0x00, + 0x30 +}; + +// Character 248 (0xF8) +// Box: 8 7 -1 0 +// Advance: 7 +// +// +--------+ +// | **** *| +// | ** ** | +// | ** *** | +// | *** ** | +// | ** ** | +// | ** ** | +// |* **** | +// +--------+ +static const byte glyph248[] = { + 0x3D, + 0x66, + 0x6E, + 0x76, + 0x66, + 0x66, + 0xBC +}; + +// Character 249 (0xF9) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | ** | +// | ** | +// | | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** ***| +// | ** **| +// +------+ +static const byte glyph249[] = { + 0x60, + 0x30, + 0x00, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xDC, + 0x6C +}; + +// Character 250 (0xFA) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | ** | +// | ** | +// | | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** ***| +// | ** **| +// +------+ +static const byte glyph250[] = { + 0x18, + 0x30, + 0x00, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xDC, + 0x6C +}; + +// Character 251 (0xFB) +// Box: 6 10 0 0 +// Advance: 7 +// +// +------+ +// | *** | +// | ** **| +// | | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** ***| +// | ** **| +// +------+ +static const byte glyph251[] = { + 0x38, + 0x6C, + 0x00, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xDC, + 0x6C +}; + +// Character 252 (0xFC) +// Box: 6 9 0 0 +// Advance: 7 +// +// +------+ +// | ** **| +// | | +// |** **| +// |** **| +// |** **| +// |** **| +// |** **| +// |** ***| +// | ** **| +// +------+ +static const byte glyph252[] = { + 0x6C, + 0x00, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xCC, + 0xDC, + 0x6C +}; + +// Character 253 (0xFD) +// Box: 7 13 0 -3 +// Advance: 8 +// +// +-------+ +// | ** | +// | ** | +// | | +// |** **| +// |** **| +// | ** ** | +// | ** ** | +// | *** | +// | *** | +// | ** | +// | * | +// | ** | +// | ** | +// +-------+ +static const byte glyph253[] = { + 0x0C, + 0x18, + 0x00, + 0xC6, + 0xC6, + 0x6C, + 0x6C, + 0x38, + 0x38, + 0x18, + 0x10, + 0x30, + 0x60 +}; + +// Character 254 (0xFE) +// Box: 6 12 0 -3 +// Advance: 7 +// +// +------+ +// |** | +// |** | +// |** ** | +// |*** **| +// |** **| +// |** **| +// |** **| +// |*** **| +// |** ** | +// |** | +// |** | +// |** | +// +------+ +static const byte glyph254[] = { + 0xC0, + 0xC0, + 0xD8, + 0xEC, + 0xCC, + 0xCC, + 0xCC, + 0xEC, + 0xD8, + 0xC0, + 0xC0, + 0xC0 +}; + +// Character 255 (0xFF) +// Box: 7 12 0 -3 +// Advance: 8 +// +// +-------+ +// | ** ** | +// | | +// |** **| +// |** **| +// | ** ** | +// | ** ** | +// | *** | +// | *** | +// | ** | +// | * | +// | ** | +// | ** | +// +-------+ +static const byte glyph255[] = { + 0x6C, + 0x00, + 0xC6, + 0xC6, + 0x6C, + 0x6C, + 0x38, + 0x38, + 0x18, + 0x10, + 0x30, + 0x60 +}; + +// Bitmap pointer table +const byte *const bitmapTable[] = { + glyph0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + glyph32, + glyph33, + glyph34, + glyph35, + glyph36, + glyph37, + glyph38, + glyph39, + glyph40, + glyph41, + glyph42, + glyph43, + glyph44, + glyph45, + glyph46, + glyph47, + glyph48, + glyph49, + glyph50, + glyph51, + glyph52, + glyph53, + glyph54, + glyph55, + glyph56, + glyph57, + glyph58, + glyph59, + glyph60, + glyph61, + glyph62, + glyph63, + glyph64, + glyph65, + glyph66, + glyph67, + glyph68, + glyph69, + glyph70, + glyph71, + glyph72, + glyph73, + glyph74, + glyph75, + glyph76, + glyph77, + glyph78, + glyph79, + glyph80, + glyph81, + glyph82, + glyph83, + glyph84, + glyph85, + glyph86, + glyph87, + glyph88, + glyph89, + glyph90, + glyph91, + glyph92, + glyph93, + glyph94, + glyph95, + glyph96, + glyph97, + glyph98, + glyph99, + glyph100, + glyph101, + glyph102, + glyph103, + glyph104, + glyph105, + glyph106, + glyph107, + glyph108, + glyph109, + glyph110, + glyph111, + glyph112, + glyph113, + glyph114, + glyph115, + glyph116, + glyph117, + glyph118, + glyph119, + glyph120, + glyph121, + glyph122, + glyph123, + glyph124, + glyph125, + glyph126, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + glyph160, + glyph161, + glyph162, + glyph163, + glyph164, + glyph165, + glyph166, + glyph167, + glyph168, + glyph169, + glyph170, + glyph171, + glyph172, + glyph173, + glyph174, + glyph175, + glyph176, + glyph177, + glyph178, + glyph179, + glyph180, + glyph181, + glyph182, + glyph183, + glyph184, + glyph185, + glyph186, + glyph187, + glyph188, + glyph189, + glyph190, + glyph191, + glyph192, + glyph193, + glyph194, + glyph195, + glyph196, + glyph197, + glyph198, + glyph199, + glyph200, + glyph201, + glyph202, + glyph203, + glyph204, + glyph205, + glyph206, + glyph207, + glyph208, + glyph209, + glyph210, + glyph211, + glyph212, + glyph213, + glyph214, + glyph215, + glyph216, + glyph217, + glyph218, + glyph219, + glyph220, + glyph221, + glyph222, + glyph223, + glyph224, + glyph225, + glyph226, + glyph227, + glyph228, + glyph229, + glyph230, + glyph231, + glyph232, + glyph233, + glyph234, + glyph235, + glyph236, + glyph237, + glyph238, + glyph239, + glyph240, + glyph241, + glyph242, + glyph243, + glyph244, + glyph245, + glyph246, + glyph247, + glyph248, + glyph249, + glyph250, + glyph251, + glyph252, + glyph253, + glyph254, + glyph255 +}; + +// Advance table +static const byte advances[] = { + 9, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 4, + 5, + 8, + 7, + 12, + 9, + 3, + 6, + 6, + 6, + 7, + 4, + 5, + 4, + 4, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 4, + 4, + 7, + 7, + 7, + 8, + 12, + 8, + 9, + 8, + 9, + 8, + 7, + 10, + 9, + 4, + 7, + 9, + 7, + 11, + 9, + 10, + 8, + 10, + 9, + 9, + 8, + 9, + 8, + 10, + 8, + 8, + 7, + 4, + 4, + 4, + 7, + 7, + 4, + 7, + 7, + 7, + 7, + 7, + 5, + 7, + 7, + 3, + 3, + 7, + 3, + 11, + 7, + 7, + 7, + 7, + 5, + 7, + 5, + 7, + 8, + 11, + 7, + 8, + 6, + 5, + 4, + 5, + 7, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 0, + 4, + 4, + 7, + 7, + 7, + 7, + 4, + 7, + 5, + 11, + 6, + 8, + 8, + 5, + 11, + 4, + 5, + 7, + 4, + 4, + 4, + 7, + 7, + 4, + 4, + 4, + 6, + 8, + 10, + 10, + 10, + 8, + 8, + 8, + 8, + 8, + 8, + 8, 13, - 14, - 13, 15, -1, -3, + 8, + 8, + 8, + 8, + 8, + 4, + 4, + 4, + 4, + 9, + 9, + 10, + 10, + 10, + 10, + 10, + 7, + 10, + 9, + 9, + 9, + 9, + 8, + 8, + 8, + 7, + 7, + 7, + 7, + 7, + 7, 11, - 32, - 224, - _font_bits, - _sysfont_offset, - _sysfont_width, - _sysfont_bbx, - 32, - sizeof(_font_bits)/sizeof(bitmap_t) + 7, + 7, + 7, + 7, + 7, + 3, + 3, + 3, + 3, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 7, + 8, + 7, + 8 +}; + +// Bounding box table +static const BdfBoundingBox boxes[] = { + { 7, 9, 1, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 1, 1, 0, 0 }, + { 2, 9, 1, 0 }, + { 3, 3, 1, 6 }, + { 7, 8, 0, 0 }, + { 6, 11, 0, -2 }, + { 11, 9, 0, 0 }, + { 9, 9, 0, 0 }, + { 1, 3, 1, 6 }, + { 4, 12, 1, -3 }, + { 4, 12, 1, -3 }, + { 5, 4, 0, 5 }, + { 6, 5, 0, 1 }, + { 2, 4, 1, -2 }, + { 4, 1, 0, 3 }, + { 2, 2, 1, 0 }, + { 4, 9, 0, 0 }, + { 6, 9, 0, 0 }, + { 4, 9, 0, 0 }, + { 6, 9, 0, 0 }, + { 6, 9, 0, 0 }, + { 7, 9, 0, 0 }, + { 6, 9, 0, 0 }, + { 6, 9, 0, 0 }, + { 6, 9, 0, 0 }, + { 6, 9, 0, 0 }, + { 6, 9, 0, 0 }, + { 2, 7, 1, 0 }, + { 2, 9, 1, -2 }, + { 5, 5, 1, 1 }, + { 6, 3, 0, 2 }, + { 5, 5, 1, 1 }, + { 6, 9, 1, 0 }, + { 10, 10, 1, -1 }, + { 8, 9, 0, 0 }, + { 7, 9, 1, 0 }, + { 7, 9, 1, 0 }, + { 7, 9, 1, 0 }, + { 6, 9, 1, 0 }, + { 6, 9, 1, 0 }, + { 8, 9, 1, 0 }, + { 7, 9, 1, 0 }, + { 2, 9, 1, 0 }, + { 6, 9, 0, 0 }, + { 8, 9, 1, 0 }, + { 6, 9, 1, 0 }, + { 9, 9, 1, 0 }, + { 7, 9, 1, 0 }, + { 8, 9, 1, 0 }, + { 7, 9, 1, 0 }, + { 8, 9, 1, 0 }, + { 7, 9, 1, 0 }, + { 7, 9, 1, 0 }, + { 8, 9, 0, 0 }, + { 7, 9, 1, 0 }, + { 8, 9, 0, 0 }, + { 10, 9, 0, 0 }, + { 8, 9, 0, 0 }, + { 8, 9, 0, 0 }, + { 7, 9, 0, 0 }, + { 3, 12, 1, -3 }, + { 4, 9, 0, 0 }, + { 3, 12, 0, -3 }, + { 7, 4, 0, 5 }, + { 7, 1, 0, -3 }, + { 3, 2, 0, 8 }, + { 7, 7, 0, 0 }, + { 6, 9, 0, 0 }, + { 6, 7, 0, 0 }, + { 6, 9, 0, 0 }, + { 6, 7, 0, 0 }, + { 5, 9, 0, 0 }, + { 6, 10, 0, -3 }, + { 6, 9, 0, 0 }, + { 2, 9, 0, 0 }, + { 3, 12, -1, -3 }, + { 7, 9, 0, 0 }, + { 2, 9, 0, 0 }, + { 10, 7, 0, 0 }, + { 6, 7, 0, 0 }, + { 6, 7, 0, 0 }, + { 6, 10, 0, -3 }, + { 6, 10, 0, -3 }, + { 5, 7, 0, 0 }, + { 6, 7, 0, 0 }, + { 5, 9, 0, 0 }, + { 6, 7, 0, 0 }, + { 7, 7, 0, 0 }, + { 10, 7, 0, 0 }, + { 6, 7, 0, 0 }, + { 7, 10, 0, -3 }, + { 5, 7, 0, 0 }, + { 4, 12, 0, -3 }, + { 2, 12, 1, -3 }, + { 4, 12, 0, -3 }, + { 7, 2, 0, 3 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 0, 0, 0, 0 }, + { 1, 1, 0, 0 }, + { 2, 10, 1, -3 }, + { 6, 9, 0, -1 }, + { 6, 9, 0, 0 }, + { 6, 6, 0, 1 }, + { 6, 9, 0, 0 }, + { 2, 11, 1, -2 }, + { 6, 12, 0, -3 }, + { 5, 1, 0, 8 }, + { 9, 9, 1, 0 }, + { 4, 6, 1, 3 }, + { 6, 5, 1, 1 }, + { 6, 4, 1, 2 }, + { 4, 1, 0, 3 }, + { 9, 9, 1, 0 }, + { 4, 1, 0, 8 }, + { 4, 4, 0, 4 }, + { 6, 7, 0, 0 }, + { 4, 5, 0, 4 }, + { 4, 5, 0, 4 }, + { 3, 2, 0, 8 }, + { 6, 10, 0, -3 }, + { 7, 12, 0, -3 }, + { 2, 2, 1, 3 }, + { 4, 4, 0, -3 }, + { 3, 5, 0, 4 }, + { 4, 6, 1, 3 }, + { 6, 5, 1, 1 }, + { 10, 9, 0, 0 }, + { 10, 9, 0, 0 }, + { 10, 9, 0, 0 }, + { 6, 10, 1, -3 }, + { 8, 12, 0, 0 }, + { 8, 12, 0, 0 }, + { 8, 12, 0, 0 }, + { 8, 12, 0, 0 }, + { 8, 11, 0, 0 }, + { 8, 12, 0, 0 }, + { 11, 9, 1, 0 }, + { 7, 12, 1, -3 }, + { 6, 12, 1, 0 }, + { 6, 12, 1, 0 }, + { 6, 12, 1, 0 }, + { 6, 11, 1, 0 }, + { 3, 12, 0, 0 }, + { 3, 12, 1, 0 }, + { 5, 12, 0, 0 }, + { 5, 11, 0, 0 }, + { 8, 9, 0, 0 }, + { 7, 12, 1, 0 }, + { 8, 12, 1, 0 }, + { 8, 12, 1, 0 }, + { 8, 12, 1, 0 }, + { 8, 12, 1, 0 }, + { 8, 11, 1, 0 }, + { 6, 5, 0, 1 }, + { 8, 10, 1, -1 }, + { 7, 12, 1, 0 }, + { 7, 12, 1, 0 }, + { 7, 12, 1, 0 }, + { 7, 11, 1, 0 }, + { 8, 12, 0, 0 }, + { 7, 9, 1, 0 }, + { 6, 9, 1, 0 }, + { 7, 10, 0, 0 }, + { 7, 10, 0, 0 }, + { 7, 10, 0, 0 }, + { 7, 10, 0, 0 }, + { 7, 9, 0, 0 }, + { 7, 11, 0, 0 }, + { 10, 7, 0, 0 }, + { 6, 10, 0, -3 }, + { 6, 10, 0, 0 }, + { 6, 10, 0, 0 }, + { 6, 10, 0, 0 }, + { 6, 9, 0, 0 }, + { 3, 10, -1, 0 }, + { 3, 10, 0, 0 }, + { 5, 10, -1, 0 }, + { 5, 9, -1, 0 }, + { 6, 10, 0, 0 }, + { 6, 10, 0, 0 }, + { 6, 10, 0, 0 }, + { 6, 10, 0, 0 }, + { 6, 10, 0, 0 }, + { 6, 10, 0, 0 }, + { 6, 9, 0, 0 }, + { 6, 5, 0, 1 }, + { 8, 7, -1, 0 }, + { 6, 10, 0, 0 }, + { 6, 10, 0, 0 }, + { 6, 10, 0, 0 }, + { 6, 9, 0, 0 }, + { 7, 13, 0, -3 }, + { 6, 12, 0, -3 }, + { 7, 12, 0, -3 } +}; + +// Font structure +static const BdfFontData desc = { + 13, // Max advance + 14, // Height + { 13, 15, -1, -3 }, // Bounding box + 11, // Ascent + + 0, // First character + 0, // Default character + 256, // Characters + + bitmapTable, // Bitmaps + advances, // Advances + boxes // Boxes }; DEFINE_FONT(g_sysfont_big) diff --git a/graphics/fonts/ttf.cpp b/graphics/fonts/ttf.cpp new file mode 100644 index 0000000000..06231799ce --- /dev/null +++ b/graphics/fonts/ttf.cpp @@ -0,0 +1,483 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program 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 2 + * of the License, or (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +// Since FreeType2 includes files, which contain forbidden symbols, we need to +// allow all symbols here. +#define FORBIDDEN_SYMBOL_ALLOW_ALL + +#include "common/scummsys.h" +#ifdef USE_FREETYPE2 + +#include "graphics/fonts/ttf.h" +#include "graphics/font.h" +#include "graphics/surface.h" + +#include "common/singleton.h" +#include "common/stream.h" +#include "common/hashmap.h" + +#include <ft2build.h> +#include FT_FREETYPE_H +#include FT_GLYPH_H + +namespace Graphics { + +namespace { + +inline int ftFloor26_6(FT_Pos x) { + return x / 64; +} + +inline int ftCeil26_6(FT_Pos x) { + return (x + 63) / 64; +} + +} // End of anonymous namespace + +class TTFLibrary : public Common::Singleton<TTFLibrary> { +public: + TTFLibrary(); + ~TTFLibrary(); + + /** + * Check whether FreeType2 is initialized properly. + */ + bool isInitialized() const { return _initialized; } + + bool loadFont(const uint8 *file, const uint32 size, FT_Face &face); + void closeFont(FT_Face &face); +private: + FT_Library _library; + bool _initialized; +}; + +#define g_ttf ::Graphics::TTFLibrary::instance() + +TTFLibrary::TTFLibrary() : _library(), _initialized(false) { + if (!FT_Init_FreeType(&_library)) + _initialized = true; +} + +TTFLibrary::~TTFLibrary() { + if (_initialized) { + FT_Done_FreeType(_library); + _initialized = false; + } +} + +bool TTFLibrary::loadFont(const uint8 *file, const uint32 size, FT_Face &face) { + assert(_initialized); + + return (FT_New_Memory_Face(_library, file, size, 0, &face) == 0); +} + +void TTFLibrary::closeFont(FT_Face &face) { + assert(_initialized); + + FT_Done_Face(face); +} + +class TTFFont : public Font { +public: + TTFFont(); + virtual ~TTFFont(); + + bool load(Common::SeekableReadStream &stream, int size, bool monochrome, const uint32 *mapping); + + virtual int getFontHeight() const; + + virtual int getMaxCharWidth() const; + + virtual int getCharWidth(byte chr) const; + + virtual int getKerningOffset(byte left, byte right) const; + + virtual void drawChar(Surface *dst, byte chr, int x, int y, uint32 color) const; +private: + bool _initialized; + FT_Face _face; + + uint8 *_ttfFile; + uint32 _size; + + int _width, _height; + int _ascent, _descent; + + struct Glyph { + Surface image; + int xOffset, yOffset; + int advance; + }; + + bool cacheGlyph(Glyph &glyph, FT_UInt &slot, uint chr); + typedef Common::HashMap<byte, Glyph> GlyphCache; + GlyphCache _glyphs; + + FT_UInt _glyphSlots[256]; + + bool _monochrome; + bool _hasKerning; +}; + +TTFFont::TTFFont() + : _initialized(false), _face(), _ttfFile(0), _size(0), _width(0), _height(0), _ascent(0), + _descent(0), _glyphs(), _glyphSlots(), _monochrome(false), _hasKerning(false) { +} + +TTFFont::~TTFFont() { + if (_initialized) { + g_ttf.closeFont(_face); + + delete[] _ttfFile; + _ttfFile = 0; + + for (GlyphCache::iterator i = _glyphs.begin(), end = _glyphs.end(); i != end; ++i) + i->_value.image.free(); + + _initialized = false; + } +} + +bool TTFFont::load(Common::SeekableReadStream &stream, int size, bool monochrome, const uint32 *mapping) { + if (!g_ttf.isInitialized()) + return false; + + _size = stream.size(); + if (!_size) + return false; + + _ttfFile = new uint8[_size]; + assert(_ttfFile); + + if (stream.read(_ttfFile, _size) != _size) { + delete[] _ttfFile; + _ttfFile = 0; + + return false; + } + + if (!g_ttf.loadFont(_ttfFile, _size, _face)) { + delete[] _ttfFile; + _ttfFile = 0; + + return false; + } + + // We only support scalable fonts. + if (!FT_IS_SCALABLE(_face)) { + delete[] _ttfFile; + _ttfFile = 0; + + g_ttf.closeFont(_face); + + return false; + } + + // Check whether we have kerning support + _hasKerning = (FT_HAS_KERNING(_face) != 0); + + if (FT_Set_Char_Size(_face, 0, size * 64, 0, 0)) { + delete[] _ttfFile; + _ttfFile = 0; + + return false; + } + + _monochrome = monochrome; + + FT_Fixed yScale = _face->size->metrics.y_scale; + _ascent = ftCeil26_6(FT_MulFix(_face->ascender, yScale)); + _descent = ftCeil26_6(FT_MulFix(_face->descender, yScale)); + + _width = ftCeil26_6(FT_MulFix(_face->max_advance_width, _face->size->metrics.x_scale)); + _height = _ascent - _descent + 1; + + if (!mapping) { + // Load all ISO-8859-1 characters. + for (uint i = 0; i < 256; ++i) { + if (!cacheGlyph(_glyphs[i], _glyphSlots[i], i)) + _glyphSlots[i] = 0; + } + } else { + for (uint i = 0; i < 256; ++i) { + const uint32 unicode = mapping[i] & 0x7FFFFFFF; + const bool isRequired = (mapping[i] & 0x80000000) != 0; + // Check whether loading an important glyph fails and error out if + // that is the case. + if (!cacheGlyph(_glyphs[i], _glyphSlots[i], unicode)) { + _glyphSlots[i] = 0; + if (isRequired) + return false; + } + } + } + + _initialized = (_glyphs.size() != 0); + return _initialized; +} + +int TTFFont::getFontHeight() const { + return _height; +} + +int TTFFont::getMaxCharWidth() const { + return _width; +} + +int TTFFont::getCharWidth(byte chr) const { + GlyphCache::const_iterator glyphEntry = _glyphs.find(chr); + if (glyphEntry == _glyphs.end()) + return 0; + else + return glyphEntry->_value.advance; +} + +int TTFFont::getKerningOffset(byte left, byte right) const { + if (!_hasKerning) + return 0; + + FT_UInt leftGlyph = _glyphSlots[left]; + FT_UInt rightGlyph = _glyphSlots[right]; + + if (!leftGlyph || !rightGlyph) + return 0; + + FT_Vector kerningVector; + FT_Get_Kerning(_face, leftGlyph, rightGlyph, FT_KERNING_DEFAULT, &kerningVector); + return (kerningVector.x / 64); +} + +namespace { + +template<typename ColorType> +void renderGlyph(uint8 *dstPos, const int dstPitch, const uint8 *srcPos, const int srcPitch, const int w, const int h, ColorType color, const PixelFormat &dstFormat) { + uint8 sR, sG, sB; + dstFormat.colorToRGB(color, sR, sG, sB); + + for (int y = 0; y < h; ++y) { + ColorType *rDst = (ColorType *)dstPos; + const uint8 *src = srcPos; + + for (int x = 0; x < w; ++x) { + if (*src == 255) { + *rDst = color; + } else if (*src) { + const uint8 a = *src; + + uint8 dR, dG, dB; + dstFormat.colorToRGB(*rDst, dR, dG, dB); + + dR = ((255 - a) * dR + a * sR) / 255; + dG = ((255 - a) * dG + a * sG) / 255; + dB = ((255 - a) * dB + a * sB) / 255; + + *rDst = dstFormat.RGBToColor(dR, dG, dB); + } + + ++rDst; + ++src; + } + + dstPos += dstPitch; + srcPos += srcPitch; + } +} + +} // End of anonymous namespace + +void TTFFont::drawChar(Surface *dst, byte chr, int x, int y, uint32 color) const { + GlyphCache::const_iterator glyphEntry = _glyphs.find(chr); + if (glyphEntry == _glyphs.end()) + return; + + const Glyph &glyph = glyphEntry->_value; + + x += glyph.xOffset; + y += glyph.yOffset; + + if (x > dst->w) + return; + if (y > dst->h) + return; + + int w = glyph.image.w; + int h = glyph.image.h; + + const uint8 *srcPos = (const uint8 *)glyph.image.getBasePtr(0, 0); + + // Make sure we are not drawing outside the screen bounds + if (x < 0) { + srcPos -= x; + w += x; + x = 0; + } + + if (x + w > dst->w) + w = dst->w - x; + + if (w <= 0) + return; + + if (y < 0) { + srcPos += y * glyph.image.pitch; + h += y; + y = 0; + } + + if (y + h > dst->h) + h = dst->h - y; + + if (h <= 0) + return; + + uint8 *dstPos = (uint8 *)dst->getBasePtr(x, y); + + if (dst->format.bytesPerPixel == 1) { + for (int cy = 0; cy < h; ++cy) { + uint8 *rDst = dstPos; + const uint8 *src = srcPos; + + for (int cx = 0; cx < w; ++cx) { + // We assume a 1Bpp mode is a color indexed mode, thus we can + // not take advantage of anti-aliasing here. + if (*src >= 0x80) + *rDst = color; + + ++rDst; + ++src; + } + + dstPos += dst->pitch; + srcPos += glyph.image.pitch; + } + } else if (dst->format.bytesPerPixel == 2) { + renderGlyph<uint16>(dstPos, dst->pitch, srcPos, glyph.image.pitch, w, h, color, dst->format); + } else if (dst->format.bytesPerPixel == 4) { + renderGlyph<uint32>(dstPos, dst->pitch, srcPos, glyph.image.pitch, w, h, color, dst->format); + } +} + +bool TTFFont::cacheGlyph(Glyph &glyph, FT_UInt &slot, uint chr) { + slot = FT_Get_Char_Index(_face, chr); + if (!slot) + return false; + + // We use the light target and render mode to improve the looks of the + // glyphs. It is most noticable in FreeSansBold.ttf, where otherwise the + // 't' glyph looks like it is cut off on the right side. + if (FT_Load_Glyph(_face, slot, (_monochrome ? FT_LOAD_TARGET_MONO : FT_LOAD_TARGET_LIGHT))) + return false; + + if (FT_Render_Glyph(_face->glyph, (_monochrome ? FT_RENDER_MODE_MONO : FT_RENDER_MODE_LIGHT))) + return false; + + if (_face->glyph->format != FT_GLYPH_FORMAT_BITMAP) + return false; + + FT_Glyph_Metrics &metrics = _face->glyph->metrics; + + glyph.xOffset = ftFloor26_6(metrics.horiBearingX); + int xMax = glyph.xOffset + ftCeil26_6(metrics.width); + glyph.yOffset = _ascent - ftFloor26_6(metrics.horiBearingY); + + glyph.advance = ftCeil26_6(metrics.horiAdvance); + + // In case we got a negative xMin we adjust that, this might make some + // characters make a bit odd, but it's the only way we can assure no + // invalid memory writes with the current font API + if (glyph.xOffset < 0) { + xMax -= glyph.xOffset; + glyph.xOffset = 0; + + if (xMax > glyph.advance) + glyph.advance = xMax; + } + + const FT_Bitmap &bitmap = _face->glyph->bitmap; + glyph.image.create(bitmap.width, bitmap.rows, PixelFormat::createFormatCLUT8()); + + const uint8 *src = bitmap.buffer; + int srcPitch = bitmap.pitch; + if (srcPitch < 0) { + src += (bitmap.rows - 1) * srcPitch; + srcPitch = -srcPitch; + } + + uint8 *dst = (uint8 *)glyph.image.getBasePtr(0, 0); + memset(dst, 0, glyph.image.h * glyph.image.pitch); + + switch (bitmap.pixel_mode) { + case FT_PIXEL_MODE_MONO: + for (int y = 0; y < bitmap.rows; ++y) { + const uint8 *curSrc = src; + uint8 mask = 0; + + for (int x = 0; x < bitmap.width; ++x) { + if ((x % 8) == 0) + mask = *curSrc++; + + if (mask & 0x80) + *dst = 255; + + mask <<= 1; + ++dst; + } + + src += srcPitch; + } + break; + + case FT_PIXEL_MODE_GRAY: + for (int y = 0; y < bitmap.rows; ++y) { + memcpy(dst, src, bitmap.width); + dst += glyph.image.pitch; + src += srcPitch; + } + break; + + default: + warning("TTFFont::cacheGlyph: Unsupported pixel mode %d", bitmap.pixel_mode); + return false; + } + + return true; +} + +Font *loadTTFFont(Common::SeekableReadStream &stream, int size, bool monochrome, const uint32 *mapping) { + TTFFont *font = new TTFFont(); + + if (!font->load(stream, size, monochrome, mapping)) { + delete font; + return 0; + } + + return font; +} + +} // End of namespace Graphics + +namespace Common { +DECLARE_SINGLETON(Graphics::TTFLibrary); +} // End of namespace Common + +#endif + diff --git a/graphics/fonts/ttf.h b/graphics/fonts/ttf.h new file mode 100644 index 0000000000..7222d6e112 --- /dev/null +++ b/graphics/fonts/ttf.h @@ -0,0 +1,42 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program 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 2 + * of the License, or (at your option) any later version. + * + * This program 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, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#ifndef GRAPHICS_FONTS_TTF_H +#define GRAPHICS_FONTS_TTF_H + +#include "common/scummsys.h" + +#ifdef USE_FREETYPE2 + +#include "common/stream.h" + +namespace Graphics { + +class Font; +Font *loadTTFFont(Common::SeekableReadStream &stream, int size, bool monochrome = false, const uint32 *mapping = 0); + +} // End of namespace Graphics + +#endif + +#endif + diff --git a/graphics/iff.cpp b/graphics/iff.cpp index 4bb971f299..7434a6bebc 100644 --- a/graphics/iff.cpp +++ b/graphics/iff.cpp @@ -206,7 +206,7 @@ struct PBMLoader { case ID_BODY: if (_surface) { _surface->create(_decoder._header.width, _decoder._header.height, PixelFormat::createFormatCLUT8()); - _decoder.loadBitmap((byte*)_surface->pixels, chunk._stream); + _decoder.loadBitmap((byte *)_surface->pixels, chunk._stream); } return true; // stop the parser } @@ -234,7 +234,7 @@ bool PackBitsReadStream::eos() const { } uint32 PackBitsReadStream::read(void *dataPtr, uint32 dataSize) { - byte *out = (byte*)dataPtr; + byte *out = (byte *)dataPtr; uint32 left = dataSize; uint32 lenR = 0, lenW = 0; diff --git a/graphics/imagedec.cpp b/graphics/imagedec.cpp index eb595a750e..9552f095fa 100644 --- a/graphics/imagedec.cpp +++ b/graphics/imagedec.cpp @@ -117,7 +117,7 @@ Surface *BMPDecoder::decodeImage(Common::SeekableReadStream &stream, const Pixel assert(newSurf); newSurf->create(info.width, info.height, format); assert(newSurf->pixels); - OverlayColor *curPixel = (OverlayColor*)newSurf->pixels + (newSurf->h-1) * newSurf->w; + OverlayColor *curPixel = (OverlayColor *)newSurf->pixels + (newSurf->h-1) * newSurf->w; int pitchAdd = info.width % 4; for (int i = 0; i < newSurf->h; ++i) { for (int i2 = 0; i2 < newSurf->w; ++i2) { diff --git a/graphics/jpeg.cpp b/graphics/jpeg.cpp index c97a540d33..53e693a045 100644 --- a/graphics/jpeg.cpp +++ b/graphics/jpeg.cpp @@ -43,20 +43,6 @@ static const uint8 _zigZagOrder[64] = { 53, 60, 61, 54, 47, 55, 62, 63 }; -// IDCT table built with : -// _idct8x8[x][y] = cos(((2 * x + 1) * y) * (M_PI / 16.0)) * 0.5; -// _idct8x8[x][y] /= sqrt(2.0) if y == 0 -static const double _idct8x8[8][8] = { - { 0.353553390593274, 0.490392640201615, 0.461939766255643, 0.415734806151273, 0.353553390593274, 0.277785116509801, 0.191341716182545, 0.097545161008064 }, - { 0.353553390593274, 0.415734806151273, 0.191341716182545, -0.097545161008064, -0.353553390593274, -0.490392640201615, -0.461939766255643, -0.277785116509801 }, - { 0.353553390593274, 0.277785116509801, -0.191341716182545, -0.490392640201615, -0.353553390593274, 0.097545161008064, 0.461939766255643, 0.415734806151273 }, - { 0.353553390593274, 0.097545161008064, -0.461939766255643, -0.277785116509801, 0.353553390593274, 0.415734806151273, -0.191341716182545, -0.490392640201615 }, - { 0.353553390593274, -0.097545161008064, -0.461939766255643, 0.277785116509801, 0.353553390593274, -0.415734806151273, -0.191341716182545, 0.490392640201615 }, - { 0.353553390593274, -0.277785116509801, -0.191341716182545, 0.490392640201615, -0.353553390593273, -0.097545161008064, 0.461939766255643, -0.415734806151273 }, - { 0.353553390593274, -0.415734806151273, 0.191341716182545, 0.097545161008064, -0.353553390593274, 0.490392640201615, -0.461939766255643, 0.277785116509801 }, - { 0.353553390593274, -0.490392640201615, 0.461939766255643, -0.415734806151273, 0.353553390593273, -0.277785116509801, 0.191341716182545, -0.097545161008064 } -}; - JPEG::JPEG() : _stream(NULL), _w(0), _h(0), _numComp(0), _components(NULL), _numScanComp(0), _scanComp(NULL), _currentComp(NULL) { @@ -113,6 +99,7 @@ void JPEG::reset() { // Reset member variables _stream = NULL; _w = _h = 0; + _restartInterval = 0; // Free the components for (int c = 0; c < _numComp; c++) @@ -208,12 +195,18 @@ bool JPEG::read(Common::SeekableReadStream *stream) { case 0xE0: // JFIF/JFXX segment ok = readJFIF(); break; + case 0xDD: // Define Restart Interval + ok = readDRI(); + break; case 0xFE: // Comment _stream->seek(_stream->readUint16BE() - 2, SEEK_CUR); break; default: { // Unknown marker uint16 size = _stream->readUint16BE(); - warning("JPEG: Unknown marker %02X, skipping %d bytes", marker, size - 2); + + if ((marker & 0xE0) != 0xE0) + warning("JPEG: Unknown marker %02X, skipping %d bytes", marker, size - 2); + _stream->seek(size - 2, SEEK_CUR); } } @@ -224,7 +217,7 @@ bool JPEG::read(Common::SeekableReadStream *stream) { bool JPEG::readJFIF() { uint16 length = _stream->readUint16BE(); uint32 tag = _stream->readUint32BE(); - if (tag != MKTAG('J','F','I','F')) { + if (tag != MKTAG('J', 'F', 'I', 'F')) { warning("JPEG::readJFIF() tag mismatch"); return false; } @@ -234,8 +227,10 @@ bool JPEG::readJFIF() { } byte majorVersion = _stream->readByte(); byte minorVersion = _stream->readByte(); - if(majorVersion != 1 || minorVersion != 1) - warning("JPEG::readJFIF() Non-v1.1 JPEGs may not be handled correctly"); + + if (majorVersion != 1 || (minorVersion != 1 && minorVersion != 2)) + warning("JPEG::readJFIF() Non-v1.1/1.2 JPEGs may not be handled correctly"); + /* byte densityUnits = */ _stream->readByte(); /* uint16 xDensity = */ _stream->readUint16BE(); /* uint16 yDensity = */ _stream->readUint16BE(); @@ -304,7 +299,7 @@ bool JPEG::readDHT() { // Free the Huffman table delete[] _huff[tableNum].values; _huff[tableNum].values = NULL; delete[] _huff[tableNum].sizes; _huff[tableNum].sizes = NULL; - delete[] _huff[tableNum].codes; _huff[tableNum].codes = NULL; + delete[] _huff[tableNum].codes; _huff[tableNum].codes = NULL; // Read the number of values for each length uint8 numValues[16]; @@ -445,10 +440,28 @@ bool JPEG::readSOS() { } bool ok = true; - for (int y = 0; ok && (y < yMCU); y++) - for (int x = 0; ok && (x < xMCU); x++) + uint16 interval = _restartInterval; + + for (int y = 0; ok && (y < yMCU); y++) { + for (int x = 0; ok && (x < xMCU); x++) { ok = readMCU(x, y); + // If we have a restart interval, we'll need to reset a couple + // variables + if (_restartInterval != 0) { + interval--; + + if (interval == 0) { + interval = _restartInterval; + _bitsNumber = 0; + + for (byte i = 0; i < _numScanComp; i++) + _scanComp[i]->DCpredictor = 0; + } + } + } + } + // Trim Component surfaces back to image height and width // Note: Code using jpeg must use surface.pitch correctly... for (uint16 c = 0; c < _numScanComp; c++) { @@ -489,6 +502,21 @@ bool JPEG::readDQT() { return true; } +// Marker 0xDD (Define Restart Interval) +bool JPEG::readDRI() { + debug(5, "JPEG: readDRI"); + uint16 size = _stream->readUint16BE() - 2; + + if (size != 2) { + warning("JPEG: Invalid DRI size %d", size); + return false; + } + + _restartInterval = _stream->readUint16BE(); + debug(5, "Restart interval: %d", _restartInterval); + return true; +} + bool JPEG::readMCU(uint16 xMCU, uint16 yMCU) { bool ok = true; for (int c = 0; ok && (c < _numComp); c++) { @@ -504,40 +532,63 @@ bool JPEG::readMCU(uint16 xMCU, uint16 yMCU) { return ok; } -void JPEG::idct8x8(float result[64], const int16 dct[64]) { - float tmp[64]; +// triple-butterfly-add (and possible rounding) +#define xadd3(xa, xb, xc, xd, h) \ + p = xa + xb; \ + n = xa - xb; \ + xa = p + xc + h; \ + xb = n + xd + h; \ + xc = p - xc + h; \ + xd = n - xd + h; + +// butterfly-mul +#define xmul(xa, xb, k1, k2, sh) \ + n = k1 * (xa + xb); \ + p = xa; \ + xa = (n + (k2 - k1) * xb) >> sh; \ + xb = (n - (k2 + k1) * p) >> sh; + +// IDCT based on public domain code from http://halicery.com/jpeg/idct.html +void JPEG::idct1D8x8(int32 src[8], int32 dest[64], int32 ps, int32 half) { + int p, n; + + src[0] <<= 9; + src[1] <<= 7; + src[3] *= 181; + src[4] <<= 9; + src[5] *= 181; + src[7] <<= 7; + + // Even part + xmul(src[6], src[2], 277, 669, 0) + xadd3(src[0], src[4], src[6], src[2], half) + + // Odd part + xadd3(src[1], src[7], src[3], src[5], 0) + xmul(src[5], src[3], 251, 50, 6) + xmul(src[1], src[7], 213, 142, 6) + + dest[0 * 8] = (src[0] + src[1]) >> ps; + dest[1 * 8] = (src[4] + src[5]) >> ps; + dest[2 * 8] = (src[2] + src[3]) >> ps; + dest[3 * 8] = (src[6] + src[7]) >> ps; + dest[4 * 8] = (src[6] - src[7]) >> ps; + dest[5 * 8] = (src[2] - src[3]) >> ps; + dest[6 * 8] = (src[4] - src[5]) >> ps; + dest[7 * 8] = (src[0] - src[1]) >> ps; +} - // Apply 1D IDCT to rows - for (int y = 0; y < 8; y++) { - for (int x = 0; x < 8; x++) { - tmp[y + x * 8] = dct[0] * _idct8x8[x][0] - + dct[1] * _idct8x8[x][1] - + dct[2] * _idct8x8[x][2] - + dct[3] * _idct8x8[x][3] - + dct[4] * _idct8x8[x][4] - + dct[5] * _idct8x8[x][5] - + dct[6] * _idct8x8[x][6] - + dct[7] * _idct8x8[x][7]; - } +void JPEG::idct2D8x8(int32 block[64]) { + int32 tmp[64]; - dct += 8; - } + // Apply 1D IDCT to rows + for (int i = 0; i < 8; i++) + idct1D8x8(&block[i * 8], &tmp[i], 9, 1 << 8); // Apply 1D IDCT to columns - for (int x = 0; x < 8; x++) { - const float *u = tmp + x * 8; - for (int y = 0; y < 8; y++) { - result[y * 8 + x] = u[0] * _idct8x8[y][0] - + u[1] * _idct8x8[y][1] - + u[2] * _idct8x8[y][2] - + u[3] * _idct8x8[y][3] - + u[4] * _idct8x8[y][4] - + u[5] * _idct8x8[y][5] - + u[6] * _idct8x8[y][6] - + u[7] * _idct8x8[y][7]; - } - } -} + for (int i = 0; i < 8; i++) + idct1D8x8(&tmp[i * 8], &block[i], 12, 1 << 11); + } bool JPEG::readDataUnit(uint16 x, uint16 y) { // Prepare an empty data array @@ -553,30 +604,29 @@ bool JPEG::readDataUnit(uint16 x, uint16 y) { readAC(readData); // Calculate the DCT coefficients from the input sequence - int16 DCT[64]; + int32 block[64]; for (uint8 i = 0; i < 64; i++) { // Dequantize - int16 val = readData[i]; + int32 val = readData[i]; int16 quant = _quant[_currentComp->quantTableSelector][i]; val *= quant; // Store the normalized coefficients, undoing the Zig-Zag - DCT[_zigZagOrder[i]] = val; + block[_zigZagOrder[i]] = val; } // Apply the IDCT - float result[64]; - idct8x8(result, DCT); + idct2D8x8(block); // Level shift to make the values unsigned for (int i = 0; i < 64; i++) { - result[i] = result[i] + 128; + block[i] = block[i] + 128; - if (result[i] < 0) - result[i] = 0; + if (block[i] < 0) + block[i] = 0; - if (result[i] > 255) - result[i] = 255; + if (block[i] > 255) + block[i] = 255; } // Paint the component surface @@ -594,7 +644,7 @@ bool JPEG::readDataUnit(uint16 x, uint16 y) { for (uint8 i = 0; i < 8; i++) { for (uint16 sH = 0; sH < scalingH; sH++) { - *ptr = (byte)(result[j * 8 + i]); + *ptr = (byte)(block[j * 8 + i]); ptr++; } } @@ -647,15 +697,15 @@ void JPEG::readAC(int16 *out) { int16 JPEG::readSignedBits(uint8 numBits) { uint16 ret = 0; - if (numBits > 16) error("requested %d bits", numBits); //XXX + if (numBits > 16) + error("requested %d bits", numBits); //XXX // MSB=0 for negatives, 1 for positives for (int i = 0; i < numBits; i++) ret = (ret << 1) + readBit(); // Extend sign bits (PAG109) - if (!(ret >> (numBits - 1))) - { + if (!(ret >> (numBits - 1))) { uint16 tmp = ((uint16)-1 << numBits) + 1; ret = ret + tmp; } @@ -709,6 +759,9 @@ uint8 JPEG::readBit() { // DNL marker: Define Number of Lines // TODO: terminate scan warning("DNL marker detected: terminate scan"); + } else if (byte2 >= 0xD0 && byte2 <= 0xD7) { + debug(7, "RST%d marker detected", byte2 & 7); + _bitsData = _stream->readByte(); } else { warning("Error: marker 0x%02X read in entropy data", byte2); } diff --git a/graphics/jpeg.h b/graphics/jpeg.h index 27b91e8777..b87791470f 100644 --- a/graphics/jpeg.h +++ b/graphics/jpeg.h @@ -54,6 +54,7 @@ private: Common::SeekableReadStream *_stream; uint16 _w, _h; + uint16 _restartInterval; // Image components uint8 _numComp; @@ -101,6 +102,7 @@ private: bool readDHT(); bool readSOS(); bool readDQT(); + bool readDRI(); // Helper functions bool readMCU(uint16 xMCU, uint16 yMCU); @@ -116,7 +118,8 @@ private: uint8 _bitsNumber; // Inverse Discrete Cosine Transformation - void idct8x8(float dst[64], const int16 src[64]); + static void idct1D8x8(int32 src[8], int32 dest[64], int32 ps, int32 half); + static void idct2D8x8(int32 block[64]); }; } // End of Graphics namespace diff --git a/graphics/module.mk b/graphics/module.mk index 02c88d98ba..1e84b2425d 100644 --- a/graphics/module.mk +++ b/graphics/module.mk @@ -9,6 +9,7 @@ MODULE_OBJS := \ fonts/consolefont.o \ fonts/newfont_big.o \ fonts/newfont.o \ + fonts/ttf.o \ fonts/winfont.o \ iff.o \ imagedec.o \ diff --git a/graphics/pict.cpp b/graphics/pict.cpp index 0f4dcd463f..872f2f224a 100644 --- a/graphics/pict.cpp +++ b/graphics/pict.cpp @@ -338,10 +338,9 @@ void PictDecoder::unpackBitsRect(Common::SeekableReadStream *stream, bool hasPal _outputSurface = new Graphics::Surface(); _outputSurface->create(width, height, (bytesPerPixel == 1) ? PixelFormat::createFormatCLUT8() : _pixelFormat); - // Create an temporary buffer, but allocate a bit more than we need to avoid overflow - // (align it to the next highest two-byte packed boundary, which may be more unpacked, - // as m68k and therefore QuickDraw is word-aligned) - byte *buffer = new byte[width * height * bytesPerPixel + (8 * 2 / packBitsData.pixMap.pixelSize)]; + // Ensure we have enough space in the buffer to hold an entire line's worth of pixels + uint32 lineSize = MAX<int>(width * bytesPerPixel + (8 * 2 / packBitsData.pixMap.pixelSize), packBitsData.pixMap.rowBytes); + byte *buffer = new byte[lineSize * height]; // Read in amount of data per row for (uint16 i = 0; i < packBitsData.pixMap.bounds.height(); i++) { @@ -467,7 +466,6 @@ void PictDecoder::skipBitsRect(Common::SeekableReadStream *stream, bool hasPalet stream->readUint16BE(); uint16 packType; - uint16 pixelSize; // Top two bits signify PixMap vs BitMap if (rowBytes & 0xC000) { @@ -475,7 +473,7 @@ void PictDecoder::skipBitsRect(Common::SeekableReadStream *stream, bool hasPalet stream->readUint16BE(); packType = stream->readUint16BE(); stream->skip(14); - pixelSize = stream->readUint16BE(); + stream->readUint16BE(); // pixelSize stream->skip(16); if (hasPalette) { @@ -488,7 +486,6 @@ void PictDecoder::skipBitsRect(Common::SeekableReadStream *stream, bool hasPalet } else { // BitMap packType = 0; - pixelSize = 1; } stream->skip(18); diff --git a/graphics/png.cpp b/graphics/png.cpp index 2189fd333f..cea8b575ad 100644 --- a/graphics/png.cpp +++ b/graphics/png.cpp @@ -22,8 +22,6 @@ #include "graphics/png.h" -#ifdef GRAPHICS_PNG_H - #include "graphics/pixelformat.h" #include "graphics/surface.h" @@ -487,5 +485,3 @@ void PNG::readTransparencyChunk(uint32 chunkLength) { } } // End of Graphics namespace - -#endif // GRAPHICS_PNG_H diff --git a/graphics/png.h b/graphics/png.h index 3f8ea85320..078c76fc6b 100644 --- a/graphics/png.h +++ b/graphics/png.h @@ -27,16 +27,6 @@ * - zlib */ -// Currently, only the sword25 engine uses the PNG decoder, so skip compiling -// it if sword25 is not enabled, or if zlib (a required dependency) is not -// enabled. - -#if !(defined(ENABLE_SWORD25) || defined(USE_ZLIB)) - -// Do not compile the PNG decoder code - -#else - #ifndef GRAPHICS_PNG_H #define GRAPHICS_PNG_H @@ -176,5 +166,3 @@ private: } // End of Graphics namespace #endif // GRAPHICS_PNG_H - -#endif // Engine and zlib guard diff --git a/graphics/scaler/scale2x.h b/graphics/scaler/scale2x.h index b0c887d43c..917e817a0d 100644 --- a/graphics/scaler/scale2x.h +++ b/graphics/scaler/scale2x.h @@ -18,8 +18,8 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#ifndef __SCALE2X_H -#define __SCALE2X_H +#ifndef SCALER_SCALE2X_H +#define SCALER_SCALE2X_H #if defined(_MSC_VER) #define __restrict__ diff --git a/graphics/scaler/scale3x.h b/graphics/scaler/scale3x.h index ad5604d086..8d93914400 100644 --- a/graphics/scaler/scale3x.h +++ b/graphics/scaler/scale3x.h @@ -18,8 +18,8 @@ * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ -#ifndef __SCALE3X_H -#define __SCALE3X_H +#ifndef SCALER_SCALE3X_H +#define SCALER_SCALE3X_H #if defined(_MSC_VER) #define __restrict__ diff --git a/graphics/scaler/scalebit.h b/graphics/scaler/scalebit.h index 6e4a30caf0..75f9dae455 100644 --- a/graphics/scaler/scalebit.h +++ b/graphics/scaler/scalebit.h @@ -33,8 +33,8 @@ * - derivative works of the program are allowed. */ -#ifndef __SCALEBIT_H -#define __SCALEBIT_H +#ifndef SCALER_SCALEBIT_H +#define SCALER_SCALEBIT_H int scale_precondition(unsigned scale, unsigned pixel, unsigned width, unsigned height); void scale(unsigned scale, void* void_dst, unsigned dst_slice, const void* void_src, unsigned src_slice, unsigned pixel, unsigned width, unsigned height); diff --git a/graphics/scaler/thumbnail_intern.cpp b/graphics/scaler/thumbnail_intern.cpp index ef540b8cd8..88f3cc2077 100644 --- a/graphics/scaler/thumbnail_intern.cpp +++ b/graphics/scaler/thumbnail_intern.cpp @@ -46,7 +46,7 @@ void createThumbnail_2(const uint8 *src, uint32 srcPitch, uint8 *dstPtr, uint32 assert(height % 2 == 0); for (int y = 0; y < height; y += 2) { for (int x = 0; x < width; x += 2, dstPtr += 2) { - *((uint16*)dstPtr) = quadBlockInterpolate<bitFormat>(src + 2 * x, srcPitch); + *((uint16 *)dstPtr) = quadBlockInterpolate<bitFormat>(src + 2 * x, srcPitch); } dstPtr += (dstPitch - 2 * width / 2); src += 2 * srcPitch; @@ -64,7 +64,7 @@ void createThumbnail_4(const uint8 *src, uint32 srcPitch, uint8 *dstPtr, uint32 uint16 downleft = quadBlockInterpolate<bitFormat>(src + srcPitch * 2 + 2 * x, srcPitch); uint16 downright = quadBlockInterpolate<bitFormat>(src + srcPitch * 2 + 2 * (x + 2), srcPitch); - *((uint16*)dstPtr) = interpolate16_1_1_1_1<Graphics::ColorMasks<bitFormat> >(upleft, upright, downleft, downright); + *((uint16 *)dstPtr) = interpolate16_1_1_1_1<Graphics::ColorMasks<bitFormat> >(upleft, upright, downleft, downright); } dstPtr += (dstPitch - 2 * width / 4); src += 4 * srcPitch; @@ -116,9 +116,9 @@ static bool grabScreen565(Graphics::Surface *surf) { byte r = 0, g = 0, b = 0; if (screenFormat.bytesPerPixel == 1) { - r = palette[((uint8*)screen->pixels)[y * screen->pitch + x] * 3]; - g = palette[((uint8*)screen->pixels)[y * screen->pitch + x] * 3 + 1]; - b = palette[((uint8*)screen->pixels)[y * screen->pitch + x] * 3 + 2]; + r = palette[((uint8 *)screen->pixels)[y * screen->pitch + x] * 3]; + g = palette[((uint8 *)screen->pixels)[y * screen->pitch + x] * 3 + 1]; + b = palette[((uint8 *)screen->pixels)[y * screen->pitch + x] * 3 + 2]; } else if (screenFormat.bytesPerPixel == 2) { uint16 col = READ_UINT16(screen->getBasePtr(x, y)); screenFormat.colorToRGB(col, r, g, b); diff --git a/graphics/sjis.h b/graphics/sjis.h index f96eef6ad1..2d05005fc3 100644 --- a/graphics/sjis.h +++ b/graphics/sjis.h @@ -43,7 +43,7 @@ #endif #include "common/scummsys.h" -#include "common/util.h" +#include "common/platform.h" namespace Graphics { diff --git a/graphics/surface.cpp b/graphics/surface.cpp index e0b25f22e9..79a7821feb 100644 --- a/graphics/surface.cpp +++ b/graphics/surface.cpp @@ -95,10 +95,10 @@ void Surface::hLine(int x, int y, int x2, uint32 color) { memset(ptr, (byte)color, x2 - x + 1); } else if (format.bytesPerPixel == 2) { uint16 *ptr = (uint16 *)getBasePtr(x, y); - Common::set_to(ptr, ptr + (x2 - x + 1), (uint16)color); + Common::fill(ptr, ptr + (x2 - x + 1), (uint16)color); } else if (format.bytesPerPixel == 4) { uint32 *ptr = (uint32 *)getBasePtr(x, y); - Common::set_to(ptr, ptr + (x2 - x + 1), color); + Common::fill(ptr, ptr + (x2 - x + 1), color); } else { error("Surface::hLine: bytesPerPixel must be 1, 2, or 4"); } @@ -172,13 +172,13 @@ void Surface::fillRect(Common::Rect r, uint32 color) { if (format.bytesPerPixel == 2) { uint16 *ptr = (uint16 *)getBasePtr(r.left, r.top); while (height--) { - Common::set_to(ptr, ptr + width, (uint16)color); + Common::fill(ptr, ptr + width, (uint16)color); ptr += pitch / 2; } } else { uint32 *ptr = (uint32 *)getBasePtr(r.left, r.top); while (height--) { - Common::set_to(ptr, ptr + width, color); + Common::fill(ptr, ptr + width, color); ptr += pitch / 4; } } diff --git a/graphics/yuv_to_rgb.h b/graphics/yuv_to_rgb.h index 2d3b9e634e..259ba09810 100644 --- a/graphics/yuv_to_rgb.h +++ b/graphics/yuv_to_rgb.h @@ -35,8 +35,6 @@ namespace Graphics { -struct Surface; - /** * Convert a YUV420 image to an RGB surface * |