src/x11/nanox.c

/*
 * nanox.c
 *
 * Replacements for some comomon Xlib functions
 * Licence: The wxWidgets licence
 */

#include "wx/setup.h"

#if wxUSE_NANOX

#ifdef __GNUG__
#pragma implementation "Xlib.h"
#endif

#include <ctype.h>
#include <malloc.h>
#include <string.h>
#include <stdio.h>
#include "wx/defs.h"
#include "wx/x11/nanox/X11/Xlib.h"

/* Expands to some compatibility functions (see XtoNX.h) */

STATIC_FUNCTIONS

static GR_PALETTE* s_globalColormap = 0;

Colormap DefaultColormapOfScreen(Screen* screen)
{
    if (!s_globalColormap)
    {
        s_globalColormap = (GR_PALETTE*) malloc(sizeof(GR_PALETTE));

        GrGetSystemPalette(s_globalColormap);
    }

    return s_globalColormap;
}

int XSetGraphicsExposures( Display* display, GC gc, Bool graphics_exposures)
{
    return Success ;
}

int XWarpPointer( Display* display, Window srcW, Window destW,
                 int srcX, int srcY,
                 unsigned int srcWidth,
                 unsigned int srcHeight,
                 int destX, int destY)
{
    GrMoveCursor(destX, destY);
    return Success;
}

int XSetInputFocus(Display* display, Window focus, int revert_to, Time time)
{
    GrSetFocus(focus);
    return Success;
}

int XGetInputFocus(Display* display, Window* focus_return, int* revert_to_return)
{
    * focus_return = GrGetFocus();
    * revert_to_return = 0;
    return Success;
}

int XGrabPointer(Display* display, Window grab_window,
                 Bool owner_events, unsigned int event_mask,
                 int pointer_mode, int keyboard_mode,
                 Window confine_to, Cursor cursor, Time time)
{
    /* According to comments in srvevent.c in Nano-X, the pointer
     * is implicitly grabbed when a mouse button is down.
     * We may be able to simulate this further in the event loop.
     */
    return Success;
}

int XUngrabPointer(Display* display, Time time)
{
    return Success;
}

int XCopyArea(Display* display, Drawable src, Drawable dest, GC gc,
              int src_x, int src_y, unsigned int width, unsigned int height,
              int dest_x, int dest_y)
{
    GrCopyArea(dest, gc, dest_x, dest_y,
			width, height, src,
			src_x, src_y, 0);
    return Success;
}

int XCopyPlane(Display* display, Drawable src, Drawable dest, GC gc,
              int src_x, int src_y, unsigned int width, unsigned int height,
              int dest_x, int dest_y, unsigned long plane)
{
    GrCopyArea(dest, gc, dest_x, dest_y,
			width, height, src,
			src_x, src_y, 0);
    return Success;
}

#if 0
typedef struct {
  GR_WINDOW_ID wid;		/* window id (or 0 if no such window) */
  GR_WINDOW_ID parent;		/* parent window id */
  GR_WINDOW_ID child;		/* first child window id (or 0) */
  GR_WINDOW_ID sibling;		/* next sibling window id (or 0) */
  GR_BOOL inputonly;		/* TRUE if window is input only */
  GR_BOOL mapped;		/* TRUE if window is mapped */
  GR_COUNT unmapcount;		/* reasons why window is unmapped */
  GR_COORD x;			/* absolute x position of window */
  GR_COORD y;			/* absolute y position of window */
  GR_SIZE width;		/* width of window */
  GR_SIZE height;		/* height of window */
  GR_SIZE bordersize;		/* size of border */
  GR_COLOR bordercolor;		/* color of border */
  GR_COLOR background;		/* background color */
  GR_EVENT_MASK eventmask;	/* current event mask for this client */
  GR_WM_PROPS props;		/* window properties */
  GR_CURSOR_ID cursor;		/* cursor id*/
  unsigned long processid;	/* process id of owner*/
} GR_WINDOW_INFO;

typedef struct {
     int x, y;		      /* location of window */
     int width, height;       /* width and height of window */
     int border_width;	      /* border width of window */
     int depth; 	      /* depth of window */
     Visual *visual;	      /* the associated visual structure */
     Window root;	      /* root of screen containing window */
     int class; 	      /* InputOutput, InputOnly*/
     int bit_gravity;	      /* one of the bit gravity values */
     int win_gravity;	      /* one of the window gravity values */
     int backing_store;       /* NotUseful, WhenMapped, Always */
     unsigned long backing_planes;/* planes to be preserved if possible */
     unsigned long backing_pixel;/* value to be used when restoring planes */
     Bool save_under;	      /* boolean, should bits under be saved? */
     Colormap colormap;       /* color map to be associated with window */
     Bool map_installed;      /* boolean, is color map currently installed*/
     int map_state;	      /* IsUnmapped, IsUnviewable, IsViewable */
     long all_event_masks;    /* set of events all people have interest in*/
     long your_event_mask;    /* my event mask */
     long do_not_propagate_mask;/* set of events that should not propagate */
     Bool override_redirect;  /* boolean value for override-redirect */
     Screen *screen;	      /* back pointer to correct screen */
} XWindowAttributes;

#endif


Status XGetWindowAttributes(Display* display, Window w,
                            XWindowAttributes* window_attributes)
{
    GR_WINDOW_INFO info;
    Window parent = 0;
    GrFlush();
    GrGetWindowInfo(w, & info);

    window_attributes->x = info.x;
    window_attributes->y = info.y;
    window_attributes->width = info.width;
    window_attributes->height = info.height;
    window_attributes->border_width = info.bordersize;
    window_attributes->depth = 0;
    window_attributes->visual = NULL;
    window_attributes->root = 0;
    window_attributes->_class = info.inputonly ? InputOnly : InputOutput ;
    window_attributes->bit_gravity = 0;
    window_attributes->win_gravity = 0;
    window_attributes->backing_store = 0;
    window_attributes->backing_planes = 0;
    window_attributes->backing_pixel = 0;
    window_attributes->save_under = FALSE;
    window_attributes->colormap = DefaultColormapOfScreen(0);
    window_attributes->map_installed = FALSE;
    window_attributes->map_state = info.mapped ? IsViewable : IsUnmapped ;
    window_attributes->all_event_masks = 0;
    window_attributes->do_not_propagate_mask = 0;
    window_attributes->override_redirect = FALSE;
    window_attributes->screen = NULL;

    /* We need to check if any parents are unmapped,
     * or we will report a window as mapped when it is not.
     */
    parent = info.parent;
    while (parent)
    {
        GrGetWindowInfo(parent, & info);
        if (info.mapped == 0)
            window_attributes->map_state = IsUnmapped;

        parent = info.parent;
    }

    return 1;
}

static XErrorHandler* g_ErrorHandler = NULL;

void DefaultNanoXErrorHandler(GR_EVENT_ERROR* ep)
{
    if (g_ErrorHandler)
    {
        XErrorEvent errEvent;
        errEvent.type = ep->type;
        errEvent.display = NULL;
        errEvent.resourceid = ep->id;
        errEvent.serial = 0;
        errEvent.error_code = ep->code;
        errEvent.request_code = 0;
        errEvent.minor_code = 0;
        (*g_ErrorHandler)(NULL, & errEvent);
    }
}

XErrorHandler XSetErrorHandler (XErrorHandler handler)
{
    XErrorHandler oldHandler = g_ErrorHandler;
    g_ErrorHandler = handler;
    GrSetErrorHandler(DefaultNanoXErrorHandler);
    return oldHandler;
}

static Screen s_screen;
Screen *XScreenOfDisplay(Display*		display,
                         int screen_number)
{
    /* TODO: fill in the members. See Xlib.h */
    return & s_screen;
}

int DisplayWidth(Display* display, int screen)
{
    return _display.display_width;
}

int DisplayHeight(Display* display, int screen)
{
    return _display.display_height;
}

int DefaultDepth(Display* display, int screen)
{
    return _display.display_bpp;
}

int XAllocColor(Display* display, Colormap cmap,
                XColor* color)
{
    GR_PIXELVAL pixel;
    GrFindColor(GR_RGB(color->red, color->green, color->blue), & pixel);
    color->pixel = pixel;
    return 1;
}

typedef struct {
    const char* name;
    unsigned int red;
    unsigned int green;
    unsigned int blue;
} _wxColourEntry;

static _wxColourEntry _wxColourDatabase[] =
{
    { "WHITE", 255, 255, 255 },
    { "BLACK", 0, 0, 0 },
    { "RED", 255, 0, 0 },
    { "GREEN", 0, 255, 0 },
    { "BLUE", 0, 255, 255 },
    { "GREY", 128, 128, 128 },
    { "GRAY", 128, 128, 128 },
    { "LIGHT GREY", 192, 192, 192 },
    { "LIGHT GRAY", 192, 192, 192 },
    { "DARK GREY", 32, 32, 32 },
    { "DARK GRAY", 32, 32, 32 },
    { "CYAN", 0, 255, 255 },
    { "MAGENTA", 255, 255, 0 },

    /* TODO: the rest */
    { NULL, 0, 0, 0 }
};

int XParseColor(Display* display, Colormap cmap,
                const char* cname, XColor* color)
{
    int i = 0;
    for (;;)
    {
        if (!_wxColourDatabase[i].name)
            break;
        else
        {
            if (strcmp(cname, _wxColourDatabase[i].name) == 0)
            {
                color->red = _wxColourDatabase[i].red;
                color->green = _wxColourDatabase[i].green;
                color->blue = _wxColourDatabase[i].blue;

                return 1;
            }
            i ++;
        }
    }

    /* Not found: use black */
    color->red = 0;
    color->green = 0;
    color->blue = 0;

    return 0;
}

int XDrawLine(Display* display, Window win, GC gc,
              int x1, int y1, int x2, int y2)
{
    GR_POINT points[2];
    points[0].x = x1;
    points[0].y = y1;
    points[1].x = x2;
    points[1].y = y2;

    GrDrawLines(win, gc, points, 2);
    return 1;
}

int XTextExtents( XFontStruct* font, char* s, int len, int* direction,
                  int* ascent, int* descent2, XCharStruct* overall)
{
    GR_SIZE retwidth, retheight, retbase;
    GR_GC_ID gc = GrNewGC();

    *ascent = font->info.baseline;
    *direction = 1; /* ? */
    *descent2 = 0; /* ? */

    GrSetGCFont(gc, font->fid);

    /* TODO need to set the relevant flags for the character set.
     * A good trick might be to pass a wxString instead of char*
     * to this function.
     */

    GrGetGCTextSize(gc, s, len, GR_TFASCII, & retwidth,
                    & retheight, & retbase);
    if (overall)
    {
        overall->width = retwidth;
        overall->lbearing = 0;
        overall->rbearing = 0;
        overall->ascent = *ascent;
        overall->descent = 0;
        overall->attributes = 0;
    }

    GrDestroyGC(gc);

    return 1;
}

XFontStruct* XLoadQueryFont(Display* display, const char* fontSpec)
{
    /* TODO: map fontSpec to something sensible for Nano-X */
    char *fontName = NULL;
    XFontStruct* fontInfo = malloc(sizeof(XFontStruct));
    fontInfo->fid = GrCreateFont(fontName, 0, 0);
    GrGetFontInfo(fontInfo->fid, & fontInfo->info);
    printf("Warning: should not call XLoadQueryFont since font spec is not used in Nano-X.\n");
    return fontInfo;
}

int XFreeFont(Display* display, XFontStruct* fontStruct)
{
    GrDestroyFont(fontStruct->fid);
    free(fontStruct);
    return 1;
}

int XQueryColor(Display* display, Colormap cmap, XColor* color)
{
    /* cmap is a GR_PALETTE */
    if (color->pixel < cmap->count)
    {
        color->red = cmap->palette[color->pixel].r;
        color->green = cmap->palette[color->pixel].g;
        color->blue = cmap->palette[color->pixel].b;
        return 1;
    }
    else
        return 0;
}

int XConfigureWindow(Display* display, Window w, int mask, XWindowChanges* changes)
{
    if ((mask & CWX) && (mask & CWY))
        GrMoveWindow(w, changes->x, changes->y);
    if ((mask & CWWidth) && (mask & CWHeight))
        GrResizeWindow(w, changes->width, changes->height);
    if (mask & CWBorderWidth)
    {
        /* TODO */
    }
    if (mask & CWSibling)
    {
        /* TODO */
    }
    if (mask & CWStackMode)
    {
        /* TODO */
    }
    return 1;
}

int XTranslateCoordinates(Display* display, Window srcWindow, Window destWindow, int srcX, int srcY, int* destX, int* destY, Window* childReturn)
{
    int offx = 0;
    int offy = 0;

    Window w = srcWindow;
    while (w != GR_ROOT_WINDOW_ID)
    {
        GR_WINDOW_INFO info;
        GrGetWindowInfo(w, & info);
        w = info.parent;

        offx += info.x ;
        offy += info.y ;
    }

    w = destWindow;

    while (w != GR_ROOT_WINDOW_ID)
    {
        GR_WINDOW_INFO info;
        GrGetWindowInfo(w, & info);
        w = info.parent;

        offx -= info.x ;
        offy -= info.y ;
    }

    *destX = srcX + offx;
    *destY = srcY + offy;

    if (childReturn)
        *childReturn = 0;

    return 1;
}

/* Should not really be necessary but in no-optimize mode
 * gcc complains that wxNoop is not found if wxNoop is inline.
 */

void wxNoop()
{
}

#endif
  /* wxUSE_NANOX */
Commit	Line	Data
	1	/*
	2	* nanox.c
	3	*
	4	* Replacements for some comomon Xlib functions
	5	* Licence: The wxWidgets licence
	6	*/
	7
	8	#include "wx/setup.h"
	9
	10	#if wxUSE_NANOX
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "Xlib.h"
	14	#endif
	15
	16	#include <ctype.h>
	17	#include <malloc.h>
	18	#include <string.h>
	19	#include <stdio.h>
	20	#include "wx/defs.h"
	21	#include "wx/x11/nanox/X11/Xlib.h"
	22
	23	/* Expands to some compatibility functions (see XtoNX.h) */
	24
	25	STATIC_FUNCTIONS
	26
	27	static GR_PALETTE* s_globalColormap = 0;
	28
	29	Colormap DefaultColormapOfScreen(Screen* screen)
	30	{
	31	if (!s_globalColormap)
	32	{
	33	s_globalColormap = (GR_PALETTE*) malloc(sizeof(GR_PALETTE));
	34
	35	GrGetSystemPalette(s_globalColormap);
	36	}
	37
	38	return s_globalColormap;
	39	}
	40
	41	int XSetGraphicsExposures( Display* display, GC gc, Bool graphics_exposures)
	42	{
	43	return Success ;
	44	}
	45
	46	int XWarpPointer( Display* display, Window srcW, Window destW,
	47	int srcX, int srcY,
	48	unsigned int srcWidth,
	49	unsigned int srcHeight,
	50	int destX, int destY)
	51	{
	52	GrMoveCursor(destX, destY);
	53	return Success;
	54	}
	55
	56	int XSetInputFocus(Display* display, Window focus, int revert_to, Time time)
	57	{
	58	GrSetFocus(focus);
	59	return Success;
	60	}
	61
	62	int XGetInputFocus(Display* display, Window* focus_return, int* revert_to_return)
	63	{
	64	* focus_return = GrGetFocus();
	65	* revert_to_return = 0;
	66	return Success;
	67	}
	68
	69	int XGrabPointer(Display* display, Window grab_window,
	70	Bool owner_events, unsigned int event_mask,
	71	int pointer_mode, int keyboard_mode,
	72	Window confine_to, Cursor cursor, Time time)
	73	{
	74	/* According to comments in srvevent.c in Nano-X, the pointer
	75	* is implicitly grabbed when a mouse button is down.
	76	* We may be able to simulate this further in the event loop.
	77	*/
	78	return Success;
	79	}
	80
	81	int XUngrabPointer(Display* display, Time time)
	82	{
	83	return Success;
	84	}
	85
	86	int XCopyArea(Display* display, Drawable src, Drawable dest, GC gc,
	87	int src_x, int src_y, unsigned int width, unsigned int height,
	88	int dest_x, int dest_y)
	89	{
	90	GrCopyArea(dest, gc, dest_x, dest_y,
	91	width, height, src,
	92	src_x, src_y, 0);
	93	return Success;
	94	}
	95
	96	int XCopyPlane(Display* display, Drawable src, Drawable dest, GC gc,
	97	int src_x, int src_y, unsigned int width, unsigned int height,
	98	int dest_x, int dest_y, unsigned long plane)
	99	{
	100	GrCopyArea(dest, gc, dest_x, dest_y,
	101	width, height, src,
	102	src_x, src_y, 0);
	103	return Success;
	104	}
	105
	106	#if 0
	107	typedef struct {
	108	GR_WINDOW_ID wid; /* window id (or 0 if no such window) */
	109	GR_WINDOW_ID parent; /* parent window id */
	110	GR_WINDOW_ID child; /* first child window id (or 0) */
	111	GR_WINDOW_ID sibling; /* next sibling window id (or 0) */
	112	GR_BOOL inputonly; /* TRUE if window is input only */
	113	GR_BOOL mapped; /* TRUE if window is mapped */
	114	GR_COUNT unmapcount; /* reasons why window is unmapped */
	115	GR_COORD x; /* absolute x position of window */
	116	GR_COORD y; /* absolute y position of window */
	117	GR_SIZE width; /* width of window */
	118	GR_SIZE height; /* height of window */
	119	GR_SIZE bordersize; /* size of border */
	120	GR_COLOR bordercolor; /* color of border */
	121	GR_COLOR background; /* background color */
	122	GR_EVENT_MASK eventmask; /* current event mask for this client */
	123	GR_WM_PROPS props; /* window properties */
	124	GR_CURSOR_ID cursor; /* cursor id*/
	125	unsigned long processid; /* process id of owner*/
	126	} GR_WINDOW_INFO;
	127
	128	typedef struct {
	129	int x, y; /* location of window */
	130	int width, height; /* width and height of window */
	131	int border_width; /* border width of window */
	132	int depth; /* depth of window */
	133	Visual visual; / the associated visual structure */
	134	Window root; /* root of screen containing window */
	135	int class; /* InputOutput, InputOnly*/
	136	int bit_gravity; /* one of the bit gravity values */
	137	int win_gravity; /* one of the window gravity values */
	138	int backing_store; /* NotUseful, WhenMapped, Always */
	139	unsigned long backing_planes;/* planes to be preserved if possible */
	140	unsigned long backing_pixel;/* value to be used when restoring planes */
	141	Bool save_under; /* boolean, should bits under be saved? */
	142	Colormap colormap; /* color map to be associated with window */
	143	Bool map_installed; /* boolean, is color map currently installed*/
	144	int map_state; /* IsUnmapped, IsUnviewable, IsViewable */
	145	long all_event_masks; /* set of events all people have interest in*/
	146	long your_event_mask; /* my event mask */
	147	long do_not_propagate_mask;/* set of events that should not propagate */
	148	Bool override_redirect; /* boolean value for override-redirect */
	149	Screen screen; / back pointer to correct screen */
	150	} XWindowAttributes;
	151
	152	#endif
	153
	154
	155	Status XGetWindowAttributes(Display* display, Window w,
	156	XWindowAttributes* window_attributes)
	157	{
	158	GR_WINDOW_INFO info;
	159	Window parent = 0;
	160	GrFlush();
	161	GrGetWindowInfo(w, & info);
	162
	163	window_attributes->x = info.x;
	164	window_attributes->y = info.y;
	165	window_attributes->width = info.width;
	166	window_attributes->height = info.height;
	167	window_attributes->border_width = info.bordersize;
	168	window_attributes->depth = 0;
	169	window_attributes->visual = NULL;
	170	window_attributes->root = 0;
	171	window_attributes->_class = info.inputonly ? InputOnly : InputOutput ;
	172	window_attributes->bit_gravity = 0;
	173	window_attributes->win_gravity = 0;
	174	window_attributes->backing_store = 0;
	175	window_attributes->backing_planes = 0;
	176	window_attributes->backing_pixel = 0;
	177	window_attributes->save_under = FALSE;
	178	window_attributes->colormap = DefaultColormapOfScreen(0);
	179	window_attributes->map_installed = FALSE;
	180	window_attributes->map_state = info.mapped ? IsViewable : IsUnmapped ;
	181	window_attributes->all_event_masks = 0;
	182	window_attributes->do_not_propagate_mask = 0;
	183	window_attributes->override_redirect = FALSE;
	184	window_attributes->screen = NULL;
	185
	186	/* We need to check if any parents are unmapped,
	187	* or we will report a window as mapped when it is not.
	188	*/
	189	parent = info.parent;
	190	while (parent)
	191	{
	192	GrGetWindowInfo(parent, & info);
	193	if (info.mapped == 0)
	194	window_attributes->map_state = IsUnmapped;
	195
	196	parent = info.parent;
	197	}
	198
	199	return 1;
	200	}
	201
	202	static XErrorHandler* g_ErrorHandler = NULL;
	203
	204	void DefaultNanoXErrorHandler(GR_EVENT_ERROR* ep)
	205	{
	206	if (g_ErrorHandler)
	207	{
	208	XErrorEvent errEvent;
	209	errEvent.type = ep->type;
	210	errEvent.display = NULL;
	211	errEvent.resourceid = ep->id;
	212	errEvent.serial = 0;
	213	errEvent.error_code = ep->code;
	214	errEvent.request_code = 0;
	215	errEvent.minor_code = 0;
	216	(*g_ErrorHandler)(NULL, & errEvent);
	217	}
	218	}
	219
	220	XErrorHandler XSetErrorHandler (XErrorHandler handler)
	221	{
	222	XErrorHandler oldHandler = g_ErrorHandler;
	223	g_ErrorHandler = handler;
	224	GrSetErrorHandler(DefaultNanoXErrorHandler);
	225	return oldHandler;
	226	}
	227
	228	static Screen s_screen;
	229	Screen XScreenOfDisplay(Display display,
	230	int screen_number)
	231	{
	232	/* TODO: fill in the members. See Xlib.h */
	233	return & s_screen;
	234	}
	235
	236	int DisplayWidth(Display* display, int screen)
	237	{
	238	return _display.display_width;
	239	}
	240
	241	int DisplayHeight(Display* display, int screen)
	242	{
	243	return _display.display_height;
	244	}
	245
	246	int DefaultDepth(Display* display, int screen)
	247	{
	248	return _display.display_bpp;
	249	}
	250
	251	int XAllocColor(Display* display, Colormap cmap,
	252	XColor* color)
	253	{
	254	GR_PIXELVAL pixel;
	255	GrFindColor(GR_RGB(color->red, color->green, color->blue), & pixel);
	256	color->pixel = pixel;
	257	return 1;
	258	}
	259
	260	typedef struct {
	261	const char* name;
	262	unsigned int red;
	263	unsigned int green;
	264	unsigned int blue;
	265	} _wxColourEntry;
	266
	267	static _wxColourEntry _wxColourDatabase[] =
	268	{
	269	{ "WHITE", 255, 255, 255 },
	270	{ "BLACK", 0, 0, 0 },
	271	{ "RED", 255, 0, 0 },
	272	{ "GREEN", 0, 255, 0 },
	273	{ "BLUE", 0, 255, 255 },
	274	{ "GREY", 128, 128, 128 },
	275	{ "GRAY", 128, 128, 128 },
	276	{ "LIGHT GREY", 192, 192, 192 },
	277	{ "LIGHT GRAY", 192, 192, 192 },
	278	{ "DARK GREY", 32, 32, 32 },
	279	{ "DARK GRAY", 32, 32, 32 },
	280	{ "CYAN", 0, 255, 255 },
	281	{ "MAGENTA", 255, 255, 0 },
	282
	283	/* TODO: the rest */
	284	{ NULL, 0, 0, 0 }
	285	};
	286
	287	int XParseColor(Display* display, Colormap cmap,
	288	const char* cname, XColor* color)
	289	{
	290	int i = 0;
	291	for (;;)
	292	{
	293	if (!_wxColourDatabase[i].name)
	294	break;
	295	else
	296	{
	297	if (strcmp(cname, _wxColourDatabase[i].name) == 0)
	298	{
	299	color->red = _wxColourDatabase[i].red;
	300	color->green = _wxColourDatabase[i].green;
	301	color->blue = _wxColourDatabase[i].blue;
	302
	303	return 1;
	304	}
	305	i ++;
	306	}
	307	}
	308
	309	/* Not found: use black */
	310	color->red = 0;
	311	color->green = 0;
	312	color->blue = 0;
	313
	314	return 0;
	315	}
	316
	317	int XDrawLine(Display* display, Window win, GC gc,
	318	int x1, int y1, int x2, int y2)
	319	{
	320	GR_POINT points[2];
	321	points[0].x = x1;
	322	points[0].y = y1;
	323	points[1].x = x2;
	324	points[1].y = y2;
	325
	326	GrDrawLines(win, gc, points, 2);
	327	return 1;
	328	}
	329
	330	int XTextExtents( XFontStruct* font, char* s, int len, int* direction,
	331	int* ascent, int* descent2, XCharStruct* overall)
	332	{
	333	GR_SIZE retwidth, retheight, retbase;
	334	GR_GC_ID gc = GrNewGC();
	335
	336	*ascent = font->info.baseline;
	337	direction = 1; / ? */
	338	descent2 = 0; / ? */
	339
	340	GrSetGCFont(gc, font->fid);
	341
	342	/* TODO need to set the relevant flags for the character set.
	343	* A good trick might be to pass a wxString instead of char*
	344	* to this function.
	345	*/
	346
	347	GrGetGCTextSize(gc, s, len, GR_TFASCII, & retwidth,
	348	& retheight, & retbase);
	349	if (overall)
	350	{
	351	overall->width = retwidth;
	352	overall->lbearing = 0;
	353	overall->rbearing = 0;
	354	overall->ascent = *ascent;
	355	overall->descent = 0;
	356	overall->attributes = 0;
	357	}
	358
	359	GrDestroyGC(gc);
	360
	361	return 1;
	362	}
	363
	364	XFontStruct* XLoadQueryFont(Display* display, const char* fontSpec)
	365	{
	366	/* TODO: map fontSpec to something sensible for Nano-X */
	367	char *fontName = NULL;
	368	XFontStruct* fontInfo = malloc(sizeof(XFontStruct));
	369	fontInfo->fid = GrCreateFont(fontName, 0, 0);
	370	GrGetFontInfo(fontInfo->fid, & fontInfo->info);
	371	printf("Warning: should not call XLoadQueryFont since font spec is not used in Nano-X.\n");
	372	return fontInfo;
	373	}
	374
	375	int XFreeFont(Display* display, XFontStruct* fontStruct)
	376	{
	377	GrDestroyFont(fontStruct->fid);
	378	free(fontStruct);
	379	return 1;
	380	}
	381
	382	int XQueryColor(Display* display, Colormap cmap, XColor* color)
	383	{
	384	/* cmap is a GR_PALETTE */
	385	if (color->pixel < cmap->count)
	386	{
	387	color->red = cmap->palette[color->pixel].r;
	388	color->green = cmap->palette[color->pixel].g;
	389	color->blue = cmap->palette[color->pixel].b;
	390	return 1;
	391	}
	392	else
	393	return 0;
	394	}
	395
	396	int XConfigureWindow(Display* display, Window w, int mask, XWindowChanges* changes)
	397	{
	398	if ((mask & CWX) && (mask & CWY))
	399	GrMoveWindow(w, changes->x, changes->y);
	400	if ((mask & CWWidth) && (mask & CWHeight))
	401	GrResizeWindow(w, changes->width, changes->height);
	402	if (mask & CWBorderWidth)
	403	{
	404	/* TODO */
	405	}
	406	if (mask & CWSibling)
	407	{
	408	/* TODO */
	409	}
	410	if (mask & CWStackMode)
	411	{
	412	/* TODO */
	413	}
	414	return 1;
	415	}
	416
	417	int XTranslateCoordinates(Display* display, Window srcWindow, Window destWindow, int srcX, int srcY, int* destX, int* destY, Window* childReturn)
	418	{
	419	int offx = 0;
	420	int offy = 0;
	421
	422	Window w = srcWindow;
	423	while (w != GR_ROOT_WINDOW_ID)
	424	{
	425	GR_WINDOW_INFO info;
	426	GrGetWindowInfo(w, & info);
	427	w = info.parent;
	428
	429	offx += info.x ;
	430	offy += info.y ;
	431	}
	432
	433	w = destWindow;
	434
	435	while (w != GR_ROOT_WINDOW_ID)
	436	{
	437	GR_WINDOW_INFO info;
	438	GrGetWindowInfo(w, & info);
	439	w = info.parent;
	440
	441	offx -= info.x ;
	442	offy -= info.y ;
	443	}
	444
	445	*destX = srcX + offx;
	446	*destY = srcY + offy;
	447
	448	if (childReturn)
	449	*childReturn = 0;
	450
	451	return 1;
	452	}
	453
	454	/* Should not really be necessary but in no-optimize mode
	455	* gcc complains that wxNoop is not found if wxNoop is inline.
	456	*/
	457
	458	void wxNoop()
	459	{
	460	}
	461
	462	#endif
	463	/* wxUSE_NANOX */