bertos/gfx/text.c

   1 /**
   2  * \file
   3  * <!--
   4  * This file is part of BeRTOS.
   5  *
   6  * Bertos is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  * As a special exception, you may use this file as part of a free software
  21  * library without restriction.  Specifically, if other files instantiate
  22  * templates or use macros or inline functions from this file, or you compile
  23  * this file and link it with other files to produce an executable, this
  24  * file does not by itself cause the resulting executable to be covered by
  25  * the GNU General Public License.  This exception does not however
  26  * invalidate any other reasons why the executable file might be covered by
  27  * the GNU General Public License.
  28  *
  29  * Copyright 2003, 2004, 2005 Develer S.r.l. (http://www.develer.com/)
  30  * Copyright 1999 Bernie Innocenti <bernie@codewiz.org>
  31  *
  32  * -->
  33  *
  34  * \version $Id$
  35  * \author Bernie Innocenti <bernie@codewiz.org>
  36  * \author Stefano Fedrigo <aleph@develer.com>
  37  *
  38  * \brief Text graphic routines
  39  */
  40
  41 #include <gfx/gfx.h>
  42 #include <gfx/font.h>
  43 #include <gfx/text.h>
  44 #include <gfx/text.h>
  45
  46 #include <gfx/gfx_p.h> // FIXME: BM_DRAWPIXEL
  47
  48 #include <cfg/debug.h>
  49
  50
  51 /**
  52  * ANSI escape sequences flag: true for ESC state on.
  53  *
  54  * \todo Move to Bitmap.flags.
  55  */
  56 static bool ansi_mode = false;
  57
  58 /**
  59  * Move (imaginary) cursor to coordinates specified.
  60  */
  61 void text_setCoord(struct Bitmap *bm, int x, int y)
  62 {
  63         bm->penX = x;
  64         bm->penY = y;
  65 }
  66
  67
  68 /**
  69  * Move (imaginary) cursor to column and row specified.
  70  * Next text write will start a that row and col.
  71  */
  72 void text_moveTo(struct Bitmap *bm, int row, int col)
  73 {
  74         ASSERT(col >= 0);
  75         ASSERT(col < bm->width / bm->font->width);
  76         ASSERT(row >= 0);
  77         ASSERT(row < bm->height / bm->font->height);
  78
  79         text_setCoord(bm, col * bm->font->width, row * bm->font->height);
  80 }
  81
  82
  83 /**
  84  * Render char \a c on Bitmap \a bm.
  85  */
  86 static int text_putglyph(char c, struct Bitmap *bm)
  87 {
  88         const uint8_t * PROGMEM glyph;  /* font is in progmem */
  89         uint8_t glyph_width, glyph_height, glyph_height_bytes;
  90         unsigned char index = (unsigned char)c;
  91
  92         /* Check for out of range char and replace with '?' or first char in font. */
  93         if (UNLIKELY(!FONT_HAS_GLYPH(bm->font, index)))
  94         {
  95                 kprintf("Illegal char '%c' (0x%02x)\n", index, index);
  96                 if (FONT_HAS_GLYPH(bm->font, '?'))
  97                         index = '?';
  98                 else
  99                         index = bm->font->first;
 100         }
 101
 102         /* Make character relative to font start */
 103         index -= bm->font->first;
 104
 105         glyph_height = bm->font->height;
 106         // FIXME: for vertical fonts only
 107         glyph_height_bytes = (glyph_height + 7) / 8;
 108
 109         if (bm->font->offset)
 110         {
 111                 /* Proportional font */
 112                 glyph_width = bm->font->widths[index]; /* TODO: optimize away */
 113                 glyph = bm->font->glyph + bm->font->offset[index];
 114         }
 115         else
 116         {
 117                 /*
 118                  * Fixed-width font: compute the first column of pixels
 119                  * of the selected glyph using the character code to index
 120                  * the glyph array.
 121                  */
 122                 glyph_width = bm->font->width;
 123
 124                 //For horizontal fonts
 125                 //glyph = bm->font->glyph + index * (((glyph_width + 7) / 8) * glyph_height);
 126                 glyph = bm->font->glyph + index * glyph_height_bytes * glyph_width;
 127         }
 128
 129         /* Slow path for styled glyphs */
 130         if (UNLIKELY(bm->styles))
 131         {
 132                 uint8_t styles = bm->styles;
 133                 uint8_t prev_dots = 0, italic_prev_dots = 0;
 134                 uint8_t dots;
 135                 uint8_t row, col, row_bit;
 136
 137                 /*
 138                  * To avoid repeating clipping and other expensive computations,
 139                  * we cluster calls to gfx_blitRaster() using a small buffer.
 140                  */
 141                 #define CONFIG_TEXT_RENDER_OPTIMIZE 1
 142                 #if CONFIG_TEXT_RENDER_OPTIMIZE
 143                         #define RENDER_BUF_WIDTH 12
 144                         #define RENDER_BUF_HEIGHT 8
 145                         uint8_t render_buf[RAST_SIZE(RENDER_BUF_WIDTH, RENDER_BUF_HEIGHT)];
 146                         uint8_t render_xpos = 0;
 147                 #endif
 148
 149                 /* This style alone could be handled by the fast path too */
 150                 if (bm->styles & STYLEF_CONDENSED)
 151                         --glyph_width;
 152
 153                 if (bm->styles & STYLEF_EXPANDED)
 154                         glyph_width *= 2;
 155
 156                 for (row = 0, row_bit = 0; row < glyph_height_bytes; ++row, row_bit += 8)
 157                 {
 158                         /* For each dot column in the glyph... */
 159                         for (col = 0; col < glyph_width; ++col)
 160                         {
 161                                 uint8_t src_col = col;
 162
 163                                 /* Expanded style: advances only once every two columns. */
 164                                 if (styles & STYLEF_EXPANDED)
 165                                         src_col /= 2;
 166
 167                                 /* Fetch a column of dots from glyph. */
 168                                 dots = PGM_READ_CHAR(RAST_ADDR(glyph, src_col, row_bit, glyph_width));
 169
 170                                 /* Italic: get lower 4 dots from previous column */
 171                                 if (styles & STYLEF_ITALIC)
 172                                 {
 173                                         uint8_t new_dots = dots;
 174                                         dots = (dots & 0xF0) | italic_prev_dots;
 175                                         italic_prev_dots = new_dots & 0x0F;
 176                                 }
 177
 178                                 /* Bold: "or" pixels with the previous column */
 179                                 if (styles & STYLEF_BOLD)
 180                                 {
 181                                         uint8_t new_dots = dots;
 182                                         dots |= prev_dots;
 183                                         prev_dots = new_dots;
 184                                 }
 185
 186                                 /* Underlined: turn on base pixel */
 187                                 if ((styles & STYLEF_UNDERLINE)
 188                                         && (row == glyph_height_bytes - 1))
 189                                         dots |= (1 << (glyph_height - row_bit - 1));
 190
 191                                 /* Inverted: invert pixels */
 192                                 if (styles & STYLEF_INVERT)
 193                                         dots = ~dots;
 194
 195                                 /* Output dots */
 196                                 #if CONFIG_TEXT_RENDER_OPTIMIZE
 197                                         render_buf[render_xpos++] = dots;
 198                                         if (render_xpos == RENDER_BUF_WIDTH)
 199                                         {
 200                                                 gfx_blitRaster(bm, bm->penX + col - render_xpos + 1, bm->penY + row_bit,
 201                                                         render_buf, render_xpos,
 202                                                         MIN((uint8_t)RENDER_BUF_HEIGHT, (uint8_t)(glyph_height - row_bit)),
 203                                                         RENDER_BUF_WIDTH);
 204                                                 render_xpos = 0;
 205                                         }
 206                                 #else
 207                                         gfx_blitRaster(bm, bm->penX + col, bm->penY + row_bit,
 208                                                 &dots, 1, MIN((uint8_t)8, glyph_height - row_bit), 1);
 209                                 #endif
 210                         }
 211
 212                         #if CONFIG_TEXT_RENDER_OPTIMIZE
 213                                 /* Flush out rest of render buffer */
 214                                 if (render_xpos != 0)
 215                                 {
 216                                         gfx_blitRaster(bm, bm->penX + col - render_xpos, bm->penY + row_bit,
 217                                                 render_buf, render_xpos,
 218                                                 MIN((uint8_t)RENDER_BUF_HEIGHT, (uint8_t)(glyph_height - row_bit)),
 219                                                 RENDER_BUF_WIDTH);
 220                                         render_xpos = 0;
 221                                 }
 222                         #endif
 223                 }
 224         }
 225         else
 226         {
 227                 /* No style: fast vanilla copy of glyph to bitmap */
 228                 gfx_blitRaster(bm, bm->penX, bm->penY, glyph, glyph_width, glyph_height, glyph_width);
 229         }
 230
 231         /* Update current pen position */
 232         bm->penX += glyph_width;
 233
 234         return c;
 235 }
 236
 237
 238 /**
 239  * Render char \c c, with (currently) limited ANSI escapes
 240  * emulation support and '\n' for newline.
 241  */
 242 int text_putchar(char c, struct Bitmap *bm)
 243 {
 244         /* Handle ANSI escape sequences */
 245         if (UNLIKELY(ansi_mode))
 246         {
 247                 switch (c)
 248                 {
 249                 case ANSI_ESC_CLEARSCREEN:
 250                         gfx_bitmapClear(bm);
 251                         bm->penX = 0;
 252                         bm->penY = 0;
 253                         text_style(bm, 0, STYLEF_MASK);
 254                         break;
 255                 DB(default:
 256                         kprintf("Unknown ANSI esc code: %x\n", c);)
 257                 }
 258                 ansi_mode = false;
 259         }
 260         else if (c == '\033')  /* Enter ANSI ESC mode */
 261         {
 262                 ansi_mode = true;
 263         }
 264         else if (c == '\n')  /* Go one line down on a line-feed */
 265         {
 266                 if (bm->penY + bm->font->height < bm->height)
 267                 {
 268                         bm->penY += bm->font->height;
 269                         bm->penX = 0;
 270                 }
 271         }
 272         else
 273         {
 274                 text_putglyph(c, bm);
 275         }
 276         return c;
 277 }
 278
 279
 280 /**
 281  * Clear the screen and reset cursor position
 282  */
 283 void text_clear(struct Bitmap *bmp)
 284 {
 285         text_putchar('\x1b', bmp);
 286         text_putchar('c', bmp);
 287 }
 288
 289
 290 void text_clearLine(struct Bitmap *bm, int line)
 291 {
 292         gfx_rectClear(bm, 0, line * bm->font->height, bm->width, (line + 1) * bm->font->height);
 293 }
 294
 295
 296 /**
 297  * Set/clear algorithmic font style bits.
 298  *
 299  * \param bm     Pointer to Bitmap to affect.
 300  * \param flags  Style flags to set
 301  * \param mask   Mask of flags to modify
 302  * \return       Old style flags
 303  *
 304  * Examples:
 305  * Turn on bold, leave other styles alone
 306  *   \code text_style(bm, STYLEF_BOLD, STYLEF_BOLD); \endcode
 307  *
 308  * Turn off bold and turn on italic, leave others as they are
 309  *   \code text_style(bm, STYLEF_ITALIC, STYLEF_BOLD | STYLEF_ITALIC); \endcode
 310  *
 311  * Query current style without chaning it
 312  *   \code style = text_style(bm, 0, 0); \endcode
 313  *
 314  * Reset all styles (plain text)
 315  *   \code text_style(bm, 0, STYLE_MASK); \endcode
 316  */
 317 uint8_t text_style(struct Bitmap *bm, uint8_t flags, uint8_t mask)
 318 {
 319         uint8_t old = bm->styles;
 320         bm->styles = (bm->styles & ~mask) | flags;
 321         return old;
 322 }