@@ -193,6 +193,26 @@ void oswald_draw_font58(const unsigned int x1, unsigned int y1, const uint8_t ch

         return;

 }

+void oswald_writestr_font58(const unsigned int x1, unsigned int y1, const char *str, int *width, const uint8_t fg, const uint8_t bg)

+{

+	int x,w;

+	for(x=x1;*str!='\0';x+=w+1,str++) 

+		oswald_draw_font58(x, y1,*str,&w,fg,bg);

+	*width=x-x1;

+}

+

+int oswald_getwidth_font58(char *str)

+{

+	int total;

+	int width;

+	for(total=0;*str!='\0';str++) {

+		if(oswald_getchar_font58(*str,&width)!=NULL)

+			total+=width;

+		total++;

+	}

+	return(total);

+}

+

 void oswald_draw_font58_scaled(const unsigned int x1, unsigned int y1, const uint8_t character, int *width, const uint8_t fg, const uint8_t bg,const unsigned int scalex,const unsigned int scaley)

 {

 	int x,y,ix,iy;

@@ -246,6 +266,25 @@ void oswald_draw_font58_scaled(const unsigned int x1, unsigned int y1, const uin

         return;

 }

+void oswald_writestr_font58_scaled(const unsigned int x1, unsigned int y1, const char *str, int *width, const uint8_t fg, const uint8_t bg,const unsigned int scalex,const unsigned int scaley) 

+{

+	int x,w;

+	for(x=x1;*str!='\0';x+=w+1,str++) 

+		oswald_draw_font58_scaled(x, y1,*str,&w,fg,bg,scalex,scaley);

+	*width=x-x1;

+}

+

+int oswald_getwidth_font58_scaled(char *str, int scalex, int scaley)

+{

+	int total;

+	int width;

+	for(total=0;*str!='\0';str++) {

+		if(oswald_getchar_font58(*str,&width)!=NULL)

+			total+=width*scalex;

+		total++;

+	}

+	return(total);

+}

 void oswald_draw_microdigit(const unsigned int x1, unsigned int y1, const uint8_t character, int *width, const uint8_t fg, const uint8_t bg)

 {

@@ -390,14 +429,6 @@ void oswald_draw_line_ww(const uint8_t xstart, const uint8_t ystart, const uint8

         }

 }

-uint8_t oswald_getwidth_character(const oswald_font_face face, const uint8_t Character)

-{

-	int width;

-	if(oswald_getchar_font58(Character,&width)==NULL)

-		return(0);

-	return(width);

-}

-

 uint8_t oswald_write_character(const uint8_t x, const uint8_t y, const oswald_font_face face,

         const boolean invert, const uint8_t Character)

 {

@@ -406,18 +437,6 @@ uint8_t oswald_write_character(const uint8_t x, const uint8_t y, const oswald_fo

         return width+1;

 }

-int oswald_getwidth_string(const oswald_font_face face, char *str)

-{

-	int total;

-	int width;

-	for(total=0;*str!=NULL;str++) {

-		if(oswald_getchar_font58(*str,&width)!=NULL)

-			total+=width;

-		total++;

-	}

-	return(total);

-}

-

 void oswald_write_string(const uint8_t x, const uint8_t y, const oswald_font_face face, const boolean invert, char *str)

 {

         uint8_t lx, i, strl;

@@ -152,15 +152,14 @@ void oswald_draw_grid(const unsigned int x1, const unsigned int y1, const unsign

         hal_lcd_set_pixel(x2-1,y2-1,1);

 }

-void oswald_draw_font58(const unsigned int x1, unsigned int y1, const uint8_t character, int *width, const uint8_t fg, const uint8_t bg)

+static const uint8_t *

+oswald_getchar_font58(const uint8_t character, int *width)

 {

-        int bit;

-	int k;

-	uint8_t car;

 	const uint8_t *ptr;

-        *width=0;

-        if(character<32 || character>255)

-                return;

+	if(character<32 || character>255) {

+		*width=0;

+                return(NULL);

+	}

 	ptr=(font5x8+((character-32)<<2));

 	/* simple way to calc. the width */

         *width=(((ptr[0]&0x02)||(ptr[1]&0x10)||(ptr[2]&0x84)||(ptr[3]&0x21))?5:

@@ -168,6 +167,17 @@ void oswald_draw_font58(const unsigned int x1, unsigned int y1, const uint8_t ch

                 ((ptr[0]&0x08)||(ptr[1]&0x42)||(ptr[2]&0x10)||(ptr[3]&0x84))?3:

                 ((ptr[0]&0x10)||(ptr[1]&0x84)||(ptr[2]&0x21)||(ptr[3]&0x08))?2:

                 ((ptr[0]&0x3f)||(ptr[1]&0xff)||(ptr[2]&0xff)||(ptr[3]&0xff))?2:1);

+	return(ptr);

+}

+

+void oswald_draw_font58(const unsigned int x1, unsigned int y1, const uint8_t character, int *width, const uint8_t fg, const uint8_t bg)

+{

+        int bit;

+	int k;

+	uint8_t car;

+	const uint8_t *ptr;

+	if((ptr=oswald_getchar_font58(character,width))==NULL)

+		return;

         if(ptr[0]&0x80) {

                 oswald_draw_rect(x1,y1,x1+*width,y1+1,bg);

                 if(ptr[0]&0x40)

@@ -212,13 +222,8 @@ void oswald_draw_font58_scaled(const unsigned int x1, unsigned int y1, const uin

 		}

 	}

 	/* default case */

-	ptr=(font5x8+((character-32)<<2));

-	/* simple way to calc. the width */

-        *width=(((ptr[0]&0x02)||(ptr[1]&0x10)||(ptr[2]&0x84)||(ptr[3]&0x21))?5:

-                ((ptr[0]&0x04)||(ptr[1]&0x21)||(ptr[2]&0x08)||(ptr[3]&0x42))?4:

-                ((ptr[0]&0x08)||(ptr[1]&0x42)||(ptr[2]&0x10)||(ptr[3]&0x84))?3:

-                ((ptr[0]&0x10)||(ptr[1]&0x84)||(ptr[2]&0x21)||(ptr[3]&0x08))?2:

-                ((ptr[0]&0x3f)||(ptr[1]&0xff)||(ptr[2]&0xff)||(ptr[3]&0xff))?2:1);

+	if((ptr=oswald_getchar_font58(character,width))==NULL)

+		return;

         if(ptr[0]&0x80) {

                 if(ptr[0]&0x40)

                         oswald_draw_rect(x1+(*width-1)*scalex,y1,x1+(*width-1+1)*scalex-1,y1+scaley-1,fg);

@@ -385,6 +390,14 @@ void oswald_draw_line_ww(const uint8_t xstart, const uint8_t ystart, const uint8

         }

 }

+uint8_t oswald_getwidth_character(const oswald_font_face face, const uint8_t Character)

+{

+	int width;

+	if(oswald_getchar_font58(Character,&width)==NULL)

+		return(0);

+	return(width);

+}

+

 uint8_t oswald_write_character(const uint8_t x, const uint8_t y, const oswald_font_face face,

         const boolean invert, const uint8_t Character)

 {

@@ -393,6 +406,18 @@ uint8_t oswald_write_character(const uint8_t x, const uint8_t y, const oswald_fo

         return width+1;

 }

+int oswald_getwidth_string(const oswald_font_face face, char *str)

+{

+	int total;

+	int width;

+	for(total=0;*str!=NULL;str++) {

+		if(oswald_getchar_font58(*str,&width)!=NULL)

+			total+=width;

+		total++;

+	}

+	return(total);

+}

+

 void oswald_write_string(const uint8_t x, const uint8_t y, const oswald_font_face face, const boolean invert, char *str)

 {

         uint8_t lx, i, strl;

@@ -51,6 +51,17 @@ oswald_draw_point(const uint8_t color)

         gc.x%=gc.w;

 }

+void

+oswald_draw_point_transparent(const uint8_t color, const uint8_t transparent)

+{

+	if(color!=transparent)

+	        hal_lcd_set_pixel(gc.x1+gc.x,gc.y1+gc.y,color);

+        gc.x++;

+        gc.y+=(gc.x/gc.w);

+        gc.x%=gc.w;

+}

+

+

 #if 0

 void oswald_draw_pixel(const unsigned int xstart, const unsigned int ystart, uint8_t color)

@@ -62,7 +73,7 @@ void oswald_draw_pixel(const unsigned int xstart, const unsigned int ystart, uin

 void oswald_draw_bitmap_opts(const unsigned int xstart, const unsigned int ystart,

                 const unsigned int xoff, const unsigned int yoff,

                 const unsigned int width, const unsigned int height,

-                const boolean invert,

+                const boolean fg,

                 const unsigned int bmp_width, const unsigned int bmp_height,

                 const void *bmp)

 {

@@ -72,25 +83,15 @@ void oswald_draw_bitmap_opts(const unsigned int xstart, const unsigned int ystar

         if (bmp == NULL)

                 return;

-        //g_printerr("dbmp %d,%d off %d,%d\n", xstart, ystart, width, height);

         cb = (uint8_t *)bmp;

-        //g_printerr("dat %02x %02x %02x\n", (uint8_t)cb[0], (uint8_t)cb[1], (uint8_t)cb[2]);

         // we only draw set pixel, unset pixel remain as they are

         for (y=yoff; y<bmp_height && y<height; y++) {

                 for (x=xoff; x<bmp_width && x<width; x++) {

                         cb = (uint8_t *)(bmp + (y * ((bmp_width / 8) + ((bmp_width % 8) ? 1 : 0))) + (x / 8));

-                        // g_printerr("dat %02x %02x %02x\n", (uint8_t)cb[0], (uint8_t)cb[1], (uint8_t)cb[2]);

                         if (*cb & (1 << (x % 8))) {

-                                if (!invert)

-                                        hal_lcd_set_pixel((xstart + x) - xoff, (ystart + y) - yoff, TRUE);

-                                // g_printerr("X");

-                        } else {

-                                if (invert)

-                                        hal_lcd_set_pixel((xstart + x) - xoff, (ystart + y) - yoff, TRUE);

-                                // g_printerr(".");

+                                hal_lcd_set_pixel((xstart + x) - xoff, (ystart + y) - yoff, fg);

                         }

                 }

-                //g_printerr("\n");

         }

 }

@@ -177,7 +178,7 @@ void oswald_draw_font58(const unsigned int x1, unsigned int y1, const uint8_t ch

         oswald_set_draw_window(x1,y1,x1+4,y1+5);

 	for(k=0;k<=3;++k) {

         	for(bit=((k==0)?0x20:0x80),car=ptr[k];bit>0;bit>>=1)

-                	oswald_draw_point((car&bit)?fg:bg);

+                	oswald_draw_point_transparent((car&bit)?fg:bg,bg);

 	}

         return;

 }

@@ -198,15 +199,15 @@ void oswald_draw_font58_scaled(const unsigned int x1, unsigned int y1, const uin

 			return;

 		} else if(scalex==4 && scaley==5) {

 			*width=16;

-			oswald_draw_bitmap_opts(x1,y1,(character-'0')*4*4,0,(character-'0')*4*4+16,font5x8scaledx4x5_height,!fg,font5x8scaledx4x5_width,font5x8scaledx4x5_height,font5x8scaledx4x5_bits);

+			oswald_draw_bitmap_opts(x1,y1,(character-'0')*4*4,0,(character-'0')*4*4+16,font5x8scaledx4x5_height,fg,font5x8scaledx4x5_width,font5x8scaledx4x5_height,font5x8scaledx4x5_bits);

 			return;

 		} else if(scalex==2 && scaley==2) {

 			*width=8;

-			oswald_draw_bitmap_opts(x1,y1,(character-'0')*2*4,0,(character-'0')*2*4+8,font5x8scaledx2x2_height,!fg,font5x8scaledx2x2_width,font5x8scaledx2x2_height,font5x8scaledx2x2_bits);

+			oswald_draw_bitmap_opts(x1,y1,(character-'0')*2*4,0,(character-'0')*2*4+8,font5x8scaledx2x2_height,fg,font5x8scaledx2x2_width,font5x8scaledx2x2_height,font5x8scaledx2x2_bits);

 			return;

 		} else if(scalex==2 && scaley==3) {

 			*width=8;

-			oswald_draw_bitmap_opts(x1,y1,(character-'0')*2*4,0,(character-'0')*2*4+8,font5x8scaledx2x3_height,!fg,font5x8scaledx2x3_width,font5x8scaledx2x3_height,font5x8scaledx2x3_bits);

+			oswald_draw_bitmap_opts(x1,y1,(character-'0')*2*4,0,(character-'0')*2*4+8,font5x8scaledx2x3_height,fg,font5x8scaledx2x3_width,font5x8scaledx2x3_height,font5x8scaledx2x3_bits);

 			return;

 		}

 	}

@@ -219,12 +220,10 @@ void oswald_draw_font58_scaled(const unsigned int x1, unsigned int y1, const uin

                 ((ptr[0]&0x10)||(ptr[1]&0x84)||(ptr[2]&0x21)||(ptr[3]&0x08))?2:

                 ((ptr[0]&0x3f)||(ptr[1]&0xff)||(ptr[2]&0xff)||(ptr[3]&0xff))?2:1);

         if(ptr[0]&0x80) {

-                oswald_draw_rect(x1,y1,x1+(4+1)*scalex-1,y1+(1+1)*scaley-1,bg);

                 if(ptr[0]&0x40)

                         oswald_draw_rect(x1+(*width-1)*scalex,y1,x1+(*width-1+1)*scalex-1,y1+scaley-1,fg);

                 y1+=2*scaley;

-        } else

-                oswald_draw_rect(x1,y1+6*scaley,x1+(4+1)*scalex-1,y1+(7+1)*scaley-1,bg);

+        }

         oswald_set_draw_window(x1,y1,x1+(4+1)*scalex-1,y1+(5+1)*scaley-1);

 	for(y=0;y<6;y++) {

 		for(iy=0;iy<scaley;iy++) {

@@ -232,9 +231,9 @@ void oswald_draw_font58_scaled(const unsigned int x1, unsigned int y1, const uin

 				n=2+x+y*5;

 				k=n>>3;

 				b=n&0x7;

-				c=(ptr[k]&(0x80>>b))?1:0;

+				c=(ptr[k]&(0x80>>b))?fg:bg;

 				for(ix=0;ix<scalex;ix++)

-					oswald_draw_point(c);

+					oswald_draw_point_transparent(c,bg);

 			}

 		}

 	}

@@ -252,7 +251,7 @@ void oswald_draw_microdigit(const unsigned int x1, unsigned int y1, const uint8_

 	car=((character>='0' && character<='9')?micronumbers[character-'0']:0x00);

         oswald_set_draw_window(x1,y1,x1+1,y1+3);

         for(bit=0x80;bit>0;bit>>=1)

-               	oswald_draw_point((car&bit)?fg:bg);

+               	oswald_draw_point_transparent((car&bit)?fg:bg,bg);

         *width=3;

         return;

 }

@@ -267,7 +266,7 @@ void oswald_draw_tinydigit(const unsigned int x1, unsigned int y1, const uint8_t

 	car=((character>='0' && character<='9')?tinynumbers[character-'0']:0x00);

         oswald_set_draw_window(x1,y1,x1+2,y1+4);

         for(bit=0x4000;bit>0;bit>>=1)

-               	oswald_draw_point((car&bit)?fg:bg);

+               	oswald_draw_point_transparent((car&bit)?fg:bg,bg);

         *width=4;

         return;

 }

@@ -276,11 +275,11 @@ void oswald_draw_bigdigit(const unsigned int x1, unsigned int y1, const uint8_t

 {

 	*width=14;

 	if(character>='0' && character<='9') 

-		oswald_draw_bitmap_opts(x1,y1,(character-'0')*14,0,(character-'0')*14+14,fontbigdigits_height,!fg,fontbigdigits_width,fontbigdigits_height,fontbigdigits_bits);

+		oswald_draw_bitmap_opts(x1,y1,(character-'0')*14,0,(character-'0')*14+14,fontbigdigits_height,fg,fontbigdigits_width,fontbigdigits_height,fontbigdigits_bits);

         return;

 }

-void oswald_draw_line(const uint8_t xstart, const uint8_t ystart, const uint8_t xend, const uint8_t yend)

+void oswald_draw_line(const uint8_t xstart, const uint8_t ystart, const uint8_t xend, const uint8_t yend, const uint8_t fg)

 {

         int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;

@@ -308,7 +307,7 @@ void oswald_draw_line(const uint8_t xstart, const uint8_t ystart, const uint8_t

         x = xstart;

         y = ystart;

         err = el/2;

-        hal_lcd_set_pixel(x, y, TRUE);

+        hal_lcd_set_pixel(x, y, fg);

         for (t = 0; t < el; ++t) {

                 err -= es;

@@ -320,11 +319,11 @@ void oswald_draw_line(const uint8_t xstart, const uint8_t ystart, const uint8_t

                         x += pdx;

                         y += pdy;

                 }

-                hal_lcd_set_pixel(x, y, TRUE);

+                hal_lcd_set_pixel(x, y, fg);

         }

 }

-void oswald_draw_line_ww(const uint8_t xstart, const uint8_t ystart, const uint8_t xend, const uint8_t yend, const uint8_t thickness)

+void oswald_draw_line_ww(const uint8_t xstart, const uint8_t ystart, const uint8_t xend, const uint8_t yend, const uint8_t fg, const uint8_t thickness)

 {

         int16_t i, x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;

@@ -360,10 +359,10 @@ void oswald_draw_line_ww(const uint8_t xstart, const uint8_t ystart, const uint8

         err = el/2;

         hal_lcd_set_pixel(x, y, TRUE);

         for (i=1; i<thickness; i++) {

-                hal_lcd_set_pixel(x-i, y, TRUE);

-                hal_lcd_set_pixel(x+i, y, TRUE);

-                hal_lcd_set_pixel(x, y-i, TRUE);

-                hal_lcd_set_pixel(x, y+i, TRUE);

+                hal_lcd_set_pixel(x-i, y, fg);

+                hal_lcd_set_pixel(x+i, y, fg);

+                hal_lcd_set_pixel(x, y-i, fg);

+                hal_lcd_set_pixel(x, y+i, fg);

         }

         for (t = 0; t < el; ++t) {

@@ -376,12 +375,12 @@ void oswald_draw_line_ww(const uint8_t xstart, const uint8_t ystart, const uint8

                         x += pdx;

                         y += pdy;

                 }

-                hal_lcd_set_pixel(x, y, TRUE);

+                hal_lcd_set_pixel(x, y, fg);

                 for (i=1; i<thickness; i++) {

-                        hal_lcd_set_pixel(x-i, y, TRUE);

-                        hal_lcd_set_pixel(x+i, y, TRUE);

-                        hal_lcd_set_pixel(x, y-i, TRUE);

-                        hal_lcd_set_pixel(x, y+i, TRUE);

+                        hal_lcd_set_pixel(x-i, y, fg);

+                        hal_lcd_set_pixel(x+i, y, fg);

+                        hal_lcd_set_pixel(x, y-i, fg);

+                        hal_lcd_set_pixel(x, y+i, fg);

                 }

         }

 }

@@ -4,243 +4,441 @@

 #include "oswald_hal.h"

 #include "oswald_graphics.h"

+#if defined(__GNUC__) && (__MSP430X__ > 0)

+__attribute__((__far__))

+#endif

+#include "fonts/font5x8scaledx4x5.xbm"

+

+#if defined(__GNUC__) && (__MSP430X__ > 0)

+__attribute__((__far__))

+#endif

+#include "fonts/font5x8scaledx2x2.xbm"

+

+#if defined(__GNUC__) && (__MSP430X__ > 0)

+__attribute__((__far__))

+#endif

+#include "fonts/font5x8scaledx2x3.xbm"

+

+#if defined(__GNUC__) && (__MSP430X__ > 0)

+__attribute__((__far__))

+#endif

+#include "fonts/fontbigdigits.xbm"

+

+#define LCD_WIDTH 96

+#define LCD_HEIGHT 96

+

+typedef struct {

+        unsigned int x1,y1,x2,y2;

+        unsigned int x,y;

+        unsigned int w;

+} gc_t;

+gc_t gc={0,0,LCD_WIDTH-1,LCD_HEIGHT-1};

+

+void

+oswald_set_draw_window(const unsigned int x1,const unsigned int y1,const unsigned int x2,const unsigned int y2)

+{

+        gc.x1=x1,gc.x2=x2,gc.y1=y1,gc.y2=y2;

+        gc.x=gc.y=0;

+        gc.w=gc.x2-gc.x1+1;

+}

+

+void

+oswald_draw_point(const uint8_t color)

+{

+        hal_lcd_set_pixel(gc.x1+gc.x,gc.y1+gc.y,color);

+        gc.x++;

+        gc.y+=(gc.x/gc.w);

+        gc.x%=gc.w;

+}

 #if 0

 void oswald_draw_pixel(const unsigned int xstart, const unsigned int ystart, uint8_t color)

 {

-	hal_lcd_set_pixel(xstart, ystart, TRUE);

+        hal_lcd_set_pixel(xstart, ystart, TRUE);

 }

 #endif

 void oswald_draw_bitmap_opts(const unsigned int xstart, const unsigned int ystart,

-		const unsigned int xoff, const unsigned int yoff,

-		const unsigned int width, const unsigned int height,

-		const boolean invert,

-		const unsigned int bmp_width, const unsigned int bmp_height,

-		const void *bmp)

-{

-	unsigned int x, y;

-	uint8_t *cb;

-

-	if (bmp == NULL)

-		return;

-

-	//g_printerr("dbmp %d,%d off %d,%d\n", xstart, ystart, width, height);

-	cb = (uint8_t *)bmp;

-	//g_printerr("dat %02x %02x %02x\n", (uint8_t)cb[0], (uint8_t)cb[1], (uint8_t)cb[2]);

-	// we only draw set pixel, unset pixel remain as they are

-	for (y=yoff; y<bmp_height && y<height; y++) {

-		for (x=xoff; x<bmp_width && x<width; x++) {

-			cb = (uint8_t *)(bmp + (y * ((bmp_width / 8) + ((bmp_width % 8) ? 1 : 0))) + (x / 8));

-			// g_printerr("dat %02x %02x %02x\n", (uint8_t)cb[0], (uint8_t)cb[1], (uint8_t)cb[2]);

-			if (*cb & (1 << (x % 8))) {

-				if (!invert)

-					hal_lcd_set_pixel((xstart + x) - xoff, (ystart + y) - yoff, TRUE);

-				// g_printerr("X");

-			} else {

-				if (invert)

-					hal_lcd_set_pixel((xstart + x) - xoff, (ystart + y) - yoff, TRUE);

-				// g_printerr(".");

-			}

-		}

-		//g_printerr("\n");

-	}

+                const unsigned int xoff, const unsigned int yoff,

+                const unsigned int width, const unsigned int height,

+                const boolean invert,

+                const unsigned int bmp_width, const unsigned int bmp_height,

+                const void *bmp)

+{

+        unsigned int x, y;

+        uint8_t *cb;

+

+        if (bmp == NULL)

+                return;

+

+        //g_printerr("dbmp %d,%d off %d,%d\n", xstart, ystart, width, height);

+        cb = (uint8_t *)bmp;

+        //g_printerr("dat %02x %02x %02x\n", (uint8_t)cb[0], (uint8_t)cb[1], (uint8_t)cb[2]);

+        // we only draw set pixel, unset pixel remain as they are

+        for (y=yoff; y<bmp_height && y<height; y++) {

+                for (x=xoff; x<bmp_width && x<width; x++) {

+                        cb = (uint8_t *)(bmp + (y * ((bmp_width / 8) + ((bmp_width % 8) ? 1 : 0))) + (x / 8));

+                        // g_printerr("dat %02x %02x %02x\n", (uint8_t)cb[0], (uint8_t)cb[1], (uint8_t)cb[2]);

+                        if (*cb & (1 << (x % 8))) {

+                                if (!invert)

+                                        hal_lcd_set_pixel((xstart + x) - xoff, (ystart + y) - yoff, TRUE);

+                                // g_printerr("X");

+                        } else {

+                                if (invert)

+                                        hal_lcd_set_pixel((xstart + x) - xoff, (ystart + y) - yoff, TRUE);

+                                // g_printerr(".");

+                        }

+                }

+                //g_printerr("\n");

+        }

 }

-void oswald_draw_line(const uint8_t xstart, const uint8_t ystart, const uint8_t xend, const uint8_t yend)

+void oswald_draw_bitmap_opts_1x2fg(const unsigned int xstart, const unsigned int ystart,

+                const unsigned int xoff, const unsigned int yoff,

+                const unsigned int width, const unsigned int height,

+                const boolean fg,

+                const unsigned int bmp_width, const unsigned int bmp_height,

+                const void *bmp)

 {

-	int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;

- 

-	dx = xend - xstart;

-	dy = yend - ystart;

- 

-	incx = (dx >= 0) ? 1 : -1;

-	incy = (dy >= 0) ? 1 : -1;

-

-	if (dx<0)

-		dx = -dx;

-	if (dy<0)

-		dy = -dy;

- 

-	if (dx>dy) {

-		pdx = incx; pdy = 0;

-		ddx=incx; ddy=incy;

-		es =dy;   el =dx;

-	} else {

-		pdx=0;    pdy=incy;

-		ddx=incx; ddy=incy;

-		es =dx;   el =dy;

-	}

- 

-	x = xstart;

-	y = ystart;

-	err = el/2;

-	hal_lcd_set_pixel(x, y, TRUE);

- 

-	for (t = 0; t < el; ++t) {

-		err -= es; 

-		if (err < 0) {

-			err += el;

-			x += ddx;

-			y += ddy;

-		} else {

-			x += pdx;

-			y += pdy;

-		}

-		hal_lcd_set_pixel(x, y, TRUE);

-	}

+        unsigned int x, y, iy;

+        uint8_t *cb;

+

+        if (bmp == NULL)

+                return;

+

+        cb = (uint8_t *)bmp;

+        for (y=yoff,iy=0; y<bmp_height && y<height; y++, iy++) {

+                for (x=xoff; x<bmp_width && x<width; x++) {

+                        cb = (uint8_t *)(bmp + (y * ((bmp_width / 8) + ((bmp_width % 8) ? 1 : 0))) + (x / 8));

+                        if (*cb & (1 << (x % 8))) {

+                                hal_lcd_set_pixel((xstart + x) - xoff, (ystart + y) - yoff + iy , fg);

+                                hal_lcd_set_pixel((xstart + x) - xoff, (ystart + y) - yoff + iy + 1, fg);

+                        }

+                }

+        }

 }

-void oswald_draw_line_ww(const uint8_t xstart, const uint8_t ystart, const uint8_t xend, const uint8_t yend, const uint8_t thickness)

+void oswald_draw_rect(const unsigned int x1, const unsigned int y1, const unsigned int x2, const unsigned int y2, const uint8_t color)

 {

-	int16_t i, x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;

- 

-	dx = xend - xstart;

-	dy = yend - ystart;

- 

-	incx = (dx >= 0) ? 1 : -1;

-	incy = (dy >= 0) ? 1 : -1;

-

-	if (dx<0)

-		dx = -dx;

-	if (dy<0)

-		dy = -dy;

- 

-	if (dx>dy) {

-		pdx = incx;

-		pdy = 0;

-		ddx = incx;

-		ddy = incy;

-		es = dy;

-		el = dx;

-	} else {

-		pdx = 0;

-		pdy = incy;

-		ddx = incx;

-		ddy = incy;

-		es = dx;

-		el = dy;

-	}

- 

-	x = xstart;

-	y = ystart;

-	err = el/2;

-	hal_lcd_set_pixel(x, y, TRUE);

-	for (i=1; i<thickness; i++) {

-		hal_lcd_set_pixel(x-i, y, TRUE);

-		hal_lcd_set_pixel(x+i, y, TRUE);

-		hal_lcd_set_pixel(x, y-i, TRUE);

-		hal_lcd_set_pixel(x, y+i, TRUE);

+        unsigned int x, y;

+        for(y=y1;y<=y2;++y) {

+                for(x=x1;x<=x2;++x)

+                        hal_lcd_set_pixel(x,y,color);

+        }

+}

+

+void oswald_draw_grid(const unsigned int x1, const unsigned int y1, const unsigned int x2, const unsigned int y2, const unsigned int ix, const unsigned int iy)

+{

+        unsigned int x, y;

+        for(y=y1+iy;y<y2;y+=iy) {

+        	oswald_set_draw_window(x1,y,x2,y);

+                for(x=x1;x<=x2;++x)

+                	oswald_draw_point(x&1);

+        }

+        for(x=x1+ix;x<x2;x+=ix) {

+        	oswald_set_draw_window(x,y1,x,y2);

+                for(y=y1;y<=y2;++y)

+                	oswald_draw_point(y&1);

+        }

+	oswald_draw_rect(x1+1,y1,x2-1,y1,1);

+	oswald_draw_rect(x1+1,y2,x2-1,y2,1);

+	oswald_draw_rect(x1,y1+1,x1,y2-1,1);

+	oswald_draw_rect(x2,y1+1,x2,y2-1,1);

+        hal_lcd_set_pixel(x1+1,y1+1,1);

+        hal_lcd_set_pixel(x1+1,y2-1,1);

+        hal_lcd_set_pixel(x2-1,y1+1,1);

+        hal_lcd_set_pixel(x2-1,y2-1,1);

+}

+

+void oswald_draw_font58(const unsigned int x1, unsigned int y1, const uint8_t character, int *width, const uint8_t fg, const uint8_t bg)

+{

+        int bit;

+	int k;

+	uint8_t car;

+	const uint8_t *ptr;

+        *width=0;

+        if(character<32 || character>255)

+                return;

+	ptr=(font5x8+((character-32)<<2));

+	/* simple way to calc. the width */

+        *width=(((ptr[0]&0x02)||(ptr[1]&0x10)||(ptr[2]&0x84)||(ptr[3]&0x21))?5:

+                ((ptr[0]&0x04)||(ptr[1]&0x21)||(ptr[2]&0x08)||(ptr[3]&0x42))?4:

+                ((ptr[0]&0x08)||(ptr[1]&0x42)||(ptr[2]&0x10)||(ptr[3]&0x84))?3:

+                ((ptr[0]&0x10)||(ptr[1]&0x84)||(ptr[2]&0x21)||(ptr[3]&0x08))?2:

+                ((ptr[0]&0x3f)||(ptr[1]&0xff)||(ptr[2]&0xff)||(ptr[3]&0xff))?2:1);

+        if(ptr[0]&0x80) {

+                oswald_draw_rect(x1,y1,x1+*width,y1+1,bg);

+                if(ptr[0]&0x40)

+                        oswald_draw_rect(x1+*width-1,y1,x1+*width-1,y1,fg);

+                y1+=2;

+        } else

+                oswald_draw_rect(x1,y1,x1+*width-1,y1+7,bg);

+        oswald_set_draw_window(x1,y1,x1+4,y1+5);

+	for(k=0;k<=3;++k) {

+        	for(bit=((k==0)?0x20:0x80),car=ptr[k];bit>0;bit>>=1)

+                	oswald_draw_point((car&bit)?fg:bg);

 	}

- 

-	for (t = 0; t < el; ++t) {

-		err -= es; 

-		if (err < 0) {

-			err += el;

-			x += ddx;

-			y += ddy;

-		} else {

-			x += pdx;

-			y += pdy;

+        return;

+}

+

+void oswald_draw_font58_scaled(const unsigned int x1, unsigned int y1, const uint8_t character, int *width, const uint8_t fg, const uint8_t bg,const unsigned int scalex,const unsigned int scaley)

+{

+	int x,y,ix,iy;

+        int k,n,b,c;

+	const uint8_t *ptr;

+        *width=0;

+        if(character<32 || character>255)

+                return;

+	/* special cases */

+	if(character>='0' && character<='9') {

+		if(scalex==4 && scaley==10) {

+			*width=16;

+			oswald_draw_bitmap_opts_1x2fg(x1,y1,(character-'0')*4*4,0,(character-'0')*4*4+16,font5x8scaledx4x5_height,fg,font5x8scaledx4x5_width,font5x8scaledx4x5_height,font5x8scaledx4x5_bits);

+			return;

+		} else if(scalex==4 && scaley==5) {

+			*width=16;

+			oswald_draw_bitmap_opts(x1,y1,(character-'0')*4*4,0,(character-'0')*4*4+16,font5x8scaledx4x5_height,!fg,font5x8scaledx4x5_width,font5x8scaledx4x5_height,font5x8scaledx4x5_bits);

+			return;

+		} else if(scalex==2 && scaley==2) {

+			*width=8;

+			oswald_draw_bitmap_opts(x1,y1,(character-'0')*2*4,0,(character-'0')*2*4+8,font5x8scaledx2x2_height,!fg,font5x8scaledx2x2_width,font5x8scaledx2x2_height,font5x8scaledx2x2_bits);

+			return;

+		} else if(scalex==2 && scaley==3) {

+			*width=8;

+			oswald_draw_bitmap_opts(x1,y1,(character-'0')*2*4,0,(character-'0')*2*4+8,font5x8scaledx2x3_height,!fg,font5x8scaledx2x3_width,font5x8scaledx2x3_height,font5x8scaledx2x3_bits);

+			return;

 		}

-		hal_lcd_set_pixel(x, y, TRUE);

-		for (i=1; i<thickness; i++) {

-			hal_lcd_set_pixel(x-i, y, TRUE);

-			hal_lcd_set_pixel(x+i, y, TRUE);

-			hal_lcd_set_pixel(x, y-i, TRUE);

-			hal_lcd_set_pixel(x, y+i, TRUE);

+	}

+	/* default case */

+	ptr=(font5x8+((character-32)<<2));

+	/* simple way to calc. the width */

+        *width=(((ptr[0]&0x02)||(ptr[1]&0x10)||(ptr[2]&0x84)||(ptr[3]&0x21))?5:

+                ((ptr[0]&0x04)||(ptr[1]&0x21)||(ptr[2]&0x08)||(ptr[3]&0x42))?4:

+                ((ptr[0]&0x08)||(ptr[1]&0x42)||(ptr[2]&0x10)||(ptr[3]&0x84))?3:

+                ((ptr[0]&0x10)||(ptr[1]&0x84)||(ptr[2]&0x21)||(ptr[3]&0x08))?2:

+                ((ptr[0]&0x3f)||(ptr[1]&0xff)||(ptr[2]&0xff)||(ptr[3]&0xff))?2:1);

+        if(ptr[0]&0x80) {

+                oswald_draw_rect(x1,y1,x1+(4+1)*scalex-1,y1+(1+1)*scaley-1,bg);

+                if(ptr[0]&0x40)

+                        oswald_draw_rect(x1+(*width-1)*scalex,y1,x1+(*width-1+1)*scalex-1,y1+scaley-1,fg);

+                y1+=2*scaley;

+        } else

+                oswald_draw_rect(x1,y1+6*scaley,x1+(4+1)*scalex-1,y1+(7+1)*scaley-1,bg);

+        oswald_set_draw_window(x1,y1,x1+(4+1)*scalex-1,y1+(5+1)*scaley-1);

+	for(y=0;y<6;y++) {

+		for(iy=0;iy<scaley;iy++) {

+			for(x=0;x<5;x++) {

+				n=2+x+y*5;

+				k=n>>3;

+				b=n&0x7;

+				c=(ptr[k]&(0x80>>b))?1:0;

+				for(ix=0;ix<scalex;ix++)

+					oswald_draw_point(c);

+			}

 		}

 	}

+        *width*=scalex;

+        return;

 }

-uint8_t oswald_write_character(const uint8_t x, const uint8_t y, const oswald_font_face face, const boolean invert, const uint8_t Character)

+

+void oswald_draw_microdigit(const unsigned int x1, unsigned int y1, const uint8_t character, int *width, const uint8_t fg, const uint8_t bg)

 {

-	uint8_t *cdata = oswald_fonts[face].data;

-	uint8_t cwidth;

-	int csize;

+	static unsigned char micronumbers[10] = { 0xff, 0x55, 0xdb, 0xd7, /* 0-3 */

+						  0xbd, 0xe6, 0xef, 0xda, /* 4-7 */

+					          0xcf, 0xf7 /* 8-9 */ };

+	unsigned char bit,car;

+	car=((character>='0' && character<='9')?micronumbers[character-'0']:0x00);

+        oswald_set_draw_window(x1,y1,x1+1,y1+3);

+        for(bit=0x80;bit>0;bit>>=1)

+               	oswald_draw_point((car&bit)?fg:bg);

+        *width=3;

+        return;

+}

-//	if (Character == 32) { // space, blank no need to draw one ;)

-//		return oswald_fonts[face].width / 2;

-//	}

+void oswald_draw_tinydigit(const unsigned int x1, unsigned int y1, const uint8_t character, int *width, const uint8_t fg, const uint8_t bg)

+{

+	static unsigned short tinynumbers[10] = { 

+		0x2b6a,0x2c97,0x62a7,0x728e,

+		0x5bc9,0x798e,0x29aa,0x7252,

+		0x2aaa,0x2aca };

+	unsigned short bit,car;

+	car=((character>='0' && character<='9')?tinynumbers[character-'0']:0x00);

+        oswald_set_draw_window(x1,y1,x1+2,y1+4);

+        for(bit=0x4000;bit>0;bit>>=1)

+               	oswald_draw_point((car&bit)?fg:bg);

+        *width=4;

+        return;

+}

+

+void oswald_draw_bigdigit(const unsigned int x1, unsigned int y1, const uint8_t character, int *width, const uint8_t fg, const uint8_t bg)

+{

+	*width=14;

+	if(character>='0' && character<='9') 

+		oswald_draw_bitmap_opts(x1,y1,(character-'0')*14,0,(character-'0')*14+14,fontbigdigits_height,!fg,fontbigdigits_width,fontbigdigits_height,fontbigdigits_bits);

+        return;

+}

-	csize = ((oswald_fonts[face].width / 8) + ((oswald_fonts[face].width % 8) ? 1 : 0)) * oswald_fonts[face].height;

-	if (oswald_fonts[face].font_type == FONT_TYPE_PROPORTIONAL)

-		csize += 1; // at least 1px spacing

+void oswald_draw_line(const uint8_t xstart, const uint8_t ystart, const uint8_t xend, const uint8_t yend)

+{

+        int x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;

-	//csize += (oswald_fonts[face].height / 8) + ((oswald_fonts[face].height % 8) ? 1 : 0);

+        dx = xend - xstart;

+        dy = yend - ystart;

-	// g_printerr("fp = 0x%08lx cdata = 0x%08lx\n", font_7x12, cdata);

+        incx = (dx >= 0) ? 1 : -1;

+        incy = (dy >= 0) ? 1 : -1;

-	cdata = (cdata + ((int)csize * (int)Character));

+        if (dx<0)

+                dx = -dx;

+        if (dy<0)

+                dy = -dy;

-	//g_printerr("%02x\n", oswald_fonts[face].data[0][0]);

-	//g_printerr("char %02x face %d %dx%d csize %d\n", Character, face, oswald_fonts[face].width, oswald_fonts[face].height, csize);

-	//g_printerr("char %02x %02x %02x\n", (uint8_t)cdata[0], (uint8_t)cdata[1], (uint8_t)cdata[2]);

+        if (dx>dy) {

+                pdx = incx; pdy = 0;

+                ddx=incx; ddy=incy;

+                es =dy;   el =dx;

+        } else {

+                pdx=0;    pdy=incy;

+                ddx=incx; ddy=incy;

+                es =dx;   el =dy;

+        }

-	// oswald_draw_bitmap(x, y, oswald_fonts[face].height, oswald_fonts[face].height, cdata);

-	if (oswald_fonts[face].font_type == FONT_TYPE_MONOSPACE) {

-		cwidth = oswald_fonts[face].width;

-		//oswald_draw_bitmap(x, y, ((oswald_fonts[face].width / 8) + ((oswald_fonts[face].width % 8) ? 1 : 0)) * 8, oswald_fonts[face].height, (uint8_t *)cdata);

-		oswald_draw_bitmap_opts(x,y,0,0,((oswald_fonts[face].width / 8) + ((oswald_fonts[face].width % 8) ? 1 : 0)) * 8,oswald_fonts[face].height,invert,((oswald_fonts[face].width / 8) + ((oswald_fonts[face].width % 8) ? 1 : 0)) * 8,oswald_fonts[face].height,(uint8_t *)cdata);

-	} else if (oswald_fonts[face].font_type == FONT_TYPE_PROPORTIONAL) {

-		cwidth = cdata[0];

-		cdata++;

-		// oswald_draw_bitmap_size(x, y, (cwidth+1), oswald_fonts[face].height, ((oswald_fonts[face].width / 8) + ((oswald_fonts[face].width % 8) ? 1 : 0))*8, oswald_fonts[face].height, (uint8_t *)cdata);

-		oswald_draw_bitmap_opts(x,y,0,0,(cwidth+1),oswald_fonts[face].height,invert,((oswald_fonts[face].width / 8) + ((oswald_fonts[face].width % 8) ? 1 : 0))*8,oswald_fonts[face].height,(uint8_t *)cdata);

-	} else {

-		cwidth = 0;

-	}

-	// oswald_draw_bitmap_offset(x, y, (oswald_fonts[face].width % 8) > 0 ? (8-(oswald_fonts[face].width % 8)) : 0, 0, ((oswald_fonts[face].width / 8) + ((oswald_fonts[face].width % 8) ? 1 : 0))*8, oswald_fonts[face].height, cdata);

+        x = xstart;

+        y = ystart;

+        err = el/2;

+        hal_lcd_set_pixel(x, y, TRUE);

-	return cwidth;

+        for (t = 0; t < el; ++t) {

+                err -= es;

+                if (err < 0) {

+                        err += el;

+                        x += ddx;

+                        y += ddy;

+                } else {

+                        x += pdx;

+                        y += pdy;

+                }

+                hal_lcd_set_pixel(x, y, TRUE);

+        }

+}

+

+void oswald_draw_line_ww(const uint8_t xstart, const uint8_t ystart, const uint8_t xend, const uint8_t yend, const uint8_t thickness)

+{

+        int16_t i, x, y, t, dx, dy, incx, incy, pdx, pdy, ddx, ddy, es, el, err;

+

+        dx = xend - xstart;

+        dy = yend - ystart;

+

+        incx = (dx >= 0) ? 1 : -1;

+        incy = (dy >= 0) ? 1 : -1;

+

+        if (dx<0)

+                dx = -dx;

+        if (dy<0)

+                dy = -dy;

+

+        if (dx>dy) {

+                pdx = incx;

+                pdy = 0;

+                ddx = incx;

+                ddy = incy;

+                es = dy;

+                el = dx;

+        } else {

+                pdx = 0;

+                pdy = incy;

+                ddx = incx;