Return to XWrBitF.c CVS log

Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / X

Annotation of researchv9/X11/src/X.V11R1/lib/X/XWrBitF.c, revision 1.1.1.1

1.1       root        1: /* Copyright, 1987, Massachusetts Institute of Technology */
                      2: 
                      3: #include "copyright.h"
                      4: 
                      5: #include "Xlib.h"
                      6: #include "Xutil.h"
                      7: #include "Xlibint.h"
                      8: #include <stdio.h>
                      9: #include <strings.h>
                     10: 
                     11: #define ERR_RETURN 0
                     12: 
                     13: static char *Format_Image(image, resultsize)
                     14: XImage *image;
                     15: int *resultsize;
                     16: {
                     17:   register int x, c, b;
                     18:   register char *ptr;
                     19:   int y;
                     20:   char *data;
                     21:   int width, height;
                     22:   int bytes_per_line;
                     23: 
                     24:   width = image->width;
                     25:   height = image->height;
                     26: 
                     27:   bytes_per_line = (width+7)/8;
                     28:   *resultsize = bytes_per_line * height;           /* Calculate size of data */
                     29: 
                     30:   data = (char *) Xmalloc( *resultsize );           /* Get space for data */
                     31:   if (!data)
                     32:     return(ERR_RETURN);
                     33: 
                     34:   /*
                     35:    * The slow but robust brute force method of converting the image:
                     36:    */
                     37:   ptr = data;
                     38:   c = 0; b=1;
                     39:   for (y=0; y<height; y++) {
                     40:     for (x=0; x<width;) {
                     41:       if (XGetPixel(image, x, y))
                     42:        c |= b;
                     43:       b <<= 1;
                     44:       if (!(++x & 7)) {
                     45:        *(ptr++)=c;
                     46:        c=0; b=1;
                     47:       }
                     48:     }
                     49:     if (x & 7) {
                     50:       *(ptr++)=c;
                     51:       c=0; b=1;
                     52:     }
                     53:   }
                     54: 
                     55:   return(data);
                     56: }
                     57:    
                     58: #define BYTES_PER_OUTPUT_LINE 12
                     59: 
                     60: int XWriteBitmapFile(display, filename, bitmap, width, height, x_hot, y_hot)
                     61:      Display *display;
                     62:      char *filename;
                     63:      Pixmap bitmap;
                     64:      int width, height;
                     65:      int x_hot, y_hot;
                     66: {
                     67:   char *data, *ptr;
                     68:   int size, byte;
                     69:   int c;
                     70:   XImage *image;
                     71:   FILE *stream;
                     72:   char *name;
                     73: 
                     74:   if (!(name = rindex(filename, '/')))
                     75:     name = filename;
                     76:   else
                     77:     name++;
                     78: 
                     79:   if (!(stream = fopen(filename, "w")))
                     80:     return(BitmapOpenFailed);
                     81: 
                     82:   /* Convert bitmap to an image */
                     83:   image = XGetImage(display, bitmap, 0,0,width, height, 1L, XYPixmap);
                     84: 
                     85:   /* Get standard format for data */
                     86:   data = Format_Image(image, &size);
                     87:   XDestroyImage(image);
                     88:   if (!data) {
                     89:     fclose(stream);
                     90:     return(BitmapNoMemory);
                     91:   }
                     92: 
                     93:   /* Write out standard header */
                     94:   fprintf(stream, "#define %s_width %d\n", name, image->width);
                     95:   fprintf(stream, "#define %s_height %d\n", name, image->height);
                     96:   if (x_hot != -1) {
                     97:     fprintf(stream, "#define %s_x_hot %d\n", name, x_hot);
                     98:     fprintf(stream, "#define %s_y_hot %d\n", name, y_hot);
                     99:   }
                    100: 
                    101:   /* Print out the data itself */
                    102:   fprintf(stream, "static char %s_bits[] = {", name);
                    103:   for (byte=0, ptr=data; byte<size; byte++, ptr++) {
                    104:     if (!byte)
                    105:       fprintf(stream, "\n   ");
                    106:     else if (!(byte % BYTES_PER_OUTPUT_LINE))
                    107:       fprintf(stream, ",\n   ");
                    108:     else
                    109:       fprintf(stream, ", ");
                    110:     c = *ptr;
                    111:     if (c<0)
                    112:       c += 256;
                    113:     fprintf(stream, "0x%02x", c);
                    114:   }
                    115:   fprintf(stream, "};\n");
                    116: 
                    117:   Xfree(data);
                    118:   fclose(stream);
                    119:   return(BitmapSuccess);
                    120: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.