--- sourceforge.net/trunk/rdesktop/xwin.c	2004/06/16 03:08:55	713
+++ sourceforge.net/trunk/rdesktop/xwin.c	2005/03/08 00:43:10	831
@@ -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;
@@ -47,6 +49,8 @@
 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;
@@ -115,6 +119,31 @@
 	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 */
 extern BOOL g_owncolmap;
 static Colormap g_xcolmap;
@@ -168,49 +197,44 @@
 			(unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
 }
 
-static PixelColour
-split_colour15(uint32 colour)
-{
-	PixelColour 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);
-	return rv;
-}
-
-static PixelColour
-split_colour16(uint32 colour)
-{
-	PixelColour 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);
-	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)
 {
@@ -218,16 +242,16 @@
 	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 */
@@ -247,6 +271,14 @@
 	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) \
 { \
@@ -255,34 +287,36 @@
 	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;
 
 	if (g_arch_match)
 	{
+		/* *INDENT-OFF* */
 		REPEAT2
 		(
 			*((uint16 *) out) = g_colmap[*(data++)];
 			out += 2;
 		)
+		/* *INDENT-ON* */
 	}
 	else if (g_xserver_be)
 	{
 		while (out < end)
 		{
 			value = (uint16) g_colmap[*(data++)];
-			*(out++) = value >> 8;
-			*(out++) = value;
+			BOUT16(out, value);
 		}
 	}
 	else
@@ -290,15 +324,14 @@
 		while (out < end)
 		{
 			value = (uint16) g_colmap[*(data++)];
-			*(out++) = value;
-			*(out++) = value >> 8;
+			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;
 
@@ -307,9 +340,7 @@
 		while (out < end)
 		{
 			value = g_colmap[*(data++)];
-			*(out++) = value >> 16;
-			*(out++) = value >> 8;
-			*(out++) = value;
+			BOUT24(out, value);
 		}
 	}
 	else
@@ -317,35 +348,32 @@
 		while (out < end)
 		{
 			value = g_colmap[*(data++)];
-			*(out++) = value;
-			*(out++) = value >> 8;
-			*(out++) = value >> 16;
+			LOUT24(out, value);
 		}
 	}
 }
 
 static void
-translate8to32(uint8 * data, uint8 * out, uint8 * end)
+translate8to32(const uint8 * data, uint8 * out, uint8 * end)
 {
 	uint32 value;
 
 	if (g_arch_match)
 	{
+		/* *INDENT-OFF* */
 		REPEAT4
 		(
 			*((uint32 *) out) = g_colmap[*(data++)];
 			out += 4;
 		)
+		/* *INDENT-ON* */
 	}
 	else if (g_xserver_be)
 	{
 		while (out < end)
 		{
 			value = g_colmap[*(data++)];
-			*(out++) = value >> 24;
-			*(out++) = value >> 16;
-			*(out++) = value >> 8;
-			*(out++) = value;
+			BOUT32(out, value);
 		}
 	}
 	else
@@ -353,289 +381,455 @@
 		while (out < end)
 		{
 			value = g_colmap[*(data++)];
-			*(out++) = value;
-			*(out++) = value >> 8;
-			*(out++) = value >> 16;
-			*(out++) = value >> 24;
+			LOUT32(out, value);
 		}
 	}
 }
 
-/* *INDENT-ON* */
-
 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)
-		{
-			BSWAP16(pixel);
-		}
-
-		value = make_colour(split_colour15(pixel));
-
-		if (g_xserver_be)
+		while (out < end)
 		{
-			*(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
+		{
+			while (out < end)
+			{
+				pixel = *(data++);
+				SPLITCOLOUR16(pixel, pc);
+				value = MAKECOLOUR(pc);
+				BOUT16(out, value);
+			}
+		}
+	}
+	else
+	{
+		if (g_host_be)
 		{
-			*(out++) = value >> 8;
-			*(out++) = value;
+			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
+		{
+			while (out < end)
+			{
+				pixel = *(data++);
+				SPLITCOLOUR16(pixel, pc);
+				value = MAKECOLOUR(pc);
+				BOUT32(out, value);
+			}
+		}
+	}
+	else
+	{
+		if (g_host_be)
 		{
-			*(out++) = value >> 24;
-			*(out++) = value >> 16;
-			*(out++) = value >> 8;
-			*(out++) = value;
+			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);
 		}
 	}
 }
@@ -656,6 +850,8 @@
 			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);
@@ -829,10 +1025,21 @@
 		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 averything is little endian */
-		if (vi.red_mask > vi.green_mask && vi.green_mask > vi.blue_mask)
-			if (!g_xserver_be && !g_host_be)
+		/* 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);
@@ -944,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;
@@ -961,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);
@@ -1429,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;
 		}
 
@@ -1481,7 +1689,7 @@
 	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 (tdata != data)
@@ -1539,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);
@@ -1552,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;
 }
 
@@ -1984,6 +2191,136 @@
 	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_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,