--- sourceforge.net/trunk/rdesktop/xwin.c 2004/02/25 18:28:52 617 +++ sourceforge.net/trunk/rdesktop/xwin.c 2005/03/10 22:48:15 844 @@ -1,7 +1,7 @@ /* -*- c-basic-offset: 8 -*- rdesktop: A Remote Desktop Protocol client. User interface services - X Window System - Copyright (C) Matthew Chapman 1999-2002 + Copyright (C) Matthew Chapman 1999-2005 This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -30,6 +30,8 @@ extern int g_width; extern int g_height; +extern int g_xpos; +extern int g_ypos; extern BOOL g_sendmotion; extern BOOL g_fullscreen; extern BOOL g_grab_keyboard; @@ -43,8 +45,12 @@ static int g_x_socket; static Screen *g_screen; Window g_wnd; +extern uint32 g_embed_wnd; BOOL g_enable_compose = False; +BOOL g_Unobscured; /* used for screenblt */ static GC g_gc = NULL; +static GC g_create_bitmap_gc = NULL; +static GC g_create_glyph_gc = NULL; static Visual *g_visual; static int g_depth; static int g_bpp; @@ -56,6 +62,7 @@ static Atom g_protocol_atom, g_kill_atom; static BOOL g_focused; static BOOL g_mouse_in_wnd; +static BOOL g_arch_match = False; /* set to True if RGB XServer and little endian */ /* endianness */ static BOOL g_host_be; @@ -64,7 +71,7 @@ static int g_red_shift_l, g_blue_shift_l, g_green_shift_l; /* software backing store */ -BOOL g_ownbackstore = True; /* We can't rely on external BackingStore */ +extern BOOL g_ownbackstore; static Pixmap g_backstore = 0; /* Moving in single app mode */ @@ -112,8 +119,33 @@ XFillRectangle(g_display, g_ownbackstore ? g_backstore : g_wnd, g_gc, x, y, cx, cy); \ } +#define FILL_POLYGON(p,np)\ +{ \ + XFillPolygon(g_display, g_wnd, g_gc, p, np, Complex, CoordModePrevious); \ + if (g_ownbackstore) \ + XFillPolygon(g_display, g_backstore, g_gc, p, np, Complex, CoordModePrevious); \ +} + +#define DRAW_ELLIPSE(x,y,cx,cy,m)\ +{ \ + switch (m) \ + { \ + case 0: /* Outline */ \ + XDrawArc(g_display, g_wnd, g_gc, x, y, cx, cy, 0, 360*64); \ + if (g_ownbackstore) \ + XDrawArc(g_display, g_backstore, g_gc, x, y, cx, cy, 0, 360*64); \ + break; \ + case 1: /* Filled */ \ + XFillArc(g_display, g_ownbackstore ? g_backstore : g_wnd, g_gc, x, y, \ + cx, cy, 0, 360*64); \ + if (g_ownbackstore) \ + XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y); \ + break; \ + } \ +} + /* colour maps */ -BOOL g_owncolmap = False; +extern BOOL g_owncolmap; static Colormap g_xcolmap; static uint32 *g_colmap = NULL; @@ -165,49 +197,44 @@ (unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS); } -static PixelColour -split_colour15(uint32 colour) -{ - PixelColour rv; - rv.red = (colour & 0x7c00) >> 7; - rv.green = (colour & 0x03e0) >> 2; - rv.blue = (colour & 0x001f) << 3; - return rv; -} - -static PixelColour -split_colour16(uint32 colour) -{ - PixelColour rv; - rv.red = (colour & 0xf800) >> 8; - rv.green = (colour & 0x07e0) >> 3; - rv.blue = (colour & 0x001f) << 3; - return rv; -} - -static PixelColour -split_colour24(uint32 colour) -{ - PixelColour rv; - rv.blue = (colour & 0xff0000) >> 16; - rv.green = (colour & 0x00ff00) >> 8; - rv.red = (colour & 0x0000ff); - return rv; +#define SPLITCOLOUR15(colour, rv) \ +{ \ + rv.red = ((colour >> 7) & 0xf8) | ((colour >> 12) & 0x7); \ + rv.green = ((colour >> 2) & 0xf8) | ((colour >> 8) & 0x7); \ + rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7); \ } -static uint32 -make_colour(PixelColour pc) -{ - return (((pc.red >> g_red_shift_r) << g_red_shift_l) - | ((pc.green >> g_green_shift_r) << g_green_shift_l) - | ((pc.blue >> g_blue_shift_r) << g_blue_shift_l)); +#define SPLITCOLOUR16(colour, rv) \ +{ \ + rv.red = ((colour >> 8) & 0xf8) | ((colour >> 13) & 0x7); \ + rv.green = ((colour >> 3) & 0xfc) | ((colour >> 9) & 0x3); \ + rv.blue = ((colour << 3) & 0xf8) | ((colour >> 2) & 0x7); \ +} \ + +#define SPLITCOLOUR24(colour, rv) \ +{ \ + rv.blue = (colour & 0xff0000) >> 16; \ + rv.green = (colour & 0x00ff00) >> 8; \ + rv.red = (colour & 0x0000ff); \ } +#define MAKECOLOUR(pc) \ + ((pc.red >> g_red_shift_r) << g_red_shift_l) \ + | ((pc.green >> g_green_shift_r) << g_green_shift_l) \ + | ((pc.blue >> g_blue_shift_r) << g_blue_shift_l) \ + #define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); } #define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | (x & 0xff00)); } #define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \ x = (x << 16) | (x >> 16); } +#define BOUT16(o, x) { *(o++) = x >> 8; *(o++) = x; } +#define BOUT24(o, x) { *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; } +#define BOUT32(o, x) { *(o++) = x >> 24; *(o++) = x >> 16; *(o++) = x >> 8; *(o++) = x; } +#define LOUT16(o, x) { *(o++) = x; *(o++) = x >> 8; } +#define LOUT24(o, x) { *(o++) = x; *(o++) = x >> 8; *(o++) = x >> 16; } +#define LOUT32(o, x) { *(o++) = x; *(o++) = x >> 8; *(o++) = x >> 16; *(o++) = x >> 24; } + static uint32 translate_colour(uint32 colour) { @@ -215,371 +242,594 @@ switch (g_server_bpp) { case 15: - pc = split_colour15(colour); + SPLITCOLOUR15(colour, pc); break; case 16: - pc = split_colour16(colour); + SPLITCOLOUR16(colour, pc); break; case 24: - pc = split_colour24(colour); + SPLITCOLOUR24(colour, pc); break; } - return make_colour(pc); + return MAKECOLOUR(pc); +} + +/* indent is confused by UNROLL8 */ +/* *INDENT-OFF* */ + +/* repeat and unroll, similar to bitmap.c */ +/* potentialy any of the following translate */ +/* functions can use repeat but just doing */ +/* the most common ones */ + +#define UNROLL8(stm) { stm stm stm stm stm stm stm stm } +/* 2 byte output repeat */ +#define REPEAT2(stm) \ +{ \ + while (out <= end - 8 * 2) \ + UNROLL8(stm) \ + while (out < end) \ + { stm } \ +} +/* 3 byte output repeat */ +#define REPEAT3(stm) \ +{ \ + while (out <= end - 8 * 3) \ + UNROLL8(stm) \ + while (out < end) \ + { stm } \ +} +/* 4 byte output repeat */ +#define REPEAT4(stm) \ +{ \ + while (out <= end - 8 * 4) \ + UNROLL8(stm) \ + while (out < end) \ + { stm } \ } +/* *INDENT-ON* */ static void -translate8to8(uint8 * data, uint8 * out, uint8 * end) +translate8to8(const uint8 * data, uint8 * out, uint8 * end) { while (out < end) *(out++) = (uint8) g_colmap[*(data++)]; } static void -translate8to16(uint8 * data, uint8 * out, uint8 * end) +translate8to16(const uint8 * data, uint8 * out, uint8 * end) { uint16 value; - while (out < end) + if (g_arch_match) { - value = (uint16) g_colmap[*(data++)]; - - if (g_xserver_be) + /* *INDENT-OFF* */ + REPEAT2 + ( + *((uint16 *) out) = g_colmap[*(data++)]; + out += 2; + ) + /* *INDENT-ON* */ + } + else if (g_xserver_be) + { + while (out < end) { - *(out++) = value >> 8; - *(out++) = value; + value = (uint16) g_colmap[*(data++)]; + BOUT16(out, value); } - else + } + else + { + while (out < end) { - *(out++) = value; - *(out++) = value >> 8; + value = (uint16) g_colmap[*(data++)]; + LOUT16(out, value); } } } /* little endian - conversion happens when colourmap is built */ static void -translate8to24(uint8 * data, uint8 * out, uint8 * end) +translate8to24(const uint8 * data, uint8 * out, uint8 * end) { uint32 value; - while (out < end) + if (g_xserver_be) { - value = g_colmap[*(data++)]; - - if (g_xserver_be) + while (out < end) { - *(out++) = value >> 16; - *(out++) = value >> 8; - *(out++) = value; + value = g_colmap[*(data++)]; + BOUT24(out, value); } - else + } + else + { + while (out < end) { - *(out++) = value; - *(out++) = value >> 8; - *(out++) = value >> 16; + value = g_colmap[*(data++)]; + LOUT24(out, value); } } } static void -translate8to32(uint8 * data, uint8 * out, uint8 * end) +translate8to32(const uint8 * data, uint8 * out, uint8 * end) { uint32 value; - while (out < end) + if (g_arch_match) { - value = g_colmap[*(data++)]; - - if (g_xserver_be) + /* *INDENT-OFF* */ + REPEAT4 + ( + *((uint32 *) out) = g_colmap[*(data++)]; + out += 4; + ) + /* *INDENT-ON* */ + } + else if (g_xserver_be) + { + while (out < end) { - *(out++) = value >> 24; - *(out++) = value >> 16; - *(out++) = value >> 8; - *(out++) = value; + value = g_colmap[*(data++)]; + BOUT32(out, value); } - else + } + else + { + while (out < end) { - *(out++) = value; - *(out++) = value >> 8; - *(out++) = value >> 16; - *(out++) = value >> 24; + value = g_colmap[*(data++)]; + LOUT32(out, value); } } } static void -translate15to16(uint16 * data, uint8 * out, uint8 * end) +translate15to16(const uint16 * data, uint8 * out, uint8 * end) { uint16 pixel; uint16 value; + PixelColour pc; - while (out < end) + if (g_xserver_be) { - pixel = *(data++); - - if (g_host_be) + while (out < end) { - BSWAP16(pixel); - } - - value = make_colour(split_colour15(pixel)); - - if (g_xserver_be) - { - *(out++) = value >> 8; - *(out++) = value; + pixel = *(data++); + if (g_host_be) + { + BSWAP16(pixel); + } + SPLITCOLOUR15(pixel, pc); + value = MAKECOLOUR(pc); + BOUT16(out, value); } - else + } + else + { + while (out < end) { - *(out++) = value; - *(out++) = value >> 8; + pixel = *(data++); + if (g_host_be) + { + BSWAP16(pixel); + } + SPLITCOLOUR15(pixel, pc); + value = MAKECOLOUR(pc); + LOUT16(out, value); } } } static void -translate15to24(uint16 * data, uint8 * out, uint8 * end) +translate15to24(const uint16 * data, uint8 * out, uint8 * end) { uint32 value; uint16 pixel; + PixelColour pc; - while (out < end) + if (g_arch_match) { - pixel = *(data++); - - if (g_host_be) - { - BSWAP16(pixel); - } - - value = make_colour(split_colour15(pixel)); - if (g_xserver_be) + /* *INDENT-OFF* */ + REPEAT3 + ( + pixel = *(data++); + SPLITCOLOUR15(pixel, pc); + *(out++) = pc.blue; + *(out++) = pc.green; + *(out++) = pc.red; + ) + /* *INDENT-ON* */ + } + else if (g_xserver_be) + { + while (out < end) { - *(out++) = value >> 16; - *(out++) = value >> 8; - *(out++) = value; + pixel = *(data++); + if (g_host_be) + { + BSWAP16(pixel); + } + SPLITCOLOUR15(pixel, pc); + value = MAKECOLOUR(pc); + BOUT24(out, value); } - else + } + else + { + while (out < end) { - *(out++) = value; - *(out++) = value >> 8; - *(out++) = value >> 16; + pixel = *(data++); + if (g_host_be) + { + BSWAP16(pixel); + } + SPLITCOLOUR15(pixel, pc); + value = MAKECOLOUR(pc); + LOUT24(out, value); } } } static void -translate15to32(uint16 * data, uint8 * out, uint8 * end) +translate15to32(const uint16 * data, uint8 * out, uint8 * end) { uint16 pixel; uint32 value; + PixelColour pc; - while (out < end) + if (g_arch_match) { - pixel = *(data++); - - if (g_host_be) - { - BSWAP16(pixel); - } - - value = make_colour(split_colour15(pixel)); - - if (g_xserver_be) + /* *INDENT-OFF* */ + REPEAT4 + ( + pixel = *(data++); + SPLITCOLOUR15(pixel, pc); + *(out++) = pc.blue; + *(out++) = pc.green; + *(out++) = pc.red; + *(out++) = 0; + ) + /* *INDENT-ON* */ + } + else if (g_xserver_be) + { + while (out < end) { - *(out++) = value >> 24; - *(out++) = value >> 16; - *(out++) = value >> 8; - *(out++) = value; + pixel = *(data++); + if (g_host_be) + { + BSWAP16(pixel); + } + SPLITCOLOUR15(pixel, pc); + value = MAKECOLOUR(pc); + BOUT32(out, value); } - else + } + else + { + while (out < end) { - *(out++) = value; - *(out++) = value >> 8; - *(out++) = value >> 16; - *(out++) = value >> 24; + pixel = *(data++); + if (g_host_be) + { + BSWAP16(pixel); + } + SPLITCOLOUR15(pixel, pc); + value = MAKECOLOUR(pc); + LOUT32(out, value); } } } static void -translate16to16(uint16 * data, uint8 * out, uint8 * end) +translate16to16(const uint16 * data, uint8 * out, uint8 * end) { uint16 pixel; uint16 value; + PixelColour pc; - while (out < end) + if (g_xserver_be) { - pixel = *(data++); - if (g_host_be) { - BSWAP16(pixel); + while (out < end) + { + pixel = *(data++); + BSWAP16(pixel); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + BOUT16(out, value); + } } - - value = make_colour(split_colour16(pixel)); - - if (g_xserver_be) + else { - *(out++) = value >> 8; - *(out++) = value; + while (out < end) + { + pixel = *(data++); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + BOUT16(out, value); + } + } + } + else + { + if (g_host_be) + { + while (out < end) + { + pixel = *(data++); + BSWAP16(pixel); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + LOUT16(out, value); + } } else { - *(out++) = value; - *(out++) = value >> 8; + while (out < end) + { + pixel = *(data++); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + LOUT16(out, value); + } } } } static void -translate16to24(uint16 * data, uint8 * out, uint8 * end) +translate16to24(const uint16 * data, uint8 * out, uint8 * end) { uint32 value; uint16 pixel; + PixelColour pc; - while (out < end) + if (g_arch_match) + { + /* *INDENT-OFF* */ + REPEAT3 + ( + pixel = *(data++); + SPLITCOLOUR16(pixel, pc); + *(out++) = pc.blue; + *(out++) = pc.green; + *(out++) = pc.red; + ) + /* *INDENT-ON* */ + } + else if (g_xserver_be) { - pixel = *(data++); - if (g_host_be) { - BSWAP16(pixel); + while (out < end) + { + pixel = *(data++); + BSWAP16(pixel); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + BOUT24(out, value); + } } - - value = make_colour(split_colour16(pixel)); - - if (g_xserver_be) + else + { + while (out < end) + { + pixel = *(data++); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + BOUT24(out, value); + } + } + } + else + { + if (g_host_be) { - *(out++) = value >> 16; - *(out++) = value >> 8; - *(out++) = value; + while (out < end) + { + pixel = *(data++); + BSWAP16(pixel); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + LOUT24(out, value); + } } else { - *(out++) = value; - *(out++) = value >> 8; - *(out++) = value >> 16; + while (out < end) + { + pixel = *(data++); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + LOUT24(out, value); + } } } } static void -translate16to32(uint16 * data, uint8 * out, uint8 * end) +translate16to32(const uint16 * data, uint8 * out, uint8 * end) { uint16 pixel; uint32 value; + PixelColour pc; - while (out < end) + if (g_arch_match) + { + /* *INDENT-OFF* */ + REPEAT4 + ( + pixel = *(data++); + SPLITCOLOUR16(pixel, pc); + *(out++) = pc.blue; + *(out++) = pc.green; + *(out++) = pc.red; + *(out++) = 0; + ) + /* *INDENT-ON* */ + } + else if (g_xserver_be) { - pixel = *(data++); - if (g_host_be) { - BSWAP16(pixel); + while (out < end) + { + pixel = *(data++); + BSWAP16(pixel); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + BOUT32(out, value); + } } - - value = make_colour(split_colour16(pixel)); - - if (g_xserver_be) + else { - *(out++) = value >> 24; - *(out++) = value >> 16; - *(out++) = value >> 8; - *(out++) = value; + while (out < end) + { + pixel = *(data++); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + BOUT32(out, value); + } + } + } + else + { + if (g_host_be) + { + while (out < end) + { + pixel = *(data++); + BSWAP16(pixel); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + LOUT32(out, value); + } } else { - *(out++) = value; - *(out++) = value >> 8; - *(out++) = value >> 16; - *(out++) = value >> 24; + while (out < end) + { + pixel = *(data++); + SPLITCOLOUR16(pixel, pc); + value = MAKECOLOUR(pc); + LOUT32(out, value); + } } } } static void -translate24to16(uint8 * data, uint8 * out, uint8 * end) +translate24to16(const uint8 * data, uint8 * out, uint8 * end) { uint32 pixel = 0; uint16 value; + PixelColour pc; + while (out < end) { pixel = *(data++) << 16; pixel |= *(data++) << 8; pixel |= *(data++); - - value = (uint16) make_colour(split_colour24(pixel)); - + SPLITCOLOUR24(pixel, pc); + value = MAKECOLOUR(pc); if (g_xserver_be) { - *(out++) = value >> 8; - *(out++) = value; + BOUT16(out, value); } else { - *(out++) = value; - *(out++) = value >> 8; + LOUT16(out, value); } } } static void -translate24to24(uint8 * data, uint8 * out, uint8 * end) +translate24to24(const uint8 * data, uint8 * out, uint8 * end) { uint32 pixel; uint32 value; + PixelColour pc; - while (out < end) + if (g_xserver_be) { - pixel = *(data++) << 16; - pixel |= *(data++) << 8; - pixel |= *(data++); - - value = make_colour(split_colour24(pixel)); - - if (g_xserver_be) + while (out < end) { - *(out++) = value >> 16; - *(out++) = value >> 8; - *(out++) = value; + pixel = *(data++) << 16; + pixel |= *(data++) << 8; + pixel |= *(data++); + SPLITCOLOUR24(pixel, pc); + value = MAKECOLOUR(pc); + BOUT24(out, value); } - else + } + else + { + while (out < end) { - *(out++) = value; - *(out++) = value >> 8; - *(out++) = value >> 16; + pixel = *(data++) << 16; + pixel |= *(data++) << 8; + pixel |= *(data++); + SPLITCOLOUR24(pixel, pc); + value = MAKECOLOUR(pc); + LOUT24(out, value); } } } static void -translate24to32(uint8 * data, uint8 * out, uint8 * end) +translate24to32(const uint8 * data, uint8 * out, uint8 * end) { uint32 pixel; uint32 value; + PixelColour pc; - while (out < end) + if (g_arch_match) { - pixel = *(data++) << 16; - pixel |= *(data++) << 8; - pixel |= *(data++); - - value = make_colour(split_colour24(pixel)); - - if (g_xserver_be) + /* *INDENT-OFF* */ +#ifdef NEED_ALIGN + REPEAT4 + ( + *(out++) = *(data++); + *(out++) = *(data++); + *(out++) = *(data++); + *(out++) = 0; + ) +#else + REPEAT4 + ( + *((uint32 *) out) = *((uint32 *) data); + out += 4; + data += 3; + ) +#endif + /* *INDENT-ON* */ + } + else if (g_xserver_be) + { + while (out < end) { - *(out++) = value >> 24; - *(out++) = value >> 16; - *(out++) = value >> 8; - *(out++) = value; + pixel = *(data++) << 16; + pixel |= *(data++) << 8; + pixel |= *(data++); + SPLITCOLOUR24(pixel, pc); + value = MAKECOLOUR(pc); + BOUT32(out, value); } - else + } + else + { + while (out < end) { - *(out++) = value; - *(out++) = value >> 8; - *(out++) = value >> 16; - *(out++) = value >> 24; + pixel = *(data++) << 16; + pixel |= *(data++) << 8; + pixel |= *(data++); + SPLITCOLOUR24(pixel, pc); + value = MAKECOLOUR(pc); + LOUT32(out, value); } } } @@ -587,9 +837,26 @@ static uint8 * translate_image(int width, int height, uint8 * data) { - int size = width * height * g_bpp / 8; - uint8 *out = (uint8 *) xmalloc(size); - uint8 *end = out + size; + int size; + uint8 *out; + uint8 *end; + + /* if server and xserver bpp match, */ + /* and arch(endian) matches, no need to translate */ + /* just return data */ + if (g_arch_match) + { + if (g_depth == 15 && g_server_bpp == 15) + return data; + if (g_depth == 16 && g_server_bpp == 16) + return data; + if (g_depth == 24 && g_bpp == 24 && g_server_bpp == 24) + return data; + } + + size = width * height * (g_bpp / 8); + out = (uint8 *) xmalloc(size); + end = out + size; switch (g_server_bpp) { @@ -727,6 +994,10 @@ TrueColorVisual = True; } + test = 1; + g_host_be = !(BOOL) (*(uint8 *) (&test)); + g_xserver_be = (ImageByteOrder(g_display) == MSBFirst); + if ((g_server_bpp == 8) && ((!TrueColorVisual) || (g_depth <= 8))) { /* we use a colourmap, so the default visual should do */ @@ -753,6 +1024,22 @@ calculate_shifts(vi.red_mask, &g_red_shift_r, &g_red_shift_l); calculate_shifts(vi.blue_mask, &g_blue_shift_r, &g_blue_shift_l); calculate_shifts(vi.green_mask, &g_green_shift_r, &g_green_shift_l); + + /* if RGB video and everything is little endian */ + if ((vi.red_mask > vi.green_mask && vi.green_mask > vi.blue_mask) && + !g_xserver_be && !g_host_be) + { + if (g_depth <= 16 || (g_red_shift_l == 16 && g_green_shift_l == 8 && + g_blue_shift_l == 0)) + { + g_arch_match = True; + } + } + + if (g_arch_match) + { + DEBUG(("Architectures match, enabling little endian optimisations.\n")); + } } pfm = XListPixmapFormats(g_display, &i); @@ -792,10 +1079,6 @@ g_ownbackstore = True; } - test = 1; - g_host_be = !(BOOL) (*(uint8 *) (&test)); - g_xserver_be = (ImageByteOrder(g_display) == MSBFirst); - /* * Determine desktop size */ @@ -868,7 +1151,8 @@ ui_create_window(void) { uint8 null_pointer_mask[1] = { 0x80 }; - uint8 null_pointer_data[4] = { 0x00, 0x00, 0x00, 0x00 }; + uint8 null_pointer_data[24] = { 0x00 }; + XSetWindowAttributes attribs; XClassHint *classhints; XSizeHints *sizehints; @@ -885,14 +1169,17 @@ attribs.override_redirect = g_fullscreen; attribs.colormap = g_xcolmap; - g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), 0, 0, wndwidth, wndheight, - 0, g_depth, InputOutput, g_visual, - CWBackPixel | CWBackingStore | CWOverrideRedirect | - CWColormap | CWBorderPixel, &attribs); + g_wnd = XCreateWindow(g_display, RootWindowOfScreen(g_screen), g_xpos, g_ypos, wndwidth, + wndheight, 0, g_depth, InputOutput, g_visual, + CWBackPixel | CWBackingStore | CWOverrideRedirect | CWColormap | + CWBorderPixel, &attribs); if (g_gc == NULL) g_gc = XCreateGC(g_display, g_wnd, 0, NULL); + if (g_create_bitmap_gc == NULL) + g_create_bitmap_gc = XCreateGC(g_display, g_wnd, 0, NULL); + if ((g_ownbackstore) && (g_backstore == 0)) { g_backstore = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth); @@ -925,6 +1212,11 @@ XFree(sizehints); } + if (g_embed_wnd) + { + XReparentWindow(g_display, g_wnd, (Window) g_embed_wnd, 0, 0); + } + input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | VisibilityChangeMask | FocusChangeMask; @@ -956,6 +1248,7 @@ XMaskEvent(g_display, VisibilityChangeMask, &xevent); } while (xevent.type != VisibilityNotify); + g_Unobscured = xevent.xvisibility.state == VisibilityUnobscured; g_focused = False; g_mouse_in_wnd = False; @@ -973,6 +1266,39 @@ } void +ui_resize_window() +{ + XSizeHints *sizehints; + Pixmap bs; + + sizehints = XAllocSizeHints(); + if (sizehints) + { + sizehints->flags = PMinSize | PMaxSize; + sizehints->min_width = sizehints->max_width = g_width; + sizehints->min_height = sizehints->max_height = g_height; + XSetWMNormalHints(g_display, g_wnd, sizehints); + XFree(sizehints); + } + + if (!(g_fullscreen || g_embed_wnd)) + { + XResizeWindow(g_display, g_wnd, g_width, g_height); + } + + /* create new backstore pixmap */ + if (g_backstore != 0) + { + bs = XCreatePixmap(g_display, g_wnd, g_width, g_height, g_depth); + XSetForeground(g_display, g_gc, BlackPixelOfScreen(g_screen)); + XFillRectangle(g_display, bs, g_gc, 0, 0, g_width, g_height); + XCopyArea(g_display, g_backstore, bs, g_gc, 0, 0, g_width, g_height, 0, 0); + XFreePixmap(g_display, g_backstore); + g_backstore = bs; + } +} + +void ui_destroy_window(void) { if (g_IC != NULL) @@ -1033,6 +1359,9 @@ switch (xevent.type) { + case VisibilityNotify: + g_Unobscured = xevent.xvisibility.state == VisibilityUnobscured; + break; case ClientMessage: /* the window manager told us to quit */ if ((xevent.xclient.message_type == g_protocol_atom) @@ -1311,12 +1640,9 @@ error("select: %s\n", strerror(errno)); case 0: - /* TODO: if tv.tv_sec just times out - * we will segfault. - * FIXME: - */ - //s_timeout = True; - //rdpdr_check_fds(&rfds, &wfds, (BOOL) True); + /* Abort serial read calls */ + if (s_timeout) + rdpdr_check_fds(&rfds, &wfds, (BOOL) True); continue; } @@ -1363,10 +1689,10 @@ image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0, (char *) tdata, width, height, bitmap_pad, 0); - XPutImage(g_display, bitmap, g_gc, image, 0, 0, 0, 0, width, height); + XPutImage(g_display, bitmap, g_create_bitmap_gc, image, 0, 0, 0, 0, width, height); XFree(image); - if (!g_owncolmap) + if (tdata != data) xfree(tdata); return (HBITMAP) bitmap; } @@ -1405,7 +1731,7 @@ } XFree(image); - if (!g_owncolmap) + if (tdata != data) xfree(tdata); } @@ -1421,12 +1747,12 @@ XImage *image; Pixmap bitmap; int scanline; - GC gc; scanline = (width + 7) / 8; bitmap = XCreatePixmap(g_display, g_wnd, width, height, 1); - gc = XCreateGC(g_display, bitmap, 0, NULL); + if (g_create_glyph_gc == 0) + g_create_glyph_gc = XCreateGC(g_display, bitmap, 0, NULL); image = XCreateImage(g_display, g_visual, 1, ZPixmap, 0, (char *) data, width, height, 8, scanline); @@ -1434,10 +1760,9 @@ image->bitmap_bit_order = MSBFirst; XInitImage(image); - XPutImage(g_display, bitmap, gc, image, 0, 0, 0, 0, width, height); + XPutImage(g_display, bitmap, g_create_glyph_gc, image, 0, 0, 0, 0, width, height); XFree(image); - XFreeGC(g_display, gc); return (HGLYPH) bitmap; } @@ -1729,7 +2054,7 @@ { case 0: /* Solid */ SET_FOREGROUND(fgcolour); - FILL_RECTANGLE(x, y, cx, cy); + FILL_RECTANGLE_BACKSTORE(x, y, cx, cy); break; case 2: /* Hatch */ @@ -1740,7 +2065,7 @@ XSetFillStyle(g_display, g_gc, FillOpaqueStippled); XSetStipple(g_display, g_gc, fill); XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin); - FILL_RECTANGLE(x, y, cx, cy); + FILL_RECTANGLE_BACKSTORE(x, y, cx, cy); XSetFillStyle(g_display, g_gc, FillSolid); XSetTSOrigin(g_display, g_gc, 0, 0); ui_destroy_glyph((HGLYPH) fill); @@ -1750,15 +2075,12 @@ for (i = 0; i != 8; i++) ipattern[7 - i] = brush->pattern[i]; fill = (Pixmap) ui_create_glyph(8, 8, ipattern); - SET_FOREGROUND(bgcolour); SET_BACKGROUND(fgcolour); XSetFillStyle(g_display, g_gc, FillOpaqueStippled); XSetStipple(g_display, g_gc, fill); XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin); - - FILL_RECTANGLE(x, y, cx, cy); - + FILL_RECTANGLE_BACKSTORE(x, y, cx, cy); XSetFillStyle(g_display, g_gc, FillSolid); XSetTSOrigin(g_display, g_gc, 0, 0); ui_destroy_glyph((HGLYPH) fill); @@ -1769,6 +2091,9 @@ } RESET_FUNCTION(opcode); + + if (g_ownbackstore) + XCopyArea(g_display, g_backstore, g_wnd, g_gc, x, y, cx, cy, x, y); } void @@ -1779,8 +2104,18 @@ SET_FUNCTION(opcode); if (g_ownbackstore) { - XCopyArea(g_display, g_backstore, g_wnd, g_gc, srcx, srcy, cx, cy, x, y); - XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x, y); + if (g_Unobscured) + { + XCopyArea(g_display, g_wnd, g_wnd, g_gc, srcx, srcy, cx, cy, x, y); + XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x, + y); + } + else + { + XCopyArea(g_display, g_backstore, g_wnd, g_gc, srcx, srcy, cx, cy, x, y); + XCopyArea(g_display, g_backstore, g_backstore, g_gc, srcx, srcy, cx, cy, x, + y); + } } else { @@ -1856,6 +2191,151 @@ FILL_RECTANGLE(x, y, cx, cy); } +void +ui_polygon(uint8 opcode, + /* mode */ uint8 fillmode, + /* dest */ POINT * point, int npoints, + /* brush */ BRUSH * brush, int bgcolour, int fgcolour) +{ + uint8 style, i, ipattern[8]; + Pixmap fill; + + SET_FUNCTION(opcode); + + switch (fillmode) + { + case ALTERNATE: + XSetFillRule(g_display, g_gc, EvenOddRule); + break; + case WINDING: + XSetFillRule(g_display, g_gc, WindingRule); + break; + default: + unimpl("fill mode %d\n", fillmode); + } + + if (brush) + style = brush->style; + else + style = 0; + + switch (style) + { + case 0: /* Solid */ + SET_FOREGROUND(fgcolour); + FILL_POLYGON((XPoint *) point, npoints); + break; + + case 2: /* Hatch */ + fill = (Pixmap) ui_create_glyph(8, 8, + hatch_patterns + brush->pattern[0] * 8); + SET_FOREGROUND(fgcolour); + SET_BACKGROUND(bgcolour); + XSetFillStyle(g_display, g_gc, FillOpaqueStippled); + XSetStipple(g_display, g_gc, fill); + XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin); + FILL_POLYGON((XPoint *) point, npoints); + XSetFillStyle(g_display, g_gc, FillSolid); + XSetTSOrigin(g_display, g_gc, 0, 0); + ui_destroy_glyph((HGLYPH) fill); + break; + + case 3: /* Pattern */ + for (i = 0; i != 8; i++) + ipattern[7 - i] = brush->pattern[i]; + fill = (Pixmap) ui_create_glyph(8, 8, ipattern); + SET_FOREGROUND(bgcolour); + SET_BACKGROUND(fgcolour); + XSetFillStyle(g_display, g_gc, FillOpaqueStippled); + XSetStipple(g_display, g_gc, fill); + XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin); + FILL_POLYGON((XPoint *) point, npoints); + XSetFillStyle(g_display, g_gc, FillSolid); + XSetTSOrigin(g_display, g_gc, 0, 0); + ui_destroy_glyph((HGLYPH) fill); + break; + + default: + unimpl("brush %d\n", brush->style); + } + + RESET_FUNCTION(opcode); +} + +void +ui_polyline(uint8 opcode, + /* dest */ POINT * points, int npoints, + /* pen */ PEN * pen) +{ + /* TODO: set join style */ + SET_FUNCTION(opcode); + SET_FOREGROUND(pen->colour); + XDrawLines(g_display, g_wnd, g_gc, (XPoint *) points, npoints, CoordModePrevious); + if (g_ownbackstore) + XDrawLines(g_display, g_backstore, g_gc, (XPoint *) points, npoints, + CoordModePrevious); + RESET_FUNCTION(opcode); +} + +void +ui_ellipse(uint8 opcode, + /* mode */ uint8 fillmode, + /* dest */ int x, int y, int cx, int cy, + /* brush */ BRUSH * brush, int bgcolour, int fgcolour) +{ + uint8 style, i, ipattern[8]; + Pixmap fill; + + SET_FUNCTION(opcode); + + if (brush) + style = brush->style; + else + style = 0; + + switch (style) + { + case 0: /* Solid */ + SET_FOREGROUND(fgcolour); + DRAW_ELLIPSE(x, y, cx, cy, fillmode); + break; + + case 2: /* Hatch */ + fill = (Pixmap) ui_create_glyph(8, 8, + hatch_patterns + brush->pattern[0] * 8); + SET_FOREGROUND(fgcolour); + SET_BACKGROUND(bgcolour); + XSetFillStyle(g_display, g_gc, FillOpaqueStippled); + XSetStipple(g_display, g_gc, fill); + XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin); + DRAW_ELLIPSE(x, y, cx, cy, fillmode); + XSetFillStyle(g_display, g_gc, FillSolid); + XSetTSOrigin(g_display, g_gc, 0, 0); + ui_destroy_glyph((HGLYPH) fill); + break; + + case 3: /* Pattern */ + for (i = 0; i != 8; i++) + ipattern[7 - i] = brush->pattern[i]; + fill = (Pixmap) ui_create_glyph(8, 8, ipattern); + SET_FOREGROUND(bgcolour); + SET_BACKGROUND(fgcolour); + XSetFillStyle(g_display, g_gc, FillOpaqueStippled); + XSetStipple(g_display, g_gc, fill); + XSetTSOrigin(g_display, g_gc, brush->xorigin, brush->yorigin); + DRAW_ELLIPSE(x, y, cx, cy, fillmode); + XSetFillStyle(g_display, g_gc, FillSolid); + XSetTSOrigin(g_display, g_gc, 0, 0); + ui_destroy_glyph((HGLYPH) fill); + break; + + default: + unimpl("brush %d\n", brush->style); + } + + RESET_FUNCTION(opcode); +} + /* warning, this function only draws on wnd or backstore, not both */ void ui_draw_glyph(int mixmode, @@ -1911,17 +2391,25 @@ } void -ui_draw_text(uint8 font, uint8 flags, int mixmode, int x, int y, +ui_draw_text(uint8 font, uint8 flags, uint8 opcode, int mixmode, int x, int y, int clipx, int clipy, int clipcx, int clipcy, - int boxx, int boxy, int boxcx, int boxcy, int bgcolour, - int fgcolour, uint8 * text, uint8 length) + int boxx, int boxy, int boxcx, int boxcy, BRUSH * brush, + int bgcolour, int fgcolour, uint8 * text, uint8 length) { + /* TODO: use brush appropriately */ + FONTGLYPH *glyph; int i, j, xyoffset, x1, y1; DATABLOB *entry; SET_FOREGROUND(bgcolour); + /* Sometimes, the boxcx value is something really large, like + 32691. This makes XCopyArea fail with Xvnc. The code below + is a quick fix. */ + if (boxx + boxcx > g_width) + boxcx = g_width - boxx; + if (boxcx > 1) { FILL_RECTANGLE_BACKSTORE(boxx, boxy, boxcx, boxcy); @@ -2049,3 +2537,14 @@ XFree(image); } + +/* these do nothing here but are used in uiports */ +void +ui_begin_update(void) +{ +} + +void +ui_end_update(void) +{ +}