/*
 * Copyright (c) 1999, 2000, 2001, 2002, 2003 Greg Haerr <greg@censoft.com>
 * Portions Copyright (c) 2002 by Koninklijke Philips Electronics N.V.
 * Copyright (c) 2000 Alex Holden <alex@linuxhacker.org>
 * Copyright (c) 1991 David I. Bell
 */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MWINCLUDECOLORS
#include "serv.h"

static int	nextid = GR_ROOT_WINDOW_ID + 1;

static void CheckNextEvent(GR_EVENT *ep, GR_BOOL doCheckEvent);
 
/*
 * Return information about the screen for clients to use.
 */
void 
GrGetScreenInfo(GR_SCREEN_INFO *sip)
{
	SERVER_LOCK();

	GdGetScreenInfo(rootwp->psd, sip);

	/* set virtual screen sizing (for PDA emulation on desktop)*/
	sip->vs_width = nxres? nxres: sip->cols;
	sip->vs_height = nyres? nyres: sip->rows;

	/* set workspace equal to virtual screen area minus 22 pixel taskbar*/
	sip->ws_width = sip->vs_width;
	sip->ws_height = sip->vs_height - 22;

	SERVER_UNLOCK();
}

/*
 * Return the size of a text string for the font in a graphics context.
 * This is the width of the string, the height of the string,
 * and the height above the bottom of the font of the baseline for the font.
 */
void 
GrGetGCTextSize(GR_GC_ID gc, void *str, int count, GR_TEXTFLAGS flags,
	GR_SIZE *retwidth, GR_SIZE *retheight, GR_SIZE *retbase)
{
	GR_GC		*gcp;
	GR_FONT		*fontp;
	PMWFONT		pf;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp == NULL)
		fontp = NULL;
	else
		fontp = GsFindFont(gcp->fontid);
	pf = fontp? fontp->pfont: stdfont;
	GdGetTextSize(pf, str, count, retwidth, retheight, retbase, flags);

	SERVER_UNLOCK();
}

#if NONETWORK
/*
 * Return the next waiting event for a client, or wait for one if there
 * is none yet.  The event is copied into the specified structure, and
 * then is moved from the event queue to the free event queue.  If there
 * is an error event waiting, it is delivered before any other events.
 */
void
GrGetNextEvent(GR_EVENT *ep)
{
	GrGetNextEventTimeout(ep, 0L);
}

/*
 * Return the next event from the event queue, or
 * wait for a new one if one is not ready.  If timeout
 * is nonzero, return timeout event if time elapsed.
 */
void
GrGetNextEventTimeout(GR_EVENT *ep, GR_TIMEOUT timeout)
{
	SERVER_LOCK();
	/* If no event ready, wait for one*/
	/* Note: won't work for multiple clients*/
	/* This is OK, since only static linked apps call this function*/
	while(curclient->eventhead == NULL)
		GsSelect(timeout);
	CheckNextEvent(ep, GR_FALSE);
	SERVER_UNLOCK();
}

/*
 * Wait until an event is available for a client, and then peek at it.
 */
void
GrPeekWaitEvent(GR_EVENT *ep)
{
	SERVER_LOCK();
	while(curclient->eventhead == NULL)
		GsSelect(0L);
	GrPeekEvent(ep);
	SERVER_UNLOCK();
}

/*
 * Return the current length of the input queue.
 */
int 
GrQueueLength(void)
{
	int count = 0;
	GR_EVENT_LIST *elp;

	SERVER_LOCK();
	for (elp=curclient->eventhead; elp; elp=elp->next)
		++count;
	SERVER_UNLOCK();
	return count;
}

/* builtin callback function for GrGetTypedEvent*/
static GR_BOOL
GetTypedEventCallback(GR_WINDOW_ID wid, GR_EVENT_MASK mask, GR_UPDATE_TYPE update,
	GR_EVENT *ep, void *arg)
{
	GR_EVENT_MASK	emask = GR_EVENTMASK(ep->type);

DPRINTF("GetTypedEventCallback: wid %d mask %x update %d from %d type %d\n", wid, (unsigned)mask, update, ep->general.wid, ep->type);

	/* FIXME: not all events have wid field here... */
	if (wid && (wid != ep->general.wid))
		return 0;

	if (mask) {
		if ((mask & emask) == 0)
			return 0;

		if (update && ((mask & emask) == GR_EVENT_MASK_UPDATE))
			if (update != ep->update.utype)
				return 0;
	}

	return 1;
}

/*
 * Fills in the specified event structure with a copy of the next event on the
 * queue that matches the type parameters passed and removes it from the queue.
 * If block is GR_TRUE, the call will block until a matching event is found.
 * Otherwise, only the local queue is searched, and an event type of
 * GR_EVENT_TYPE_NONE is returned if the a match is not found.
 */
int
GrGetTypedEvent(GR_WINDOW_ID wid, GR_EVENT_MASK mask, GR_UPDATE_TYPE update,
	GR_EVENT *ep, GR_BOOL block)
{
	return GrGetTypedEventPred(wid, mask, update, ep, block,
		GetTypedEventCallback, NULL);
}

/*
 * The specified callback function is called with the passed event type parameters
 * for each event on the queue, until the callback function CheckFunction
 * returns GR_TRUE.  The event is then removed from the queue and returned.
 * If block is GR_TRUE, the call will block until a matching event is found.
 * Otherwise, only the local queue is searched, and an event type of
 * GR_EVENT_TYPE_NONE is returned if a match is not found.
 */
int
GrGetTypedEventPred(GR_WINDOW_ID wid, GR_EVENT_MASK mask, GR_UPDATE_TYPE update,
	GR_EVENT *ep, GR_BOOL block, GR_TYPED_EVENT_CALLBACK matchfn, void *arg)
{
	GR_EVENT_LIST *elp, *prevelp;

	SERVER_LOCK();
	/* determine if we need to wait for any events*/
	while(curclient->eventhead == NULL) {
getevent:
		GsSelect(block? 0L: -1L); /* wait/poll for event*/
		if (!block)
			break;
	}

	/* Now, run through the event queue, looking for matches of the type
	 * info that was passed.
	 */
	prevelp = NULL;
	elp = curclient->eventhead;
	while (elp) {
		if (matchfn(wid, mask, update, &elp->event, arg)) {
			/* remove event from queue, return it*/
			if (prevelp == NULL)
				curclient->eventhead = elp->next;
			else prevelp->next = elp->next;
			if (curclient->eventtail == elp)
				curclient->eventtail = NULL;
			elp->next = eventfree;
			eventfree = elp;

			*ep = elp->event;
			SERVER_UNLOCK();
			return ep->type;
		}
		prevelp = elp;
		elp = elp->next;
	}

	/* if event still not found and waiting ok, then wait*/
	if (block)
		goto getevent;

	/* return no event*/
	ep->type = GR_EVENT_TYPE_NONE;
	SERVER_UNLOCK();
	return GR_EVENT_TYPE_NONE;
} 
#endif /* NONETWORK*/

/*
 * Return the next event from the event queue if one is ready.
 * If one is not ready, then the type GR_EVENT_TYPE_NONE is returned.
 * If it is an error event, then a user-specified routine is called
 * if it was defined, otherwise we clean up and exit.
 */
void
GrCheckNextEvent(GR_EVENT *ep)
{
	SERVER_LOCK();
	CheckNextEvent(ep, GR_TRUE);
	SERVER_UNLOCK();
}

static void
CheckNextEvent(GR_EVENT *ep, GR_BOOL doCheckEvent)
{
	GR_EVENT_LIST *	elp;

#if 0 /* was NONETWORK*/
	/* NOTE: select() now called through GrPeekEvent when bound to server*/
	if (doCheckEvent)
		GsSelect(1L);
#endif
	/* Copy first event if any*/
	if(!GrPeekEvent(ep))
		return;

	/* Get first event again*/
	elp = curclient->eventhead;

#if NONETWORK
	/* if GrCheckEvent, turn timeouts into no event*/
	if (doCheckEvent && elp->event.type == GR_EVENT_TYPE_TIMEOUT)
		ep->type = GR_EVENT_TYPE_NONE;
#endif

	/* Remove first event from queue*/
	curclient->eventhead = elp->next;
	if (curclient->eventtail == elp)
		curclient->eventtail = NULL;

	elp->next = eventfree;
	eventfree = elp;
}

/*
 * Peek at the event queue for the current client to see if there are any
 * outstanding events.  Returns the event at the head of the queue, or
 * else a null event type.  The event is still left in the queue, however.
 */
int
GrPeekEvent(GR_EVENT *ep)
{
	GR_EVENT_LIST *	elp;

	SERVER_LOCK();
	elp = curclient->eventhead;
#if NONETWORK
	/* if no events on queue, force select() event check*/
	if (elp == NULL) {
		GsSelect(-1L);	/* poll*/
		elp = curclient->eventhead;
	}
#endif
	if(elp == NULL) {
		ep->type = GR_EVENT_TYPE_NONE;
		SERVER_UNLOCK();
		return 0;
	}

	/* copy event out*/
	*ep = elp->event;

	SERVER_UNLOCK();
	return 1;
}

/*
 * Return information about a window id.
 */
void
GrGetWindowInfo(GR_WINDOW_ID wid, GR_WINDOW_INFO *infoptr)
{
	GR_WINDOW	*wp;		/* window structure */
	GR_PIXMAP	*pp;
	GR_EVENT_CLIENT	*evp;		/* event-client structure */

	SERVER_LOCK();

	/* first check window list*/
	wp = GsFindWindow(wid);
	if (wp) {
		infoptr->wid = wid;
		/* report parent-relative x,y coordinates*/
		infoptr->x = wp->x - (wp->parent ? wp->parent->x : 0);
		infoptr->y = wp->y - (wp->parent ? wp->parent->y : 0);
		infoptr->width = wp->width;
		infoptr->height = wp->height;
		infoptr->parent = wp->parent? wp->parent->id: 0;
		infoptr->child = wp->children? wp->children->id: 0;
		infoptr->sibling = wp->siblings? wp->siblings->id: 0;
		infoptr->mapped = wp->mapped;
		infoptr->realized = wp->realized;
		infoptr->inputonly = !wp->output;
		infoptr->bordersize = wp->bordersize;
		infoptr->bordercolor = wp->bordercolor;
		infoptr->background = wp->background;
		infoptr->props = wp->props;
		infoptr->cursor = wp->cursorid;
		infoptr->processid = wp->owner? wp->owner->processid: 0;
		infoptr->eventmask = 0;

		for (evp = wp->eventclients; evp; evp = evp->next) {
			if (evp->client == curclient)
				infoptr->eventmask = evp->eventmask;
		}
		SERVER_UNLOCK();
		return;
	}

	/* then pixmap list*/
	pp = GsFindPixmap(wid);
	if (pp) {
		infoptr->wid = wid;
		infoptr->x = pp->x;
		infoptr->y = pp->y;
		infoptr->width = pp->width;
		infoptr->height = pp->height;
		infoptr->parent = 0;
		infoptr->child = 0;
		infoptr->sibling = 0;
		infoptr->mapped = GR_FALSE;
		infoptr->realized = GR_TRUE;
		infoptr->inputonly = GR_FALSE;
		infoptr->bordersize = 0;
		infoptr->bordercolor = 0;
		infoptr->background = 0;
		infoptr->eventmask = 0;
		infoptr->cursor = 0;
		infoptr->processid = pp->owner? pp->owner->processid: 0;
		SERVER_UNLOCK();
		return;
	}

	/* No error if window id is invalid.*/
	memset(infoptr, 0, sizeof(GR_WINDOW_INFO));
	SERVER_UNLOCK();
}

/*
 * Destroy an existing window and all of its children.
 * Also used to destroy a pixmap.
 */
void
GrDestroyWindow(GR_WINDOW_ID wid)
{
	GR_WINDOW	*wp;		/* window structure */
	GR_PIXMAP	*pp;
	GR_PIXMAP	*prevpp;
	PSD		psd;

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if (wp) {
		GsWpDestroyWindow(wp);
	} else {
		pp = GsFindPixmap(wid);
		if (pp) {
			psd = pp->psd;
			/* deallocate pixmap memory*/
			if (psd->flags & PSF_ADDRMALLOC)
				free(psd->addr);

			/* deallocate mem gc*/
			psd->FreeMemGC(psd);

			/*
			 * Remove this pixmap from the complete list of pixmaps.
			 */
			prevpp = listpp;
			if (prevpp == pp)
				listpp = pp->next;
			else {
				while (prevpp->next != pp)
					prevpp = prevpp->next;
				prevpp->next = pp->next;
			}

			/*
			 * Forget various information if they related to this
			 * pixmap.  Then finally free the structure.
			 */
			if (pp == cachepp) {
				cachepixmapid = 0;
				cachepp = NULL;
			}
			free(pp);
		}
	}

	SERVER_UNLOCK();
}


/*
 * Raise a window to the highest level among its siblings.
 */
void
GrRaiseWindow(GR_WINDOW_ID wid)
{
	GR_WINDOW	*wp;		/* window structure */
	GR_WINDOW	*prevwp;	/* previous window pointer */
	GR_BOOL		overlap;	/* TRUE if there was overlap */

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if ((wp == NULL) || (wp == rootwp)) {
		SERVER_UNLOCK();
		return;
	}

	/*
	 * If this is already the highest window then we are done.
	 */
	prevwp = wp->parent->children;
	if (prevwp == wp) {
		SERVER_UNLOCK();
		return;
	}

	/*
	 * Find the sibling just before this window so we can unlink it.
	 * Also, determine if any sibling ahead of us overlaps the window.
	 * Remember that for exposure events.
	 */
	overlap = GR_FALSE;
	while (prevwp->siblings != wp) {
		overlap |= GsCheckOverlap(prevwp, wp);
		prevwp = prevwp->siblings;
	}
	overlap |= GsCheckOverlap(prevwp, wp);

	/*
	 * Now unlink the window and relink it in at the front of the
	 * sibling chain.
	 */
	prevwp->siblings = wp->siblings;
	wp->siblings = wp->parent->children;
	wp->parent->children = wp;

	/*
	 * Finally redraw the window if necessary.
	 */
	if (overlap) {
		GsDrawBorder(wp);
		GsExposeArea(wp, wp->x, wp->y, wp->width, wp->height, NULL);
	}

	SERVER_UNLOCK();
}

/*
 * Lower a window to the lowest level among its siblings.
 */
void
GrLowerWindow(GR_WINDOW_ID wid)
{
	GR_WINDOW	*wp;		/* window structure */
	GR_WINDOW	*prevwp;	/* previous window pointer */
	GR_WINDOW	*sibwp;		/* sibling window */
	GR_WINDOW	*expwp;		/* siblings being exposed */

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if ((wp == NULL) || (wp == rootwp)) {
		SERVER_UNLOCK();
		return;
	}
	if (wp->siblings == NULL) {
		SERVER_UNLOCK();
		return;
	}

	/*
	 * Find the sibling just before this window so we can unlink us.
	 */
	prevwp = wp->parent->children;
	if (prevwp != wp) {
		while (prevwp->siblings != wp)
			prevwp = prevwp->siblings;
	}

	/*
	 * Remember the first sibling that is after us, so we can
	 * generate exposure events for the remaining siblings.  Then
	 * walk down the sibling chain looking for the last sibling.
	 */
	expwp = wp->siblings;
	sibwp = wp;
	while (sibwp->siblings)
		sibwp = sibwp->siblings;

	/*
	 * Now unlink the window and relink it in at the end of the
	 * sibling chain.
	 */
	if (prevwp == wp)
		wp->parent->children = wp->siblings;
	else
		prevwp->siblings = wp->siblings;
	sibwp->siblings = wp;

	wp->siblings = NULL;

	/*
	 * Finally redraw the sibling windows which this window covered
	 * if they overlapped our window.
	 */
	while (expwp && (expwp != wp)) {
		if (GsCheckOverlap(wp, expwp)) {
			GsExposeArea(expwp, wp->x - wp->bordersize,
				wp->y - wp->bordersize,
				wp->width + wp->bordersize * 2,
				wp->height + wp->bordersize * 2, NULL);
		}
		expwp = expwp->siblings;
	}

	SERVER_UNLOCK();
}

/* Offset a window position and all children by offx,offy*/
static void
OffsetWindow(GR_WINDOW *wp, GR_COORD offx, GR_COORD offy)
{
	GR_WINDOW	*cp;

	wp->x += offx;
	wp->y += offy;
	for(cp=wp->children; cp; cp=cp->siblings)
		OffsetWindow(cp, offx, offy);
}

/* deliver an update move event to window and all children*/
static void
DeliverUpdateMoveEventAndChildren(GR_WINDOW *wp)
{
	GR_WINDOW *	childwp;

	GsDeliverUpdateEvent(wp, GR_UPDATE_MOVE, wp->x, wp->y,
		wp->width, wp->height);

	for (childwp = wp->children; childwp; childwp = childwp->siblings)
		DeliverUpdateMoveEventAndChildren(childwp);
}

/*
 * Move the window to the specified position relative to its parent.
 */
void
GrMoveWindow(GR_WINDOW_ID wid, GR_COORD x, GR_COORD y)
{
	GR_WINDOW	*wp;		/* window structure */
	GR_COORD	offx, offy;

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if (wp == NULL) {
		SERVER_UNLOCK();
		return;
	}
	if (wp == rootwp) {
		GsError(GR_ERROR_ILLEGAL_ON_ROOT_WINDOW, wid);
		SERVER_UNLOCK();
		return;
	}

	x += wp->parent->x;
	y += wp->parent->y;
	offx = x - wp->x;
	offy = y - wp->y;

	if (wp->x == x && wp->y == y) {
		SERVER_UNLOCK();
		return;
	}

	/* * move algorithms not requiring unmap/map ***/
#if 1
	/* perform screen blit if topmost and mapped - no flicker!*/
	if (wp->mapped && wp == wp->parent->children
		&& wp->parent->id == GR_ROOT_WINDOW_ID

		/* temp don't blit in portrait mode, still buggy*/
		/* *&& !(wp->psd->portrait & (MWPORTRAIT_LEFT|MWPORTRAIT_RIGHT))***/

		/* don't blit if window has custom frame, background not right*/
		&& !wp->clipregion
	   ) {
		int 		oldx = wp->x;
		int 		oldy = wp->y;
		GR_WINDOW_ID 	pixid = GrNewPixmap(wp->width, wp->height,NULL);
		GR_GC_ID	gc = GrNewGC();
		GR_WINDOW * 	stopwp = wp;
		int		X, Y, W, H;

		/* must hide cursor first or GdFixCursor() will show it*/
		GdHideCursor(rootwp->psd);

		/* turn off clipping of root's children*/
		GrSetGCMode(gc, GR_MODE_COPY|GR_MODE_EXCLUDECHILDREN);

		/* copy topmost window contents offscreen*/
		GrCopyArea(pixid, gc, 0, 0, wp->width, wp->height,
			GR_ROOT_WINDOW_ID, oldx, oldy, MWROP_COPY);

		/* calc new window offsets*/
		OffsetWindow(wp, offx, offy);

		/* force recalc of clip region*/
		clipwp = NULL;

		/* copy window bits to new location*/
		GrCopyArea(GR_ROOT_WINDOW_ID, gc, wp->x, wp->y, wp->width,
			wp->height, pixid, 0, 0, MWROP_COPY);

		/*
		 * If any portion of the window was offscreen
		 * and is coming onscreen, must send expose events
		 * to this window as well.
		 */
		if ((oldx < 0 && wp->x > oldx) ||
		    (oldy < 0 && wp->y > oldy) ||
		    (oldx+wp->width > rootwp->width && wp->x < oldx) ||
		    (oldy+wp->height > rootwp->height && wp->y < oldy))
			stopwp = NULL;

		/* 
		 * Calculate bounded exposed area and
		 * redraw anything lower than stopwp window.
		 */
		X = MWMIN(oldx, wp->x);
		Y = MWMIN(oldy, wp->y);
		W = MWMAX(oldx, wp->x) + wp->width - X;
		H = MWMAX(oldy, wp->y) + wp->height - Y;
		GsExposeArea(rootwp, X, Y, W, H, stopwp);

		GdShowCursor(rootwp->psd);
		GrDestroyGC(gc);
		GrDestroyWindow(pixid);
		DeliverUpdateMoveEventAndChildren(wp);
		SERVER_UNLOCK();
		return;
	}
#endif
#if 0
	/* perform quick move and expose if topmost and mapped - no blit*/
	if (wp->mapped && wp == wp->parent->children) {
		int	oldx = wp->x;
		int	oldy = wp->y;
		int	X, Y, W, H;

		OffsetWindow(wp, offx, offy);

		/* force recalc of clip region*/
		clipwp = NULL;

		X = MWMIN(oldx, wp->x);
		Y = MWMIN(oldy, wp->y);
		W = MWMAX(oldx, wp->x) + wp->width - X;
		H = MWMAX(oldy, wp->y) + wp->height - Y;
		GsExposeArea(rootwp, X, Y, W, H, NULL);
		DeliverUpdateMoveEventAndChildren(wp);
		SERVER_UNLOCK();
		return;
	}
#endif
	/*
	 * This method will redraw the window entirely,
	 * resulting in considerable flicker.
	 */
	GsWpUnrealizeWindow(wp, GR_TRUE);
	OffsetWindow(wp, offx, offy);
	GsWpRealizeWindow(wp, GR_FALSE);
	DeliverUpdateMoveEventAndChildren(wp);

	SERVER_UNLOCK();
	return;
}

/*
 * Resize the window to be the specified size.
 */
void
GrResizeWindow(GR_WINDOW_ID wid, GR_SIZE width, GR_SIZE height)
{
	GR_WINDOW	*wp;		/* window structure */

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if (wp == NULL) {
		SERVER_UNLOCK();
		return;
	}
	if (wp == rootwp) {
		GsError(GR_ERROR_ILLEGAL_ON_ROOT_WINDOW, wid);
		SERVER_UNLOCK();
		return;
	}
	if ((width <= 0) || (height <= 0)) {
		GsError(GR_ERROR_BAD_WINDOW_SIZE, wid);
		SERVER_UNLOCK();
		return;
	}

	if ((wp->width == width) && (wp->height == height)) {
		SERVER_UNLOCK();
		return;
	}

	if (!wp->realized || !wp->output) {
		wp->width = width;
		wp->height = height;
		SERVER_UNLOCK();
		return;
	}

	/*
	 * This should be optimized to not require redrawing of the window
	 * when possible.
	 */
	GsWpUnrealizeWindow(wp, GR_TRUE);
	wp->width = width;
	wp->height = height;
	/* send size update before expose event*/
	GsDeliverUpdateEvent(wp, GR_UPDATE_SIZE, wp->x, wp->y, width, height);
	GsWpRealizeWindow(wp, GR_FALSE);

	SERVER_UNLOCK();
}

/*
 * Reparent window to new parent, position at passed x, y
 */
void
GrReparentWindow(GR_WINDOW_ID wid, GR_WINDOW_ID pwid, GR_COORD x, GR_COORD y)
{
	GR_WINDOW	*wp;		/* window structure */
	GR_WINDOW	*pwp;		/* parent window structure */
	GR_WINDOW	**mysibptr;	/* handle to my sibling ptr */
	GR_COORD	offx, offy;

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	pwp = GsFindWindow(pwid);
	if (!wp || !pwp || wp == pwp) {
		SERVER_UNLOCK();
		return;
	}
	if (wp == rootwp) {
		GsError(GR_ERROR_ILLEGAL_ON_ROOT_WINDOW, wid);
		SERVER_UNLOCK();
		return;
	}

/*printf("grreparent: pid %d wid %d (oldpid %d) realized %d,%d\n", pwid, wid, wp->parent->id, pwp->realized, wp->realized);*/
	x += pwp->x;
	y += pwp->y;
	offx = x - wp->x;
	offy = y - wp->y;

	/* 
	 * Unrealize window and all children.  No effect if
	 * this window isn't already realized.
	 */
	GsWpUnrealizeWindow(wp, GR_TRUE);

	/* link window into new parent chain*/
	for(mysibptr = &(wp->parent->children); *mysibptr != wp; 
		mysibptr = &((*mysibptr)->siblings))
			continue;

	*mysibptr = wp->siblings;
	wp->parent = pwp;
	wp->siblings = pwp->children;
	pwp->children = wp;

	if (offx || offy)
		OffsetWindow(wp, offx, offy);

	/*
	 * Realize window again. Window will become visible if
	 * the parent window is realized and this window is mapped.
	 *
	 * Temp flag is set TRUE, no additional
	 * UPDATE_MAP will be sent.
	 */
	GsWpRealizeWindow(wp, GR_TRUE);

	/* send reparent update event*/
	GsDeliverUpdateEvent(wp, GR_UPDATE_REPARENT, wp->x, wp->y, wp->width, wp->height);

	SERVER_UNLOCK();
}

static int nextgcid = 1000;
/*
 * Allocate a new GC with default parameters.
 * The GC is owned by the current client.
 */
GR_GC_ID 
GrNewGC(void)
{
	GR_GC	*gcp;

	SERVER_LOCK();

	gcp = (GR_GC *) malloc(sizeof(GR_GC));
	if (gcp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}

	gcp->id = nextgcid++;
	gcp->mode = GR_MODE_COPY;
	gcp->regionid = 0;	/* no region*/
	gcp->xoff = 0;		/* no offset*/
	gcp->yoff = 0;
	gcp->fontid = 0;	/* 0 is default font*/
	gcp->foreground = WHITE;
	gcp->background = BLACK;
	gcp->fgispixelval = GR_FALSE;
	gcp->bgispixelval = GR_FALSE;
	gcp->usebackground = GR_TRUE;

	gcp->exposure = GR_TRUE;

	gcp->linestyle = GR_LINE_SOLID;
	gcp->fillmode = GR_FILL_SOLID;

	gcp->dashcount = 0;
	gcp->dashmask = 0;

	gcp->stipple.bitmap = NULL;
	gcp->stipple.width = 0;
	gcp->stipple.height = 0;
	
	gcp->tile.psd = NULL;
	gcp->tile.width = 0;
	gcp->tile.height = 0;
	
	gcp->ts_offset.x = 0;
	gcp->ts_offset.y = 0;

	gcp->changed = GR_TRUE;
	gcp->owner = curclient;
	gcp->next = listgcp;

	listgcp = gcp;

	SERVER_UNLOCK();

	return gcp->id;
}

/*
 * Destroy an existing graphics context.
 */
void
GrDestroyGC(GR_GC_ID gc)
{
	GR_GC		*gcp;		/* graphics context */
	GR_GC		*prevgcp;	/* previous graphics context */

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp == NULL) {
		SERVER_UNLOCK();
		return;
	}

	if (gc == cachegcid) {
		cachegcid = 0;
		cachegcp = NULL;
	}
	if (gcp == curgcp)
		curgcp = NULL;

	if (listgcp == gcp)
		listgcp = gcp->next;
	else {
		prevgcp = listgcp;
		while (prevgcp->next != gcp)
			prevgcp = prevgcp->next;

		prevgcp->next = gcp->next;
	}

	if (gcp->stipple.bitmap)
		free(gcp->stipple.bitmap);
	free(gcp);

	SERVER_UNLOCK();
}

/*
 * Allocate a new GC which is a copy of another one.
 * The GC is owned by the current client.
 */
GR_GC_ID 
GrCopyGC(GR_GC_ID gc)
{
	GR_GC		*oldgcp;	/* old graphics context */
	GR_GC		*gcp;		/* new graphics context */
	GR_GC_ID id;

	SERVER_LOCK();

	oldgcp = GsFindGC(gc);
	if (oldgcp == NULL) {
		SERVER_UNLOCK();
		return 0;
	}

	gcp = (GR_GC *) malloc(sizeof(GR_GC));
	if (gcp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}

	/*
	 * Copy all the old gcp values into the new one, except allocate
	 * a new id for it and link it into the list of GCs.
	 */
	*gcp = *oldgcp;
	gcp->id = nextgcid++;
	id = gcp->id;
	gcp->changed = GR_TRUE;
	gcp->owner = curclient;
	gcp->next = listgcp;
	listgcp = gcp;

	SERVER_UNLOCK();

	return id;
}

/*
 * Return information about the specified graphics context.
 */
void 
GrGetGCInfo(GR_GC_ID gc, GR_GC_INFO *gcip)
{
	GR_GC		*gcp;

	SERVER_LOCK();

	/*
	 * Find the GC manually so that an error is not generated.
	 */
	for (gcp = listgcp; gcp && (gcp->id != gc); gcp = gcp->next)
		continue;

	if (gcp == NULL) {
		memset(gcip, 0, sizeof(GR_GC_INFO));
		SERVER_UNLOCK();
		return;
	}

	gcip->gcid = gc;
	gcip->mode = gcp->mode;
	gcip->region = gcp->regionid;
	gcip->xoff = gcp->xoff;
	gcip->yoff = gcp->yoff;
	gcip->font = gcp->fontid;
	gcip->foreground = gcp->foreground;
	gcip->background = gcp->background;
	gcip->fgispixelval = gcp->fgispixelval;
	gcip->bgispixelval = gcp->bgispixelval;
	gcip->usebackground = gcp->usebackground;
	gcip->exposure = gcp->exposure;

	SERVER_UNLOCK();
}

static int nextregionid = 1000;
/*
 * Allocate a new REGION with default parameters.
 * The REGION is owned by the current client.
 */
GR_REGION_ID
GrNewRegion(void)
{
	GR_REGION *regionp;
	GR_REGION_ID id;

	SERVER_LOCK();
           
	regionp = (GR_REGION *) malloc(sizeof(GR_REGION));
	if (regionp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}
	
	regionp->rgn = GdAllocRegion();
	regionp->id = nextregionid++;
	regionp->owner = curclient;
	regionp->next = listregionp;

	listregionp = regionp;

	id = regionp->id;

	SERVER_UNLOCK();

	return id;
}

/*
 * Allocate a new region from a set of points interpreted as a polygon.
 * The REGION is owned by the current client.
 */
GR_REGION_ID
GrNewPolygonRegion(int mode, GR_COUNT count, GR_POINT *points)
{
#if POLYREGIONS
	GR_REGION *regionp;
	GR_REGION_ID id;

	SERVER_LOCK();
           
	regionp = (GR_REGION *) malloc(sizeof(GR_REGION));
	if (regionp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}
	
	regionp->rgn = GdAllocPolygonRegion(points, count, mode);
	regionp->id = nextregionid++;
	regionp->owner = curclient;
	regionp->next = listregionp;

	listregionp = regionp;

	id = regionp->id;

	SERVER_UNLOCK();

	return id;
#else
	return 0;
#endif
}

/*
 * Destroy an existing region.
 */
void
GrDestroyRegion(GR_REGION_ID region)
{
	GR_REGION	*regionp;	/* region */
	GR_REGION	*prevregionp;	/* previous region */

	SERVER_LOCK();

	regionp = GsFindRegion(region);
	if (regionp == NULL) {
		SERVER_UNLOCK();
		return;
	}

	if (listregionp == regionp) {
		listregionp = regionp->next;
	} else {
		prevregionp = listregionp;
		while (prevregionp->next != regionp)
			prevregionp = prevregionp->next;

		prevregionp->next = regionp->next;
	}
	GdDestroyRegion(regionp->rgn);
	free(regionp);

	SERVER_UNLOCK();
}

/*
 * Updates the region from a union of the specified rectangle
 * and the original region.
 */
void
GrUnionRectWithRegion(GR_REGION_ID region, GR_RECT *rect)
{
	GR_REGION	*regionp;
	MWRECT		rc;
	
	SERVER_LOCK();
	
	regionp = GsFindRegion(region);
	if (regionp) {
		/* convert Nano-X rect to MW rect*/
		rc.left = rect->x;
		rc.top = rect->y;
		rc.right = rect->x + rect->width;
		rc.bottom = rect->y + rect->height;
		GdUnionRectWithRegion(&rc, regionp->rgn);	
	}

	SERVER_UNLOCK();
}

/*
 * Updates the region from a union of two regions.
 */ 
void
GrUnionRegion(GR_REGION_ID dst_rgn, GR_REGION_ID src_rgn1,
	GR_REGION_ID src_rgn2)
{
	GR_REGION	*regionp;
	GR_REGION	*srcregionp1;
	GR_REGION	*srcregionp2;
	
	SERVER_LOCK();
	
	regionp = GsFindRegion(dst_rgn);
	if (regionp == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	srcregionp1 = GsFindRegion(src_rgn1);
	if (srcregionp1 == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	srcregionp2 = GsFindRegion(src_rgn2);
	if (srcregionp2 == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	GdUnionRegion(regionp->rgn, srcregionp1->rgn, srcregionp2->rgn);

	SERVER_UNLOCK();
}

/*
 * Updates the region by subtracting a region from another.
 */ 
void
GrSubtractRegion(GR_REGION_ID dst_rgn, GR_REGION_ID src_rgn1,
	GR_REGION_ID src_rgn2)
{
	GR_REGION	*regionp;
	GR_REGION	*srcregionp1;
	GR_REGION	*srcregionp2;
	
	SERVER_LOCK();
	
	regionp = GsFindRegion(dst_rgn);
	if (regionp == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	srcregionp1 = GsFindRegion(src_rgn1);
	if (srcregionp1 == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	srcregionp2 = GsFindRegion(src_rgn2);
	if (srcregionp2 == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	GdSubtractRegion(regionp->rgn, srcregionp1->rgn, srcregionp2->rgn);
	
	SERVER_UNLOCK();
}

/*
 * Updates the region to the difference of two regions.
 */ 
void
GrXorRegion(GR_REGION_ID dst_rgn, GR_REGION_ID src_rgn1,
	GR_REGION_ID src_rgn2)
{
	GR_REGION	*regionp;
	GR_REGION	*srcregionp1;
	GR_REGION	*srcregionp2;
	
	SERVER_LOCK();
	
	regionp = GsFindRegion(dst_rgn);
	if (regionp == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	srcregionp1 = GsFindRegion(src_rgn1);
	if (srcregionp1 == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	srcregionp2 = GsFindRegion(src_rgn2);
	if (srcregionp2 == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	GdXorRegion(regionp->rgn, srcregionp1->rgn, srcregionp2->rgn);
	
	SERVER_UNLOCK();
}

/*
 * Updates the region from a intersection of two regions.
 */ 
void
GrIntersectRegion(GR_REGION_ID dst_rgn, GR_REGION_ID src_rgn1,
	GR_REGION_ID src_rgn2)
{
	GR_REGION	*regionp;
	GR_REGION	*srcregionp1;
	GR_REGION	*srcregionp2;
	
	SERVER_LOCK();
	
	regionp = GsFindRegion(dst_rgn);
	if (regionp == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	srcregionp1 = GsFindRegion(src_rgn1);
	if (srcregionp1 == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	srcregionp2 = GsFindRegion(src_rgn2);
	if (srcregionp2 == NULL) {
		SERVER_UNLOCK();
		return;
	}
	
	GdIntersectRegion(regionp->rgn, srcregionp1->rgn, srcregionp2->rgn);
	
	SERVER_UNLOCK();
}

/*
 * Sets the clip-mask in the GC to the specified region.
 */
void
GrSetGCRegion(GR_GC_ID gc, GR_REGION_ID region)
{
	GR_GC		*gcp;
	
	SERVER_LOCK();
	
	gcp = GsFindGC(gc);
	if (gcp) {
		gcp->regionid = region;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}

/*
 * Set the x,y origin of user clip region in GC.
 */
void
GrSetGCClipOrigin(GR_GC_ID gc, int xoff, int yoff)
{
	GR_GC		*gcp;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp) {
		gcp->xoff = xoff;
		gcp->yoff = yoff;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}

/*
 * Determines whether a specified point resides in a region.
 */ 
GR_BOOL
GrPointInRegion(GR_REGION_ID region, GR_COORD x, GR_COORD y)
{
	GR_REGION	*regionp;
	GR_BOOL		result;
	
	SERVER_LOCK();
	
	regionp =  GsFindRegion(region);
	if (regionp == NULL) {
		SERVER_UNLOCK();
		return GR_FALSE;
	}
	
	result = GdPtInRegion(regionp->rgn, x, y);
	
	SERVER_UNLOCK();
	
	return result;
}

/*
 * Determines whether a specified rectangle at least partly resides
 * in a region.
 */ 
int
GrRectInRegion(GR_REGION_ID region, GR_COORD x, GR_COORD y, GR_COORD w,
	GR_COORD h)
{
	GR_REGION	*regionp;
	MWRECT		rect;
	int		result;
	
	SERVER_LOCK();
	
	regionp =  GsFindRegion(region);
	if (regionp == NULL) {
		SERVER_UNLOCK();
		return MWRECT_OUT;
	}
	
	rect.left = x;
	rect.top = y;
	rect.right = x + w;
	rect.bottom = y + h;
	result = GdRectInRegion(regionp->rgn, &rect);
	
	SERVER_UNLOCK();
	
	return result;
}

/*
 * Return GR_TRUE if a region is empty.
 */ 
GR_BOOL
GrEmptyRegion(GR_REGION_ID region)
{
	GR_REGION	*regionp;
	GR_BOOL		result;
	
	SERVER_LOCK();
	
	regionp =  GsFindRegion(region);
	if (regionp == NULL) {
		SERVER_UNLOCK();
		return GR_TRUE;
	}
	
	result = GdEmptyRegion(regionp->rgn);
	
	SERVER_UNLOCK();
	
	return result;
}

/*
 * Return GR_TRUE if two regions are identical.
 */ 
GR_BOOL
GrEqualRegion(GR_REGION_ID rgn1, GR_REGION_ID rgn2)
{
	GR_REGION	*prgn1;
	GR_REGION	*prgn2;
	GR_BOOL result;
	
	SERVER_LOCK();
	
	prgn1 = GsFindRegion(rgn1);
	prgn2 = GsFindRegion(rgn2);

	if (!prgn1 && !prgn2) {
		result = GR_TRUE;
	} else if (!prgn1 || !prgn2) {
		result = GR_FALSE;
	} else {
		result = GdEqualRegion(prgn1->rgn, prgn2->rgn);
	}
	
	SERVER_UNLOCK();
	
	return result;
}

/*
 * Offset a region by dx, dy.
 */ 
void
GrOffsetRegion(GR_REGION_ID region, GR_SIZE dx, GR_SIZE dy)
{
	GR_REGION	*regionp;
	
	SERVER_LOCK();
	
	regionp =  GsFindRegion(region);
	if (regionp)
		GdOffsetRegion(regionp->rgn, dx, dy);
	
	SERVER_UNLOCK();
}

/*
 * Return the bounding box for the specified region.
 */
int
GrGetRegionBox(GR_REGION_ID region, GR_RECT *rect)
{
	GR_REGION	*regionp;
	MWRECT		rc;
	int		ret_val;
	
	SERVER_LOCK();
	
	regionp =  GsFindRegion(region);
	if (regionp == NULL) {
		memset(rect, 0, sizeof(GR_RECT));
		SERVER_UNLOCK();
		return MWREGION_ERROR;
	}
	
	ret_val = GdGetRegionBox(regionp->rgn, &rc);
	/* convert MW rect to Nano-X rect*/
	rect->x = rc.left;
	rect->y = rc.top;
	rect->width = rc.right - rc.left;
	rect->height = rc.bottom - rc.top;
	
	SERVER_UNLOCK();
	
	return ret_val;
}

static int nextfontid = 1000;
/*
 * Allocate a new GC with default parameters.
 * The GC is owned by the current client.
 */
GR_FONT_ID
GrCreateFont(GR_CHAR *name, GR_COORD height, GR_LOGFONT *plogfont)
{
	GR_FONT	*fontp;

	SERVER_LOCK();
	
	fontp = (GR_FONT *) malloc(sizeof(GR_FONT));
	if (fontp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}

	if (plogfont)
		fontp->pfont = GdCreateFont(&scrdev, NULL, 0, plogfont);
	else
		fontp->pfont = GdCreateFont(&scrdev, (const char *)name, height, NULL);

	/* if no font created, deallocate and return ID 0*/
	if (!fontp->pfont) {
		free(fontp);
		return 0;
	}

	fontp->id = nextfontid++;
	fontp->owner = curclient;
	fontp->next = listfontp;

	listfontp = fontp;

	SERVER_UNLOCK();
	
	return fontp->id;
}

#if HAVE_FREETYPE_2_SUPPORT
/*
 * Create a new font from memory.
 * The font is owned by the current client.
 */
GR_FONT_ID
GrCreateFontFromBuffer(const void *buffer, unsigned length,
		       const char *format, GR_COORD height)
{
	GR_FONT *fontp;

	SERVER_LOCK();
	
	fontp = (GR_FONT *)malloc(sizeof(GR_FONT));
	if (fontp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}

	/* DPRINTF("Font magic = '%c%c%c%c', len = %u @ GrCreateFontFromBuffer\n",
	 *         (char) buffer[0], (char) buffer[1],
	 *         (char) buffer[2], (char) buffer[3], length);
	 */

	fontp->pfont = GdCreateFontFromBuffer(&scrdev, buffer, length, format,
				       height);
	if (fontp->pfont == NULL) {
		/* Error loading font, probably corrupt data or unsupported format. */
		free(fontp);
		SERVER_UNLOCK();
		return 0;
	}

	fontp->id = nextfontid++;
	fontp->owner = curclient;
	fontp->next = listfontp;
	listfontp = fontp;

	SERVER_UNLOCK();
	return fontp->id;
}

/*
 * Create a new font from memory.
 * The font is owned by the current client.
 */
GR_FONT_ID
GrCopyFont(GR_FONT_ID fontid, GR_COORD height)
{
	GR_FONT *srcfontp;
	GR_FONT *fontp;

	SERVER_LOCK();

	fontp = (GR_FONT *)malloc(sizeof(GR_FONT));
	if (fontp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}

	srcfontp = GsFindFont(fontid);
	if (srcfontp)
		fontp->pfont = GdDuplicateFont(&scrdev, srcfontp->pfont,height);
	else
		fontp->pfont = GdCreateFont(&scrdev, NULL, height, NULL);

	fontp->id = nextfontid++;
	fontp->owner = curclient;
	fontp->next = listfontp;
	listfontp = fontp;
	
	SERVER_UNLOCK();
	return fontp->id;
}
#endif /*HAVE_FREETYPE_2_SUPPORT*/

/* Set the font size for the passed font*/
void
GrSetFontSize(GR_FONT_ID fontid, GR_COORD size)
{
	GR_FONT		*fontp;

	SERVER_LOCK();

	fontp = GsFindFont(fontid);
	if (fontp)
		GdSetFontSize(fontp->pfont, size);

	SERVER_UNLOCK();
}

/* Set the font rotation in tenths of degrees for the passed font*/
void
GrSetFontRotation(GR_FONT_ID fontid, int tenthdegrees)
{
	GR_FONT		*fontp;

	SERVER_LOCK();

	fontp = GsFindFont(fontid);
	if (fontp)
		GdSetFontRotation(fontp->pfont, tenthdegrees);

	SERVER_UNLOCK();
}

/* Set the font size for the passed font*/
void
GrSetFontAttr(GR_FONT_ID fontid, int setflags, int clrflags)
{
	GR_FONT		*fontp;

	SERVER_LOCK();

	fontp = GsFindFont(fontid);
	if (fontp)
		GdSetFontAttr(fontp->pfont, setflags, clrflags);

	SERVER_UNLOCK();
}

/*
 * Unload and deallocate an existing font.
 */
void
GrDestroyFont(GR_FONT_ID fontid)
{
	GR_FONT		*fontp;
	GR_FONT		*prevfontp;

	SERVER_LOCK();

	fontp = GsFindFont(fontid);
	if (fontp == NULL) {
		SERVER_UNLOCK();
		return;
	}

	if (listfontp == fontp)
		listfontp = fontp->next;
	else {
		prevfontp = listfontp;
		while (prevfontp->next != fontp)
			prevfontp = prevfontp->next;

		prevfontp->next = fontp->next;
	}
	GdDestroyFont(fontp->pfont);
	free(fontp);

	SERVER_UNLOCK();
}

/*
 * Return useful information about the specified font.
 * Font #0 returns info about the standard font.
 */
void
GrGetFontInfo(GR_FONT_ID font, GR_FONT_INFO *fip)
{
	GR_FONT	*fontp;
	PMWFONT	pf;

	SERVER_LOCK();

	if (font == 0)
		pf = stdfont;
	else {
		fontp = GsFindFont(font);
		if (!fontp) {
			memset(fip, 0, sizeof(GR_FONT_INFO));
			SERVER_UNLOCK();
			return;
		}
		pf = fontp->pfont;
	}
	GdGetFontInfo(pf, fip);

	SERVER_UNLOCK();
}

/*
 * Select events for a window for this client.
 * The events are a bitmask for the events desired.
 */
void 
GrSelectEvents(GR_WINDOW_ID wid, GR_EVENT_MASK eventmask)
{
	GR_WINDOW	*wp;		/* window structure */
	GR_EVENT_CLIENT	*evp;		/* event-client structure */

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if (wp == NULL) {
		SERVER_UNLOCK();
		return;
	}

	/*
	 * See if this client is already in the event client list.
	 * If so, then just replace the events he is selecting for.
	 */
	for (evp = wp->eventclients; evp; evp = evp->next) {
		if (evp->client == curclient) {
			evp->eventmask = eventmask;
			SERVER_UNLOCK();
			return;
		}
	}

	/*
	 * A new client for this window, so allocate a new event client
	 * structure and insert it into the front of the list in the window.
	 */
	evp = (GR_EVENT_CLIENT *) malloc(sizeof(GR_EVENT_CLIENT));
	if (evp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, wid);
		SERVER_UNLOCK();
		return;
	}

	evp->client = curclient;
	evp->eventmask = eventmask;
	evp->next = wp->eventclients;
	wp->eventclients = evp;

	/*
	 * If it's a request for child updates to the root window,
	 * then search entire list and send map events for
	 * mapped windows now.  This allows a window manager
	 * to get the mapped window list without another API call.
	 */
	if (wid==GR_ROOT_WINDOW_ID && (eventmask & GR_EVENT_MASK_CHLD_UPDATE)) {
		for (wp = listwp; wp; wp = wp->next) {
			if (wp->realized)
				GsDeliverUpdateEvent(wp, GR_UPDATE_MAP,
					wp->x, wp->y, wp->width, wp->height);
		}
	}

	SERVER_UNLOCK();
}

static GR_WINDOW *
NewWindow(GR_WINDOW *pwp, GR_COORD x, GR_COORD y, GR_SIZE width,
	GR_SIZE height, GR_SIZE bordersize, GR_COLOR background,
	GR_COLOR bordercolor)
{
	GR_WINDOW	*wp;	/* new window*/

	if (width <= 0 || height <= 0 || bordersize < 0) {
		GsError(GR_ERROR_BAD_WINDOW_SIZE, 0);
		return NULL;
	}

	wp = (GR_WINDOW *) malloc(sizeof(GR_WINDOW));
	if (wp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		return NULL;
	}

	wp->id = nextid++;
	wp->psd = rootwp->psd;
	wp->parent = pwp;
	wp->children = NULL;
	wp->siblings = pwp->children;
	wp->next = listwp;
	wp->x = pwp->x + x;
	wp->y = pwp->y + y;
	wp->width = width;
	wp->height = height;
	wp->bordersize = bordersize;
	wp->background = background;
	wp->bgpixmap = NULL;
	wp->bgpixmapflags = GR_BACKGROUND_TILE;
	wp->bordercolor = bordercolor;
	wp->nopropmask = 0;
	wp->eventclients = NULL;
	wp->owner = curclient;
	wp->cursorid = pwp->cursorid;
	wp->mapped = GR_FALSE;
	wp->realized = GR_FALSE;
	wp->output = GR_TRUE;
	wp->props = 0;
	wp->title = NULL;
	wp->clipregion = NULL;

	pwp->children = wp;
	listwp = wp;

	return wp;
}

/*
 * Allocate a new window which is a child of the specified window.
 * The window inherits the cursor of the parent window.
 * The window is owned by the current client.
 */
GR_WINDOW_ID
GrNewWindow(GR_WINDOW_ID parent, GR_COORD x, GR_COORD y, GR_SIZE width,
	GR_SIZE height, GR_SIZE bordersize, GR_COLOR background,
	GR_COLOR bordercolor)
{
	GR_WINDOW	*pwp;		/* parent window */
	GR_WINDOW	*wp;		/* new window */
	GR_WINDOW_ID id;

	SERVER_LOCK();

	pwp = GsFindWindow(parent);
	if (pwp == NULL) {
		SERVER_UNLOCK();
		return 0;
	}

	if (!pwp->output) {
		GsError(GR_ERROR_INPUT_ONLY_WINDOW, pwp->id);
		SERVER_UNLOCK();
		return 0;
	}

	wp = NewWindow(pwp, x, y, width, height, bordersize, background,
		bordercolor);
	id = wp? wp->id: 0;
	
	SERVER_UNLOCK();
	
	return id;
}

/*
 * Allocate a new input-only window which is a child of the specified window.
 * Such a window is invisible, cannot be drawn into, and is only used to
 * return events.  The window inherits the cursor of the parent window.
 * The window is owned by the current client.
 */
GR_WINDOW_ID
GrNewInputWindow(GR_WINDOW_ID parent, GR_COORD x, GR_COORD y,
	GR_SIZE width, GR_SIZE height)
{
	GR_WINDOW	*pwp;		/* parent window */
	GR_WINDOW	*wp;		/* new window */
	GR_WINDOW_ID id;

	SERVER_LOCK();

	pwp = GsFindWindow(parent);
	if (pwp == NULL) {
		SERVER_UNLOCK();
		return 0;
	}

	wp = NewWindow(pwp, x, y, width, height, 0, BLACK, BLACK);
	if (wp) {
		/* convert to input-only window*/
		wp->output = GR_FALSE;
		id = wp->id;
		SERVER_UNLOCK();
		return id;
	}
	SERVER_UNLOCK();
	return 0;
}

/*
 * Allocate a pixmap, can be used with any drawing functions
 * for offscreen drawing
 */
GR_WINDOW_ID
GrNewPixmap(GR_SIZE width, GR_SIZE height, void * pixels)
{
	GR_PIXMAP	*pp;
	PSD		psd;
        int 		size, linelen, bpp, planes;
	GR_WINDOW_ID id;
   
	if (width <= 0 || height <= 0) {
		/* no error for now, server will desynchronize w/app*/
		/*GsError(GR_ERROR_BAD_WINDOW_SIZE, 0);*/
		return 0;
	}

	SERVER_LOCK();

	/*
	 * allocate offscreen psd.  If screen driver doesn't
	 * support blitting, this will fail.  Use root window screen
	 * device for compatibility for now.
	 */
	planes = rootwp->psd->planes;
	bpp = rootwp->psd->bpp;
        psd = rootwp->psd->AllocateMemGC(rootwp->psd);
	if (!psd) {
		SERVER_UNLOCK();
		return 0;
	}

	pp = (GR_PIXMAP *) malloc(sizeof(GR_PIXMAP));
	if (pp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		psd->FreeMemGC(psd);
		SERVER_UNLOCK();
		return 0;
	}

        GdCalcMemGCAlloc(psd, width, height, 0, 0, &size, &linelen);

	/* Allocate space for pixel values */
        if (!pixels) {
	        pixels = calloc(size, 1);
		psd->flags |= PSF_ADDRMALLOC;
	}
	if (!pixels) {
		free(pp);
		psd->FreeMemGC(psd);
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}
  
	pp->id = nextid++;
	pp->next = listpp;
	pp->psd = psd;
	pp->x = 0;
	pp->y = 0;
	pp->width = width;
	pp->height = height;
	pp->owner = curclient;

        psd->MapMemGC(psd, width, height, planes, bpp, linelen, size,
		pixels);
	
        listpp = pp;
	
	id = pp->id;
	
	SERVER_UNLOCK();
	
	return id;
}

/*
 * Map the window to make it (and possibly its children) visible on the screen.
 */
void
GrMapWindow(GR_WINDOW_ID wid)
{
	GR_WINDOW	*wp;		/* window structure */

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if (!wp || wp->mapped) {
		SERVER_UNLOCK();
		return;
	}

	wp->mapped = GR_TRUE;

	GsWpRealizeWindow(wp, GR_FALSE);

	SERVER_UNLOCK();
}

/*
 * Unmap the window to make it and its children invisible on the screen.
 */
void
GrUnmapWindow(GR_WINDOW_ID wid)
{
	GR_WINDOW	*wp;		/* window structure */

	SERVER_LOCK();
	
	wp = GsFindWindow(wid);
	if (!wp || !wp->mapped) {
		SERVER_UNLOCK();
		return;
	}

	GsWpUnrealizeWindow(wp, GR_FALSE);

	wp->mapped = GR_FALSE;

	SERVER_UNLOCK();
}

/*
 * Clear the associated area of a window to its background color
 * or pixmap.  Generate expose event for window if exposeflag set.
 */
void
GrClearArea(GR_WINDOW_ID wid, GR_COORD x, GR_COORD y, GR_SIZE width,
	GR_SIZE height, GR_BOOL exposeflag)
{
	GR_WINDOW		*wp;	/* window structure */

	SERVER_LOCK();

	wp = GsPrepareWindow(wid);
	if (wp) {
		if (width == 0)
			width = wp->width;
		if (height == 0)
			height = wp->height;
		GsWpClearWindow(wp, x, y, width, height, exposeflag);
	}

	SERVER_UNLOCK();
}

/* Return window with keyboard focus.*/
GR_WINDOW_ID
GrGetFocus(void)
{
	GR_WINDOW_ID id;

	SERVER_LOCK();
	id = focuswp->id;
	SERVER_UNLOCK();

	return id;
}

/*
 * Set the focus to a particular window.
 * This makes keyboard events only visible to that window or children of it,
 * depending on the pointer location.
 */
void
GrSetFocus(GR_WINDOW_ID wid)
{
	GR_WINDOW	*wp;		/* window structure */

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if (wp == NULL) {
		SERVER_UNLOCK();
		return;
	}

	if (!wp->realized) {
		GsError(GR_ERROR_UNMAPPED_FOCUS_WINDOW, wid);
		SERVER_UNLOCK();
		return;
	}

	/* Check if window wants focus, if not, ignore call*/
	if (wp->props & GR_WM_PROPS_NOFOCUS) {
		SERVER_UNLOCK();
		return;
	}

	focusfixed = (wp != rootwp);
	GsWpSetFocus(wp);

	SERVER_UNLOCK();
}

/*
 * Create a new server-based cursor resource.
 */
static int nextcursorid = 1000;
GR_CURSOR_ID
GrNewCursor(GR_SIZE width, GR_SIZE height, GR_COORD hotx, GR_COORD hoty,
	GR_COLOR foreground, GR_COLOR background, GR_BITMAP *fgbitmap,
	GR_BITMAP *bgbitmap)
{
	GR_CURSOR	*cp;
	int		bytes;
	GR_CURSOR_ID id;

	SERVER_LOCK();

	/*
	 * Make sure the size of the bitmap is reasonable.
	 */
	if (width <= 0 || width > MWMAX_CURSOR_SIZE ||
	    height <= 0 || height > MWMAX_CURSOR_SIZE) {
		GsError(GR_ERROR_BAD_CURSOR_SIZE, 0);
		SERVER_UNLOCK();
		return 0;
	}

	cp = (GR_CURSOR *)malloc(sizeof(GR_CURSOR));
	if (cp == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}

	/* fill in cursor structure*/
	cp->cursor.width = width;
	cp->cursor.height = height;
	cp->cursor.hotx = hotx;
	cp->cursor.hoty = hoty;
	cp->cursor.fgcolor = foreground;
	cp->cursor.bgcolor = background;

	bytes = GR_BITMAP_SIZE(width, height) * sizeof(GR_BITMAP);
	memcpy(&cp->cursor.image, fgbitmap, bytes);
	memcpy(&cp->cursor.mask, bgbitmap, bytes);

	cp->id = nextcursorid++;
	cp->owner = curclient;
	cp->next = listcursorp;
	listcursorp = cp;

	id = cp->id;
	
	SERVER_UNLOCK();
	
	return id;
}

/*
 * Destroy a server-based cursor.
 */
void
GrDestroyCursor(GR_CURSOR_ID cid)
{
	GR_CURSOR	*cursorp;
	GR_CURSOR	*prevcursorp;

	SERVER_LOCK();

	cursorp = GsFindCursor(cid);
	if (cursorp == NULL) {
		SERVER_UNLOCK();
		return;
	}

	if (listcursorp == cursorp)
		listcursorp = cursorp->next;
	else {
		prevcursorp = listcursorp;
		while (prevcursorp->next != cursorp)
			prevcursorp = prevcursorp->next;

		prevcursorp->next = cursorp->next;
	}

	if (curcursor == cursorp)
		curcursor = NULL;

	free(cursorp);
	GsCheckCursor();

	SERVER_UNLOCK();
}

/*
 * Specify a cursor for a window.
 * This cursor will only be used within that window, and by default
 * for its new children.  If the cursor is currently within this
 * window, it will be changed to the new one immediately.
 * If the new cursor id is 0, revert to the root window cursor.
 */
void
GrSetWindowCursor(GR_WINDOW_ID wid, GR_CURSOR_ID cid)
{
	GR_WINDOW	*wp;
	GR_CURSOR	*cp;		/* cursor structure */

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if (wp == NULL) {
		SERVER_UNLOCK();
		return;
	}

	if (cid == 0)
		cp = stdcursor;
	else {
		cp = GsFindCursor(cid);
		if (!cp) {
			SERVER_UNLOCK();
			return;		/* FIXME add server errmsg*/
		}
	}
	wp->cursorid = cid;

	/*
	 * If this was the current cursor, then draw the new one.
	 */
	if (cp == curcursor || curcursor == NULL) {
		GdMoveCursor(cursorx - cp->cursor.hotx,
			cursory - cp->cursor.hoty);
		GdSetCursor(&cp->cursor);
	}

	GsCheckCursor();

	SERVER_UNLOCK();
}

/*
 * Move the cursor to the specified absolute screen coordinates.
 * The coordinates are that of the defined hot spot of the cursor.
 * The cursor's appearance is changed to that defined for the window
 * in which the cursor is moved to.  In addition, mouse enter, mouse
 * exit, focus in, and focus out events are generated if necessary.
 * The current mouse location is also changed.
 */
void
GrMoveCursor(GR_COORD x, GR_COORD y)
{

	SERVER_LOCK();

	/*
	 * Move the cursor only if necessary, offsetting it to
	 * place the hot spot at the specified coordinates.
	 */
	if (x != cursorx || y != cursory) {
		if(curcursor) {
			GdMoveCursor(x - curcursor->cursor.hotx,
				y - curcursor->cursor.hoty);
			GdMoveMouse(x, y);
		}
		cursorx = x;
		cursory = y;
	}

	/*
	 * Now check to see which window the mouse is in, whether or
	 * not the cursor shape should be changed, and whether or not
	 * the input focus window should be changed.
	 */
	GsCheckMouseWindow();
	GsCheckFocusWindow();
	GsCheckCursor();

	SERVER_UNLOCK();
}

/*
 * Set the foreground color in a graphics context from a passed RGB color value.
 */
void
GrSetGCForeground(GR_GC_ID gc, GR_COLOR foreground)
{
	GR_GC		*gcp;		/* graphics context */

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp && ((gcp->foreground != foreground) || gcp->fgispixelval)) {
		gcp->foreground = foreground;
		gcp->fgispixelval = GR_FALSE;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}

/*
 * Set the background color in a graphics context from a passed RGB color value.
 */
void
GrSetGCBackground(GR_GC_ID gc, GR_COLOR background)
{
	GR_GC		*gcp;		/* graphics context */

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp && ((gcp->background != background) || gcp->bgispixelval)) {
		gcp->background = background;
		gcp->bgispixelval = GR_FALSE;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}

/*
 * Set the foreground color in a graphics context from a passed pixel value.
 */
void
GrSetGCForegroundPixelVal(GR_GC_ID gc, GR_PIXELVAL foreground)
{
	GR_GC *gcp;		/* graphics context */

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp && ((gcp->foreground != foreground) || !gcp->fgispixelval)) {
		gcp->foreground = foreground;
		gcp->fgispixelval = GR_TRUE;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}

/*
 * Set the background color in a graphics context from a passed pixel value.
 */
void
GrSetGCBackgroundPixelVal(GR_GC_ID gc, GR_PIXELVAL background)
{
	GR_GC *gcp;		/* graphics context */

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp && ((gcp->background != background) || !gcp->bgispixelval)) {
		gcp->background = background;
		gcp->bgispixelval = GR_TRUE;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}

/*
 * Set whether or not the background color is drawn in bitmaps and text.
 */
void
GrSetGCUseBackground(GR_GC_ID gc, GR_BOOL flag)
{
	GR_GC		*gcp;		/* graphics context */

	SERVER_LOCK();

	flag = (flag != 0);
	gcp = GsFindGC(gc);
	if (gcp && gcp->usebackground != flag) {
		gcp->usebackground = flag;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}

/*
 * Set the drawing mode in a graphics context.
 */
void
GrSetGCMode(GR_GC_ID gc, int mode)
{
	GR_GC		*gcp;		/* graphics context */

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (!gcp || gcp->mode == mode) {
		SERVER_UNLOCK();
		return;
	}
	if ((mode & GR_MODE_DRAWMASK) > GR_MAX_MODE) {
		GsError(GR_ERROR_BAD_DRAWING_MODE, gc);
		SERVER_UNLOCK();
		return;
	}

	gcp->mode = mode;
	gcp->changed = GR_TRUE;

	SERVER_UNLOCK();
}

/* 
 * Set the attributes of the line.  
 */
void
GrSetGCLineAttributes(GR_GC_ID gc, int linestyle)
{
	GR_GC *gcp;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (!gcp) {
		SERVER_UNLOCK();
		return;
	}

	switch (linestyle) {
	case GR_LINE_SOLID:
	case GR_LINE_ONOFF_DASH:
		gcp->linestyle = linestyle;
		break;

	default:
		GsError(GR_ERROR_BAD_LINE_ATTRIBUTE, gc);
		SERVER_UNLOCK();
		return;
	}
	gcp->changed = GR_TRUE;

	SERVER_UNLOCK();
}

/*
 * Set the dash mode 
 * A series of numbers are passed indicating the on / off state 
 * for example { 3, 1 } indicates 3 on and 1 off 
 */
void
GrSetGCDash(GR_GC_ID gc, char *dashes, int count)
{
	GR_GC *gcp;
	unsigned long dmask = 0;
	int dcount = 0;
	int onoff = 1;
	int i;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (!gcp) {
		SERVER_UNLOCK();
		return;
	}

	/* Build the bitmask (up to 32 bits) */
	for (i = 0; i < count; i++) {
		int b = 0;

		for (; b < dashes[i]; b++) {
			if (onoff)
				dmask |= (1 << dcount);
			if ((++dcount) == 32)
				break;
		}

		onoff = (onoff + 1) % 2;
		if (dcount == 32)
			break;
	}
	gcp->dashmask = dmask;
	gcp->dashcount = dcount;
	gcp->changed = GR_TRUE;

	SERVER_UNLOCK();
}

void
GrSetGCFillMode(GR_GC_ID gc, int fillmode)
{
	GR_GC *gcp;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (!gcp) {
		SERVER_UNLOCK();
		return;
	}

	switch (fillmode) {
	case GR_FILL_SOLID:
	case GR_FILL_STIPPLE:
	case GR_FILL_OPAQUE_STIPPLE:
	case GR_FILL_TILE:
		gcp->fillmode = fillmode;
		break;

	default:
		GsError(GR_ERROR_BAD_FILL_MODE, gc);
		SERVER_UNLOCK();
		return;
	}
	gcp->changed = GR_TRUE;

	SERVER_UNLOCK();
}

void
GrSetGCStipple(GR_GC_ID gc, GR_BITMAP * bitmap, GR_SIZE width, GR_SIZE height)
{
	GR_GC *gcp;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (!gcp) {
		SERVER_UNLOCK();
		return;
	}

	if (gcp->stipple.bitmap)
		free(gcp->stipple.bitmap);

	if (!bitmap) {
		gcp->stipple.bitmap = 0;
		gcp->stipple.width = gcp->stipple.height = 0;
		gcp->changed = GR_TRUE;
		SERVER_UNLOCK();
		return;
	}

	gcp->stipple.bitmap =
		malloc(GR_BITMAP_SIZE(width, height) * sizeof(GR_BITMAP));
	memcpy(gcp->stipple.bitmap, bitmap,
	       GR_BITMAP_SIZE(width, height) * sizeof(GR_BITMAP));

	gcp->stipple.width = width;
	gcp->stipple.height = height;
	gcp->changed = GR_TRUE;

	SERVER_UNLOCK();
}

void
GrSetGCTile(GR_GC_ID gc, GR_WINDOW_ID pixmap, GR_SIZE width, GR_SIZE height)
{
	GR_WINDOW *win;
	GR_GC *gcp;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (!gcp) {
		SERVER_UNLOCK();
		return;
	}

	if (!pixmap) {
		gcp->tile.psd = NULL;
		gcp->tile.width = gcp->tile.height = 0;
		gcp->changed = GR_TRUE;
		SERVER_UNLOCK();
		return;
	}

	win = GsFindWindow(pixmap);
	if (win)
		gcp->tile.psd = win->psd;
	else {
		GR_PIXMAP *pix = GsFindPixmap(pixmap);
		if (!pix) {
			gcp->tile.psd = NULL;
			gcp->tile.width = gcp->tile.height = 0;
			gcp->changed = GR_TRUE;
			SERVER_UNLOCK();
			return;
		}
		gcp->tile.psd = pix->psd;
	}

	/* FIXME:  Set a size restriction here? */
	gcp->tile.width = width;
	gcp->tile.height = height;
	gcp->changed = GR_TRUE;

	SERVER_UNLOCK();
}

void
GrSetGCTSOffset(GR_GC_ID gc, GR_COORD xoff, GR_COORD yoff)
{
	GR_GC *gcp;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp) {
		gcp->ts_offset.x = xoff;
		gcp->ts_offset.y = yoff;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}

/* 
 * Boolean that sets if we send EXPOSE events on a GrCopyArea
 */
void 
GrSetGCGraphicsExposure(GR_GC_ID gc, GR_BOOL exposure)
{
	GR_GC		*gcp;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp) {
		gcp->exposure = exposure;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}


/*
 * Set the text font in a graphics context.
 */
void
GrSetGCFont(GR_GC_ID gc, GR_FONT_ID font)
{
	GR_GC		*gcp;

	SERVER_LOCK();

	gcp = GsFindGC(gc);
	if (gcp && gcp->fontid != font) {
		gcp->fontid = font;
		gcp->changed = GR_TRUE;
	}

	SERVER_UNLOCK();
}

/*
 * Draw a line in the specified drawable using the specified graphics context.
 */

void
GrLine(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x1, GR_COORD y1, GR_COORD x2,
	GR_COORD y2)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdLine(dp->psd, dp->x + x1, dp->y + y1,
				dp->x + x2, dp->y + y2, TRUE);
			break;
	}

	SERVER_UNLOCK();
}

/*
 * Draw the boundary of a rectangle in the specified drawable using the
 * specified graphics context.
 * NOTE: this function draws a rectangle 1 pixel wider and higher
 * than Xlib's XDrawRectangle().
 */
void 
GrRect(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y, GR_SIZE width,
	GR_SIZE height)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
      	        case GR_DRAW_TYPE_PIXMAP:
			GdRect(dp->psd, dp->x + x, dp->y + y, width, height);
			break;
	}

	SERVER_UNLOCK();
}

/*
 * Fill a rectangle in the specified drawable using the specified
 * graphics context.
 */
void
GrFillRect(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y,
	GR_SIZE width, GR_SIZE height)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdFillRect(dp->psd, dp->x + x, dp->y + y, width,height);
			break;
	}

	SERVER_UNLOCK();
}

/*
 * Draw the boundary of an ellipse in the specified drawable with
 * the specified graphics context.  Integer only.
 */
void
GrEllipse(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y, GR_SIZE rx,
	GR_SIZE ry)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdEllipse(dp->psd, dp->x + x, dp->y + y, rx, ry, FALSE);
			break;
	}

	SERVER_UNLOCK();
}

/*
 * Fill an ellipse in the specified drawable using the specified
 * graphics context.  Integer only.
 */
void
GrFillEllipse(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y, GR_SIZE rx,
	GR_SIZE ry)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdEllipse(dp->psd, dp->x + x, dp->y + y, rx, ry, TRUE);
			break;
	}

	SERVER_UNLOCK();
}

/*
 * Draw an arc, pie or ellipse in the specified drawable using
 * the specified graphics context.  Integer only.
 */
void	
GrArc(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y,
	GR_SIZE rx, GR_SIZE ry, GR_COORD ax, GR_COORD ay,
	GR_COORD bx, GR_COORD by, int type)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdArc(dp->psd, dp->x + x, dp->y + y, rx, ry, ax, ay,
					bx, by, type);

			break;
	}

	SERVER_UNLOCK();
}

/*
 * Draw an arc or pie in the specified drawable using
 * the specified graphics context.  Requires floating point.
 */
void
GrArcAngle(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y,
	GR_SIZE rx, GR_SIZE ry, GR_COORD angle1, GR_COORD angle2, int type)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdArcAngle(dp->psd, dp->x + x, dp->y + y, rx, ry,
				angle1, angle2, type);
			break;
	}

	SERVER_UNLOCK();
}

/*
 * Draw a rectangular area in the specified drawable using the specified
 * graphics, as determined by the specified bit map.  This differs from
 * rectangle drawing in that the rectangle is drawn using the foreground
 * color and possibly the background color as determined by the bit map.
 * Each row of bits is aligned to the next bitmap word boundary (so there
 * is padding at the end of the row).  The background bit values are only
 * written if the usebackground flag is set in the GC.
 */
void
GrBitmap(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y, GR_SIZE width,
	GR_SIZE height, GR_BITMAP *imagebits)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdBitmap(dp->psd, dp->x + x, dp->y + y, width, height,
				imagebits);
			break;
	}

	SERVER_UNLOCK();
}

/* draw a multicolor image at x, y*/
void
GrDrawImageBits(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y,
	GR_IMAGE_HDR *pimage)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdDrawImage(dp->psd, dp->x + x, dp->y + y, pimage);
			break;
	}

	SERVER_UNLOCK();
}

#if MW_FEATURE_IMAGES && defined(HAVE_FILEIO)
/* Load an image file from disk and display it at the specified coordinates*/
void
GrDrawImageFromFile(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y,
	GR_SIZE width, GR_SIZE height, char* path, int flags)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
 	        case GR_DRAW_TYPE_PIXMAP:
			GdDrawImageFromFile(dp->psd, dp->x + x, dp->y + y,
				width, height, path, flags);
			break;
	}

	SERVER_UNLOCK();
}

/* load image from file and cache it*/
GR_IMAGE_ID
GrLoadImageFromFile(char *path, int flags)
{
	GR_IMAGE_ID	id;
	GR_IMAGE *	imagep;

	SERVER_LOCK();

	id = GdLoadImageFromFile(&scrdev, path, flags);
	if (!id) {
		SERVER_UNLOCK();
		return 0;
	}

	imagep = (GR_IMAGE *) malloc(sizeof(GR_IMAGE));
	if (!imagep) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		GdFreeImage(id);
		SERVER_UNLOCK();
		return 0;
	}
	
	imagep->id = id;
	imagep->owner = curclient;
	imagep->next = listimagep;
	listimagep = imagep;

	SERVER_UNLOCK();
	return id;
}
#endif /* MW_FEATURE_IMAGES && defined(HAVE_FILEIO) */

#if MW_FEATURE_IMAGES
/* Draw an image from a buffer */
void
GrDrawImageFromBuffer(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y,
	GR_SIZE width, GR_SIZE height, void *buffer, int size, int flags)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
	case GR_DRAW_TYPE_WINDOW:
	case GR_DRAW_TYPE_PIXMAP:
		GdDrawImageFromBuffer(dp->psd, dp->x + x, dp->y + y,
			width, height, buffer, size, flags);
		break;
	}

	SERVER_UNLOCK();
}

/* load image from the given buffer and cache it*/
GR_IMAGE_ID
GrLoadImageFromBuffer(void *buffer, int size, int flags)
{
	GR_IMAGE_ID	id;
	GR_IMAGE *	imagep;

	SERVER_LOCK();

	id = GdLoadImageFromBuffer(&scrdev, buffer, size, flags);
	if (!id) {
		SERVER_UNLOCK();
		return 0;
	}

	imagep = (GR_IMAGE *) malloc(sizeof(GR_IMAGE));
	if (!imagep) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		GdFreeImage(id);
		SERVER_UNLOCK();
		return 0;
	}

	imagep->id = id;
	imagep->owner = curclient;
	imagep->next = listimagep;
	listimagep = imagep;

	SERVER_UNLOCK();

	return id;
}

/* draw cached image*/
void
GrDrawImageToFit(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y,
	GR_SIZE width, GR_SIZE height, GR_IMAGE_ID imageid)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
 	        case GR_DRAW_TYPE_PIXMAP:
			GdDrawImageToFit(dp->psd, dp->x + x, dp->y + y,
				width, height, imageid);
			break;
	   
	}

	SERVER_UNLOCK();
}

/* draw part of the cached image*/
void
GrDrawImagePartToFit(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD dx, GR_COORD dy,
	GR_SIZE dwidth, GR_SIZE dheight, GR_COORD sx, GR_COORD sy,
	GR_SIZE swidth, GR_SIZE sheight, GR_IMAGE_ID imageid)
{
	GR_DRAWABLE	*dp;
	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
 	        case GR_DRAW_TYPE_PIXMAP:
			GdDrawImagePartToFit(dp->psd, dp->x + dx, dp->y + dy,
				dwidth, dheight,sx,sy,swidth,sheight, imageid);
			break;
	   
	}

	SERVER_UNLOCK();
}

/* free cached image*/
void
GrFreeImage(GR_IMAGE_ID id)
{
	GR_IMAGE	*imagep;
	GR_IMAGE	*previmagep;

	SERVER_LOCK();

	for (imagep = listimagep; imagep; imagep = imagep->next) {
		if (imagep->id == id) {

			if (listimagep == imagep)
				listimagep = imagep->next;
			else {
				previmagep = listimagep;
				while (previmagep->next != imagep)
					previmagep = previmagep->next;

				previmagep->next = imagep->next;
			}

			GdFreeImage(imagep->id);
			free(imagep);
			SERVER_UNLOCK();
			return;
		}
	}

	SERVER_UNLOCK();
}

/* return cached image information*/
void
GrGetImageInfo(GR_IMAGE_ID id, GR_IMAGE_INFO *iip)
{
	SERVER_LOCK();
	GdGetImageInfo(id, iip);
	SERVER_UNLOCK();
}
#endif /* MW_FEATURE_IMAGES */

/*
 * Draw a rectangular area in the specified drawable using the specified
 * graphics context.  This differs from rectangle drawing in that the
 * color values for each pixel in the rectangle are specified.  
 * The color table is indexed row by row.
 */
void
GrArea(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y, GR_SIZE width,
	GR_SIZE height, void *pixels, int pixtype)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdArea(dp->psd, dp->x + x, dp->y + y, width, height,
				pixels, pixtype);
			break;
	}

	SERVER_UNLOCK();
}

/*
 * Copy a rectangle from one drawable to another or the same
 */
void
GrCopyArea(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y,
	GR_SIZE width, GR_SIZE height, GR_DRAW_ID srcid,
	GR_COORD srcx, GR_COORD srcy, unsigned long op)
{
  	GR_GC		*gcp;
	GR_BOOL         exposure = GR_TRUE;

	GR_DRAWABLE	*dp;
        GR_WINDOW	*swp;
        GR_PIXMAP	*spp = NULL;
        GR_DRAW_TYPE	type;
        PSD 		srcpsd;

	SERVER_LOCK();
   
        srcpsd = NULL;

        swp = GsFindWindow(srcid);
        type = GsPrepareDrawing(id, gc, &dp);
	if (type == GR_DRAW_TYPE_NONE) {
		SERVER_UNLOCK();
		return;
	}

        if (swp) {
		srcpsd = swp->psd;
		srcx += swp->x;
		srcy += swp->y;
	} else {
	       spp = GsFindPixmap(srcid);
	       if (spp)
		     srcpsd = spp->psd;
	}
	if (!srcpsd) {
		SERVER_UNLOCK();
		return;
	}

#if DYNAMICREGIONS  
	gcp = GsFindGC(gc);
	if (gcp)
		exposure = gcp->exposure;
	
	/*
	 * Skip blit and send expose event if window is partly
	 * obscured and source and destination are onscreen.
	 * Also check that receiving window's first client has
	 * selected for expose events.  This keeps brain-dead
	 * programs that don't process exposure events somewhat working.
	 */
	if (exposure && swp && (srcpsd == dp->psd) && swp->eventclients &&
	    (swp->eventclients->eventmask & GR_EVENT_MASK_EXPOSURE)) {
		MWRECT 		rc;
		extern MWCLIPREGION *clipregion;

		/* clip blit rectangle to source screen/bitmap size*/
		if(srcx+width > srcpsd->xvirtres)
			width = srcpsd->xvirtres - srcx;
		if(srcy+height > srcpsd->yvirtres)
			height = srcpsd->yvirtres - srcy;

		rc.left = srcx;
		rc.top = srcy;
		rc.right = srcx + width;
		rc.bottom = srcy + height;

		/*
		 * if source isn't entirely within clip region, then
		 * the blit is partly obscured and will copy some garbage.
		 * In this case, skip the blit, punt, and deliver an
		 * exposure event instead for proper display.
		 */
		if (GdRectInRegion(clipregion, &rc) != MWRECT_ALLIN) {
EPRINTF("nano-X: skipping blit, sending expose event\n");
			GsDeliverExposureEvent(swp, dp->x+x, dp->y+y,
				width, height);
			SERVER_UNLOCK();
			return;
		}
	}
#endif

	if (op == MWROP_USE_GC_MODE) {
		GR_GC *gcp = GsFindGC(gc);

		if (gcp == NULL) {
			op = MWROP_COPY;
		} else {
			op = MWMODE_TO_ROP(gcp->mode);
		}
	}

	/* perform blit*/
	GdCheckCursor(srcpsd, srcx, srcy, srcx+width, srcy+height); /* FIXME*/
	GdBlit(dp->psd, dp->x+x, dp->y+y, width, height, srcpsd, srcx, srcy,op);
	GdFixCursor(srcpsd); /* FIXME*/

	SERVER_UNLOCK();
}


/*
 * Read the color values from the specified rectangular area of the
 * specified drawable into a supplied buffer.  If the drawable is a
 * window which is obscured by other windows, then the returned values
 * will include the values from the covering windows.  Regions outside
 * of the screen boundaries, or unmapped windows will return black.
 */
void
GrReadArea(GR_DRAW_ID id,GR_COORD x,GR_COORD y,GR_SIZE width,GR_SIZE height,
	GR_PIXELVAL *pixels)
{
	GR_WINDOW	*wp;
	GR_PIXMAP	*pp = NULL;

	SERVER_LOCK();

	if ((wp = GsFindWindow(id)) == NULL && (pp = GsFindPixmap(id)) == NULL){
		GsError(GR_ERROR_BAD_WINDOW_ID, id);
		SERVER_UNLOCK();
		return;
	}

	if (wp != NULL) {
		if (!wp->realized || (x >= wp->width) || (y >= wp->height) ||
		   (x + width <= 0) || (y + height <= 0)) {
			/* long		count;
			* GR_PIXELVAL	black;
			*
			* black = GdFindColor(BLACK);
			* count = width * height;
			* while (count-- > 0)
			*	*pixels++ = black;
			*/
			SERVER_UNLOCK();
			return;
		}
		GdReadArea(wp->psd, wp->x+x, wp->y+y, width, height, pixels);
	}
	if (pp != NULL) {
		if ((x >= pp->width) || (y >= pp->height) ||
		    (x + width <= 0) || (y + height <= 0)) {
			SERVER_UNLOCK();
			return;
		}
		GdReadArea(pp->psd, x, y, width, height, pixels);
	}

	SERVER_UNLOCK();
}

/*
 * Draw a point in the specified drawable using the specified
 * graphics context.
 */
void
GrPoint(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdPoint(dp->psd, dp->x + x, dp->y + y);
			break;
	}

	SERVER_UNLOCK();
}

/*
 * Draw points in the specified drawable using the specified
 * graphics context.
 */
void
GrPoints(GR_DRAW_ID id, GR_GC_ID gc, GR_COUNT count, GR_POINT *pointtable)
{
	GR_DRAWABLE	*dp;
	GR_POINT	*pp;
	GR_COUNT	i;
        PSD 		psd;

	SERVER_LOCK();
   
	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
	                psd = dp->psd;
	                break;
		default:
			SERVER_UNLOCK();
			return;
	}

	pp = pointtable;
	for (i = count; i-- > 0; pp++) {
		GdPoint(psd, pp->x + dp->x, pp->y + dp->y);
	}

	SERVER_UNLOCK();
}

/*
 * Draw a polygon in the specified drawable using the specified
 * graphics context.  The polygon is only complete if the first
 * point is repeated at the end.
 */
void
GrPoly(GR_DRAW_ID id, GR_GC_ID gc, GR_COUNT count, GR_POINT *pointtable)
{
	GR_DRAWABLE	*dp;
	GR_POINT	*pp;
	GR_COUNT	i;
        PSD 		psd;

	SERVER_LOCK();
   
	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
	                psd = dp->psd;
	                break;
		default:
			SERVER_UNLOCK();
			return;
	}

	/*
	 * Here for drawing to a window.
	 * Relocate all the points relative to the window.
	 */
	pp = pointtable;
	for (i = count; i-- > 0; pp++) {
		pp->x += dp->x;
		pp->y += dp->y;
	}

	GdPoly(psd, count, pointtable);

#ifdef NONETWORK   
	/*
	 * The following is only necessary when the server
	 * isn't a separate process.  We don't want to change the
	 * user's arguments!
	 */
	pp = pointtable;
	for (i = count; i-- > 0; pp++) {
		pp->x -= dp->x;
		pp->y -= dp->y;
	}
#endif

	SERVER_UNLOCK();
}

/*
 * Draw a filled polygon in the specified drawable using the specified
 * graphics context.  The last point may be a duplicate of the first
 * point, but this is not required.
 */
void
GrFillPoly(GR_DRAW_ID id, GR_GC_ID gc, GR_COUNT count, GR_POINT *pointtable)
{
	GR_DRAWABLE	*dp;
	GR_POINT	*pp;
	GR_COUNT	i;
        PSD 		psd;

	SERVER_LOCK();
   
	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
	                psd = dp->psd;
			break;
		default:
			SERVER_UNLOCK();
			return;
	}

	/*
	 * Here for drawing to a window.
	 * Relocate all the points relative to the window.
	 */
	pp = pointtable;
	for (i = count; i-- > 0; pp++) {
		pp->x += dp->x;
		pp->y += dp->y;
	}

	GdFillPoly(psd, count, pointtable);

#ifdef NONETWORK
	/*
	 * The following is only necessary when the server
	 * isn't a separate process.  We don't want to change the
	 * user's arguments!
	 */
	pp = pointtable;
	for (i = count; i-- > 0; pp++) {
		pp->x -= dp->x;
		pp->y -= dp->y;
	}
#endif   

	SERVER_UNLOCK();
}

/*
 * Draw a text string in the specified drawable using the
 * specified graphics context.
 */
void
GrText(GR_DRAW_ID id, GR_GC_ID gc, GR_COORD x, GR_COORD y, void *str,
	GR_COUNT count, GR_TEXTFLAGS flags)
{
	GR_DRAWABLE	*dp;

	SERVER_LOCK();

	/* default to baseline alignment if none specified*/
	if((flags&(MWTF_TOP|MWTF_BASELINE|MWTF_BOTTOM)) == 0)
		flags |= MWTF_BASELINE;

	switch (GsPrepareDrawing(id, gc, &dp)) {
		case GR_DRAW_TYPE_WINDOW:
	        case GR_DRAW_TYPE_PIXMAP:
			GdText(dp->psd, dp->x + x, dp->y + y, str, count,flags);
			break;
	}

	SERVER_UNLOCK();
}

/* Return the system palette entries*/
void
GrGetSystemPalette(GR_PALETTE *pal)
{

	SERVER_LOCK();

	/* return 0 count if not in palettized mode*/
	memset(pal, 0, sizeof(GR_PALETTE *));

	if(rootwp->psd->pixtype == MWPF_PALETTE) {
		pal->count = (int)rootwp->psd->ncolors;
		GdGetPalette(rootwp->psd, 0, pal->count, pal->palette);
	}

	SERVER_UNLOCK();
}

/* Set the system palette entries from first for count*/
void
GrSetSystemPalette(GR_COUNT first, GR_PALETTE *pal)
{
	SERVER_LOCK();

	GdSetPalette(rootwp->psd, first, pal->count, pal->palette);
	if (first == 0)
		GsRedrawScreen();

	SERVER_UNLOCK();
}

/* Convert passed color value to pixel value, depending on system mode*/
void
GrFindColor(GR_COLOR c, GR_PIXELVAL *retpixel)
{
	SERVER_LOCK();
	*retpixel = GdFindColor(&scrdev, c);
	SERVER_UNLOCK();
}

/* visible =0, no cursor change; =1, show; else hide*/
void
GrInjectPointerEvent(GR_COORD x, GR_COORD y, int button, int visible)
{
	SERVER_LOCK();

	if (visible != 0) {
		if (visible == 1)
			GdShowCursor(&scrdev);
		else
			GdHideCursor(&scrdev);
	}

	GdMoveMouse(x, y);
	GsHandleMouseStatus(x, y, button);

	SERVER_UNLOCK();
}

void
GrInjectKeyboardEvent(GR_WINDOW_ID wid, GR_KEY keyvalue, GR_KEYMOD modifiers,
	GR_SCANCODE scancode, GR_BOOL pressed)
{
	SERVER_LOCK();

	/* create a keyboard event */
	GsDeliverKeyboardEvent(wid,
		pressed? GR_EVENT_TYPE_KEY_DOWN: GR_EVENT_TYPE_KEY_UP,
		keyvalue, modifiers, scancode);

	SERVER_UNLOCK();
}

/*
 * Set certain window properties, according to flags value
 * passed in props.
 */
void
GrSetWMProperties(GR_WINDOW_ID wid, GR_WM_PROPERTIES *props)
{
	GR_WINDOW *wp;
	int tl = 0;    /* Initialized to avoid warning */

	SERVER_LOCK();

	/* Find the window structure (generate an error if it doesn't exist) */
	wp = GsFindWindow(wid);
	if(!wp) {
		GsError(GR_ERROR_BAD_WINDOW_ID, wid);
		SERVER_UNLOCK();
		return;
	}

	/* Set window properties*/
	if (props->flags & GR_WM_FLAGS_PROPS)
		wp->props = props->props;

	/* Set window title*/
	if (props->flags & GR_WM_FLAGS_TITLE) {
		/* Remove the old title if it exists */
		if(wp->title)
			free(wp->title);

		/* Calculate the space needed to store the new title */
		if(props->title)
			tl = strlen((const char *)props->title) + 1;

		/* Check for empty title*/
		if(!props->title || tl == 1) {
			wp->title = NULL;
		} else {
			/* Otherwise, allocate some space for the new title */
			if(!(wp->title = malloc(tl)))
				GsError(GR_ERROR_MALLOC_FAILED, wid);
			else
				memcpy(wp->title, props->title, tl);
		}
		
		/* send UPDATE_ACTIVATE event to force redraw*/
		GsWpNotifyActivate(focuswp);
	}

	/* Set window background*/
	if (props->flags & GR_WM_FLAGS_BACKGROUND) {
		if (wp->background != props->background) {
			wp->background = props->background;
			GsExposeArea(wp, wp->x, wp->y, wp->width, wp->height,
				NULL);
		}
	}

	/* Set window border size*/
	if (props->flags & GR_WM_FLAGS_BORDERSIZE) {
		if (wp->bordersize != props->bordersize) {
			/* FIXME: check if this works if not already realized*/
			GsWpUnrealizeWindow(wp, GR_TRUE);
			wp->bordersize = props->bordersize;
			GsWpRealizeWindow(wp, GR_TRUE);
		}
	}

	/* Set window border color*/
	if (props->flags & GR_WM_FLAGS_BORDERCOLOR) {
		if (wp->bordercolor != props->bordercolor) {
			wp->bordercolor = props->bordercolor;
			if (wp->bordersize)
				GsDrawBorder(wp);
		}
	}

	SERVER_UNLOCK();
}

/*
 * Return all window properties
 */
void
GrGetWMProperties(GR_WINDOW_ID wid, GR_WM_PROPERTIES *props)
{
	GR_WINDOW *wp;

	SERVER_LOCK();

	/* Find the window structure, no error on invalid window id*/ 
	wp = GsFindWindow(wid);
	if(!wp) {
		/* set flags to 0 on bad window id*/
		memset(props, 0, sizeof(GR_WM_PROPERTIES));
		SERVER_UNLOCK();
		return;
	}

	/* Return everything, regardless of props->flags*/
	props->flags = GR_WM_FLAGS_PROPS | GR_WM_FLAGS_TITLE |
		GR_WM_FLAGS_BACKGROUND | GR_WM_FLAGS_BORDERSIZE |
		GR_WM_FLAGS_BORDERCOLOR;
	props->props = wp->props;
	props->title = wp->title;
	props->background = wp->background;
	props->bordersize = wp->bordersize;
	props->bordercolor = wp->bordercolor;

	SERVER_UNLOCK();
}

void
GrCloseWindow(GR_WINDOW_ID wid)
{
	GR_WINDOW *wp;

	SERVER_LOCK();

	/* Find the window structure (generate an error if it doesn't exist) */
	wp = GsFindWindow(wid);
	if(!wp) {
		/* 
		 * no error for now, client/server problems
		 * with nxwm when sent
		 */
		/*GsError(GR_ERROR_BAD_WINDOW_ID, wid);*/
		SERVER_UNLOCK();
		return;
	}

	/* Send a CLOSE_REQ event to the client */
	GsDeliverGeneralEvent(wp, GR_EVENT_TYPE_CLOSE_REQ, NULL);

	SERVER_UNLOCK();
}

void
GrKillWindow(GR_WINDOW_ID wid)
{
	GR_WINDOW *wp;

	SERVER_LOCK();

	/* Find the window structure (generate an error if it doesn't exist) */
	wp = GsFindWindow(wid);
	if(!wp) {
		GsError(GR_ERROR_BAD_WINDOW_ID, wid);
		SERVER_UNLOCK();
		return;
	}

	/* Forcibly kill the connection to the client */
	GsClose(wp->owner->id);

	SERVER_UNLOCK();
}

/*
 * GrGetSystemColor color scheme definitions
 */ 
/* define color scheme: A (tan), B (winstd) or C (old)*/
#define A

#define A_RGB(r,g,b)
#define B_RGB(r,g,b)
#define C_RGB(r,g,b)

#ifdef A
#undef  A_RGB
#define A_RGB(r,g,b)	GR_RGB(r,g,b),
#endif
#ifdef B
#undef  B_RGB
#define B_RGB(r,g,b)	GR_RGB(r,g,b),
#endif
#ifdef C
#undef  C_RGB
#define C_RGB(r,g,b)	GR_RGB(r,g,b),
#endif

#define MAXSYSCOLORS	20	/* # of GR_COLOR_* system colors*/

static const GR_COLOR sysColors[MAXSYSCOLORS] = {
	/* desktop background*/
	GR_RGB(  0, 128, 128),  /* GR_COLOR_DESKTOP             */

	/* caption colors*/
	A_RGB(128,   0,   0)	/* GR_COLOR_ACTIVECAPTION       */
	B_RGB(128,   0, 128)	/* GR_COLOR_ACTIVECAPTION       */
	C_RGB(128,   0, 128)	/* GR_COLOR_ACTIVECAPTION       */
	GR_RGB(255, 255, 255),  /* GR_COLOR_ACTIVECAPTIONTEXT   */
	A_RGB(162, 141, 104)	/* GR_COLOR_INACTIVECAPTION     */
	B_RGB(128, 128, 128)  	/* GR_COLOR_INACTIVECAPTION     */
	C_RGB(  0,  64, 128)	/* GR_COLOR_INACTIVECAPTION     */
	GR_RGB(192, 192, 192),  /* GR_COLOR_INACTIVECAPTIONTEXT */

	/* 3d border shades*/
	GR_RGB(  0,   0,   0),  /* GR_COLOR_WINDOWFRAME         */
	A_RGB(162, 141, 104)	/* GR_COLOR_BTNSHADOW           */
	B_RGB(128, 128, 128)	/* GR_COLOR_BTNSHADOW           */
	C_RGB(128, 128, 128)	/* GR_COLOR_BTNSHADOW           */
	A_RGB(213, 204, 187)	/* GR_COLOR_3DLIGHT             */
	B_RGB(223, 223, 223)	/* GR_COLOR_3DLIGHT             */
	C_RGB(192, 192, 192)	/* GR_COLOR_3DLIGHT             */
	A_RGB(234, 230, 221)  	/* GR_COLOR_BTNHIGHLIGHT        */
	B_RGB(255, 255, 255)  	/* GR_COLOR_BTNHIGHLIGHT        */
	C_RGB(223, 223, 223)  	/* GR_COLOR_BTNHIGHLIGHT        */

	/* top level application window backgrounds/text*/
	A_RGB(213, 204, 187)	/* GR_COLOR_APPWINDOW           */
	B_RGB(192, 192, 192)	/* GR_COLOR_APPWINDOW           */
	C_RGB(160, 160, 160)	/* GR_COLOR_APPWINDOW           */
	GR_RGB(  0,   0,   0),  /* GR_COLOR_APPTEXT             */

	/* button control backgrounds/text (usually same as app window colors)*/
	A_RGB(213, 204, 187)	/* GR_COLOR_BTNFACE             */
	B_RGB(192, 192, 192)	/* GR_COLOR_BTNFACE             */
	C_RGB(160, 160, 160)	/* GR_COLOR_BTNFACE             */
	GR_RGB(  0,   0,   0),  /* GR_COLOR_BTNTEXT             */

	/* edit/listbox control backgrounds/text, selected highlights*/
	GR_RGB(255, 255, 255),  /* GR_COLOR_WINDOW              */
	GR_RGB(  0,   0,   0),  /* GR_COLOR_WINDOWTEXT          */
	GR_RGB(128,   0,   0),  /* GR_COLOR_HIGHLIGHT           */
	GR_RGB(255, 255, 255),  /* GR_COLOR_HIGHLIGHTTEXT       */
	GR_RGB( 64,  64,  64),  /* GR_COLOR_GRAYTEXT            */

	/* menu backgrounds/text*/
	A_RGB(213, 204, 187)	/* GR_COLOR_MENU                */
	B_RGB(192, 192, 192)	/* GR_COLOR_MENU                */
	C_RGB(160, 160, 160)	/* GR_COLOR_MENU                */
	GR_RGB(  0,   0,   0),  /* GR_COLOR_MENUTEXT            */
};

/* Return system-defined color*/
GR_COLOR
GrGetSysColor(int index)
{
	GR_COLOR color = 0;
	SERVER_LOCK();
	if(index >= 0 && index < MAXSYSCOLORS)
		color = sysColors[index];
	SERVER_UNLOCK();
	return color;
}

void
GrSetScreenSaverTimeout(GR_TIMEOUT timeout)
{
#if MW_FEATURE_TIMERS
	MWTIMER *timer;

	SERVER_LOCK();

	screensaver_delay = timeout * 1000;

	if((timer = GdFindTimer(GsActivateScreenSaver)))
		GdDestroyTimer(timer);

	/* 0 timeout cancels timer*/
	if (timeout == 0) {
		SERVER_UNLOCK();
		return;
	}

	GdAddTimer(screensaver_delay, GsActivateScreenSaver,
					GsActivateScreenSaver);

	SERVER_UNLOCK();
#endif /* MW_FEATURE_TIMERS */
}

void
GrSetSelectionOwner(GR_WINDOW_ID wid, GR_CHAR *typelist)
{
	GR_WINDOW_ID oldwid = selection_owner.wid;

	SERVER_LOCK();

	if(selection_owner.typelist) free(selection_owner.typelist);

	selection_owner.wid = wid;

	if(wid) {
		if(!(selection_owner.typelist = (GR_CHAR *)strdup((const char *)typelist))) {
			GsError(GR_ERROR_MALLOC_FAILED, wid);
			selection_owner.wid = 0;
		}
	} else selection_owner.typelist = NULL;

	GsDeliverSelectionChangedEvent(oldwid, wid);

	SERVER_UNLOCK();
}

GR_WINDOW_ID
GrGetSelectionOwner(GR_CHAR **typelist)
{
	GR_WINDOW_ID result;

	SERVER_LOCK();
	*typelist = selection_owner.typelist;
	result = selection_owner.wid;
	SERVER_UNLOCK();

	return result;
}

void
GrRequestClientData(GR_WINDOW_ID wid, GR_WINDOW_ID rid, GR_SERIALNO serial,
							GR_MIMETYPE mimetype)
{
	SERVER_LOCK();
	GsDeliverClientDataReqEvent(rid, wid, serial, mimetype);
	SERVER_UNLOCK();
}

void
GrSendClientData(GR_WINDOW_ID wid, GR_WINDOW_ID did, GR_SERIALNO serial,
				GR_LENGTH len, GR_LENGTH thislen, void *data)
{
	SERVER_LOCK();
	GsDeliverClientDataEvent(did, wid, serial, len, thislen, data);
	SERVER_UNLOCK();
}

/*
 * Set a window's background pixmap.  Note that this doesn't
 * cause a screen refresh, use GrClearWindow if required.
 */
void
GrSetBackgroundPixmap(GR_WINDOW_ID wid, GR_WINDOW_ID pixmap, int flags)
{
	GR_WINDOW *wp;
	GR_PIXMAP *pp = NULL;

	SERVER_LOCK();

	if (!(wp = GsFindWindow(wid))) {
		GsError(GR_ERROR_BAD_WINDOW_ID, wid);
		SERVER_UNLOCK();
		return;
	}

	if (pixmap && !(pp = GsFindPixmap(pixmap))) {
		GsError(GR_ERROR_BAD_WINDOW_ID, pixmap);
		SERVER_UNLOCK();
		return;
	}
	wp->bgpixmap = pp;
	wp->bgpixmapflags = flags;

	SERVER_UNLOCK();
}

void
GrGetFontList(GR_FONTLIST ***fonts, int *numfonts)
{
	SERVER_LOCK();
	GdGetFontList(fonts,numfonts);
	SERVER_UNLOCK();
}

void 
GrFreeFontList(GR_FONTLIST ***fonts, int numfonts)
{
	SERVER_LOCK();
	GdFreeFontList(fonts, numfonts);
	SERVER_UNLOCK();
}

/*
 * Copy and stretch a rectangle.
 */
void
GrStretchArea(GR_DRAW_ID dstid, GR_GC_ID gc,
	      GR_COORD dx1, GR_COORD dy1,
	      GR_COORD dx2, GR_COORD dy2,
	      GR_DRAW_ID srcid,
	      GR_COORD sx1, GR_COORD sy1,
	      GR_COORD sx2, GR_COORD sy2,
	      unsigned long op)
{
	GR_DRAWABLE *dp;
	GR_WINDOW *swp;
	GR_PIXMAP *spp = NULL;
	GR_DRAW_TYPE type;
	PSD srcpsd;

	SERVER_LOCK();

	srcpsd = NULL;

	type = GsPrepareDrawing(dstid, gc, &dp);
	if (type == GR_DRAW_TYPE_NONE) {
		SERVER_UNLOCK();
		return;
	}

	dx1 += dp->x;
	dy1 += dp->y;
	dx2 += dp->x;
	dy2 += dp->y;

	swp = GsFindWindow(srcid);
	if (swp) {
		srcpsd = swp->psd;
		sx1 += swp->x;
		sy1 += swp->y;
		sx2 += swp->x;
		sy2 += swp->y;
	} else {
		spp = GsFindPixmap(srcid);
		if (spp)
			srcpsd = spp->psd;
	}
	if (!srcpsd) {
		SERVER_UNLOCK();
		return;
	}

	if (op == MWROP_USE_GC_MODE) {
		GR_GC *gcp;
		gcp = GsFindGC(gc);
		if (gcp == NULL) {
			op = MWROP_COPY;
		} else {
			op = MWMODE_TO_ROP(gcp->mode);
		}
	}

	/* perform blit */

	/* DPRINTF("Nano-X: GrStretchArea() calling GdStretchBlit()\n"); */
	//GdCheckCursor(srcpsd, s1x, s1y, s2x, s2y); /* FIXME*/
	/*GdStretchBlit(dp->psd, dx, dy, dw, dh,
	   srcpsd,  sx, sy, sw, sh,
	   op); */
	GdStretchBlitEx(dp->psd, dx1, dy1, dx2, dy2,
			srcpsd, sx1, sy1, sx2, sy2, op);
	/* DPRINTF("Nano-X: GrStretchArea() done GdStretchBlitEx()\n"); */
	//GdFixCursor(srcpsd); /* FIXME*/

	SERVER_UNLOCK();
}

/*
 * Return window parent and list of children.
 * Caller must free() children list after use.
 */
void
GrQueryTree(GR_WINDOW_ID wid, GR_WINDOW_ID *parentid, GR_WINDOW_ID **children,
	GR_COUNT *nchildren)
{
	GR_WINDOW	*wp;
	GR_WINDOW	*cp;
	GR_WINDOW_ID	*retarray;
	GR_COUNT	n = 0;

	SERVER_LOCK();

	wp = GsFindWindow(wid);
	if (!wp) {
		*parentid = 0;
nochildren:
		*children = NULL;
		*nchildren = 0;
		SERVER_UNLOCK();
		return;
	}
	*parentid = wp->parent? wp->parent->id: 0;

	/* count children for alloc*/
	for(cp=wp->children; cp; cp=cp->siblings)
		++n;
	if (n == 0)
		goto nochildren;
	
	/* alloc return child array*/
	retarray = (GR_WINDOW_ID *)malloc(n * sizeof(GR_WINDOW_ID));
	if (!retarray) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		goto nochildren;
	}

	/* fill in return array*/
	n = 0;
	for(cp=wp->children; cp; cp=cp->siblings) {
		retarray[n++] = cp->id;
	}
	*children = retarray;
	*nchildren = n;

	SERVER_UNLOCK();
}


#if MW_FEATURE_TIMERS
static int next_timer_id = 1000;

/**
 * Creates a Nano-X timer with the specified period.
 * NOTE: There is a potential for more GR_TIMER_EVENTS to be queued
 * in the connection between the Nano-X server and client.  The client
 * should be able to handle late arriving GR_TIMER_EVENTs.
 *
 * @param wid the ID of the window to use as a destination for GR_TIMER_EVENT
 *	events that result from this timer.
 * @param period the timer period in milliseconds
 * @return the ID of the newly created timer, or 0 if failure.
 */
GR_TIMER_ID
GrCreateTimer (GR_WINDOW_ID wid, GR_TIMEOUT period)
{
    GR_TIMER  *timer;
	GR_TIMER_ID id;

	SERVER_LOCK();

    /* Create a nano-X layer timr */
    timer = (GR_TIMER*) malloc (sizeof (GR_TIMER));
    if (timer == NULL)
    {
        GsError (GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
        return 0;
    }

    /* Create a device independent layer timer */
    timer->timer = GdAddPeriodicTimer (period, GsTimerCB, timer);
    if (timer->timer == NULL)
    {
        free (timer);
        GsError (GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
        return 0;
    }

    /* 
     * Fill in the rest of the timer structure, and 
     * link the new timer into the servers list of timers.
     */
    timer->id    = next_timer_id++;
    timer->owner = curclient;
    timer->wid   = wid;
    timer->next  = list_timer;
    list_timer   = timer;

    id = timer->id;

	SERVER_UNLOCK();

	return id;
}

/**
 * Destroys a timer previously created with GrCreateTimer().
 *
 * @param tid the ID of the timer to destroy
 */
void
GrDestroyTimer (GR_TIMER_ID tid)
{
    GR_TIMER  *timer;
    GR_TIMER  *prev_timer;

	SERVER_LOCK();
    
    /* Find the timer structure that corresponds to "tid" */
    timer = GsFindTimer (tid);
    if (timer == NULL) {
		SERVER_UNLOCK();
        return;
	}

    if (tid == cache_timer_id) 
    {
        cache_timer_id = 0;
        cache_timer = NULL;
    }

    /* Delete the timer from the device independent engine layer */
    GdDestroyTimer (timer->timer);

    /* Pull the timer out of the servers list */
    if (list_timer == timer)
    {
        list_timer = timer->next;
    }
    else 
    {
        prev_timer = list_timer;
        while (prev_timer->next != timer)
        {
            prev_timer = prev_timer->next;
        }
        prev_timer->next = timer->next;
    }
    free (timer);

	SERVER_UNLOCK();
}
#endif /* MW_FEATURE_TIMERS */


/**
 * Sets new server portrait mode and redraws all windows.
 *
 * @param portraitmode New portrait mode.
 */
void
GrSetPortraitMode(int portraitmode)
{
	SERVER_LOCK();
	GsSetPortraitMode(portraitmode);
	SERVER_UNLOCK();
}

/**
 * Returns the current information for the pointer
 *
 * @param mwin	Window the mouse is current in
 * @param x	Current X pos of mouse (from root)
 * @param y	Current Y pos of mouse (from root)
 * @param bmask Current button mask
 */
void 
GrQueryPointer(GR_WINDOW_ID *mwin, GR_COORD *x, GR_COORD *y, GR_BUTTON *bmask)
{
	SERVER_LOCK();
	*mwin = mousewp->id;
	*x = cursorx;
	*y = cursory;
	*bmask = curbuttons;
	SERVER_UNLOCK();
}

/**
 * Creates a new region from a bitmap mask.
 *
 * @param bitmap	monochrome source bitmap
 * @param width		width of source bitmap
 * @param height	height of source bitmap
 */
GR_REGION_ID
GrNewBitmapRegion(GR_BITMAP *bitmap, GR_SIZE width, GR_SIZE height)
{
#if DYNAMICREGIONS
	GR_REGION *regionp;
	GR_REGION_ID id;

	SERVER_LOCK();

	if (!(regionp = malloc(sizeof(GR_REGION)))) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return 0;
	}

	regionp->rgn = GdAllocBitmapRegion(bitmap, width, height);
	regionp->id = nextregionid++;
	regionp->owner = curclient;
	regionp->next = listregionp;

	listregionp = regionp;
	id = regionp->id;
	
	SERVER_UNLOCK();
	
	return id;
#else
	return 0;
#endif
}

/**
 * Sets the bounding region of the specified window, not
 * to be confused with a GC clip region.  The bounding region
 * is used to implement non-rectangular windows.
 * A window is defined by two regions: the bounding region
 * and the clip region.  The bounding region defines the area
 * within the parent window that the window will occupy, including
 * border.  The clip region is the subset of the bounding region
 * that is available for subwindows and graphics.  The area between
 * the bounding region and the clip region is defined to be the
 * border of the window.
 * Currently, only the window bounding region is implemented.
 *
 * @param wid		window id
 * @param rid		region id
 * @param type	region type, bounding or clip mask
 */
void
GrSetWindowRegion(GR_WINDOW_ID wid, GR_REGION_ID rid, int type)
{
#if DYNAMICREGIONS
	GR_WINDOW *wp;
	GR_REGION *region;
	MWCLIPREGION *newregion;

	SERVER_LOCK();

	/*FIXME clip window region not yet implemented*/

	if (!(wp = GsFindWindow(wid))) {
		GsError(GR_ERROR_BAD_WINDOW_ID, wid);
		SERVER_UNLOCK();
		return;
	}

	if (rid) {
		if (!(region = GsFindRegion(rid))) {
			GsError(GR_ERROR_BAD_REGION_ID, rid);
			SERVER_UNLOCK();
			return;
		}

		if (!(newregion = GdAllocRegion())) {
			GsError(GR_ERROR_MALLOC_FAILED, 0);
			SERVER_UNLOCK();
			return;
		}

		GdCopyRegion(newregion, region->rgn);
	} else newregion = NULL;

	if (wp->clipregion)
		GdDestroyRegion(wp->clipregion);
	wp->clipregion = newregion;

	SERVER_UNLOCK();
#endif
}

/**
 * This passes transform data to the mouse input engine.
 *
 * @param trans the GR_TRANSFORM structure that contains the transform data
 * for the filter, or NULL for raw mode.
 */
void
GrSetTransform(GR_TRANSFORM *trans)
{
	SERVER_LOCK();
	GdSetTransform(trans);
	SERVER_UNLOCK();
}

/**
 * Grab a key for a specific window.
 *
 * @param id Window to send event to.
 * @param key MWKEY value.
 * @param type The type of reservation to make.  Valid values are
 *             #GR_GRAB_HOTKEY_EXCLUSIVE,
 *             #GR_GRAB_HOTKEY, 
 *             #GR_GRAB_EXCLUSIVE and
 *             #GR_GRAB_EXCLUSIVE_MOUSE.
 * @return #GR_TRUE on success, #GR_FALSE on error.
 */
GR_BOOL
GrGrabKey(GR_WINDOW_ID id, GR_KEY key, int type)
{
	GR_GRABBED_KEY *keygrab;
	GR_GRABBED_KEY *last_keygrab;

	if ((unsigned)type > GR_GRAB_MAX)
		return GR_FALSE;

	SERVER_LOCK();

	/* Check we can do the grab. Look for previous grabs on the same key. */
	last_keygrab = NULL;
	for (keygrab = list_grabbed_keys; keygrab != NULL; 
	     keygrab = keygrab->next) {
	     	last_keygrab = keygrab; /* Save the last non-NULL pointer */
		if (keygrab->key == key) {
			if ((keygrab->wid == id)
			 && (keygrab->type == type)
			 && (keygrab->owner == curclient)) {
				/*
				 * Already there.  Success.
				 */
				SERVER_UNLOCK();
				return GR_TRUE;
			}
			else if ((type != GR_GRAB_HOTKEY)
			      && (keygrab->type != GR_GRAB_HOTKEY)) {
				/*
				 * Attempting to have two exclusive
				 * reservations.  Fail.
				 */
				SERVER_UNLOCK();
				return GR_FALSE;
			}
		}
	}

	/* Create a GR_GRABBED_KEY */
	keygrab = (GR_GRABBED_KEY *)malloc(sizeof(GR_GRABBED_KEY));
	if (keygrab == NULL) {
		GsError(GR_ERROR_MALLOC_FAILED, 0);
		SERVER_UNLOCK();
		return GR_FALSE;
	}

	/* Fill in the structure. */
	keygrab->key = key;
	keygrab->wid = id;
	keygrab->type = type;
	keygrab->owner = curclient;
	
	/* 
	 * Link into the servers list.  We must have all GR_GRAB_HOTKEY
	 * events for a particular key after any other grabs for that
	 * key.  We accomplish this simply by adding GR_GRAB_HOTKEY
	 * grabs to the end of the list, and all other types to the
	 * beginning.
	 */
	if ((type != GR_GRAB_HOTKEY) || (last_keygrab == NULL)) {
		/* Add to start of list (or list is empty). */
		keygrab->next = list_grabbed_keys;
		list_grabbed_keys = keygrab;
	} else {
		/* Add to end of list. */
		keygrab->next = NULL;
		last_keygrab->next = keygrab;
	}

	SERVER_UNLOCK();
	return GR_TRUE;
}

/**
 * Ungrab a key for a specific window.
 *
 * @param id window to stop key grab.
 * @param key MWKEY value.
 */
void
GrUngrabKey(GR_WINDOW_ID id, GR_KEY key)
{
	GR_GRABBED_KEY *keygrab;
	GR_GRABBED_KEY **keygrab_prev_next;

	SERVER_LOCK();

	keygrab_prev_next = &list_grabbed_keys;
	keygrab           =  list_grabbed_keys;
	while (keygrab != NULL) {
		if ((keygrab->key == key) && (keygrab->wid == id) &&
		    (keygrab->owner == curclient)) {
			*keygrab_prev_next = keygrab->next;
			free(keygrab);
			SERVER_UNLOCK();
			return;
		}
		keygrab_prev_next = &keygrab->next;
		keygrab           =  keygrab->next;
	}

	SERVER_UNLOCK();
}

int
GrSnapScreenToImage(const char *path,GR_COORD x, GR_COORD y, 
							GR_SIZE width,	GR_SIZE height)
{
	int ret;
	SERVER_LOCK();
	ret = GdSnapToImage(rootwp->psd, x,y,
					width, height,path);
	SERVER_UNLOCK();
	return ret;
}

/*
 * Sends generic message to target wid.
 * return 0 if successful, otherwise -1.
 */
int
GrSendMsg(GR_WINDOW_ID wid, void * msg, int bytes)
{
	GR_WINDOW *wp;
	GR_EVENT_MSG *emp;		/* general msg event */
	GR_EVENT_CLIENT	*ecp;	/* current event client */
	int ret = -1;

	SERVER_LOCK();

	if (!(wp = GsFindWindow(wid))) {
		//mask "GsError", because it can lead nano-x to exit, and application will be exit too.
		//GsError(GR_ERROR_BAD_WINDOW_ID, wid);
		DPRINTF("nano-X: ERROR (Bad window id: %d) !\n,",wid);
		goto bail;
	}

	// deliver msg to all clients.
	for (ecp = wp->eventclients; ecp; ecp = ecp->next) {
		if ((ecp->eventmask & GR_EVENT_MASK_MSG) == 0)
			continue;
		
		emp = (GR_EVENT_MSG *) GsAllocEvent(ecp->client);
		if (emp == NULL)
			continue;
			
		emp->type = GR_EVENT_TYPE_MSG;
		emp->wid = wid;
		emp->bytes = bytes;
		memcpy(emp->msg, msg, bytes);
		ret = 0;
	}

 bail:
	SERVER_UNLOCK();
	return ret;
}

