MultiSource/Benchmarks/MallocBench/gs/gdevx.c

/* Copyright (C) 1989, 1990, 1991 Aladdin Enterprises.  All rights reserved.
   Distributed by Free Software Foundation, Inc.

This file is part of Ghostscript.

Ghostscript is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY.  No author or distributor accepts responsibility
to anyone for the consequences of using it or for whether it serves any
particular purpose or works at all, unless he says so in writing.  Refer
to the Ghostscript General Public License for full details.

Everyone is granted permission to copy, modify and redistribute
Ghostscript, but only under the conditions described in the Ghostscript
General Public License.  A copy of this license is supposed to have been
given to you along with Ghostscript so you can know your rights and
responsibilities.  It should be in a file named COPYING.  Among other
things, the copyright notice and this notice must be preserved on all
copies.  */

/* gdevx.c */
/* X Windows driver for GhostScript library */
/* The X include files include <sys/types.h>, which, on some machines */
/* at least, define byte, uint, ushort, and ulong, which std.h also defines. */
/* We have to shuffle the order of includes to make this all work. */
/* First we arrange things so that std.h defines _byte, _uint, _ushort, */
/* and _ulong instead of (our own) byte, uint, ushort, and ulong. */
#  define byte _byte
#  define uint _uint
#  define ushort _ushort
#  define ulong _ulong
#include "gx.h"			/* for gx_bitmap; includes std.h */
#include "malloc_.h"
#include "memory_.h"
#include "gsmatrix.h"			/* needed for gxdevice.h */
#include "gxbitmap.h"
#include "gxdevice.h"
#  undef byte
#  undef uint
#  undef ushort
#  undef ulong
/* Now we can include the X files. */
#include "gdevx.h"

typedef struct gx_device_s gx_device;

/* Flags for patching around bugs in the X library */
#define use_XPutImage 1
#define use_XSetTile 1

/* Define whether to use a backing pixmap to handle expose events. */
/* Note that this is a variable rather than a #define. */
/* Note also that it is consulted each time we open an X device. */
private int use_backing = 1;

/* Define the maximum size of the temporary pixmap for copy_mono */
/* that we are willing to leave lying around in the server */
/* between uses.  (Assume 32-bit ints here!) */
private int max_temp_pixmap = 20000;

/* Forward references */
private int set_tile(P2(gx_device *, gx_bitmap *));
private void free_cp(P1(gx_device *));
/* Screen updating machinery */
#define update_init(dev)\
  ((gx_device_X *)(dev))->up_area = 0,\
  ((gx_device_X *)(dev))->up_count = 0
#define update_flush(dev)\
  if ( ((gx_device_X *)(dev))->up_area != 0 ) update_do_flush(dev)
private void update_do_flush(P1(gx_device *));
private void update_add(P5(gx_device *, int, int, int, int));

/* Procedures */

int x_open(P1(gx_device *));

int x_close(P1(gx_device *));

gx_color_index x_map_rgb_color(P4(gx_device *, _ushort, _ushort, _ushort));

int x_map_color_rgb(P3(gx_device *, gx_color_index, _ushort *));

int x_sync(P1(gx_device *));

int x_fill_rectangle(P6(gx_device *, int, int, int, int, gx_color_index));

int x_tile_rectangle(P8(gx_device *, gx_bitmap *, int, int, int, int, gx_color_index, gx_color_index));

int x_copy_mono(P10(gx_device *, _byte *, int, int, int, int, int, int, gx_color_index, gx_color_index));

int x_copy_color(P8(gx_device *, _byte *, int, int, int, int, int, int));

int x_draw_line(P6(gx_device *, int, int, int, int, gx_color_index));

int x_fill_trapezoid(P8(gx_device *, int, int, int, int, int, int, gx_color_index));

int x_tile_trapezoid(P10(gx_device *, gx_bitmap *, int, int, int, int, int, int, gx_color_index, gx_color_index));

/* The device descriptor */
private gx_device_procs x_procs = {
	x_open,
	gx_default_get_initial_matrix,
	x_sync,
	gx_default_output_page,
	x_close,
	x_map_rgb_color,
	x_map_color_rgb,
	x_fill_rectangle,
	x_tile_rectangle,
	x_copy_mono,
	x_copy_color,
	x_draw_line,
	x_fill_trapezoid,
	x_tile_trapezoid
};

/* Define default window parameters */

#define PROGRAM_NAME "Ghostscript"

#define ARG_BORDER_WIDTH "borderWidth"
#define DEFAULT_BORDER_WIDTH 1

#define ARG_BORDER_COLOR "borderColor"
#define DEFAULT_BORDER_COLOR  (xdev->colors[0]) /* That's black. */

#define ARG_GEOMETRY "geometry"
#define DEFAULT_GEOMETRY "612x792+0+0"

#define DEFAULT_X_POSITION 0
#define DEFAULT_Y_POSITION 0

#define ARG_X_RESOLUTION "xResolution"
#define DEFAULT_X_RESOLUTION 72
#define ARG_Y_RESOLUTION "yResolution"
#define DEFAULT_Y_RESOLUTION 72

/* The page width and height are defined in a slightly peculiar */
/* way so that <resolution> * DEFAULT_{WIDTH|HEIGHT}_INCHES will work. */
#define DEFAULT_WIDTH_INCHES 85/10	/* no parentheses! */
#define DEFAULT_HEIGHT_INCHES 11

/* Define a rectangle structure for update bookkeeping */
typedef struct rect_s {
  int xo, yo, xe, ye;
} rect;

/* Define the X Windows device */
typedef struct gx_device_X_s {
	gx_device_common;

	/* An XImage object for writing bitmap images to the screen */
	XImage image;

	/* Global X state */
	Display *dpy;
	Screen *scr;
	int depth;
	Visual *vis;
	Colormap cmap;
	Window win;
	GC gc;

	/* A backing pixmap so X will handle exposure automatically */
	Pixmap bpixmap;			/* 0 if use_backing is false, */
					/* or if it can't be allocated */
	rect update;		/* region needing updating */
	long up_area;		/* total area of update */
				/* (always 0 if no backing pixmap) */
	int up_count;		/* # of updates since flush */
	Pixmap dest;		/* bpixmap if non-0, else win */
	unsigned long accum_color; /* 'or' of all device colors used so far */

	/* An intermediate pixmap for the stencil case of copy_mono */
	struct {
	  Pixmap pixmap;
	  GC gc;
	  int raster, height;
	} cp;

	/* Structure for dealing with the halftone tile. */
	/* Later this might become a multi-element cache. */
	struct {
	  Pixmap pixmap;
	  Pixmap no_pixmap;	/* kludge to get around X bug */
	  int width, height, raster;
	  _byte *bits;
	  int bits_size;
	  gx_color_index fore_c, back_c;
	} ht;

	/* Cache the fill style from the GC */
	int fill_style;

#define set_fill_style(style)\
  if ( xdev->fill_style != style )\
    XSetFillStyle(xdev->dpy, xdev->gc, (xdev->fill_style = style))
#define set_function(func)\
  XSetFunction(xdev->dpy, xdev->gc, func) /* don't bother to cache */

	/* Map color indices to X pixel values */
	unsigned long colors[8];
#define black colors[0]
#define white colors[7]
	gx_color_index back_color, fore_color;

#define set_back_color(color)\
  if ( xdev->back_color != color )\
   { unsigned long dev_color = xdev->colors[xdev->back_color = color];\
     xdev->accum_color |= dev_color;\
     XSetBackground(xdev->dpy, xdev->gc, dev_color);\
   }
#define set_fore_color(color)\
  if ( xdev->fore_color != color )\
   { unsigned long dev_color = xdev->colors[xdev->fore_color = color];\
     xdev->accum_color |= dev_color;\
     XSetForeground(xdev->dpy, xdev->gc, dev_color);\
   }

} gx_device_X;

/* The instance is public. */
gx_device_X gs_x11_device = {
	sizeof(gx_device_X),
	&x_procs,
	"x11",
	DEFAULT_WIDTH_INCHES, DEFAULT_HEIGHT_INCHES,	/* x and y extent */
	DEFAULT_X_RESOLUTION, DEFAULT_Y_RESOLUTION,	/* x and y density */
		/* Following parameters are initialized for monochrome */
	0,			/* has color */
	1,			/* max r-g-b value */
	1,			/* bits per color pixel */
		/* End of monochrome/color parameters */
	0,			/* connection not initialized */
	{ /* image */
	  0, 0,			/* width, height */
	  0, XYBitmap, NULL,	/* xoffset, format, data */
	  LSBFirst, 8,    	/* byte-order, bitmap-unit */
	  MSBFirst, 8, 1,	/* bitmap-bit-order, bitmap-pad, depth */
	  0, 1,			/* bytes_per_line, bits_per_pixel */
	  0, 0, 0,		/* red_mask, green_mask, blue_mask */
	  NULL,			/* *obdata */
	   { NULL,			/* *(*create_image)() */
	     NULL,			/* (*destroy_image)() */
	     NULL,			/* (*get_pixel)() */
	     NULL,			/* (*put_pixel)() */
	     NULL,			/* *(*sub_image)() */
	     NULL			/* (*add_pixel)() */
	   },
	},
	NULL, NULL, 0, NULL,	/* dpy, scr, depth_all_ones, vis */
				/* (connection not initialized) */
	(Colormap)None,		/* cmap */
	(Window)None,		/* win */
	NULL,			/* gc */
	(Pixmap)0,		/* bpixmap */
	 { 0, 0, 0, 0 }, 0, 0,	/* update, up_area, up_count */
	(Pixmap)0,		/* dest */
	0,			/* accum_color */
	 { /* cp */
	   (Pixmap)0,		/* pixmap */
	   NULL,		/* gc */
	   -1, -1		/* raster, height */
	 },
	 { /* ht */
	   (Pixmap)None,		/* pixmap */
	   (Pixmap)None,		/* no_pixmap */
	   0, 0, 0,			/* width, height, raster */
	   NULL, 1 			/* bits, bits_size */
	 },
	FillSolid,		/* fill_style */
	{ 0, 0, 0, 0, 0, 0, 0, 0 }, /* colors[8] */
	0, 0			/* back_color, fore_color */

};
/* Macro for casting gx_device argument */
#define xdev ((gx_device_X *)dev)

/* Macro to validate and coerce arguments */
#define check_rect()\
	if ( x + w > xdev->width ) w = xdev->width - x;\
	if ( y + h > xdev->height ) h = xdev->height - y;\
	if ( w <= 0 || h <= 0 ) return 0;\
	if ( x < 0 || y < 0 ) return -1

#if !use_XPutImage
/* XPutImage doesn't work, do it ourselves. */
#  undef XPutImage
private void alt_put_image();
#  define XPutImage(dpy,win,gc,im,sx,sy,x,y,w,h)\
    alt_put_image(dev,dpy,win,gc,im,sx,sy,x,y,w,h)
#endif


/* Open the X device */
int
x_open(register gx_device *dev)
{	Screen *scr;
	XSizeHints sizehints;
	int border_width;
	char *x_resolution_str, *y_resolution_str;
	char *border_width_str, *border_color_str;
	unsigned long border_color;
	char *geometry;
	XColor screen_color, exact_color;
	XSetWindowAttributes xswa;
	XEvent event;
#ifdef DEBUG
if ( gs_debug['X'] )
	{ extern int _Xdebug;
	  _Xdebug = 1;
	}
#endif
	if ( !(xdev->dpy = XOpenDisplay(NULL)) )
	  { eprintf1("gs: Cannot open X display `%s'.\n",
		     getenv("DISPLAY"));
	    exit(1);
	  }
	scr = DefaultScreenOfDisplay(xdev->dpy);
	xdev->scr = scr;
	xdev->depth = DefaultDepthOfScreen(scr);
	xdev->vis = DefaultVisualOfScreen(scr);
	xdev->cmap = DefaultColormapOfScreen(scr);
	xdev->black = BlackPixelOfScreen(scr);
	xdev->white = WhitePixelOfScreen(scr);

	/* Figure out the resolution of our screen; 25.4 is the
	 * number of millimeters in an inch.  The only reason for
	 * allowing the user to specify the resolution is that
	 * X servers commonly lie about it (and about the screen size).
	 */

	x_resolution_str = XGetDefault(xdev->dpy, PROGRAM_NAME,
				       ARG_X_RESOLUTION);
	y_resolution_str = XGetDefault(xdev->dpy, PROGRAM_NAME,
				       ARG_Y_RESOLUTION);
	xdev->x_pixels_per_inch =
	  (x_resolution_str == NULL ?
	   25.4 * WidthOfScreen(scr) / WidthMMOfScreen(scr) :
	   atoi(x_resolution_str));
	xdev->y_pixels_per_inch =
	  (y_resolution_str == NULL ?
	   25.4 * HeightOfScreen(scr) / HeightMMOfScreen(scr) :
	   atoi(y_resolution_str));

	/* Figure out monochrome vs. color */
	switch ( xdev->vis->class )
	  {
	  case StaticGray:
	  case GrayScale:
	    xdev->has_color = 0;
	    { int i;
	      for ( i = 1; i < 7; i++ ) xdev->colors[i] = xdev->white;
	    }
	    break;
	  default:		/* color */
	    xdev->has_color = 1;
	    /* Just do primary colors for now */
	    { XColor xc;
	      int i;
	      for ( i = 1; i < 7; i++ )
		{ xc.red = (i & 4 ? ~(_ushort)0 : 0);
		  xc.green = (i & 2 ? ~(_ushort)0 : 0);
		  xc.blue = (i & 1 ? ~(_ushort)0 : 0);
		  XAllocColor(xdev->dpy, xdev->cmap, &xc);
		  xdev->colors[i] = xc.pixel;
		}
	    }
	  }
	xdev->ht.pixmap = (Pixmap)0;
	xdev->ht.bits = 0;
	xdev->fill_style = FillSolid;

	/* Get defaults from the database. */
	border_width_str = XGetDefault(xdev->dpy, PROGRAM_NAME,
				       ARG_BORDER_WIDTH);

	border_width = (border_width_str == NULL ? DEFAULT_BORDER_WIDTH :
			atoi(border_width_str));

	border_color_str = XGetDefault(xdev->dpy, PROGRAM_NAME,
				       ARG_BORDER_COLOR);

	border_color = (border_color_str == NULL ||
			 !XAllocNamedColor(xdev->dpy, xdev->cmap, 
					   border_color_str, 
					   &screen_color, &exact_color) ?
			DEFAULT_BORDER_COLOR :
			screen_color.pixel);

	sizehints.x = DEFAULT_X_POSITION;
	sizehints.y = DEFAULT_Y_POSITION;
	sizehints.width = xdev->x_pixels_per_inch * DEFAULT_WIDTH_INCHES;
	sizehints.height = xdev->y_pixels_per_inch * DEFAULT_HEIGHT_INCHES;
	sizehints.flags = 0;

	geometry = XGetDefault(xdev->dpy, PROGRAM_NAME, ARG_GEOMETRY);

	if (geometry != NULL)
	   {	/*
		 * Note that border_width must be set first.  We can't use
		 * scr, because that is a Screen*, and XGeometry wants
		 * the screen number.
		 */
		int bitmask = XGeometry(xdev->dpy, DefaultScreen(xdev->dpy),
					geometry, DEFAULT_GEOMETRY,
					border_width,
					1, 1, /* ``Font'' width and height. */
					0, 0, /* Interior padding. */
					&sizehints.x, &sizehints.y,
					&sizehints.width, &sizehints.height);

		if (bitmask & (XValue | YValue))
			sizehints.flags |= USPosition;

		if (bitmask & (WidthValue | HeightValue))
			sizehints.flags |= USSize;
	   }

	xdev->width = sizehints.width;
	xdev->height = sizehints.height;

	xswa.event_mask = ExposureMask;
	xswa.background_pixel = xdev->black;
	xswa.border_pixel = border_color;
	xdev->win = XCreateWindow(xdev->dpy, RootWindowOfScreen(scr),
				  sizehints.x, sizehints.y, /* upper left */
				  sizehints.width, sizehints.height,
				  border_width,
				  xdev->depth,
				  InputOutput, /* class */
				  xdev->vis, /* visual */
				  CWEventMask | CWBackPixel | CWBorderPixel,
				  &xswa);
	if ( use_backing )
	  xdev->bpixmap =
		XCreatePixmap(xdev->dpy, xdev->win,
			      xdev->width, xdev->height,
			      xdev->depth);
	else
	  xdev->bpixmap = (Pixmap)0;
	xdev->dest = (xdev->bpixmap != (Pixmap)0 ?
		      xdev->bpixmap : (Pixmap)xdev->win);
	xdev->accum_color = 0;
	update_init(dev);

	XChangeProperty(xdev->dpy, xdev->win, XA_WM_NAME, XA_STRING, 8,
			PropModeReplace, (unsigned char *)PROGRAM_NAME,
			strlen(PROGRAM_NAME));
	XSetNormalHints(xdev->dpy, xdev->win, &sizehints);

	/* Set up a graphics context */
	xdev->gc = XCreateGC(xdev->dpy, xdev->win, 0, NULL);
	XSetFunction(xdev->dpy, xdev->gc, GXcopy);
	XSetLineAttributes(xdev->dpy, xdev->gc, 0,
			   LineSolid, CapButt, JoinMiter);

	/* Clear the background pixmap to avoid initializing with garbage. */
	if ( xdev->bpixmap != (Pixmap)0 )
	  { XSetWindowBackgroundPixmap(xdev->dpy, xdev->win, xdev->bpixmap);
	    XSetForeground(xdev->dpy, xdev->gc, xdev->white);
	    XFillRectangle(xdev->dpy, xdev->bpixmap, xdev->gc,
			   0, 0, xdev->width, xdev->height);
	  }

	/* Initialize foreground and background colors */
	xdev->back_color = 7;
	XSetBackground(xdev->dpy, xdev->gc, xdev->white);
	xdev->fore_color = 0;
	XSetForeground(xdev->dpy, xdev->gc, xdev->black);

	/* Make the window appear. */
	XMapWindow(xdev->dpy, xdev->win);

	/* Before anything else, do a flush and wait for */
	/* an exposure event. */
	XFlush(xdev->dpy);
	XNextEvent(xdev->dpy, &event);

	xdev->ht.no_pixmap = XCreatePixmap(xdev->dpy, xdev->win, 1, 1,
					   xdev->depth);

	XSync(xdev->dpy, 0);
	return 0;
}

/* Close the device.  NOT SURE WHAT TO DO HERE YET. */
int
x_close(gx_device *dev)
{	return 0;
}

/* Map a color.  The "device colors" are just r,g,b packed together. */
gx_color_index
x_map_rgb_color(register gx_device *dev, _ushort r, _ushort g, _ushort b)
{	return (r << 2) + (g << 1) + b;
}


/* Map a "device color" back to r-g-b. */
int
x_map_color_rgb(register gx_device *dev, gx_color_index color, _ushort *prgb)
{	prgb[0] = (color >> 2) & 1;
	prgb[1] = (color >> 1) & 1;
	prgb[2] = color & 1;
	return 0;
}

/* Synchronize the display with the commands already given */
int
x_sync(register gx_device *dev)
{	update_flush(dev);
	XSync(xdev->dpy, 0);
	return 0;
}

/* Fill a rectangle with a color. */
int
x_fill_rectangle(register gx_device *dev,
  int x, int y, int w, int h, gx_color_index color)
{	check_rect();
	set_fill_style(FillSolid);
	set_fore_color(color);
	set_function(GXcopy);
	XFillRectangle(xdev->dpy, xdev->dest, xdev->gc, x, y, w, h);
	if ( xdev->bpixmap != (Pixmap)0 )
	 { update_add(dev, x, y, w, h);
	 }
#ifdef DEBUG
if ( gs_debug['F'] )
	printf("[F] fill (%d,%d):(%d,%d) %ld\n",
	       x, y, w, h, (long)color);
#endif
	return 0;
}

/* Tile a rectangle. */
int
x_tile_rectangle(register gx_device *dev, gx_bitmap *tile,
  int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
{	check_rect();

	/* Check for a colored tile.  We should implement this */
	/* properly someday, since X can handle it. */

	if ( one == gx_no_color_index && zero == gx_no_color_index )
		return -1;

	/* 
	 * Remember, an X tile is already filled with particular
	 * pixel values (i.e., colors).  Therefore if we are changing
	 * fore/background color, we must invalidate the tile (using
	 * the same technique as in set_tile).  This problem only
	 * bites when using grayscale -- you may want to change
	 * fg/bg but use the same halftone screen.
	 */
	if ( (zero != xdev->ht.back_c) || (one != xdev->ht.fore_c) )
	  if ( xdev->ht.bits ) *xdev->ht.bits = ~*tile->data;

	set_back_color(zero);
	set_fore_color(one);
	set_function(GXcopy);
	if ( !set_tile(dev, tile) )
	 { /* Bad news.  Fall back to the default algorithm. */
	   set_fill_style(FillSolid);
	   return gx_default_tile_rectangle(dev, tile, x, y, w, h, zero, one);
	 }
	else
	  { /* Use the tile to fill the rectangle */
	    XFillRectangle(xdev->dpy, xdev->dest, xdev->gc, x, y, w, h);
	    if ( xdev->bpixmap != (Pixmap)0 )
	     { update_add(dev, x, y, w, h);
	     }
	  }
#ifdef DEBUG
if ( gs_debug['F'] )
	printf("[F] tile (%d,%d):(%d,%d) %ld,%ld\n",
	       x, y, w, h, (long)zero, (long)one);
#endif
	return 0;
}

/* Set up with a specified tile. */
/* Return false if we can't do it for some reason. */
private int
set_tile(register gx_device *dev, register gx_bitmap *tile)
{
#ifdef DEBUG
if ( gs_debug['T'] )
	return 0;
#endif
	/* Set up the tile Pixmap */
	if ( tile->width != xdev->ht.width ||
	     tile->height != xdev->ht.height ||
	     xdev->ht.pixmap == (Pixmap)0
	   )
	  { if ( xdev->ht.pixmap != (Pixmap)0 )
	      XFreePixmap(xdev->dpy, xdev->ht.pixmap);
	    if ( xdev->ht.bits )
	      { free(xdev->ht.bits);
		xdev->ht.bits = 0;
	      }
	    xdev->ht.pixmap = XCreatePixmap(xdev->dpy, xdev->win,
					    tile->width, tile->height,
					    xdev->depth);
	    if ( xdev->ht.pixmap == (Pixmap)0 )
	      return 0;
	    xdev->ht.bits_size = tile->raster * tile->height;
	    xdev->ht.bits = (_byte *)malloc(xdev->ht.bits_size);
	    if ( xdev->ht.bits == 0 )
	      { XFreePixmap(xdev->dpy, xdev->ht.pixmap);
		xdev->ht.pixmap = (Pixmap)0;
		return 0;
	      }
	    xdev->ht.width = tile->width, xdev->ht.height = tile->height;
	    xdev->ht.raster = tile->raster;
	    *xdev->ht.bits = ~*tile->data; /* force copying */
	  }
	xdev->ht.fore_c = xdev->fore_color;
	xdev->ht.back_c = xdev->back_color;
	/* Copy the tile into the Pixmap if needed */
	if ( memcmp(xdev->ht.bits, tile->data, xdev->ht.bits_size) )
	  { memcpy(xdev->ht.bits, tile->data, xdev->ht.bits_size);
	    xdev->image.data = (char *)tile->data;
	    xdev->image.width = tile->width;
	    xdev->image.height = tile->height;
	    xdev->image.bytes_per_line = tile->raster;
	    xdev->image.format = XYBitmap;
	    set_fill_style(FillSolid);
#ifdef DEBUG
if ( gs_debug['H'] )
	    { int i;
	      printf("[H] 0x%x: width=%d height=%d raster=%d\n",
		     tile->data, tile->width, tile->height, tile->raster);
	      for ( i = 0; i < tile->raster * tile->height; i++ )
		printf(" %02x", tile->data[i]);
	      printf("\n");
	    }
#endif
	    XSetTile(xdev->dpy, xdev->gc, xdev->ht.no_pixmap); /* *** X bug *** */
	    XPutImage(xdev->dpy, xdev->ht.pixmap, xdev->gc, &xdev->image,
		      0, 0, 0, 0, tile->width, tile->height);
	    XSetTile(xdev->dpy, xdev->gc, xdev->ht.pixmap);
	  }
	set_fill_style(FillTiled);
	return use_XSetTile;
}

/* Copy a monochrome bitmap. */
int
x_copy_mono(register gx_device *dev, _byte *base, int sourcex, int raster,
  int x, int y, int w, int h, gx_color_index zero, gx_color_index one)
/*
 * X doesn't readily support the simple operation of writing a color
 * through a mask.  The plot is the following: 
 *  If neither color is gx_no_color_index ("transparent"),
 *	use XPutImage with the "copy" function as usual.
 *  If the color is 0 or bitwise-includes every color written to date
 *    (a special optimization for writing black/white on color displays),
 *	use XPutImage with an appropriate Boolean function.
 *  Otherwise, do the following complicated stuff:
 *	Create pixmap of depth 1 if necessary.
 *	If foreground color is "transparent" then
 *	  invert the raster data (using GXcopyInverted in XPutImage).
 *	Use XPutImage to copy the raster image to the newly
 *	  created Pixmap.
 *	Install the Pixmap as the clip_mask in the X GC and
 *	  tweak the clip origin.
 *	Do an XFillRectangle, fill style=solid, specifying a
 *	  rectangle the same size as the original raster data.
 *	De-install the clip_mask.
 */
{	int function = GXcopy;
	unsigned long
	  bc = xdev->colors[zero],
	  fc = xdev->colors[one];
	
	check_rect();

	xdev->image.width = raster << 3;
	xdev->image.height = h;
	xdev->image.data = (char *)base;
	xdev->image.bytes_per_line = raster;
	set_fill_style(FillSolid);

	/* Check for null, easy 1-color, hard 1-color, and 2-color cases. */
	if ( zero != gx_no_color_index )
	  { if ( one != gx_no_color_index )
	      { /* Simply replace existing bits with what's in the image */
	      }
	    else if ( bc == 0 )
	      function = GXand,
	      fc = xdev->accum_color;
	    else if ( !(~bc & xdev->accum_color) )
	      function = GXorInverted,
	      fc = bc, bc = 0;
	    else
	      goto hard;
	  }
	else
	  { if ( one == gx_no_color_index ) /* no-op */
	      return 0;
	    else if ( fc == 0 )
	      function = GXandInverted,
	      bc = 0, fc = xdev->accum_color;
	    else if ( !(~fc & xdev->accum_color) )
	      function = GXor,
	      bc = 0;
	    else
	      goto hard;
	  }
	xdev->image.format = XYBitmap;
	set_function(function);
	XSetBackground(xdev->dpy, xdev->gc, bc);
	XSetForeground(xdev->dpy, xdev->gc, fc);
	xdev->back_color = xdev->fore_color = gx_no_color_index;
	xdev->accum_color |= fc | bc;
	XPutImage(xdev->dpy, xdev->dest, xdev->gc, &xdev->image,
		  sourcex, 0, x, y, w, h);

	goto out;

hard:	/* Handle the hard 1-color case. */
	if ( raster > xdev->cp.raster || h > xdev->cp.height )
	  { /* Must allocate a new pixmap and GC. */
	    /* Release the old ones first. */
	    free_cp(dev);

	    /* Create the clipping pixmap, depth must be 1. */
	    xdev->cp.pixmap =
	      XCreatePixmap(xdev->dpy, xdev->win, raster << 3, h, 1);
	    if ( xdev->cp.pixmap == (Pixmap)0 )
	      {	dprintf("x_copy_mono: can't allocate pixmap\n");
		exit(1);
	      }
	    xdev->cp.gc = XCreateGC(xdev->dpy, xdev->cp.pixmap, 0, 0);
	    if ( xdev->cp.gc == (GC)0 )
	      {	dprintf("x_copy_mono: can't allocate GC\n");
		exit(1);
	      }
	    xdev->cp.raster = raster;
	    xdev->cp.height = h;
	  }

	/* Initialize static mask image params */
	xdev->image.format = ZPixmap;

	/* Select function based on fg/bg transparency. */
	if ( one == gx_no_color_index )
	  { XSetFunction(xdev->dpy, xdev->cp.gc, GXcopyInverted);
	    XPutImage(xdev->dpy, xdev->cp.pixmap, xdev->cp.gc,
		      &xdev->image, sourcex, 0, 0, 0, w, h);
	    /* Reset function in stencil gc */
	    XSetFunction(xdev->dpy, xdev->cp.gc, GXcopy);
	    set_fore_color(zero);
	  }
	else
	  { XPutImage(xdev->dpy, xdev->cp.pixmap, xdev->cp.gc,
		      &xdev->image, sourcex, 0, 0, 0, w, h);
	    set_fore_color(one);
	  }

	/* Install as clipmask. */
	XSetClipMask(xdev->dpy, xdev->gc, xdev->cp.pixmap);
	XSetClipOrigin(xdev->dpy, xdev->gc, x, y);

	/*
	 * Draw a solid rectangle through the raster clip mask.
	 * Note fill style is guaranteed to be solid from above.
	 */
	XFillRectangle(xdev->dpy, xdev->dest, xdev->gc, x, y, w, h);

	/* Tidy up.  Free the pixmap if it's big. */
	XSetClipMask(xdev->dpy, xdev->gc, None);
	if ( raster * h > max_temp_pixmap )
	  free_cp(dev);

out:	if ( xdev->bpixmap != (Pixmap)0 )
	  { /* We wrote to the pixmap, so update the display now. */
	    update_add(dev, x, y, w, h);
	  }

	return 0;
}

/* Internal routine to free the GC and pixmap used for copying. */
private void
free_cp(register gx_device *dev)
{	if ( xdev->cp.gc != NULL )
	   {	XFreeGC(xdev->dpy, xdev->cp.gc);
		xdev->cp.gc = NULL;
	   }
	if ( xdev->cp.pixmap != (Pixmap)0 )
	   {	XFreePixmap(xdev->dpy, xdev->cp.pixmap);
		xdev->cp.pixmap = (Pixmap)0;
	   }
	xdev->cp.raster = -1;	/* mark as unallocated */
}

/* Copy a "color" bitmap.  Since "color" is the same as monochrome, */
/* this just reduces to copying a monochrome bitmap. */
/****** THIS ROUTINE IS COMPLETELY WRONG, SINCE WE DO SUPPORT COLOR. ******/
/* Fortunately, no one uses it at the moment. */
int
x_copy_color(register gx_device *dev, _byte *base, int sourcex, int raster,
  int x, int y, int w, int h)
{	return x_copy_mono(dev, base, sourcex, raster, x, y, w, h, (gx_color_index)0, (gx_color_index)7);
}

/* Draw a line */
int
x_draw_line(register gx_device *dev,
  int x0, int y0, int x1, int y1, gx_color_index color)
{	set_fore_color(color);
	set_fill_style(FillSolid);
	set_function(GXcopy);
	XDrawLine(xdev->dpy, xdev->dest, xdev->gc, x0, y0, x1, y1);
	if ( xdev->bpixmap != (Pixmap)0 )
	 { int x = x0, y = y0, w = x1 - x0, h = y1 - y0;
	   if ( w < 0 ) x = x1, w = - w;
	   if ( h < 0 ) y = y1, h = - h;
	   update_add(dev, x, y, w+1, h+1);
	 }
	return 0;
}

/* Define a common macro for setting up a trapezoid. */
#define setup_trapezoid()\
	XPoint vlist[4];\
	XPoint *pv = vlist + 1;\
	vlist[0].x = x0, vlist[0].y = y0;\
	if ( w0 )\
	  pv->x = x0 + w0, pv->y = y0, pv++;\
	pv->x = x1 + w1, pv->y = y1, pv++;\
	if ( w1 )\
	  pv->x = x1, pv->y = y1, pv++
#define vcount (pv - vlist)
/* Define a common macro for finishing a trapezoid. */
#define finish_trapezoid()\
	set_function(GXcopy);\
	XFillPolygon(xdev->dpy, xdev->dest, xdev->gc,\
		     vlist, vcount, Convex, CoordModeOrigin);\
	if ( xdev->bpixmap != (Pixmap)0 )\
	 { int xl = x0, xr = x0 + w0;\
	   if ( x1 < xl ) xl = x1;\
	   if ( x1 + w1 > xr ) xr = x1 + w1;\
	   update_add(dev, xl, y0, xr - xl, y1 - y0);\
	 }

/* Fill a trapezoid */
int
x_fill_trapezoid(register gx_device *dev,
  int x0, int y0, int w0, int x1, int y1, int w1, gx_color_index color)
{	setup_trapezoid();
	set_fore_color(color);
	set_fill_style(FillSolid);
	finish_trapezoid();
	return 0;
}

/* Tile a trapezoid */
int
x_tile_trapezoid(register gx_device *dev, gx_bitmap *tile,
  int x0, int y0, int w0, int x1, int y1, int w1,
  gx_color_index zero, gx_color_index one)
{
	/* Check for a colored tile.  We should implement this */
	/* properly someday, since X can handle it. */

	if ( one == gx_no_color_index && zero == gx_no_color_index )
	  return -1;
	/* See x_tile_rectangle for the significance of the following. */
	if ( (zero != xdev->ht.back_c) || (one != xdev->ht.fore_c) )
	  if ( xdev->ht.bits ) *xdev->ht.bits = ~*tile->data;

	{ setup_trapezoid();
	  set_back_color(zero);
	  set_fore_color(one);
	  if ( !set_tile(dev, tile) )
	   { set_fill_style(FillSolid);
	     return gx_default_tile_trapezoid(dev, tile,
	       x0, y0, w0, x1, y1, w1, zero, one);
	   }
	  /* Use the tile to fill the trapezoid */
	  finish_trapezoid();
	 }
	return 0;
}

/* ------ Screen update procedures ------ */

/* Flush updates to the screen if needed. */
private void
update_do_flush(register gx_device *dev)
{	int xo = xdev->update.xo, yo = xdev->update.yo;
	set_function(GXcopy);
	XCopyArea(xdev->dpy, xdev->bpixmap, xdev->win, xdev->gc,
		  xo, yo, xdev->update.xe - xo, xdev->update.ye - yo,
		  xo, yo);
	update_init(dev);
}

/* Add a region to be updated. */
/* This is only called if xdev->bpixmap != 0. */
private void
update_add(register gx_device *dev, int xo, int yo, int w, int h)
{	int xe = xo + w, ye = yo + h;
	long new_area = (long)w * h;
	++xdev->up_count;
	if ( xdev->up_area != 0 )
	  { /* See whether adding this rectangle */
	    /* would result in too much being copied unnecessarily. */
	    long old_area = xdev->up_area;
	    long new_up_area;
	    rect u;
	    u.xo = min(xo, xdev->update.xo);
	    u.yo = min(yo, xdev->update.yo);
	    u.xe = max(xe, xdev->update.xe);
	    u.ye = max(ye, xdev->update.ye);
	    new_up_area = (long)(u.xe - u.xo) * (u.ye - u.yo);
	    if ( new_up_area > 100 &&
		old_area + new_area < new_up_area * 2 / 3 ||
		xdev->up_count >= 200
		)
	      update_do_flush(dev);
	    else
	      { xdev->update = u;
		xdev->up_area = new_up_area;
		return;
	      }
	  }
	xdev->update.xo = xo;
	xdev->update.yo = yo;
	xdev->update.xe = xe;
	xdev->update.ye = ye;
	xdev->up_area = new_area;
}

/* ------ Internal procedures ------ */

/* Substitute for XPutImage using XFillRectangle. */
/* This is a total hack to get around an apparent bug */
/* in the X server.  It only works with the specific */
/* parameters (bit/byte order, padding) used above. */
private void
alt_put_image(gx_device *dev, Display *dpy, Drawable win, GC gc,
  XImage *pi, int sx, int sy, int dx, int dy, unsigned w, unsigned h)
{	int raster = pi->bytes_per_line;
	_byte *data = (_byte *)pi->data + sy * raster + (sx >> 3);
	int init_mask = 0x80 >> (sx & 7);
	int invert;
	int yi;
#define nrects 40
	XRectangle rects[nrects];
	XRectangle *rp = rects;
	if ( xdev->fore_color != gx_no_color_index )
	  { if ( xdev->back_color != gx_no_color_index )
	      { XSetForeground(dpy, gc, xdev->colors[xdev->back_color]);
		XFillRectangle(dpy, win, gc, dx, dy, w, h);
	      }
	    XSetForeground(dpy, gc, xdev->colors[xdev->fore_color]);
	    invert = 0;
	  }
	else if ( xdev->back_color != gx_no_color_index )
	  { XSetForeground(dpy, gc, xdev->colors[xdev->back_color]);
	    invert = 0xff;
	  }
	else
	  return;
	for ( yi = 0; yi < h; yi++, data += raster )
	  { register int mask = init_mask;
	    register _byte *dp = data;
	    register int xi = 0;
	    while ( xi < w )
	      { if ( (*dp ^ invert) & mask )
		  { int xleft = xi;
		    if ( rp == &rects[nrects] )
		      { XFillRectangles(dpy, win, gc, rects, nrects);
			rp = rects;
		      }
		    /* Scan over a run of 1-bits */
		    rp->x = dx + xi, rp->y = dy + yi;
		    do
		      { if ( !(mask >>= 1) ) mask = 0x80, dp++;
			xi++;
		      }
		    while ( xi < w && (*dp & mask) );
		    rp->width = xi - xleft, rp->height = 1;
		    rp++;
		  }
		else
		  { if ( !(mask >>= 1) ) mask = 0x80, dp++;
		    xi++;
		  }
	      }
	  }
	XFillRectangles(dpy, win, gc, rects, rp - rects);
}