#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"
-Colormap DefaultColormapOfScreen(Screen /* screen */)
-{
- static Colormap s_globalColormap;
- static bool s_init = FALSE;
+/* Expands to some compatibility functions (see XtoNX.h) */
+
+STATIC_FUNCTIONS
+
+static GR_PALETTE* s_globalColormap = 0;
- if (!s_init)
+Colormap DefaultColormapOfScreen(Screen* screen)
+{
+ if (!s_globalColormap)
{
- GrGetSystemPalette(& s_globalColormap);
- s_init = TRUE;
+ 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 */
\ No newline at end of file
+ /* wxUSE_NANOX */
projects / wxWidgets.git / blobdiff