X-Git-Url: https://codewiz.org/gitweb?a=blobdiff_plain;f=gfx%2Ftext.c;h=f296be78d3ae11560e0f1fbbf43489ba39ae9ee3;hb=522981c00bd0a016c15beb1ba1f8de27428ebaf8;hp=0fa994cd55189e41abbd9a8ba44b9ad9a7d6392b;hpb=39108834d9c102712d6c11830ca9b9fb5b098d19;p=bertos.git

diff --git a/gfx/text.c b/gfx/text.c
index 0fa994cd..f296be78 100755
--- a/gfx/text.c
+++ b/gfx/text.c
@@ -1,4 +1,4 @@
-/*!
+/**
  * \file
  * <!--
  * Copyright 2003, 2004, 2005 Develer S.r.l. (http://www.develer.com/)
@@ -15,6 +15,33 @@
 
 /*#*
  *#* $Log$
+ *#* Revision 1.13  2006/07/19 12:56:26  bernie
+ *#* Convert to new Doxygen style.
+ *#*
+ *#* Revision 1.12  2006/05/25 23:35:22  bernie
+ *#* Implement correct and faster clipping for algo text.
+ *#*
+ *#* Revision 1.11  2006/05/15 07:21:06  bernie
+ *#* Doxygen fix.
+ *#*
+ *#* Revision 1.10  2006/04/27 05:39:23  bernie
+ *#* Enhance text rendering to arbitrary x,y coords.
+ *#*
+ *#* Revision 1.9  2006/04/11 00:08:24  bernie
+ *#* text_offset(): New function, but I'm not quite confident with the design.
+ *#*
+ *#* Revision 1.8  2006/03/22 09:50:37  bernie
+ *#* Use the same format for fonts and rasters.
+ *#*
+ *#* Revision 1.7  2006/03/20 17:51:55  bernie
+ *#* Cleanups.
+ *#*
+ *#* Revision 1.6  2006/03/13 02:05:54  bernie
+ *#* Mark slow paths as UNLIKELY.
+ *#*
+ *#* Revision 1.5  2006/03/07 22:18:04  bernie
+ *#* Correctly compute text width for prop fonts; Make styles a per-bitmap attribute.
+ *#*
  *#* Revision 1.4  2006/02/15 09:10:15  bernie
  *#* Implement prop fonts; Fix algo styles.
  *#*
@@ -92,47 +119,39 @@
 #include <cfg/debug.h>
 
 
-/*!
- * Flags degli stili algoritmici
+/**
+ * ANSI escape sequences flag: true for ESC state on.
  *
- * La routine di rendering del testo e' in grado di applicare
- * delle semplici trasformazioni al font interno per generare
- * automaticamente degli stili predefiniti (bold, italic,
- * underline) a partire dal set di caratteri plain.
+ * \todo Move to Bitmap.flags.
  */
-static uint8_t text_styles;
-
-/*! ANSI escape sequences flag: true for ESC state on */
 static bool ansi_mode = false;
 
+/**
+ * Move (imaginary) cursor to coordinates specified.
+ */
+void text_setCoord(struct Bitmap *bm, int x, int y)
+{
+	bm->penX = x;
+	bm->penY = y;
+}
 
-/*!
+
+/**
  * Move (imaginary) cursor to column and row specified.
  * Next text write will start a that row and col.
  */
-void text_moveto(struct Bitmap *bm, int row, int col)
+void text_moveTo(struct Bitmap *bm, int row, int col)
 {
 	ASSERT(col >= 0);
 	ASSERT(col < bm->width / bm->font->width);
 	ASSERT(row >= 0);
 	ASSERT(row < bm->height / bm->font->height);
 
-	bm->penX = col * bm->font->width;
-	bm->penY = row * bm->font->height;
+	text_setCoord(bm, col * bm->font->width, row * bm->font->height);
 }
 
 
-/*!
- * Move (imaginary) cursor to coordinates specified.
- */
-void text_setcoord(struct Bitmap *bm, int x, int y)
-{
-	bm->penX = x;
-	bm->penY = y;
-}
-
-
-/*!
+/**
  * Render char \a c on Bitmap \a bm.
  */
 static int text_putglyph(char c, struct Bitmap *bm)
@@ -142,10 +161,10 @@ static int text_putglyph(char c, struct Bitmap *bm)
 	unsigned char index = (unsigned char)c;
 
 	/* Check for out of range char and replace with '?' or first char in font. */
-	if (index < bm->font->first || index > bm->font->last)
+	if (UNLIKELY(!FONT_HAS_GLYPH(bm->font, index)))
 	{
 		kprintf("Illegal char '%c' (0x%02x)\n", index, index);
-		if ('?' >= bm->font->first && '?' <= bm->font->last)
+		if (FONT_HAS_GLYPH(bm->font, '?'))
 			index = '?';
 		else
 			index = bm->font->first;
@@ -178,44 +197,49 @@ static int text_putglyph(char c, struct Bitmap *bm)
 		glyph = bm->font->glyph + index * glyph_height_bytes * glyph_width;
 	}
 
-	if (text_styles & STYLEF_CONDENSED)
-		--glyph_width;
-
-	if (text_styles & STYLEF_EXPANDED)
-		glyph_width *= 2;
-
 	/* Slow path for styled glyphs */
-	if (text_styles)
+	if (UNLIKELY(bm->styles))
 	{
+		uint8_t styles = bm->styles;
 		uint8_t prev_dots = 0, italic_prev_dots = 0;
 		uint8_t dots;
-		uint8_t row, col;
+		uint8_t row, col, row_bit;
 
-		/* Check if glyph fits in the bitmap. */
-		if ((bm->penX < 0) || (bm->penX + glyph_width > bm->width)
-			|| (bm->penY < 0) || (bm->penY + glyph_height > bm->height))
-		{
-			kprintf("bad coords x=%d y=%d\n", bm->penX, bm->penY);
-			return 0;
-		}
-
-		for (row = 0; row < glyph_height_bytes; ++row)
+		/*
+		 * To avoid repeating clipping and other expensive computations,
+		 * we cluster calls to gfx_blitRaster() using a small buffer.
+		 */
+		#define CONFIG_TEXT_RENDER_OPTIMIZE 1
+		#if CONFIG_TEXT_RENDER_OPTIMIZE
+			#define RENDER_BUF_WIDTH 12
+			#define RENDER_BUF_HEIGHT 8
+			uint8_t render_buf[RAST_SIZE(RENDER_BUF_WIDTH, RENDER_BUF_HEIGHT)];
+			uint8_t render_xpos = 0;
+		#endif
+
+		/* This style alone could be handled by the fast path too */
+		if (bm->styles & STYLEF_CONDENSED)
+			--glyph_width;
+
+		if (bm->styles & STYLEF_EXPANDED)
+			glyph_width *= 2;
+
+		for (row = 0, row_bit = 0; row < glyph_height_bytes; ++row, row_bit += 8)
 		{
 			/* For each dot column in the glyph... */
 			for (col = 0; col < glyph_width; ++col)
 			{
 				uint8_t src_col = col;
-				uint8_t i;
 
 				/* Expanded style: advances only once every two columns. */
-				if (text_styles & STYLEF_EXPANDED)
+				if (styles & STYLEF_EXPANDED)
 					src_col /= 2;
 
 				/* Fetch a column of dots from glyph. */
-				dots = PGM_READ_CHAR(glyph + src_col * glyph_height_bytes + row);
+				dots = PGM_READ_CHAR(RAST_ADDR(glyph, src_col, row_bit, glyph_width));
 
 				/* Italic: get lower 4 dots from previous column */
-				if (text_styles & STYLEF_ITALIC)
+				if (styles & STYLEF_ITALIC)
 				{
 					uint8_t new_dots = dots;
 					dots = (dots & 0xF0) | italic_prev_dots;
@@ -223,7 +247,7 @@ static int text_putglyph(char c, struct Bitmap *bm)
 				}
 
 				/* Bold: "or" pixels with the previous column */
-				if (text_styles & STYLEF_BOLD)
+				if (styles & STYLEF_BOLD)
 				{
 					uint8_t new_dots = dots;
 					dots |= prev_dots;
@@ -231,23 +255,48 @@ static int text_putglyph(char c, struct Bitmap *bm)
 				}
 
 				/* Underlined: turn on base pixel */
-				if (text_styles & STYLEF_UNDERLINE)
-					dots |= 0x80;
+				if ((styles & STYLEF_UNDERLINE)
+					&& (row == glyph_height_bytes - 1))
+					dots |= (1 << (glyph_height - row_bit - 1));
 
 				/* Inverted: invert pixels */
-				if (text_styles & STYLEF_INVERT)
+				if (styles & STYLEF_INVERT)
 					dots = ~dots;
 
 				/* Output dots */
-				for (i = 0; i < 8 && (row * 8) + i < glyph_height; ++i)
-					BM_DRAWPIXEL(bm, bm->penX + col, bm->penY + row * 8 + i, dots & (1<<i));
+				#if CONFIG_TEXT_RENDER_OPTIMIZE
+					render_buf[render_xpos++] = dots;
+					if (render_xpos == RENDER_BUF_WIDTH)
+					{
+						gfx_blitRaster(bm, bm->penX + col - render_xpos + 1, bm->penY + row_bit,
+							render_buf, render_xpos,
+							MIN((uint8_t)RENDER_BUF_HEIGHT, (uint8_t)(glyph_height - row_bit)),
+							RENDER_BUF_WIDTH);
+						render_xpos = 0;
+					}
+				#else
+					gfx_blitRaster(bm, bm->penX + col, bm->penY + row_bit,
+						&dots, 1, MIN((uint8_t)8, glyph_height - row_bit), 1);
+				#endif
 			}
+
+			#if CONFIG_TEXT_RENDER_OPTIMIZE
+				/* Flush out rest of render buffer */
+				if (render_xpos != 0)
+				{
+					gfx_blitRaster(bm, bm->penX + col - render_xpos, bm->penY + row_bit,
+						render_buf, render_xpos,
+						MIN((uint8_t)RENDER_BUF_HEIGHT, (uint8_t)(glyph_height - row_bit)),
+						RENDER_BUF_WIDTH);
+					render_xpos = 0;
+				}
+			#endif
 		}
 	}
 	else
 	{
 		/* No style: fast vanilla copy of glyph to bitmap */
-		gfx_blitRaster(bm, bm->penX, bm->penY, glyph, glyph_width, glyph_height, glyph_height_bytes);
+		gfx_blitRaster(bm, bm->penX, bm->penY, glyph, glyph_width, glyph_height, glyph_width);
 	}
 
 	/* Update current pen position */
@@ -257,14 +306,14 @@ static int text_putglyph(char c, struct Bitmap *bm)
 }
 
 
-/*!
+/**
  * Render char \c c, with (currently) limited ANSI escapes
  * emulation support and '\n' for newline.
  */
 int text_putchar(char c, struct Bitmap *bm)
 {
 	/* Handle ANSI escape sequences */
-	if (ansi_mode)
+	if (UNLIKELY(ansi_mode))
 	{
 		switch (c)
 		{
@@ -272,7 +321,7 @@ int text_putchar(char c, struct Bitmap *bm)
 			gfx_bitmapClear(bm);
 			bm->penX = 0;
 			bm->penY = 0;
-			text_style(0, STYLEF_MASK);
+			text_style(bm, 0, STYLEF_MASK);
 			break;
 		DB(default:
 			kprintf("Unknown ANSI esc code: %x\n", c);)
@@ -299,7 +348,7 @@ int text_putchar(char c, struct Bitmap *bm)
 }
 
 
-/*!
+/**
  * Clear the screen and reset cursor position
  */
 void text_clear(struct Bitmap *bmp)
@@ -315,29 +364,30 @@ void text_clearLine(struct Bitmap *bm, int line)
 }
 
 
-/*!
+/**
  * Set/clear algorithmic font style bits.
  *
+ * \param bm     Pointer to Bitmap to affect.
  * \param flags  Style flags to set
  * \param mask   Mask of flags to modify
  * \return       Old style flags
  *
  * Examples:
  * Turn on bold, leave other styles alone
- *   \code prt_style(STYLEF_BOLD, STYLEF_BOLD); \endcode
+ *   \code text_style(bm, STYLEF_BOLD, STYLEF_BOLD); \endcode
  *
  * Turn off bold and turn on italic, leave others as they are
- *   \code prt_style(STYLEF_ITALIC, STYLEF_BOLD | STYLEF_ITALIC); \endcode
+ *   \code text_style(bm, STYLEF_ITALIC, STYLEF_BOLD | STYLEF_ITALIC); \endcode
  *
  * Query current style without chaning it
- *   \code style = prt_style(0, 0); \endcode
+ *   \code style = text_style(bm, 0, 0); \endcode
  *
  * Reset all styles (plain text)
- *   \code prt_style(0, STYLE_MASK); \endcode
+ *   \code text_style(bm, 0, STYLE_MASK); \endcode
  */
-uint8_t text_style(uint8_t flags, uint8_t mask)
+uint8_t text_style(struct Bitmap *bm, uint8_t flags, uint8_t mask)
 {
-	uint8_t old = text_styles;
-	text_styles = (text_styles & ~mask) | flags;
+	uint8_t old = bm->styles;
+	bm->styles = (bm->styles & ~mask) | flags;
 	return old;
 }