libg15render-1.3.0.svn316/0000755000175000017500000000000011236737054013457 5ustar catecatelibg15render-1.3.0.svn316/config/0000755000175000017500000000000011236737054014724 5ustar catecatelibg15render-1.3.0.svn316/doc/0000755000175000017500000000000011236737054014224 5ustar catecatelibg15render-1.3.0.svn316/src/0000755000175000017500000000000011236737054014246 5ustar catecatelibg15render-1.3.0.svn316/src/screen.c0000644000175000017500000000577011065756053015702 0ustar catecate/* This file is part of g15tools. g15tools 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. g15tools 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 g15lcd; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include "libg15render.h" /** * Retrieves the value of the pixel at (x, y) * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x X offset for pixel to be retrieved. * \param y Y offset for pixel to be retrieved. */ int g15r_getPixel (g15canvas * canvas, unsigned int x, unsigned int y) { if (x >= G15_LCD_WIDTH || y >= G15_LCD_HEIGHT) return 0; unsigned int pixel_offset = y * G15_LCD_WIDTH + x; unsigned int byte_offset = pixel_offset / BYTE_SIZE; unsigned int bit_offset = 7 - (pixel_offset % BYTE_SIZE); return (canvas->buffer[byte_offset] & (1 << bit_offset)) >> bit_offset; } /** * Sets the value of the pixel at (x, y) * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x X offset for pixel to be set. * \param y Y offset for pixel to be set. * \param val Value to which pixel should be set. */ void g15r_setPixel (g15canvas * canvas, unsigned int x, unsigned int y, int val) { if (x >= G15_LCD_WIDTH || y >= G15_LCD_HEIGHT) return; unsigned int pixel_offset = y * G15_LCD_WIDTH + x; unsigned int byte_offset = pixel_offset / BYTE_SIZE; unsigned int bit_offset = 7 - (pixel_offset % BYTE_SIZE); if (canvas->mode_xor) val ^= g15r_getPixel (canvas, x, y); if (canvas->mode_reverse) val = !val; if (val) canvas->buffer[byte_offset] = canvas->buffer[byte_offset] | 1 << bit_offset; else canvas->buffer[byte_offset] = canvas->buffer[byte_offset] & ~(1 << bit_offset); } /** * Clears the screen and fills it with pixels of color * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param color Screen will be filled with this color. */ void g15r_clearScreen (g15canvas * canvas, int color) { memset (canvas->buffer, (color ? 0xFF : 0), G15_BUFFER_LEN); } /** * Clears the screen and resets the mode values for a canvas * * \param canvas A pointer to a g15canvas struct */ void g15r_initCanvas (g15canvas * canvas) { memset (canvas->buffer, 0, G15_BUFFER_LEN); canvas->mode_cache = 0; canvas->mode_reverse = 0; canvas->mode_xor = 0; #ifdef TTF_SUPPORT if (FT_Init_FreeType (&canvas->ftLib)) printf ("Freetype couldnt initialise\n"); #endif } libg15render-1.3.0.svn316/src/pixel.c0000644000175000017500000004770311236737013015541 0ustar catecate/* This file is part of g15tools. g15tools 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. g15tools 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 g15lcd; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include #include #include #include #include "libg15render.h" void swap (int *x, int *y) { int tmp; tmp = *x; *x = *y; *y = tmp; } /** * The area with an upper left corner at (x1, y1) and lower right corner at (x2, y2) will be * filled with color if fill>0 or the current contents of the area will be reversed if fill==0. * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x1 Defines leftmost bound of area to be filled. * \param y1 Defines uppermost bound of area to be filled. * \param x2 Defines rightmost bound of area to be filled. * \param y2 Defines bottommost bound of area to be filled. * \param fill Area will be filled with color if fill != 0, else contents of area will have color values reversed. * \param color If fill != 0, then area will be filled if color == 1 and emptied if color == 0. */ void g15r_pixelReverseFill (g15canvas * canvas, int x1, int y1, int x2, int y2, int fill, int color) { int x = 0; int y = 0; for (x = x1; x <= x2; ++x) { for (y = y1; y <= y2; ++y) { if (!fill) color = !g15r_getPixel (canvas, x, y); g15r_setPixel (canvas, x, y, color); } } } /** * A 1-bit bitmap defined in colormap[] is drawn to the canvas with an upper left corner at (x1, y1) * and a lower right corner at (x1+width, y1+height). * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x1 Defines the leftmost bound of the area to be drawn. * \param y1 Defines the uppermost bound of the area to be drawn. * \param width Defines the width of the bitmap to be drawn. * \param height Defines the height of the bitmap to be drawn. * \param colormap An array containing width*height entries of value 0 for pixel off or != 0 for pixel on. */ void g15r_pixelOverlay (g15canvas * canvas, int x1, int y1, int width, int height, short colormap[]) { int i = 0; for (i = 0; i < (width * height); ++i) { int color = (colormap[i] ? G15_COLOR_BLACK : G15_COLOR_WHITE); int x = x1 + i % width; int y = y1 + i / width; g15r_setPixel (canvas, x, y, color); } } /** * A line of color is drawn from (px1, py1) to (px2, py2). * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param px1 X component of point 1. * \param py1 Y component of point 1. * \param px2 X component of point 2. * \param py2 Y component of point 2. * \param color Line will be drawn this color. */ void g15r_drawLine (g15canvas * canvas, int px1, int py1, int px2, int py2, const int color) { /* * Bresenham's Line Algorithm * http://en.wikipedia.org/wiki/Bresenham's_algorithm */ int steep = 0; if (abs (py2 - py1) > abs (px2 - px1)) steep = 1; if (steep) { swap (&px1, &py1); swap (&px2, &py2); } if (px1 > px2) { swap (&px1, &px2); swap (&py1, &py2); } int dx = px2 - px1; int dy = abs (py2 - py1); int error = 0; int y = py1; int ystep = (py1 < py2) ? 1 : -1; int x = 0; for (x = px1; x <= px2; ++x) { if (steep) g15r_setPixel (canvas, y, x, color); else g15r_setPixel (canvas, x, y, color); error += dy; if (2 * error >= dx) { y += ystep; error -= dx; } } } /** * Draws a box around the area bounded by (x1, y1) and (x2, y2). * * The box will be filled if fill != 0 and the sides will be thick pixels wide. * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x1 Defines leftmost bound of the box. * \param y1 Defines uppermost bound of the box. * \param x2 Defines rightmost bound of the box. * \param y2 Defines bottommost bound of the box. * \param color Lines defining the box will be drawn this color. * \param thick Lines defining the box will be this many pixels thick. * \param fill The box will be filled with color if fill != 0. */ void g15r_pixelBox (g15canvas * canvas, int x1, int y1, int x2, int y2, int color, int thick, int fill) { int i = 0; for (i = 0; i < thick; ++i) { g15r_drawLine (canvas, x1, y1, x2, y1, color); /* Top */ g15r_drawLine (canvas, x1, y1, x1, y2, color); /* Left */ g15r_drawLine (canvas, x2, y1, x2, y2, color); /* Right */ g15r_drawLine (canvas, x1, y2, x2, y2, color); /* Bottom */ x1++; y1++; x2--; y2--; } int x = 0, y = 0; if (fill) { for (x = x1; x <= x2; ++x) for (y = y1; y <= y2; ++y) g15r_setPixel (canvas, x, y, color); } } /** * Draws a circle centered at (x, y) with a radius of r. * * The circle will be filled if fill != 0. * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x Defines horizontal center of the circle. * \param y Defines vertical center of circle. * \param r Defines radius of circle. * \param fill The circle will be filled with color if fill != 0. * \param color Lines defining the circle will be drawn this color. */ void g15r_drawCircle (g15canvas * canvas, int x, int y, int r, int fill, int color) { int xx, yy, dd; xx = 0; yy = r; dd = 2 * (1 - r); while (yy >= 0) { if (!fill) { g15r_setPixel (canvas, x + xx, y - yy, color); g15r_setPixel (canvas, x + xx, y + yy, color); g15r_setPixel (canvas, x - xx, y - yy, color); g15r_setPixel (canvas, x - xx, y + yy, color); } else { g15r_drawLine (canvas, x - xx, y - yy, x + xx, y - yy, color); g15r_drawLine (canvas, x - xx, y + yy, x + xx, y + yy, color); } if (dd + yy > 0) { yy--; dd = dd - (2 * yy + 1); } if (xx > dd) { xx++; dd = dd + (2 * xx + 1); } } } /** * Draws a rounded box around the area bounded by (x1, y1) and (x2, y2). * * The box will be filled if fill != 0. * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x1 Defines leftmost bound of the box. * \param y1 Defines uppermost bound of the box. * \param x2 Defines rightmost bound of the box. * \param y2 Defines bottommost bound of the box. * \param fill The box will be filled with color if fill != 0. * \param color Lines defining the box will be drawn this color. */ void g15r_drawRoundBox (g15canvas * canvas, int x1, int y1, int x2, int y2, int fill, int color) { int y, shave = 3; if (shave > (x2 - x1) / 2) shave = (x2 - x1) / 2; if (shave > (y2 - y1) / 2) shave = (y2 - y1) / 2; if ((x1 != x2) && (y1 != y2)) { if (fill) { g15r_drawLine (canvas, x1 + shave, y1, x2 - shave, y1, color); for (y = y1 + 1; y < y1 + shave; y++) g15r_drawLine (canvas, x1 + 1, y, x2 - 1, y, color); for (y = y1 + shave; y <= y2 - shave; y++) g15r_drawLine (canvas, x1, y, x2, y, color); for (y = y2 - shave + 1; y < y2; y++) g15r_drawLine (canvas, x1 + 1, y, x2 - 1, y, color); g15r_drawLine (canvas, x1 + shave, y2, x2 - shave, y2, color); if (shave == 4) { g15r_setPixel (canvas, x1 + 1, y1 + 1, color == G15_COLOR_WHITE ? G15_COLOR_BLACK : G15_COLOR_WHITE); g15r_setPixel (canvas, x1 + 1, y2 - 1, color == G15_COLOR_WHITE ? G15_COLOR_BLACK : G15_COLOR_WHITE); g15r_setPixel (canvas, x2 - 1, y1 + 1, color == G15_COLOR_WHITE ? G15_COLOR_BLACK : G15_COLOR_WHITE); g15r_setPixel (canvas, x2 - 1, y2 - 1, color == G15_COLOR_WHITE ? G15_COLOR_BLACK : G15_COLOR_WHITE); } } else { g15r_drawLine (canvas, x1 + shave, y1, x2 - shave, y1, color); g15r_drawLine (canvas, x1, y1 + shave, x1, y2 - shave, color); g15r_drawLine (canvas, x2, y1 + shave, x2, y2 - shave, color); g15r_drawLine (canvas, x1 + shave, y2, x2 - shave, y2, color); if (shave > 1) { g15r_drawLine (canvas, x1 + 1, y1 + 1, x1 + shave - 1, y1 + 1, color); g15r_drawLine (canvas, x2 - shave + 1, y1 + 1, x2 - 1, y1 + 1, color); g15r_drawLine (canvas, x1 + 1, y2 - 1, x1 + shave - 1, y2 - 1, color); g15r_drawLine (canvas, x2 - shave + 1, y2 - 1, x2 - 1, y2 - 1, color); g15r_drawLine (canvas, x1 + 1, y1 + 1, x1 + 1, y1 + shave - 1, color); g15r_drawLine (canvas, x1 + 1, y2 - 1, x1 + 1, y2 - shave + 1, color); g15r_drawLine (canvas, x2 - 1, y1 + 1, x2 - 1, y1 + shave - 1, color); g15r_drawLine (canvas, x2 - 1, y2 - 1, x2 - 1, y2 - shave + 1, color); } } } } /** * Given a maximum value, and a value between 0 and that maximum value, calculate and draw a bar showing that percentage. * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x1 Defines leftmost bound of the bar. * \param y1 Defines uppermost bound of the bar. * \param x2 Defines rightmost bound of the bar. * \param y2 Defines bottommost bound of the bar. * \param color The bar will be drawn this color. * \param num Number of units relative to max filled. * \param max Number of units equal to 100% filled. * \param type Type of bar. 1=solid bar, 2=solid bar with border, 3 = solid bar with I-frame. */ void g15r_drawBar (g15canvas * canvas, int x1, int y1, int x2, int y2, int color, int num, int max, int type) { float len, length; if (max <= 0 || num < 0) return; if (num > max) num = max; if (type == 2) { y1 += 2; y2 -= 2; x1 += 2; x2 -= 2; } len = ((float) max / (float) num); length = (x2 - x1) / len; if (type == 1) { g15r_pixelBox (canvas, x1, y1 - type, x2, y2 + type, color ^ 1, 1, 1); g15r_pixelBox (canvas, x1, y1 - type, x2, y2 + type, color, 1, 0); } else if (type == 2) { g15r_pixelBox (canvas, x1 - 2, y1 - type, x2 + 2, y2 + type, color ^ 1, 1, 1); g15r_pixelBox (canvas, x1 - 2, y1 - type, x2 + 2, y2 + type, color, 1, 0); } else if (type == 3) { g15r_drawLine (canvas, x1, y1 - type, x1, y2 + type, color); g15r_drawLine (canvas, x2, y1 - type, x2, y2 + type, color); g15r_drawLine (canvas, x1, y1 + ((y2 - y1) / 2), x2, y1 + ((y2 - y1) / 2), color); } g15r_pixelBox (canvas, x1, y1, (int) ceil (x1 + length), y2, color, 1, 1); } /** * wbmp splash screen loader - assumes image is 160x43 * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param filename A string holding the path to the wbmp to be displayed. */ int g15r_loadWbmpSplash(g15canvas *canvas, char *filename) { int width=0, height=0; char *buf; buf = g15r_loadWbmpToBuf(filename, &width, &height); memcpy (canvas->buffer, buf, G15_BUFFER_LEN); return 0; } /** * Draw an icon to a canvas * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated in is found. * \param buf A pointer to the buffer holding the icon to be displayed. * \param my_x Leftmost boundary of image. * \param my_y Topmost boundary of image. * \param width Width of the image in buf. * \param height Height of the image in buf. */ void g15r_drawIcon(g15canvas *canvas, char *buf, int my_x, int my_y, int width, int height) { int y,x,val; unsigned int pixel_offset = 0; unsigned int byte_offset, bit_offset; //TODO:http://www.g15tools.com/forum/viewtopic.php?p=314#p314 // Does his new piece of code work? Is it better than below? If so, replace. for (y=0; y < height; y++) { for (x=0; x < width; x++) { pixel_offset = y * width + x; byte_offset = pixel_offset / BYTE_SIZE; bit_offset = 7 - (pixel_offset % BYTE_SIZE); val = (buf[byte_offset] & (1 << bit_offset)) >> bit_offset; g15r_setPixel (canvas, x + my_x, y + my_y, val); } } } /** * Draw a sprite to a canvas * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated in is found. * \param buf A pointer to the buffer holding a set of sprites. * \param my_x Leftmost boundary of image. * \param my_y Topmost boundary of image. * \param width Width of the sprite. * \param height Height of the sprite. * \param start_x X offset for reading sprite from buf. * \param start_y Y offset for reading sprite from buf. * \param total_width Width of the set of sprites held in buf. */ void g15r_drawSprite(g15canvas *canvas, char *buf, int my_x, int my_y, int width, int height, int start_x, int start_y, int total_width) { int y,x,val; unsigned int pixel_offset = 0; unsigned int byte_offset, bit_offset; for (y=0; y < height - 1; y++) for (x=0; x < width - 1; x++) { pixel_offset = (y + start_y) * total_width + (x + start_x); byte_offset = pixel_offset / BYTE_SIZE; bit_offset = 7 - (pixel_offset % BYTE_SIZE); val = (buf[byte_offset] & (1 << bit_offset)) >> bit_offset; g15r_setPixel (canvas, x + my_x, y + my_y, val); } } /** * basic wbmp loader - loads a wbmp image into a buffer. * * \param filename A string holding the path to the wbmp to be loaded. * \param img_width A pointer to an int that will hold the image width on return. * \param img_height A pointer to an int that will hold the image height on return. */ char * g15r_loadWbmpToBuf(char *filename, int *img_width, int *img_height) { int wbmp_fd; int retval; int x,y,val; char *buf; unsigned int buflen,header=4; unsigned char headerbytes[5]; unsigned int pixel_offset = 0; unsigned int byte_offset, bit_offset; wbmp_fd=open(filename,O_RDONLY); if(!wbmp_fd){ return NULL; } retval=read(wbmp_fd,headerbytes,5); if(retval){ if (headerbytes[2] & 1) { *img_width = ((unsigned char)headerbytes[2] ^ 1) | (unsigned char)headerbytes[3]; *img_height = headerbytes[4]; header = 5; } else { *img_width = headerbytes[2]; *img_height = headerbytes[3]; } int byte_width = *img_width / 8; if (*img_width %8) byte_width++; buflen = byte_width * (*img_height); buf = (char *)malloc (buflen); if (buf == NULL) return NULL; if (header == 4) buf[0]=headerbytes[4]; retval=read(wbmp_fd,buf+(5-header),buflen); close(wbmp_fd); } /* now invert the image */ for (y = 0; y < *img_height; y++) for (x = 0; x < *img_width; x++) { pixel_offset = y * (*img_width) + x; byte_offset = pixel_offset / BYTE_SIZE; bit_offset = 7 - (pixel_offset % BYTE_SIZE); val = (buf[byte_offset] & (1 << bit_offset)) >> bit_offset; if (!val) buf[byte_offset] = buf[byte_offset] | 1 << bit_offset; else buf[byte_offset] = buf[byte_offset] & ~(1 << bit_offset); } return buf; } /** * Draw a large number to a canvas * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x1 Defines leftmost bound of the number. * \param y1 Defines uppermost bound of the number. * \param x2 Defines rightmost bound of the number. * \param y2 Defines bottommost bound of the number. * \param color The number will be drawn this color. * \param num The number to be drawn. */ void g15r_drawBigNum (g15canvas * canvas, unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2, int color, int num) { x1 += 2; x2 -= 2; switch(num){ case 0: g15r_pixelBox (canvas, x1, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1 +5, y1 +5, x2 -5, y2 - 6, 1 - color, 1, 1); break; case 1: g15r_pixelBox (canvas, x2-5, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1, y1, x2 -5, y2, 1 - color, 1, 1); break; case 2: g15r_pixelBox (canvas, x1, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1, y1+5, x2 -5, y1+((y2/2)-3), 1 - color, 1, 1); g15r_pixelBox (canvas, x1+5, y1+((y2/2)+3), x2 , y2-6, 1 - color, 1, 1); break; case 3: g15r_pixelBox (canvas, x1, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1, y1+5, x2 -5, y1+((y2/2)-3), 1 - color, 1, 1); g15r_pixelBox (canvas, x1, y1+((y2/2)+3), x2-5 , y2-6, 1 - color, 1, 1); break; case 4: g15r_pixelBox (canvas, x1, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1, y1+((y2/2)+3), x2 -5, y2, 1 - color, 1, 1); g15r_pixelBox (canvas, x1+5, y1, x2-5 , y1+((y2/2)-3), 1 - color, 1, 1); break; case 5: g15r_pixelBox (canvas, x1, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1+5, y1+5, x2 , y1+((y2/2)-3), 1 - color, 1, 1); g15r_pixelBox (canvas, x1, y1+((y2/2)+3), x2-5 , y2-6, 1 - color, 1, 1); break; case 6: g15r_pixelBox (canvas, x1, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1+5, y1+5, x2 , y1+((y2/2)-3), 1 - color, 1, 1); g15r_pixelBox (canvas, x1+5, y1+((y2/2)+3), x2-5 , y2-6, 1 - color, 1, 1); break; case 7: g15r_pixelBox (canvas, x1, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1, y1+5, x2 -5, y2, 1 - color, 1, 1); break; case 8: g15r_pixelBox (canvas, x1, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1+5, y1+5, x2-5 , y1+((y2/2)-3), 1 - color, 1, 1); g15r_pixelBox (canvas, x1+5, y1+((y2/2)+3), x2-5 , y2-6, 1 - color, 1, 1); break; case 9: g15r_pixelBox (canvas, x1, y1, x2, y2 , color, 1, 1); g15r_pixelBox (canvas, x1+5, y1+5, x2-5 , y1+((y2/2)-3), 1 - color, 1, 1); g15r_pixelBox (canvas, x1, y1+((y2/2)+3), x2-5 , y2, 1 - color, 1, 1); break; case 10: g15r_pixelBox (canvas, x2-5, y1+5, x2, y1+10 , color, 1, 1); g15r_pixelBox (canvas, x2-5, y2-10, x2, y2-5 , color, 1, 1); break; case 11: g15r_pixelBox (canvas, x1, y1+((y2/2)-2), x2, y1+((y2/2)+2), color, 1, 1); break; case 12: g15r_pixelBox (canvas, x2-5, y2-5, x2, y2 , color, 1, 1); break; } } /** * Draw an XBM Image to the canvas * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated in is found. * \param data A pointer to the buffer holding the icon to be displayed. * \param width Width of the image in data. * \param height Height of the image in data. * \param pos_x Leftmost boundary of image. * \param pos_y Topmost boundary of image. */ void g15r_drawXBM (g15canvas *canvas, unsigned char* data, int width, int height, int pos_x, int pos_y) { int y = 0; int z = 0; unsigned char byte; int bytes_per_row = ceil ((double) width / 8); int bits_left = width; int current_bit = 0; for (y = 0; y < height; y++) { bits_left = width; for (z=0; z < bytes_per_row; z++) { byte = data[(y * bytes_per_row) + z]; current_bit = 0; while (current_bit < 8) { if (bits_left > 0) { if ((byte >> current_bit) & 1) { g15r_setPixel(canvas, (current_bit + (z*8) + pos_x),y + pos_y,G15_COLOR_BLACK); } bits_left--; } current_bit++; } } } } libg15render-1.3.0.svn316/src/text.c0000644000175000017500000005016411236737013015377 0ustar catecate/* This file is part of g15tools. g15tools 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. g15tools 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 g15lcd; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include "libg15render.h" #include #include #include static g15font *defaultfont[40]; /** Render a character in std large font * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param col size-dependent column to start rendering. * \param row size-dependent row to start rendering. * \param character ascii character to render. * \param sx horizontal top-left pixel location. * \param sy vertical top-left pixel location. */ void g15r_renderCharacterLarge (g15canvas * canvas, int col, int row, unsigned char character, unsigned int sx, unsigned int sy) { unsigned char buf[2]; buf[0]=character; buf[1]=0; g15r_G15FPrint (canvas, (char*)buf, ((col * 8) + sx), sy, G15_TEXT_LARGE, 0, G15_COLOR_BLACK, row); } /** Render a character in std medium font. * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param col size-dependent column to start rendering. * \param row size-dependent row to start rendering. * \param character ascii character to render. * \param sx horizontal top-left pixel location. * \param sy vertical top-left pixel location. */ void g15r_renderCharacterMedium (g15canvas * canvas, int col, int row, unsigned char character, unsigned int sx, unsigned int sy) { unsigned char buf[2]; buf[0]=character; buf[1]=0; g15r_G15FPrint (canvas, (char*)buf, ((col * 5) + sx), sy, G15_TEXT_MED, 0, G15_COLOR_BLACK, row); } /** Render a character in std small font. * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param col size-dependent column to start rendering. * \param row size-dependent row to start rendering. * \param character ascii character to render. * \param sx horizontal top-left pixel location. * \param sy vertical top-left pixel location. */ void g15r_renderCharacterSmall (g15canvas * canvas, int col, int row, unsigned char character, unsigned int sx, unsigned int sy) { unsigned char buf[2]; buf[0]=character; buf[1]=0; g15r_G15FPrint (canvas, (char*)buf, ((col * 4) + sx), sy, G15_TEXT_SMALL, 0, G15_COLOR_BLACK, row); } /** * Render a string in the designated size * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param stringOut An unsigned char pointer to the string which is to be printed. * \param row size-dependent row to start rendering. * \param size size of printed string. May be 0-3 for standard sizes, or 5-39 in pixel height. * \param sx horizontal top-left pixel location. * \param sy vertical top-left pixel location. */ void g15r_renderString (g15canvas * canvas, unsigned char stringOut[], int row, int size, unsigned int sx, unsigned int sy) { g15r_G15FPrint (canvas, (char*)stringOut, sx, sy, size, 0, G15_COLOR_BLACK, row); } #ifdef TTF_SUPPORT /** * Load a font for use with FreeType2 font support * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param fontname Absolute pathname to font file to be loaded. * \param fontsize Size in points for font to be loaded. * \param face_num Slot into which font face will be loaded. * \return 0 for success or FreeType2 errorcode. */ int g15r_ttfLoad (g15canvas * canvas, char *fontname, int fontsize, int face_num) { int errcode = 0; if (face_num < 0) face_num = 0; if (face_num > G15_MAX_FACE) face_num = G15_MAX_FACE; if (canvas->ttf_fontsize[face_num]) FT_Done_Face (canvas->ttf_face[face_num][0]); /* destroy the last face */ if (!canvas->ttf_fontsize[face_num] && !fontsize) canvas->ttf_fontsize[face_num] = 10; else canvas->ttf_fontsize[face_num] = fontsize; errcode = FT_New_Face (canvas->ftLib, fontname, 0, &canvas->ttf_face[face_num][0]); if (errcode) { canvas->ttf_fontsize[face_num] = 0; } else { if (canvas->ttf_fontsize[face_num] && FT_IS_SCALABLE (canvas->ttf_face[face_num][0])) errcode = FT_Set_Char_Size (canvas->ttf_face[face_num][0], 0, canvas->ttf_fontsize[face_num] * 64, 90, 0); } return errcode; } int calc_ttf_true_ypos (FT_Face face, int y, int ttf_fontsize) { if (!FT_IS_SCALABLE (face)) ttf_fontsize = face->available_sizes->height; y += ttf_fontsize * .75; return y; } int calc_ttf_totalstringwidth (FT_Face face, char *str) { FT_GlyphSlot slot = face->glyph; FT_UInt glyph_index; int i, errcode; unsigned int len = strlen (str); int width = 0; for (i = 0; i < len; i++) { glyph_index = FT_Get_Char_Index (face, str[i]); errcode = FT_Load_Glyph (face, glyph_index, 0); width += slot->advance.x >> 6; } return width; } int calc_ttf_centering (FT_Face face, char *str) { int leftpos; leftpos = 80 - (calc_ttf_totalstringwidth (face, str) / 2); if (leftpos < 1) leftpos = 1; return leftpos; } int calc_ttf_right_justify (FT_Face face, char *str) { int leftpos; leftpos = 160 - calc_ttf_totalstringwidth (face, str); if (leftpos < 1) leftpos = 1; return leftpos; } void draw_ttf_char (g15canvas * canvas, FT_Bitmap charbitmap, unsigned char character, int x, int y, int color) { FT_Int char_x, char_y, p, q; FT_Int x_max = x + charbitmap.width; FT_Int y_max = y + charbitmap.rows; static FT_Bitmap tmpbuffer; /* convert to 8bit format.. */ FT_Bitmap_Convert (canvas->ftLib, &charbitmap, &tmpbuffer, 1); for (char_y = y, q = 0; char_y < y_max; char_y++, q++) for (char_x = x, p = 0; char_x < x_max; char_x++, p++) if (tmpbuffer.buffer[q * tmpbuffer.width + p]) g15r_setPixel (canvas, char_x, char_y, color); } void draw_ttf_str (g15canvas * canvas, char *str, int x, int y, int color, FT_Face face) { FT_GlyphSlot slot = face->glyph; int i, errcode; unsigned int len = strlen (str); for (i = 0; i < len; i++) { errcode = FT_Load_Char (face, str[i], FT_LOAD_RENDER | FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO); draw_ttf_char (canvas, slot->bitmap, str[i], x + slot->bitmap_left, y - slot->bitmap_top, color); x += slot->advance.x >> 6; } } /** * Render a string with a FreeType2 font * * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param x initial x position for string. * \param y initial y position for string. * \param fontsize Size of string in points. * \param face_num Font to be used is loaded in this slot. * \param color Text will be drawn this color. * \param center Text will be centered if center == 1 and right justified if center == 2. * \param print_string Pointer to the string to be printed. */ void g15r_ttfPrint (g15canvas * canvas, int x, int y, int fontsize, int face_num, int color, int center, char *print_string) { if (canvas->ttf_fontsize[face_num]) { if (fontsize > 0 && FT_IS_SCALABLE (canvas->ttf_face[face_num][0])) { canvas->ttf_fontsize[face_num] = fontsize; int errcode = FT_Set_Pixel_Sizes (canvas->ttf_face[face_num][0], 0, canvas->ttf_fontsize[face_num]); if (errcode) printf ("Trouble setting the Glyph size!\n"); } y = calc_ttf_true_ypos (canvas->ttf_face[face_num][0], y, canvas->ttf_fontsize[face_num]); if (center == 1) x = calc_ttf_centering (canvas->ttf_face[face_num][0], print_string); else if (center == 2) x = calc_ttf_right_justify (canvas->ttf_face[face_num][0], print_string); draw_ttf_str (canvas, print_string, x, y, color, canvas->ttf_face[face_num][0]); } else { /* fall back to our default bitmap font */ g15r_G15FPrint (canvas, print_string, x, y, fontsize, center, color, 0); } } #endif /* TTF_SUPPORT */ /* G15Font Support */ /** * Load a g15 font from file. * \param filename string containing full name and location of font to load. * \return pointer to completed g15font structure. */ g15font * g15r_loadG15Font(char *filename) { FILE *file; g15font *font = calloc(1,sizeof(g15font)); unsigned char buffer[128]; int i; if(access(filename,F_OK)!=0) { fprintf(stderr,"loadG15Font: %s doesn't exist or has permissions problem.\n",filename); return NULL; } if(access(filename,R_OK)!=0) { fprintf(stderr,"loadG15Font: %s exists but cannot be read. Permissions problem?\n",filename); return NULL; } if(!(file=fopen(filename,"rb"))) return NULL; if(fread(buffer,G15_FONT_HEADER_SIZE,1,file)) { if(buffer[0] != 'G' || buffer[1] != 'F' || buffer[2] != 'N' || buffer[3] != 'T' ) { fclose(file); return NULL; } } else return NULL; font->font_height = buffer[4] | (buffer[5] << 8); font->ascender_height = buffer[6] | (buffer[7] << 8); font->lineheight = buffer[8] | (buffer[9] << 8); /* any future expansion that require more than one bit to be set should be recorded at the end of the file, */ /* with the extended-feature bit (not defined as yet, probably 1) set here */ /* The first byte of the extended packet should indicate the extension data type (none defined yet) */ /* The second byte should indicate length in bytes of the packet to read, not inclusive of these two bytes */ /* followed by the extended data. This should allow for a degree of backward compatibility between future versions */ /* should they arise. */ /* features = buffer[10] | (buffer[11] << 8) */ font->numchars = buffer[12] | (buffer[13] << 8); font->default_gap = buffer[14]; unsigned int current_alloc = 2048; char *glyphBuf = malloc(current_alloc); char *glyphPtr = glyphBuf; unsigned int memsize=0; for (i=0;i numchars; i++) { unsigned char charheader[G15_CHAR_HEADER_SIZE]; unsigned int character; fread(charheader, G15_CHAR_HEADER_SIZE, 1, file); character = charheader[0] | (charheader[1] << 8); font->glyph[character].width = charheader[2] | (charheader[3] << 8); memsize+=(font->font_height * ((font->glyph[character].width + 7) / 8)); if(memsize>current_alloc) { /* attempt to semi-coherently allocate additional memory */ current_alloc+=((font->font_height * ((font->glyph[character].width + 7) / 8)*(font->numchars - i))); glyphBuf = realloc(glyphBuf,(size_t)current_alloc); } font->glyph[character].buffer = (unsigned char*)glyphPtr; font->glyph[character].gap = 0; fread(font->glyph[character].buffer, font->font_height * ((font->glyph[character].width + 7) / 8), 1, file); font->active[character] = 1; glyphPtr+=(font->font_height * ((font->glyph[character].width + 7) / 8)); } fclose(file); return (font); } /** * Save g15font struct to given file. * \param oFilename string containing full name and location of font to save. * \param font g15font structure containing glyphs. Glyphs to be saved should have the corresponding active[glyph] set. * \return 0 on success, -1 on failure. */ int g15r_saveG15Font(char *oFilename, g15font *font) { FILE *f; unsigned int i; unsigned char fntheader[G15_FONT_HEADER_SIZE]; if(font==NULL) return -1; f = fopen(oFilename, "w+b"); if(f==NULL) return -1; font->numchars=0; for(i=0;iactive[i]) { font->numchars++; } } fntheader[0] = 'G'; fntheader[1] = 'F'; fntheader[2] = 'N'; fntheader[3] = 'T'; fntheader[4] = (unsigned char)font->font_height; fntheader[5] = (unsigned char)(font->font_height >> 8); fntheader[6] = (unsigned char)font->ascender_height; fntheader[7] = (unsigned char)(font->ascender_height >> 8); fntheader[8] = (unsigned char)font->lineheight; fntheader[9] = (unsigned char)(font->lineheight >> 8); /* any future expansion that require more than one bit to be set should be recorded at the end of the file, */ /* with the extended-feature bit (not defined as yet, probably 1) set here */ /* The first byte of the extended packet should indicate the extension data type (none defined yet) */ /* The second byte should indicate length in bytes of the packet to read, not inclusive of these two bytes */ /* followed by the extended data. This should allow for a degree of backward compatibility between future versions */ /* should they arise. */ fntheader[10] = 0; /* features */ fntheader[11] = 0; /* features >> 8 */ fntheader[12] = (unsigned char)font->numchars; fntheader[13] = (unsigned char)(font->numchars >> 8); fntheader[14] = (unsigned char)font->default_gap; fwrite (fntheader, G15_FONT_HEADER_SIZE, 1, f); for(i=0;iactive[i]) { unsigned char charheader[G15_CHAR_HEADER_SIZE]; charheader[0] = (unsigned char)i; charheader[1] = (unsigned char)(i >> 8); charheader[2] = (unsigned char)font->glyph[i].width; charheader[3] = (unsigned char)(font->glyph[i].width >> 8); fwrite(charheader,G15_CHAR_HEADER_SIZE,1,f); fwrite(font->glyph[i].buffer,font->font_height * ((font->glyph[i].width + 7) / 8),1,f); } } fclose(f); return 0; } /** * De-allocate memory associated with g15font struct, including glyph buffers * \param font g15font structure containing glyphs. */ void g15r_deleteG15Font(g15font*font){ if(font) { if(font->glyph_buffer!=NULL) free(font->glyph_buffer); free(font); } } /** * Calculate width (in pixels) of given string if rendered in font 'font'. * \param font Loaded g15font structure as returned by g15r_loadG15Font() * \param string Pointer to string for width calculations. * \return total width in pixels of given string. */ int g15r_testG15FontWidth(g15font *font,char *string){ int i; int totalwidth=0; if(font==NULL) return 0; font->glyph[32].gap = 0; for(i=0;iglyph[(int)string[i]].width + font->glyph[(int)string[i]].gap + font->default_gap; return totalwidth; } /** * Return g15font structure containing the default font at requested size * loading the font if needed. * \param integer pointsize argument in the range of 0-39 * \return pointer to g15font struct containing font at requested size or NULL if not valid. */ g15font * g15r_requestG15DefaultFont (int size) { char filename[128]; if (size<0) size=0; if (size>39) size=39; /* check if previously loaded, otherwise load it now */ if(!defaultfont[size]) { snprintf(filename,128,"%s/G15/default-%.2i.fnt",G15FONT_DIR,size); defaultfont[size] = g15r_loadG15Font(filename); if((defaultfont[size])==NULL) { fprintf(stderr,"libg15render: Unable to load font \"%s\"\n",filename); return NULL; } } return defaultfont[size]; } /** Render a character in given font. * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param font Loaded g15font structure as returned by g15r_loadG15Font() * \param character ascii character to render. * \param top_left_pixel_x horizontal top-left pixel location. * \param top_left_pixel_y vertical top-left pixel location. * \param colour desired colour of character when rendered. * \param paint_bg should the background of the character cell be painted? */ int g15r_renderG15Glyph(g15canvas *canvas, g15font *font,unsigned char character,int top_left_pixel_x, int top_left_pixel_y, int colour, int paint_bg) { int x,y,w,bp; if(font->glyph[character].buffer==NULL || font->active[character] == 0) return 0; unsigned char *buffer = font->glyph[character].buffer; unsigned int height = font->font_height; int i = 0; int bufferlen = height * ((font->glyph[character].width + 7) / 8); top_left_pixel_y-=font->font_height - font->ascender_height - 1 ; w = font->glyph[character].width + (7-(font->glyph[character].width % 8 )); if(font->glyph[character].width%8==0) w = font->glyph[character].width-1; x=0;y=0; if(paint_bg) g15r_pixelBox (canvas, top_left_pixel_x, top_left_pixel_y-1, top_left_pixel_x + font->glyph[character].width+font->default_gap, top_left_pixel_y + font->lineheight, colour^1, 1, 1); for (bp=0;bp w ) { x=0;y++; } x++; if(x<=font->glyph[character].width) { if( buffer[bp] & (0x80 >> i)) g15r_setPixel (canvas, top_left_pixel_x + x, top_left_pixel_y + y,colour); else if(paint_bg) g15r_setPixel (canvas, top_left_pixel_x + x, top_left_pixel_y + y,colour^1); } } } if(character!=32) return font->glyph[character].width + font->default_gap; else return font->glyph[character].width; } /** Render a string in given font. * \param canvas A pointer to a g15canvas struct in which the buffer to be operated on is found. * \param font Loaded g15font structure as returned by g15r_loadG15Font() * \param string Pointer to string to operate on. * \param row vertical font-dependent row to start printing on. can usually be left at 0 * \param sx horizontal top-left pixel location. * \param sy vertical top-left pixel location. * \param colour desired colour of character when rendered. * \param paint_bg if !0, pixels in the glyph background will also be painted, obstructing any image behind the text. */ void g15r_G15FontRenderString (g15canvas * canvas, g15font *font, char *string, int row, unsigned int sx, unsigned int sy, int colour, int paint_bg) { int i=0; int prevwidth=0; if(font==NULL) return; sy += ( font->lineheight * row ); for(i=0;i= 4, denotes height in pixels. if size<4, standard font sizes are used. * \param center Desired text justification. 0==left, 1==centered, 2==right justified. * \param colour desired colour of character when rendered. * \param row vertical font-dependent row to start printing on. can usually be left at 0 */ /* print string with the default G15Font, with on-demand loading of required sized bitmaps */ void g15r_G15FPrint (g15canvas *canvas, char *string, int x, int y, int size, int center, int colour, int row) { int xc, paint_bg; /* check if previously loaded, otherwise load it now */ if(g15r_requestG15DefaultFont(size)==NULL) return; if(size<3) { paint_bg=1; x-=1; y-=1; } else { paint_bg=0; } switch(center) { case 0: g15r_G15FontRenderString (canvas, defaultfont[size], string, row, x, y, colour, paint_bg); break; case 1: xc = g15r_testG15FontWidth(defaultfont[size],string); g15r_G15FontRenderString (canvas, defaultfont[size], string, row, 80-(xc/2),y, colour, paint_bg); break; case 2: xc = g15r_testG15FontWidth(defaultfont[size],string); g15r_G15FontRenderString (canvas, defaultfont[size], string, row, 160-xc,y, colour, paint_bg); break; } } libg15render-1.3.0.svn316/src/Makefile.am0000644000175000017500000000061711236737013016301 0ustar catecateLLIBDIR=@LIBDIR@ AM_CFLAGS=@CFLAGS@ DISTCLEANFILES = Makefile.in lib_LTLIBRARIES = libg15render.la libg15render_la_SOURCES = libg15render.h text.c pixel.c screen.c libg15render_la_LIBADD = @FTLIB@ libg15render_la_LDFLAGS = -version-info 2:0:1 include_HEADERS= libg15render.h bin_PROGRAMS = g15fontconvert g15fontconvert_SOURCES = g15fontconvert.c g15fontconvert_LDADD = libg15render.la @FTLIB@ libg15render-1.3.0.svn316/src/libg15render.h0000644000175000017500000002004311236737013016674 0ustar catecate#ifndef LIBG15RENDER_H_ #define LIBG15RENDER_H_ #ifdef __cplusplus extern "C" { #endif #include #ifdef HAVE_CONFIG_H #include "config.h" #endif #ifdef TTF_SUPPORT #include #include FT_FREETYPE_H #include FT_BITMAP_H #endif #define G15R_FONT_SUPPORT 1 #define G15R_FONT_API_V2 1 #define BYTE_SIZE 8 #define G15_BUFFER_LEN 1048 #define G15_LCD_OFFSET 32 #define G15_LCD_HEIGHT 43 #define G15_LCD_WIDTH 160 #define G15_COLOR_WHITE 0 #define G15_COLOR_BLACK 1 #define G15_TEXT_SMALL 0 #define G15_TEXT_MED 1 #define G15_TEXT_LARGE 2 #define G15_TEXT_HUGE 3 #define G15_PIXEL_NOFILL 0 #define G15_PIXEL_FILL 1 #define G15_MAX_FACE 5 #define G15_FONT_HEADER_SIZE 15 #define G15_CHAR_HEADER_SIZE 4 #define G15_MAX_GLYPH 256 #define G15_JUSTIFY_LEFT 0 #define G15_JUSTIFY_CENTER 1 #define G15_JUSTIFY_RIGHT 2 /** \brief This structure holds the data need to render objects to the LCD screen.*/ typedef struct g15canvas { /** g15canvas::buffer[] is a buffer holding the pixel data to be sent to the LCD.*/ unsigned char buffer[G15_BUFFER_LEN]; /** g15canvas::mode_xor determines whether xor processing is used in g15r_setPixel.*/ int mode_xor; /** g15canvas::mode_cache can be used to determine whether caching should be used in an application.*/ int mode_cache; /** g15canvas::mode_reverse determines whether color values passed to g15r_setPixel are reversed.*/ int mode_reverse; #ifdef TTF_SUPPORT FT_Library ftLib; FT_Face ttf_face[G15_MAX_FACE][sizeof (FT_Face)]; int ttf_fontsize[G15_MAX_FACE]; #endif } g15canvas; /** \brief Structure holding glyph data for g15render font types */ typedef struct g15glyph { /** g15glyph::buffer holds glyph data */ unsigned char *buffer; /** g15glyph::width - width of the glyph, without padding */ unsigned char width; /** g15glyph::gap - recommended gap between this character and the next */ unsigned char gap; }g15glyph; /** \brief Structure holding a single font. One g15font struct is needed per size. */ typedef struct g15font { /** g15font::font_height - total max height of font in pixels */ unsigned int font_height; /** g15font::ascender_height - height in pixels from baseline to the top pixel of an ascender character */ unsigned int ascender_height; /** g15font::lineheight - height in pixels from decender to ascender */ unsigned int lineheight; /** g15font::numchars - number of glyphs available in this font */ unsigned int numchars; /** g15font::glyph - contains all glyphs available in this font */ g15glyph glyph[G15_MAX_GLYPH]; // allow 256 chars.. ought to be enough for our purposes /** g15font::default_gap - default gap between glyphs (in pixels). */ unsigned int default_gap; /** g15font::active - each active glyph is set to 1 else 0 */ unsigned char active[G15_MAX_GLYPH]; /** g15font::glyph_buffer memory pool for glyphs */ char *glyph_buffer; }g15font; /** \brief Fills an area bounded by (x1, y1) and (x2, y2)*/ void g15r_pixelReverseFill (g15canvas * canvas, int x1, int y1, int x2, int y2, int fill, int color); /** \brief Overlays a bitmap of size width x height starting at (x1, y1)*/ void g15r_pixelOverlay (g15canvas * canvas, int x1, int y1, int width, int height, short colormap[]); /** \brief Draws a line from (px1, py1) to (px2, py2)*/ void g15r_drawLine (g15canvas * canvas, int px1, int py1, int px2, int py2, const int color); /** \brief Draws a box bounded by (x1, y1) and (x2, y2)*/ void g15r_pixelBox (g15canvas * canvas, int x1, int y1, int x2, int y2, int color, int thick, int fill); /** \brief Draws a circle centered at (x, y) with a radius of r*/ void g15r_drawCircle (g15canvas * canvas, int x, int y, int r, int fill, int color); /** \brief Draws a box with rounded corners bounded by (x1, y1) and (x2, y2)*/ void g15r_drawRoundBox (g15canvas * canvas, int x1, int y1, int x2, int y2, int fill, int color); /** \brief Draws a completion bar*/ void g15r_drawBar (g15canvas * canvas, int x1, int y1, int x2, int y2, int color, int num, int max, int type); /** \brief Draw a splash screen from 160x43 wbmp file*/ int g15r_loadWbmpSplash(g15canvas *canvas, char *filename); /** \brief Draw an icon to the screen from a wbmp buffer*/ void g15r_drawIcon(g15canvas *canvas, char *buf, int my_x, int my_y, int width, int height); /** \brief Draw a sprite to the screen from a wbmp buffer*/ void g15r_drawSprite(g15canvas *canvas, char *buf, int my_x, int my_y, int width, int height, int start_x, int start_y, int total_width); /** \brief Load a wbmp file into a buffer*/ char *g15r_loadWbmpToBuf(char *filename, int *img_width, int *img_height); /** \brief Draw a large number*/ void g15r_drawBigNum (g15canvas * canvas, unsigned int x1, unsigned int y1, unsigned int x2, unsigned int y2, int color, int num); /** \brief Draw an XBM image*/ void g15r_drawXBM (g15canvas *canvas, unsigned char* data, int width, int height, int pos_x, int pos_y); /** \brief Gets the value of the pixel at (x, y)*/ int g15r_getPixel (g15canvas * canvas, unsigned int x, unsigned int y); /** \brief Sets the value of the pixel at (x, y)*/ void g15r_setPixel (g15canvas * canvas, unsigned int x, unsigned int y, int val); /** \brief Fills the screen with pixels of color*/ void g15r_clearScreen (g15canvas * canvas, int color); /** \brief Clears the canvas and resets the mode switches*/ void g15r_initCanvas (g15canvas * canvas); /** \brief Renders a character in the large font at (x, y)*/ void g15r_renderCharacterLarge (g15canvas * canvas, int x, int y, unsigned char character, unsigned int sx, unsigned int sy); /** \brief Renders a character in the meduim font at (x, y)*/ void g15r_renderCharacterMedium (g15canvas * canvas, int x, int y, unsigned char character, unsigned int sx, unsigned int sy); /** \brief Renders a character in the small font at (x, y)*/ void g15r_renderCharacterSmall (g15canvas * canvas, int x, int y, unsigned char character, unsigned int sx, unsigned int sy); /** \brief Renders a string with font size in row*/ void g15r_renderString (g15canvas * canvas, unsigned char stringOut[], int row, int size, unsigned int sx, unsigned int sy); /** \brief Load G15 font and return it in g15font struct */ g15font * g15r_loadG15Font(char *filename); /** \brief Save font in font struct to given file, return 0 on success */ int g15r_saveG15Font(char *oFilename, g15font *font); /** \brief De-allocate memory associated with font */ void g15r_deleteG15Font(g15font*font); /** \brief Returns length (in pixels) of string if rendered in font 'font' */ int g15r_testG15FontWidth(g15font *font,char *string); /** \brief Returns g15font structure containing the default font at requested size if available */ g15font * g15r_requestG15DefaultFont (int size); /** \brief render glyph 'character' from loaded font struct 'font'. Returns width (in pixels) of rendered glyph */ int g15r_renderG15Glyph(g15canvas *canvas, g15font *font, unsigned char character, int top_left_pixel_x, int top_left_pixel_y, int colour, int paint_bg); /** \brief Render a string in font 'font' to canvas */ void g15r_G15FontRenderString (g15canvas * canvas, g15font *font, char *string, int row, unsigned int sx, unsigned int sy, int colour, int paint_bg); /** \brief Print a string using the G15 default font at size 'size' */ void g15r_G15FPrint (g15canvas *canvas, char *string, int x, int y, int size, int center, int colour, int row); #ifdef TTF_SUPPORT /** \brief Loads a font through the FreeType2 library*/ int g15r_ttfLoad (g15canvas * canvas, char *fontname, int fontsize, int face_num); /** \brief Prints a string in a given font*/ void g15r_ttfPrint (g15canvas * canvas, int x, int y, int fontsize, int face_num, int color, int center, char *print_string); #endif #ifdef __cplusplus } #endif #endif /*LIBG15RENDER_H_ */ libg15render-1.3.0.svn316/src/g15fontconvert.c0000644000175000017500000001634611236737013017303 0ustar catecate/* This file is part of g15tools. g15tools 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. g15tools 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 libg15render; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ #include "config.h" #include "libg15render.h" #include #include #include #ifdef TTF_SUPPORT #include #include FT_FREETYPE_H #include FT_BITMAP_H #endif #ifndef TTF_SUPPORT /* No truetype support */ int main(char *argv) { printf("g15fontconvert - libg15render has no FreeType support compiled in. This is required for the conversion program. Leaving now.\n"); return -1; } #else /* TrueType Support */ void packpixel(unsigned char *buffer, int width, int x, int y,int colour) { if(x<0) x=0; if(y<0) y=0; unsigned char c = 0x80 >> (x % 8); if(colour) buffer[width * y + (x / 8)] |= c; } FT_Library lib; int convertG15Font(char *inFilename, char *oFilename, int size, int gap){ FT_Face face; FT_GlyphSlot glyphslot; g15font *font = NULL; int i; int retval; retval = FT_New_Face(lib, inFilename, 0, &face); if(retval== FT_Err_Unknown_File_Format){ return -1; } else if(retval) { return -1; } glyphslot = face->glyph; if(FT_IS_SCALABLE(face)) { FT_Set_Char_Size(face, 0, size << 6, 80, 0); }else { printf("Bitmap Font has fixed height, ignoring requested size\n"); } font = malloc(sizeof(g15font)); font->font_height = (face->size->metrics.ascender >> 6) - (face->size->metrics.descender >> 6); font->ascender_height = face->size->metrics.ascender >> 6; font->lineheight = face->size->metrics.height >> 6; if(gap>-1) font->default_gap = gap; else font->default_gap = 1; if(font->font_height==0) { font->font_height = 2+(face->available_sizes->y_ppem>>6); /* */ printf("Font height unknown, guessing %i.\n",font->font_height - 1); } if(font->ascender_height==0) { font->ascender_height = font->font_height; face->size->metrics.ascender = font->font_height<<6; printf("modded ascender to %i\n", (int)face->size->metrics.ascender>>6); } if(face->size->metrics.descender==0) { face->size->metrics.descender = (font->font_height<<6) - (face->available_sizes->size) ; printf("modded descender to %i\n",(int)face->size->metrics.descender>>6); font->font_height = (face->size->metrics.ascender >> 6) + (face->size->metrics.descender >> 6); } if(font->lineheight==0) { printf("modded lineheight\n"); font->lineheight=font->font_height; } printf("Converting\n"); for(i=0;i<256;i++) { unsigned int glyph_index = FT_Get_Char_Index(face,i); retval = FT_Load_Glyph(face, glyph_index, FT_LOAD_DEFAULT|FT_LOAD_TARGET_MONO|FT_LOAD_NO_BITMAP); glyphslot = face->glyph; retval = FT_Render_Glyph(glyphslot, FT_RENDER_MODE_MONO); if(retval==0) { if(glyph_index>0) font->active[i]=1; else font->active[i]=0; int char_x, char_y; if(glyphslot->bitmap.width==0) glyphslot->bitmap.width = glyphslot->advance.x >> 6; font->glyph[i].width = glyphslot->bitmap.width; font->glyph[i].buffer = malloc(glyphslot->bitmap.width*font->font_height); memset(font->glyph[i].buffer,0,glyphslot->bitmap.width*font->font_height); unsigned char * bufPtr = glyphslot->bitmap.buffer; for ( char_y = 0; char_y < glyphslot->bitmap.rows; char_y++) { char y=(face->size->metrics.ascender >> 6) - (face->glyph->metrics.horiBearingY >> 6); for ( char_x = 0; char_x < glyphslot->bitmap.width; char_x++) { if((bufPtr[char_x / 8] >> (7 - char_x % 8)) & 1) packpixel(font->glyph[i].buffer,(glyphslot->bitmap.width+7)/8, char_x,char_y+y,1); } bufPtr += glyphslot->bitmap.pitch; } } } FT_Done_Face(face); if(g15r_saveG15Font(oFilename,font)<0) { printf("Problem saving font\n"); return -1; } printf("Font saved to %s\n",oFilename); g15r_deleteG15Font(font); return 0; } void helptext() { printf("g15fontconvert - (c) 2008 The G15Tools project\n"); printf(" -h\t--help\t\t\tThis helptext\n"); printf(" -s\t--size [size]\t\tSpecify size in pixels of desired font (default 10pixels high)\n"); printf(" -g\t--gap [gap]\t\tSpecify gap in pixels between characters (default 1pixel)\n"); printf(" -i\t--infile [filename]\tFilename of font to convert\n"); printf(" -o\t--outfile [filename]\tname of file to write (default to [infile].fnt\n"); exit(0); } int main(int argc, char **argv) { int i; int size = 10; int gap = -1; int have_infile=0; int have_outfile=0; char infile[128]; char outfile[128]; FT_Init_FreeType(&lib); if(argc<2) helptext(); for (i=0;i