--- sourceforge.net/trunk/rdesktop/xwin.c 2001/01/06 03:47:04 25 +++ sourceforge.net/trunk/rdesktop/xwin.c 2001/06/20 13:54:48 28 @@ -19,26 +19,85 @@ */ #include +#include #include #include "rdesktop.h" extern int width; extern int height; extern BOOL motion; +extern BOOL grab_keyboard; +extern BOOL fullscreen; +extern int private_colormap; +static int bpp; +static int depth; static Display *display; static Window wnd; static GC gc; static Visual *visual; -static XIM IM; +static uint32 *colmap; + +#define Ctrans(col) ( private_colormap ? col : colmap[col]) + +#define L_ENDIAN +int screen_msbfirst = 0; + +static uint8 *translate(int width, int height, uint8 *data); + +static int rop2_map[] = { + GXclear, /* 0 */ + GXnor, /* DPon */ + GXandInverted, /* DPna */ + GXcopyInverted, /* Pn */ + GXandReverse, /* PDna */ + GXinvert, /* Dn */ + GXxor, /* DPx */ + GXnand, /* DPan */ + GXand, /* DPa */ + GXequiv, /* DPxn */ + GXnoop, /* D */ + GXorInverted, /* DPno */ + GXcopy, /* P */ + GXorReverse, /* PDno */ + GXor, /* DPo */ + GXset /* 1 */ +}; + +static void +xwin_set_function(uint8 rop2) +{ + static uint8 last_rop2 = ROP2_COPY; + + if (last_rop2 != rop2) + { + XSetFunction(display, gc, rop2_map[rop2]); + last_rop2 = rop2; + } +} + +static void +xwin_grab_keyboard() +{ + XGrabKeyboard(display, wnd, True, GrabModeAsync, GrabModeAsync, + CurrentTime); +} + +static void +xwin_ungrab_keyboard() +{ + XUngrabKeyboard(display, CurrentTime); +} BOOL ui_create_window(char *title) { - Screen *screen; XSetWindowAttributes attribs; + XClassHint *classhints; + XSizeHints *sizehints; unsigned long input_mask; - int i; + XPixmapFormatValues *pfm; + int count; display = XOpenDisplay(NULL); if (display == NULL) @@ -47,50 +106,101 @@ return False; } - /* Check the screen supports 8-bit depth. */ - screen = DefaultScreenOfDisplay(display); - for (i = 0; i < screen->ndepths; i++) - if (screen->depths[i].depth == 8) - break; + visual = DefaultVisual(display, DefaultScreen(display)); + depth = DefaultDepth(display, DefaultScreen(display)); + pfm = XListPixmapFormats(display, &count); + if (pfm != NULL) + { + while (count--) + { + if ((pfm + count)->depth == depth + && (pfm + count)->bits_per_pixel > bpp) + { + bpp = (pfm + count)->bits_per_pixel; + } + } + XFree(pfm); + } - if (i >= screen->ndepths) + if (bpp < 8) { - ERROR("8-bit depth required (in this version).\n"); + ERROR("Less than 8 bpp not currently supported.\n"); XCloseDisplay(display); return False; } - visual = DefaultVisual(display, DefaultScreen(display)); + width &= ~3; /* make width nicely divisible */ - attribs.background_pixel = - BlackPixel(display, DefaultScreen(display)); + attribs.background_pixel = BlackPixel(display, DefaultScreen(display)); attribs.backing_store = Always; + + if (fullscreen) + { + attribs.override_redirect = True; + width = WidthOfScreen(DefaultScreenOfDisplay(display)); + height = HeightOfScreen(DefaultScreenOfDisplay(display)); + XSetInputFocus(display, PointerRoot, RevertToPointerRoot, + CurrentTime); + } + else + { + attribs.override_redirect = False; + } + wnd = XCreateWindow(display, DefaultRootWindow(display), - 0, 0, width, height, 0, 8, InputOutput, visual, - CWBackingStore | CWBackPixel, &attribs); + 0, 0, width, height, 0, CopyFromParent, + InputOutput, CopyFromParent, + CWBackingStore | CWBackPixel | CWOverrideRedirect, + &attribs); XStoreName(display, wnd, title); - XMapWindow(display, wnd); + + classhints = XAllocClassHint(); + if (classhints != NULL) + + { + classhints->res_name = "rdesktop"; + classhints->res_class = "rdesktop"; + XSetClassHint(display, wnd, classhints); + XFree(classhints); + } + + sizehints = XAllocSizeHints(); + if (sizehints) + { + sizehints->flags = + PPosition | PSize | PMinSize | PMaxSize | PBaseSize; + sizehints->min_width = width; + sizehints->max_width = width; + sizehints->min_height = height; + sizehints->max_height = height; + sizehints->base_width = width; + sizehints->base_height = height; + XSetWMNormalHints(display, wnd, sizehints); + XFree(sizehints); + } input_mask = KeyPressMask | KeyReleaseMask; input_mask |= ButtonPressMask | ButtonReleaseMask; if (motion) input_mask |= PointerMotionMask; + if (grab_keyboard) + input_mask |= EnterWindowMask | LeaveWindowMask; XSelectInput(display, wnd, input_mask); gc = XCreateGC(display, wnd, 0, NULL); - IM = XOpenIM(display, NULL, NULL, NULL); + XMapWindow(display, wnd); return True; } void ui_destroy_window() { - XCloseIM(IM); XFreeGC(display, gc); XDestroyWindow(display, wnd); XCloseDisplay(display); + display = NULL; } static uint8 @@ -103,16 +213,44 @@ switch (key) { - case 0x62: /* left arrow */ - return 0x48; - case 0x64: /* up arrow */ - return 0x4b; - case 0x66: /* down arrow */ - return 0x4d; - case 0x68: /* right arrow */ - return 0x50; - case 0x73: /* Windows key */ - DEBUG("CHECKPOINT\n"); + case 0x61: /* home */ + return 0x47 | 0x80; + case 0x62: /* up arrow */ + return 0x48 | 0x80; + case 0x63: /* page up */ + return 0x49 | 0x80; + case 0x64: /* left arrow */ + return 0x4b | 0x80; + case 0x66: /* right arrow */ + return 0x4d | 0x80; + case 0x67: /* end */ + return 0x4f | 0x80; + case 0x68: /* down arrow */ + return 0x50 | 0x80; + case 0x69: /* page down */ + return 0x51 | 0x80; + case 0x6a: /* insert */ + return 0x52 | 0x80; + case 0x6b: /* delete */ + return 0x53 | 0x80; + case 0x6c: /* keypad enter */ + return 0x1c | 0x80; + case 0x6d: /* right ctrl */ + return 0x1d | 0x80; + case 0x6f: /* ctrl - print screen */ + return 0x37 | 0x80; + case 0x70: /* keypad '/' */ + return 0x35 | 0x80; + case 0x71: /* right alt */ + return 0x38 | 0x80; + case 0x72: /* ctrl break */ + return 0x46 | 0x80; + case 0x73: /* left window key */ + return 0xff; /* real scancode is 5b */ + case 0x74: /* right window key */ + return 0xff; /* real scancode is 5c */ + case 0x75: /* menu key */ + return 0x5d | 0x80; } return 0; @@ -145,16 +283,14 @@ if (display == NULL) return; - while (XCheckWindowEvent(display, wnd, 0xffffffff, &event)) + while (XCheckWindowEvent(display, wnd, ~0, &event)) { ev_time = time(NULL); switch (event.type) { case KeyPress: - scancode = - xwin_translate_key(event. - xkey.keycode); + scancode = xwin_translate_key(event.xkey.keycode); if (scancode == 0) break; @@ -163,9 +299,7 @@ break; case KeyRelease: - scancode = - xwin_translate_key(event. - xkey.keycode); + scancode = xwin_translate_key(event.xkey.keycode); if (scancode == 0) break; @@ -175,10 +309,7 @@ break; case ButtonPress: - button = - xwin_translate_mouse(event. - xbutton.button); - + button = xwin_translate_mouse(event.xbutton.button); if (button == 0) break; @@ -189,9 +320,7 @@ break; case ButtonRelease: - button = - xwin_translate_mouse(event. - xbutton.button); + button = xwin_translate_mouse(event.xbutton.button); if (button == 0) break; @@ -206,6 +335,17 @@ MOUSE_FLAG_MOVE, event.xmotion.x, event.xmotion.y); + break; + + case EnterNotify: + if (grab_keyboard) + xwin_grab_keyboard(); + break; + + case LeaveNotify: + if (grab_keyboard) + xwin_ungrab_keyboard(); + break; } } } @@ -221,15 +361,20 @@ { XImage *image; Pixmap bitmap; + uint8 *tdata; + tdata = (private_colormap ? data : translate(width, height, data)); + bitmap = XCreatePixmap(display, wnd, width, height, depth); + image = + XCreateImage(display, visual, + depth, ZPixmap, + 0, tdata, width, height, BitmapPad(display), 0); - bitmap = XCreatePixmap(display, wnd, width, height, 8); - - image = XCreateImage(display, visual, 8, ZPixmap, 0, - data, width, height, 8, width); - XSetFunction(display, gc, GXcopy); + xwin_set_function(ROP2_COPY); XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height); - XFree(image); + XFree(image); + if (!private_colormap) + xfree(tdata); return (HBITMAP) bitmap; } @@ -238,12 +383,19 @@ int width, int height, uint8 *data) { XImage *image; + uint8 *tdata = + (private_colormap ? data : translate(width, height, data)); + image = + XCreateImage(display, visual, depth, ZPixmap, 0, tdata, width, + height, BitmapPad(display), 0); - image = XCreateImage(display, visual, 8, ZPixmap, 0, - data, width, height, 8, width); - XSetFunction(display, gc, GXcopy); + xwin_set_function(ROP2_COPY); + + /* Window */ XPutImage(display, wnd, gc, image, 0, 0, x, y, cx, cy); XFree(image); + if (!private_colormap) + xfree(tdata); } void @@ -252,6 +404,127 @@ XFreePixmap(display, (Pixmap) bmp); } +HCURSOR +ui_create_cursor(unsigned int x, unsigned int y, int width, + int height, uint8 *mask, uint8 *data) +{ + XImage *imagecursor; + XImage *imagemask; + Pixmap maskbitmap, cursorbitmap; + Cursor cursor; + XColor bg, fg; + GC lgc; + int i, x1, y1, scanlinelen; + uint8 *cdata, *cmask; + uint8 c; + cdata = (uint8 *) malloc(sizeof(uint8) * width * height); + if (!cdata) + return NULL; + scanlinelen = (width + 7) >> 3; + cmask = (uint8 *) malloc(sizeof(uint8) * scanlinelen * height); + if (!cmask) + { + free(cdata); + return NULL; + } + i = (height - 1) * scanlinelen; + + if (!screen_msbfirst) + { + while (i >= 0) + { + for (x1 = 0; x1 < scanlinelen; x1++) + { + c = *(mask++); + cmask[i + x1] = + ((c & 0x1) << 7) | ((c & 0x2) << 5) | + ((c & 0x4) << 3) | ((c & 0x8) << 1) | + ((c & 0x10) >> 1) | ((c & 0x20) >> 3) + | ((c & 0x40) >> 5) | ((c & 0x80) >> + 7); + } + i -= scanlinelen; + } + } + else + { + while (i >= 0) + { + for (x1 = 0; x1 < scanlinelen; x1++) + { + cmask[i + x1] = *(mask++); + } + i -= scanlinelen; + } + } + + + fg.red = 0; + fg.blue = 0; + fg.green = 0; + fg.flags = DoRed | DoBlue | DoGreen; + bg.red = 65535; + bg.blue = 65535; + bg.green = 65535; + bg.flags = DoRed | DoBlue | DoGreen; + maskbitmap = XCreatePixmap(display, wnd, width, height, 1); + cursorbitmap = XCreatePixmap(display, wnd, width, height, 1); + lgc = XCreateGC(display, maskbitmap, 0, NULL); + XSetFunction(display, lgc, GXcopy); + imagemask = + XCreateImage(display, visual, 1, XYBitmap, 0, cmask, width, + height, 8, 0); + imagecursor = + XCreateImage(display, visual, 1, XYBitmap, 0, cdata, width, + height, 8, 0); + for (y1 = height - 1; y1 >= 0; y1--) + for (x1 = 0; x1 < width; x1++) + { + if (data[0] >= 0x80 || data[1] >= 0x80 + || data[2] >= 0x80) + if (XGetPixel(imagemask, x1, y1)) + + { + XPutPixel(imagecursor, x1, y1, 0); + XPutPixel(imagemask, x1, y1, 0); /* mask is blank for text cursor! */ + } + + else + XPutPixel(imagecursor, x1, y1, 1); + + else + XPutPixel(imagecursor, x1, y1, + XGetPixel(imagemask, x1, y1)); + data += 3; + } + XPutImage(display, maskbitmap, lgc, imagemask, 0, 0, 0, 0, width, + height); + XPutImage(display, cursorbitmap, lgc, imagecursor, 0, 0, 0, 0, width, + height); XFree(imagemask); + XFree(imagecursor); + free(cmask); + free(cdata); + XFreeGC(display, lgc); + cursor = + XCreatePixmapCursor(display, cursorbitmap, maskbitmap, &fg, + &bg, x, y); + XFreePixmap(display, maskbitmap); + XFreePixmap(display, cursorbitmap); + return (HCURSOR) cursor; +} + +void +ui_set_cursor(HCURSOR cursor) +{ + XDefineCursor(display, wnd, (Cursor) cursor); +} + +void +ui_destroy_cursor(HCURSOR cursor) +{ + XFreeCursor(display, (Cursor) cursor); +} + HGLYPH ui_create_glyph(int width, int height, uint8 *data) { @@ -288,29 +561,52 @@ HCOLOURMAP ui_create_colourmap(COLOURMAP *colours) { - COLOURENTRY *entry; - XColor *xcolours, *xentry; - Colormap map; - int i, ncolours = colours->ncolours; - - xcolours = xmalloc(sizeof(XColor) * ncolours); - for (i = 0; i < ncolours; i++) + if (!private_colormap) { - entry = &colours->colours[i]; - xentry = &xcolours[i]; - - xentry->pixel = i; - xentry->red = entry->red << 8; - xentry->blue = entry->blue << 8; - xentry->green = entry->green << 8; - xentry->flags = DoRed | DoBlue | DoGreen; + COLOURENTRY *entry; + int i, ncolours = colours->ncolours; + uint32 *nc = xmalloc(sizeof(*colmap) * ncolours); + for (i = 0; i < ncolours; i++) + { + XColor xc; + entry = &colours->colours[i]; + xc.red = entry->red << 8; + xc.green = entry->green << 8; + xc.blue = entry->blue << 8; + XAllocColor(display, + DefaultColormap(display, + DefaultScreen(display)), + &xc); + /* XXX Check return value */ + nc[i] = xc.pixel; + } + return nc; } + else + { + COLOURENTRY *entry; + XColor *xcolours, *xentry; + Colormap map; + int i, ncolours = colours->ncolours; + xcolours = xmalloc(sizeof(XColor) * ncolours); + for (i = 0; i < ncolours; i++) + { + entry = &colours->colours[i]; + xentry = &xcolours[i]; - map = XCreateColormap(display, wnd, visual, AllocAll); - XStoreColors(display, map, xcolours, ncolours); + xentry->pixel = i; + xentry->red = entry->red << 8; + xentry->blue = entry->blue << 8; + xentry->green = entry->green << 8; + xentry->flags = DoRed | DoBlue | DoGreen; + } + + map = XCreateColormap(display, wnd, visual, AllocAll); + XStoreColors(display, map, xcolours, ncolours); - xfree(xcolours); - return (HCOLOURMAP) map; + xfree(xcolours); + return (HCOLOURMAP) map; + } } void @@ -322,7 +618,17 @@ void ui_set_colourmap(HCOLOURMAP map) { - XSetWindowColormap(display, wnd, (Colormap) map); + + /* XXX, change values of all pixels on the screen if the new colmap + * doesn't have the same values as the old one? */ + if (!private_colormap) + colmap = map; + else + { + XSetWindowColormap(display, wnd, (Colormap) map); + if (fullscreen) + XInstallColormap(display, (Colormap) map); + } } void @@ -355,31 +661,6 @@ XBell(display, 0); } -static int rop2_map[] = { - GXclear, /* 0 */ - GXnor, /* DPon */ - GXandInverted, /* DPna */ - GXcopyInverted, /* Pn */ - GXandReverse, /* PDna */ - GXinvert, /* Dn */ - GXxor, /* DPx */ - GXnand, /* DPan */ - GXand, /* DPa */ - GXequiv, /* DPxn */ - GXnoop, /* D */ - GXorInverted, /* DPno */ - GXcopy, /* P */ - GXorReverse, /* PDno */ - GXor, /* DPo */ - GXset /* 1 */ -}; - -static void -xwin_set_function(uint8 rop2) -{ - XSetFunction(display, gc, rop2_map[rop2]); -} - void ui_destblt(uint8 opcode, /* dest */ int x, int y, int cx, int cy) @@ -396,21 +677,24 @@ { Display *dpy = display; Pixmap fill; + uint8 i, ipattern[8]; xwin_set_function(opcode); switch (brush->style) { case 0: /* Solid */ - XSetForeground(dpy, gc, fgcolour); + XSetForeground(dpy, gc, Ctrans(fgcolour)); XFillRectangle(dpy, wnd, gc, x, y, cx, cy); break; case 3: /* Pattern */ - fill = (Pixmap) ui_create_glyph(8, 8, brush->pattern); + for (i = 0; i != 8; i++) + ipattern[i] = ~brush->pattern[i]; + fill = (Pixmap) ui_create_glyph(8, 8, ipattern); - XSetForeground(dpy, gc, fgcolour); - XSetBackground(dpy, gc, bgcolour); + XSetForeground(dpy, gc, Ctrans(fgcolour)); + XSetBackground(dpy, gc, Ctrans(bgcolour)); XSetFillStyle(dpy, gc, FillOpaqueStippled); XSetStipple(dpy, gc, fill); @@ -470,6 +754,12 @@ brush, bgcolour, fgcolour); break; + case 0xc0: + ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy); + ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, + fgcolour); + break; + default: NOTIMP("triblt 0x%x\n", opcode); ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy); @@ -483,7 +773,7 @@ { xwin_set_function(opcode); - XSetForeground(display, gc, pen->colour); + XSetForeground(display, gc, Ctrans(pen->colour)); XDrawLine(display, wnd, gc, startx, starty, endx, endy); } @@ -494,7 +784,7 @@ { xwin_set_function(ROP2_COPY); - XSetForeground(display, gc, colour); + XSetForeground(display, gc, Ctrans(colour)); XFillRectangle(display, wnd, gc, x, y, cx, cy); } @@ -508,8 +798,8 @@ xwin_set_function(ROP2_COPY); - XSetForeground(display, gc, fgcolour); + XSetForeground(display, gc, Ctrans(fgcolour)); switch (mixmode) { case MIX_TRANSPARENT: @@ -521,9 +811,13 @@ break; case MIX_OPAQUE: - XSetBackground(display, gc, bgcolour); - XCopyPlane(display, pixmap, wnd, gc, - srcx, srcy, cx, cy, x, y, 1); + XSetBackground(display, gc, Ctrans(bgcolour)); +/* XCopyPlane (display, pixmap, back_pixmap, back_gc, srcx, srcy, cx, cy, x, y, 1); */ + XSetStipple(display, gc, pixmap); + XSetFillStyle(display, gc, FillOpaqueStippled); + XSetTSOrigin(display, gc, x, y); + XFillRectangle(display, wnd, gc, x, y, cx, cy); + XSetFillStyle(display, gc, FillSolid); break; default: @@ -538,16 +832,15 @@ int bgcolour, int fgcolour, uint8 *text, uint8 length) { FONTGLYPH *glyph; - int i; + int i, xyoffset; + + xwin_set_function(ROP2_COPY); + XSetForeground(display, gc, Ctrans(bgcolour)); if (boxcx > 1) - { - ui_rect(boxx, boxy, boxcx, boxcy, bgcolour); - } + XFillRectangle(display, wnd, gc, boxx, boxy, boxcx, boxcy); else if (mixmode == MIX_OPAQUE) - { - ui_rect(clipx, clipy, clipcx, clipcy, bgcolour); - } + XFillRectangle(display, wnd, gc, clipx, clipy, clipcx, clipcy); /* Paint text, character by character */ for (i = 0; i < length; i++) @@ -555,8 +848,25 @@ glyph = cache_get_font(font, text[i]); if (!(flags & TEXT2_IMPLICIT_X)) - x += text[++i]; + { + xyoffset = text[++i]; + if ((xyoffset & 0x80)) + { + if (flags & 0x04) /* vertical text */ + y += text[++i] | (text[++i] << 8); + else + x += text[++i] | (text[++i] << 8); + } + else + { + if (flags & 0x04) /* vertical text */ + y += xyoffset; + else + x += xyoffset; + } + + } if (glyph != NULL) { ui_draw_glyph(mixmode, x + (short) glyph->offset, @@ -574,12 +884,21 @@ void ui_desktop_save(uint32 offset, int x, int y, int cx, int cy) { + Pixmap pix; XImage *image; - image = XGetImage(display, wnd, x, y, cx, cy, 0xffffffff, ZPixmap); - cache_put_desktop(offset, cx, cy, image->bytes_per_line, image->data); - XFree(image->data); - XFree(image); + pix = XCreatePixmap(display, wnd, cx, cy, depth); + xwin_set_function(ROP2_COPY); + + XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0); + image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap); + + offset *= bpp/8; + cache_put_desktop(offset, cx, cy, image->bytes_per_line, + bpp/8, image->data); + + XDestroyImage(image); + XFreePixmap(display, pix); } void @@ -588,13 +907,407 @@ XImage *image; uint8 *data; - data = cache_get_desktop(offset, cx, cy); + offset *= bpp/8; + data = cache_get_desktop(offset, cx, cy, bpp/8); if (data == NULL) return; - - image = XCreateImage(display, visual, 8, ZPixmap, 0, - data, cx, cy, 32, cx); - XSetFunction(display, gc, GXcopy); + image = + XCreateImage(display, visual, + depth, ZPixmap, + 0, data, cx, cy, BitmapPad(display), + cx * bpp/8); + xwin_set_function(ROP2_COPY); XPutImage(display, wnd, gc, image, 0, 0, x, y, cx, cy); XFree(image); } + +/* unroll defines, used to make the loops a bit more readable... */ +#define unroll8Expr(uexp) uexp uexp uexp uexp uexp uexp uexp uexp +#define unroll8Lefts(uexp) case 7: uexp \ + case 6: uexp \ + case 5: uexp \ + case 4: uexp \ + case 3: uexp \ + case 2: uexp \ + case 1: uexp + +static uint8 * +translate(int width, int height, uint8 *data) +{ + uint32 i; + uint32 size = width * height; + uint8 *d2 = xmalloc(size * bpp/8); + uint8 *d3 = d2; + uint32 pix; + i = (size & ~0x7); + + /* XXX: where are the bits swapped??? */ +#ifdef L_ENDIAN /* little-endian */ + /* big-endian screen */ + if (screen_msbfirst) + { + switch (bpp) + { + case 32: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix >> 24; + *d3++ = pix >> 16; + *d3++ = pix >> 8; + *d3++ = pix;) i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix >> + 24; + *d3++ = + pix >> + 16; + *d3++ = + pix >> 8; + *d3++ = + pix;)} + break; + case 24: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix >> 16; + *d3++ = pix >> 8; + *d3++ = pix;) i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix >> + 16; + *d3++ = + pix >> 8; + *d3++ = + pix;)} + break; + case 16: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix >> 8; + *d3++ = pix;) i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix >> 8; + *d3++ = + pix;)} + break; + case 8: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix;)} + break; + } + } + else + { /* little-endian screen */ + switch (bpp) + { + case 32: + while (i) + { + unroll8Expr(*((uint32 *) d3) = + colmap[*data++]; + d3 += sizeof(uint32); + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(* + ((uint32 + *) d3) += colmap[*data++]; +d3 += sizeof(uint32); + )} + break; + case 24: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + *d3++ = pix >> 8; + *d3++ = pix >> 16; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix; + *d3++ = + pix >> 8; + *d3++ = + pix >> + 16;)} + break; + case 16: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + *d3++ = pix >> 8; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix; + *d3++ = + pix >> 8; + )} + break; + case 8: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix;)} + } + } + +#else /* bigendian-compiled */ + if (screen_msbfirst) + { + /* big-endian screen */ + switch (bpp) + { + case 32: + while (i) + { + unroll8Expr(*((uint32 *) d3) = + colmap[*data++]; + d3 += sizeof(uint32); + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(* + ((uint32 + *) d3) += colmap[*data++]; +d3 += sizeof(uint32); + )} + break; + case 24: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + *d3++ = pix >> 8; + *d3++ = pix >> 16; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix; + *d3++ = + pix >> 8; + *d3++ = + pix >> + 16;)} + break; + case 16: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + *d3++ = pix >> 8; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix; + *d3++ = + pix >> 8; + )} + break; + case 8: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix;)} + } + } + else + { + /* little-endian screen */ + switch (bpp) + { + case 32: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + *d3++ = pix >> 8; + *d3++ = pix >> 16; + *d3++ = pix >> 24; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix; + *d3++ = + pix >> 8; + *d3++ = + pix >> + 16; + *d3++ = + pix >> + 24;)} + break; + case 24: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + *d3++ = pix >> 8; + *d3++ = pix >> 16; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix; + *d3++ = + pix >> 8; + *d3++ = + pix >> + 16;)} + break; + case 16: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + *d3++ = pix >> 8; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix; + *d3++ = + pix >> 8; + )} + break; + case 8: + while (i) + { + unroll8Expr(pix = colmap[*data++]; + *d3++ = pix; + )i -= 8; + } + i = (size & 0x7); + if (i != 0) + switch (i) + { + unroll8Lefts(pix = + colmap + [*data++]; + *d3++ = + pix;)} + } + } +#endif + + return d2; +}