getx10.c File Reference

#include <stdio.h>
#include <math.h>
#include <X/Xlib.h>
#include "rle.h"

Include dependency graph for getx10.c:

Go to the source code of this file.

Macros
#define	MAXSEND   65535 /* 64K */
#define	arrow_width   16
#define	arrow_height   16
#define	arrow_x_hot   4
#define	arrow_y_hot   1
#define	arrow_mask_width   16
#define	arrow_mask_height   16
#define	DMAP(v, x, y)   (modN[v]>dm16[x][y] ? divN[v] + 1 : divN[v])

Functions
	main (argc, char **argv)
	get_pic (FILE *infile, char *infname, char *display_name, char *window_geometry)
	update_pic (use_pix)
	update_zoom ()
	create_window (width, height, window_geometry)
	map_scanline (rgb, n, s, y,*line)
	put_scanline (unsigned char *scan, width, x, y)
	map_rgb_to_bw (rle_pixel *red_row, rle_pixel *green_row, rle_pixel *blue_row, rle_pixel *bw_row, rle_pixel **map, rowlen)
	init_color ()
	load_x_map ()
	resize_zoom_window ()

Variables
static char	rcs_ident [] = "$Id: getx10.c,v 3.0.1.1 1992/01/28 18:12:35 spencer Exp $"
int	dm16 [16][16]
static short	arrow_bits []
static short	arrow_mask_bits []
Cursor	arrow_curs
Color	colmap [256]
int	gammamap [256]
rle_pixel **	in_cmap
int	modN [256]
int	divN [256]
int	bwflag = 0
int	levels = 0
int	levelsq
int	levelsc
rle_hdr	hdr
double	disp_gam = 2.5
double	img_gam = 1.0
int	iflag = 0
int	setbg = 0
int	mapflg = 0
int	usemap = 0
int	forkflg = 0
int	zoomflg = 0
Display *	dpy
Window	fbwin
Window	iconwin
Window	zoomwin
int	iconfact
int	iconrow
int	iconscan
int	iconbyte
int	zoomfact = 8
int	zoom_x_dim = 15
int	zoom_y_dim = 15
int	zoom_x_center
int	zoom_y_center
int	nscan
int	nrow
int	nbyte
int	dbg = 0
unsigned char *	buffer
unsigned char *	iconbuf

Macro Definition Documentation

#define arrow_height   16

Definition at line 47 of file getx10.c.

#define arrow_mask_height   16

Definition at line 56 of file getx10.c.

#define arrow_mask_width   16

Definition at line 55 of file getx10.c.

#define arrow_width   16

Definition at line 46 of file getx10.c.

#define arrow_x_hot   4

Definition at line 48 of file getx10.c.

#define arrow_y_hot   1

Definition at line 49 of file getx10.c.

#define DMAP	(		v,
			x,
			y
	)		(modN[v]>dm16[x][y] ? divN[v] + 1 : divN[v])

Definition at line 831 of file getx10.c.

#define MAXSEND   65535 /* 64K */

Definition at line 38 of file getx10.c.

Function Documentation

create_window	(	width	,
		height	,
		window_geometry
	)

Definition at line 756 of file getx10.c.

References nrow, nscan, zoom_x_dim, zoom_y_dim, zoomfact, and zoomflg.

{
    OpaqueFrame frame;
    char geometry[30];
    int zoomwidth, zoomheight;

    /* 
     * Now, make the window.
     */
    sprintf( geometry, "=%dx%d+0+0", nrow, nscan );
    frame.bdrwidth = 3;
    frame.border = WhitePixmap;
    frame.background = BlackPixmap;
    if ( (fbwin = XCreate( hdr.cmd, hdr.cmd, window_geometry, geometry,
               &frame, nrow, nscan )) == NULL )
    {
    fprintf( stderr, "%s: Window Create failed\n", hdr.cmd );
    exit( 1 );
    }
    XMapWindow( fbwin );
    XGetHardwareColor( &colmap[0] );    /* Assume black! */
    XPixSet( fbwin, 0, 0, width, height, colmap[0].pixel );
    XSetResizeHint( fbwin, width, height, 1, 1 );
    XSelectInput( fbwin, ButtonPressed|ButtonReleased|ExposeRegion );

    if (zoomflg)
    {
    arrow_curs = XCreateCursor(arrow_width,arrow_height,arrow_bits,
                 arrow_mask_bits, arrow_x_hot, arrow_y_hot,
                 BlackPixel, WhitePixel, GXcopy);
    XDefineCursor(fbwin,arrow_curs);
    }

    iconwin = XCreateWindow( RootWindow, 1, 1, 
                 width / iconfact, height / iconfact, 0, 0, 0 );
    XTileRelative( iconwin );
    XSetIconWindow( fbwin, iconwin );
    XSelectInput( iconwin, ButtonPressed|ButtonReleased|ExposeWindow );
    
    if (zoomflg)
    {
    zoomwidth = zoomfact * zoom_x_dim;
    zoomheight = zoomfact * zoom_y_dim;
    sprintf( geometry, "=%dx%d+0+0", zoomwidth, zoomheight );
    frame.bdrwidth = 3;
    frame.border = WhitePixmap;
    frame.background = BlackPixmap;
    if ( (zoomwin = XCreate( "getx10 zoom", hdr.cmd, window_geometry, 
                geometry,
                &frame, zoomwidth, zoomheight )) == NULL )
    {
        fprintf( stderr, "%s: Zoom window Create failed\n", hdr.cmd );
        exit( 1 );
    }
    resize_zoom_window();
    XMapWindow( zoomwin );
    XPixSet( zoomwin, 0, 0, zoomfact * zoom_x_dim, zoomfact * zoom_y_dim,
        colmap[0].pixel );
    XSetResizeHint( zoomwin, 0, 0, zoomfact, zoomfact );
    XSelectInput( zoomwin, ButtonPressed|ButtonReleased|ExposeRegion );
    XDefineCursor(zoomwin,arrow_curs);
    }
}

get_pic	(	FILE *	infile,
		char *	infname,
		char *	display_name,
		char *	window_geometry
	)

Definition at line 253 of file getx10.c.

{
    register int    i,
                    y;
    int         ncolors,
            xmin_original;
    unsigned char  *scan[3];

    /*
     * Read setup info from file. 
     */
    hdr.rle_file = infile;
    if ( !mapflg || usemap )
    rle_get_setup_ok(&hdr, NULL, NULL);

    if ( dbg )
    rle_debug( 1 );

    /* We're only interested in R, G, & B */
    RLE_CLR_BIT(hdr, RLE_ALPHA);
    for (i = 3; i < hdr.ncolors; i++)
    RLE_CLR_BIT(hdr, i);
    ncolors = hdr.ncolors > 3 ? 3 : hdr.ncolors;

    /*
     * Open display first time through. 
     */
    if (dpy == NULL)
    {
    dpy = XOpenDisplay(display_name);
    if (dpy == NULL)
    {
        fprintf(stderr, "%s: Can't open display %s\n",
            hdr.cmd, display_name ? "" : display_name);
        exit(1);
    }
    if ( DisplayPlanes() == 1 ) /* b&w display */
        bwflag = 2;
    }

    /* If no image gamma on command line, check comments in file */
    if ( ! iflag )
    {
    char * v;
    if ( (v = rle_getcom( "image_gamma", &hdr )) != NULL )
    {
        img_gam = atof( v );
        /* Protect against bogus information */
        if ( img_gam == 0.0 )
        img_gam = 1.0;
        else
        img_gam = 1.0 / img_gam;
    }
    else if ( (v = rle_getcom( "display_gamma", &hdr )) != NULL )
    {
        img_gam = atof( v );
        /* Protect */
        if ( img_gam == 0.0 )
        img_gam = 1.0;
    }
    }

    /*
     * Set up the color map. 
     */
    /* Input map, at least 3 channels */
    in_cmap = buildmap( &hdr, 3, img_gam, 1.0 );
    /* Get X color map */
    if ( usemap )
    load_x_map();
    else
    init_color();

    if ( mapflg )
    exit( 0 );

    /*
     * Compute image size and allocate storage. 
     */
    nrow = (hdr.xmax - hdr.xmin + 1);
    if ( bwflag == 2 )
    nbyte = ((nrow + 15) / 16) * 2; /* 1 bit display */
    else
    nbyte = nrow;
    nscan = (hdr.ymax - hdr.ymin + 1);
    buffer = (unsigned char *) malloc(nbyte * nscan);

    /*
     * Icon wants to be about 50 x 50.  Figure out how much smaller than the
     * image this is. 
     */
    iconfact = nrow / 50;
    if (iconfact < nscan / 50)
    iconfact = nscan / 50;
    if ( iconfact == 0 )
    iconfact = 1;
    iconrow = (1 + nrow / iconfact);
    iconscan = (1 + nscan / iconfact);
    if ( bwflag == 2 )
    {
    iconbuf = (unsigned char *)
        malloc(BitmapSize( (1 + nrow / iconfact),
                   (1 + nscan / iconfact) ));
    iconbyte = 2 * ((iconrow + 15) / 16);
    }
    else
    {
    iconbuf = (unsigned char *) malloc((1 + nrow / iconfact) *
                       (1 + nscan / iconfact));
    iconbyte = iconrow;
    }

    /*
     * Set up for rle_getrow.  Pretend image x origin is 0. 
     */
    for (i = 0; i < 3; i++)
    scan[i] = (unsigned char *) malloc(nrow);
    hdr.xmax -= hdr.xmin;
    xmin_original = hdr.xmin;
    hdr.xmin = 0;

    /*
     * Get a window of the right size (user positions it with the mouse). 
     */
    if ( setbg < 2 )
    create_window(nrow, nscan, window_geometry);

    /*
     * For each scan line, dither it and display. 
     */
    while ((y = rle_getrow(&hdr, scan)) <= hdr.ymax)
    {
    if ( bwflag && ncolors > 1 )
    {
        map_rgb_to_bw( scan[0], scan[1], scan[ncolors - 1], scan[0],
               in_cmap, nrow );
        /* Note: map_scanline only uses channel 0 for B&W */
    }
    else if ( bwflag )
        for ( i = 0; i < nrow; i++ )
        scan[0][i] = in_cmap[0][scan[0][i]];
    else
        for (i = 2; i >= ncolors; i--)
        bcopy(scan[0], scan[i], nrow);
    map_scanline(scan, nrow, 1, y,
             &buffer[(hdr.ymax - y) * nbyte]);
    /* Subsample image to create icon */
    if ( (hdr.ymax - y) % iconfact == 0 )
        map_scanline( scan, iconrow, iconfact,
              (hdr.ymax - y) / iconfact,
              &iconbuf[((hdr.ymax - y) / iconfact) *
                   iconbyte] );
        if ( setbg < 2 )
        put_scanline(&buffer[(hdr.ymax - y) * nbyte], nrow, 0,
             hdr.ymax - y );
    }
    /*
     * Free temp storage 
     */
    for (i = 0; i < 3; i++)
    free(scan[i]);

    hdr.xmin = xmin_original;
    hdr.xmax += xmin_original;
}

init_color

(

)

Definition at line 935 of file getx10.c.

References bwdithermap(), bwflag, rle_hdr::cmd, disp_gam, dithermap(), divN, dm16, hdr, levels, levelsc, levelsq, make_square(), and modN.

{
    int i, rgbmap[256][3], bwmap[256];
#ifdef DEBUG
    int j;
#endif

    if ( !bwflag )
    {
    /* 
     * Figure out how many color map entries we can get
     */
    if ( levels == 0 )
        levels = 6;     /* default starting point */
    for ( ; levels >= 2; levels-- )
        if ( levels*levels*levels < DisplayCells() )
        break;
    if ( levels < 2 )
    {
        fprintf(stderr,
            "%s: This display doesn't have enough color resolution.\
\nWill produce black and white image instead.\n", hdr.cmd );
        bwflag = 1;
        levels = 0;
    }
    /*
     * levels is the maximum number we can get.  Now we have to try to
     * actually acquire the color map entries.
     */
    while ( levels >= 2 )
    {
        levelsq = levels * levels;
        levelsc = levelsq * levels;

        dithermap( levels, disp_gam, rgbmap, divN, modN, dm16 );

        /* 
         * Set up the color map entries.  We don't yet know the location
         * in the map at which each will reside, so init it to 0.
         */
        for(i = 0; i < levelsc; i++) {
        colmap[i].pixel = 0;
        colmap[i].red = rgbmap[i][0] << 8;
        colmap[i].green = rgbmap[i][1] << 8;
        colmap[i].blue = rgbmap[i][2] << 8;
        }

        /* Get a color map entry for each color.  Assume enough exist! */
        for ( i = 0; i < levelsc; i++ )
        {
        if ( XGetHardwareColor( &colmap[i] ) == 0 )
            break;
        }

        /* Check if the colors are available */
        if ( i < levelsc )
        {
        levels--;
        /* Free the colors already obtained */
        for ( i--; i >= 0; i-- )
            XFreeColors( &colmap[i].pixel, 1, 0 );
        continue;
        }
        break;      /* succeeded */
    }
    if ( levels < 2 && bwflag == 0 )
    {
        fprintf( stderr,
             "%s: Sorry, not enough color map entries are available.\
\nWill make black & white image instead.\n", hdr.cmd );
        bwflag = 1;
        levels = 0;
    }
    }

    /* Get a B&W color map */
    if ( bwflag == 1 )
    {
    /* Try for lots of levels, give up by factors of 2 until success */
    if ( levels == 0 )
        if ( DisplayCells() > 16 )
        levels = DisplayCells() / 2;
        else
        levels = DisplayCells() - 4;    /* assume this many taken */
    for ( ; levels > 1; (levels > 16) ? (levels /= 2) : (levels -= 1) )
    {
        bwdithermap( levels, disp_gam, bwmap, divN, modN, dm16 );

        /* 
         * Set up the color map entries.  We don't yet know the location
         * in the map at which each will reside, so init it to 0.
         */
        for ( i = 0; i < levels; i++ )
        {
        colmap[i].pixel = 0;
        colmap[i].red = bwmap[i] << 8;
        colmap[i].green = colmap[i].red;
        colmap[i].blue = colmap[i].red;
        }

        /* Get a color map entry for each color.  Assume enough exist! */
        for ( i = 0; i < levels; i++ )
        {
        if ( XGetHardwareColor( &colmap[i] ) == 0 )
            break;
        }

        /* Check if the colors are available */
        if ( i < levels )
        {
        /* Free the colors already obtained */
        for ( i--; i >= 0; i-- )
            XFreeColors( &colmap[i].pixel, 1, 0 );
        continue;
        }
        break;      /* succeeded */
    }
    if ( levels < 2 )
        bwflag = 2;     /* use 1 bit dithering */
    else
        levelsc = levels;   /* remember full range */
    }

    /* If b&w 1-bit display, just use two colors */
    if ( bwflag == 2 )
    {
    /* All we care about, really, is the magic square */
    make_square( 255.0, divN, modN, dm16 );
    levels = levelsc = 2;
    }

#ifdef DEBUG
    printf( "Magic square for %d levels:\n", levels );
    for ( i = 0; i < 16; i++ )
    {
    for ( j = 0; j < 16; j++ )
        printf( "%4d", dm16[i][j] );
    printf( "\n" );
    }
    printf( "divN array:\n" );
    for ( i = 0; i < 256; i++ )
    printf( "%4d%s", divN[i], i % 16 == 15 ? "\n" : "" );
    printf( "modN array:\n" );
    for ( i = 0; i < 256; i++ )
    printf( "%4d%s", modN[i], i % 16 == 15 ? "\n" : "" );
#endif
}

Here is the call graph for this function:

load_x_map

(

)

Definition at line 1100 of file getx10.c.

References rle_hdr::cmaplen, disp_gam, hdr, in_cmap, and rle_getcom().

{
    int nmap = 0, i, j;
    char * mapcom;
    int gammamap[256];
    
    if ( (mapcom = rle_getcom( "color_map_length", &hdr )) )
    nmap = atoi( mapcom );
    if ( nmap == 0 )
    nmap = 1 << hdr.cmaplen;

    /* We won't be using in_cmap, so gamma correct it in place */
    for ( i = 0; i < 256; i++ )
    gammamap[i] = (int)(0.5 + 255 * pow( i / 255.0, 1.0/disp_gam ));

    for ( i = 0; i < nmap; i++ )
    for ( j = 0; j < 3; j++ )
        in_cmap[j][i] = gammamap[in_cmap[j][i]];

    /* 
     * Set up the color map entries.  We don't yet know the location
     * in the map at which each will reside, so init it to 0.
     */
    for(i = 0; i < nmap; i++) {
    colmap[i].pixel = 0;
    colmap[i].red = in_cmap[0][i] << 8;
    colmap[i].green = in_cmap[1][i] << 8;
    colmap[i].blue = in_cmap[2][i] << 8;
    if ( XGetHardwareColor( &colmap[i] ) == 0 )
    {
        fprintf( stderr,
        "%s: Sorry, need at least %d color map entries, only got %d.\n\
Will display image anyway.\n",
             hdr.cmd, nmap, i );
        break;
    }
    }
    for ( ; i < 256; i++ )
    colmap[i].pixel = 0;    /* for "undefined" colors */
}

Here is the call graph for this function:

main	(	argc	,
		char **	argv
	)

Definition at line 158 of file getx10.c.

{
    char ** infnames = NULL, *infname = NULL, *display_name = NULL,
    * window_geometry = NULL;
    FILE * infile = stdin;
    int nfile = 0, use_pix = 0,
    dflag = 0, gflag = 0, wflag = 0;

    if ( scanargs( argc, argv,
           "% Bb%- m%- f%- p%- cWw%- D%- n%-levels!d d%-display!s \n\
\t=%-window-geometry!s Ii%-gamma!F g%-gamma!F z%- file%s",
           &setbg, &mapflg, &forkflg, &use_pix, &bwflag, &dbg,
           &levels, &levels,
           &dflag, &display_name,
           &wflag, &window_geometry,
           &iflag, &img_gam,
           &gflag, &disp_gam,
           &zoomflg,
           &infname ) == 0 )
    exit( 1 );

    hdr = *rle_hdr_init( (rle_hdr *)NULL );
    rle_names( &hdr, cmd_name( argv ), infname );

    use_pix = ! use_pix;
    if ( setbg & !use_pix )
    {
    fprintf( stderr, "Can't specify -p with -b, -p ignored\n" );
    use_pix = 1;
    }
    if ( setbg == 2 )
    forkflg = 1;

    if ( iflag == 1 )       /* -i */
    img_gam = 1.0 / img_gam;

    if ( bwflag == 4 )      /* -c */
    {
    bwflag = 0;
    usemap = 1;
    }

    /* Would like to be able to use multiple files, but haven't
     * figured how to get X to let us.  So, use this kludge for now.
     */
    if ( infname != NULL )
    {
    infnames = &infname;
    nfile = 1;
    }

    /* 
     * For each file, display it.
     */
    do {
    if ( nfile > 0 )
    {
            infile = rle_open_f(hdr.cmd, *infnames, "r");
        get_pic( infile, *infnames, display_name,
             window_geometry );
        fclose( infile );
        infnames++;
        nfile--;
    }
    else
        get_pic( stdin, NULL, display_name,
             window_geometry );
    if ( ! forkflg )
    {
        if ( fork() == 0 )
        {
        /* 
         * Get rid of std fds so rshd will go
         * away.
         */
        close( 0 );
        close( 1 );
        close( 2 );
        update_pic( use_pix );
        break;
        }
    }
    else
    {
        update_pic( use_pix );
    }
    } while ( nfile > 0 );
    exit( 0 );
    /*  XCloseDisplay( dpy );*/
}

map_rgb_to_bw	(	rle_pixel *	red_row,
		rle_pixel *	green_row,
		rle_pixel *	blue_row,
		rle_pixel *	bw_row,
		rle_pixel **	map,
		rowlen
	)

Definition at line 903 of file getx10.c.

{
    register int x, bw;

    for (x=0; x<rowlen; x++)
    {
    /* 68000 won't store float > 127 into byte? */
    /* HP compiler blows it */
    bw = .35*map[0][red_row[x]] + .55*map[1][green_row[x]] +
        .10*map[2][blue_row[x]];
    bw_row[x] = bw;
    }
}

map_scanline	(	rgb	,
		n	,
		s	,
		y	,
		*	line
	)

Definition at line 833 of file getx10.c.

{
    register int i, col, row;

    if ( usemap )
    {
    register unsigned char *r;

    for ( r = rgb[0], i = 0; i < n; i++, r += s )
        line[i] = colmap[*r].pixel;
    }
    else if ( !bwflag )
    {
    register unsigned char *r, *g, *b;
    for ( row = y % 16, col = 0, i = 0, r = rgb[0], g = rgb[1], b = rgb[2];
          i < n; i++, r+=s, g+=s, b+=s, col = ((col + 1) & 15) )
        line[i] = colmap[DMAP(in_cmap[0][*r], col, row) +
                 DMAP(in_cmap[1][*g], col, row) * levels +
                 DMAP(in_cmap[2][*b], col, row) * levelsq].pixel;
    }
    else if ( bwflag == 1 ) /* gray scale display */
    {
    register unsigned char *r;

    for ( row = y % 16, col = 0, i = 0, r = rgb[0];
          i < n; i++, r+=s, col = ((col + 1) & 15) )
        line[i] = colmap[DMAP(*r, col, row)].pixel;
    }
    else            /* bitmap display */
    {
    register unsigned short *l = (unsigned short *)line;
    register unsigned char * r;

    for ( row = y % 16, col = 0, i = 0, r = rgb[0], *l = 0;
          i < n; r+=s, col = ((col + 1) & 15) )
    {
        *l |= (*r > dm16[col][row] ? 1 : 0) << (i % 16);
        if ( (++i % 16) == 0 && i < n )
        *++l = 0;
    }
    }
}

put_scanline	(	unsigned char *	scan,
		width	,
		x	,
		y
	)

Definition at line 877 of file getx10.c.

{
    if ( bwflag != 2 )
    XPixmapBitsPutZ( fbwin, x, y, width, 1, scan, 0, GXcopy, AllPlanes );
    else
    XBitmapBitsPut( fbwin, x, y, width, 1, scan, 1, 0, 0, GXcopy,
            AllPlanes );
}

resize_zoom_window

(

)

Definition at line 1141 of file getx10.c.

References zoom_x_dim, zoom_y_dim, and zoomfact.

{
    WindowInfo info;
    int xs, ys;

    XQueryWindow( zoomwin, &info );

    /* truncate to multiple of zoomfact */
    xs = zoomfact * ( info.width / zoomfact );
    ys = zoomfact * ( info.height / zoomfact );

    if ( xs != info.width || ys != info.height )
    XChangeWindow( zoomwin, xs, ys );

    zoom_x_dim = xs / zoomfact;
    zoom_y_dim = ys / zoomfact;
}

update_pic

(

use_pix

)

Definition at line 425 of file getx10.c.

References bwflag, nbyte, nrow, nscan, setbg, zoom_x_center, zoom_y_center, and zoomflg.

{
    int             i,
                    npix,
                    pixscan,
                    lastscan,
                    gotpix;
    long            bufsize,
                    pixsize;
    XEvent          rep;
    XButtonEvent xkey;
    XExposeEvent    xex;
    int zoom_x_press, zoom_y_press;

    Pixmap(*pix)[] = 0;
    Bitmap bm;

    if (zoomflg)
    {
    zoom_x_center = nrow / 2;
    zoom_y_center = nscan / 2;
    update_zoom();
    }

    /*
     * If requested, use off screen pixmap to speed image redisplay. Need to
     * allocate it in slices, since can't write whole image to X at once. 
     */
    if (use_pix)
    {
    npix = 1 + (nscan * nbyte) / MAXSEND;
    pixscan = MAXSEND / nbyte;
    pixsize = pixscan * nbyte;
    lastscan = nscan % pixscan;

    pix = (Pixmap(*)[]) malloc(npix * sizeof(Pixmap));
    for (i = 0; i < npix; i++)
        if ( bwflag != 2 )
        (*pix)[i] = XStorePixmapZ(nrow,
                      (i == npix - 1) ? lastscan : pixscan,
                      &buffer[i * nrow * pixscan]);
        else
        {
         bm = XStoreBitmap(nrow,
                   (i == npix - 1) ? lastscan : pixscan,
                   &buffer[i * nbyte * pixscan]);
         (*pix)[i] = XMakePixmap( bm, 1, 0 );
         XFreeBitmap( bm );
         }
    }

    if ( setbg )
    {
    XChangeBackground( RootWindow, (*pix)[0] );
    XClear( RootWindow );
    XFlush();
        if ( setbg == 2 )
            exit( 0 );
    }

    /*
     * Basic event loop:  handle expose events on window & icon, and exit on
     * (shifted) mouse button event. 
     */
    for (;;)
    {
    XNextEvent(&rep);
    if (rep.type == ButtonPressed)
    {
        xkey = *(XButtonEvent *) &rep;
        if (zoomflg && (xkey.window == fbwin))
        {
        zoom_x_press = xkey.x;
        zoom_y_press = xkey.y;
        }
    }
    else if (rep.type == ButtonReleased)
    {
        xkey = *(XButtonEvent *) &rep;
        if ( xkey.detail & ShiftMask )
        {
        if (zoomflg && (xkey.window == zoomwin))
        {
            /* get rid of just zoom window if shiftclicked */
            XDestroyWindow(zoomwin);
            zoomflg = 0;
        }
        else
        {
            /* Shiftclick in fbwin means exit. */
            break;
        }
        }
        if (zoomflg && (xkey.window == fbwin))
        {
        zoom_x_center = xkey.x;
        zoom_y_center = xkey.y;
        if ((zoom_x_center != zoom_x_press) &&
            (zoom_y_center != zoom_y_press))
        {
            /* drag to define zoom region */
            if (zoom_x_press < zoom_x_center)
            {
            zoom_x_dim = (zoom_x_center - zoom_x_press);
            zoom_x_center = zoom_x_press + (zoom_x_dim / 2);
            }
            else
            {
            zoom_x_dim = (zoom_x_press - zoom_x_center);
            zoom_x_center = zoom_x_center + (zoom_x_dim / 2);
            }
            if (zoom_y_press < zoom_y_center)
            {
            zoom_y_dim = (zoom_y_center - zoom_y_press);
            zoom_y_center = zoom_y_press + (zoom_y_dim / 2);
            }
            else
            {
            zoom_y_dim = (zoom_y_press - zoom_y_center);
            zoom_y_center = zoom_y_center + (zoom_y_dim / 2);
            }
            XChangeWindow(zoomwin, zoomfact * zoom_x_dim, 
                  zoomfact * zoom_y_dim);
            XSetResizeHint( zoomwin, 0, 0, zoomfact, zoomfact );
        }
        update_zoom();
        }
        else if (zoomflg && (xkey.window == zoomwin))
        {
        if (xkey.detail & RightMask)
        {
            /* increase zoom factor */
            zoomfact += 1;
            XChangeWindow(zoomwin, zoomfact * zoom_x_dim, 
                  zoomfact * zoom_y_dim);
            XSetResizeHint( zoomwin, 0, 0, zoomfact, zoomfact );
        }
        else if (xkey.detail & LeftMask)
        {
            /* decrease zoom factor */
            if (zoomfact > 1)
            {
            zoomfact -= 1;
            XChangeWindow(zoomwin, zoomfact * zoom_x_dim, 
                      zoomfact * zoom_y_dim);
            XSetResizeHint( zoomwin, 0, 0, zoomfact, zoomfact );
            }
        }
        else if (xkey.detail & MiddleMask)
        {
            if (forkflg)
            {
            /* can only report pixel status when not forking */
            fprintf(stderr, "Position: (%d, %d)\n",
                hdr.xmin +
                xkey.x / zoomfact + (zoom_x_center 
                             - (zoom_x_dim / 2)), 
                (hdr.ymax 
                 - xkey.y / zoomfact 
                 - (zoom_y_center - (zoom_y_dim / 2))));
            fprintf(stderr, "Image crop: (%d, %d) to (%d, %d)\n",
                hdr.xmin, hdr.ymin,
                hdr.xmax, hdr.ymax);
            fprintf(stderr, "Zoom crop: (%d, %d) to (%d, %d)\n",
                hdr.xmin + 
                (zoom_x_center - (zoom_x_dim / 2)), 
                (hdr.ymax - (zoom_y_dim - 1) 
                 - (zoom_y_center - (zoom_y_dim / 2))),
                hdr.xmin + (zoom_x_dim - 1)
                + (zoom_x_center - (zoom_x_dim / 2)),
                (hdr.ymax
                 - (zoom_y_center - (zoom_y_dim / 2))));


            }
        }
        }
    }
    else if (rep.type == ExposeWindow || rep.type == ExposeRegion)
    {
        xex = *((XExposeEvent *) & rep);
        /*
         * For icon exposure, just redraw whole thing - it's quick and
         * much easier. 
         */
        if (xex.window == iconwin)
        if ( bwflag != 2 )
            XPixmapBitsPutZ(iconwin, 0, 0, iconrow, iconscan,
                    iconbuf, 0, GXcopy, AllPlanes);
        else
            XBitmapBitsPut(iconwin, 0, 0, iconrow, iconscan,
                   iconbuf, 1, 0, 0, GXcopy, AllPlanes);
        else if (zoomflg && (xex.window == zoomwin))
        {
        resize_zoom_window();
        update_zoom();
        }
        else
        {
        /*
         * If window has been resized (bigger), don't bother redrawing
         * the area outside the image. 
         */
        if (xex.y + xex.height >= nscan)
            xex.height = nscan - xex.y;
        /*
         * If bitmap, round beginning pixel to beginning of word
         */
        if ( bwflag == 2 )
        {
            xex.width += xex.x; /* remember ending pixel */
            xex.x = (xex.x / 16) * 16;  /* round down */
            xex.width -= xex.x; /* new width */
        }
        if (xex.x + xex.width >= nrow)
            xex.width = nrow - xex.x;
        /*
         * If no pixmap, do it the slow way. 
         */
        if (pix == 0)
            if ( bwflag == 2 )
            for (i = xex.y; i < xex.y + xex.height; i++)
                put_scanline( &buffer[i * nbyte + xex.x / 8],
                      xex.width, xex.x, i );
            else
            for (i = xex.y; i < xex.y + xex.height; i++)
                put_scanline( &buffer[i * nbyte + xex.x],
                      xex.width, xex.x, i );
        else
        {
            /*
             * Pixmaps exist, figure out how many slices are affected
             * and which portion of each. 
             */
            int             start = xex.y / pixscan,
                            end = (xex.y + xex.height) / pixscan,
                            y = xex.y,
                            ytop;
            register int    j;

            for (i = start; i <= end; i++)
            {
            ytop = (i == end) ? xex.y + xex.height
                : (i + 1) * pixscan;
            /*
             * if this slice has a pixmap, blit it.  If not, do it
             * slow from the buffer. 
             */
            if ((*pix)[i] != 0)
                XPixmapPut(fbwin, xex.x, y - i * pixscan,
                       xex.x, y,
                       xex.width, ytop - y, (*pix)[i],
                       GXcopy, AllPlanes);
            else
                if ( bwflag == 2 )
                for (j = y; j < ytop; j++)
                    put_scanline( &buffer[j * nbyte +
                              xex.x / 8],
                          xex.width, xex.x, j );
                else
                for (j = y; j < ytop; j++)
                    put_scanline( &buffer[j * nbyte + xex.x],
                          xex.width, xex.x, j );
            y = ytop;
            }
        }
        }
    }
    else if ( rep.type != ButtonPressed )
        fprintf(stderr, "%s: Event type %x?\n", hdr.cmd, rep.type);
    }

    /*
     * Window goes away when we do. 
     */
    XDestroyWindow(fbwin);
    if (zoomflg) XDestroyWindow(zoomwin);
}

update_zoom

(

)

Definition at line 704 of file getx10.c.

References buffer, bwflag, nbyte, nrow, nscan, zoom_x_center, zoom_x_dim, zoom_y_center, zoom_y_dim, and zoomfact.

{
    unsigned char the_pix;
    int i,j;
    int zoomx, zoomy;
    int x_bottom, x_top;
    int y_bottom, y_top;
    int zoom_x_corner, zoom_y_corner;

    x_bottom = zoom_x_center - (zoom_x_dim / 2);
    x_top = x_bottom + zoom_x_dim - 1;
    y_bottom = zoom_y_center - (zoom_y_dim / 2);
    y_top = y_bottom + zoom_y_dim - 1;

    for (j=y_bottom; j<=y_top; j++)
    {
    zoom_y_corner = (j - y_bottom) * zoomfact;
    if ((j < 0) || (j >= nscan))
    {
        /* dump a blank line */
        XPixSet( zoomwin, 0, zoom_y_corner, zoomfact * zoom_x_dim, 
            zoomfact, colmap[0].pixel );
    }
    else
    {
        for ( i= x_bottom; i<=x_top; i++)
        {
        zoom_x_corner = (i - x_bottom) * zoomfact;
        if ((i < 0) || (i >= nrow))
        {
            /* dump a black pixel */
            XPixSet( zoomwin, zoom_x_corner, zoom_y_corner,
                zoomfact, zoomfact, colmap[0].pixel );
        }
        else
        {
            if ( bwflag != 2 )
            the_pix = buffer[j * nbyte + i];
            else
            the_pix = buffer[j * nbyte + i/8] & (1 << (i % 8)) ?
                1 : 0;
            XPixSet( zoomwin, zoom_x_corner, zoom_y_corner,
                zoomfact, zoomfact, the_pix );
        }
        }
    }
    }
}

Variable Documentation

short arrow_bits[]

static

Initial value:

= {
   0x0000, 0x0010, 0x0030, 0x0070,
   0x00f0, 0x01f0, 0x03f0, 0x07f0,
   0x0ff0, 0x01f0, 0x03b0, 0x0310,
   0x0700, 0x0600, 0x0600, 0x0000}

Definition at line 50 of file getx10.c.

Cursor arrow_curs

Definition at line 62 of file getx10.c.

short arrow_mask_bits[]

static

Initial value:

= {
   0x0018, 0x0038, 0x0078, 0x00f8,
   0x01f8, 0x03f8, 0x07f8, 0x0ff8,
   0x1ff8, 0x1ff8, 0x07f8, 0x07b8,
   0x0f98, 0x0f00, 0x0f00, 0x0f00}

Definition at line 57 of file getx10.c.

unsigned char* buffer

Definition at line 106 of file getx10.c.

int bwflag = 0

Definition at line 71 of file getx10.c.

Referenced by init_color(), makemap(), update_pic(), and update_zoom().

Color colmap[256]

Definition at line 67 of file getx10.c.

int dbg = 0

Definition at line 104 of file getx10.c.

double disp_gam = 2.5

Definition at line 85 of file getx10.c.

int divN[256]

Definition at line 70 of file getx10.c.

int dm16[16][16]

Definition at line 43 of file getx10.c.

Display* dpy

Definition at line 94 of file getx10.c.

Window fbwin

Definition at line 95 of file getx10.c.

int forkflg = 0

Definition at line 91 of file getx10.c.

int gammamap[256]

Definition at line 68 of file getx10.c.

Referenced by init_gamma_map(), and write_colour_map().

rle_hdr hdr

Definition at line 84 of file getx10.c.

Referenced by borrow_color_map(), colormap(), direct_setup(), init_24_bit_colour_map(), init_color(), load_x_map(), rasterDone(), read_rle_header(), window_color_map(), write_ppm_data(), write_rle_data(), and write_rle_header().

unsigned char * iconbuf

Definition at line 106 of file getx10.c.

int iconbyte

Definition at line 96 of file getx10.c.

int iconfact

Definition at line 96 of file getx10.c.

int iconrow

Definition at line 96 of file getx10.c.

int iconscan

Definition at line 96 of file getx10.c.

Window iconwin

Definition at line 95 of file getx10.c.

int iflag = 0

Definition at line 87 of file getx10.c.

double img_gam = 1.0

Definition at line 86 of file getx10.c.

rle_pixel** in_cmap

Definition at line 69 of file getx10.c.

int levels = 0

Definition at line 79 of file getx10.c.

Referenced by init_color().

int levelsc

Definition at line 79 of file getx10.c.

Referenced by init_color().

int levelsq

Definition at line 79 of file getx10.c.

Referenced by init_color().

int mapflg = 0

Definition at line 89 of file getx10.c.

int modN[256]

Definition at line 70 of file getx10.c.

int nbyte

Definition at line 102 of file getx10.c.

Referenced by update_pic(), and update_zoom().

int nrow

Definition at line 101 of file getx10.c.

Referenced by create_window(), update_pic(), and update_zoom().

int nscan

Definition at line 101 of file getx10.c.

Referenced by create_window(), update_pic(), and update_zoom().

char rcs_ident[] = "$Id: getx10.c,v 3.0.1.1 1992/01/28 18:12:35 spencer Exp $"

static

Definition at line 29 of file getx10.c.

int setbg = 0

Definition at line 88 of file getx10.c.

Referenced by update_pic().

int usemap = 0

Definition at line 90 of file getx10.c.

int zoom_x_center

Definition at line 100 of file getx10.c.

Referenced by update_pic(), and update_zoom().

int zoom_x_dim = 15

Definition at line 98 of file getx10.c.

Referenced by create_window(), resize_zoom_window(), and update_zoom().

int zoom_y_center

Definition at line 100 of file getx10.c.

Referenced by update_pic(), and update_zoom().

int zoom_y_dim = 15

Definition at line 99 of file getx10.c.

Referenced by create_window(), resize_zoom_window(), and update_zoom().

int zoomfact = 8

Definition at line 97 of file getx10.c.

Referenced by create_window(), resize_zoom_window(), and update_zoom().

int zoomflg = 0

Definition at line 92 of file getx10.c.

Referenced by create_window(), and update_pic().

Window zoomwin

Definition at line 95 of file getx10.c.