/* $Id: x11window.c,v 1.1.1.1 1997/12/06 05:41:31 darius Exp $ */


/* x11window.c
 *
 * Kevin P. Smith  6/11/89
 * Much modified by Jerry Frain and Joe Young
 */

#include <stdio.h>
#ifdef __STDC__
#include <stdlib.h>
#endif
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#ifdef RFCURSORS
#include <X11/Xmu/CurUtil.h>
#endif
#include <X11/cursorfont.h>
#include <assert.h>
#include <string.h>
#include "Wlib.h"
#include "defs.h"
#include "struct.h"
#include "data.h"
#include "proto.h"

#define INVALID_POSITION	-10000	/* gotta be a big negative */
/* XFIX speedup */
#define MAXCACHE	128

/* changes too good to risk leaving out, by Richard Caley (rjc@cstr.ed.ac.uk)*/
#define RJC
#define FOURPLANEFIX

/*
#define NORMAL_FONT	"-*-fixed-medium-r-*-*-10-*-*-*-*-*-*-*"
#define BOLD_FONT	"-*-fixed-medium-r-*-*-10-*-*-*-*-*-*-*"
#define ITALIC_FONT	"-*-fixed-medium-r-*-*-10-*-*-*-*-*-*-*"
*/

#define NORMAL_FONT	"6x10"
#define BOLD_FONT	"6x10"
#define BOLD_FONT2	"-*-clean-bold-r-normal--10-100-75-75-c-60-*"
#define ITALIC_FONT	"6x10"
#define ITALIC_FONT2	"-*-clean-bold-r-normal--10-100-75-75-c-60-*"
#define BIG_FONT	"-adobe-helvetica-bold-r-normal--34-*-*-*-*-*-*-*"
#define IND_FONT        "-*-clean-bold-r-normal--10-100-75-75-c-60-*"
/*#define BOLD_FONT2	"-schumacher-clean-bold-r-normal--10-100-75-75-c-60-iso8859-1"
#define ITALIC_FONT2	"-misc-fixed-medium-i-normal--10-100-75-75-c-60-iso8859-1"
#define BIG_FONT	"-adobe-helvetica-bold-r-normal--34-*-*-*-*-*-*-*"
*/

static char *_nfonts[] = {
    NORMAL_FONT,
    "-*-clean-medium-r-normal--10-100-75-75-c-60-*",
    "fixed",
    NULL,
};
static char *_bfonts[] = {
    BOLD_FONT,
    "-*-clean-bold-r-normal--10-100-75-75-c-60-*",
    "fixed",
    NULL,
};
static char *_ifonts[] = {
    ITALIC_FONT,
    "-*-clean-bold-r-normal--10-100-75-75-c-60-*",
    "fixed",
    NULL,
};
static char *_bgfonts[] = {
    BIG_FONT,
    "-*-lucidatypewriter-*-*-*-*-40-*-*-*-*-*-*-*",
    "fixed",
    NULL,
};

#define FONTS 4
#define BITGC 4

#define WHITE   0
#define BLACK   1
#define RED     2
#define GREEN   3
#define YELLOW  4
#define CYAN    5
#define GREY	6

static int zero = 0;
static int one = 1;
static int two = 2;
static int three = 3;

int     controlkey = 0;
#define	BillsScrewyAltMask	(Mod1Mask|Mod2Mask|Mod3Mask|Mod4Mask|Mod5Mask)
int     altkey = 0;
int     W_FastClear = 0;
#ifdef CONTINUOUS_MOUSE
int     buttonDown = 0;
#endif				/* CONTINUOUS_MOUSE */
Display *W_Display;
Window  W_Root;
Colormap W_Colormap;
int     W_Screen;
#ifdef FOURPLANEFIX
Visual *W_Visual;
#endif
W_Font  W_BigFont = (W_Font) & zero, W_RegularFont = (W_Font) & one;
W_Font  W_HighlightFont = (W_Font) & two, W_UnderlineFont = (W_Font) & three;
W_Color W_White = WHITE, W_Black = BLACK, W_Red = RED, W_Green = GREEN;
W_Color W_Yellow = YELLOW, W_Cyan = CYAN, W_Grey = GREY;
int     W_Textwidth, W_Textheight;
char   *getdefault();
char   *strdup();

int     W_in_message = 0;	/* jfy -- for Jerry's warp message hack */

#ifdef RJC
extern W_Window baseWin;
static XClassHint class_hint = {
    "netrek", "Netrek",
};

static XWMHints wm_hint = {
    InputHint | StateHint,
    True,
    WithdrawnState,
    None,
    None,
    0, 0,
    None,
    None,
};

static XSizeHints wm_size_hint;
#endif				/* RJC */

static W_Event W_myevent;
static int W_isEvent = 0;

struct fontInfo {
    XFontStruct *fontstruct;
    int     baseline;
};

struct colors {
    char   *name;
    GC      contexts[FONTS + 1];
    Pixmap  pixmap;
    long    pixelValue;
};

struct icon {
    Window  window;
    Pixmap  bitmap;
    int     width, height;
    Pixmap  pixmap;
};

#define WIN_GRAPH	1
#define WIN_TEXT	2
#define WIN_MENU	3
#define WIN_SCROLL	4

struct window {
    Window  window;
    int     type;
    char   *data;
    int     mapped;
    int     width, height;
    char   *name;
    Cursor  cursor;
#ifdef SHORT_PACKETS
    int     insensitive;
#endif
#if 0
    W_Callback handle_keydown;
    W_Callback handle_keyup;
    W_Callback handle_button;
    W_Callback handle_expose;
#endif				/* 0 */
};

struct stringList {
    char   *string;
    W_Color color;
    struct stringList *next;
};

struct menuItem {
    char   *string;
    W_Color color;
    W_Font  font;
};

struct colors colortable[] = {
    {"white"},
    {"black"},
    {"red"},
    {"green"},
    {"yellow"},
    {"cyan"},
    {"light grey"}
};

struct windowlist {
    struct window *window;
    struct windowlist *next;
};

#define HASHSIZE 29
#define hash(x) (((int) (x)) % HASHSIZE)

struct windowlist *hashtable[HASHSIZE];
struct fontInfo fonts[FONTS];

struct window *newWindow();
#ifndef NeXT
#ifndef __STDC__
char   *malloc();
#endif
#endif				/* NeXT */
short  *x11tox10bits();

struct window myroot;

#define NCOLORS (sizeof(colortable)/sizeof(colortable[0]))
#define W_Void2Window(win) ((win) ? (struct window *) (win) : &myroot)
#define W_Window2Void(window) ((W_Window) (window))
#define W_Void2Icon(bit) ((struct icon *) (bit))
#define W_Icon2Void(bit) ((W_Icon) (bit))
#define fontNum(font) (*((int *) font))
#define TILESIDE 16

#define WIN_EDGE 5		/* border on l/r edges of text windows */
#define MENU_PAD 4		/* border on t/b edges of text windows */
#define MENU_BAR 2		/* width of menu bar */

static unsigned char gray[] = {
    0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55,
    0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55,
    0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55,
    0xaa, 0xaa, 0x55, 0x55, 0xaa, 0xaa, 0x55, 0x55
};

static unsigned char striped[] = {
    0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
    0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f,
    0xff, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff, 0x00,
    0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0
};

static unsigned char solid[] = {
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff
};

/* Prototypes */
/*static int _myerror P((Display *d , XErrorEvent *e ));*/
static void GetFonts P((void));
static XFontStruct *find_font P((char *oldf, char **fonts));
static void GetColors P((void));
static void FlushClearAreaCache P((Window win));
static int W_SpNextEvent P((W_Event * wevent));
static void FlushLineCache P((Window win, int color));
static void FlushPointCache P((Window win, int color));
static struct window *findWindow P((Window window));
static void addToHash P((struct window * win));
static void AddToScrolling P((struct window * win, W_Color color, char *str, int len));
static void redrawScrolling P((struct window * win));
static void resizeScrolling P((struct window * win, int width, int height));
static void redrawMenu P((struct window * win));
static void redrawMenuItem P((struct window * win, int n));
static void changeMenuItem P((struct window * win, int n, W_Color color, char *str, int len, W_Font font));
/*static void W_SetTransientForHint P((W_Window w , W_Window pw ));*/
static void checkGeometry P((char *name, int *x, int *y, int *width, int *height));
static void checkParent P((char *name, W_Window * parent));
static void checkCursor P((char *name, char *cursname, Cursor * cursor));
static void findMouse P((int *x, int *y));
#ifdef AUTOKEY
static void W_Flush P((void));
#endif				/* AUTOKEY */
static void deleteWindow P((struct window * window));

/* X debugging */
#if 0
static int
_myerror(d, e)
    Display *d;
    XErrorEvent *e;
{
    abort();
}
#endif				/* 0 */

void
W_Initialize(str)
    char   *str;
{
    int     i;

#ifdef DEBUG
    printf("Initializing...\n");
#endif
    for (i = 0; i < HASHSIZE; i++) {
	hashtable[i] = NULL;
    }
    if ((W_Display = XOpenDisplay(str)) == NULL) {
	fprintf(stderr, "Cannot open display \"%s\"\n", str ? str : "(null)");
	EXIT(1);
    }
#if 0
    /* tmp */
    XSynchronize(W_Display, True);
    XSetErrorHandler(_myerror);
#endif

    W_Root = DefaultRootWindow(W_Display);
#ifdef FOURPLANEFIX
    W_Visual = DefaultVisual(W_Display, DefaultScreen(W_Display));
#endif
    W_Screen = DefaultScreen(W_Display);
    W_Colormap = DefaultColormap(W_Display, W_Screen);
    myroot.window = W_Root;
    myroot.type = WIN_GRAPH;
    GetFonts();
    GetColors();
}

static void
GetFonts()
{
    Font    regular, italic, bold, big;
    int     i;
    XGCValues values;
    XFontStruct *fontinfo;
    char   *fontname;

    fontname = getdefault("font");
    if (fontname == NULL)
	fontname = NORMAL_FONT;
    fontinfo = XLoadQueryFont(W_Display, fontname);
    if (fontinfo == NULL) {
	fontinfo = find_font(fontname, _nfonts);
    }
    if (fontinfo == NULL) {
	printf("netrek: Can't find any fonts!\n");
	EXIT(1);
    }
    regular = fontinfo->fid;
    W_Textwidth = fontinfo->max_bounds.width;
    W_Textheight = fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent;
    fonts[1].baseline = fontinfo->max_bounds.ascent;
    fonts[1].fontstruct = fontinfo;

    fontname = getdefault("boldfont");
    if (fontname == NULL) {
	if (DisplayCells(W_Display, W_Screen) <= 4)
	    fontname = BOLD_FONT2;
	else
	    fontname = BOLD_FONT;
    }
    fontinfo = XLoadQueryFont(W_Display, fontname);
    if (fontinfo == NULL) {
	fontinfo = find_font(fontname, _bfonts);
    }
    if (fontinfo == NULL) {
	bold = regular;
	fonts[2].baseline = fonts[1].baseline;
	fonts[2].fontstruct = fonts[1].fontstruct;
    } else {
	bold = fontinfo->fid;
	fonts[2].baseline = fontinfo->max_bounds.ascent;
	fonts[2].fontstruct = fontinfo;
	if (fontinfo->max_bounds.width > W_Textwidth)
	    W_Textwidth = fontinfo->max_bounds.width;
	if (fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent > W_Textheight)
	    W_Textheight = fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent;
    }

    fontname = getdefault("italicfont");
    if (fontname == NULL) {
	if (DisplayCells(W_Display, W_Screen) <= 4)
	    fontname = ITALIC_FONT2;
	else
	    fontname = ITALIC_FONT;
    }
    fontinfo = XLoadQueryFont(W_Display, fontname);
    if (fontinfo == NULL) {
	fontinfo = find_font(fontname, _ifonts);
    }
    if (fontinfo == NULL) {
	italic = regular;
	fonts[3].baseline = fonts[1].baseline;
	fonts[3].fontstruct = fonts[1].fontstruct;
    } else {
	italic = fontinfo->fid;
	fonts[3].baseline = fontinfo->max_bounds.ascent;
	fonts[3].fontstruct = fontinfo;
	if (fontinfo->max_bounds.width > W_Textwidth)
	    W_Textwidth = fontinfo->max_bounds.width;
	if (fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent > W_Textheight)
	    W_Textheight = fontinfo->max_bounds.descent + fontinfo->max_bounds.ascent;
    }

    fontname = getdefault("bigfont");
    if (fontname == NULL)
	fontname = BIG_FONT;
    fontinfo = XLoadQueryFont(W_Display, fontname);
    if (fontinfo == NULL) {
	fontinfo = find_font(fontname, _bgfonts);
    }
    if (fontinfo == NULL) {
	big = regular;
	fonts[0].baseline = fonts[1].baseline;
	fonts[0].fontstruct = fonts[1].fontstruct;
    } else {
	big = fontinfo->fid;
	fonts[0].baseline = fontinfo->max_bounds.ascent;
	fonts[0].fontstruct = fontinfo;
    }
    for (i = 0; i < NCOLORS; i++) {
	values.font = big;
	colortable[i].contexts[0] = XCreateGC(W_Display, W_Root, GCFont, &values);
	XSetGraphicsExposures(W_Display, colortable[i].contexts[0], False);
	values.font = regular;
	colortable[i].contexts[1] = XCreateGC(W_Display, W_Root, GCFont, &values);
	XSetGraphicsExposures(W_Display, colortable[i].contexts[1], False);
	values.font = bold;
	colortable[i].contexts[2] = XCreateGC(W_Display, W_Root, GCFont, &values);
	XSetGraphicsExposures(W_Display, colortable[i].contexts[2], False);
	values.font = italic;
	colortable[i].contexts[3] = XCreateGC(W_Display, W_Root, GCFont, &values);
	XSetGraphicsExposures(W_Display, colortable[i].contexts[3], False);
	{
	    static char dl[] = {1, 4};
	    XSetLineAttributes(W_Display, colortable[i].contexts[3],
			       0, LineOnOffDash, CapButt, JoinMiter);
	    XSetDashes(W_Display, colortable[i].contexts[3], 0, dl, 2);
	}
	values.function = GXor;
	colortable[i].contexts[BITGC] = XCreateGC(W_Display, W_Root, GCFunction, &values);
	XSetGraphicsExposures(W_Display, colortable[i].contexts[BITGC], False);
    }
}

static XFontStruct *
find_font(oldf, fonts)
    char   *oldf, **fonts;
{
    XFontStruct *fi;
    char  **f;
    fprintf(stderr, "netrek: Can't find font %s.  Trying others...\n",
	    oldf);
    for (f = fonts; *f; f++) {
	if (strcmp(*f, oldf) != 0) {
	    if ((fi = XLoadQueryFont(W_Display, *f)))
		return fi;
	}
    }
    printf("Error - can't find any font!\n");
    return NULL;
}

#ifdef FOURPLANEFIX
static unsigned short extrared[8] = {0x00, 0x20, 0x40, 0x60, 0x80, 0xa0, 0xb0, 0xc0};
static unsigned short extragreen[8] = {0x40, 0x60, 0x80, 0xa0, 0xb0, 0xc0, 0x00, 0x20};
static unsigned short extrablue[8] = {0x80, 0xa0, 0xb0, 0xc0, 0x00, 0x20, 0x40, 0x60};
#endif

int
W_Mono()
{
    return forceMono;
}

static void
GetColors()
{
    int     i, j;
    XColor  foo;
    int     white, black;
    unsigned long pixel;
    unsigned long planes[3];
    char    defaultstring[100];
    char   *defaults;
#ifdef FOURPLANEFIX
    unsigned long extracolors[8];
    XColor  colordef;
#endif
    extern int forceMono;
    forceMono = booleanDefault("forcemono", forceMono);

    if ((DisplayCells(W_Display, W_Screen) <= 4) || forceMono) {
	forceMono = 1;
	white = WhitePixel(W_Display, W_Screen);
	black = BlackPixel(W_Display, W_Screen);
	for (i = 0; i < NCOLORS; i++) {
	    if (i != W_Black) {
		colortable[i].pixelValue = white;
	    } else {
		colortable[i].pixelValue = black;
	    }
	    if (i == W_Red) {
		colortable[i].pixmap = XCreatePixmapFromBitmapData
		    (W_Display,
		     W_Root, (char *) striped, TILESIDE, TILESIDE,
		     white, black,
		     DefaultDepth(W_Display, W_Screen));
	    } else if (i == W_Yellow) {
		colortable[i].pixmap = XCreatePixmapFromBitmapData
		    (W_Display,
		     W_Root, (char *) gray, TILESIDE, TILESIDE,
		     white, black,
		     DefaultDepth(W_Display, W_Screen));
	    } else {
		colortable[i].pixmap = XCreatePixmapFromBitmapData
		    (W_Display,
		     W_Root, (char *) solid, TILESIDE, TILESIDE,
		     colortable[i].pixelValue,
		     colortable[i].pixelValue,
		     DefaultDepth(W_Display, W_Screen));
	    }

	    /*
	       We assume white is 0 or 1, and black is 0 or 1. We adjust
	       graphics function based upon who is who.
	    */
	    if (white == 0) {	/* Black is 1 */
		XSetFunction(W_Display, colortable[i].contexts[BITGC], GXand);
	    }
	}
    } else if (DefaultVisual(W_Display, W_Screen)->class == TrueColor) {
/* Stuff added by sheldon@iastate.edu 5/28/93
 * This is supposed to detect a TrueColor display, and then do a lookup of
 * the colors in default colormap, instead of creating new colormap
 */
	for (i = 0; i < NCOLORS; i++) {
	    sprintf(defaultstring, "color.%s", colortable[i].name);

	    defaults = getdefault(defaultstring);
	    if (defaults == NULL)
		defaults = colortable[i].name;
	    XParseColor(W_Display, W_Colormap, defaults, &foo);
	    XAllocColor(W_Display, W_Colormap, &foo);
	    colortable[i].pixelValue = foo.pixel;
	    colortable[i].pixmap = XCreatePixmapFromBitmapData(W_Display,
	    W_Root, (char *) solid, TILESIDE, TILESIDE, foo.pixel, foo.pixel,
					 DefaultDepth(W_Display, W_Screen));
	}
    } else {
#ifdef FOURPLANEFIX
	if (!XAllocColorCells(W_Display, W_Colormap, False, planes, 3,
			      &pixel, 1)) {
	    /* couldn't allocate 3 planes, make a new colormap */
	    W_Colormap = XCreateColormap(W_Display, W_Root, W_Visual, AllocNone);
	    if (!XAllocColorCells(W_Display, W_Colormap, False, planes, 3,
				  &pixel, 1)) {
		fprintf(stderr, "Cannot create new colormap\n");
		EXIT(1);
	    }
	    /*
	       and fill it with at least 8 more colors so when mouse is
	       inside netrek windows, use might be able to see his other
	       windows
	    */
	    if (XAllocColorCells(W_Display, W_Colormap, False, NULL, 0,
				 extracolors, 8)) {
		colordef.flags = DoRed | DoGreen | DoBlue;
		for (i = 0; i < 8; i++) {
		    colordef.pixel = extracolors[i];
		    colordef.red = extrared[i] << 8;
		    colordef.green = extragreen[i] << 8;
		    colordef.blue = extrablue[i] << 8;
		    XStoreColor(W_Display, W_Colormap, &colordef);
		}
	    }
	}
#else
	XAllocColorCells(W_Display, W_Colormap, False, planes, 3, &pixel, 1);
#endif
	for (i = 0; i < NCOLORS; i++) {
	    /*
	       strcpy(defaultstring, "color.%s", colortable[i].name);
	    */
	    sprintf(defaultstring, "color.%s", colortable[i].name);

	    defaults = getdefault(defaultstring);
	    if (defaults == NULL)
		defaults = colortable[i].name;
	    XParseColor(W_Display, W_Colormap, defaults, &foo);
	    /*
	       Black must be the color with all the planes off. That is the
	       only restriction I concerned myself with in the following case
	       statement.
	    */
	    switch (i) {
	    case WHITE:
		foo.pixel = pixel | planes[0] | planes[1] | planes[2];
		break;
	    case BLACK:
		foo.pixel = pixel;
		break;
	    case RED:
		foo.pixel = pixel | planes[0];
		break;
	    case CYAN:
		foo.pixel = pixel | planes[1];
		break;
	    case YELLOW:
		foo.pixel = pixel | planes[2];
		break;
	    case GREY:
		foo.pixel = pixel | planes[0] | planes[1];
		break;
	    case GREEN:
		foo.pixel = pixel | planes[1] | planes[2];
		break;
	    }
	    XStoreColor(W_Display, W_Colormap, &foo);
	    colortable[i].pixelValue = foo.pixel;
	    colortable[i].pixmap = XCreatePixmapFromBitmapData(W_Display,
	    W_Root, (char *) solid, TILESIDE, TILESIDE, foo.pixel, foo.pixel,
					 DefaultDepth(W_Display, W_Screen));
	}
    }
    for (i = 0; i < NCOLORS; i++) {
	for (j = 0; j < FONTS + 1; j++) {
	    XSetForeground(W_Display, colortable[i].contexts[j],
			   colortable[i].pixelValue);
	    XSetBackground(W_Display, colortable[i].contexts[j],
			   colortable[W_Black].pixelValue);
	}
    }
}

void
W_RenameWindow(window, str)
    W_Window window;
    char   *str;
{
    XStoreName(W_Display, ((struct window *) window)->window, str);
}

static  W_Window
w_MakeWindow(name, x, y, width, height, parent,
	     cursname, border, color, wsort)
    char   *name;
    int     x, y, width, height;
    W_Window parent;
    char   *cursname;
    int     border;
    W_Color color;
    int     wsort;		/* WIN_? */
{
    int     gx, gy;
    struct window *newwin;
    Window  wparent;
    Cursor  cursor;
    XSetWindowAttributes attrs;
    int     pwidth, pheight;	/* pixel width and height */


    checkGeometry(name, &gx, &gy, &width, &height);
    if (gx != INVALID_POSITION)
	x = gx;
    if (gy != INVALID_POSITION)
	y = gy;

    checkParent(name, &parent);
    wparent = W_Void2Window(parent)->window;

    checkCursor(name, cursname, &cursor);
    attrs.cursor = cursor;

    attrs.border_pixel = colortable[color].pixelValue;
    attrs.background_pixel = colortable[W_Black].pixelValue;

    if (wsort == WIN_TEXT || wsort == WIN_SCROLL || wsort == WIN_MENU) {
	pwidth = width * W_Textwidth + WIN_EDGE * 2;
	if (wsort == WIN_MENU)
	    pheight = height * (W_Textheight + MENU_PAD * 2 + MENU_BAR) - MENU_BAR;
	else
	    pheight = height * W_Textheight + MENU_PAD * 2;
    } else {
	pwidth = width;
	pheight = height;
    }

    switch (wsort) {
    case WIN_TEXT:
    case WIN_MENU:
	attrs.event_mask = KeyPressMask | ButtonPressMask | ExposureMask | ButtonReleaseMask;
	attrs.do_not_propagate_mask = ExposureMask | KeyPressMask | ButtonPressMask;
	break;
    case WIN_GRAPH:
	attrs.event_mask = KeyPressMask | ButtonPressMask | ExposureMask | LeaveWindowMask | ButtonReleaseMask | ButtonMotionMask;
	attrs.do_not_propagate_mask = ExposureMask;
	break;
    case WIN_SCROLL:
	attrs.event_mask = ResizeRedirectMask | ExposureMask | KeyPressMask | ButtonReleaseMask | ButtonPressMask;
	attrs.do_not_propagate_mask = ResizeRedirectMask | ExposureMask;
	break;
    default:
	fprintf(stderr, "x11window.c: w_MakeWindow: unknown wsort %d\n", wsort);
    }

#ifdef AUTOKEY
    if (attrs.event_mask & KeyPressMask)
	attrs.event_mask |= KeyReleaseMask;
#endif				/* AUTOKEY */

    if (strcmp(name, "netrek_icon") == 0)	/* icon should not select for
						   input */
	attrs.event_mask = ExposureMask;
    if (strcmp(name, "wait_icon") == 0)	/* same here [BDyess] */
	attrs.event_mask = ExposureMask;

    if (strcmp(name, "info") == 0)	/* make info window passthru [BDyess] */
	attrs.event_mask = ExposureMask;

    newwin = newWindow
	(XCreateWindow(W_Display, wparent, x, y, pwidth, pheight, border,
		       CopyFromParent, InputOutput, CopyFromParent,
		       CWBackPixel | CWBorderPixel | CWEventMask |
		       (cursor ? CWCursor : 0),
		       &attrs),
	 wsort);

    newwin->cursor = cursor;

    {
	char   *s;

	if (0 == strcmp(name, "wait"))
	    s = serverName;
	else if (0 == strcmp(name, "Motd"))
	    s = "Motd - [f] forward, [b] back, [tab] sysdefs, [space] unmap";
	else if (0 == strcmp(name, "netrek")) {
	    if (!title) {
		char    buf[80];
		sprintf(buf, "Netrek  @  %s", serverName);
		s = buf;
	    } else {
		/* but title on command line will override */
		/* from -h arg */
		s = title;
	    }
	} else
	    s = name;

	XStoreName(W_Display, newwin->window, s);
    }

    wm_size_hint.width = wm_size_hint.min_width =
	wm_size_hint.max_width = wm_size_hint.base_width = pwidth;
    wm_size_hint.min_height = wm_size_hint.height =
	wm_size_hint.max_height = wm_size_hint.base_height = pheight;
    wm_size_hint.flags = USSize | PMinSize | PMaxSize | PBaseSize;
    if (gx > INVALID_POSITION || gy > INVALID_POSITION) {
	wm_size_hint.flags |= USPosition;
	wm_size_hint.x = x;
	wm_size_hint.y = y;
    }
    XSetWMNormalHints(W_Display, newwin->window, &wm_size_hint);

    class_hint.res_name = name;
    class_hint.res_class = "Netrek";
    XSetClassHint(W_Display, newwin->window, &class_hint);

    XSetWMHints(W_Display, newwin->window, &wm_hint);

    if (((wparent == W_Root &&
	  baseWin != NULL &&
	  strcmp(name, "wait") != 0)
	 || wsort == WIN_MENU) &&
	strcmp(name, "MetaServer List") != 0 &&
	strcmp(name, "Motd") != 0) {
	XSetTransientForHint(W_Display, newwin->window,
			     W_Void2Window(baseWin)->window);
    }
    newwin->name = strdup(name);
    newwin->width = width;
    newwin->height = height;
    if (wsort == WIN_MENU) {
	int     i;
	struct menuItem *items;
	items = (struct menuItem *) malloc(height * sizeof(struct menuItem));
	for (i = 0; i < height; i++) {
	    items[i].string = NULL;
	    items[i].color = W_White;
	    items[i].font = W_RegularFont;
	}
	newwin->data = (char *) items;
    } else {
	newwin->data = 0;
    }

    if (wparent != W_Root)
	if (checkMapped(name))
	    W_MapWindow(W_Window2Void(newwin));

#ifdef DEBUG
    printf("New graphics window %d, child of %d\n", newwin, parent);
#endif

#ifdef FOURPLANEFIX
    XSetWindowColormap(W_Display, newwin->window, W_Colormap);
#endif

    return (W_Window2Void(newwin));
}




W_Window
W_MakeWindow(name, x, y, width, height, parent, cursname, border, color)
    char   *name;
    int     x, y, width, height;
    W_Window parent;
    char   *cursname;
    int     border;
    W_Color color;
{
    return w_MakeWindow(name, x, y, width, height, parent,
			cursname, border, color, WIN_GRAPH);
}

void
W_ChangeBorder(window, color)
    W_Window window;
    int     color;
{
#ifdef DEBUG
    printf("Changing border of %d\n", window);
#endif

    /* fix inexplicable color bug */
    if (DisplayCells(W_Display, W_Screen) <= 2)
	XSetWindowBorderPixmap(W_Display, W_Void2Window(window)->window,
			       colortable[color].pixmap);
    else
	XSetWindowBorder(W_Display, W_Void2Window(window)->window,
			 colortable[color].pixelValue);
}

void
W_MapWindow(window)
    W_Window window;
{
    struct window *win;

#ifdef DEBUG
    printf("Mapping %d\n", window);
#endif
    win = W_Void2Window(window);
    if (win->mapped)
	return;
    win->mapped = 1;
    XMapRaised(W_Display, win->window);
}

void
W_UnmapWindow(window)
    W_Window window;
{
    struct window *win;

#ifdef DEBUG
    printf("UnMapping %d\n", window);
#endif
    win = W_Void2Window(window);
    if (win->mapped == 0)
	return;
    win->mapped = 0;
    XUnmapWindow(W_Display, win->window);
}

int
W_IsMapped(window)
    W_Window window;
{
    struct window *win;

    win = W_Void2Window(window);
    if (win == NULL)
	return (0);
    return (win->mapped);
}

void
W_FillArea(window, x, y, width, height, color)
    W_Window window;
    int     x, y, width, height;
    W_Color color;
{
    struct window *win;

#ifdef DEBUG
    printf("Clearing (%d %d) x (%d %d) with %d on %d\n", x, y, width, height,
	   color, window);
#endif
    win = W_Void2Window(window);
    switch (win->type) {
    case WIN_GRAPH:
	XFillRectangle(W_Display, win->window, colortable[color].contexts[0],
		       x, y, width, height);
	break;
    default:
	XFillRectangle(W_Display, win->window, colortable[color].contexts[0],
		    WIN_EDGE + x * W_Textwidth, MENU_PAD + y * W_Textheight,
		       width * W_Textwidth, height * W_Textheight);
    }
}

/* XFIX */

static XRectangle _rcache[MAXCACHE];
static int _rcache_index;

static void
FlushClearAreaCache(win)
    Window  win;
{
    XFillRectangles(W_Display, win, colortable[backColor].contexts[0],
		    _rcache, _rcache_index);
    _rcache_index = 0;
}

/* local window only */
void
W_CacheClearArea(window, x, y, width, height)
    W_Window window;
    int     x, y, width, height;
{
    Window  win = W_Void2Window(window)->window;
    register XRectangle *r;

    if (_rcache_index == MAXCACHE)
	FlushClearAreaCache(win);

    r = &_rcache[_rcache_index++];
    r->x = (short) x;
    r->y = (short) y;
    r->width = (unsigned short) width;
    r->height = (unsigned short) height;
}

void
W_FlushClearAreaCache(window)
    W_Window window;
{
    Window  win = W_Void2Window(window)->window;

    if (_rcache_index)
	FlushClearAreaCache(win);
}

/* XFIX: clears now instead of filling. */
void
W_ClearArea(window, x, y, width, height)
    W_Window window;
    int     x, y, width, height;
{
    struct window *win;

#ifdef DEBUG
    printf("Clearing (%d %d) x (%d %d) with %d on %d\n", x, y, width, height,
	   color, window);
#endif
    win = W_Void2Window(window);
    switch (win->type) {
    case WIN_GRAPH:
	/* XFIX: changed */
	XClearArea(W_Display, win->window, x, y, width, height, False);
	break;
    default:
	/* XFIX: changed */
	XClearArea(W_Display, win->window, WIN_EDGE + x * W_Textwidth,
		   MENU_PAD + y * W_Textheight, width * W_Textwidth, height * W_Textheight, False);
	break;
    }
}

void
W_ClearWindow(window)
    W_Window window;
{
#ifdef DEBUG
    printf("Clearing %d\n", window);
#endif
    XClearWindow(W_Display, W_Void2Window(window)->window);
}

void
W_GetEvent(wevent)
    W_Event *wevent;
{
/* blocks until an event is received [BDyess] */
    XEvent  event;

    if (W_isEvent) {
	*wevent = W_myevent;
	W_isEvent = 0;
	return;
    }
    XNextEvent(W_Display, &event);
    XPutBackEvent(W_Display, &event);
    W_SpNextEvent(wevent);
}

int
W_EventsPending()
{
    if (W_isEvent)
	return (1);
    while (XPending(W_Display) || buttonDown) {
	if (W_SpNextEvent(&W_myevent)) {
	    W_isEvent = 1;
	    return (1);
	}
    }
    return (0);
}

void
W_NextEvent(wevent)
    W_Event *wevent;
{
    if (W_isEvent) {
	*wevent = W_myevent;
	W_isEvent = 0;
	return;
    }
    while (W_SpNextEvent(wevent) == 0);
}

static int
W_SpNextEvent(wevent)
    W_Event *wevent;
{
    XEvent  event;
    XKeyEvent *key;
    XButtonEvent *button;
    XExposeEvent *expose;
    XResizeRequestEvent *resize;
    char    ch;
    struct window *win;
#ifdef CONTINUOUS_MOUSE
    static W_Event buttonEvent;
    static int delay, cupd = -1;
#endif				/* CONTINUOUS_MOUSE */

#ifdef DEBUG
    printf("Getting an event...\n");
#endif
    key = (XKeyEvent *) & event;
    button = (XButtonEvent *) & event;
    expose = (XExposeEvent *) & event;
    resize = (XResizeRequestEvent *) & event;
    for (;;) {
	if (XPending(W_Display))
	    XNextEvent(W_Display, &event);
#ifdef CONTINUOUS_MOUSE
	else if (buttonDown) {
	    if (continuousMouse && allowContinuousMouse) {
		if (cupd != udcounter) {
		    cupd = udcounter;
		    if (delay == 0) {
			bcopy(&buttonEvent, wevent, sizeof(W_Event));
			delay = clickDelay;
		    } else {
			delay--;
			wevent->type = -1;
		    }
		} else
		    wevent->type = -1;
		exitInputLoop = 1;
	    } else {
		wevent->type = -1;
		buttonDown = 0;
	    }
	    return (1);
	}
#endif
	else
	    return (0);
	/*
	   printf("read an event %d\n", event.type);
	*/
	win = findWindow(key->window);
	if (win == NULL)
	    return (0);
	if ((event.type == KeyPress || event.type == ButtonPress) &&
	    win->type == WIN_MENU) {
	    if (key->y % (W_Textheight + MENU_PAD * 2 + MENU_BAR) >=
		W_Textheight + MENU_PAD * 2)
		return (0);
	    key->y = key->y / (W_Textheight + MENU_PAD * 2 + MENU_BAR);
	}
	switch ((int) event.type) {
	case LeaveNotify:	/* for message window -- jfy */
	    if (win == (struct window *) messagew) {
		W_in_message = 0;
	    }
	    return (0);
	    break;
	case KeyPress:
	    if (key->state & ControlMask) {
		controlkey = 1;
		key->state &= ~ControlMask;
	    } else
		controlkey = 0;
	    if (key->state & BillsScrewyAltMask) {
		altkey = 1;
		key->state &= ~BillsScrewyAltMask;
	    } else
		altkey = 0;
	    if (XLookupString(key, &ch, 1, NULL, NULL) > 0) {
		wevent->type = W_EV_KEY;
		wevent->Window = W_Window2Void(win);
		wevent->x = key->x;
		wevent->y = key->y;
		if (controlkey)
		    wevent->key = (int) ch + 128;
		else if (altkey)
		    wevent->key = (int) ch + 256;
		else
		    wevent->key = ch;
		return (1);
	    }
	    return (0);
	    break;
#ifdef AUTOKEY
	case KeyRelease:
	    if (XLookupString(key, &ch, 1, NULL, NULL) > 0) {
		wevent->type = W_EV_KEY_OFF;
		wevent->Window = W_Window2Void(win);
		wevent->x = key->x;
		wevent->y = key->y;
		wevent->key = ch;
		return (1);
	    }
	    return (0);
	    break;
#endif				/* AUTOKEY */
	case ButtonPress:
	    wevent->type = W_EV_BUTTON;
	    wevent->Window = W_Window2Void(win);
	    wevent->x = button->x;
	    wevent->y = button->y;
	    switch (button->button & 0xf) {
	    case Button3:
		wevent->key = W_RBUTTON;
		break;
	    case Button1:
		wevent->key = W_LBUTTON;
		break;
	    case Button2:
		wevent->key = W_MBUTTON;
		break;
	    }
	    if (key->state & ControlMask)
		wevent->key += 6;
	    if (key->state & ShiftMask)
		wevent->key += 3;
	    if (key->state & BillsScrewyAltMask)
		wevent->key += 12;	/* alt */
#ifdef CONTINUOUS_MOUSE
	    if (continuousMouse && allowContinuousMouse &&
		(wevent->Window == w || wevent->Window == mapw) &&
	    /*
	       buttonRepeatMask allows only certain buttons to repeat
	       [BDyess]
	    */
		(1 << (wevent->key) & buttonRepeatMask)) {
		buttonDown = 1;
		exitInputLoop = 1;
		delay = clickDelay;
		bcopy(wevent, &buttonEvent, sizeof(W_Event));
	    }
	    return (1);
	case ButtonRelease:
	    /* bcopy(&buttonEvent,wevent,sizeof(W_Event)); */
	    wevent->type = -1;
	    buttonDown = 0;
	    return (1);
	case MotionNotify:
	    /*
	       the !buttonDown ensures that if you press a button and then
	       press another, release just the second, and then move the
	       mouse that nothing happens.
	    */
	    if (!(continuousMouse && allowContinuousMouse) || !buttonDown) {
		wevent->type = -1;
		return (1);
	    }
	    wevent->type = W_EV_BUTTON;
	    wevent->Window = W_Window2Void(win);
	    wevent->x = button->x;
	    wevent->y = button->y;
	    wevent->key = buttonEvent.key;
	    bcopy(wevent, &buttonEvent, sizeof(W_Event));
	    if (cupd == udcounter)
		wevent->type = -1;
	    else
		cupd = udcounter;

	    return (1);
#else
	    return (1);
#endif				/* CONTINUOUS_MOUSE */
	case Expose:
	    if (expose->count != 0)
		return (0);
	    if (win->type == WIN_SCROLL) {
		redrawScrolling(win);
		return (0);
	    }
	    if (win->type == WIN_MENU) {
		redrawMenu(win);
		return (0);
	    }
	    wevent->type = W_EV_EXPOSE;
	    wevent->Window = W_Window2Void(win);
	    return (1);
	case ResizeRequest:
	    resizeScrolling(win, resize->width, resize->height);
	    break;
	default:
	    return (0);
	    break;
	}
    }
}

void
W_MakeLine(window, x0, y0, x1, y1, color)
    W_Window window;
    int     x0, y0, x1, y1;
    W_Color color;
{
    Window  win;

#ifdef DEBUG
    printf("Line on %d\n", window);
#endif
    win = W_Void2Window(window)->window;
    XDrawLine(W_Display, win, colortable[color].contexts[0], x0, y0, x1, y1);
}

void
W_DrawPoint(window, x, y, color)
    W_Window window;
    int     x, y;
    W_Color color;
{
    Window  win;

#ifdef DEBUG
    printf("Point on %d\n", window);
#endif
    win = W_Void2Window(window)->window;
    XDrawPoint(W_Display, win, colortable[color].contexts[0], x, y);
}

/* XFIX */

static XSegment _lcache[NCOLORS][MAXCACHE];
static int _lcache_index[NCOLORS];

static void
FlushLineCache(win, color)
    Window  win;
    int     color;
{
    XDrawSegments(W_Display, win, colortable[color].contexts[0],
		  _lcache[color], _lcache_index[color]);
    _lcache_index[color] = 0;
}

/* for local window only */
void
W_CacheLine(window, x0, y0, x1, y1, color)
    W_Window window;
    int     x0, y0, x1, y1, color;
{
    Window  win = W_Void2Window(window)->window;
    register XSegment *s;

    if (_lcache_index[color] == MAXCACHE)
	FlushLineCache(win, color);

    s = &_lcache[color][_lcache_index[color]++];
    s->x1 = (short) x0;
    s->y1 = (short) y0;
    s->x2 = (short) x1;
    s->y2 = (short) y1;
}

void
W_FlushLineCaches(window)
    W_Window window;
{
    Window  win = W_Void2Window(window)->window;
    register i;
    for (i = 0; i < NCOLORS; i++) {
	if (_lcache_index[i])
	    FlushLineCache(win, i);
    }
}

static XPoint _pcache[NCOLORS][MAXCACHE];
static int _pcache_index[NCOLORS];

static void
FlushPointCache(win, color)
    Window  win;
    int     color;
{
    XDrawPoints(W_Display, win, colortable[color].contexts[0],
		_pcache[color], _pcache_index[color], CoordModeOrigin);
    _pcache_index[color] = 0;
}

void
W_CachePoint(window, x, y, color)
    W_Window window;
    int     x, y, color;
{
    Window  win = W_Void2Window(window)->window;
    register XPoint *p;

    if (_pcache_index[color] == MAXCACHE)
	FlushPointCache(win, color);

    p = &_pcache[color][_pcache_index[color]++];
    p->x = (short) x;
    p->y = (short) y;
}

void
W_FlushPointCaches(window)
    W_Window window;
{
    Window  win = W_Void2Window(window)->window;
    register i;
    for (i = 0; i < NCOLORS; i++) {
	if (_pcache_index[i])
	    FlushPointCache(win, i);
    }
}

void
W_MakeTractLine(window, x0, y0, x1, y1, color)
    W_Window window;
    int     x0, y0, x1, y1;
    W_Color color;
{
    Window  win;

#ifdef DEBUG
    printf("Line on %d\n", window);
#endif
    win = W_Void2Window(window)->window;
    XDrawLine(W_Display, win, colortable[color].contexts[3], x0, y0, x1, y1);
}

void
W_DrawSectorHighlight(window, x, y, w, h, color)
    W_Window window;
    int     x, y, w, h;
    W_Color color;
{
    Window  win;
#ifdef YUCK
    XRectangle r[2];

    r[0].x = (short) x;
    r[0].y = (short) y;
    r[0].width = (unsigned short) w;
    r[0].height = (unsigned short) h;
    r[1].x = (short) x + 2;
    r[1].y = (short) y + 2;
    r[1].width = (unsigned short) w - 4;
    r[1].height = (unsigned short) h - 4;

    win = W_Void2Window(window)->window;
    XDrawRectangles(W_Display, win, colortable[color].contexts[3],
		    r, 2);
#else
    XRectangle r[1];

    r[0].x = (short) x + 2;
    r[0].y = (short) y + 2;
    r[0].width = (unsigned short) w - 4;
    r[0].height = (unsigned short) h - 4;

    win = W_Void2Window(window)->window;
    XDrawRectangles(W_Display, win, colortable[color].contexts[3],
		    r, 1);
#endif
}

void
W_WriteTriangle(window, x, y, s, t, color)
    W_Window window;
    int     x, y, s;
    int     t;
    W_Color color;
{
    struct window *win = W_Void2Window(window);
    XPoint  points[3];

    if (t == 0) {
	points[0].x = x;
	points[0].y = y;
	points[1].x = x + s;
	points[1].y = y - s;
	points[2].x = x - s;
	points[2].y = y - s;
    } else {
	points[0].x = x;
	points[0].y = y;
	points[1].x = x + s;
	points[1].y = y + s;
	points[2].x = x - s;
	points[2].y = y + s;
    }


    XFillPolygon(W_Display, win->window, colortable[color].contexts[0],
		 points, 3, Convex, CoordModeOrigin);
}

void
W_WriteText(window, x, y, color, str, len, font)
    W_Window window;
    int     x, y, len;
    W_Color color;
    W_Font  font;
    char   *str;
{
    struct window *win;
    int     addr;

    if (!font)
	font = W_RegularFont;
#ifdef DEBUG
    printf("Text for %d @ (%d, %d) in %d: [%s]\n", window, x, y, color, str);
#endif
    win = W_Void2Window(window);
    switch (win->type) {
    case WIN_GRAPH:
	addr = fonts[fontNum(font)].baseline;
	XDrawImageString(W_Display, win->window,
	  colortable[color].contexts[fontNum(font)], x, y + addr, str, len);
	break;
    case WIN_SCROLL:
	if (y<0) {
	  XCopyArea(W_Display, win->window, win->window,

		    colortable[W_White].contexts[0], WIN_EDGE, MENU_PAD,
		    win->width * W_Textwidth, (win->height - 1) * W_Textheight,
		    WIN_EDGE, MENU_PAD+W_Textheight);
	  XClearArea(W_Display, win->window,
		     WIN_EDGE, MENU_PAD,
		     W_Textwidth * win->width, W_Textheight, False);
	  XDrawImageString(W_Display, win->window,
			   colortable[color].contexts[1],
			   WIN_EDGE, MENU_PAD + fonts[1].baseline,
			   str, len);
	} else {
	  XCopyArea(W_Display, win->window, win->window,
		    colortable[W_White].contexts[0], WIN_EDGE, MENU_PAD + W_Textheight,
		    win->width * W_Textwidth, (win->height - 1) * W_Textheight,
		    WIN_EDGE, MENU_PAD);
	  XClearArea(W_Display, win->window,
		     WIN_EDGE, MENU_PAD + W_Textheight * (win->height - 1),
		     W_Textwidth * win->width, W_Textheight, False);
	  XDrawImageString(W_Display, win->window,
			   colortable[color].contexts[1],
			   WIN_EDGE, MENU_PAD + W_Textheight * (win->height - 1) + fonts[1].baseline,
			   str, len);
	}
	AddToScrolling(win, color, str, len);
	break;
    case WIN_MENU:
	changeMenuItem(win, y, color, str, len, font);
	break;
    default:
	addr = fonts[fontNum(font)].baseline;
	XDrawImageString(W_Display, win->window,
			 colortable[color].contexts[fontNum(font)],
	     x * W_Textwidth + WIN_EDGE, MENU_PAD + y * W_Textheight + addr,
			 str, len);
	break;
    }
}

void
W_MaskText(window, x, y, color, str, len, font)
    W_Window window;
    int     x, y, len;
    W_Color color;
    W_Font  font;
    char   *str;
{
    struct window *win;
    int     addr;

    addr = fonts[fontNum(font)].baseline;
#ifdef DEBUG
    printf("TextMask for %d @ (%d, %d) in %d: [%s]\n", window, x, y, color, str);
#endif
    win = W_Void2Window(window);
    XDrawString(W_Display, win->window,
	  colortable[color].contexts[fontNum(font)], x, y + addr, str, len);
}

W_Icon
W_StoreBitmap(width, height, data, window)
    int     width, height;
    W_Window window;
    char   *data;
{
    struct icon *newicon;
    struct window *win;

#ifdef DEBUG
    printf("Storing bitmap for %d (%d x %d)\n", window, width, height);
    fflush(stdout);
#endif
    win = W_Void2Window(window);
    newicon = (struct icon *) malloc(sizeof(struct icon));
    newicon->width = width;
    newicon->height = height;
    newicon->bitmap = XCreateBitmapFromData(W_Display, win->window,
					    data, width, height);
    newicon->window = win->window;
    newicon->pixmap = 0;
    return (W_Icon2Void(newicon));
}

void
W_FreeBitmap(bit)
    W_Icon  bit;
{
    struct icon *icon;
    icon = W_Void2Icon(bit);
    XFreePixmap(W_Display, icon->bitmap);
    free(icon);
}

void
W_WriteBitmap(x, y, bit, color)
    int     x, y;
    W_Icon  bit;
    W_Color color;
{
    struct icon *icon;

    icon = W_Void2Icon(bit);
#ifdef DEBUG
    printf("Writing bitmap to %d\n", icon->window);
#endif

    XCopyPlane(W_Display, icon->bitmap, icon->window,
	 colortable[color].contexts[BITGC], 0, 0, icon->width, icon->height,
	       x, y, 1);

}

void
W_WriteWinBitmap(win, x, y, bit, color)
    W_Window win;
    int     x, y;
    W_Icon  bit;
    W_Color color;
{
    struct icon *icon;
    Window  original;

    icon = W_Void2Icon(bit);
    original = icon->window;
    icon->window = W_Void2Window(win)->window;
    W_WriteBitmap(x, y, bit, color);
    icon->window = original;
    return;
}

void
W_TileWindow(window, bit)
    W_Window window;
    W_Icon  bit;
{
    Window  win;
    struct icon *icon;

#ifdef DEBUG
    printf("Tiling window %d\n", window);
#endif
    icon = W_Void2Icon(bit);
    win = W_Void2Window(window)->window;

    if (icon->pixmap == 0) {
	icon->pixmap = XCreatePixmap(W_Display, W_Root,
	      icon->width, icon->height, DefaultDepth(W_Display, W_Screen));
	XCopyPlane(W_Display, icon->bitmap, icon->pixmap,
	   colortable[W_White].contexts[0], 0, 0, icon->width, icon->height,
		   0, 0, 1);
    }
    XSetWindowBackgroundPixmap(W_Display, win, icon->pixmap);
    XClearWindow(W_Display, win);

    /*
       if (icon->pixmap==0) { icon->pixmap=XMakePixmap(icon->bitmap,
       colortable[W_White].pixelValue, colortable[W_Black].pixelValue); }
       XChangeBackground(win, icon->pixmap); XClear(win);
    */
}

void
W_UnTileWindow(window)
    W_Window window;
{
    Window  win;

#ifdef DEBUG
    printf("Untiling window %d\n", window);
#endif
    win = W_Void2Window(window)->window;

    XSetWindowBackground(W_Display, win, colortable[W_Black].pixelValue);
    XClearWindow(W_Display, win);
}

W_Window
W_MakeTextWindow(name, x, y, width, height, parent, cursname, border)
    char   *name;
    int     x, y, width, height;
    W_Window parent;
    char   *cursname;
    int     border;
{
    return w_MakeWindow(name, x, y, width, height,
			parent, cursname, border, W_White, WIN_TEXT);
}

struct window *
newWindow(window, type)
    Window  window;
    int     type;
{
    struct window *newwin;

    newwin = (struct window *) malloc(sizeof(struct window));
    newwin->window = window;
    newwin->type = type;
    newwin->mapped = 0;
    newwin->insensitive = 0;
    addToHash(newwin);
    return (newwin);
}


static struct window *
findWindow(window)
    Window  window;
{
    struct windowlist *entry;

    entry = hashtable[hash(window)];
    while (entry != NULL) {
	if (entry->window->window == window)
	    return (entry->window);
	entry = entry->next;
    }
    return (NULL);
}

static void
addToHash(win)
    struct window *win;
{
    struct windowlist **new;

#ifdef DEBUG
    printf("Adding to %d\n", hash(win->window));
#endif
    new = &hashtable[hash(win->window)];
    while (*new != NULL) {
	new = &((*new)->next);
    }
    *new = (struct windowlist *) malloc(sizeof(struct windowlist));
    (*new)->next = NULL;
    (*new)->window = win;
}

W_Window
W_MakeScrollingWindow(name, x, y, width, height, parent, cursname, border)
    char   *name;
    int     x, y, width, height;
    W_Window parent;
    char   *cursname;
    int     border;
{
    return w_MakeWindow(name, x, y, width, height, parent, cursname,
			border, W_White, WIN_SCROLL);
}

/* Add a string to the string list of the scrolling window.
 */
static void
AddToScrolling(win, color, str, len)
    struct window *win;
    W_Color color;
    char   *str;
    int     len;
{
    struct stringList **strings;
    char   *newstring;
    int     count;

    strings = (struct stringList **) & (win->data);
    count = 0;
    while ((*strings) != NULL) {
	count++;
	strings = &((*strings)->next);
    }
    (*strings) = (struct stringList *) malloc(sizeof(struct stringList));
    (*strings)->next = NULL;
    (*strings)->color = color;
    newstring = (char *) malloc(len + 1);
    strncpy(newstring, str, len);
    newstring[len] = 0;
    (*strings)->string = newstring;
    if (count >= 100) {		/* Arbitrary large size. */
	struct stringList *temp;

	temp = (struct stringList *) win->data;
	free(temp->string);
	temp = temp->next;
	free((char *) win->data);
	win->data = (char *) temp;
    }
}

#ifdef SHORT_PACKETS
void
W_SetSensitive(w, v)
    W_Window w;
    int     v;
{
    struct window *win = W_Void2Window(w);

    win->insensitive = !v;

    if (win->type == WIN_SCROLL)
	redrawScrolling(win);
}
#endif

static void
redrawScrolling(win)
    struct window *win;
{
    int     count;
    struct stringList *list;
    int     y;

    XClearWindow(W_Display, win->window);
    count = 0;
    list = (struct stringList *) win->data;
    while (list != NULL) {
	list = list->next;
	count++;
    }
    list = (struct stringList *) win->data;
    while (count > win->height) {
	list = list->next;
	count--;
    }
    y = (win->height - count) * W_Textheight + fonts[1].baseline;
    if (count == 0)
	return;
    while (list != NULL) {
	XDrawImageString(W_Display, win->window,
			 colortable[list->color].contexts[1],
		WIN_EDGE, MENU_PAD + y, list->string, strlen(list->string));
	list = list->next;
	y = y + W_Textheight;
    }
}

static void
resizeScrolling(win, width, height)
    struct window *win;
    int     width, height;
{
    win->height = (height - MENU_PAD * 2) / W_Textheight;
    win->width = (width - WIN_EDGE * 2) / W_Textwidth;
    XResizeWindow(W_Display, win->window, win->width * W_Textwidth + WIN_EDGE * 2,
		  win->height * W_Textheight + MENU_PAD * 2);
}

W_Window
W_MakeMenu(name, x, y, width, height, parent, border)
    char   *name;
    int     x, y, width, height;
    W_Window parent;
    int     border;
{
    return w_MakeWindow(name, x, y, width, height, parent,
			"left_ptr", border, W_White, WIN_MENU);
}

static void
redrawMenu(win)
    struct window *win;
{
    int     count;

    for (count = 1; count < win->height; count++) {
	XFillRectangle(W_Display, win->window,
		       colortable[W_Grey].contexts[0],
	  0, count * (W_Textheight + MENU_PAD * 2) + (count - 1) * MENU_BAR,
		       win->width * W_Textwidth + WIN_EDGE * 2, MENU_BAR);
    }
    for (count = 0; count < win->height; count++) {
	redrawMenuItem(win, count);
    }
}

static void
redrawMenuItem(win, n)
    struct window *win;
    int     n;
{
    struct menuItem *items;
    int     addr;

    items = (struct menuItem *) win->data;

    XFillRectangle(W_Display, win->window,
		   colortable[W_Black].contexts[0],
	  WIN_EDGE, n * (W_Textheight + MENU_PAD * 2 + MENU_BAR) + MENU_PAD,
		   win->width * W_Textwidth, W_Textheight);
    if (items[n].string) {
	addr = fonts[fontNum(items[n].font)].baseline;
	XDrawImageString(W_Display, win->window,
		colortable[items[n].color].contexts[fontNum(items[n].font)],
			 WIN_EDGE,
	     n * (W_Textheight + MENU_PAD * 2 + MENU_BAR) + MENU_PAD + addr,
			 items[n].string, strlen(items[n].string));
    }
}

static void
changeMenuItem(win, n, color, str, len, font)
    struct window *win;
    int     n;
    W_Color color;
    char   *str;
    int     len;
    W_Font  font;
{
    struct menuItem *items;
    char   *news;

    items = (struct menuItem *) win->data;
    if (items[n].string) {
	free(items[n].string);
    }
    news = malloc(len + 1);
    strncpy(news, str, len);
    news[len] = 0;
    items[n].string = news;
    items[n].color = color;
    items[n].font = font;
    redrawMenuItem(win, n);
    XFlush(W_Display);
}

static  Cursor
make_cursor(bits, mask, width, height, xhot, yhot)
    char   *bits, *mask;
    int     width, height, xhot, yhot;
{
    Pixmap  cursbits;
    Pixmap  cursmask;
    XColor  whiteCol, blackCol;
    Cursor  curs;

    whiteCol.pixel = colortable[W_White].pixelValue;
    XQueryColor(W_Display, W_Colormap, &whiteCol);
    blackCol.pixel = colortable[W_Black].pixelValue;
    XQueryColor(W_Display, W_Colormap, &blackCol);

    cursbits = XCreateBitmapFromData(W_Display, DefaultRootWindow(W_Display),
				     bits, width, height);
    cursmask = XCreateBitmapFromData(W_Display, DefaultRootWindow(W_Display),
				     mask, width, height);

    curs = XCreatePixmapCursor(W_Display, cursbits, cursmask,
			       &whiteCol, &blackCol, xhot, yhot);

    XFreePixmap(W_Display, cursbits);
    XFreePixmap(W_Display, cursmask);
    return curs;
}

#ifdef TCURSORS
#if 1

void
W_DefineTCrossCursor(window)
    W_Window window;
{
    return;
}

void
W_DefineTextCursor(window)
    W_Window window;
{
    static Cursor new = 0;
    struct window *win = W_Void2Window(window);
    XColor  f, b;

    if (!new) {
	f.pixel = colortable[W_Yellow].pixelValue;
	b.pixel = colortable[W_Black].pixelValue;

	XQueryColor(W_Display, W_Colormap, &f);
	XQueryColor(W_Display, W_Colormap, &b);

	new = XCreateFontCursor(W_Display, XC_xterm);

	XRecolorCursor(W_Display, new, &f, &b);
    }
    XDefineCursor(W_Display, win->window, new);

    return;
}

void
W_RevertCursor(window)
    W_Window window;
{
    struct window *win = W_Void2Window(window);

    XDefineCursor(W_Display, win->window, win->cursor);

    return;
}

void
W_DefineCursor(window, width, height, bits, mask, xhot, yhot)
    W_Window window;
    int     width, height, xhot, yhot;
    char   *bits, *mask;
{
    return;
}

#else

#ifdef YUCK
void
W_DefineTCrossCursor(window)
    W_Window window;
{
    static
    Cursor  new;
    struct window *win = W_Void2Window(window);
    static
    XColor  f, b;

    if (new) {
	XDefineCursor(W_Display, win->window, new);
	return;
    }
    f.pixel = colortable[W_White].pixelValue;
    b.pixel = colortable[W_Black].pixelValue;

    XQueryColor(W_Display, W_Colormap, &f);
    XQueryColor(W_Display, W_Colormap, &b);

    new = XCreateFontCursor(W_Display, XC_tcross);
    XRecolorCursor(W_Display, new, &f, &b);
    XDefineCursor(W_Display, win->window, new);
}

#else
W_DefineTCrossCursor(window)
    W_Window window;
{
    W_DefineCursor(window, cross_width, cross_height,
		   cross_bits, crossmask_bits, cross_x_hot, cross_y_hot);
}

#endif

void
W_DefineTextCursor(window)
    W_Window window;
{
    static
    Cursor  new;
    struct window *win = W_Void2Window(window);
    XColor  f, b;

    if (new) {
	XDefineCursor(W_Display, win->window, new);
	return;
    }
    f.pixel = colortable[W_Yellow].pixelValue;
    b.pixel = colortable[W_Black].pixelValue;

    XQueryColor(W_Display, W_Colormap, &f);
    XQueryColor(W_Display, W_Colormap, &b);

    new = XCreateFontCursor(W_Display, XC_xterm);
    XRecolorCursor(W_Display, new, &f, &b);
    XDefineCursor(W_Display, win->window, new);
}

void
W_DefineCursor(window, width, height, bits, mask, xhot, yhot)
    W_Window window;
    int     width, height, xhot, yhot;
    char   *bits, *mask;
{
    static char *oldbits = NULL;
    static Cursor curs;
    struct window *win;

#ifdef DEBUG
    printf("Defining cursor for %d\n", window);
#endif
    win = W_Void2Window(window);
    if (!oldbits || oldbits != bits) {
	oldbits = bits;
	curs = make_cursor(bits, mask, width, height, xhot, yhot);
    }
    XDefineCursor(W_Display, win->window, curs);
}
#endif
#endif

void
W_Beep()
{
    XBell(W_Display, 0);
}

int
W_WindowWidth(window)
    W_Window window;
{
    return (W_Void2Window(window)->width);
}

int
W_WindowHeight(window)
    W_Window window;
{
    return (W_Void2Window(window)->height);
}

int
W_Socket()
{
    return (ConnectionNumber(W_Display));
}

void
W_DestroyWindow(window)
    W_Window window;
{
    struct window *win;

#ifdef DEBUG
    printf("Destroying %d\n", window);
#endif
    win = W_Void2Window(window);
    deleteWindow(win);
    XDestroyWindow(W_Display, win->window);
    free((char *) win);
}

static void
deleteWindow(window)
    struct window *window;
{
    struct windowlist **rm;
    struct windowlist *temp;

    rm = &hashtable[hash(window->window)];
    while (*rm != NULL && (*rm)->window != window) {
	rm = &((*rm)->next);
    }
    if (*rm == NULL) {
	printf("Attempt to delete non-existent window!\n");
	return;
    }
    temp = *rm;
    *rm = temp->next;
    free((char *) temp);
}

void
W_SetIconWindow(main, icon)
    W_Window main;
    W_Window icon;
{
    XWMHints hints;

    XSetIconName(W_Display, W_Void2Window(icon)->window, W_Void2Window(main)->name);

    hints.flags = IconWindowHint;
    hints.icon_window = W_Void2Window(icon)->window;
    XSetWMHints(W_Display, W_Void2Window(main)->window, &hints);
}

static void
checkGeometry(name, x, y, width, height)
    char   *name;
    int    *x, *y, *width, *height;
/* fixed so that it handles negative positions 12/21/93          */
/* note that this is NOT standard X syntax, but it was requested */
/* and it's how BRM-Hadley works.                       [BDyess] */
{
    char   *adefault;
    char    buf[100];
    char   *s;

#ifdef RJC
    *x = *y = INVALID_POSITION;
#endif				/* RJC */

    sprintf(buf, "%s.geometry", name);
    adefault = getdefault(buf);
    if (adefault == NULL)
	return;
    /* geometry should be of the form 502x885+1+1, 502x885, or +1+1 */
    s = adefault;
    if (*s != '+' && *s != '-') {
	while (*s != 'x' && *s != 0)
	    s++;
	*width = atoi(adefault);
	if (*s == 0)
	    return;
	s++;
	adefault = s;
	while (*s != '+' && *s != '-' && *s != 0)
	    s++;
	*height = atoi(adefault);
	if (*s == 0)
	    return;
    }
    adefault = s;
    s++;
    if (*s == '-')
	s++;			/* for the case where they have wxh+-x+y */
    while (*s != '+' && *s != '-' && *s != 0)
	s++;
    *x = atoi(adefault + 1);
    if (*adefault == '-')
	*x = -*x;
    if (*s == 0)
	return;
    *y = atoi(s + 1);
    if (*s == '-')
	*y = -*y;
    /* printf("width: %d, height: %d, x: %d, y: %d\n",*width, *height,*x,*y); */
    return;
}

static void
checkParent(name, parent)
    char   *name;
    W_Window *parent;
{
    char   *adefault;
    char    buf[100];
    int     i;
    struct windowlist *windows;

    sprintf(buf, "%s.parent", name);
    adefault = getdefault(buf);
    if (adefault == NULL)
	return;
    /* parent must be name of other window or "root" */
    if (strcmpi(adefault, "root") == 0) {
	*parent = W_Window2Void(&myroot);
	return;
    }
    for (i = 0; i < HASHSIZE; i++) {
	windows = hashtable[i];
	while (windows != NULL) {
	    if (strcmpi(adefault, windows->window->name) == 0) {
		*parent = W_Window2Void(windows->window);
		return;
	    }
	    windows = windows->next;
	}
    }
}

#ifdef YUCK
#define cross_width 15
#define cross_height 15
#define cross_x_hot 7
#define cross_y_hot 7
static unsigned char cross_bits[] = {
    0x00, 0x00, 0xc0, 0x01, 0xa0, 0x02, 0x00, 0x00, 0x80, 0x00, 0x04, 0x10, 0x82, 0x20, 0x56,
0x35, 0x82, 0x20, 0x04, 0x10, 0x80, 0x00, 0x00, 0x00, 0xa0, 0x02, 0xc0, 0x01, 0x00, 0x00};
static unsigned char crossmask_bits[] = {
    0xe0, 0x03, 0xf0, 0x07, 0xf0, 0x07, 0xf0, 0x07, 0xce, 0x39, 0xcf, 0x79, 0xff, 0x7f, 0xff,
0x7f, 0xff, 0x7f, 0xcf, 0x79, 0xce, 0x39, 0xf0, 0x07, 0xf0, 0x07, 0xf0, 0x07, 0xe0, 0x03};
#else
#define cross_width 16
#define cross_height 16
#define cross_x_hot 7
#define cross_y_hot 7
static unsigned char cross_bits[] = {
    0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0xc0, 0x01, 0x80, 0x00,
    0x10, 0x04, 0x3f, 0x7e, 0x10, 0x04, 0x80, 0x00, 0xc0, 0x01, 0x80, 0x00,
0x80, 0x00, 0x80, 0x00, 0x80, 0x00, 0x00, 0x00};
static unsigned char crossmask_bits[] = {
    0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xe0, 0x03, 0xd0, 0x05,
    0xbf, 0x7e, 0x7f, 0x7f, 0xbf, 0x7e, 0xd0, 0x05, 0xe0, 0x03, 0xc0, 0x01,
0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0x00, 0x00};
#endif

static void
checkCursor(name, cursname, cursor)
    char   *name;
    char   *cursname;
    Cursor *cursor;
{
    char    buf[100];
    unsigned cnum;
    char   *adefault;

    *cursor = 0;

    sprintf(buf, "%s.cursor", name);
    adefault = getdefault(buf);
    if (adefault == NULL)
	adefault = cursname;
    if (adefault == NULL)
	return;

#ifdef RFCURSORS
    cnum = XmuCursorNameToIndex(adefault);
    if (cnum != -1) {
	XColor  f, b;
	*cursor = XCreateFontCursor(W_Display, cnum);
	if (cnum == XC_xterm) {

	    f.pixel = colortable[W_Yellow].pixelValue;
	    b.pixel = colortable[W_Black].pixelValue;

	    XQueryColor(W_Display, W_Colormap, &f);
	    XQueryColor(W_Display, W_Colormap, &b);

	    XRecolorCursor(W_Display, *cursor, &f, &b);
	} else if (cnum == XC_pirate) {
	    f.pixel = colortable[W_Red].pixelValue;
	    b.pixel = colortable[W_Black].pixelValue;

	    XQueryColor(W_Display, W_Colormap, &f);
	    XQueryColor(W_Display, W_Colormap, &b);

	    XRecolorCursor(W_Display, *cursor, &f, &b);
	}
    } else
#endif
    if (0 == strcmp("bomb here", adefault)) {
	static Cursor bomb_here = 0;
	if (bomb_here == 0) {
	    bomb_here = make_cursor(cross_bits, crossmask_bits,
				    cross_width, cross_height,
				    cross_x_hot, cross_y_hot);
	}
	*cursor = bomb_here;
    }
}

int
checkMapped(name)
    char   *name;
{
    char    buf[100];

    sprintf(buf, "%s.mapped", name);
    return (booleanDefault(buf, 0));
}

void
W_WarpPointer(window, x, y)
    W_Window window;
    int     x, y;
{
    static int warped_from_x = 0, warped_from_y = 0;

    if (window == NULL) {
	if (W_in_message) {
	    XWarpPointer(W_Display, None, W_Root, 0, 0, 0, 0, warped_from_x, warped_from_y);
	    W_in_message = 0;
	}
    } else {
	findMouse(&warped_from_x, &warped_from_y);
	XWarpPointer(W_Display, None, W_Void2Window(window)->window, 0, 0, 0, 0, 0, 0);
	W_in_message = 1;
    }
}

static void
findMouse(x, y)
    int    *x, *y;
{
    Window  theRoot, theChild;
    int     wX, wY, rootX, rootY, status;
    unsigned int wButtons;

    status = XQueryPointer(W_Display, W_Root, &theRoot, &theChild, &rootX, &rootY, &wX, &wY, &wButtons);
    if (status == True) {
	*x = wX;
	*y = wY;
    } else {
	*x = 0;
	*y = 0;
    }
}

int
findMouseInWin(x, y, w)
    int    *x, *y;
    W_Window w;
{
    Window  theRoot, theChild;
    int     wX, wY, rootX, rootY, status;
    unsigned int wButtons;
    struct window *win = W_Void2Window(w);
    Window  thisWin = win->window;

    status = XQueryPointer(W_Display, thisWin, &theRoot, &theChild,
			   &rootX, &rootY, &wX, &wY, &wButtons);
    if (status == True) {
	/*
	   if it's in the window we specified then the values returned should
	   be within the with and height of the window
	*/
	if (wX <= win->width && wY <= win->height) {
	    *x = wX;
	    *y = wY;
	    return 1;
	}
    }
    *x = 0;
    *y = 0;
    return 0;
}

#ifdef AUTOKEY
static void
W_Flush()
{
    XFlush(W_Display);
}

W_AutoRepeatOff()
{
    XAutoRepeatOff(W_Display);
    W_Flush();
}

W_AutoRepeatOn()
{
    XAutoRepeatOn(W_Display);
    W_Flush();
}
#endif				/* AUTOKEY */

/* find the width of a font */
int
W_StringWidth(string, font)
    char    string[];
    W_Font  font;
{
    int     x, y;

    y = strlen(string);
    x = XTextWidth(fonts[fontNum(font)].fontstruct, string, y);
    return (x);			/* just a guess ?? old never returned! WHS
				   4/6/93 */
}

void
W_TranslatePoints(w, x, y)
    int    *x, *y;
    W_Window w;
{
    struct window *win;
    win = W_Void2Window(w);

    if (win->type == WIN_TEXT) {
	*y = (*y - MENU_PAD) / W_Textheight;
	*x = (*x - MENU_PAD) / W_Textwidth;
    }
    return;
}

#if 0
#define MAKE_WINDOW_GETTER(name, part) \
  W_Callback name(w) \
       W_Window w; \
 { \
     return W_Void2Window(w)->part; \
 }

#define MAKE_WINDOW_SETTER(name, port) \
   W_Callback name(w, c) \
      W_Window w; \
      W_Callback c; \
   { \
      W_Void2Window(w)->port = c; \
   }

MAKE_WINDOW_GETTER(W_GetWindowKeyDownHandler, handle_keydown);
MAKE_WINDOW_SETTER(W_SetWindowKeyDownHandler, handle_keydown);

MAKE_WINDOW_GETTER(W_GetWindowKeyUpHandler, handle_keyup);
MAKE_WINDOW_SETTER(W_SetWindowKeyUpHandler, handle_keyup);

MAKE_WINDOW_GETTER(W_GetWindowButtonHandler, handle_button);
MAKE_WINDOW_SETTER(W_SetWindowButtonHandler, handle_button);

MAKE_WINDOW_GETTER(W_GetWindowExposeHandler, handle_expose);
MAKE_WINDOW_SETTER(W_SetWindowExposeHandler, handle_expose);
#endif				/* 0 */

void
W_ResizeWindow(window, neww, newh)	/* TSH 2/93 */
    W_Window window;
    int     neww, newh;
{
    Window  win = W_Void2Window(window)->window;

    XResizeWindow(W_Display, win, (unsigned int) neww, (unsigned int) newh);
}

void
W_ResizeMenu(window, neww, newh)/* TSH 2/93 */
    W_Window window;
    int     neww, newh;
{
    W_ResizeWindow(window, neww * W_Textwidth + WIN_EDGE * 2,
	      newh * (W_Textheight + MENU_PAD * 2) + (newh - 1) * MENU_BAR);
}

void
W_ResizeText(window, neww, newh)/* TSH 2/93 */
    W_Window window;
    int     neww, newh;
{
    W_ResizeWindow(window, neww * W_Textwidth + WIN_EDGE * 2,
		   newh * W_Textheight + MENU_PAD * 2);
}

void
W_Deiconify(window)
    W_Window window;
{
    struct window *win;
    win = W_Void2Window(window);
    /* according to ICCCM 4.1.4, this is how you deiconify a window. */
    XMapWindow(W_Display, win->window);
}

W_Icon
W_MakeShieldBitmap(width, height, window)
    int     width, height;
    W_Window window;
{
    static GC pen = 0;
    struct window *win;
    struct icon *newicon;

    win = W_Void2Window(window);

    newicon = (struct icon *) malloc(sizeof(struct icon));
    newicon->width = width;
    newicon->height = height;
    newicon->bitmap = XCreatePixmap(W_Display, win->window, width, height, 1);
    newicon->window = win->window;
    newicon->pixmap = 0;

    pen = XCreateGC(W_Display, newicon->bitmap, 0L, 0);
    XSetForeground(W_Display, pen, 0L);
    XFillRectangle(W_Display, newicon->bitmap, pen, 0, 0, width, height);
    XSetForeground(W_Display, pen, 1L);
    XDrawArc(W_Display, newicon->bitmap, pen, 0, 0, width - 1, height - 1, 0, 360 * 64);
    XFreeGC(W_Display, pen);

    return W_Icon2Void(newicon);
}

#ifdef BEEPLITE
void 
W_OverlayBitmap(x, y, bit, color)
    int     x, y;
    W_Icon  bit;
    W_Color color;
{
    struct icon *icon = W_Void2Icon(bit);
#ifdef DEBUG
    printf("Overlaying bitmap to %d\n", icon->window);
#endif
    XCopyPlane(W_Display, icon->bitmap, icon->window,
	     colortable[color].contexts[0], 0, 0, icon->width, icon->height,
	       x, y, 1);
}
#endif