path: root/vendor/x11iraf/ximtool/raster.c

#include <stdio.h>
#include <sys/types.h>
#include <dirent.h>

#include <X11/Intrinsic.h>
#include <X11/StringDefs.h>
#include <Obm.h>
#include <ObmW/Gterm.h>
#include "ximtool.h"
#include "iis.h"

/*  Slackware/RedHat4.2 compatibility hack. */
#if defined(linux) && defined(isalnum)
#undef isalnum
#define isalnum(c) (isalpha(c)||isdigit(c))
#endif


#define	DBG_RASTER	0


/*
 * RASTER.C -- Raster pixel (frame buffer) routines.  These are the routines
 * which create and manipulate the frame buffers and the graphics pipeline
 * to the screen.
 *
 *	     xim_initialize (xim, config, nframes, hardreset)
 *		  xim_reset (xim, w)
 *	         xim_resize (xim, w)
 *	        xim_refresh (xim)
 *
 *	       xim_setFrame (xim, frame)
 *    xim_setReferenceFrame (chan, frame)
 *	xim_setDisplayFrame (xim, frame)
 *	      xim_initFrame (xim, frame, nframes, config, memModel)
 *	       xim_delFrame (xim, frame)
 *	    xim_matchFrames (xim, frames, reference_frame)
 *	 xim_registerFrames (xim, frames, reference_frame)
 *	       xim_fitFrame (xim)
 *	     xim_tileFrames (xim, frame_list)
 *
 *	     xim_cursorMode (xim, state)
 *
 *	     xim_setMapping (xim, fb, frame, mapping, src, dst, fill_mode)
 *		xim_setZoom (xim, fb, frame, mapping, src, dst,
 *			     xcen,ycen, xmag,ymag, xoff,yoff, absolute)
 *		xim_setFlip (xim, fb, flip_x, flip_y)
 *	    xim_setColormap (name, dirs, red, green, blue, ncolors)
 *		 xim_setRop (xim, fb, rop)
 *   rop = xim_getAntialias (xim, s)
 *
 *	      xim_getScreen (xim, frame, sx, sy, width, height, depth)
 *      bool = xim_onScreen (xim, frame)
 *
 *         xim_setCursorPos (xim, sx, sy)
 *         xim_getCursorPos (xim, sx, sy, raster, frame)
 *
 * pixels = xim_readDisplay (xim, x0,y0,nx,ny, w,h, r,g,b, ncolors)
 *  stat = xim_writeDisplay (xim, frame, mapname, pixels, w,h, r,g,b, ncolors)
 *
 *		xim_message (xim, object, message)
 *		   xim_msgi (xim, object, intval)
 *		  xim_alert (xim, text, ok_action, cancel_action)
 */

/* Define some builtin colormaps. */
static Lut aips0 = {
#include "data/aips0.lut"
};
static Lut blue = {
#include "data/blue.lut"
};
static Lut color = {
#include "data/color.lut"
};
static Lut green = {
#include "data/green.lut"
};
static Lut halley = {
#include "data/halley.lut"
};
static Lut heat = {
#include "data/heat.lut"
};
static Lut rainbow = {
#include "data/rainbow.lut"
};
static Lut red = {
#include "data/red.lut"
};
static Lut staircase = {
#include "data/staircase.lut"
};
static Lut standard = {
#include "data/standard.lut"
};

static void get_fbconfig();
static void set_colorbar();
static int get_dirfile();
static void load_testpattern();
static void set_nframes();
static void xim_frameRegion();
static void xim_colortables();
extern char *getenv();
double strtod();

#define	TOL	0.0001


/* XIM_INITIALIZE -- Initialize the imaging subsystem.  Read the config file
 * and create the frame buffers, mappings, and colormaps.
 */
void
xim_initialize (xim, config, nframes, hardreset)
register XimDataPtr xim;
int config;
int nframes;
int hardreset;
{
	register Widget gt = xim->gt;
	register FrameBufPtr fb;
	register int i;

	unsigned short m_red[MAX_COLORS];
	unsigned short m_green[MAX_COLORS];
	unsigned short m_blue[MAX_COLORS];
	char *fname, *ip, *op, sbuf[8192];
	String maps[MAX_COLORMAPS], dirs[4];
	int max_cmaps, first, ngray, rgb_len, nfiles, n;
	static int nbuiltin_cmaps = 0;
	int display_frame = 1;
	char cmapname[SZ_NAME];
	char buf[SZ_LINE];
	FbConfigPtr cf;
	ColorMapPtr cm;
	struct dir *dp;
	int startup;
	DIR *dir;

	/* The gterm widget handle should already have been set by the
	 * GUI during startup.
	 */
	if (!gt) {
	    fprintf (stderr, "xim_initialize:  no gterm-image widget!!\n");
	    exit (1);
	}

	/* Inform the GUI that the frame buffers are being initialized.
	 * The initialize parameter is set to "startup" during program
	 * startup, "restart" at the start of an initialization during
	 * execution, and "done" when initialization is completed.
	 */
	startup = (xim->nframes == 0);
	xim_message (xim, "initialize", startup ? "startup" : "restart");

	if (hardreset || startup || config != xim->fb_configno) {
	    xim_msgi (xim, "frame", 0);
	    xim_message (xim, "frameTitle", "");
	    set_nframes (xim, 0);
	    cm = &colormaps[DEF_COLORMAP-1];
	    strcpy (cmapname, cm->name);
	    hardreset = 1;

	    /* Get frame buffer configurations. */
	    get_fbconfig (xim);

	    /* Remove any existing border highlight marker. */
	    if (xim->gm_border) {
		GmDestroy (xim->gm_border);
		xim->gm_border = NULL;
	    }

	    /* Initialize the frame buffers. */
	    if (DBG_RASTER)
		fprintf (stderr, "xim_initialize: Raster init.....\n");
	    GtRasterInit (gt);
	    if (DBG_RASTER)
		fprintf (stderr, "xim_initialize: Raster init.....DONE\n");
	    for (i=1;  i <= MAX_FRAMES;  i++)
		xim->frames[i].frameno = 0;

	    cf = &xim->fb_config[config-1];
	    nframes = (nframes <= 0) ? cf->nframes : nframes;

	    if (startup) {
		/* Set initial tile frames list to be all frames if starting
		 * up in tile frames mode.
		 */
		if (xim->tileFrames && nframes > 1) {
		    xim->tileFramesList = 0;
		    xim->nTileFrames = 0;
		    for (i=0;  i < nframes;  i++) {
			xim->tileFramesList |= (1 << i);
			xim->nTileFrames++;
		    }
		}
	    } else {
		xim->display_frame = 0;
		xim->df_p = NULL;
		for (i=0;  i < XtNumber(xim->chan);  i++) {
		    IoChanPtr chan = &xim->chan[i];
		    if (chan->type)
			xim_setReferenceFrame (chan, 1);
		}
		if (xim->cursor_chan)
		    xim->cursor_chan = &xim->chan[0];
	    }

	    xim->rop = xim->antialias ?
		xim_getAntialias (xim, xim->antialiasType) : 0x00;
	    xim->fb_configno = config = max(1, min(MAX_FBCONFIG, config));
	    if (DBG_RASTER)
		fprintf (stderr,
		    "xim_initialize: ........................SETNFRAME\n");
	    set_nframes (xim, nframes);
	    if (DBG_RASTER)
		fprintf (stderr,
		    "xim_initialize: ........................SETNFRAME DONE\n");

	    /* Initialize the tile framing options. */
	    xim->tileByRows = 1;
	    xim->tileTopDown = 1;
	    xim->tileLabels = 0;

	    /* Set the new frame size. */
	    sprintf (buf, "%d %d %d", cf->width, cf->height, 8);
	    xim_message (xim, "frameSize", buf);

	    /* Create the frames. */
	    for (i=1;  i <= nframes;  i++) {
		if (DBG_RASTER)
		    fprintf (stderr,
			"xim_initialize: ...............INITFRAME %d\n",i);
		xim_initFrame (xim, i, nframes, cf, xim->memModel);
		if (DBG_RASTER)
		    fprintf (stderr,
			"xim_initialize: ...............INITFRAME %d DONE\n",i);
	    }

            /* Reinitialize the tile framing. */
            if (xim->tileFrames) {
                xim->tileFramesList = 0;
                xim->nTileFrames = 0;
                for (i=0;  i < nframes;  i++) {
                    xim->tileFramesList |= (1 << i);
                    xim->nTileFrames++;
                }
            }

	    xim->width = cf->width;
	    xim->height = cf->height;
	    GtSetLogRes (gt, cf->width, cf->height);

	} else {
	    /* Soft reset. */
	    display_frame = xim->display_frame;
	    fb = &xim->frames[display_frame-1];
	    cm = &colormaps[fb->colormap-1];
	    strcpy (cmapname, cm->name);

	    for (i=0;  i < ncolormaps;  i++) {
		cm = &colormaps[i];
		GtFreeColormap (gt, cm->mapno);
	    }
	}

	if (DBG_RASTER)
	    fprintf (stderr,
		"xim_initialize: ........................CMAP SETUP\n");
	/* Set up the colormap to emulate the IIS/imtool colormap.  Set
	 * xim->ncolors to the length of the grayscale region of the colormap
	 * returned by iiscolormap so that our other colormaps will have the
	 * same size.
	 */
	if (DBG_RASTER)
	    fprintf (stderr,
		"xim_initialize: xim->ncolors = %d\n", xim->ncolors);
	xim_iiscolormap (gt, m_red,m_green,m_blue, &first, &ngray, &rgb_len);
	if (DBG_RASTER)
	    fprintf (stderr,
		"xim_initialize: writeColormap:  first=%d ngray=%d len=%d\n",
		first, ngray, rgb_len);
	GtWriteColormap (gt, 0, first, rgb_len, m_red, m_green, m_blue);
	if ((xim->ncolors = ngray) < 0) {
	    fprintf (stderr, "ERROR: No colormap cells available.\n");
	    exit (1);
	}


	/* Initialize the color tables.
	*/
	max_cmaps = nbuiltin_cmaps ? nbuiltin_cmaps : MAX_COLORMAPS;
	if (DBG_RASTER)
	    fprintf (stderr,
		"xim_initialize: init colortables:  xim->ncolors = %d\n",
		xim->ncolors);
	for (ncolormaps=0;  ncolormaps < max_cmaps;  ncolormaps++) {
	    cm = &colormaps[ncolormaps];
	    if (!cm->name[0])
		break;
	    cm->mapno = GtNextColormap (gt);
	    xim_setColormap (cm->name, NULL, m_red, m_green, m_blue,
		xim->ncolors);
	    GtWriteColormap (gt, cm->mapno, first, xim->ncolors,
		m_red, m_green, m_blue);
	}
	if (DBG_RASTER)
	    fprintf (stderr, "xim_initialize: init colortables:  DONE\n");

	/* The first time this is called count the number of builtin cmaps. */
	if (nbuiltin_cmaps == 0)
	    nbuiltin_cmaps = ncolormaps;

	/* Get the names of the two user defined colormaps, if any. */
	nfiles = 0;
	maps[nfiles++] = xim->userCMap1;
	maps[nfiles++] = xim->userCMap2;

	/* If any user colormap directories are specified get the names
	 * of the colormap files in these directories.
	 */
	dirs[0] = "./";
	dirs[1] = xim->userCMapDir1;
	dirs[2] = xim->userCMapDir2;
	dirs[3] = NULL;

	for (i=1, op=sbuf;  dirs[i];  i++) {
	    if (strcmp (dirs[i], "none") != 0) {
		if (dir = opendir (dirs[i])) {
		    while ((n = get_dirfile (dir, op, SZ_FNAME)) > 0) {
			maps[nfiles++] = op;
			op += n + 1;
			if (nfiles >= MAX_COLORMAPS)
			    break;
		    }
		    closedir (dir);
		}
	    }
	}

	/* Add all the user specified colormaps to the colormap table.
	 */
	for (i=0;  i < nfiles && ncolormaps < MAX_COLORMAPS;  i++) {
	    fname = maps[i];
	    if (strcmp (fname, "none") != 0) {
		if (xim_setColormap (fname, dirs,
		    m_red, m_green, m_blue, xim->ncolors) == OK) {

		    cm = &colormaps[ncolormaps++];
		    cm->mapno = GtNextColormap (gt);

		    /* Use root portion of filename as the colormap name. */
		    for (ip=fname;  *ip;  ip++)
			if (*ip == '/')
			    fname = ip + 1;
		    for (ip=fname, op=cm->name;  *ip && *ip != '.';  ip++) {
			*op++ = *ip;
			if (op - cm->name >= SZ_CMAPNAME)
			    break;
		    }
		    *op = '\0';

		    GtWriteColormap (gt, cm->mapno, first, xim->ncolors,
			m_red, m_green, m_blue);
		}
	    }
	}

	/* Pass the list of colortables on to the user interface. */
	xim_colortables (xim);

	/* Set initial display frame. */
	xim_setDisplayFrame (xim, display_frame);

	/* Force the initial default colormap to be loaded. */
	fb = &xim->frames[display_frame-1];
	for (i=0;  i < ncolormaps;  i++) {
	    cm = &colormaps[i];
	    if (strcmp (cm->name, cmapname) == 0)
		break;
	}
	if (i >= ncolormaps)
	    cm = &colormaps[DEF_COLORMAP-1];

	GtLoadColormap (gt, cm->mapno, fb->offset, fb->scale);
	xim_enhancement (xim, fb);

	/* Set options. */
/*	xim_message (xim, "cmfocus", xim->cm_focus ? "True" : "False");*/
	xim_message (xim, "autoscale", xim->autoscale ? "True" : "False");
	xim_message (xim, "antialias", xim->antialias ? "True" : "False");
	xim_message (xim, "tileFrames", xim->tileFrames ? "True" : "False");

	xim_message (xim, "initialize", "done");

	if (DBG_RASTER)
	    fprintf (stderr,
		"xim_initialize: ................................RETURNING\n");
}


/* XIM_RESET -- Called when the active gterm widget is set or changed.
 */
void
xim_reset (xim, w)
XimDataPtr xim;
Widget w;
{
	unsigned short iomap[MAX_COLORS];
	int iomap_len;

	if (!w)
	    return;

	/* The following assumes that the GUI does a setGterm first for the
	 * colorbar and second for the main image window.  The first thing we
	 * do is set the iomap so that all ximtool color and pixel i/o will
	 * see the emulated IIS color model.
	 */
	if (xim->cb == NULL) {
	    xim->cb = w;
	    xim_iisiomap (w, iomap, &iomap_len);
	    GtPostResizeProc (w, set_colorbar, xim);
	    GtWriteIomap (w, iomap, 0, iomap_len);
	} else {
	    xim->gt = w;
	    xim_iisiomap (w, iomap, &iomap_len);
	    GtPostResizeProc (w, xim_resize, xim);
	    GtWriteIomap (w, iomap, 0, iomap_len);
	}
}


/* XIM_RESIZE -- Called when the active gterm widget is resized.  We need to
 * resize the zoom raster and modify the zoom mapping for each frame to
 * reflect the new window size.
 */
void
xim_resize (xim, w)
XimDataPtr xim;
Widget w;
{
	register FrameBufPtr fb;
	int junk, sx, sy, width, height, depth;
	int i, active, frame, mapping, zoomtype;
	float xscale, yscale, scale;
	char buf[SZ_LINE];


	/* This case is true during startup. */
	if (xim->nframes <= 0)
	    return;

	/* Get new screen size.  In tile frame mode select the first frame
	 * in the list for the size, which may not always be frame 1.
	 */
	if (xim->tileFrames && !(xim->tileFramesList & 1)) {
	    if (xim->nframes == 0)
		return;
	    for (i=1;  i <= xim->nframes;  i++)
                if (xim->tileFramesList & (1 << (i-1))) {
	    	    xim_getScreen (xim, i, &sx, &sy, &width, &height, &depth);
		    break;
		}
	} else
	    xim_getScreen (xim, 1, &sx, &sy, &width, &height, &depth);

	/* Compute the new scale factor required to scale the source to the
	 * destination at magnification 1.0.
	 */
	if (xim->autoscale) {
	    xscale = (float)width / (float)xim->width;
	    yscale = (float)height / (float)xim->height;
	    scale = min (xscale, yscale);
	} else {
	    xscale = 1.0;
	    yscale = 1.0;
	    scale = 1.0;
	}

	/* Adjust the mapping for each frame. */
	for (frame=1;  frame <= xim->nframes;  frame++) {
	    fb = &xim->frames[frame-1];
	    mapping = fb->zoommap;

	    /* For rapid frame blink, split screen, etc. the zoom raster
	     * must be the same size as the screen so we must resize this
	     * raster when the display window is resized.  The CreateRaster
	     * call will delete the old raster and all its mappings and
	     * create a new one.  We must then restore the mappings, and
	     * if this is an active display frame, refresh the mapping.
	     */
	    active = xim_onScreen (xim, frame);

	    if (fb->zoomras) {
		GtQueryRaster (w, fb->zoomras, &zoomtype, &junk, &junk, &junk);
		GtCreateRaster (w, fb->zoomras, zoomtype, width, height, depth);
		xim_setMapping (xim, NULL, frame, fb->dispmap,
		    fb->zoomras, 0, M_FILL);
		if (!active) {
		    GtDisableMapping (w, fb->dispmap, 0);
		    xim_setMapping (xim, NULL, frame, fb->zoommap,
			fb->raster, fb->zoomras, M_FILL);
		    GtDisableMapping (w, fb->zoommap, 0);
		}
	    } else {
		if (active) {
		    GtEnableMapping (w, fb->dispmap, 0);
		    GtSetDisplayRaster (w, xim->display_frame);
		} else
		    GtDisableMapping (w, fb->dispmap, 0);
	    }

	    /* Set the new mapping. */
	    fb->xscale = fb->yscale = scale;
	    xim_setZoom (xim, fb, frame, mapping, fb->raster, fb->zoomras,
		fb->xcen, fb->ycen, fb->xmag, fb->ymag, 
		fb->xoff, fb->yoff, False);
	}

	/* Refresh the screen for any active mappings.  Any mappings
	 * defined on any visible frame should be refreshed, since a
	 * redraw clears the display window.
	 */
	for (frame=1;  frame <= xim->nframes;  frame++) {
	    if (xim_onScreen (xim, frame)) {
		int junk, width, height, depth;
		fb = &xim->frames[frame-1];
		GtQueryRaster (w, fb->raster, &junk, &width, &height, &depth);
		GtRefreshPixels (w, fb->raster, GtPixel, 0, 0, width, height);
	    }
	}

	/* Highlight the current frame. */
	xim_highlightFrame (xim, xim->display_frame);

	sprintf (buf, "%d %d %d %d", sx, sy, width, height);
	xim_message (xim, "resize", buf);
}


/* XIM_REFRESH -- Refresh the current display frame.
 */
void
xim_refresh (xim)
XimDataPtr xim;
{
	register FrameBufPtr fb = xim->df_p;
	int junk, width, height, depth;

	GtQueryRaster (xim->gt, fb->raster, &junk, &width, &height, &depth);
	GtRefreshPixels (xim->gt, fb->raster, GtPixel, 0, 0, width, height);
}


/* XIM_CLOSE -- Free any raster specific resources.
 */
void
xim_close (xim)
register XimDataPtr xim;
{
}


/* XIM_SETFRAME -- Configure a frame to be both the display and reference
 * frame.
 */
void
xim_setFrame (xim, frame)
register XimDataPtr xim;
int frame;
{
	xim_setDisplayFrame (xim, frame);
}


/* XIM_SETREFERENCEFRAME -- Set the frame used for frame buffer i/o.
 */
void
xim_setReferenceFrame (chan, frame)
register IoChanPtr chan;
int frame;
{
	register XimDataPtr xim = (XimDataPtr) chan->xim;
	register FrameBufPtr fb;
	int frameno;

	/* Ignore request if channel not active. */
	if (!chan->type)
	    return;

	frameno = max(1, min(MAX_FRAMES, frame));
	fb = &xim->frames[frameno-1];

	/* Ignore request if not a valid frame. */
	if (fb->frameno > 0) {
	    chan->reference_frame = frameno;
	    chan->rf_p = fb;
	}
}


/* XIM_SETDISPLAYFRAME -- Set the frame which is displayed.
 */
void
xim_setDisplayFrame (xim, frame)
register XimDataPtr xim;
int frame;
{
	register FrameBufPtr fb;
	register Widget gt = xim->gt;
	FrameBufPtr old_fb = xim->df_p;
	int frameno, old_frameno;
	char buf[256];

	old_frameno = old_fb ? old_fb->frameno : 0;
	frameno = max(1, min(MAX_FRAMES, frame));
	fb = &xim->frames[frameno-1];

	/* Ignore request if not a valid frame. */
	if (fb->frameno > 0 && (!old_fb || frameno != old_frameno)) {
	    /* Special case: if tile frame mode is in effect and we are
	     * displaying a frame not in the tile list, clear the screen
	     * before displaying the frame.  Likewise, if displaying an
	     * untiled frame while in tile frame mode and then reverting
	     * to display of a tiled frame, clear the screen and display
	     * all the tiled frames.
	     */
	    if (xim->tileFrames && old_fb) {
		int tile_old = (xim->tileFramesList & (1 << old_frameno-1));
		int tile_new = (xim->tileFramesList & (1 <<     frameno-1));

		if (tile_old && !tile_new)
		    GtClearScreen (gt);
		else if (!tile_old && tile_new) {
		    GtClearScreen (gt);
/*		    xim_resize (xim, gt);*/
		}
	    }

	    /* Map the new frame. */
	    xim->df_p = fb;
	    xim->display_frame = frameno;
	    GtEnableMapping (gt, fb->dispmap, 0);

	    /* Unmap the old frame. */
	    if (old_fb && !xim_onScreen (xim, old_frameno)) {
		FrameBufPtr old_fb = &xim->frames[old_frameno-1];
		GtDisableMapping (gt, old_fb->dispmap, 0);
	    }

	    /* Display the new frame. */
	    if (GtActiveMapping (gt, fb->zoommap)) {
		GtRefreshMapping (gt, fb->dispmap);
	    } else {
		GtEnableMapping (gt, fb->zoommap, 0);
		GtRefreshMapping (gt, fb->zoommap);
	    }
	    GtSetDisplayRaster (gt, frameno);


	    /* Highlight the new frame if in tileFrames mode. */
	    xim_highlightFrame (xim, frameno);

	    /* Load the colormap only if it differs from what we already
	     * have.  This avoids the waste of repeatedly reloading the
	     * colormap when blinking frames that have matched colormaps.
	     */
	    if (!old_fb || fb->colormap != old_fb->colormap ||
		abs (fb->offset - old_fb->offset) > 0.001 ||
		abs (fb->scale - old_fb->scale) > 0.001) {

	    	GtSetColormapFocus (-1);	/* force full update	*/
		GtLoadColormap (gt, fb->colormap, fb->offset, fb->scale);
	    	GtSetColormapFocus (xim->cm_focus);
	    }

	    xim_msgi (xim, "frame", frameno);
	    xim_message (xim, "frameTitle", fb->ctran.imtitle);
	    xim_message (xim, "xflip", fb->xflip ? "true" : "false");
	    xim_message (xim, "yflip", fb->yflip ? "true" : "false");
	    xim_frameRegion (xim, fb);

	    sprintf (buf, "%g %g %g %g %g %g %g %g",
		fb->xmag, fb->ymag, fb->xcen, fb->ycen, 
		fb->xscale, fb->yscale, fb->xoff, fb->yoff);
	    xim_message (xim, "frameView", buf);
	}
}


/* XIM_INITFRAME -- Initialize a frame buffer.
 */
void
xim_initFrame (xim, frame, nframes, config, memModel)
register XimDataPtr xim;
int frame, nframes;
FbConfigPtr config;
char *memModel;
{
	register FrameBufPtr fb = &xim->frames[frame-1];
	register Widget gt = xim->gt;
	int sx, sy, width, height, depth;
	char buf[SZ_LINE];

	if (frame < 1 || frame > MAX_FRAMES)
	    return;

	xim_delFrame (xim, frame);
	memset ((void *)fb, 0, sizeof(FrameBuf));

	/* Create the frame buffer. */
	fb->frameno = frame;
	fb->raster = GtNextRaster (gt);

	if (DBG_RASTER) {
	    fprintf (stderr, 
  		"xim_initFrame: Creating CLIENT raster for frame=%d raster=%d (%dx%dx%d)\n",
  		frame, fb->raster, 
  		config->width, config->height, DEF_FRAME_DEPTH);
	    fprintf (stderr, 
  		"xim_initFrame: Creating memModel=%s frame=%d raster=%d  (%d x %d)\n", 
  		memModel, frame, fb->raster, config->width, config->height);
	}

	if (GtCreateRaster (gt, fb->raster, GtClient,
		config->width, config->height, DEF_FRAME_DEPTH) < 0) {

	    	    fprintf (stderr, "cannot create %dx%d frame buffer #%d\n",
			config->width, config->height, frame);
	    return;
	}

	/* Get region of screen to be written into. */
	xim_getScreen (xim, frame, &sx, &sy, &width, &height, &depth);

	if (DBG_RASTER)
	    fprintf (stderr,
		"xim_initFrame: [%d of %d] screen size -- %d x %d x %d\n",
		frame, nframes, width, height, depth);

	/* Set up the graphics pipeline to the screen.  The "memory model"
	 * determines memory is used, trading off memory usage against speed
	 * for operations like zoom/pan and blink.
	 */

	if (strcmp (memModel, "fast") == 0) {
	    /* Use both client and server memory to achieve the best
	     * possible performance.  The frame buffer raster (type ximage)
	     * is mapped to a server pixmap with the zoom/pan mapping, and
	     * the server pixmap is mapped to the screen with the one-to-one
	     * frame display mapping.
	     */
fast:	    fb->zoomras = GtNextRaster (gt);
	    if (GtCreateRaster (gt,
		    fb->zoomras, GtServer, width, height, depth) < 0)
		goto nice;

	    xim_setMapping (xim, fb, frame, fb->zoommap = GtNextMapping(gt),
		fb->raster, fb->zoomras, xim->autoscale ? M_ASPECT : M_UNITARY);
	    xim_setMapping (xim, fb, frame, fb->dispmap = GtNextMapping(gt),
		fb->zoomras, 0, M_FILL);

	} else if (strcmp (memModel, "beNiceToServer") == 0) {
	    /* Minimize use of X server memory, but keep zoom raster to speed
	     * up blinks.  Everything is the same as with the "fast" memory
	     * model except that the zoom raster is an ximage rather than
	     * server pixmap raster.
	     */
nice: 	    fb->zoomras = GtNextRaster (gt);
	    if (DBG_RASTER)
		fprintf (stderr,
		    "xim_initFrame: creating 'nice' model (0x%x)\n", 
		    fb->zoomras);
	    if (GtCreateRaster (gt,
		    fb->zoomras, GtClient, width, height, depth) < 0)
		goto small;

	    xim_setMapping (xim, fb, frame, fb->zoommap = GtNextMapping(gt),
		fb->raster, fb->zoomras, xim->autoscale ? M_ASPECT : M_UNITARY);
	    xim_setMapping (xim, fb, frame, fb->dispmap = GtNextMapping(gt),
		fb->zoomras, 0, M_FILL);

	} else if (strcmp (memModel, "small") == 0) {
	    /* Minimize both client and server memory as far as possible.
	     * Only the frame buffer raster is used, the zoom/pan mapping
	     * maps directly to the screen and is also used as the screen
	     * mapping.
	     *
	     * FIXME:  On TrueColor visuals we can have an issue here where
	     * the display pixmap is 24-bits and various things (e.g. pixel
	     * readback) are expecting 8-bits.
	     */
small:	    fb->zoomras = 0;
	    if (DBG_RASTER)
		fprintf (stderr,
		    "xim_initFrame: creating 'small' model (0x%x)\n", 
		    fb->zoomras);

	    xim_setMapping (xim, fb, frame, fb->zoommap = GtNextMapping(gt),
		fb->raster, fb->zoomras, xim->autoscale ? M_ASPECT : M_UNITARY);
	    fb->dispmap = fb->zoommap;

	} else {
	    fprintf (stderr,
		"unrecognized memModel `%s', default to `fast'\n", memModel);
	    goto fast;
	}

	/* Set up the default colormap. */
	fb->colormap = DEF_COLORMAP;
	fb->offset = 0.5;
	fb->scale = (xim->invert ? -1.0 : 1.0);
	xim_enhancement (xim, fb);

	/* Disable frame display initially if not mapped to screen. */
	if (xim_onScreen (xim, frame)) {
	    GtEnableMapping (gt, fb->dispmap, 0);
	    GtSetDisplayRaster (gt, frame);
	} else
	    GtDisableMapping (gt, fb->dispmap, 0);

	set_nframes (xim, max (xim->nframes, frame));
}


/* XIM_DELFRAME -- Delete a frame.
 */
void
xim_delFrame (xim, frame)
register XimDataPtr xim;
int frame;
{
	register FrameBufPtr fb = &xim->frames[frame-1];
	register Widget gt = xim->gt;

	if (frame < 1 || frame > MAX_FRAMES)
	    return;
	if (fb->frameno <= 0)
	    return;

	GtFreeMapping (gt, fb->dispmap);
	if (fb->zoommap != fb->dispmap)
	    GtFreeMapping (gt, fb->zoommap);
	if (fb->zoomras)
	    GtDestroyRaster (gt, fb->zoomras);
	if (fb->raster)
	    GtDestroyRaster (gt, fb->raster);

	fb->frameno = 0;
	if (xim->nframes == frame)
	    set_nframes (xim, frame - 1);
}


/* XIM_ERASEFRAME -- Erase a frame.
 */
void
xim_eraseFrame (xim, frame)
register XimDataPtr xim;
int frame;
{
	FrameBufPtr fb = &xim->frames[frame-1];
	Widget gt = xim->gt;
	int    Z = 0;

	GtSetPixels (gt, fb->raster, GtPixel, Z,Z,Z,Z, CMS_BACKGROUND, 0);
}


/* XIM_FITFRAME -- Attempt to resize the display window to be the same
 * size as the frame buffer.
 */
void
xim_fitFrame (xim)
register XimDataPtr xim;
{
	register Widget gt = xim->gt;

	GtCreateRaster (gt, 0, GtServer, xim->width, xim->height, 8);
}


/* XIM_TILEFRAMES -- Set or clear tile frame mode.
 */
void
xim_tileFrames (xim, frame_list)
register XimDataPtr xim;
int frame_list;
{
	register int i;
	register Widget w = xim->gt;
	register FrameBufPtr fb;
	char buf[SZ_LINE];
	int mapping;


	/* Get list of frames to be tiled. */
	xim->tileFramesList = frame_list;
	for (i=0, xim->nTileFrames = 0;  i < xim->nframes;  i++)
	    if (frame_list & (1 << i))
		xim->nTileFrames++;

	/* Remove any existing border highlight marker. */
	if (xim->gm_border) {
	    GmDestroy (xim->gm_border);
	    xim->gm_border = NULL;
	}

	xim->tileFrames = (frame_list != 0);
	GtClearScreen (w);
	initialize_shadow_pixmap (w, 0);
	xim_resize (xim, w);

	/* Entering tile frame mode.
	 */
	if (xim->tileFrames) {
			
	    /* Ensure that the display frame is set to one of the
	     * tiled frames.
	     */
	    if (!(xim->tileFramesList & (1 << xim->display_frame-1))) {
		for (i=1;  i <= xim->nframes;  i++)
		    if (xim->tileFramesList & (1 << (i-1))) {
			xim->df_p = NULL;
			xim->display_frame = 0;
			xim_setFrame (xim, i);
			break;
		    }
	    }


	    /* Change the stacking order of the frame mappings if
	     * necessary so that any frames not in the tile list are 
	     * displayed above the tiled frames.  If this is not
	     * done the untiled frames may be obscured by the tiled
	     * frames.
	     */
	    for (i=0, mapping=0;  i < xim->nframes;  i++)
		if (xim->tileFramesList & (1 << i)) {
		    fb = &xim->frames[i];
		    if (!mapping)
			mapping = fb->dispmap;
		    else if (GtCompareMappings (w, mapping, fb->dispmap) < 0)
			mapping = fb->dispmap;
		}
	    for (i=0;  i < xim->nframes;  i++)
		if (!(xim->tileFramesList & (1 << i))) {
		    fb = &xim->frames[i];
		    GtRaiseMapping (w, fb->dispmap, mapping);
		}
	}

	/* Highlight the current frame. */
	xim_highlightFrame (xim, xim->display_frame);

	sprintf (buf, "%s", xim->tileFrames ? "True" : "False");
	xim_message (xim, "tileFrames", buf);
}


/* XIM_HIGHLIGHTFRAME -- If in tile frames mode, highlight the current frame
 * by coloring the border of the frame.
 */
xim_highlightFrame (xim, frame)
register XimDataPtr xim;
int frame;
{
	/* If we are tiling frames highlight the new display frame. */
	if (xim->gm_border) {
	    GmDestroy (xim->gm_border);
	    xim->gm_border = NULL;
	}

	if (xim->tileFrames && xim->highlightFrames) {
	    int sx, sy, width, height, depth;
	    int interactive, erase;
	    XtPointer gm;
	    Arg args[20];
	    int nargs = 0;

	    xim_getScreen (xim, frame, &sx, &sy, &width, &height, &depth);
	    if (sx > 0 && sy > 0) {
		gm = (XtPointer) GmCreate (xim->gt, Gm_Box,
		    interactive=False);

		XtSetArg (args[nargs], GmX, sx + (width-1)/2);        nargs++;
		XtSetArg (args[nargs], GmY, sy + (height-1)/2);       nargs++;
		XtSetArg (args[nargs], GmWidth, (width-1)/2+1);       nargs++;
		XtSetArg (args[nargs], GmHeight, (height-1)/2+1);     nargs++;
		XtSetArg (args[nargs], GmLineWidth, xim->tileBorder); nargs++;
		XtSetArg (args[nargs], GmSensitive, False);           nargs++;
		XtSetArg (args[nargs], GmVisible, True);              nargs++;
		XtSetArg (args[nargs], GmActivated, True);            nargs++;

		GmLower (gm, NULL);
		GmSetAttribute (gm, GmLineColor, xim->borderColor, XtRString);
		GmSetAttributes (gm, args, nargs, XtRInt);

		xim->gm_border = gm;
	    }
	    xim_labelTiles (xim);
	}
}


/* XIM_LABELTILES -- Label the tile with the frame number.
 */
xim_labelTiles (xim)
register XimDataPtr xim;
{
	FrameBufPtr  fb;
	MappingPtr   mp;
	Widget       gt = xim->gt;
	XtPointer    gm;
	Arg 	     args[10];
	char	     text[256], tw[16];
	register int i, j, len;
	int 	     sx, sy, width, height, depth, nargs=0;

	static XtPointer labels[MAX_FRAMES];
	static int label_init = 1;
	    
	if (!(xim->tileFrames && xim->tileLabels > 0))
	    return;

	/* Initialize the label markers. */
	if (label_init) {
	    /* First time through make sure we're all NULL.  */
	    for (i=0;  i < MAX_FRAMES; i++)  
		labels[i] = (XtPointer) NULL;
	    label_init = 0;
	} else {
	    /* Free up the existing labels.  */
	    for (i=0;  labels[i] && i < MAX_FRAMES; i++) {
	    	GmDestroy (labels[i]);
	    	labels[i] = (XtPointer) NULL;
	    }
	}


	for (i=0;  i < xim->nframes;  i++) {
	    if (xim->tileFramesList & (1 << i)) {
		xim_getScreen (xim, i+1, &sx, &sy, &width, &height, &depth);
		fb = &xim->frames[i];
		switch (xim->tileLabels) {
		case 1: 				/* frame number */
		    sprintf (text, " %d ", i+1);
		    break;
		case 2: 				/* image name 	*/
		    if (fb->nmaps == 0) {
			strcpy (text, " Blank ");
		    } else {
		        mp = &fb->mapping[0];
		        len = strlen (mp->ref);
		        for (j=len-1; mp->ref[j] != '/' && j > 0; j--) ;
		        sprintf (text, " %s ", &mp->ref[++j]);
		    }
		    break;
		case 3: 				/* image title	*/
		    if (fb->nmaps == 0) {
			strcpy (text, " Blank ");
		    } else {
		        len = strlen (fb->ctran.imtitle);
		        for (j=0; fb->ctran.imtitle[j] != ' ' && j < len; j++) ;
		        j += 3;
		        sprintf (text, " %s ", &fb->ctran.imtitle[j]);
		    }
		    break;
		}


		/* Now draw the label as a text marker on the tile.  We use
		 * markers since they can be placed as needed in the frame
		 * and provide a background which lets them be read despite
		 * whatever image scaling is in place.
		 */
		gm = (XtPointer) GmCreate (xim->gt, Gm_Text, False);

		nargs = 0;			/* initialize		*/
		len = strlen (text);
		sprintf (tw, "%dch", len);

		XtSetArg (args[nargs], GmX, sx + 10);            nargs++;
		XtSetArg (args[nargs], GmY, sy + height - 20);   nargs++;
		XtSetArg (args[nargs], GmLineWidth, 0);          nargs++;
		XtSetArg (args[nargs], GmSensitive, True);       nargs++;
		XtSetArg (args[nargs], GmVisible, True);         nargs++;
		XtSetArg (args[nargs], GmActivated, True);       nargs++;
		XtSetArg (args[nargs], GmImageText, True);       nargs++;

		GmSetAttribute (gm, GmWidth, tw, XtRString);
		GmSetAttribute (gm, GmHeight, "1ch", XtRString);
		GmSetAttribute (gm, GmTextBgColor, "black", XtRString);
		GmSetAttribute (gm, GmTextColor, "yellow", XtRString);
		GmSetAttribute (gm, GmText, text, XtRString);
		GmSetAttributes (gm, args, nargs, XtRInt);
        	GmMarkpos (gm);
        	GmRedraw (gm, GXcopy, True);

		labels[i] = gm;			/* save the marker ptr 	*/
	    }
	}
}


/* XIM_MATCHFRAMES -- Make the color enhancement of the listed frames match
 * that of the indicated frame.
 */
void
xim_matchFrames (xim, frames, reference_frame)
XimDataPtr xim;
int *frames;
int reference_frame;
{
	register FrameBufPtr fr, fb = &xim->frames[reference_frame-1];
	register int *ip, i;
	Widget gt = xim->gt;
	char buf[256];
	int bits;

	/* If frames is NULL match all frames.  Set one bit in BITS for
	 * each frame to be modified.  This ensures that each frame is
	 * only modified once, even if the same frame is listed more than
	 * once.
	 */
	if (frames) {
	    for (ip=frames, bits=0;  *ip;  ip++)
		bits |= (1 << (*ip - 1));
	} else {
	    for (i=1, bits=0;  i <= xim->nframes;  i++)
		bits |= (1 << (i - 1));
	}

	for (i=0;  i < xim->nframes;  i++) {
	    fr = &xim->frames[i];
	    if (fr != fb && (bits & (1 << (fr->frameno - 1)))) {
		fr->colormap = fb->colormap;
		fr->offset = fb->offset;
		fr->scale = fb->scale;
		xim_enhancement (xim, fr);
	    }
	}
}


/* XIM_REGISTERFRAMES -- Register the listed frames with the given reference
 * frame, i.e.  set the field center and scale of each frame to match the
 * reference frame.
 */
void
xim_registerFrames (xim, frames, reference_frame, offsets)
XimDataPtr xim;
int *frames;
int reference_frame;
int offsets;
{
	register int *ip, i;
	register FrameBufPtr fr, fb = &xim->frames[reference_frame-1];
	int src, st, sx, sy, snx, sny;
	int dst, dt, dx, dy, dnx, dny;
	Widget gt = xim->gt;
	int bits, rop;

	/* If frames is NULL register all frames.  Set one bit in BITS for
	 * each frame to be modified.  This ensures that each frame is
	 * only modified once, even if the same frame is listed more than
	 * once.
	 */
	if (frames) {
	    for (ip=frames, bits=0;  *ip;  ip++)
		bits |= (1 << (*ip - 1));
	} else {
	    for (i=1, bits=0;  i <= xim->nframes;  i++)
		bits |= (1 << (i - 1));
	}

	GtGetMapping (gt, fb->zoommap,
	    &rop, &src,&st,&sx,&sy,&snx,&sny, &dst,&dt,&dx,&dy,&dnx,&dny);

	for (i=0;  i < xim->nframes;  i++) {
	    fr = &xim->frames[i];

/*	    if (fr != fb && (bits & (1 << (fr->frameno - 1)))) {*/
	    if ((bits & (1 << (fr->frameno - 1)))) {
		fr->xcen = fb->xcen;  fr->ycen = fb->ycen;
		fr->xmag = fb->xmag;  fr->ymag = fb->ymag;
		fr->xflip = fb->xflip;  fr->yflip = fb->yflip;

		if (!xim_onScreen (xim, fb->frameno))
		    GtDisableMapping (gt, fr->zoommap, 0);

		if (offsets) {
		    /* fb is the current display buffer, fr is some other
		     * frame in the list.  To do the offsets we must
		     * first subtract the offset of the current display
		     * and then add the offset peculiar to the frame.
		     */

		    int nsx, nsy;

		    nsx = (int)(sx - fb->xoff + fr->xoff);
		    nsy = (int)(sy - fb->yoff + fr->yoff);

		    GtSetMapping (gt, fr->zoommap, xim->rop,
		        fr->raster, st,nsx,nsy, snx,sny, 
		        fr->zoomras,dt,dx,dy,dnx,dny);
		    GtRefreshMapping (gt, fr->zoommap);

		} else {
		    GtSetMapping (gt, fr->zoommap, xim->rop,
		        fr->raster, st,sx,sy, snx,sny, 
		        fr->zoomras,dt,dx,dy,dnx,dny);
		}
	    }
	}
	    
	/* A normal registration zeroes the offsets for each frame.  */
	if (!offsets) {
	    for (i=0;  i < xim->nframes;  i++) {
	        fr = &xim->frames[i];
	        fr->xoff = fr->yoff = 0;
	    }
	}
	xim_labelTiles (xim);
}


/* XIM_CURSORMODE -- Enter or leave cursor mode.  The remote client issues
 * a cursor read request via the datastream, then blocks until a cursor
 * value is returned.  The GUI is responsible for signalling to the user
 * that the application is waiting for cursor input, and for returning the
 * cursor value when the cursor read finishes.
 */
void
xim_cursorMode (xim, state)
register XimDataPtr xim;
int state;
{
	/* The GUI is responsible for implementing cursor reads. */
	xim_message (xim, "cursorMode", state ? "on" : "off");
}


/* XIM_SETMAPPING -- Set up a mapping between two rasters.
 */
void
xim_setMapping (xim, fb, frame, mapping, src, dst, fill_mode)
register FrameBufPtr fb;
register XimDataPtr xim;
int frame;
int mapping;
int src, dst;
int fill_mode;
{
	register Widget gt = xim->gt;
	int src_type, src_width, src_height, src_depth;
	int dst_type, dst_width, dst_height, dst_depth, dst_x, dst_y;
	float xscale, yscale, scale;
	int dx, dy, dnx, dny;
	int sx, sy, snx, sny;

	/* Get dimensions of source and destination rasters. */
	if (GtQueryRaster (gt, src,
		&src_type, &src_width, &src_height, &src_depth) == 0)
	    return;

	/* Get region of destination to be written into. */
	if (dst == 0) {
	    xim_getScreen (xim, frame,
		&dst_x, &dst_y, &dst_width, &dst_height, &dst_depth);
	} else {
	    if (GtQueryRaster (gt, dst,
		    &dst_type, &dst_width, &dst_height, &dst_depth) == 0)
		return;
	    dst_x = dst_y = 0;
	}

	xscale = (float)dst_width / (float)src_width;
	yscale = (float)dst_height / (float)src_height;

	switch (fill_mode) {
	case M_UNITARY:
	    /* Set up a unitary (one-to-one) mapping, i.e. one pixel in the
	     * source is mapped to one pixel in the destination.  The mapped
	     * region is the center of both rasters.
	     */
	    xscale = yscale = 1.0;
	    /* fall through */

	case M_ASPECT:
	    /* Scale the source to fit the destination, preserving the
	     * aspect ratio and displaying all source pixels.
	     */
	    scale = min (xscale, yscale);
	    if (abs(scale - (int)(scale+0.5)) < TOL)
		scale = (int)(scale+0.5);

	    dnx = src_width * scale;
	    if (dnx > dst_width) {
		/* Clip source rect. */
		dnx = dst_width;
		snx = dnx;
		sx = max (0, (src_width + 1) / 2 - snx / 2);
		dx = 0;
	    } else {
		/* Clip destination rect. */
		snx = src_width;
		sx = 0;
		dx = max (0, (dst_width + 1) / 2 - dnx / 2);
	    }

	    dny = src_height * scale;
	    if (dny > dst_height) {
		/* Clip source rect. */
		dny = dst_height;
		sny = dny;
		sy = max (0, (src_height + 1) / 2 - sny / 2);
		dy = 0;
	    } else {
		/* Clip destination rect. */
		sny = src_height;
		sy = 0;
		dy = max (0, (dst_height + 1) / 2 - dny / 2);
	    }

	    GtSetMapping (gt, mapping, xim->rop,
		src, GtPixel, sx, sy, snx, sny,
		dst, GtPixel, dst_x + dx, dst_y + dy, dnx, dny);
	    break;

	case M_FILL:
	    /* Scale the source to fill the destination window.
	     */
	    GtSetMapping (gt, mapping, xim->rop,
		src, GtPixel, 0, 0, src_width, src_height,
		dst, GtPixel, dst_x, dst_y, dst_width, dst_height);
	    break;
	}

	if (fb && mapping == fb->zoommap) {
	    fb->xmag = 1.0;
	    fb->ymag = 1.0;
	    fb->xscale = xscale;
	    fb->yscale = yscale;
	    fb->xcen = (src_width + 1) / 2.0;
	    fb->ycen = (src_height + 1) / 2.0;
	    fb->xflip = fb->yflip = 0;
	}
}


/* XIM_SETZOOM -- Modify a mapping between two rasters given the specified
 * view center and zoom factors.
 */
void
xim_setZoom (xim, fb, frame, mapping, src, dst, xcen,ycen,xmag,ymag, xoff,yoff, absolute)
register XimDataPtr xim;
register FrameBufPtr fb;
int frame;
int mapping;
int src, dst;
float xcen, ycen;	/* center of source raster region to be mapped */
float xmag, ymag;	/* magnification in each axis */
float xoff, yoff;	/* offset in each axis */
Boolean absolute;	/* ignore xscale/yscale */
{
	register Widget gt = xim->gt;
	int src_type, src_width, src_height, src_depth;
	int dst_type, dst_width, dst_height, dst_depth, dst_x, dst_y;
	int sx1, sx2, sy1, sy2, snx, sny;
	int dx1, dx2, dy1, dy2, dnx, dny;
	int fx1, fx2, fy1, fy2, shift;
	int src_recenter_allowed = 1;
	int dst_recenter_allowed = 1;
	int xreplicate, yreplicate;
	int scale, max_x, max_y, bias;
	float xscale, yscale;
	char buf[256];


	/* Get dimensions of source and destination rasters. */
	if (GtQueryRaster (gt, src,
		&src_type, &src_width, &src_height, &src_depth) == 0)
	    return;

	/* Get region of destination to be written into. */
	if (dst == 0) {
	    xim_getScreen (xim, frame,
		&dst_x, &dst_y, &dst_width, &dst_height, &dst_depth);
	} else {
	    if (GtQueryRaster (gt, dst,
		    &dst_type, &dst_width, &dst_height, &dst_depth) == 0)
		return;
	    dst_x = dst_y = 0;
	}

	/* Use old center if none given. */
	if (xcen <= 0)
	    xcen = fb->xcen;
	if (ycen <= 0)
	    ycen = fb->ycen;

	/* Get scaling ratios. */
	if (absolute) {
	    xscale = xmag;
	    yscale = ymag;
	} else {
	    xscale = xmag * fb->xscale;
	    yscale = ymag * fb->yscale;
	}

	/* Avoid roundoff if integer scaling. */
	if (xreplicate = (abs(xscale - (int)(xscale+0.5)) < TOL))
	    xscale = (int)(xscale+0.5);
	if (yreplicate = (abs(yscale - (int)(yscale+0.5)) < TOL))
	    yscale = (int)(yscale+0.5);

	/* Sanity check, return if we're getting too small. */
	if (xscale < TOL || yscale < TOL)
	    return;


	/* Map the destination rect back into the source with the given
	 * zoom factor and center, clipping the source rect at the source
	 * raster boundary.
	 */
src_recenter:
	max_x = src_width - 1;
	max_y = src_height - 1;

	snx = (int) (dst_width / xscale) + 1;
	sny = (int) (dst_height / yscale) + 1;

	sx1 = (int) (xcen - snx / 2.0 + 0.5 + xoff);		/*********/
	sx2 = (int) (xcen + snx / 2.0 + 0.5);
	sy1 = (int) (ycen - sny / 2.0 + 0.5 + yoff);		/*********/
	sy2 = (int) (ycen + sny / 2.0 + 0.5);

	/* Fiddle the source rect slightly if necessary to achieve the
	 * requested snx,sny.  This corrects for any pixel selection errors
	 * introduced in the float to integer truncation.  This is a small
	 * effect but it can be apparent at high pixel magnifications.
	 */
	sx2 -= ((sx2 - sx1 + 1) - snx);
	sy2 -= ((sy2 - sy1 + 1) - sny);

	if (src_recenter_allowed) {
	    /* Adjust the center of the source rect to make it fit on the
	     * source raster, but only if only one edge extends beyond the
	     * raster boundary.  If both edges are out of bounds we just
	     * clip below.
	     *
	     * MJF 9/29  - The changes to fx2/fy2 below are to fix an off-by-one
	     * error in the center pixel computed by an integer zoom.  For
	     * example, display a 256sq image, invert the cmap and zoom by
	     * two, the center is different than a straight centering op done
	     * by the pan function.  The effect is that hardcopy has an extra
	     * border on two sides.
	     */
	    fx1 = (sx1 < 0) ? -sx1 : 0;
	    fx2 = (sx2 > max_x) ? (max_x - sx2 + 1) : 0;
	    if (fx1 && !fx2 || !fx1 && fx2)
		xcen += (fx1 + fx2);

	    fy1 = (sy1 < 0) ? -sy1 : 0;
	    fy2 = (sy2 > max_y) ? (max_y - sy2 + 1) : 0;
	    if (fy1 && !fy2 || !fy1 && fy2)
		ycen += (fy1 + fy2);

	    src_recenter_allowed = 0;
	    goto src_recenter;
	}

	/* Clip the source rect to the raster boundary. */
	sx1 = max(0, min(max_x, sx1));
	sx2 = max(0, min(max_x, sx2));
	sy1 = max(0, min(max_y, sy1));
	sy2 = max(0, min(max_y, sy2));

	snx = sx2 - sx1 + 1;
	sny = sy2 - sy1 + 1;


	/* Map the zoomed, possibly centered, and clipped source rect back
	 * to the destination.
	 */
	max_x = dst_width - 1;
	max_y = dst_height - 1;

	dx1 = (int) ((sx1-0.5 - xcen) * xscale + dst_width / 2.0 + 0.5);
	dx2 = (int) ((sx2+0.5 - xcen) * xscale + dst_width / 2.0 + 0.5);
	dy1 = (int) ((sy1-0.5 - ycen) * yscale + dst_height / 2.0 + 0.5);
	dy2 = (int) ((sy2+0.5 - ycen) * yscale + dst_height / 2.0 + 0.5);

	if (dst_recenter_allowed) {
	    /* If the unclipped destination rect extends out of bounds on
	     * one side or the other (but not both), shift it slightly to 
	     * try to recenter it on the destination raster.  This tends
	     * to cancel out rounding errors occurring in the calculation
	     * of the destination rect.
	     */
	    fx1 = (dx1 < 0) ? -dx1 : 0;
	    fx2 = (dx2 > max_x) ? (max_x - dx2) : 0;
	    if (fx1 && !fx2 || !fx1 && fx2) {
		shift = (fx1 + fx2);
		dx1 += shift;
		dx2 += shift;
	    }

	    fy1 = (dy1 < 0) ? -dy1 : 0;
	    fy2 = (dy2 > max_y) ? (max_y - dy2) : 0;
	    if (fy1 && !fy2 || !fy1 && fy2) {
		shift = (fy1 + fy2);
		dy1 += shift;
		dy2 += shift;
	    }

	    /* If the destination rect does not fill the destination raster,
	     * center it in the raster.
	     */
	    if ((dx2 - dx1 + 1) < dst_width) {
		shift = (dx1 + (max_x - dx2)) / 2 - dx1;
		dx1 += shift;
		dx2 += shift;
	    }

	    if ((dy2 - dy1 + 1) < dst_height) {
		shift = (dy1 + (max_y - dy2)) / 2 - dy1;
		dy1 += shift;
		dy2 += shift;
	    }
	}

	/* Clip to the edge of the destination raster. */
	dx1 = max(0, min(max_x, dx1));
	dx2 = max(0, min(max_x, dx2));
	dy1 = max(0, min(max_y, dy1));
	dy2 = max(0, min(max_y, dy2));

	dnx = dx2 - dx1 + 1;
	dny = dy2 - dy1 + 1;

	/* Attempt to integerize things if integer scaling is selected.  This
	 * can leave a blank pixel or two at the edge depending upon the
	 * window size and scaling.
	 */
	scale = (int)xscale;
	if (xreplicate && dnx != snx * scale) {
	    if (snx < src_width) {
		snx = max(1, min(src_width, dnx / scale));
		dnx = max(1, min(dst_width, snx * scale));
	    } else if (dnx < dst_width) {
		dnx = max(1, min(dst_width, snx * scale));
		snx = max(1, min(src_width, dnx / scale));
	    }
	    if ((bias = ((dx2 - dx1 + 1) - dnx) / 2) > 0) {
		dx1 += bias;
		dx2 += bias;
	    }
	}
	scale = (int)yscale;
	if (yreplicate && dny != sny * scale) {
	    if (sny < src_height) {
		sny = max(1, min(src_height, dny / scale));
		dny = max(1, min(dst_height, sny * scale));
	    } else if (dny < dst_height) {
		dny = max(1, min(dst_height, sny * scale));
		sny = max(1, min(src_height, dny / scale));
	    }
	    if ((bias = ((dy2 - dy1 + 1) - dny) / 2) > 0) {
		dy1 += bias;
		dy2 += bias;
	    }
	}



	/* Set the mapping. */
        initialize_shadow_pixmap (gt, dst);
	GtSetMapping (gt, mapping, xim->rop,
	    src, GtPixel, sx1, sy1, snx, sny,
	    dst, GtPixel, dst_x + dx1, dst_y + dy1,
		fb->xflip ? -dnx : dnx,
		fb->yflip ? -dny : dny);

	/* Update the frame buffer zoom/pan/flip parameters. */
	fb->xcen = xcen;     fb->ycen = ycen;
	fb->xoff = xoff;     fb->yoff = yoff;

	if (absolute) {
	    fb->xmag = xmag / fb->xscale;
	    fb->ymag = ymag / fb->yscale;
	} else {
	    fb->xmag = xmag;
	    fb->ymag = ymag;
	}

	xim_frameRegion (xim, fb);
	sprintf (buf, "%g %g %g %g %g %g %g %g",
	    fb->xmag, fb->ymag, fb->xcen, fb->ycen, 
	    fb->xscale, fb->yscale, fb->xoff, fb->yoff);
	xim_message (xim, "frameView", buf);
}


/* XIM_GETSCREEN -- Determine the region of the display window to which
 * the given frame is mapped.
 */
xim_getScreen (xim, frame, sx, sy, width, height, depth)
register XimDataPtr xim;
int frame;
int *sx, *sy;
int *width, *height, *depth;
{
	register int i;
	int border = xim->tileBorder;
	int rtype, scr_width, scr_height;
	int twidth, theight, tileno, frameno;
	int tilex, tiley;
	int nrows = xim->tileRows, ncols = xim->tileCols;

	if (GtQueryRaster (xim->gt, 0,
		&rtype, &scr_width, &scr_height, depth) == 0)
	    return;

	/* Use the entire display window if we are not tiling frames, if
	 * there aren't enough frames to tile, or if the given frame is
	 * not in the list of tile frames.
	 */
	if (!xim->tileFrames || xim->nframes <= 1 ||
		!(xim->tileFramesList & (1 << frame-1))) {
	    *sx = *sy = 0;
	    *width = scr_width;
	    *height = scr_height;
	    return;
	}

	/* Get index of frame in tile Frames list. */
	for (i=1, frameno=0;  i <= xim->nframes;  i++) {
	    if (xim->tileFramesList & (1 << (i-1))) {
		frameno++;
		if (frame == i)
		    break;
	    }
	}

	/* Now compute the size of each tile. */
	tileno  = frameno - 1;
	twidth  = (scr_width  - (ncols * 2 * border)) / ncols;
	theight = (scr_height - (nrows * 2 * border)) / nrows;

	/* Get the "coordinates" of the tile in the mosaic. */
	if (xim->tileByRows) {
	    tilex = tileno % ncols;
	    tiley = tileno / ncols;
	} else {
	    tilex = tileno / nrows;
	    tiley = tileno % nrows;
	}
	if (!xim->tileTopDown)
	    tiley = (nrows - tiley - 1);

	/* Finally, get the placement of the tile on the screen. */
	*sx = tilex * twidth  + ((tilex*2+1) * border);
	*sy = tiley * theight + ((tiley*2+1) * border);

	*width = twidth;
	*height = theight;
}


/* XIM_ONSCREEN -- Test whether the given frame is visible onscreen.
 */
xim_onScreen (xim, frame)
register XimDataPtr xim;
int frame;
{
	if (xim->tileFrames)
	    return ((xim->tileFramesList & (1 << (frame-1))) != 0);
	else
	    return (frame == xim->display_frame);
}


/* XIM_SETFLIP -- Modify a mapping to flip the frame in X and/or Y.
 */
void
xim_setFlip (xim, fb, flip_x, flip_y)
register XimDataPtr xim;
register FrameBufPtr fb;
int flip_x, flip_y;
{
	register Widget gt = xim->gt;
	int src, st, sx, sy, snx, sny;
	int dst, dt, dx, dy, dnx, dny;
	int rop;

	if (!flip_x && !flip_y)
	    return;

	if (flip_x)
	    fb->xflip = !fb->xflip;
	if (flip_y)
	    fb->yflip = !fb->yflip;

	GtGetMapping (gt, fb->zoommap,
	    &rop, &src,&st,&sx,&sy,&snx,&sny, &dst,&dt,&dx,&dy,&dnx,&dny);

	dnx = abs (dnx);
	dnx = fb->xflip ? -dnx : dnx;
	dny = abs (dny);
	dny = fb->yflip ? -dny : dny;

	GtSetMapping (gt, fb->zoommap,
	    rop, src,st,sx,sy,snx,sny, dst,dt,dx,dy,dnx,dny);

	xim_message (xim, "xflip", fb->xflip ? "true" : "false");
	xim_message (xim, "yflip", fb->yflip ? "true" : "false");
}


/* XIM_SETROP -- Modify the rasterop portion of a mapping.
 */
void
xim_setRop (xim, fb, rop)
register XimDataPtr xim;
register FrameBufPtr fb;
int rop;
{
	register Widget gt = xim->gt;
	int src, st, sx, sy, snx, sny;
	int dst, dt, dx, dy, dnx, dny;
	int oldrop;

	GtGetMapping (gt, fb->zoommap,
	    &oldrop, &src,&st,&sx,&sy,&snx,&sny, &dst,&dt,&dx,&dy,&dnx,&dny);

	GtSetMapping (gt, fb->zoommap,
	    rop, src,st,sx,sy,snx,sny, dst,dt,dx,dy,dnx,dny);
}


/* XIM_SETCURSORPOS -- Set the cursor position.
 */
void
xim_setCursorPos (xim, sx, sy)
register XimDataPtr xim;
float sx, sy;			/* raster coordinates */
{
	GtSetRaster (xim->gt, xim->df_p->frameno);
	GtSetCursorPos (xim->gt, (int)sx, (int)sy);
	GtSetRaster (xim->gt, 0);
}


/* XIM_GETCURSORPOS -- Get the cursor position.  This is done to a fractional
 * pixel precision if the image is zoomed.
 */
void
xim_getCursorPos (xim, sx, sy, raster, frame)
register XimDataPtr xim;
float *sx, *sy;
int *raster, *frame;
{
	register FrameBufPtr fb;
	DPoint pv1, pv2;
	int rx, ry, rmap;
	int src, x, y, i;

	GtGetCursorPos (xim->gt, &x, &y);
	src = GtSelectRaster (xim->gt, 0, GtPixel, x,y, GtNDC, &rx, &ry, &rmap);

	pv1.x = rx;  pv1.y = ry;
	GtNDCToPixel (xim->gt, src, &pv1, &pv2, 1);
	*sx = pv2.x;
	*sy = pv2.y;

	if (raster)
	    *raster = src;

	if (frame) {
	    *frame = xim->display_frame;
	    for (i=1;  i < xim->nframes;  i++) {
		fb = &xim->frames[i-1];
		if (fb->raster == src || fb->zoomras == src) {
		    *frame = fb->frameno;
		    break;
		}
	    }
	}
}


/* XIM_READDISPLAY -- Read a region of the current display frame and return
 * the pixels and corresponding RGB colormap.  We allocate a pointer to the
 * pixels that needs to be freed later on.  Note this routine returns an
 * 8 bit RGB colormap.
 */
unsigned char *
xim_readDisplay (xim, x0,y0,nx,ny, w,h, r,g,b, ncolors) 
register XimDataPtr xim;
int x0,y0,nx,ny;			/* region to extract (input) */
int *w, *h;				/* size of output region (output). */
unsigned char *r, *g, *b;		/* colortable (output) */
int *ncolors;				/* size of colortable (output) */
{
	register Widget gt = xim->gt;
	register int i, j;

	int raster, x1, y1, nc;
	int first, nelem, maxelem;
	char buf[SZ_LINE], *tmpfile;
	unsigned short *rs, *gs, *bs;
	int junk, width, height, depth;
	unsigned short *cmap=NULL, *iomap=NULL;
	unsigned char *pixels=NULL;
	static int debug = 0;

	/* The display is raster zero. */
	raster = 0;

	/* Get the size of the raster we're going to extract.  If nx or ny
	 * is zero use the entire raster, else use the indicated region.
	 * If a region is given clip it to the raster boundary.
	 */
	if (GtQueryRaster (gt, raster, &junk, &width, &height, &depth) == 0)
	    goto error;


	if (nx <= 0 || ny <= 0) {
	    x0 = y0 = 0;
	    nx = width;
	    ny = height;
	} else {
	    x1 = min (width-1, x0 + nx - 1);
	    y1 = min (height-1, y0 + ny - 1);
	    x0 = max (0, x0);
	    y0 = max (0, y0);
	    nx = x1 - x0 + 1;
	    ny = y1 - y0 + 1;
	}

	/* Get a pixel buffer and read the pixels. */
	if (nx*ny <= 0 || !(pixels = (unsigned char *) malloc (nx * ny)))
	    goto error;
	if (GtReadPixels (gt, raster, pixels, 8, x0, y0, nx, ny) < 0)
	    goto error;


	/* Get Gterm widget colormap. */
	if (!(cmap = (ushort *) malloc (3 * MAX_COLORS * sizeof(ushort))))
	    goto error;

	rs = cmap;
	gs = rs + MAX_COLORS;
	bs = gs + MAX_COLORS;

	if (depth == 8) {
	    nc = GtReadColormap (gt, raster, 0, MAX_COLORS, rs,gs,bs);
	    if (nc <= 0)
	        goto error;


	    /* Get the RGB color associated with each pixel.  To determine
	    ** this we must consider both the Gterm widget colormap and iomap.
	    ** The iomap maps client pixels to Gterm widget pixels, and the 
	    ** colormap maps Gterm widget pixels to RGB values.  GtReadPixels
	    ** returns client pixels, so to get the RGB value associated with
	    ** each client pixel we must run the client pixel through the iomap
	    ** to get the Gterm widget pixel, and then use this to look up the
	    ** RGB value in the widget's colormap.  When reading the display
	    ** (raster=0) we get the colormap corresponding to the image as
	    ** currently windowed, hence the output image will be rendered as
	    ** in the current display. Note: the Gterm widget maps are 16 bits,
	    ** while we return an 8 bit RGB colormap to our caller.
	    */
	    /* Get iomap. */
	    if (!(iomap = (ushort *) malloc (MAX_COLORS * sizeof(ushort))))
	        goto error;
	    GtReadIomap (gt, iomap, 0, MAX_COLORS);

	    if (debug) {
	        register short pmin = MAX_COLORS, pmax = 0, i, j;
                fprintf (stderr, "iomap\n");
	        for (i=0; i < MAX_COLORS; ) {
                    for (j=0; j < 8 && i < MAX_COLORS; j++) {
		        pmin = (iomap[i] < pmin ? iomap[i] : pmin);
		        pmax = (iomap[i] > pmax ? iomap[i] : pmax);
                        fprintf (stderr, "%3d(%3d) ", i, iomap[i++]);
		    } 
                    fprintf (stderr, "\n");

	        }
	        fprintf (stderr, "iomap min = %d max = %d\n", pmin, pmax);
                fprintf (stderr, "Gterm Colormap\n");
                for (i=0; i < MAX_COLORS; ) {
                    for (j=1; j < 4 && i < MAX_COLORS; j++)
                        fprintf (stderr, "    %3d(%3d,%3d,%3d)",i,
			    (rs[i]>>8),(gs[i]>>8),(bs[i++]>>8));
                    fprintf (stderr, "\n");
                }
	        fflush (stderr);
	    }

	    /* Output the colormap. */
	    for (i=0;  i < nc;  i++) {
	        j = iomap[i];
	        r[i] = (rs[j] >> 8);
	        g[i] = (gs[j] >> 8);
	        b[i] = (bs[j] >> 8);
	    }
	    for (i=nc;  i < MAX_COLORS;  i++) {
	        j = iomap[i];
	        r[i] = (rs[j] >> 8);
	        g[i] = (gs[j] >> 8);
	        b[i] = (bs[j] >> 8);
	    }

	} else {
	    unsigned long lut[MAX_COLORS];
	    int   start = 10;			/* static colors offset  */

	    GtReadLUT (gt, lut, 0, MAX_COLORS);

	    nc = 216;
	    for (i=0; i < nc; i++) {
	        r[i] = (lut[i] >> 16) & 0xff;
	        g[i] = (lut[i] >>  8) & 0xff;
	        b[i] = (lut[i]      ) & 0xff;
	    }
	}

	*w = nx;
	*h = ny;
	*ncolors = nc;			/* includes static colors */

	if (debug) {
	    fprintf (stderr,
		"xim_readDisplay:  w=%d  h=%d  d=%d\n", width, height, depth);
	    for (i=0; i < nc; i++)
  	        fprintf (stderr, "xim_readDisplay[%3d]:  %3d %3d %3d\n",
		i, r[i], g[i], b[i]);
	}

	free ((char *) cmap);
	free ((char *) iomap);

	return (pixels);

error:
	if (cmap)
	    free ((char *) cmap);
	if (iomap)
	    free ((char *) iomap);
	if (pixels)
	    free ((char *) pixels);
	return (NULL);
}


/* XIM_WRITEDISPLAY -- Load the current display frame from the pixel array
 * and RGB colormap passed in the input arguments.  The data is assumed to
 * be 8 bit pseudocolor.
 */
int
xim_writeDisplay (xim, frame, mapname, pixels, w,h, r,g,b, ncolors)
register XimDataPtr xim;
int frame;				/* display frame to be written */
char *mapname;				/* colormap name to be written */
unsigned char *pixels;
int w, h;
unsigned char *r, *g, *b;
int ncolors;
{
	register int i, j;
	register FrameBufPtr fb;
	register Widget gt = xim->gt;
	unsigned short rs[MAX_COLORS], gs[MAX_COLORS], bs[MAX_COLORS];
	unsigned short iomap[MAX_COLORS], sv_iomap[MAX_COLORS];
	unsigned short invmap[MAX_COLORS];
	int want, npix, nx, ny, sx0, sy0, dx0, dy0;
	int sx, sy, width, height, depth;
	float xzoom, yzoom, zoom;
	int debug=0, autoscale=xim->autoscale;
	unsigned char *gtpix;
	ColorMapPtr cm;


	if (DBG_RASTER)
	    fprintf (stderr, "raster writeDisplay: .......................");

	/* If frame=0 use the current display frame. */
	if (frame < 1) frame = xim->display_frame;

	/* Create additional frames if needed. */
	if (frame > xim->nframes) {
            for (i=1;  i <= frame;  i++) {
                fb = &xim->frames[i-1];
                if (fb->frameno != i) {
                    xim_initFrame (xim, i, frame,
                        &xim->fb_config[xim->fb_configno-1], xim->memModel);

                    /* If we're in tile mode, add the frame to the tile list
                     * and if needed resize the tile frames.
                     */
                    if (xim->tileFrames) {
                        xim->tileFramesList |= (1 << (i-1));
                        xim->nTileFrames++;
                        xim_tileFrames (xim, xim->tileFramesList);
                    }
                }
            }
	}


	/* Erase the existing frame before disabling the mapping, otherwise
	 * we get a white background when the new image is loaded.
	 */
	xim_eraseFrame (xim, frame);

	fb = &xim->frames[frame-1];
	GtDisableMapping (gt, fb->dispmap, 0);

	/* Substitute a one-to-one iomap so that we don't confuse colors for
	 * a non-continuous tone (grayscale) image.
	 */
	GtReadIomap (gt, sv_iomap, 0, MAX_COLORS);
	for (i=0;  i < MAX_COLORS;  i++)
	    iomap[i] = FIRST_COLOR + min (xim->ncolors, i);
	GtWriteIomap (gt, iomap, 0, MAX_COLORS);

	/* If debug mode is enabled compute and print the minimum and maximum
	 * pixel values and a histogram or count of the number of pixels at
	 * each value.
	 */
	if (debug) {
	    int count[MAX_COLORS];
	    int v, lo, hi;

	    memset ((void *)count, 0, sizeof(count));
	    for (i=0, lo=MAX_COLORS, hi=0;  i < w*h;  i++) {
		v = pixels[i];
		count[v]++;
		if (v < lo)
		    lo = v;
		else if (v > hi)
		    hi = v;
	    }
	    fprintf (stderr, "%s: w=%d h=%d min=%d max=%d\n",
		mapname, w, h, lo, hi);

	    for (i=0, j=0;  i < MAX_COLORS;  i++)
		if (count[i]) {
		    fprintf (stderr, "  %3d(%4d)", i, min(9999,count[i]));
		    if (++j >= 7) {
			fprintf (stderr, "\n");
			j = 0;
		    }
		}
	    if (j)
		fprintf (stderr, "\n");

	    fprintf (stderr, "zeros: ");
	    for (i=0;  i < MAX_COLORS;  i++)
		if (!count[i])
		    fprintf (stderr, " %d", i);
	    fprintf (stderr, "\n");
	}

	/* Invert the iomap.  We want to map standard pixels 0-N to the range
	 * FC-FC+N in Gterm color space (FC is shorthand for FIRST_COLOR).
	 * GtWritePixels will process pixels through the ximtool iomap so we
	 * need to compute invmap, which tells us the input value needed to
	 * get the desired value of out the iomap.
	GtReadIomap (gt, iomap, 0, MAX_COLORS);
	memset ((void *)invmap, 0, sizeof(invmap));
	for (i=0;  i < MAX_COLORS;  i++)
	    invmap[iomap[i]] = i;
	if (!(gtpix = (unsigned char *) malloc (npix = w * h)))
	    return (-1);
	for (i=0;  i < npix;  i++) {
	    want = FIRST_COLOR + pixels[i];
	    gtpix[i] = invmap[want];
	}
	free ((char *) gtpix);
	 */

	/* If the image is too large to fit in the existing frame clip it
	 * to fit (we need to add an auto-resize option here later).
	 */
	if (w > xim->width) {
	    nx = xim->width;
	    sx0 = (w - nx) / 2;
	    dx0 = 0;
	} else {
	    nx = w;
	    sx0 = 0;
	    dx0 = (xim->width - w) / 2;
	}

	if (h > xim->height) {
	    ny = xim->height;
	    sy0 = (h - ny) / 2;
	    dy0 = 0;
	} else {
	    ny = h;
	    sy0 = 0;
	    dy0 = (xim->height - h) / 2;
	}

	/* Load the frame.  The GtWritePixels call loads to the raster 
	 * associated with the frame, not the frame number directly.
	 */
	if (nx <= xim->width && ny <= xim->height) {
	    GtWritePixels (gt, fb->raster, pixels, 8, dx0, dy0, nx, ny);
	} else {
	    unsigned char *ip = pixels + sy0 * w + sx0;
	    for (i=0;  i < ny;  i++, ip += w)
		GtWritePixels (gt, fb->raster, ip, 8, dx0, dy0+i, nx, 1);
	}

	/* Get screen size. */
	xim_getScreen (xim, 1, &sx, &sy, &width, &height, &depth);

	/* Compute the new scale factor required to scale the source to the
	 * destination at magnification 1.0.
	 */
	if (autoscale) {
	    xzoom = (float)width / (float)nx;
	    yzoom = (float)height / (float)ny;
	    zoom = min (xzoom, yzoom);
	} else {
	    xzoom = 1.0;
	    yzoom = 1.0;
	    zoom = 1.0;
	}

	/* Set the new mapping. */
	fb->xmag = fb->ymag = zoom;
	fb->xcen = xim->width / 2;
	fb->ycen = xim->height / 2;

	/* Zoom it to fill the display window. */
	xim_setZoom (xim, fb, frame, fb->zoommap, fb->raster, fb->zoomras,
	    fb->xcen, fb->ycen, fb->xmag, fb->ymag, 
	    fb->xoff, fb->yoff, True);

	/* Check if the named colortable is already defined.  If not, add
	 * another one.  If ncolors=0 omit the colortable handling, e.g.
	 * when loading a raster that doesn't have a colormap.
	 */
	if (ncolors > 0) {
	    for (i=0, cm=NULL;  i < ncolormaps;  i++)
		if (strcmp (colormaps[i].name, mapname) == 0) {
		    cm = &colormaps[i];
		    break;
		}
	    if (!cm) {
		if (ncolormaps >= MAX_COLORMAPS - 1)
		    cm = &colormaps[ncolormaps];
		else {
		    cm = &colormaps[ncolormaps++];
		    cm->mapno = GtNextColormap (gt);
		}
		strcpy (cm->name, mapname);
		ncolormaps = min (MAX_COLORMAPS-1, ncolormaps);

		/* Pass the list of colortables on to the user interface. */
		xim_colortables (xim);
	    }

	    for (i=0;  i < ncolors;  i++) {
		rs[i] = (r[i] << 8);
		gs[i] = (g[i] << 8);
		bs[i] = (b[i] << 8);
	    }

	    if (DBG_RASTER)
		fprintf (stderr,"raster writeDisplay: writing colormap.......");
	    GtWriteColormap (gt, cm->mapno,
		FIRST_COLOR, min(ncolors,xim->ncolors), rs, gs, bs);
	    if (DBG_RASTER)
		fprintf (stderr,
		    "raster writeDisplay: writing colormap.......DONE");

	    fb->offset = 0.5;
	    fb->scale = (xim->invert ? -1.0 : 1.0);
	    fb->colormap = cm->mapno;
	} else 
	    cm = &colormaps[fb->colormap-1];

	/* Display the frame. */
	GtEnableMapping (gt, fb->dispmap, 1);
	GtSetDisplayRaster (gt, xim->display_frame);
	xim_setDisplayFrame (xim, frame);

	GtSetColormapFocus (-1);	/* force full update	*/
	GtLoadColormap (gt, cm->mapno, fb->offset, fb->scale);
	GtSetColormapFocus (xim->cm_focus);
	xim_enhancement (xim, fb);

	GtWriteIomap (gt, sv_iomap, 0, MAX_COLORS);

	if (DBG_RASTER)
	    fprintf (stderr, "raster writeDisplay: ......................DONE");
	return (0);
}


/* XIM_MESSAGE -- Send a message to the user interface.
 */
void
xim_message (xim, object, message)
register XimDataPtr xim;
char *object;
char *message;
{
	char msgbuf[SZ_MSGBUF];

	sprintf (msgbuf, "setValue {%s}", message);
	ObmDeliverMsg (xim->obm, object, msgbuf);
}


/* XIM_MSGI -- Like xim_message, but the message is an integer value.
 */
void
xim_msgi (xim, object, value)
register XimDataPtr xim;
char *object;
int value;
{
	char msgbuf[SZ_LINE];
	sprintf (msgbuf, "setValue {%d}", value);
	ObmDeliverMsg (xim->obm, object, msgbuf);
}


/* XIM_ALERT -- Issue an alert to the server.  The message text input will
 * be displayed and either the ok (proceed) or cancel action will be taken,
 * causing the action text input to be sent back to the client to be
 * executed as a command.  This is used to alert the server (i.e. user) of
 * unusual circumstances and determine whether or not the server wants to
 * proceed.  An alert with no actions is a warning.
 */
void
xim_alert (xim, text, ok_action, cancel_action)
register XimDataPtr xim;
char *text;			/* message text */
char *ok_action;		/* command sent back to client for "ok" */
char *cancel_action;		/* command sent back to client for "cancel" */
{
	char msgbuf[SZ_LINE];
	sprintf (msgbuf, "setValue {{%s} {%s} {%s}}", text,
	    ok_action ? ok_action : "", cancel_action ? cancel_action : "");
	ObmDeliverMsg (xim->obm, "alert", msgbuf);
}


/*
 * Internal Routines.
 * -------------------
 */

/* XIM_FRAMEREGION -- Called when the value of the frameRegion UI parameter
 * needs to be updated.
 */
static void
xim_frameRegion (xim, fb)
register XimDataPtr xim;
register FrameBufPtr fb;
{
	int rop, src, dst;
	int st, sx, sy, snx, sny;
	int dt, dx, dy, dnx, dny;
	char buf[SZ_LINE];

	if (GtGetMapping (xim->gt, fb->zoommap, &rop,
	    &src, &st, &sx, &sy, &snx, &sny,
	    &dst, &dt, &dx, &dy, &dnx, &dny) == -1)
		return;

	/* args: frame x y width height */
	sprintf (buf, "%d %d %d %d %d", fb->frameno, sx, sy, snx, sny);
	xim_message (xim, "frameRegion", buf);
}


/* XIM_COLORTABLES -- Called when the "colortables" UI parameter needs to be
 * updated, i.e., when some change to the list of colormaps has occurred.
 */
static void
xim_colortables (xim)
XimDataPtr xim;
{
	register char *ip, *op;
	char buf[MAX_COLORMAPS*40];
	int i;

	for (i=0, op=buf;  i < ncolormaps;  i++) {
	    *op++ = '"';
	    for (ip = colormaps[i].name;  *op = *ip++;  op++)
		;
	    *op++ = '"';
	    *op++ = '\n';
	}
	*op++ = '\0';

	xim_message (xim, "colortables", buf);
}


/* XIM_ENHANCEMENT -- Called when the "enhancement" UI parameter needs to
 * be updated for a frame.
 */
xim_enhancement (xim, fb)
register XimDataPtr xim;
register FrameBufPtr fb;
{
	char buf[SZ_LINE];

	sprintf (buf, "%d \"%s\" %0.3f %0.3f", fb->frameno,
	    colormaps[fb->colormap-1].name, fb->offset, fb->scale);
	xim_message (xim, "enhancement", buf);


	/* Force an update of the colorbar.  On TrueColor visuals this
	** is required since the colormap doesn't automatically update 
	** the display.
	*/
	set_colorbar (xim, xim->cb);
}


/* GET_FBCONFIG -- Read the XIMTOOL startup file to get the set of possible
 * frame buffer sizes.
 *
 * File format:		configno nframes width height [extra fields]
 *	e.g.,			1  2  512  512
 *				2  2  800  800
 *				3  1 1024 1024		# comment
 */
static void
get_fbconfig (xim)
register XimDataPtr xim;
{
	register char	*ip;
	register FILE	*fp = NULL;
	int	config, nframes, width, height, i;
	char	lbuf[SZ_LINE+1], *fname;
	static char *fb_paths[] = {
		"/usr/local/lib/imtoolrc",
		"/opt/local/lib/imtoolrc",
		"/iraf/iraf/dev/imtoolrc",
		"/local/lib/imtoolrc",
		"/usr/iraf/dev/imtoolrc",
		"/usr/local/iraf/dev/imtoolrc",
		NULL};

	/* Initialize the config table. */
	xim->fb_configno = 1;
	for (i=0;  i < MAX_FBCONFIG;  i++) {
	    xim->fb_config[i].nframes = 1;
	    xim->fb_config[i].width = DEF_FRAME_WIDTH;
	    xim->fb_config[i].height = DEF_FRAME_HEIGHT;
	}

	/* Now add in some defaults for commonly used sizes based on the
 	 * standard IRAF imtoolrc file, we'll avoid any instrument specific
	 * configurations.
	 */
	xim->fb_config[0].width = xim->fb_config[0].height =  512;
	xim->fb_config[1].width = xim->fb_config[1].height =  800;
	xim->fb_config[2].width = xim->fb_config[2].height = 1024;
	xim->fb_config[3].width = xim->fb_config[3].height = 1600;
	xim->fb_config[4].width = xim->fb_config[4].height = 2048;
	xim->fb_config[5].width = xim->fb_config[5].height = 4096;

	/* Attempt to open the config file. */
	if ((fname=getenv(FBCONFIG_ENV1)) || (fname=getenv(FBCONFIG_ENV2)))
	    fp = fopen (fname, "r");
	if (!fp && (fname = getenv ("HOME"))) {
	    sprintf (lbuf, "%s/%s", fname, FBCONFIG_1);
	    fp = fopen (fname = lbuf, "r");
	    if (fp) {
	        xim->imtoolrc = (char *) XtCalloc (SZ_LINE, sizeof(char));
		strncpy (xim->imtoolrc, fname, strlen(fname));
	    }
	}
	if (!fp)
	    fp = fopen (fname = xim->imtoolrc, "r");
 	for (i=0; !fp && fb_paths[i]; i++) {
	    if ((fp = fopen (fname = fb_paths[i], "r"))) {
	        xim->imtoolrc = XtCalloc(strlen(fb_paths[i]+1),sizeof(char));
		strncpy (xim->imtoolrc, fb_paths[i],strlen(fb_paths[i]));
		break;
	    }
	}
	if (!fp) {
	    fprintf (stderr, 
		"Warning: No frame buffer configuration file found.\n");
	    return;
	}


	/* Scan the frame buffer configuration file.
	 */
	while (fgets (lbuf, SZ_LINE, fp) != NULL) {
	    /* Skip comment lines and blank lines. */
	    for (ip=lbuf;  *ip == ' ' || *ip == '\t';  ip++)
		;
	    if (*ip == '\n' || *ip == '#')
		continue;
	    if (!isdigit (*ip))
		continue;
	    switch (sscanf (ip, "%d%d%d%d", &config,&nframes,&width,&height)) {
	    case 4:
		break;			/* normal case */
	    case 3:
		height = width;		/* default to square format */
		break;
	    default:
		fprintf (stderr, "ximtool: bad config `%s'\n", ip);
		continue;
	    }

	    nframes = max (1, nframes);
	    width   = max (1, width);
	    height  = max (1, height);

	    /* Since the frame buffer is stored in a memory pixrect
	     * (effectively), the line length should be an integral number
	     * of 16 bit words.
	     */
	    if (width & 1) {
		fprintf (stderr, "imtool warning: fb config %d [%d-%dx%d] - ",
		    config, nframes, width, height);
		fprintf (stderr, "frame width should be even, reset to %d\n",
		    --width);
	    }

	    config = max(1, min(MAX_FBCONFIG, config)) - 1;
	    xim->fb_config[config].nframes = nframes;
	    xim->fb_config[config].width   = width;
	    xim->fb_config[config].height  = height;
	}

	if (fp) fclose (fp);
}


/* XIM_GETANTIALIAS -- Convert a antialias algorithm expressed as a string
 * into a Gterm rasterop code.
 */
xim_getAntialias (xim, s)
XimDataPtr xim;
char *s;
{
    register char *ip, *op;
    char word[SZ_NAME];
    int rop = 0;

    for (ip=s;  *ip && isspace(*ip);  ip++)
	;

    while (*ip) {
	for (op=word;  *ip && isalnum(*ip);  ip++)
	    *op++ = isupper(*ip) ? tolower(*ip) : *ip;
	*op++ = '\0';

	if (strcmp (word, "nearest") == 0)
	    rop |= MF_NEAREST;
	else if (strcmp (word, "bilinear") == 0)
	    rop |= MF_BILINEAR;
	else if (strcmp (word, "area") == 0)
	    rop |= MF_AREA;
	else if (strcmp (word, "blkavg") == 0)
	    rop |= MF_BLKAVG;
	else if (strcmp (word, "boxcar") == 0)
	    rop |= MF_BOXCAR;
	else if (strcmp (word, "lowpass") == 0)
	    rop |= MF_LOWPASS;
	else if (strcmp (word, "gaussian") == 0)
	    rop |= MF_GAUSSIAN;

	while (*ip && !isalnum(*ip))
	    ip++;
    }

    return (rop);
}


/* XIM_SETCOLORMAP -- Set up the RGB lookup tables used to map the windowed
 * monochrome output of a frame buffer into the hardware colormap.
 */
xim_setColormap (function, dirs, m_red, m_green, m_blue, nelem)
char *function;			/* type of colormap */
String *dirs;
unsigned short *m_red;
unsigned short *m_green;
unsigned short *m_blue;
int nelem;
{
	register int i, j;
	register char *ip, *op;
	static int seed = 0;
	int v, vsat, step;
	int knot[7];
	float frac;

	
	if (DBG_RASTER)
	    fprintf (stderr,
		"xim_setColormap: name='%s'  nelem=%d\n", function, nelem);

	vsat = MAX_COLORS - 1;
	step = MAX_COLORS / 6;
	for (i=0;  i < 7;  i++)
	    knot[i] = i * step;
	knot[6] = vsat;

	if (dirs) {
	    /* Load the colormap from a file. */
	    char fname[SZ_FNAME];
	    char lbuf[SZ_LINE];
	    TripletPtr p;
	    Lut user;
	    FILE *fp;

	    /* Get full file pathname.  If the same file is found in multiple
	     * directories the first version found is used.
	     */
	    strcpy (fname, function);
	    for (i=0;  function[0] != '/' && dirs[i];  i++) {
		for (ip=dirs[i], op=fname;  *ip;  )
		    *op++ = *ip++;
		if (op > fname && *(op-1) != '/')
		    *op++ = '/';
		for (ip=function;  *ip;  )
		    *op++ = *ip++;
		*op = '\0';
		if (access (fname, 0) == 0)
		    break;
	    }

	    /* Try to open the file. */
	    if ((fp = fopen (fname, "r")) == NULL) {
		fprintf (stderr, "cannot open %s\n", fname);
		return (ERR);
	    }

	    /* Scan the file.  The user colormap may have any number of
	     * RGB pairs up to a maximum of MAX_COLORS (256).
	     */
	    user.lutlen = 0;
	    while (fgets (lbuf, SZ_LINE, fp)) {
		char *np, *next;
		float v[3];

		/* Ignore blank lines and comment lines. */
		for (ip=lbuf;  isspace(*ip);  ip++)
		    ;
		if (*ip == '\0' || *ip == '#')
		    continue;
		if (user.lutlen+1 >= MAX_COLORS)
		    break;

		/* Get an RGB entry. */
		p = &user.hue[user.lutlen++];
		for (i=0, np=ip;  i < 3;  i++, np=next) {
		    v[i] = strtod (np, &next);
		    if (next == np) {
			fclose (fp);
			return (ERR);
		    }
		}

		p->red = v[0];
		p->green = v[1];
		p->blue = v[2];
	    }

	    fclose (fp);
	    if (user.lutlen <= 0)
		return (ERR);

	    /* Scale the user colormap to fit the NELEMS colors required
	     * for the output colormap.  nelem and lutlen must be the same
	     * to disable scaling and preserve the exact colortable values.
	     */
	    for (i=0;  i < nelem;  i++) {
		float x, w1, w2;
		float r, g, b;

		x = (float)i / (float)(nelem - 1) * (user.lutlen - 1);
		j = max(0, min(user.lutlen-1, (int)x));
		w1 = 1.0 - (x - j);
		w2 = 1.0 - w1;

		r = user.hue[j].red;
		g = user.hue[j].green;
		b = user.hue[j].blue;

		if (w2 > 0.0001 && j+1 < user.lutlen) {
		    r = r * w1 + user.hue[j+1].red * w2;
		    g = g * w1 + user.hue[j+1].green * w2;
		    b = b * w1 + user.hue[j+1].blue * w2;
		}

		m_red[i]   = r * vsat;
		m_green[i] = g * vsat;
		m_blue[i]  = b * vsat;
	    }

	} else if (strncmp (function, "Grayscale", 9) == 0) {
	    for (i=0;  i < nelem;  i++)
		m_red[i] = m_green[i] = m_blue[i] =
		    (float)i / (float)(nelem - 1) * vsat;

	} else if (strncmp (function, "HSV", 3) == 0) {
	    /* HSV: hue varies uniformly from 270 to 360 and back to 270.
	     * Value varies from zero to one using a cube root relation
	     * which causes the value to approach 1.0 rapidly away from zero.
	     * Saturation is zero near the endpoints, causing the curve
	     * to range from black to white at the endpoints, but ranges
	     * to 1.0 at the halfway point, causing nearly saturated colors
	     * in the middle of the range.
	     */
	    for (i=0;  i < nelem;  i++) {
		float h, s, v, r, g, b;
		double pow(), sin();

		frac = 1.0 - ((float)i / (float)(nelem - 1));
		h = frac * 360.0 + 270.0;
		s = abs (sin (frac * 3.1416));
		v = pow ((1.0 - frac), (1.0 / 3.0));

		hsv_to_rgb (h, s, v, &r, &g, &b);
		m_red[i]   = r * vsat;
		m_green[i] = g * vsat;
		m_blue[i]  = b * vsat;
	    }

	} else if (strncmp (function, "Heat", 4) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = heat.hue[j].red   * vsat;
		m_green[i] = heat.hue[j].green * vsat;
		m_blue[i]  = heat.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Ramp", 4) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = heat.hue[j].red   * (frac * (vsat * 2));
		m_green[i] = heat.hue[j].green * (frac * (vsat * 2));
		m_blue[i]  = heat.hue[j].blue  * (frac * (vsat * 2));
	    }

	} else if (strncmp (function, "AIPS0", 5) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = aips0.hue[j].red   * vsat;
		m_green[i] = aips0.hue[j].green * vsat;
		m_blue[i]  = aips0.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Color", 5) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = color.hue[j].red   * vsat;
		m_green[i] = color.hue[j].green * vsat;
		m_blue[i]  = color.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Staircase", 9) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = staircase.hue[j].red   * vsat;
		m_green[i] = staircase.hue[j].green * vsat;
		m_blue[i]  = staircase.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Standard", 8) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = standard.hue[j].red   * vsat;
		m_green[i] = standard.hue[j].green * vsat;
		m_blue[i]  = standard.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Red", 3) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = red.hue[j].red   * vsat;
		m_green[i] = red.hue[j].green * vsat;
		m_blue[i]  = red.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Green", 5) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = green.hue[j].red   * vsat;
		m_green[i] = green.hue[j].green * vsat;
		m_blue[i]  = green.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Blue", 4) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = blue.hue[j].red   * vsat;
		m_green[i] = blue.hue[j].green * vsat;
		m_blue[i]  = blue.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Halley", 6) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = halley.hue[j].red   * vsat;
		m_green[i] = halley.hue[j].green * vsat;
		m_blue[i]  = halley.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Rainbow1", 8) == 0) {
	    for (i=0;  i < nelem;  i++)
		m_red[i] = m_green[i] = m_blue[i] = 0;

	    for (i=knot[0];  i <= knot[1];  i++)
		m_blue[i] = vsat * (i - knot[0]) / step;
	    for (i=knot[1];  i <= knot[2];  i++)
		m_blue[i] = vsat;
	    for (i=knot[2];  i <= knot[3];  i++)
		m_blue[i] = vsat * (knot[3] - i) / step;

	    for (i=knot[1];  i <= knot[2];  i++)
		m_green[i] = vsat * (i - knot[1]) / step;
	    for (i=knot[2];  i <= knot[4];  i++)
		m_green[i] = vsat;
	    for (i=knot[4];  i <= knot[5];  i++)
		m_green[i] = vsat * (knot[5] - i) / step;

	    for (i=knot[3];  i <= knot[4];  i++)
		m_red[i] = vsat * (i - knot[3]) / step;
	    for (i=knot[4];  i <= knot[6];  i++)
		m_red[i] = vsat;

	    for (i=knot[5];  i <= knot[6];  i++) {
		if ((v = vsat * (i - knot[5]) / step) > vsat)
		    v = vsat;
		m_green[i] = m_blue[i] = v;
	    }

	} else if (strncmp (function, "Rainbow2", 8) == 0) {
	    for (i=0;  i < nelem;  i++) {
		frac = (float)i / (float)(nelem - 1);
		j = frac * (heat.lutlen - 1);
		m_red[i]   = rainbow.hue[j].red   * vsat;
		m_green[i] = rainbow.hue[j].green * vsat;
		m_blue[i]  = rainbow.hue[j].blue  * vsat;
	    }

	} else if (strncmp (function, "Random16", 8) == 0) {
	    int red, green, blue;
	    
	    if (!seed)
		seed = time(0);
	    srand (seed++);

	    for (i=0;  i < nelem;  ) {
		red   = ((rand() >> 4) % vsat);
		green = ((rand() >> 4) % vsat);
		blue  = ((rand() >> 4) % vsat);

		for (j=0;  i < nelem && j < nelem/16;  j++, i++) {
		    m_red[i]   = red;
		    m_green[i] = green;
		    m_blue[i]  = blue;
		}
	    }

	} else if (strncmp (function, "Random8", 7) == 0) {
	    int red, green, blue;
	    
	    if (!seed)
		seed = time(0);
	    srand (seed++);

	    for (i=0;  i < nelem;  ) {
		red   = ((rand() >> 4) % vsat);
		green = ((rand() >> 4) % vsat);
		blue  = ((rand() >> 4) % vsat);

		for (j=0;  i < nelem && j < nelem/8;  j++, i++) {
		    m_red[i]   = red;
		    m_green[i] = green;
		    m_blue[i]  = blue;
		}
	    }

	} else if (strncmp (function, "Random", 6) == 0) {
	    if (!seed)
		seed = time(0);
	    srand (seed++);
	    for (i=0;  i < nelem;  i++) {
		m_red[i]   = ((rand() >> 4) % vsat);
		m_green[i] = ((rand() >> 4) % vsat);
		m_blue[i]  = ((rand() >> 4) % vsat);
	    }
	}

	/* Scale colormap values to 16 bits. */
	for (i=0;  i < nelem;  i++) {
	    m_red[i]   <<= 8;
	    m_green[i] <<= 8;
	    m_blue[i]  <<= 8;
	}

	return (OK);
}


hsv_to_rgb (h, s, v, r, g, b)
float h, s, v;
float *r, *g, *b;
{
	register int i;
	float f, p, q, t;

	while (h >= 360.0)
	    h -= 360.0;

	h /= 60.0;
	i = (int) h;
	f = h - i;
	p = v * (1 - s);
	q = v * (1 - s*f);
	t = v * (1 - s * (1.0 - f));

	switch (i) {
	case 0:
	    *r = v;  *g = t;  *b = p;
	    break;
	case 1:
	    *r = q;  *g = v;  *b = p;
	    break;
	case 2:
	    *r = p;  *g = v;  *b = t;
	    break;
	case 3:
	    *r = p;  *g = q;  *b = v;
	    break;
	case 4:
	    *r = t;  *g = p;  *b = v;
	    break;
	case 5:
	    *r = v;  *g = p;  *b = q;
	    break;
	}
}


/* GET_DIRFILE -- Get the next file name from an open directory file.
 */
static int
get_dirfile (dir, outstr, maxch)
DIR     *dir;
char    *outstr;
int     maxch;
{
        register int    n;
        register struct dirent *dp;
        register char   *ip, *op;
        int     status;

        for (dp = readdir(dir);  dp != NULL;  dp = readdir(dir))
            if (dp->d_ino != 0) {
		n = strlen (dp->d_name);
                status = n;
                for (ip=dp->d_name, op=outstr;  --n >= 0;  )
                    *op++ = *ip++;
                *op = EOS;
                return (status);
            }

        return (EOF);
}


/* LOAD_TESTPATTERN -- Load a test pattern into the given frame.
 */
static void
load_testpattern (xim, frame, type)
XimDataPtr xim;
int frame;
int type;			/* not used */
{
	register FrameBufPtr fb = &xim->frames[frame];
	register int i, j, ncolors;
	int rtype, width, height, depth;
	unsigned char *data;

	if (GtQueryRaster (xim->gt, fb->raster,
		&rtype, &width, &height, &depth) == 0)
	    return;

	data = (unsigned char *) XtMalloc (width);
	if (data == (unsigned char *)NULL)
	    return;

	ncolors = xim->ncolors;
	for (j=0;  j < height;  j++) {
	    for (i=0;  i < width;  i++)
		data[i] = (((i + j) * 10) % ncolors);
	    GtWritePixels (xim->gt, fb->raster, data, 8, 0, j, width, 1);
	}

	XtFree ((char *)data);
}


/* SET_COLORBAR -- Write the colorbar pixels.
 */
static void
set_colorbar (xim, w)
XimDataPtr xim;
Widget w;
{
	register int i;
	static int initialized = 0;
	int first, ngray, rgb_len, rtype, width, height, depth;
	unsigned short m_red[MAX_COLORS];
	unsigned short m_green[MAX_COLORS];
	unsigned short m_blue[MAX_COLORS];
	unsigned char *data;


	if (!w)
	    return;

	if (DBG_RASTER)
	    fprintf (stderr, "SETTING COLORBAR PIXELS...... init = %d\n",
		initialized);

	if (GtQueryRaster (w, 0, &rtype, &width, &height, &depth) == 0)
	    return;

	data = (unsigned char *) XtMalloc (width * height);
	for (i=0;  i < width;  i++)
	    data[i] = ((float)i / (float)(width - 1) * (xim->ncolors - 1));

	for (i=1;  i < height;  i++)
	    memmove (data + i * width, data, width);

	if (!initialized) {
	    xim_iiscolormap (w, m_red,m_green,m_blue, &first, &ngray, &rgb_len);
	    GtWriteColormap (w, 0, first, rgb_len, m_red, m_green, m_blue);

	    xim_setColormap ("Grayscale", NULL, m_red, m_green, m_blue, ngray);
	    GtWriteColormap (w, 0, first, ngray, m_red, m_green, m_blue);

	    xim->ncolors = ngray;
	    initialized++;
	}

	GtWritePixels (w, 0, data, 8, 0, 0, width, height);
	XtFree ((char *)data);

	if (DBG_RASTER)
	    fprintf (stderr, "SETTING COLORBAR PIXELS...... DONE\n");
}


/* SET_NFRAMES -- Called when the number of frame buffers changes.
 */
static void
set_nframes (xim, nframes)
XimDataPtr xim;
int nframes;
{
	xim->nframes = nframes;
	xim_msgi (xim, "nframes", nframes);
}