diff options
Diffstat (limited to 'graphics')
32 files changed, 21942 insertions, 20313 deletions
diff --git a/graphics/VectorRendererSpec.cpp b/graphics/VectorRendererSpec.cpp index 588e17b6cb..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,35 +87,63 @@ 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() \ if (error_term >= 0) { \ @@ -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 { @@ -447,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) { @@ -473,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) + @@ -486,9 +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 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); + } +} + +template<typename PixelType> +inline void VectorRendererSpec<PixelType>:: +darkenFill(PixelType *ptr, PixelType *end) { + PixelType mask = (PixelType)((3 << _format.rShift) | (3 << _format.gShift) | (3 << _format.bShift)); + + 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; + } + } } /******************************************************************** @@ -665,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> @@ -719,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)); @@ -839,17 +925,10 @@ drawTabAlg(int x1, int y1, int w, int h, int r, PixelType color, VectorRenderer: 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_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); } } @@ -880,6 +959,8 @@ drawTabAlg(int x1, int y1, int w, int h, int r, PixelType color, VectorRenderer: } else { BE_RESET(); + precalcGradient(long_h); + PixelType color1, color2; color1 = color2 = color; @@ -889,22 +970,26 @@ drawTabAlg(int x1, int y1, int w, int h, int r, PixelType color, VectorRenderer: 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; } } @@ -998,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; } } @@ -1347,49 +1433,30 @@ 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); + // TODO: Split this up into border, bevel and interior functions - 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; - - BE_RESET(); - r--; - - while (x++ < y) { - BE_ALGORITHM(); - BE_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py); + 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); - 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); - } - } - } + int real_radius = r; + int short_h = h - (2 * r) + 2; + int long_h = h; - 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(); @@ -1398,11 +1465,11 @@ drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, Vecto 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); } @@ -1410,11 +1477,11 @@ drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, Vecto while (x++ < y) { 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); @@ -1423,9 +1490,56 @@ drawRoundedSquareAlg(int x1, int y1, int r, int w, int h, PixelType color, Vecto 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; } } @@ -1567,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; - } -} - - /******************************************************************************/ @@ -1687,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); @@ -1720,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(); - 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++) { + Base::precalcGradient(long_h); + + while (x > y++) { WU_ALGORITHM(); - colorFill<PixelType>(ptr_tl - x - py, ptr_tr + x - py, color); - colorFill<PixelType>(ptr_tl - y - px, ptr_tr + y - px, color); + if (fill_m == Base::kFillGradient) { + color1 = Base::calcGradient(real_radius - x, long_h); + color2 = Base::calcGradient(real_radius - y, long_h); - colorFill<PixelType>(ptr_bl - x + py, ptr_br + x + py, color); - colorFill<PixelType>(ptr_bl - y + px, ptr_br + y + px, color); + Base::gradientFill(ptr_tl - x - py + 1, w - 2 * r + 2 * x - 1, x1 + r - x - y + 1, real_radius - y); - WU_DRAWCIRCLE(ptr_tr, ptr_tl, ptr_bl, ptr_br, x, y, px, py, a1); + // 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 + + 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); + + int sw = 0, sp = 0; + int short_h = h - 2 * r; + int hp = h * pitch; + + 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 **/ diff --git a/graphics/VectorRendererSpec.h b/graphics/VectorRendererSpec.h index fe64f9774d..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. @@ -202,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; @@ -278,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/decoders/bmp.cpp b/graphics/decoders/bmp.cpp new file mode 100644 index 0000000000..0d44881d7c --- /dev/null +++ b/graphics/decoders/bmp.cpp @@ -0,0 +1,159 @@ +/* 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. + */ + +#include "common/stream.h" +#include "common/textconsole.h" + +#include "graphics/pixelformat.h" +#include "graphics/surface.h" +#include "graphics/decoders/bmp.h" + +namespace Graphics { + +BitmapDecoder::BitmapDecoder() { + _surface = 0; + _palette = 0; +} + +BitmapDecoder::~BitmapDecoder() { + destroy(); +} + +void BitmapDecoder::destroy() { + if (_surface) { + _surface->free(); + delete _surface; _surface = 0; + } + + delete[] _palette; _palette = 0; +} + +bool BitmapDecoder::loadStream(Common::SeekableReadStream &stream) { + destroy(); + + if (stream.readByte() != 'B') + return false; + + if (stream.readByte() != 'M') + return false; + + /* uint32 fileSize = */ stream.readUint32LE(); + /* uint16 res1 = */ stream.readUint16LE(); + /* uint16 res2 = */ stream.readUint16LE(); + uint32 imageOffset = stream.readUint32LE(); + + uint32 infoSize = stream.readUint32LE(); + if (infoSize != 40) { + warning("Only Windows v3 bitmaps are supported"); + return false; + } + + uint32 width = stream.readUint32LE(); + int32 height = stream.readSint32LE(); + + if (width == 0 || height == 0) + return false; + + if (height < 0) { + warning("Right-side up bitmaps not supported"); + return false; + } + + /* uint16 planes = */ stream.readUint16LE(); + uint16 bitsPerPixel = stream.readUint16LE(); + + if (bitsPerPixel != 8 && bitsPerPixel != 24) { + warning("%dbpp bitmaps not supported", bitsPerPixel); + return false; + } + + uint32 compression = stream.readUint32LE(); + + if (compression != 0) { + warning("Compressed bitmaps not supported"); + return false; + } + + /* uint32 imageSize = */ stream.readUint32LE(); + /* uint32 pixelsPerMeterX = */ stream.readUint32LE(); + /* uint32 pixelsPerMeterY = */ stream.readUint32LE(); + uint32 colorsUsed = stream.readUint32LE(); + /* uint32 colorsImportant = */ stream.readUint32LE(); + + if (colorsUsed == 0) + colorsUsed = 256; + + if (bitsPerPixel == 8) { + // Read the palette + _palette = new byte[colorsUsed * 3]; + for (uint16 i = 0; i < colorsUsed; i++) { + _palette[i * 3 + 2] = stream.readByte(); + _palette[i * 3 + 1] = stream.readByte(); + _palette[i * 3 + 0] = stream.readByte(); + stream.readByte(); + } + } + + // Start us at the beginning of the image + stream.seek(imageOffset); + + Graphics::PixelFormat format = Graphics::PixelFormat::createFormatCLUT8(); + + // BGRA for 24bpp + if (bitsPerPixel == 24) + format = Graphics::PixelFormat(4, 8, 8, 8, 8, 8, 16, 24, 0); + + _surface = new Graphics::Surface(); + _surface->create(width, height, format); + + int srcPitch = width * (bitsPerPixel >> 3); + const int extraDataLength = (srcPitch % 4) ? 4 - (srcPitch % 4) : 0; + + if (bitsPerPixel == 8) { + byte *dst = (byte *)_surface->pixels; + + for (int32 i = 0; i < height; i++) { + stream.read(dst + (height - i - 1) * width, width); + stream.skip(extraDataLength); + } + } else { + byte *dst = (byte *)_surface->pixels + (height - 1) * _surface->pitch; + + for (int32 i = 0; i < height; i++) { + for (uint32 j = 0; j < width; j++) { + byte b = stream.readByte(); + byte g = stream.readByte(); + byte r = stream.readByte(); + uint32 color = format.RGBToColor(r, g, b); + + *((uint32 *)dst) = color; + dst += format.bytesPerPixel; + } + + stream.skip(extraDataLength); + dst -= _surface->pitch * 2; + } + } + + return true; +} + +} // End of namespace Graphics diff --git a/graphics/imagedec.h b/graphics/decoders/bmp.h index e839d097b2..e11b12fad6 100644 --- a/graphics/imagedec.h +++ b/graphics/decoders/bmp.h @@ -19,11 +19,12 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ -#ifndef GRAPHICS_IMAGEDEC_H -#define GRAPHICS_IMAGEDEC_H +#ifndef GRAPHICS_DECODERS_BMP_H +#define GRAPHICS_DECODERS_BMP_H #include "common/scummsys.h" #include "common/str.h" +#include "graphics/decoders/image_decoder.h" namespace Common{ class SeekableReadStream; @@ -34,33 +35,22 @@ namespace Graphics { struct PixelFormat; struct Surface; -class ImageDecoder { +class BitmapDecoder : public ImageDecoder { public: - ImageDecoder() {} - virtual ~ImageDecoder() {} - - static Surface *loadFile(const Common::String &name, const PixelFormat &format); - static Surface *loadFile(Common::SeekableReadStream &stream, const PixelFormat &format); - - /** - * checks if the data can be decoded by this decoder - * - * @param stream memory read stream - * @return true if it can be decoded, otherwise false - */ - virtual bool decodeable(Common::SeekableReadStream &stream) = 0; - - /** - * decodes the data and returns an pointer to the resulting surface. - * Surface::free() must be called by the user also it must be deleted - * with delete; - * - * @param stream the memory stream which should be decoded - * @param format the pixel format used to generate the surface - * @return returns a new surface if the image could be decoded, otherwise 0 - */ - virtual Surface *decodeImage(Common::SeekableReadStream &stream, const PixelFormat &format) = 0; + BitmapDecoder(); + virtual ~BitmapDecoder(); + + // ImageDecoder API + void destroy(); + virtual bool loadStream(Common::SeekableReadStream &stream); + virtual const Surface *getSurface() const { return _surface; } + virtual const byte *getPalette() { return _palette; } + +private: + Surface *_surface; + byte *_palette; }; + } // End of namespace Graphics #endif diff --git a/graphics/decoders/image_decoder.h b/graphics/decoders/image_decoder.h new file mode 100644 index 0000000000..e768f7f9a2 --- /dev/null +++ b/graphics/decoders/image_decoder.h @@ -0,0 +1,85 @@ +/* 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_DECODERS_IMAGEDECODER_H +#define GRAPHICS_DECODERS_IMAGEDECODER_H + +#include "common/scummsys.h" +#include "common/str.h" + +namespace Common{ +class SeekableReadStream; +} + +namespace Graphics { + +struct PixelFormat; +struct Surface; + +/** + * A representation of an image decoder that maintains ownership of the surface + * and palette it decodes to. + */ +class ImageDecoder { +public: + virtual ~ImageDecoder() {} + + /** + * Load an image from the specified stream + * + * @param stream the input stream + * @return whether loading the file succeeded + * @see getSurface + * @see getPalette + */ + virtual bool loadStream(Common::SeekableReadStream &stream) = 0; + + /** + * Destroy this decoder's surface and palette + */ + virtual void destroy() = 0; + + /** + * Get the decoded surface + * + * This surface is owned by this ImageDecoder and will remain valid + * until destroy() or loadStream() is called, or until this ImageDecoder's + * destructor is called. + * + * @return the decoded surface, or 0 if no surface is present + */ + virtual const Surface *getSurface() const = 0; + + /** + * Get the decoded palette + * + * This palette is owned by this ImageDecoder and will remain valid + * until destroy() or loadStream() is called, or until this ImageDecoder's + * destructor is called. + * + * @return the decoded palette, or 0 if no palette is present + */ + virtual const byte *getPalette() const { return 0; } +}; + +} // End of namespace Graphics + +#endif diff --git a/graphics/jpeg.cpp b/graphics/decoders/jpeg.cpp index c97a540d33..a871377ca1 100644 --- a/graphics/jpeg.cpp +++ b/graphics/decoders/jpeg.cpp @@ -20,9 +20,9 @@ * */ -#include "graphics/conversion.h" -#include "graphics/jpeg.h" #include "graphics/pixelformat.h" +#include "graphics/yuv_to_rgb.h" +#include "graphics/decoders/jpeg.h" #include "common/debug.h" #include "common/endian.h" @@ -43,23 +43,9 @@ 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() : +JPEGDecoder::JPEGDecoder() : ImageDecoder(), _stream(NULL), _w(0), _h(0), _numComp(0), _components(NULL), _numScanComp(0), - _scanComp(NULL), _currentComp(NULL) { + _scanComp(NULL), _currentComp(NULL), _rgbSurface(0) { // Initialize the quantization tables for (int i = 0; i < JPEG_MAX_QUANT_TABLES; i++) @@ -74,45 +60,37 @@ JPEG::JPEG() : } } -JPEG::~JPEG() { - reset(); +JPEGDecoder::~JPEGDecoder() { + destroy(); } -Surface *JPEG::getSurface(const PixelFormat &format) { +const Surface *JPEGDecoder::getSurface() const { // Make sure we have loaded data if (!isLoaded()) return 0; - // Only accept >8bpp surfaces - if (format.bytesPerPixel == 1) - return 0; + if (_rgbSurface) + return _rgbSurface; + + // Create an RGBA8888 surface + _rgbSurface = new Graphics::Surface(); + _rgbSurface->create(_w, _h, Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0)); // Get our component surfaces - Graphics::Surface *yComponent = getComponent(1); - Graphics::Surface *uComponent = getComponent(2); - Graphics::Surface *vComponent = getComponent(3); - - Graphics::Surface *output = new Graphics::Surface(); - output->create(yComponent->w, yComponent->h, format); - - for (uint16 i = 0; i < output->h; i++) { - for (uint16 j = 0; j < output->w; j++) { - byte r = 0, g = 0, b = 0; - YUV2RGB(*((byte *)yComponent->getBasePtr(j, i)), *((byte *)uComponent->getBasePtr(j, i)), *((byte *)vComponent->getBasePtr(j, i)), r, g, b); - if (format.bytesPerPixel == 2) - *((uint16 *)output->getBasePtr(j, i)) = format.RGBToColor(r, g, b); - else - *((uint32 *)output->getBasePtr(j, i)) = format.RGBToColor(r, g, b); - } - } + const Graphics::Surface *yComponent = getComponent(1); + const Graphics::Surface *uComponent = getComponent(2); + const Graphics::Surface *vComponent = getComponent(3); + + convertYUV444ToRGB(_rgbSurface, (byte *)yComponent->pixels, (byte *)uComponent->pixels, (byte *)vComponent->pixels, yComponent->w, yComponent->h, yComponent->pitch, uComponent->pitch); - return output; + return _rgbSurface; } -void JPEG::reset() { +void JPEGDecoder::destroy() { // Reset member variables _stream = NULL; _w = _h = 0; + _restartInterval = 0; // Free the components for (int c = 0; c < _numComp; c++) @@ -138,14 +116,19 @@ void JPEG::reset() { delete[] _huff[i].sizes; _huff[i].sizes = NULL; delete[] _huff[i].codes; _huff[i].codes = NULL; } + + if (_rgbSurface) { + _rgbSurface->free(); + delete _rgbSurface; + } } -bool JPEG::read(Common::SeekableReadStream *stream) { +bool JPEGDecoder::loadStream(Common::SeekableReadStream &stream) { // Reset member variables and tables from previous reads - reset(); + destroy(); // Save the input stream - _stream = stream; + _stream = &stream; bool ok = true; bool done = false; @@ -208,49 +191,57 @@ 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); } } } + + _stream = 0; return ok; } -bool JPEG::readJFIF() { +bool JPEGDecoder::readJFIF() { uint16 length = _stream->readUint16BE(); uint32 tag = _stream->readUint32BE(); - if (tag != MKTAG('J','F','I','F')) { - warning("JPEG::readJFIF() tag mismatch"); + if (tag != MKTAG('J', 'F', 'I', 'F')) { + warning("JPEGDecoder::readJFIF() tag mismatch"); return false; } if (_stream->readByte() != 0) { // NULL - warning("JPEG::readJFIF() NULL mismatch"); + warning("JPEGDecoder::readJFIF() NULL mismatch"); return false; } 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"); - /* byte densityUnits = */ _stream->readByte(); - /* uint16 xDensity = */ _stream->readUint16BE(); - /* uint16 yDensity = */ _stream->readUint16BE(); + if (majorVersion != 1 || minorVersion != 1) + warning("JPEGDecoder::readJFIF() Non-v1.1 JPEGs may not be handled correctly"); + /* byte densityUnits = */_stream->readByte(); + /* uint16 xDensity = */_stream->readUint16BE(); + /* uint16 yDensity = */_stream->readUint16BE(); byte thumbW = _stream->readByte(); byte thumbH = _stream->readByte(); _stream->seek(thumbW * thumbH * 3, SEEK_CUR); // Ignore thumbnail if (length != (thumbW * thumbH * 3) + 16) { - warning("JPEG::readJFIF() length mismatch"); + warning("JPEGDecoder::readJFIF() length mismatch"); return false; } return true; } // Marker 0xC0 (Start Of Frame, Baseline DCT) -bool JPEG::readSOF0() { +bool JPEGDecoder::readSOF0() { debug(5, "JPEG: readSOF0"); uint16 size = _stream->readUint16BE(); @@ -289,7 +280,7 @@ bool JPEG::readSOF0() { } // Marker 0xC4 (Define Huffman Tables) -bool JPEG::readDHT() { +bool JPEGDecoder::readDHT() { debug(5, "JPEG: readDHT"); uint16 size = _stream->readUint16BE() - 2; uint32 pos = _stream->pos(); @@ -304,7 +295,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]; @@ -351,7 +342,7 @@ bool JPEG::readDHT() { } // Marker 0xDA (Start Of Scan) -bool JPEG::readSOS() { +bool JPEGDecoder::readSOS() { debug(5, "JPEG: readSOS"); uint16 size = _stream->readUint16BE(); @@ -445,10 +436,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++) { @@ -460,7 +469,7 @@ bool JPEG::readSOS() { } // Marker 0xDB (Define Quantization Tables) -bool JPEG::readDQT() { +bool JPEGDecoder::readDQT() { debug(5, "JPEG: readDQT"); uint16 size = _stream->readUint16BE() - 2; uint32 pos = _stream->pos(); @@ -489,7 +498,22 @@ bool JPEG::readDQT() { return true; } -bool JPEG::readMCU(uint16 xMCU, uint16 yMCU) { +// Marker 0xDD (Define Restart Interval) +bool JPEGDecoder::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 JPEGDecoder::readMCU(uint16 xMCU, uint16 yMCU) { bool ok = true; for (int c = 0; ok && (c < _numComp); c++) { // Set the current component @@ -504,42 +528,65 @@ 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 JPEGDecoder::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 JPEGDecoder::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) { +bool JPEGDecoder::readDataUnit(uint16 x, uint16 y) { // Prepare an empty data array int16 readData[64]; for (int i = 1; i < 64; i++) @@ -553,30 +600,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 +640,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++; } } @@ -604,7 +650,7 @@ bool JPEG::readDataUnit(uint16 x, uint16 y) { return true; } -int16 JPEG::readDC() { +int16 JPEGDecoder::readDC() { // DC is type 0 uint8 tableNum = _currentComp->DCentropyTableSelector << 1; @@ -615,7 +661,7 @@ int16 JPEG::readDC() { return readSignedBits(numBits); } -void JPEG::readAC(int16 *out) { +void JPEGDecoder::readAC(int16 *out) { // AC is type 1 uint8 tableNum = (_currentComp->ACentropyTableSelector << 1) + 1; @@ -645,17 +691,17 @@ void JPEG::readAC(int16 *out) { } } -int16 JPEG::readSignedBits(uint8 numBits) { +int16 JPEGDecoder::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; } @@ -663,7 +709,7 @@ int16 JPEG::readSignedBits(uint8 numBits) { } // TODO: optimize? -uint8 JPEG::readHuff(uint8 table) { +uint8 JPEGDecoder::readHuff(uint8 table) { bool foundCode = false; uint8 val = 0; @@ -693,7 +739,7 @@ uint8 JPEG::readHuff(uint8 table) { return val; } -uint8 JPEG::readBit() { +uint8 JPEGDecoder::readBit() { // Read a whole byte if necessary if (_bitsNumber == 0) { _bitsData = _stream->readByte(); @@ -709,6 +755,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); } @@ -720,12 +769,12 @@ uint8 JPEG::readBit() { return (_bitsData & (1 << _bitsNumber)) ? 1 : 0; } -Surface *JPEG::getComponent(uint c) { +const Surface *JPEGDecoder::getComponent(uint c) const { for (int i = 0; i < _numComp; i++) if (_components[i].id == c) // We found the desired component return &_components[i].surface; - error("JPEG::getComponent: No component %d present", c); + error("JPEGDecoder::getComponent: No component %d present", c); return NULL; } diff --git a/graphics/jpeg.h b/graphics/decoders/jpeg.h index 27b91e8777..c566d5ad21 100644 --- a/graphics/jpeg.h +++ b/graphics/decoders/jpeg.h @@ -24,6 +24,7 @@ #define GRAPHICS_JPEG_H #include "graphics/surface.h" +#include "graphics/decoders/image_decoder.h" namespace Common { class SeekableReadStream; @@ -36,24 +37,30 @@ struct PixelFormat; #define JPEG_MAX_QUANT_TABLES 4 #define JPEG_MAX_HUFF_TABLES 2 -class JPEG { +class JPEGDecoder : public ImageDecoder { public: - JPEG(); - ~JPEG(); + JPEGDecoder(); + ~JPEGDecoder(); + + // ImageDecoder API + void destroy(); + bool loadStream(Common::SeekableReadStream &str); + const Surface *getSurface() const; - bool read(Common::SeekableReadStream *str); bool isLoaded() const { return _numComp && _w && _h; } uint16 getWidth() const { return _w; } uint16 getHeight() const { return _h; } - - Surface *getComponent(uint c); - Surface *getSurface(const PixelFormat &format); + const Surface *getComponent(uint c) const; private: - void reset(); - Common::SeekableReadStream *_stream; uint16 _w, _h; + uint16 _restartInterval; + + // mutable so that we can convert to RGB only during + // a getSurface() call while still upholding the + // const requirement in other ImageDecoders + mutable Graphics::Surface *_rgbSurface; // Image components uint8 _numComp; @@ -101,6 +108,7 @@ private: bool readDHT(); bool readSOS(); bool readDQT(); + bool readDRI(); // Helper functions bool readMCU(uint16 xMCU, uint16 yMCU); @@ -116,7 +124,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/pict.cpp b/graphics/decoders/pict.cpp index dcd0df8e10..957342084e 100644 --- a/graphics/pict.cpp +++ b/graphics/decoders/pict.cpp @@ -26,9 +26,9 @@ #include "common/substream.h" #include "common/textconsole.h" -#include "graphics/jpeg.h" -#include "graphics/pict.h" #include "graphics/surface.h" +#include "graphics/decoders/jpeg.h" +#include "graphics/decoders/pict.h" namespace Graphics { @@ -36,18 +36,25 @@ namespace Graphics { // http://developer.apple.com/legacy/mac/library/documentation/mac/QuickDraw/QuickDraw-461.html // http://developer.apple.com/legacy/mac/library/documentation/mac/QuickDraw/QuickDraw-269.html -PictDecoder::PictDecoder(PixelFormat pixelFormat) { - _jpeg = new JPEG(); - _pixelFormat = pixelFormat; +PICTDecoder::PICTDecoder() { + _outputSurface = 0; +} + +PICTDecoder::~PICTDecoder() { + destroy(); } -PictDecoder::~PictDecoder() { - delete _jpeg; +void PICTDecoder::destroy() { + if (_outputSurface) { + _outputSurface->free(); + delete _outputSurface; + _outputSurface = 0; + } } -#define OPCODE(a, b, c) _opcodes.push_back(PICTOpcode(a, &PictDecoder::b, c)) +#define OPCODE(a, b, c) _opcodes.push_back(PICTOpcode(a, &PICTDecoder::b, c)) -void PictDecoder::setupOpcodesCommon() { +void PICTDecoder::setupOpcodesCommon() { OPCODE(0x0000, o_nop, "NOP"); OPCODE(0x0001, o_clip, "Clip"); OPCODE(0x0003, o_txFont, "TxFont"); @@ -63,14 +70,14 @@ void PictDecoder::setupOpcodesCommon() { OPCODE(0x0C00, o_headerOp, "HeaderOp"); } -void PictDecoder::setupOpcodesNormal() { +void PICTDecoder::setupOpcodesNormal() { setupOpcodesCommon(); OPCODE(0x0098, on_packBitsRect, "PackBitsRect"); OPCODE(0x009A, on_directBitsRect, "DirectBitsRect"); OPCODE(0x8200, on_compressedQuickTime, "CompressedQuickTime"); } -void PictDecoder::setupOpcodesQuickTime() { +void PICTDecoder::setupOpcodesQuickTime() { setupOpcodesCommon(); OPCODE(0x0098, oq_packBitsRect, "PackBitsRect"); OPCODE(0x009A, oq_directBitsRect, "DirectBitsRect"); @@ -79,93 +86,93 @@ void PictDecoder::setupOpcodesQuickTime() { #undef OPCODE -void PictDecoder::o_nop(Common::SeekableReadStream *) { +void PICTDecoder::o_nop(Common::SeekableReadStream &) { // Nothing to do } -void PictDecoder::o_clip(Common::SeekableReadStream *stream) { +void PICTDecoder::o_clip(Common::SeekableReadStream &stream) { // Ignore - stream->skip(stream->readUint16BE() - 2); + stream.skip(stream.readUint16BE() - 2); } -void PictDecoder::o_txFont(Common::SeekableReadStream *stream) { +void PICTDecoder::o_txFont(Common::SeekableReadStream &stream) { // Ignore - stream->readUint16BE(); + stream.readUint16BE(); } -void PictDecoder::o_txFace(Common::SeekableReadStream *stream) { +void PICTDecoder::o_txFace(Common::SeekableReadStream &stream) { // Ignore - stream->readByte(); + stream.readByte(); } -void PictDecoder::o_pnSize(Common::SeekableReadStream *stream) { +void PICTDecoder::o_pnSize(Common::SeekableReadStream &stream) { // Ignore - stream->readUint16BE(); - stream->readUint16BE(); + stream.readUint16BE(); + stream.readUint16BE(); } -void PictDecoder::o_txSize(Common::SeekableReadStream *stream) { +void PICTDecoder::o_txSize(Common::SeekableReadStream &stream) { // Ignore - stream->readUint16BE(); + stream.readUint16BE(); } -void PictDecoder::o_txRatio(Common::SeekableReadStream *stream) { +void PICTDecoder::o_txRatio(Common::SeekableReadStream &stream) { // Ignore - stream->readUint16BE(); - stream->readUint16BE(); - stream->readUint16BE(); - stream->readUint16BE(); + stream.readUint16BE(); + stream.readUint16BE(); + stream.readUint16BE(); + stream.readUint16BE(); } -void PictDecoder::o_versionOp(Common::SeekableReadStream *stream) { +void PICTDecoder::o_versionOp(Common::SeekableReadStream &stream) { // We only support v2 extended - if (stream->readUint16BE() != 0x02FF) + if (stream.readUint16BE() != 0x02FF) error("Unknown PICT version"); } -void PictDecoder::o_longText(Common::SeekableReadStream *stream) { +void PICTDecoder::o_longText(Common::SeekableReadStream &stream) { // Ignore - stream->readUint16BE(); - stream->readUint16BE(); - stream->skip(stream->readByte()); + stream.readUint16BE(); + stream.readUint16BE(); + stream.skip(stream.readByte()); } -void PictDecoder::o_longComment(Common::SeekableReadStream *stream) { +void PICTDecoder::o_longComment(Common::SeekableReadStream &stream) { // Ignore - stream->readUint16BE(); - stream->skip(stream->readUint16BE()); + stream.readUint16BE(); + stream.skip(stream.readUint16BE()); } -void PictDecoder::o_opEndPic(Common::SeekableReadStream *stream) { +void PICTDecoder::o_opEndPic(Common::SeekableReadStream &stream) { // We've reached the end of the picture _continueParsing = false; } -void PictDecoder::o_headerOp(Common::SeekableReadStream *stream) { +void PICTDecoder::o_headerOp(Common::SeekableReadStream &stream) { // Read the basic header, but we don't really have to do anything with it - /* uint16 version = */ stream->readUint16BE(); - stream->readUint16BE(); // Reserved - /* uint32 hRes = */ stream->readUint32BE(); - /* uint32 vRes = */ stream->readUint32BE(); + /* uint16 version = */ stream.readUint16BE(); + stream.readUint16BE(); // Reserved + /* uint32 hRes = */ stream.readUint32BE(); + /* uint32 vRes = */ stream.readUint32BE(); Common::Rect origResRect; - origResRect.top = stream->readUint16BE(); - origResRect.left = stream->readUint16BE(); - origResRect.bottom = stream->readUint16BE(); - origResRect.right = stream->readUint16BE(); - stream->readUint32BE(); // Reserved + origResRect.top = stream.readUint16BE(); + origResRect.left = stream.readUint16BE(); + origResRect.bottom = stream.readUint16BE(); + origResRect.right = stream.readUint16BE(); + stream.readUint32BE(); // Reserved } -void PictDecoder::on_packBitsRect(Common::SeekableReadStream *stream) { +void PICTDecoder::on_packBitsRect(Common::SeekableReadStream &stream) { // Unpack data (8bpp or lower) unpackBitsRect(stream, true); } -void PictDecoder::on_directBitsRect(Common::SeekableReadStream *stream) { +void PICTDecoder::on_directBitsRect(Common::SeekableReadStream &stream) { // Unpack data (16bpp or higher) unpackBitsRect(stream, false); } -void PictDecoder::on_compressedQuickTime(Common::SeekableReadStream *stream) { +void PICTDecoder::on_compressedQuickTime(Common::SeekableReadStream &stream) { // OK, here's the fun. We get to completely change how QuickDraw draws // the data in PICT files. @@ -173,63 +180,57 @@ void PictDecoder::on_compressedQuickTime(Common::SeekableReadStream *stream) { _opcodes.clear(); setupOpcodesQuickTime(); - // We set up the surface for JPEG here too - if (!_outputSurface) - _outputSurface = new Graphics::Surface(); - _outputSurface->create(_imageRect.width(), _imageRect.height(), _pixelFormat); - // We'll decode the first QuickTime data from here, but the QuickTime-specific // opcodes will take over from here on out. Normal opcodes, signing off. decodeCompressedQuickTime(stream); } -void PictDecoder::oq_packBitsRect(Common::SeekableReadStream *stream) { +void PICTDecoder::oq_packBitsRect(Common::SeekableReadStream &stream) { // Skip any data here (8bpp or lower) skipBitsRect(stream, true); } -void PictDecoder::oq_directBitsRect(Common::SeekableReadStream *stream) { +void PICTDecoder::oq_directBitsRect(Common::SeekableReadStream &stream) { // Skip any data here (16bpp or higher) skipBitsRect(stream, false); } -void PictDecoder::oq_compressedQuickTime(Common::SeekableReadStream *stream) { +void PICTDecoder::oq_compressedQuickTime(Common::SeekableReadStream &stream) { // Just pass the data along decodeCompressedQuickTime(stream); } -Surface *PictDecoder::decodeImage(Common::SeekableReadStream *stream, byte *palette) { - assert(stream); +bool PICTDecoder::loadStream(Common::SeekableReadStream &stream) { + destroy(); // Initialize opcodes to their normal state _opcodes.clear(); setupOpcodesNormal(); - _outputSurface = 0; _continueParsing = true; memset(_palette, 0, sizeof(_palette)); - uint16 fileSize = stream->readUint16BE(); + uint16 fileSize = stream.readUint16BE(); // If we have no file size here, we probably have a PICT from a file // and not a resource. The other two bytes are the fileSize which we // don't actually need (and already read if from a resource). if (!fileSize) - stream->seek(512 + 2); + stream.seek(512 + 2); - _imageRect.top = stream->readUint16BE(); - _imageRect.left = stream->readUint16BE(); - _imageRect.bottom = stream->readUint16BE(); - _imageRect.right = stream->readUint16BE(); + _imageRect.top = stream.readUint16BE(); + _imageRect.left = stream.readUint16BE(); + _imageRect.bottom = stream.readUint16BE(); + _imageRect.right = stream.readUint16BE(); _imageRect.debugPrint(0, "PICT Rect:"); // NOTE: This is only a subset of the full PICT format. // - Only V2 (Extended) Images Supported // - CompressedQuickTime (JPEG) compressed data is supported // - DirectBitsRect/PackBitsRect compressed data is supported - for (uint32 opNum = 0; !stream->eos() && !stream->err() && stream->pos() < stream->size() && _continueParsing; opNum++) { + for (uint32 opNum = 0; !stream.eos() && !stream.err() && stream.pos() < stream.size() && _continueParsing; opNum++) { // PICT v2 opcodes are two bytes - uint16 opcode = stream->readUint16BE(); + uint16 opcode = stream.readUint16BE(); if (opNum == 0 && opcode != 0x0011) error("Cannot find PICT version opcode"); @@ -238,7 +239,7 @@ Surface *PictDecoder::decodeImage(Common::SeekableReadStream *stream, byte *pale // Since opcodes are word-aligned, we need to mark our starting // position here. - uint32 startPos = stream->pos(); + uint32 startPos = stream.pos(); for (uint32 i = 0; i < _opcodes.size(); i++) { if (_opcodes[i].op == opcode) { @@ -252,76 +253,70 @@ Surface *PictDecoder::decodeImage(Common::SeekableReadStream *stream, byte *pale } // Align - stream->skip((stream->pos() - startPos) & 1); + stream.skip((stream.pos() - startPos) & 1); } - // If we got a palette throughout this nonsense, go and grab it - if (palette) - memcpy(palette, _palette, 256 * 3); - return _outputSurface; } -PictDecoder::PixMap PictDecoder::readPixMap(Common::SeekableReadStream *stream, bool hasBaseAddr) { +PICTDecoder::PixMap PICTDecoder::readPixMap(Common::SeekableReadStream &stream, bool hasBaseAddr) { PixMap pixMap; - pixMap.baseAddr = hasBaseAddr ? stream->readUint32BE() : 0; - pixMap.rowBytes = stream->readUint16BE() & 0x3fff; - pixMap.bounds.top = stream->readUint16BE(); - pixMap.bounds.left = stream->readUint16BE(); - pixMap.bounds.bottom = stream->readUint16BE(); - pixMap.bounds.right = stream->readUint16BE(); - pixMap.pmVersion = stream->readUint16BE(); - pixMap.packType = stream->readUint16BE(); - pixMap.packSize = stream->readUint32BE(); - pixMap.hRes = stream->readUint32BE(); - pixMap.vRes = stream->readUint32BE(); - pixMap.pixelType = stream->readUint16BE(); - pixMap.pixelSize = stream->readUint16BE(); - pixMap.cmpCount = stream->readUint16BE(); - pixMap.cmpSize = stream->readUint16BE(); - pixMap.planeBytes = stream->readUint32BE(); - pixMap.pmTable = stream->readUint32BE(); - pixMap.pmReserved = stream->readUint32BE(); + pixMap.baseAddr = hasBaseAddr ? stream.readUint32BE() : 0; + pixMap.rowBytes = stream.readUint16BE() & 0x3fff; + pixMap.bounds.top = stream.readUint16BE(); + pixMap.bounds.left = stream.readUint16BE(); + pixMap.bounds.bottom = stream.readUint16BE(); + pixMap.bounds.right = stream.readUint16BE(); + pixMap.pmVersion = stream.readUint16BE(); + pixMap.packType = stream.readUint16BE(); + pixMap.packSize = stream.readUint32BE(); + pixMap.hRes = stream.readUint32BE(); + pixMap.vRes = stream.readUint32BE(); + pixMap.pixelType = stream.readUint16BE(); + pixMap.pixelSize = stream.readUint16BE(); + pixMap.cmpCount = stream.readUint16BE(); + pixMap.cmpSize = stream.readUint16BE(); + pixMap.planeBytes = stream.readUint32BE(); + pixMap.pmTable = stream.readUint32BE(); + pixMap.pmReserved = stream.readUint32BE(); return pixMap; } struct PackBitsRectData { - PictDecoder::PixMap pixMap; + PICTDecoder::PixMap pixMap; Common::Rect srcRect; Common::Rect dstRect; uint16 mode; }; -void PictDecoder::unpackBitsRect(Common::SeekableReadStream *stream, bool hasPalette) { - static const PixelFormat directBitsFormat16 = PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0); - +void PICTDecoder::unpackBitsRect(Common::SeekableReadStream &stream, bool hasPalette) { PackBitsRectData packBitsData; packBitsData.pixMap = readPixMap(stream, !hasPalette); // Read in the palette if there is one present if (hasPalette) { // See http://developer.apple.com/legacy/mac/library/documentation/mac/QuickDraw/QuickDraw-267.html - stream->readUint32BE(); // seed - stream->readUint16BE(); // flags - uint16 colorCount = stream->readUint16BE() + 1; + stream.readUint32BE(); // seed + stream.readUint16BE(); // flags + uint16 colorCount = stream.readUint16BE() + 1; for (uint32 i = 0; i < colorCount; i++) { - stream->readUint16BE(); - _palette[i * 3] = stream->readUint16BE() >> 8; - _palette[i * 3 + 1] = stream->readUint16BE() >> 8; - _palette[i * 3 + 2] = stream->readUint16BE() >> 8; + stream.readUint16BE(); + _palette[i * 3] = stream.readUint16BE() >> 8; + _palette[i * 3 + 1] = stream.readUint16BE() >> 8; + _palette[i * 3 + 2] = stream.readUint16BE() >> 8; } } - packBitsData.srcRect.top = stream->readUint16BE(); - packBitsData.srcRect.left = stream->readUint16BE(); - packBitsData.srcRect.bottom = stream->readUint16BE(); - packBitsData.srcRect.right = stream->readUint16BE(); - packBitsData.dstRect.top = stream->readUint16BE(); - packBitsData.dstRect.left = stream->readUint16BE(); - packBitsData.dstRect.bottom = stream->readUint16BE(); - packBitsData.dstRect.right = stream->readUint16BE(); - packBitsData.mode = stream->readUint16BE(); + packBitsData.srcRect.top = stream.readUint16BE(); + packBitsData.srcRect.left = stream.readUint16BE(); + packBitsData.srcRect.bottom = stream.readUint16BE(); + packBitsData.srcRect.right = stream.readUint16BE(); + packBitsData.dstRect.top = stream.readUint16BE(); + packBitsData.dstRect.left = stream.readUint16BE(); + packBitsData.dstRect.bottom = stream.readUint16BE(); + packBitsData.dstRect.right = stream.readUint16BE(); + packBitsData.mode = stream.readUint16BE(); uint16 width = packBitsData.srcRect.width(); uint16 height = packBitsData.srcRect.height(); @@ -335,13 +330,9 @@ void PictDecoder::unpackBitsRect(Common::SeekableReadStream *stream, bool hasPal else bytesPerPixel = packBitsData.pixMap.pixelSize / 8; - _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++) { @@ -356,56 +347,48 @@ void PictDecoder::unpackBitsRect(Common::SeekableReadStream *stream, bool hasPal // TODO: Finish this. Hasn't been needed (yet). error("Unpacked DirectBitsRect data (not padded)"); } else if (packBitsData.pixMap.packType == 0 || packBitsData.pixMap.packType > 2) { // Packed - uint16 byteCount = (packBitsData.pixMap.rowBytes > 250) ? stream->readUint16BE() : stream->readByte(); - unpackBitsLine(buffer + i * _outputSurface->w * bytesPerPixel, packBitsData.pixMap.rowBytes, stream->readStream(byteCount), packBitsData.pixMap.pixelSize, bytesPerPixel); + uint16 byteCount = (packBitsData.pixMap.rowBytes > 250) ? stream.readUint16BE() : stream.readByte(); + unpackBitsLine(buffer + i * width * bytesPerPixel, packBitsData.pixMap.rowBytes, stream.readStream(byteCount), packBitsData.pixMap.pixelSize, bytesPerPixel); } } + _outputSurface = new Graphics::Surface(); + switch (bytesPerPixel) { case 1: // Just copy to the image + _outputSurface->create(width, height, PixelFormat::createFormatCLUT8()); memcpy(_outputSurface->pixels, buffer, _outputSurface->w * _outputSurface->h); break; case 2: // Convert from 16-bit to whatever surface we need - for (uint16 y = 0; y < _outputSurface->h; y++) { - for (uint16 x = 0; x < _outputSurface->w; x++) { - byte r = 0, g = 0, b = 0; - uint32 color = READ_BE_UINT16(buffer + (y * _outputSurface->w + x) * bytesPerPixel); - directBitsFormat16.colorToRGB(color, r, g, b); - if (_pixelFormat.bytesPerPixel == 2) - *((uint16 *)_outputSurface->getBasePtr(x, y)) = _pixelFormat.RGBToColor(r, g, b); - else - *((uint32 *)_outputSurface->getBasePtr(x, y)) = _pixelFormat.RGBToColor(r, g, b); - } - } + _outputSurface->create(width, height, PixelFormat(2, 5, 5, 5, 0, 10, 5, 0, 0)); + for (uint16 y = 0; y < _outputSurface->h; y++) + for (uint16 x = 0; x < _outputSurface->w; x++) + WRITE_UINT16(_outputSurface->getBasePtr(x, y), READ_UINT16(buffer + (y * _outputSurface->w + x) * 2)); break; case 3: // Convert from 24-bit (planar!) to whatever surface we need + _outputSurface->create(width, height, Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0)); for (uint16 y = 0; y < _outputSurface->h; y++) { for (uint16 x = 0; x < _outputSurface->w; x++) { byte r = *(buffer + y * _outputSurface->w * 3 + x); byte g = *(buffer + y * _outputSurface->w * 3 + _outputSurface->w + x); byte b = *(buffer + y * _outputSurface->w * 3 + _outputSurface->w * 2 + x); - if (_pixelFormat.bytesPerPixel == 2) - *((uint16 *)_outputSurface->getBasePtr(x, y)) = _pixelFormat.RGBToColor(r, g, b); - else - *((uint32 *)_outputSurface->getBasePtr(x, y)) = _pixelFormat.RGBToColor(r, g, b); + *((uint32 *)_outputSurface->getBasePtr(x, y)) = _outputSurface->format.RGBToColor(r, g, b); } } break; case 4: // Convert from 32-bit (planar!) to whatever surface we need + _outputSurface->create(width, height, Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0)); for (uint16 y = 0; y < _outputSurface->h; y++) { for (uint16 x = 0; x < _outputSurface->w; x++) { byte r = *(buffer + y * _outputSurface->w * 4 + x); byte g = *(buffer + y * _outputSurface->w * 4 + _outputSurface->w + x); byte b = *(buffer + y * _outputSurface->w * 4 + _outputSurface->w * 2 + x); byte a = *(buffer + y * _outputSurface->w * 4 + _outputSurface->w * 3 + x); - if (_pixelFormat.bytesPerPixel == 2) - *((uint16 *)_outputSurface->getBasePtr(x, y)) = _pixelFormat.ARGBToColor(r, g, b, a); - else - *((uint32 *)_outputSurface->getBasePtr(x, y)) = _pixelFormat.ARGBToColor(r, g, b, a); + *((uint32 *)_outputSurface->getBasePtr(x, y)) = _outputSurface->format.ARGBToColor(r, g, b, a); } } break; @@ -414,7 +397,7 @@ void PictDecoder::unpackBitsRect(Common::SeekableReadStream *stream, bool hasPal delete[] buffer; } -void PictDecoder::unpackBitsLine(byte *out, uint32 length, Common::SeekableReadStream *data, byte bitsPerPixel, byte bytesPerPixel) { +void PICTDecoder::unpackBitsLine(byte *out, uint32 length, Common::SeekableReadStream *data, byte bitsPerPixel, byte bytesPerPixel) { uint32 dataDecoded = 0; byte bytesPerDecode = (bytesPerPixel == 2) ? 2 : 1; @@ -427,7 +410,7 @@ void PictDecoder::unpackBitsLine(byte *out, uint32 length, Common::SeekableReadS for (uint32 i = 0; i < runSize; i++) { if (bytesPerDecode == 2) { - WRITE_BE_UINT16(out, value); + WRITE_UINT16(out, value); out += 2; } else { outputPixelBuffer(out, value, bitsPerPixel); @@ -435,12 +418,19 @@ void PictDecoder::unpackBitsLine(byte *out, uint32 length, Common::SeekableReadS } dataDecoded += runSize * bytesPerDecode; } else { - uint32 runSize = (op + 1) * bytesPerDecode; - - for (uint32 i = 0; i < runSize; i++) - outputPixelBuffer(out, data->readByte(), bitsPerPixel); + uint32 runSize = op + 1; + + if (bytesPerDecode == 1) { + for (uint32 i = 0; i < runSize; i++) + outputPixelBuffer(out, data->readByte(), bitsPerPixel); + } else { + for (uint32 i = 0; i < runSize; i++) { + WRITE_UINT16(out, data->readUint16BE()); + out += 2; + } + } - dataDecoded += runSize; + dataDecoded += runSize * bytesPerDecode; } } @@ -454,122 +444,124 @@ void PictDecoder::unpackBitsLine(byte *out, uint32 length, Common::SeekableReadS delete data; } -void PictDecoder::skipBitsRect(Common::SeekableReadStream *stream, bool hasPalette) { +void PICTDecoder::outputPixelBuffer(byte *&out, byte value, byte bitsPerPixel) { + switch (bitsPerPixel) { + case 1: + for (int i = 7; i >= 0; i--) + *out++ = (value >> i) & 1; + break; + case 2: + for (int i = 6; i >= 0; i -= 2) + *out++ = (value >> i) & 3; + break; + case 4: + *out++ = (value >> 4) & 0xf; + *out++ = value & 0xf; + break; + default: + *out++ = value; + } +} + +void PICTDecoder::skipBitsRect(Common::SeekableReadStream &stream, bool hasPalette) { // Step through a PackBitsRect/DirectBitsRect function if (!hasPalette) - stream->readUint32BE(); + stream.readUint32BE(); - uint16 rowBytes = stream->readUint16BE(); - uint16 height = stream->readUint16BE(); - stream->readUint16BE(); - height = stream->readUint16BE() - height; - stream->readUint16BE(); + uint16 rowBytes = stream.readUint16BE(); + uint16 height = stream.readUint16BE(); + stream.readUint16BE(); + height = stream.readUint16BE() - height; + stream.readUint16BE(); uint16 packType; - uint16 pixelSize; // FIXME: unused // Top two bits signify PixMap vs BitMap if (rowBytes & 0xC000) { // PixMap - stream->readUint16BE(); - packType = stream->readUint16BE(); - stream->skip(14); - pixelSize = stream->readUint16BE(); - stream->skip(16); + stream.readUint16BE(); + packType = stream.readUint16BE(); + stream.skip(14); + stream.readUint16BE(); // pixelSize + stream.skip(16); if (hasPalette) { - stream->readUint32BE(); - stream->readUint16BE(); - stream->skip((stream->readUint16BE() + 1) * 8); + stream.readUint32BE(); + stream.readUint16BE(); + stream.skip((stream.readUint16BE() + 1) * 8); } rowBytes &= 0x3FFF; } else { // BitMap packType = 0; - pixelSize = 1; } - stream->skip(18); + stream.skip(18); for (uint16 i = 0; i < height; i++) { if (packType == 1 || packType == 2 || rowBytes < 8) error("Unpacked PackBitsRect data"); else if (packType == 0 || packType > 2) - stream->skip((rowBytes > 250) ? stream->readUint16BE() : stream->readByte()); - } -} - -void PictDecoder::outputPixelBuffer(byte *&out, byte value, byte bitsPerPixel) { - switch (bitsPerPixel) { - case 1: - for (int i = 7; i >= 0; i--) - *out++ = (value >> i) & 1; - break; - case 2: - for (int i = 6; i >= 0; i -= 2) - *out++ = (value >> i) & 3; - break; - case 4: - *out++ = (value >> 4) & 0xf; - *out++ = value & 0xf; - break; - default: - *out++ = value; + stream.skip((rowBytes > 250) ? stream.readUint16BE() : stream.readByte()); } } // Compressed QuickTime details can be found here: // http://developer.apple.com/legacy/mac/library/#documentation/QuickTime/Rm/CompressDecompress/ImageComprMgr/B-Chapter/2TheImageCompression.html // http://developer.apple.com/legacy/mac/library/#documentation/QuickTime/Rm/CompressDecompress/ImageComprMgr/F-Chapter/6WorkingwiththeImage.html - -void PictDecoder::decodeCompressedQuickTime(Common::SeekableReadStream *stream) { +void PICTDecoder::decodeCompressedQuickTime(Common::SeekableReadStream &stream) { // First, read all the fields from the opcode - uint32 dataSize = stream->readUint32BE(); - uint32 startPos = stream->pos(); + uint32 dataSize = stream.readUint32BE(); + uint32 startPos = stream.pos(); - /* uint16 version = */ stream->readUint16BE(); + /* uint16 version = */ stream.readUint16BE(); // Read in the display matrix uint32 matrix[3][3]; for (uint32 i = 0; i < 3; i++) for (uint32 j = 0; j < 3; j++) - matrix[i][j] = stream->readUint32BE(); + matrix[i][j] = stream.readUint32BE(); // We currently only support offseting images vertically from the matrix uint16 xOffset = 0; uint16 yOffset = matrix[2][1] >> 16; - uint32 matteSize = stream->readUint32BE(); - stream->skip(8); // matte rect - /* uint16 transferMode = */ stream->readUint16BE(); - stream->skip(8); // src rect - /* uint32 accuracy = */ stream->readUint32BE(); - uint32 maskSize = stream->readUint32BE(); + uint32 matteSize = stream.readUint32BE(); + stream.skip(8); // matte rect + /* uint16 transferMode = */ stream.readUint16BE(); + stream.skip(8); // src rect + /* uint32 accuracy = */ stream.readUint32BE(); + uint32 maskSize = stream.readUint32BE(); // Skip the matte and mask - stream->skip(matteSize + maskSize); + stream.skip(matteSize + maskSize); // Now we've reached the image descriptor, so read the relevant data from that - uint32 idStart = stream->pos(); - uint32 idSize = stream->readUint32BE(); - stream->skip(40); // miscellaneous stuff - uint32 jpegSize = stream->readUint32BE(); - stream->skip(idSize - (stream->pos() - idStart)); // more useless stuff + uint32 idStart = stream.pos(); + uint32 idSize = stream.readUint32BE(); + stream.skip(40); // miscellaneous stuff + uint32 jpegSize = stream.readUint32BE(); + stream.skip(idSize - (stream.pos() - idStart)); // more useless stuff - Common::SeekableReadStream *jpegStream = new Common::SeekableSubReadStream(stream, stream->pos(), stream->pos() + jpegSize); + Common::SeekableSubReadStream jpegStream(&stream, stream.pos(), stream.pos() + jpegSize); - if (!_jpeg->read(jpegStream)) - error("PictDecoder::decodeCompressedQuickTime(): Could not decode JPEG data"); + JPEGDecoder jpeg; + if (!jpeg.loadStream(jpegStream)) + error("PICTDecoder::decodeCompressedQuickTime(): Could not decode JPEG data"); - Graphics::Surface *jpegSurface = _jpeg->getSurface(_pixelFormat); + const Graphics::Surface *jpegSurface = jpeg.getSurface(); + + if (!_outputSurface) { + _outputSurface = new Graphics::Surface(); + _outputSurface->create(_imageRect.width(), _imageRect.height(), jpegSurface->format); + } for (uint16 y = 0; y < jpegSurface->h; y++) - memcpy(_outputSurface->getBasePtr(0 + xOffset, y + yOffset), jpegSurface->getBasePtr(0, y), jpegSurface->w * _pixelFormat.bytesPerPixel); + memcpy(_outputSurface->getBasePtr(0 + xOffset, y + yOffset), jpegSurface->getBasePtr(0, y), jpegSurface->w * jpegSurface->format.bytesPerPixel); - stream->seek(startPos + dataSize); - delete jpegStream; + stream.seek(startPos + dataSize); } } // End of namespace Graphics diff --git a/graphics/pict.h b/graphics/decoders/pict.h index b426c6ee35..b1e45a6bc1 100644 --- a/graphics/pict.h +++ b/graphics/decoders/pict.h @@ -27,6 +27,7 @@ #include "common/rect.h" #include "common/scummsys.h" +#include "graphics/decoders/image_decoder.h" #include "graphics/pixelformat.h" namespace Common { @@ -35,16 +36,20 @@ class SeekableReadStream; namespace Graphics { -class JPEG; struct Surface; -#define DECLARE_OPCODE(x) void x(Common::SeekableReadStream *stream) +#define DECLARE_OPCODE(x) void x(Common::SeekableReadStream &stream) -class PictDecoder { +class PICTDecoder : public ImageDecoder { public: - PictDecoder(Graphics::PixelFormat pixelFormat); - ~PictDecoder(); - Surface *decodeImage(Common::SeekableReadStream *stream, byte *palette = 0); + PICTDecoder(); + ~PICTDecoder(); + + // ImageDecoder API + bool loadStream(Common::SeekableReadStream &stream); + void destroy(); + const Surface *getSurface() const { return _outputSurface; } + const byte *getPalette() const { return _palette; } struct PixMap { uint32 baseAddr; @@ -64,26 +69,23 @@ public: uint32 pmReserved; }; - static PixMap readPixMap(Common::SeekableReadStream *stream, bool hasBaseAddr = true); + static PixMap readPixMap(Common::SeekableReadStream &stream, bool hasBaseAddr = true); private: Common::Rect _imageRect; - PixelFormat _pixelFormat; - JPEG *_jpeg; byte _palette[256 * 3]; - bool _isPaletted; Graphics::Surface *_outputSurface; bool _continueParsing; // Utility Functions - void unpackBitsRect(Common::SeekableReadStream *stream, bool hasPalette); - void unpackBitsLine(byte *out, uint32 length, Common::SeekableReadStream *data, byte bitsPerPixel, byte bytesPerPixel); - void skipBitsRect(Common::SeekableReadStream *stream, bool hasPalette); - void decodeCompressedQuickTime(Common::SeekableReadStream *stream); + void unpackBitsRect(Common::SeekableReadStream &stream, bool hasPalette); + void unpackBitsLine(byte *out, uint32 length, Common::SeekableReadStream *stream, byte bitsPerPixel, byte bytesPerPixel); + void skipBitsRect(Common::SeekableReadStream &stream, bool hasPalette); + void decodeCompressedQuickTime(Common::SeekableReadStream &stream); void outputPixelBuffer(byte *&out, byte value, byte bitsPerPixel); // Opcodes - typedef void (PictDecoder::*OpcodeProcPICT)(Common::SeekableReadStream *stream); + typedef void (PICTDecoder::*OpcodeProcPICT)(Common::SeekableReadStream &stream); struct PICTOpcode { PICTOpcode() { op = 0; proc = 0; desc = 0; } PICTOpcode(uint16 o, OpcodeProcPICT p, const char *d) { op = o; proc = p; desc = d; } diff --git a/graphics/png.cpp b/graphics/decoders/png.cpp index cea8b575ad..b87b6fdc7a 100644 --- a/graphics/png.cpp +++ b/graphics/decoders/png.cpp @@ -20,7 +20,7 @@ * */ -#include "graphics/png.h" +#include "graphics/decoders/png.h" #include "graphics/pixelformat.h" #include "graphics/surface.h" @@ -98,116 +98,30 @@ enum PNGFilters { kFilterPaeth = 4 }; -PNG::PNG() : _compressedBuffer(0), _compressedBufferSize(0), - _unfilteredSurface(0), _transparentColorSpecified(false) { +PNGDecoder::PNGDecoder() : _compressedBuffer(0), _compressedBufferSize(0), + _transparentColorSpecified(false), _outputSurface(0) { } -PNG::~PNG() { - if (_unfilteredSurface) { - _unfilteredSurface->free(); - delete _unfilteredSurface; - } +PNGDecoder::~PNGDecoder() { + destroy(); } -Graphics::Surface *PNG::getSurface(const PixelFormat &format) { - Graphics::Surface *output = new Graphics::Surface(); - output->create(_unfilteredSurface->w, _unfilteredSurface->h, format); - byte *src = (byte *)_unfilteredSurface->pixels; - byte a = 0xFF; - byte bpp = _unfilteredSurface->format.bytesPerPixel; - - if (_header.colorType != kIndexed) { - if (_header.colorType == kTrueColor || - _header.colorType == kTrueColorWithAlpha) { - if (bpp != 3 && bpp != 4) - error("Unsupported truecolor PNG format"); - } else if (_header.colorType == kGrayScale || - _header.colorType == kGrayScaleWithAlpha) { - if (bpp != 1 && bpp != 2) - error("Unsupported grayscale PNG format"); - } - - for (uint16 i = 0; i < output->h; i++) { - for (uint16 j = 0; j < output->w; j++) { - uint32 result = 0; - - switch (bpp) { - case 1: // Grayscale - if (_transparentColorSpecified) - a = (src[0] == _transparentColor[0]) ? 0 : 0xFF; - result = format.ARGBToColor( a, src[0], src[0], src[0]); - break; - case 2: // Grayscale + alpha - result = format.ARGBToColor(src[1], src[0], src[0], src[0]); - break; - case 3: // RGB - if (_transparentColorSpecified) { - bool isTransparentColor = (src[0] == _transparentColor[0] && - src[1] == _transparentColor[1] && - src[2] == _transparentColor[2]); - a = isTransparentColor ? 0 : 0xFF; - } - result = format.ARGBToColor( a, src[0], src[1], src[2]); - break; - case 4: // RGBA - result = format.ARGBToColor(src[3], src[0], src[1], src[2]); - break; - } - - if (format.bytesPerPixel == 2) // 2bpp - *((uint16 *)output->getBasePtr(j, i)) = (uint16)result; - else // 4bpp - *((uint32 *)output->getBasePtr(j, i)) = result; - - src += bpp; - } - } - } else { - byte index, r, g, b; - uint32 mask = (0xff >> (8 - _header.bitDepth)) << (8 - _header.bitDepth); - - // Convert the indexed surface to the target pixel format - for (uint16 i = 0; i < output->h; i++) { - int data = 0; - int bitCount = 8; - byte *src1 = src; - - for (uint16 j = 0; j < output->w; j++) { - if (bitCount == 8) { - data = *src; - src++; - } - - index = (data & mask) >> (8 - _header.bitDepth); - data = (data << _header.bitDepth) & 0xff; - bitCount -= _header.bitDepth; - - if (bitCount == 0) - bitCount = 8; - - r = _palette[index * 4 + 0]; - g = _palette[index * 4 + 1]; - b = _palette[index * 4 + 2]; - a = _palette[index * 4 + 3]; - - if (format.bytesPerPixel == 2) - *((uint16 *)output->getBasePtr(j, i)) = format.ARGBToColor(a, r, g, b); - else - *((uint32 *)output->getBasePtr(j, i)) = format.ARGBToColor(a, r, g, b); - } - src = src1 + output->w; - } +void PNGDecoder::destroy() { + if (_outputSurface) { + _outputSurface->free(); + delete _outputSurface; + _outputSurface = 0; } - - return output; } -bool PNG::read(Common::SeekableReadStream *str) { +bool PNGDecoder::loadStream(Common::SeekableReadStream &stream) { + destroy(); + uint32 chunkLength = 0, chunkType = 0; - _stream = str; + _stream = &stream; // First, check the PNG signature - if (_stream->readUint32BE() != MKTAG(0x89, 0x50, 0x4e, 0x47)) { + if (_stream->readUint32BE() != MKTAG(0x89, 'P', 'N', 'G')) { delete _stream; return false; } @@ -249,8 +163,10 @@ bool PNG::read(Common::SeekableReadStream *str) { error("A palette chunk has been found in a non-indexed PNG file"); if (chunkLength % 3 != 0) error("Palette chunk not divisible by 3"); + _paletteEntries = chunkLength / 3; - readPaletteChunk(); + _stream->read(_palette, _paletteEntries * 3); + memset(_paletteTransparency, 0xff, sizeof(_paletteTransparency)); break; case kChunkIEND: // End of stream @@ -269,7 +185,6 @@ bool PNG::read(Common::SeekableReadStream *str) { } // We no longer need the file stream, thus close it here - delete _stream; _stream = 0; // Unpack the compressed buffer @@ -295,7 +210,7 @@ bool PNG::read(Common::SeekableReadStream *str) { * Taken from lodePNG, with a slight patch: * http://www.atalasoft.com/cs/blogs/stevehawley/archive/2010/02/23/libpng-you-re-doing-it-wrong.aspx */ -byte PNG::paethPredictor(int16 a, int16 b, int16 c) { +byte PNGDecoder::paethPredictor(int16 a, int16 b, int16 c) { int16 pa = ABS<int16>(b - c); int16 pb = ABS<int16>(a - c); int16 pc = ABS<int16>(a + b - c - c); @@ -315,7 +230,7 @@ byte PNG::paethPredictor(int16 a, int16 b, int16 c) { * * Taken from lodePNG */ -void PNG::unfilterScanLine(byte *dest, const byte *scanLine, const byte *prevLine, uint16 byteWidth, byte filterType, uint16 length) { +void PNGDecoder::unfilterScanLine(byte *dest, const byte *scanLine, const byte *prevLine, uint16 byteWidth, byte filterType, uint16 length) { uint16 i; switch (filterType) { @@ -370,33 +285,29 @@ void PNG::unfilterScanLine(byte *dest, const byte *scanLine, const byte *prevLin } -void PNG::constructImage() { +int PNGDecoder::getBytesPerPixel() const { + return (getNumColorChannels() * _header.bitDepth + 7) / 8; +} + +void PNGDecoder::constructImage() { assert (_header.bitDepth != 0); - byte *dest; - byte *scanLine; - byte *prevLine = 0; - byte filterType; + int bytesPerPixel = getBytesPerPixel(); + int pitch = bytesPerPixel * _header.width; + byte *unfilteredSurface = new byte[pitch * _header.height]; + byte *dest = unfilteredSurface; uint16 scanLineWidth = (_header.width * getNumColorChannels() * _header.bitDepth + 7) / 8; - - if (_unfilteredSurface) { - _unfilteredSurface->free(); - delete _unfilteredSurface; - } - _unfilteredSurface = new Graphics::Surface(); - // TODO/FIXME: It seems we can not properly determine the format here. But maybe there is a way... - _unfilteredSurface->create(_header.width, _header.height, PixelFormat((getNumColorChannels() * _header.bitDepth + 7) / 8, 0, 0, 0, 0, 0, 0, 0, 0)); - scanLine = new byte[_unfilteredSurface->pitch]; - dest = (byte *)_unfilteredSurface->getBasePtr(0, 0); + byte *scanLine = new byte[scanLineWidth]; + byte *prevLine = 0; switch(_header.interlaceType) { case kNonInterlaced: - for (uint16 y = 0; y < _unfilteredSurface->h; y++) { - filterType = _imageData->readByte(); + for (uint16 y = 0; y < _header.height; y++) { + byte filterType = _imageData->readByte(); _imageData->read(scanLine, scanLineWidth); - unfilterScanLine(dest, scanLine, prevLine, _unfilteredSurface->format.bytesPerPixel, filterType, scanLineWidth); + unfilterScanLine(dest, scanLine, prevLine, bytesPerPixel, filterType, scanLineWidth); prevLine = dest; - dest += _unfilteredSurface->pitch; + dest += pitch; } break; case kInterlaced: @@ -409,9 +320,123 @@ void PNG::constructImage() { } delete[] scanLine; + + constructOutput(unfilteredSurface); + delete[] unfilteredSurface; } -void PNG::readHeaderChunk() { +Graphics::PixelFormat PNGDecoder::findPixelFormat() const { + // Try to find the best pixel format based on what we have here + // Which is basically 8bpp for paletted non-transparent + // and 32bpp for everything else + + switch (_header.colorType) { + case kIndexed: + if (!_transparentColorSpecified) + return Graphics::PixelFormat::createFormatCLUT8(); + // fall through + case kGrayScale: + case kTrueColor: + case kGrayScaleWithAlpha: + case kTrueColorWithAlpha: + // We'll go with standard RGBA 32-bit + return Graphics::PixelFormat(4, 8, 8, 8, 8, 24, 16, 8, 0); + } + + error("Unknown PNG color type"); + return Graphics::PixelFormat(); +} + +void PNGDecoder::constructOutput(const byte *surface) { + _outputSurface = new Graphics::Surface(); + _outputSurface->create(_header.width, _header.height, findPixelFormat()); + + const byte *src = surface; + byte a = 0xFF; + int bytesPerPixel = getBytesPerPixel(); + + if (_header.colorType != kIndexed) { + if (_header.colorType == kTrueColor || + _header.colorType == kTrueColorWithAlpha) { + if (bytesPerPixel != 3 && bytesPerPixel != 4) + error("Unsupported truecolor PNG format"); + } else if (_header.colorType == kGrayScale || + _header.colorType == kGrayScaleWithAlpha) { + if (bytesPerPixel != 1 && bytesPerPixel != 2) + error("Unsupported grayscale PNG format"); + } + + for (uint16 i = 0; i < _outputSurface->h; i++) { + for (uint16 j = 0; j < _outputSurface->w; j++) { + uint32 result = 0; + + switch (bytesPerPixel) { + case 1: // Grayscale + if (_transparentColorSpecified) + a = (src[0] == _transparentColor[0]) ? 0 : 0xFF; + result = _outputSurface->format.ARGBToColor(a, src[0], src[0], src[0]); + break; + case 2: // Grayscale + alpha + result = _outputSurface->format.ARGBToColor(src[1], src[0], src[0], src[0]); + break; + case 3: // RGB + if (_transparentColorSpecified) { + bool isTransparentColor = (src[0] == _transparentColor[0] && + src[1] == _transparentColor[1] && + src[2] == _transparentColor[2]); + a = isTransparentColor ? 0 : 0xFF; + } + + result = _outputSurface->format.ARGBToColor(a, src[0], src[1], src[2]); + break; + case 4: // RGBA + result = _outputSurface->format.ARGBToColor(src[3], src[0], src[1], src[2]); + break; + } + + *((uint32 *)_outputSurface->getBasePtr(j, i)) = result; + src += bytesPerPixel; + } + } + } else { + uint32 mask = (0xff >> (8 - _header.bitDepth)) << (8 - _header.bitDepth); + + // Convert the indexed surface to the target pixel format + for (uint16 i = 0; i < _outputSurface->h; i++) { + int data = 0; + int bitCount = 8; + const byte *src1 = src; + + for (uint16 j = 0; j < _outputSurface->w; j++) { + if (bitCount == 8) { + data = *src; + src++; + } + + byte index = (data & mask) >> (8 - _header.bitDepth); + data = (data << _header.bitDepth) & 0xff; + bitCount -= _header.bitDepth; + + if (bitCount == 0) + bitCount = 8; + + if (_transparentColorSpecified) { + byte r = _palette[index * 3 + 0]; + byte g = _palette[index * 3 + 1]; + byte b = _palette[index * 3 + 2]; + a = _paletteTransparency[index]; + *((uint32 *)_outputSurface->getBasePtr(j, i)) = _outputSurface->format.ARGBToColor(a, r, g, b); + } else { + *((byte *)_outputSurface->getBasePtr(j, i)) = index; + } + } + + src = src1 + _outputSurface->w; + } + } +} + +void PNGDecoder::readHeaderChunk() { _header.width = _stream->readUint32BE(); _header.height = _stream->readUint32BE(); _header.bitDepth = _stream->readByte(); @@ -431,7 +456,7 @@ void PNG::readHeaderChunk() { _header.interlaceType = (PNGInterlaceType)_stream->readByte(); } -byte PNG::getNumColorChannels() { +byte PNGDecoder::getNumColorChannels() const { switch (_header.colorType) { case kGrayScale: return 1; // Gray @@ -448,16 +473,7 @@ byte PNG::getNumColorChannels() { } } -void PNG::readPaletteChunk() { - for (uint16 i = 0; i < _paletteEntries; i++) { - _palette[i * 4 + 0] = _stream->readByte(); // R - _palette[i * 4 + 1] = _stream->readByte(); // G - _palette[i * 4 + 2] = _stream->readByte(); // B - _palette[i * 4 + 3] = 0xFF; // Alpha, set in the tRNS chunk - } -} - -void PNG::readTransparencyChunk(uint32 chunkLength) { +void PNGDecoder::readTransparencyChunk(uint32 chunkLength) { _transparentColorSpecified = true; switch(_header.colorType) { @@ -472,8 +488,8 @@ void PNG::readTransparencyChunk(uint32 chunkLength) { _transparentColor[2] = _stream->readUint16BE(); break; case kIndexed: - for (uint32 i = 0; i < chunkLength; i++) - _palette[i * 4 + 3] = _stream->readByte(); + _stream->read(_paletteTransparency, chunkLength); + // A transparency chunk may have less entries // than the palette entries. The remaining ones // are unmodified (set to 255). Check here: diff --git a/graphics/png.h b/graphics/decoders/png.h index 25f9c1e7bc..1da0bea1ab 100644 --- a/graphics/png.h +++ b/graphics/decoders/png.h @@ -23,7 +23,6 @@ /* * PNG decoder used in engines: * - sword25 - * - ScummVM GUI * Dependencies: * - zlib */ @@ -54,6 +53,7 @@ #include "common/scummsys.h" #include "common/textconsole.h" +#include "graphics/decoders/image_decoder.h" namespace Common { class SeekableReadStream; @@ -62,82 +62,44 @@ class SeekableReadStream; namespace Graphics { struct Surface; - -enum PNGColorType { - kGrayScale = 0, // bit depths: 1, 2, 4, 8, 16 - kTrueColor = 2, // bit depths: 8, 16 - kIndexed = 3, // bit depths: 1, 2, 4, 8 - kGrayScaleWithAlpha = 4, // bit depths: 8, 16 - kTrueColorWithAlpha = 6 // bit depths: 8, 16 -}; - -enum PNGInterlaceType { - kNonInterlaced = 0, - kInterlaced = 1 -}; - -struct PNGHeader { - uint32 width; - uint32 height; - byte bitDepth; - PNGColorType colorType; - byte compressionMethod; - byte filterMethod; - PNGInterlaceType interlaceType; -}; - struct PixelFormat; -class PNG { +class PNGDecoder : public ImageDecoder { public: - PNG(); - ~PNG(); - - /** - * Reads a PNG image from the specified stream - */ - bool read(Common::SeekableReadStream *str); - - /** - * Returns the information obtained from the PNG header. - */ - PNGHeader getHeader() const { return _header; } - - /** - * Returns the PNG image, formatted for the specified pixel format. - */ - Graphics::Surface *getSurface(const PixelFormat &format); - - /** - * Returns the indexed PNG8 image. Used for PNGs with an indexed 256 color - * palette, when they're shown on an 8-bit color screen, as no translation - * is taking place. - */ - Graphics::Surface *getIndexedSurface() { - if (_header.colorType != kIndexed) - error("Indexed surface requested for a non-indexed PNG"); - return _unfilteredSurface; - } - - /** - * Returns the palette of the specified PNG8 image, given a pointer to - * an RGBA palette array (4 x 256). - */ - void getPalette(byte *palette, uint16 &entries) { - if (_header.colorType != kIndexed) - error("Palette requested for a non-indexed PNG"); - for (int i = 0; i < 256; i++) { - palette[0 + i * 4] = _palette[0 + i * 4]; // R - palette[1 + i * 4] = _palette[1 + i * 4]; // G - palette[2 + i * 4] = _palette[2 + i * 4]; // B - palette[3 + i * 4] = _palette[3 + i * 4]; // A - } - entries = _paletteEntries; - } + PNGDecoder(); + ~PNGDecoder(); + + bool loadStream(Common::SeekableReadStream &stream); + void destroy(); + const Graphics::Surface *getSurface() const { return _outputSurface; } + const byte *getPalette() const { return _palette; } private: + enum PNGColorType { + kGrayScale = 0, // bit depths: 1, 2, 4, 8, 16 + kTrueColor = 2, // bit depths: 8, 16 + kIndexed = 3, // bit depths: 1, 2, 4, 8 + kGrayScaleWithAlpha = 4, // bit depths: 8, 16 + kTrueColorWithAlpha = 6 // bit depths: 8, 16 + }; + + enum PNGInterlaceType { + kNonInterlaced = 0, + kInterlaced = 1 + }; + + struct PNGHeader { + uint32 width; + uint32 height; + byte bitDepth; + PNGColorType colorType; + byte compressionMethod; + byte filterMethod; + PNGInterlaceType interlaceType; + }; + void readHeaderChunk(); - byte getNumColorChannels(); + byte getNumColorChannels() const; void readPaletteChunk(); void readTransparencyChunk(uint32 chunkLength); @@ -153,7 +115,8 @@ private: PNGHeader _header; - byte _palette[256 * 4]; // RGBA + byte _palette[256 * 3]; // RGB + byte _paletteTransparency[256]; uint16 _paletteEntries; uint16 _transparentColor[3]; bool _transparentColorSpecified; @@ -161,9 +124,12 @@ private: byte *_compressedBuffer; uint32 _compressedBufferSize; - Graphics::Surface *_unfilteredSurface; + Graphics::Surface *_outputSurface; + Graphics::PixelFormat findPixelFormat() const; + int getBytesPerPixel() const; + void constructOutput(const byte *surface); }; -} // End of Graphics namespace +} // End of namespace Graphics #endif // GRAPHICS_PNG_H 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..7505f7913e --- /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 = _face->glyph->bitmap_left; + int xMax = glyph.xOffset + ftCeil26_6(metrics.width); + glyph.yOffset = _ascent - _face->glyph->bitmap_top; + + glyph.advance = ftCeil26_6(_face->glyph->advance.x); + + // 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 deleted file mode 100644 index eb595a750e..0000000000 --- a/graphics/imagedec.cpp +++ /dev/null @@ -1,176 +0,0 @@ -/* 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. - */ - -#include "graphics/imagedec.h" -#include "graphics/pixelformat.h" -#include "graphics/surface.h" - -#include "common/file.h" - -namespace Graphics { -// -// BMP Decoder -// -class BMPDecoder : public ImageDecoder { -public: - BMPDecoder() {} - virtual ~BMPDecoder() {} - - bool decodeable(Common::SeekableReadStream &stream); - Surface *decodeImage(Common::SeekableReadStream &stream, const PixelFormat &format); - - struct BitmapHeader { - uint16 type; - uint32 size; - uint16 res1; - uint16 res2; - uint32 imageOffset; - }; - - struct InfoHeader { - uint32 size; - uint32 width; - uint32 height; - uint16 planes; - uint16 bitsPerPixel; - uint32 compression; - uint32 imageSize; - uint32 pixelsPerMeterX; - uint32 pixelsPerMeterY; - uint32 colorsUsed; - uint32 colorsImportant; - }; -}; - -bool BMPDecoder::decodeable(Common::SeekableReadStream &stream) { - BitmapHeader header; - stream.seek(0); - header.type = stream.readUint16BE(); - header.size = stream.readUint32LE(); - - // TODO: maybe improve this detection - if (header.size == 0 || header.type != 'BM') - return false; - - return true; -} - -Surface *BMPDecoder::decodeImage(Common::SeekableReadStream &stream, const PixelFormat &format) { - if (!decodeable(stream)) { - return 0; - } - - BitmapHeader header; - InfoHeader info; - - stream.seek(0); - header.type = stream.readUint16BE(); - header.size = stream.readUint32LE(); - header.res1 = stream.readUint16LE(); - header.res2 = stream.readUint16LE(); - header.imageOffset = stream.readUint32LE(); - - if (header.size == 0 || header.type != 'BM') { - stream.seek(0); - return 0; - } - - info.size = stream.readUint32LE(); - info.width = stream.readUint32LE(); - info.height = stream.readUint32LE(); - info.planes = stream.readUint16LE(); - info.bitsPerPixel = stream.readUint16LE(); - info.compression = stream.readUint32LE(); - info.imageSize = stream.readUint32LE(); - info.pixelsPerMeterX = stream.readUint32LE(); - info.pixelsPerMeterY = stream.readUint32LE(); - info.colorsUsed = stream.readUint32LE(); - info.colorsImportant = stream.readUint32LE(); - - stream.seek(header.imageOffset); - - if (info.bitsPerPixel != 24) { - stream.seek(0); - return 0; - } - - uint8 r = 0, g = 0, b = 0; - Surface *newSurf = new Surface; - assert(newSurf); - newSurf->create(info.width, info.height, format); - assert(newSurf->pixels); - 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) { - b = stream.readByte(); - g = stream.readByte(); - r = stream.readByte(); - *curPixel = format.RGBToColor(r, g, b); - ++curPixel; - } - stream.seek(pitchAdd, SEEK_CUR); - curPixel -= newSurf->w*2; - } - - stream.seek(0); - return newSurf; -} - -#pragma mark - - -Surface *ImageDecoder::loadFile(const Common::String &name, const PixelFormat &format) { - Surface *newSurf = 0; - - Common::File imageFile; - if (imageFile.open(name)) { - newSurf = loadFile(imageFile, format); - } - - return newSurf; -} - -Surface *ImageDecoder::loadFile(Common::SeekableReadStream &stream, const PixelFormat &format) { - // TODO: implement support for bzipped memory - - // FIXME: this is not a very nice solution but it should work - // for the moment, we should use a different way to get all - // decoders - static BMPDecoder bmpDecoder; - static ImageDecoder *decoderList[] = { - &bmpDecoder, // for uncompressed .BMP files - 0 - }; - - ImageDecoder *decoder = 0; - for (int i = 0; decoderList[i] != 0; ++i) { - if (decoderList[i]->decodeable(stream)) { - decoder = decoderList[i]; - break; - } - } - - if (!decoder) - return 0; - - return decoder->decodeImage(stream, format); -} -} // End of namespace Graphics diff --git a/graphics/module.mk b/graphics/module.mk index 02c88d98ba..281f904b38 100644 --- a/graphics/module.mk +++ b/graphics/module.mk @@ -9,13 +9,10 @@ MODULE_OBJS := \ fonts/consolefont.o \ fonts/newfont_big.o \ fonts/newfont.o \ + fonts/ttf.o \ fonts/winfont.o \ iff.o \ - imagedec.o \ - jpeg.o \ maccursor.o \ - pict.o \ - png.o \ primitives.o \ scaler.o \ scaler/thumbnail_intern.o \ @@ -25,7 +22,11 @@ MODULE_OBJS := \ VectorRenderer.o \ VectorRendererSpec.o \ wincursor.o \ - yuv_to_rgb.o + yuv_to_rgb.o \ + decoders/bmp.o \ + decoders/jpeg.o \ + decoders/pict.o \ + decoders/png.o ifdef USE_SCALERS MODULE_OBJS += \ 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 d5e2692338..a96950d2c6 100644 --- a/graphics/surface.cpp +++ b/graphics/surface.cpp @@ -20,6 +20,7 @@ */ #include "common/algorithm.h" +#include "common/endian.h" #include "common/util.h" #include "common/rect.h" #include "common/textconsole.h" @@ -281,4 +282,82 @@ void Surface::move(int dx, int dy, int height) { } } +Graphics::Surface *Surface::convertTo(const PixelFormat &dstFormat, const byte *palette) const { + assert(pixels); + + Graphics::Surface *surface = new Graphics::Surface(); + + // If the target format is the same, just copy + if (format == dstFormat) { + surface->copyFrom(*this); + return surface; + } + + if (format.bytesPerPixel == 0 || format.bytesPerPixel > 4) + error("Surface::convertTo(): Can only convert from 1Bpp, 2Bpp, 3Bpp, and 4Bpp"); + + if (dstFormat.bytesPerPixel != 2 && dstFormat.bytesPerPixel != 4) + error("Surface::convertTo(): Can only convert to 2Bpp and 4Bpp"); + + surface->create(w, h, dstFormat); + + if (format.bytesPerPixel == 1) { + // Converting from paletted to high color + assert(palette); + + for (int y = 0; y < h; y++) { + const byte *srcRow = (byte *)getBasePtr(0, y); + byte *dstRow = (byte *)surface->getBasePtr(0, y); + + for (int x = 0; x < w; x++) { + byte index = *srcRow++; + byte r = palette[index * 3]; + byte g = palette[index * 3 + 1]; + byte b = palette[index * 3 + 2]; + + uint32 color = dstFormat.RGBToColor(r, g, b); + + if (dstFormat.bytesPerPixel == 2) + *((uint16 *)dstRow) = color; + else + *((uint32 *)dstRow) = color; + + dstRow += dstFormat.bytesPerPixel; + } + } + } else { + // Converting from high color to high color + for (int y = 0; y < h; y++) { + const byte *srcRow = (byte *)getBasePtr(0, y); + byte *dstRow = (byte *)surface->getBasePtr(0, y); + + for (int x = 0; x < w; x++) { + uint32 srcColor; + if (format.bytesPerPixel == 2) + srcColor = READ_UINT16(srcRow); + else if (format.bytesPerPixel == 3) + srcColor = READ_UINT24(srcRow); + else + srcColor = READ_UINT32(srcRow); + + srcRow += format.bytesPerPixel; + + // Convert that color to the new format + byte r, g, b, a; + format.colorToARGB(srcColor, a, r, g, b); + uint32 color = dstFormat.ARGBToColor(a, r, g, b); + + if (dstFormat.bytesPerPixel == 2) + *((uint16 *)dstRow) = color; + else + *((uint32 *)dstRow) = color; + + dstRow += dstFormat.bytesPerPixel; + } + } + } + + return surface; +} + } // End of namespace Graphics diff --git a/graphics/surface.h b/graphics/surface.h index 9d91a601e4..9c8c040cbf 100644 --- a/graphics/surface.h +++ b/graphics/surface.h @@ -135,6 +135,17 @@ struct Surface { void copyFrom(const Surface &surf); /** + * Convert the data to another pixel format. + * + * The calling code must call free on the returned surface and then delete + * it. + * + * @param dstFormat The desired format + * @param palette The palette (in RGB888), if the source format has a Bpp of 1 + */ + Graphics::Surface *convertTo(const PixelFormat &dstFormat, const byte *palette = 0) const; + + /** * Draw a line. * * @param x0 The x coordinate of the start point. diff --git a/graphics/yuv_to_rgb.cpp b/graphics/yuv_to_rgb.cpp index feda48bf6d..ac7f217fee 100644 --- a/graphics/yuv_to_rgb.cpp +++ b/graphics/yuv_to_rgb.cpp @@ -199,6 +199,52 @@ namespace Graphics { *((PixelInt *)(d)) = (L[cr_r] | L[crb_g] | L[cb_b]) template<typename PixelInt> +void convertYUV444ToRGB(byte *dstPtr, int dstPitch, const YUVToRGBLookup *lookup, const byte *ySrc, const byte *uSrc, const byte *vSrc, int yWidth, int yHeight, int yPitch, int uvPitch) { + // Keep the tables in pointers here to avoid a dereference on each pixel + const int16 *Cr_r_tab = lookup->_colorTab; + const int16 *Cr_g_tab = Cr_r_tab + 256; + const int16 *Cb_g_tab = Cr_g_tab + 256; + const int16 *Cb_b_tab = Cb_g_tab + 256; + const uint32 *rgbToPix = lookup->_rgbToPix; + + for (int h = 0; h < yHeight; h++) { + for (int w = 0; w < yWidth; w++) { + register const uint32 *L; + + int16 cr_r = Cr_r_tab[*vSrc]; + int16 crb_g = Cr_g_tab[*vSrc] + Cb_g_tab[*uSrc]; + int16 cb_b = Cb_b_tab[*uSrc]; + ++uSrc; + ++vSrc; + + PUT_PIXEL(*ySrc, dstPtr); + ySrc++; + dstPtr += sizeof(PixelInt); + } + + dstPtr += dstPitch - yWidth * sizeof(PixelInt); + ySrc += yPitch - yWidth; + uSrc += uvPitch - yWidth; + vSrc += uvPitch - yWidth; + } +} + +void convertYUV444ToRGB(Graphics::Surface *dst, const byte *ySrc, const byte *uSrc, const byte *vSrc, int yWidth, int yHeight, int yPitch, int uvPitch) { + // Sanity checks + assert(dst && dst->pixels); + assert(dst->format.bytesPerPixel == 2 || dst->format.bytesPerPixel == 4); + assert(ySrc && uSrc && vSrc); + + const YUVToRGBLookup *lookup = YUVToRGBMan.getLookup(dst->format); + + // Use a templated function to avoid an if check on every pixel + if (dst->format.bytesPerPixel == 2) + convertYUV444ToRGB<uint16>((byte *)dst->pixels, dst->pitch, lookup, ySrc, uSrc, vSrc, yWidth, yHeight, yPitch, uvPitch); + else + convertYUV444ToRGB<uint32>((byte *)dst->pixels, dst->pitch, lookup, ySrc, uSrc, vSrc, yWidth, yHeight, yPitch, uvPitch); +} + +template<typename PixelInt> void convertYUV420ToRGB(byte *dstPtr, int dstPitch, const YUVToRGBLookup *lookup, const byte *ySrc, const byte *uSrc, const byte *vSrc, int yWidth, int yHeight, int yPitch, int uvPitch) { int halfHeight = yHeight >> 1; int halfWidth = yWidth >> 1; diff --git a/graphics/yuv_to_rgb.h b/graphics/yuv_to_rgb.h index 259ba09810..8e025042dc 100644 --- a/graphics/yuv_to_rgb.h +++ b/graphics/yuv_to_rgb.h @@ -23,6 +23,7 @@ /** * @file * YUV to RGB conversion used in engines: + * - mohawk * - scumm (he) * - sword25 */ @@ -36,6 +37,20 @@ namespace Graphics { /** + * Convert a YUV444 image to an RGB surface + * + * @param dst the destination surface + * @param ySrc the source of the y component + * @param uSrc the source of the u component + * @param vSrc the source of the v component + * @param yWidth the width of the y surface + * @param yHeight the height of the y surface + * @param yPitch the pitch of the y surface + * @param uvPitch the pitch of the u and v surfaces + */ +void convertYUV444ToRGB(Graphics::Surface *dst, const byte *ySrc, const byte *uSrc, const byte *vSrc, int yWidth, int yHeight, int yPitch, int uvPitch); + +/** * Convert a YUV420 image to an RGB surface * * @param dst the destination surface |