Repatch (from linux) of OSX IRAF

1 files changed, 2995 insertions, 0 deletions

diff --git a/vendor/x11iraf/ximtool/raster.c b/vendor/x11iraf/ximtool/raster.c
new file mode 100644
index 00000000..51652241
--- /dev/null
+++ b/vendor/x11iraf/ximtool/raster.c
@@ -0,0 +1,2995 @@
+#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);
+}