Return to shzoom.c CVS log

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

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

1.1       root        1: #include <stdio.h>
                      2: #include <X/Xlib.h>
                      3: 
                      4: #include "wzoom.cursor"
                      5: #include "wzoom_mask.cursor"
                      6: 
                      7: #define ZOOMFACT 4   /* zoom factor relative to parent window */
                      8: 
                      9: #define MIN(a,b) (((a) < (b)) ? (a) : (b))
                     10: #define MAX(a,b) (((a) > (b)) ? (a) : (b))
                     11: 
                     12: static u_char *zimage = NULL;          /* pointer to storage */
                     13: static unsigned long zsize = 0;        /* current storage size */
                     14: static Bitmap wzmask = NULL;
                     15: static int xcur, ycur;
                     16: static int xnstatic = 0, ynstatic = 0;
                     17: static int xzoom = 0, yzoom = 0, f = 0;
                     18: 
                     19: updatezoom(wzoom, xzoomsize, yzoomsize,
                     20:           x, y, xsize, ysize, image, wzfactor)
                     21: 
                     22:     Window wzoom;              /* zoom window ID */
                     23:     int xzoomsize, yzoomsize;  /* zoom window size */
                     24:     register int x, y;         /* center coord for zoom */
                     25:     int xsize, ysize;          /* size of original image */
                     26:     unsigned char *image;      /* 8-bit image */
                     27:     int wzfactor;              /* parent window zoom factor */
                     28: 
                     29: {
                     30:     unsigned char *malloc(), *free();
                     31:     int i;
                     32:     register int j, xn = xnstatic, yn = ynstatic;
                     33: 
                     34:     if(x<0 || x>=xsize || y<0 || y>= ysize) return;
                     35: 
                     36: /* recalculate the storage needed for nearest larger zoomed pixel */
                     37:     if((f != ZOOMFACT * wzfactor) || (xzoom != xzoomsize) || 
                     38:        (yzoom != yzoomsize)) {
                     39:           f = ZOOMFACT * wzfactor;
                     40:           xn = xnstatic = xzoomsize/f + 1;
                     41:           yn = ynstatic = yzoomsize/f + 1;
                     42:           xzoom = xn*f; 
                     43:           yzoom = yn*f;
                     44:           xcur = (xzoom>>1) - wzoom_x_hot + ((f/ZOOMFACT)<<1);
                     45:           ycur = (yzoom>>1) - wzoom_y_hot + ((f/ZOOMFACT)<<1);
                     46:        }
                     47: 
                     48: /* check available storage space */
                     49:     if( (xzoom*yzoom) > zsize) {
                     50:        if(zimage != NULL) free(zimage);
                     51:        zsize = xzoom*yzoom;
                     52:        if((zimage = malloc(zsize)) == NULL) {
                     53:            fprintf(stderr,"Can't allocate zoom image buffer!\n");
                     54:            exit(1);
                     55:        }
                     56:     }
                     57: 
                     58:     replicate(x-xn/2,y-yn/2,xsize,ysize,image,f,
                     59:            0,0,xzoom,yzoom,zimage);
                     60: 
                     61:     if( (y-yn/2) < 0) 
                     62:       bzero(zimage,xzoom*f*(yn/2-y));
                     63:     if( (y-yn/2+yn) > ysize)
                     64:       bzero(zimage+xzoom*f*(ysize-y+yn/2),
                     65:            xzoom*f*(y-yn/2+yn-ysize));
                     66:     if( (x-xn/2) < 0)
                     67:       for(j=0;j<yzoom;j++) bzero(zimage+j*xzoom,f*(xn/2-x));
                     68:     if( (x-xn/2+xn) > xsize)
                     69:       for(j=0;j<yzoom;j++) bzero(zimage+j*xzoom+f*(xsize-x+xn/2),
                     70:                             f*(x-xn/2+xn-xsize));
                     71: 
                     72:     XPixmapBitsPutZ(wzoom,0,0,xzoom,yzoom,zimage,0,GXcopy,AllPlanes);
                     73: 
                     74:     if(wzmask == NULL) {
                     75:        wzmask = XStoreBitmap(wzoom_mask_width, wzoom_mask_height,
                     76:                              wzoom_mask_bits);
                     77:     }
                     78:     XBitmapBitsPut(wzoom, xcur, ycur,
                     79:                   wzoom_width, wzoom_height, wzoom_bits,
                     80:                   WhitePixel, BlackPixel, wzmask, GXcopy, AllPlanes);
                     81: }
                     82: 
                     83: replicate(x0,y0,w0,h0,from,f,x,y,w,h,to)
                     84: /* Fill array "to" with a piece of "from", each pixel mapping to fxf pixels */
                     85:      unsigned char *from, *to; /* Source array, destination array */
                     86:      int x0,y0,w0,h0;          /* Source origin, dimensions */
                     87:      int x,y,w,h;              /* Destination origin, dimensions */
                     88:      int f;                    /* Replication factor */
                     89: {
                     90:     register unsigned char *s, *d;
                     91:     register int k, n, i;
                     92:     int i0,i1,j0,j1,j;
                     93: 
                     94:     j0 = MAX(0,y0);
                     95:     j1 = MIN(h0,y0+(h-y)/f);
                     96:     i0 = MAX(0,x0);
                     97:     i1 = MIN(w0,x0+(w-x)/f);
                     98:     for(j=j0;j<j1;j++) {
                     99:        s = from + w0*j + i0;
                    100:        d = to + w*(f*(j-y0)+y) + x + f*(i0-x0);
                    101:        i = i1 - i0;
                    102:        n = f;
                    103:        while(i--) {
                    104:            k = n;
                    105:            while(k--) *d++ = *s;
                    106:            s++;
                    107:        }
                    108:        i = f-1;
                    109:        n = f*(i1-i0);
                    110:        s = d - f*(i1-i0);
                    111:        d = s + w;
                    112:        while(i--) {
                    113:            bcopy(s,d,n);
                    114:            d += w;
                    115:        }
                    116:     }
                    117: }
                    118: 

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