Add missing header.
[bertos.git] / mware / text.c
1 /*!
2  * \file
3  * <!--
4  * Copyright 1999 Bernardo Innocenti <bernie@develer.com>
5  * Copyright 2003,2004 Develer S.r.l. (http://www.develer.com/)
6  * This file is part of DevLib - See devlib/README for information.
7  * -->
8  *
9  * \version $Id$
10  *
11  * \author Bernardo Innocenti <bernie@develer.com>
12  * \author Stefano Fedrigo <aleph@develer.com>
13  *
14  * \brief Text graphic routines
15  */
16
17 /*
18  * $Log$
19  * Revision 1.2  2004/06/03 11:27:09  bernie
20  * Add dual-license information.
21  *
22  * Revision 1.1  2004/05/23 15:43:16  bernie
23  * Import mware modules.
24  *
25  * Revision 1.17  2004/05/15 16:57:01  aleph
26  * Fixes for non-DEBUG build
27  *
28  * Revision 1.16  2004/04/03 20:42:49  aleph
29  * Add text_clear()
30  *
31  * Revision 1.15  2004/03/24 15:03:45  bernie
32  * Use explicit include paths; clean Doxygen comments
33  *
34  * Revision 1.14  2004/03/19 16:52:28  bernie
35  * Move printf() like functions from text.c to text_format.c and add PROGMEM versions.
36  *
37  * Revision 1.13  2004/03/17 18:23:32  bernie
38  * Oops.
39  *
40  * Revision 1.12  2004/03/17 18:03:22  bernie
41  * Make diagnostic message shorter
42  *
43  * Revision 1.11  2004/03/13 22:52:54  aleph
44  * documentation fixes
45  */
46
47 #include "gfx.h"
48 #include "font.h"
49 #include "text.h"
50 #include <drv/kdebug.h>
51
52 /*!
53  * Flags degli stili algoritmici
54  * La routine di rendering del testo e' in grado di applicare
55  * delle semplici trasformazioni al font interno per generare
56  * automaticamente degli stili predefiniti (bold, italic,
57  * underline) a partire dal set di caratteri plain.
58  */
59 static uint8_t text_styles;
60
61 /*! ANSI escape sequences flag: true for ESC state on */
62 static bool ansi_mode = false;
63
64
65 /*!
66  * Move (imaginary) cursor to column and row specified.
67  * Next text write will start a that row and col.
68  */
69 void text_moveto(struct Bitmap *bm, int row, int col)
70 {
71         ASSERT(col >= 0);
72         ASSERT(col < bm->width / FONT_WIDTH);
73         ASSERT(row >= 0);
74         ASSERT(row < bm->height / FONT_HEIGHT);
75
76         bm->penX = col * FONT_WIDTH;
77         bm->penY = row * FONT_HEIGHT;
78 }
79
80
81 /*!
82  * Move (imaginary) cursor to coordinates specified.
83  */
84 void text_setcoord(struct Bitmap *bm, int x, int y)
85 {
86         bm->penX = x;
87         bm->penY = y;
88 }
89
90
91 /*!
92  * Render char <code>c</code>
93  */
94 static int text_putglyph(char c, struct Bitmap *bm)
95 {
96         const uint8_t * PROGMEM glyph;  /* font is in progmem */
97         uint8_t glyph_width;
98         uint8_t i;
99         uint8_t *buf;
100
101         /*
102          * Il carattere da stampare viene usato come indice per prelevare
103          * la prima colonna di dots del glyph all'interno del font.
104          */
105         glyph = font + (((unsigned char)c) * FONT_WIDTH);
106         glyph_width = FONT_WIDTH;
107
108         if (text_styles & STYLEF_CONDENSED)
109                 --glyph_width;
110
111         if (text_styles & STYLEF_EXPANDED)
112                 glyph_width *= 2;
113
114         /* The y coord is rounded at multiples of 8 for simplicity */
115         bm->penY &= ~((coord_t)7);
116
117         /* Check if glyph to write fits in the bitmap */
118         if ((bm->penX < 0) || (bm->penX + glyph_width > bm->width) ||
119                 (bm->penY < 0) || (bm->penY + FONT_HEIGHT > bm->height))
120         {
121                 DB(kprintf("bad coords x=%d y=%d\n", bm->penX, bm->penY);)
122                 return 0;
123         }
124
125         /* Locate position where to write in the raster */
126         buf = bm->raster + bm->penY / 8 * bm->width + bm->penX;
127
128         bm->penX += glyph_width;
129
130         /* If some styles are set */
131         if (text_styles)
132         {
133                 uint8_t prev_dots = 0, italic_prev_dots = 0, new_dots;
134                 uint8_t dots;
135
136                 /* Per ogni colonna di dot del glyph... */
137                 for (i = 0; i < glyph_width; ++i)
138                 {
139                         dots = pgm_read_byte(glyph);
140
141                         /* Advance to next column in glyph.
142                          * Expand: advances only once every two columns
143                          */
144                         if (!(text_styles & STYLEF_EXPANDED) || (i & 1))
145                                 glyph++;
146
147                         /* Italic: get lower 4 dots from previous column */
148                         if (text_styles & STYLEF_ITALIC)
149                         {
150                                 new_dots = dots;
151                                 dots = (dots & 0xF0) | italic_prev_dots;
152                                 italic_prev_dots = new_dots & 0x0F;
153                         }
154
155                         /* Bold: "or" pixels with the previous column */
156                         if (text_styles & STYLEF_BOLD)
157                         {
158                                 new_dots = dots;
159                                 dots |= prev_dots;
160                                 prev_dots = new_dots;
161                         }
162
163                         /* Underlined: turn on base pixel */
164                         if (text_styles & STYLEF_UNDERLINE)
165                                 dots |= 0x80;
166
167                         /* Inverted: invert pixels */
168                         if (text_styles & STYLEF_INVERT)
169                                 dots = ~dots;
170
171                         /* Output dots */
172                         *buf++ = dots;
173                 }
174         }
175         else /* No style: fast vanilla copy of glyph to line buffer */
176                 while (glyph_width--)
177                         *buf++ = pgm_read_byte(glyph++);
178
179         return c;
180 }
181
182
183 /*!
184  * Render char \c c, with (currently) limited ANSI escapes
185  * emulation support and '\n' for newline.
186  */
187 int text_putchar(char c, struct Bitmap *bm)
188 {
189         /* Handle ANSI escape sequences */
190         if (ansi_mode)
191         {
192                 switch (c)
193                 {
194                         case ANSI_ESC_CLEARSCREEN:
195                                 gfx_ClearBitmap(bm);
196                                 bm->penX = 0;
197                                 bm->penY = 0;
198                                 text_style(0, STYLEF_MASK);
199                                 break;
200                         DB(default:
201                                 kprintf("Unknown ANSI esc code: %x\n", c);)
202                 }
203                 ansi_mode = false;
204         }
205         else if (c == '\033')  /* Enter ANSI ESC mode */
206         {
207                 ansi_mode = true;
208         }
209         else if (c == '\n')  /* Go one line down on a line-feed */
210         {
211                 if (bm->penY + FONT_HEIGHT < bm->height)
212                 {
213                         bm->penY += FONT_HEIGHT;
214                         bm->penX = 0;
215                 }
216         }
217         else
218         {
219                 text_putglyph(c, bm);
220         }
221         return c;
222 }
223
224
225 /*!
226  * Clear the screen and reset cursor position
227  */
228 void text_clear(struct Bitmap *bmp)
229 {
230         text_putchar('\x1b', bmp);
231         text_putchar('c', bmp);
232 }
233
234
235 /*!
236  * Set/clear algorithmic font style bits.
237  *
238  * \param flags  Style flags to set
239  * \param mask   Mask of flags to modify
240  * \return       Old style flags
241  *
242  * Examples:
243  * Turn on bold, leave other styles alone
244  *   \code prt_style(STYLEF_BOLD, STYLEF_BOLD); \endcode
245  *
246  * Turn off bold and turn on italic, leave others as they are
247  *   \code prt_style(STYLEF_ITALIC, STYLEF_BOLD | STYLEF_ITALIC); \endcode
248  *
249  * Query current style without chaning it
250  *   \code style = prt_style(0, 0); \endcode
251  *
252  * Reset all styles (plain text)
253  *   \code prt_style(0, STYLE_MASK); \endcode
254  */
255 uint8_t text_style(uint8_t flags, uint8_t mask)
256 {
257         uint8_t old = text_styles;
258         text_styles = (text_styles & ~mask) | flags;
259         return old;
260 }