Return to shutil.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / new / X / showimg

Annotation of 43BSDTahoe/new/X/showimg/shutil.c, revision 1.1.1.1

1.1       root        1: /* split off some utility functions */
                      2: 
                      3: #include <stdio.h>
                      4: #include <X/Xlib.h>
                      5: 
                      6: #include "quad_arrow.cursor"
                      7: #include "quad_arrow_mask.cursor"
                      8: #include "pan.cursor"
                      9: #include "pan_mask.cursor"
                     10: #include "print.cursor"
                     11: #include "print_mask.cursor"
                     12: #include "zoom2.cursor"
                     13: #include "zoom2_mask.cursor"
                     14: #include "zoom4.cursor"
                     15: #include "zoom4_mask.cursor"
                     16: #include "pal.cursor"
                     17: #include "pal_mask.cursor"
                     18: 
                     19: #define MIN(a,b) (((a) < (b)) ? (a) : (b))
                     20: #define MAX(a,b) (((a) > (b)) ? (a) : (b))
                     21: 
                     22: #define SYNCINT 20
                     23: 
                     24: ipow( x, n)
                     25: register int x, n;
                     26: {
                     27:        register int p;
                     28:        for (p = 1; n > 0; --n)
                     29:                p *= x;
                     30:        return(p);
                     31: }
                     32: 
                     33: make_cursors(imcursor,pancursor,printcursor,zoom2cursor,zoom4cursor,
                     34:             palcursor)
                     35:       Cursor *imcursor, *pancursor, *printcursor;
                     36:       Cursor *zoom2cursor, *zoom4cursor, *palcursor;
                     37: {
                     38:       Cursor XCreateCursor();
                     39: 
                     40:      *imcursor = XCreateCursor(quad_arrow_width, quad_arrow_height,
                     41:                              quad_arrow_bits, 
                     42:                              quad_arrow_mask_bits,
                     43:                              quad_arrow_x_hot, quad_arrow_y_hot,
                     44:                              BlackPixel, WhitePixel, GXcopy);
                     45:      *pancursor = XCreateCursor(pan_width, pan_height,
                     46:                              pan_bits, 
                     47:                              pan_mask_bits,
                     48:                              pan_x_hot, pan_y_hot,
                     49:                              BlackPixel, WhitePixel, GXcopy);
                     50:      *printcursor = XCreateCursor(print_width, print_height,
                     51:                              print_bits, 
                     52:                              print_mask_bits,
                     53:                              print_x_hot, print_y_hot,
                     54:                              BlackPixel, WhitePixel, GXcopy);
                     55:      *zoom2cursor = XCreateCursor(zoom2_width, zoom2_height,
                     56:                              zoom2_bits, 
                     57:                              zoom2_mask_bits,
                     58:                              zoom2_x_hot, zoom2_y_hot,
                     59:                              BlackPixel, WhitePixel, GXcopy);
                     60:      *zoom4cursor = XCreateCursor(zoom4_width, zoom4_height,
                     61:                              zoom4_bits, 
                     62:                              zoom4_mask_bits,
                     63:                              zoom4_x_hot, zoom4_y_hot,
                     64:                              BlackPixel, WhitePixel, GXcopy);
                     65:      *palcursor = XCreateCursor(pal_width, pal_height,
                     66:                              pal_bits, 
                     67:                              pal_mask_bits,
                     68:                              pal_x_hot, pal_y_hot,
                     69:                              BlackPixel, WhitePixel, GXcopy);
                     70:      return;
                     71: }
                     72: 
                     73: /* write image pixels to the screen according to location, 
                     74:  * zoom factor
                     75:  */
                     76: writepix(wind, image, ncols, nrows, zoomfactor, x, y, width, height,
                     77:         xzero, yzero, mask,func,planes)
                     78:      Window wind;
                     79:      unsigned char *image;
                     80:      short ncols, nrows, zoomfactor, x, y, width, height, xzero, yzero;
                     81:      int mask, func, planes;
                     82: {
                     83:      unsigned char linebuf[8192];
                     84:      int j, k, l, minw, ldebug = 0;
                     85: 
                     86:      register unsigned char *byteimage, *line = linebuf;
                     87:      register int ncols_reg = ncols;
                     88:      register minwidth, maxy;
                     89:      register int i;
                     90: 
                     91:      minwidth = MIN((ncols_reg-x)<<zoomfactor, width);
                     92:      maxy = MIN(nrows<<zoomfactor, y+height);
                     93: 
                     94:      byteimage = image + ((yzero + y) * ncols_reg) + xzero + x;
                     95: 
                     96:      XSync(0);
                     97:      if(zoomfactor == 0) {
                     98:          for(i=y; i<maxy; i++) {
                     99:            XPixmapBitsPutZ(wind, x, i,
                    100:                minwidth, 1, byteimage, mask, func, planes);
                    101:            if((i % SYNCINT) == 0) XSync(0); 
                    102:            byteimage += ncols_reg;
                    103:          }
                    104:          return;
                    105:      } else {
                    106: 
                    107:        l = 1<<zoomfactor;
                    108: 
                    109:        /* adjust for odd pixels */
                    110:        width += x & (l-1);
                    111:        x -= x & (l-1);
                    112:        height += y & (l-1);
                    113:        y -= y & (l-1);
                    114:        if(width & (l-1))
                    115:         width = (width & ~(l-1)) + l;
                    116:        if(height & (l-1))
                    117:         height = (height & ~(l-1))+ l;
                    118: 
                    119:        minwidth = MIN((ncols_reg-(x>>zoomfactor))<<zoomfactor, width);
                    120:        maxy = MIN(nrows<<zoomfactor, y+height);
                    121:        minw = minwidth>>zoomfactor;
                    122: 
                    123:        byteimage = image + ((yzero + (y>>zoomfactor)) * ncols_reg)
                    124:                       + xzero + (x>>zoomfactor);
                    125: 
                    126:        for( j=y; j<maxy; j+=l) {
                    127:           for(k=0; k<minw; k++ ) 
                    128:               for(i=0; i<l; i++)
                    129:                   *line++ = byteimage[k];
                    130:            line = linebuf;
                    131:           for(i=0; i<l; i++) {
                    132:               if(j+i >= maxy) return;
                    133:                XPixmapBitsPutZ(wind, x, j+i, minwidth, 1, line,
                    134:                             mask, func, planes);
                    135:               if(((i+j) % SYNCINT) == 0) XSync(0); 
                    136:           }
                    137:           byteimage += ncols_reg;
                    138:        }
                    139:      }
                    140:      return;
                    141: }
                    142: 
                    143: 

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