home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / D / SVGALIB / SVGALIB1.TAR / svgalib / gl / text.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-12  |  4.8 KB  |  249 lines
  1. /* Framebuffer Graphics Libary for Linux, Copyright 1993 Harm Hanemaayer */
  2. /* text.c    Text writing and fonts */
  3.  
  4.  
  5. #include <stdlib.h>
  6. #include <vga.h>
  7. #include "inlstring.h"        /* include inline string operations */
  8.  
  9. #include "vgagl.h"
  10. #include "def.h"
  11.  
  12.  
  13.  
  14. /* Text/font functions */
  15.  
  16. static int initialized = 0;
  17. static int font_width = 8;
  18. static int font_height = 8;
  19. static char *font_address;
  20. static int font_charactersize = 64;
  21. static int font_writemode = WRITEMODE_OVERWRITE;
  22. static int compressed_font_bg = 0;
  23. static int compressed_font_fg = 15;
  24.  
  25. static void writecompressed( int x, int y, char *s );
  26.  
  27.  
  28. void gl_colorfont( int fw, int fh, int fg, void *_dp ) {
  29.     uchar *dp = _dp;
  30.     int i;
  31.     i = fw * fh * 256;
  32.     switch (BYTESPERPIXEL) {
  33.     case 1 :
  34.         while (i > 0) {
  35.             if (*dp)
  36.                 *dp = fg;
  37.             dp++;
  38.             i--;
  39.         }
  40.         break;
  41.     case 2 :
  42.         while (i > 0) {
  43.             if (*(ushort *)dp)
  44.                 *(ushort *)dp = fg;
  45.             dp += 2;
  46.             i--;
  47.         }
  48.         break;
  49.     case 3 :
  50.         while (i > 0) {
  51.             if (*(ushort *)dp || *(dp + 2)) {
  52.                 *(ushort *)dp = fg;
  53.                 *(dp + 2) = fg >> 16;
  54.             }
  55.             dp += 3;
  56.             i--;
  57.         }
  58.         break;
  59.     case 4 :
  60.         while (i > 0) {
  61.             if (*(int *)dp)
  62.                 *(int *)dp = fg;
  63.             dp += 4;
  64.             i--;
  65.         }
  66.         break;
  67.         
  68.     }
  69. }
  70.  
  71. void gl_setfont( int fw, int fh, void *font ) {
  72.     int i;
  73.     font_width = fw;
  74.     font_height = fh;
  75.     font_charactersize = font_width * font_height * BYTESPERPIXEL;
  76.     font_address = font;
  77. }
  78.  
  79. void gl_setwritemode( int m ) {
  80.     font_writemode = m;
  81. } 
  82.  
  83. void gl_write( int x, int y, char *s ) {
  84. /* clipping in putbox */
  85.     int i;
  86.     if (font_writemode & FONT_COMPRESSED) {
  87.         writecompressed(x, y, s);
  88.         return;
  89.     }
  90.     i = 0;
  91.     if (font_writemode == WRITEMODE_OVERWRITE) {
  92.         while (s[i] != 0) {
  93.             gl_putbox(x + i * font_width, y, font_width,
  94.                 font_height, font_address +
  95.                 (unsigned char)s[i] * font_charactersize);
  96.             i++;
  97.         }
  98.     }
  99.     else {    /* masked write */
  100.         while (s[i] != 0) {
  101.             gl_putboxmask(x + i * font_width, y, font_width, 
  102.                 font_height, font_address + 
  103.                 (unsigned char)s[i] * font_charactersize);
  104.             i++;
  105.         }
  106.     }
  107. }
  108.  
  109. void gl_writen( int x, int y, int n, char *s ) {
  110.     char *str = alloca(n + 1);
  111.     memcpy(str, s, n);
  112.     str[n] = 0;
  113.     gl_write(x, y, str);
  114. }
  115.  
  116. void gl_expandfont( int fw, int fh, int fg, void *_f1, void *_f2 ) {
  117. /* Convert bit-per-pixel font to byte(s)-per-pixel font */
  118.     uchar *f1 = _f1;
  119.     uchar *f2 = _f2;
  120.     int i, x, y, b;
  121.     for (i = 0; i < 256; i++) {
  122.         for (y = 0; y < fh; y++)
  123.             for (x = 0; x < fw; x++) {
  124.                 if (x % 8 == 0)
  125.                     b = *f1++;
  126.                 if (b & (128 >> (x % 8)))    /* pixel */
  127.                     switch (BYTESPERPIXEL) {
  128.                     case 1 :
  129.                         *f2 = fg;
  130.                         f2++;
  131.                         break;
  132.                     case 2 :
  133.                         *(ushort *)f2 = fg;
  134.                         f2 += 2;
  135.                         break;
  136.                     case 3 :
  137.                         *(ushort *)f2 = fg;
  138.                         *(f2 + 2) = fg >> 16;
  139.                         f2 += 3;
  140.                         break;
  141.                     case 4 :
  142.                         *(uint *)f2 = fg;
  143.                         f2 += 4;
  144.                     }
  145.                 else    /* no pixel */
  146.                     switch (BYTESPERPIXEL) {
  147.                     case 1 :
  148.                         *f2 = 0;
  149.                         f2++;
  150.                         break;
  151.                     case 2 :
  152.                         *(ushort *)f2 = 0;
  153.                         f2 += 2;
  154.                         break;
  155.                     case 3 :
  156.                         *(ushort *)f2 = 0;
  157.                         *(f2 + 2) = 0;
  158.                         f2 += 3;
  159.                         break;
  160.                     case 4 :
  161.                         *(uint *)f2 = 0;
  162.                         f2 += 4;
  163.                     }
  164.             }
  165.     }
  166. } 
  167.  
  168. static void expandcharacter( int bg, int fg, int c, unsigned char *bitmap ) {
  169.     int x, y;
  170.     unsigned char *font;
  171.     font = font_address + c * (font_height * (font_width + 7) / 8);
  172.  
  173.     for (y = 0; y < font_height; y++)
  174.         for (x = 0; x < font_width; x++) {
  175.             int b;
  176.             if (x % 8 == 0)
  177.                 b = *font++;
  178.             if (b & (128 >> (x % 8)))    /* pixel */
  179.                 switch (BYTESPERPIXEL) {
  180.                 case 1 :
  181.                     *bitmap = fg;
  182.                     bitmap++;
  183.                 break;
  184.                 case 2 :
  185.                     *(ushort *)bitmap = fg;
  186.                     bitmap += 2;
  187.                     break;
  188.                 case 3 :
  189.                     *(ushort *)bitmap = fg;
  190.                     *(bitmap + 2) = fg >> 16;
  191.                     bitmap += 3;
  192.                     break;
  193.                 case 4 :
  194.                     *(uint *)bitmap = fg;
  195.                     bitmap += 4;
  196.                 }
  197.             else    /* background pixel */
  198.                 switch (BYTESPERPIXEL) {
  199.                 case 1 :
  200.                     *bitmap = bg;
  201.                     bitmap++;
  202.                     break;
  203.                 case 2 :
  204.                     *(ushort *)bitmap = bg;
  205.                     bitmap += 2;
  206.                 break;
  207.                 case 3 :
  208.                     *(ushort *)bitmap = bg;
  209.                     *(bitmap + 2) = bg;
  210.                     bitmap += 3;
  211.                     break;
  212.                 case 4 :
  213.                     *(uint *)bitmap = bg;
  214.                     bitmap += 4;
  215.                 }
  216.         }
  217. }
  218.  
  219. /* Write using compressed font. */
  220.  
  221. static void writecompressed( int x, int y, char *s ) {
  222.     unsigned char *bitmap;
  223.     int i;
  224.     i = 0;
  225.     bitmap = alloca(font_width * font_height * BYTESPERPIXEL);
  226.     if (font_writemode == WRITEMODE_OVERWRITE) {
  227.         while (s[i] != 0) {
  228.             expandcharacter(compressed_font_bg,
  229.                 compressed_font_fg, s[i], bitmap);
  230.             gl_putbox(x + i * font_width, y, font_width,
  231.                 font_height, bitmap);
  232.             i++;
  233.         }
  234.     }
  235.     else {    /* masked write */
  236.         while (s[i] != 0) {
  237.             expandcharacter(0, compressed_font_fg, s[i], bitmap);
  238.             gl_putboxmask(x + i * font_width, y, font_width, 
  239.                 font_height, bitmap);
  240.             i++;
  241.         }
  242.     }
  243. }
  244.  
  245. void gl_setfontcolors( int bg, int fg ) {
  246.     compressed_font_bg = bg;
  247.     compressed_font_fg = fg;
  248. }
  249.