X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/5ed738a766bb06539893bd424759e75926c43e15..7d1f4c3ff01b09105c07d5e176a14428c834975e:/src/x11/nanox.c diff --git a/src/x11/nanox.c b/src/x11/nanox.c index ec9ca97b32..0aafc49442 100644 --- a/src/x11/nanox.c +++ b/src/x11/nanox.c @@ -8,21 +8,455 @@ #if wxUSE_NANOX +#ifdef __GNUG__ +#pragma implementation "Xlib.h" +#endif + +#include +#include +#include +#include +#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 */