--- sourceforge.net/trunk/rdesktop/xwin.c	2003/09/25 22:23:42	472
+++ sourceforge.net/trunk/rdesktop/xwin.c	2003/10/29 14:14:46	532
@@ -34,15 +34,13 @@
 extern char g_title[];
 extern int g_server_bpp;
 extern int g_win_button_size;
-BOOL g_enable_compose = False;
-BOOL g_focused;
-BOOL g_mouse_in_wnd;
 
 Display *g_display;
 Time g_last_gesturetime;
 static int g_x_socket;
 static Screen *g_screen;
 Window g_wnd;
+BOOL g_enable_compose = False;
 static GC g_gc;
 static Visual *g_visual;
 static int g_depth;
@@ -51,11 +49,16 @@
 static XIC g_IC;
 static XModifierKeymap *g_mod_map;
 static Cursor g_current_cursor;
+static HCURSOR g_null_cursor;
 static Atom g_protocol_atom, g_kill_atom;
+static BOOL g_focused;
+static BOOL g_mouse_in_wnd;
 
 /* endianness */
 static BOOL g_host_be;
 static BOOL g_xserver_be;
+static int g_red_shift_r, g_blue_shift_r, g_green_shift_r;
+static int g_red_shift_l, g_blue_shift_l, g_green_shift_l;
 
 /* software backing store */
 static BOOL g_ownbackstore;
@@ -66,6 +69,12 @@
 static int g_move_x_offset = 0;
 static int g_move_y_offset = 0;
 
+#ifdef WITH_RDPSND
+extern int g_dsp_fd;
+extern BOOL g_dsp_busy;
+extern BOOL g_rdpsnd;
+#endif
+
 /* MWM decorations */
 #define MWM_HINTS_DECORATIONS   (1L << 1)
 #define PROP_MOTIF_WM_HINTS_ELEMENTS    5
@@ -105,7 +114,7 @@
 static Colormap g_xcolmap;
 static uint32 *g_colmap = NULL;
 
-#define TRANSLATE(col)		( g_server_bpp != 8 ? translate_colour(col) : g_owncolmap ? col : translate_colour(g_colmap[col]) )
+#define TRANSLATE(col)		( g_server_bpp != 8 ? translate_colour(col) : g_owncolmap ? col : g_colmap[col] )
 #define SET_FOREGROUND(col)	XSetForeground(g_display, g_gc, TRANSLATE(col));
 #define SET_BACKGROUND(col)	XSetBackground(g_display, g_gc, TRANSLATE(col));
 
@@ -190,38 +199,11 @@
 }
 
 static uint32
-make_colour16(PixelColour pc)
-{
-	pc.red = (pc.red * 0x1f) / 0xff;
-	pc.green = (pc.green * 0x3f) / 0xff;
-	pc.blue = (pc.blue * 0x1f) / 0xff;
-	return (pc.red << 11) | (pc.green << 5) | pc.blue;
-}
-
-static uint32
-make_colour24(PixelColour pc)
-{
-	if (g_xserver_be)
-	{
-		return pc.red | (pc.green << 8) | (pc.blue << 16);
-	}
-	else
-	{
-		return (pc.red << 16) | (pc.green << 8) | pc.blue;
-	}
-}
-
-static uint32
-make_colour32(PixelColour pc)
+make_colour(PixelColour pc)
 {
-	if (g_xserver_be)
-	{
-		return pc.red | (pc.green << 8) | (pc.blue << 16);
-	}
-	else
-	{
-		return (pc.red << 16) | (pc.green << 8) | pc.blue;
-	}
+	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 BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }
@@ -232,68 +214,20 @@
 static uint32
 translate_colour(uint32 colour)
 {
+	PixelColour pc;
 	switch (g_server_bpp)
 	{
 		case 15:
-			switch (g_bpp)
-			{
-				case 16:
-					colour = make_colour16(split_colour15(colour));
-					break;
-				case 24:
-					colour = make_colour24(split_colour15(colour));
-					break;
-				case 32:
-					colour = make_colour32(split_colour15(colour));
-					break;
-			}
+			pc = split_colour15(colour);
 			break;
 		case 16:
-			switch (g_bpp)
-			{
-				case 16:
-					break;
-				case 24:
-					colour = make_colour24(split_colour16(colour));
-					break;
-				case 32:
-					colour = make_colour32(split_colour16(colour));
-					break;
-			}
+			pc = split_colour16(colour);
 			break;
 		case 24:
-			switch (g_bpp)
-			{
-				case 16:
-					colour = make_colour16(split_colour24(colour));
-					break;
-				case 24:
-					break;
-				case 32:
-					colour = make_colour32(split_colour24(colour));
-					break;
-			}
+			pc = split_colour24(colour);
 			break;
 	}
-	switch (g_bpp)
-	{
-		case 16:
-			if (g_host_be != g_xserver_be)
-				BSWAP16(colour);
-			break;
-
-		case 24:
-			if (g_xserver_be)
-				BSWAP24(colour);
-			break;
-
-		case 32:
-			if (g_host_be != g_xserver_be)
-				BSWAP32(colour);
-			break;
-	}
-
-	return colour;
+	return make_colour(pc);
 }
 
 static void
@@ -304,10 +238,25 @@
 }
 
 static void
-translate8to16(uint8 * data, uint16 * out, uint16 * end)
+translate8to16(uint8 * data, uint8 * out, uint8 * end)
 {
+	uint16 value;
+
 	while (out < end)
-		*(out++) = (uint16) g_colmap[*(data++)];
+	{
+		value = (uint16) g_colmap[*(data++)];
+
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 8;
+			*(out++) = value;
+		}
+		else
+		{
+			*(out++) = value;
+			*(out++) = value >> 8;
+		}
+	}
 }
 
 /* little endian - conversion happens when colourmap is built */
@@ -319,114 +268,263 @@
 	while (out < end)
 	{
 		value = g_colmap[*(data++)];
-		*(out++) = value;
-		*(out++) = value >> 8;
-		*(out++) = value >> 16;
+
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 16;
+			*(out++) = value >> 8;
+			*(out++) = value;
+		}
+		else
+		{
+			*(out++) = value;
+			*(out++) = value >> 8;
+			*(out++) = value >> 16;
+		}
 	}
 }
 
 static void
-translate8to32(uint8 * data, uint32 * out, uint32 * end)
+translate8to32(uint8 * data, uint8 * out, uint8 * end)
 {
+	uint32 value;
+
 	while (out < end)
-		*(out++) = g_colmap[*(data++)];
+	{
+		value = g_colmap[*(data++)];
+
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 24;
+			*(out++) = value >> 16;
+			*(out++) = value >> 8;
+			*(out++) = value;
+		}
+		else
+		{
+			*(out++) = value;
+			*(out++) = value >> 8;
+			*(out++) = value >> 16;
+			*(out++) = value >> 24;
+		}
+	}
 }
 
 /* todo the remaining translate function might need some big endian check ?? */
 
 static void
-translate15to16(uint16 * data, uint16 * out, uint16 * end)
+translate15to16(uint16 * data, uint8 * out, uint8 * end)
 {
+	uint16 pixel;
+	uint16 value;
+
 	while (out < end)
-		*(out++) = (uint16) make_colour16(split_colour15(*(data++)));
+	{
+		pixel = *(data++);
+
+		if (g_host_be)
+		{
+			BSWAP16(pixel);
+		}
+
+		value = make_colour(split_colour15(pixel));
+
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 8;
+			*(out++) = value;
+		}
+		else
+		{
+			*(out++) = value;
+			*(out++) = value >> 8;
+		}
+	}
 }
 
 static void
 translate15to24(uint16 * data, uint8 * out, uint8 * end)
 {
 	uint32 value;
+	uint16 pixel;
 
 	while (out < end)
 	{
-		value = make_colour24(split_colour15(*(data++)));
-		*(out++) = value;
-		*(out++) = value >> 8;
-		*(out++) = value >> 16;
+		pixel = *(data++);
+
+		if (g_host_be)
+		{
+			BSWAP16(pixel);
+		}
+
+		value = make_colour(split_colour15(pixel));
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 16;
+			*(out++) = value >> 8;
+			*(out++) = value;
+		}
+		else
+		{
+			*(out++) = value;
+			*(out++) = value >> 8;
+			*(out++) = value >> 16;
+		}
 	}
 }
 
 static void
-translate15to32(uint16 * data, uint32 * out, uint32 * end)
+translate15to32(uint16 * data, uint8 * out, uint8 * end)
 {
 	uint16 pixel;
+	uint32 value;
 
 	while (out < end)
 	{
+		pixel = *(data++);
+
 		if (g_host_be)
 		{
-			pixel = *(data++);
-			pixel = (pixel & 0xff) << 8 | (pixel & 0xff00) >> 8;
-			*(out++) = make_colour32(split_colour15(pixel));
+			BSWAP16(pixel);
+		}
+
+		value = make_colour(split_colour15(pixel));
+
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 24;
+			*(out++) = value >> 16;
+			*(out++) = value >> 8;
+			*(out++) = value;
 		}
 		else
 		{
-			*(out++) = make_colour32(split_colour15(*(data++)));
+			*(out++) = value;
+			*(out++) = value >> 8;
+			*(out++) = value >> 16;
+			*(out++) = value >> 24;
 		}
 	}
 }
 
 static void
-translate16to16(uint16 * data, uint16 * out, uint16 * end)
+translate16to16(uint16 * data, uint8 * out, uint8 * end)
 {
+	uint16 pixel;
+	uint16 value;
+
 	while (out < end)
-		*(out++) = (uint16) (*(data++));
-}
+	{
+		pixel = *(data++);
 
+		if (g_host_be)
+		{
+			BSWAP16(pixel);
+		}
+
+		value = make_colour(split_colour16(pixel));
+
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 8;
+			*(out++) = value;
+		}
+		else
+		{
+			*(out++) = value;
+			*(out++) = value >> 8;
+		}
+	}
+}
 
 static void
 translate16to24(uint16 * data, uint8 * out, uint8 * end)
 {
 	uint32 value;
+	uint16 pixel;
 
 	while (out < end)
 	{
-		value = make_colour24(split_colour16(*(data++)));
-		*(out++) = value;
-		*(out++) = value >> 8;
-		*(out++) = value >> 16;
+		pixel = *(data++);
+
+		if (g_host_be)
+		{
+			BSWAP16(pixel);
+		}
+
+		value = make_colour(split_colour16(pixel));
+
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 16;
+			*(out++) = value >> 8;
+			*(out++) = value;
+		}
+		else
+		{
+			*(out++) = value;
+			*(out++) = value >> 8;
+			*(out++) = value >> 16;
+		}
 	}
 }
 
 static void
-translate16to32(uint16 * data, uint32 * out, uint32 * end)
+translate16to32(uint16 * data, uint8 * out, uint8 * end)
 {
 	uint16 pixel;
+	uint32 value;
 
 	while (out < end)
 	{
+		pixel = *(data++);
+
 		if (g_host_be)
 		{
-			pixel = *(data++);
-			pixel = (pixel & 0xff) << 8 | (pixel & 0xff00) >> 8;
-			*(out++) = make_colour32(split_colour16(pixel));
+		BSWAP16(pixel)}
+
+		value = make_colour(split_colour16(pixel));
+
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 24;
+			*(out++) = value >> 16;
+			*(out++) = value >> 8;
+			*(out++) = value;
 		}
 		else
 		{
-			*(out++) = make_colour32(split_colour16(*(data++)));
+			*(out++) = value;
+			*(out++) = value >> 8;
+			*(out++) = value >> 16;
+			*(out++) = value >> 24;
 		}
 	}
 }
 
 static void
-translate24to16(uint8 * data, uint16 * out, uint16 * end)
+translate24to16(uint8 * data, uint8 * out, uint8 * end)
 {
 	uint32 pixel = 0;
+	uint16 value;
 	while (out < end)
 	{
 		pixel = *(data++) << 16;
 		pixel |= *(data++) << 8;
 		pixel |= *(data++);
-		*(out++) = (uint16) make_colour16(split_colour24(pixel));
+
+		value = (uint16) make_colour(split_colour24(pixel));
+
+		if (g_xserver_be)
+		{
+			*(out++) = value >> 8;
+			*(out++) = value;
+		}
+		else
+		{
+			*(out++) = value;
+			*(out++) = value >> 8;
+		}
 	}
 }
 
@@ -440,24 +538,24 @@
 }
 
 static void
-translate24to32(uint8 * data, uint32 * out, uint32 * end)
+translate24to32(uint8 * data, uint8 * out, uint8 * end)
 {
-	uint32 pixel = 0;
 	while (out < end)
 	{
-		if (g_host_be)
+		if (g_xserver_be)
 		{
-			pixel = *(data++) << 16;
-			pixel |= *(data++) << 8;
-			pixel |= *(data++);
+			*(out++) = 0x00;
+			*(out++) = *(data++);
+			*(out++) = *(data++);
+			*(out++) = *(data++);
 		}
 		else
 		{
-			pixel = *(data++);
-			pixel |= *(data++) << 8;
-			pixel |= *(data++) << 16;
+			*(out++) = *(data++);
+			*(out++) = *(data++);
+			*(out++) = *(data++);
+			*(out++) = 0x00;
 		}
-		*(out++) = pixel;
 	}
 }
 
@@ -474,13 +572,13 @@
 			switch (g_bpp)
 			{
 				case 32:
-					translate24to32(data, (uint32 *) out, (uint32 *) end);
+					translate24to32(data, out, end);
 					break;
 				case 24:
 					translate24to24(data, out, end);
 					break;
 				case 16:
-					translate24to16(data, (uint16 *) out, (uint16 *) end);
+					translate24to16(data, out, end);
 					break;
 			}
 			break;
@@ -488,15 +586,13 @@
 			switch (g_bpp)
 			{
 				case 32:
-					translate16to32((uint16 *) data, (uint32 *) out,
-							(uint32 *) end);
+					translate16to32((uint16 *) data, out, end);
 					break;
 				case 24:
 					translate16to24((uint16 *) data, out, end);
 					break;
 				case 16:
-					translate16to16((uint16 *) data, (uint16 *) out,
-							(uint16 *) end);
+					translate16to16((uint16 *) data, out, end);
 					break;
 			}
 			break;
@@ -504,15 +600,13 @@
 			switch (g_bpp)
 			{
 				case 32:
-					translate15to32((uint16 *) data, (uint32 *) out,
-							(uint32 *) end);
+					translate15to32((uint16 *) data, out, end);
 					break;
 				case 24:
 					translate15to24((uint16 *) data, out, end);
 					break;
 				case 16:
-					translate15to16((uint16 *) data, (uint16 *) out,
-							(uint16 *) end);
+					translate15to16((uint16 *) data, out, end);
 					break;
 			}
 			break;
@@ -523,13 +617,13 @@
 					translate8to8(data, out, end);
 					break;
 				case 16:
-					translate8to16(data, (uint16 *) out, (uint16 *) end);
+					translate8to16(data, out, end);
 					break;
 				case 24:
 					translate8to24(data, out, end);
 					break;
 				case 32:
-					translate8to32(data, (uint32 *) out, (uint32 *) end);
+					translate8to32(data, out, end);
 					break;
 			}
 			break;
@@ -562,12 +656,21 @@
 	return (state & keysymMask) ? True : False;
 }
 
+static void
+calculate_shifts(uint32 mask, int *shift_r, int *shift_l)
+{
+	*shift_l = ffs(mask) - 1;
+	mask >>= *shift_l;
+	*shift_r = 8 - ffs(mask & ~(mask >> 1));
+}
+
 BOOL
 ui_init(void)
 {
+	XVisualInfo vi;
 	XPixmapFormatValues *pfm;
 	uint16 test;
-	int i;
+	int i, screen_num;
 
 	g_display = XOpenDisplay(NULL);
 	if (g_display == NULL)
@@ -576,11 +679,32 @@
 		return False;
 	}
 
+	screen_num = DefaultScreen(g_display);
 	g_x_socket = ConnectionNumber(g_display);
-	g_screen = DefaultScreenOfDisplay(g_display);
-	g_visual = DefaultVisualOfScreen(g_screen);
+	g_screen = ScreenOfDisplay(g_display, screen_num);
 	g_depth = DefaultDepthOfScreen(g_screen);
 
+	if (g_server_bpp == 8)
+	{
+		/* we use a colourmap, so any visual should do */
+		g_visual = DefaultVisualOfScreen(g_screen);
+	}
+	else
+	{
+		/* need a truecolour visual */
+		if (!XMatchVisualInfo(g_display, screen_num, g_depth, TrueColor, &vi))
+		{
+			error("The display does not support true colour - high colour support unavailable.\n");
+			return False;
+		}
+
+		g_visual = vi.visual;
+		g_owncolmap = False;
+		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);
+	}
+
 	pfm = XListPixmapFormats(g_display, &i);
 	if (pfm != NULL)
 	{
@@ -603,7 +727,7 @@
 		return False;
 	}
 
-	if (g_owncolmap != True)
+	if (!g_owncolmap)
 	{
 		g_xcolmap = DefaultColormapOfScreen(g_screen);
 		if (g_depth <= 8)
@@ -619,7 +743,16 @@
 	g_host_be = !(BOOL) (*(uint8 *) (&test));
 	g_xserver_be = (ImageByteOrder(g_display) == MSBFirst);
 
-	if ((g_width == 0) || (g_height == 0))
+	/*
+	 * Determine desktop size
+	 */
+	if (g_width < 0)
+	{
+		/* Percent of screen */
+		g_height = HeightOfScreen(g_screen) * (-g_width) / 100;
+		g_width = WidthOfScreen(g_screen) * (-g_width) / 100;
+	}
+	else if (g_width == 0)
 	{
 		/* Fetch geometry from _NET_WORKAREA */
 		uint32 x, y, cx, cy;
@@ -636,8 +769,7 @@
 			g_height = 600;
 		}
 	}
-
-	if (g_fullscreen)
+	else if (g_fullscreen)
 	{
 		g_width = WidthOfScreen(g_screen);
 		g_height = HeightOfScreen(g_screen);
@@ -659,14 +791,14 @@
 
 	g_mod_map = XGetModifierMapping(g_display);
 
+	xkeymap_init();
+
 	if (g_enable_compose)
 		g_IM = XOpenIM(g_display, NULL, NULL, NULL);
 
-	xkeymap_init();
 	xclip_init();
 
-	/* todo take this out when high colour is done */
-	printf("server bpp %d client bpp %d depth %d\n", g_server_bpp, g_bpp, g_depth);
+	DEBUG_RDP5(("server bpp %d client bpp %d depth %d\n", g_server_bpp, g_bpp, g_depth));
 
 	return True;
 }
@@ -687,6 +819,9 @@
 	g_display = NULL;
 }
 
+#define NULL_POINTER_MASK	"\x80"
+#define NULL_POINTER_DATA	"\x0\x0\x0"
+
 BOOL
 ui_create_window(void)
 {
@@ -771,12 +906,17 @@
 	g_kill_atom = XInternAtom(g_display, "WM_DELETE_WINDOW", True);
 	XSetWMProtocols(g_display, g_wnd, &g_kill_atom, 1);
 
+	/* create invisible 1x1 cursor to be used as null cursor */
+	g_null_cursor = ui_create_cursor(0, 0, 1, 1, NULL_POINTER_MASK, NULL_POINTER_DATA);
+
 	return True;
 }
 
 void
 ui_destroy_window(void)
 {
+	ui_destroy_cursor(g_null_cursor);
+
 	if (g_IC != NULL)
 		XDestroyIC(g_IC);
 
@@ -1078,9 +1218,7 @@
 ui_select(int rdp_socket)
 {
 	int n = (rdp_socket > g_x_socket) ? rdp_socket + 1 : g_x_socket + 1;
-	fd_set rfds;
-
-	FD_ZERO(&rfds);
+	fd_set rfds, wfds;
 
 	while (True)
 	{
@@ -1090,10 +1228,20 @@
 			return 0;
 
 		FD_ZERO(&rfds);
+		FD_ZERO(&wfds);
 		FD_SET(rdp_socket, &rfds);
 		FD_SET(g_x_socket, &rfds);
 
-		switch (select(n, &rfds, NULL, NULL, NULL))
+#ifdef WITH_RDPSND
+		/* FIXME: there should be an API for registering fds */
+		if (g_dsp_busy)
+		{
+			FD_SET(g_dsp_fd, &wfds);
+			n = (g_dsp_fd + 1 > n) ? g_dsp_fd + 1 : n;
+		}
+#endif
+
+		switch (select(n, &rfds, &wfds, NULL, NULL))
 		{
 			case -1:
 				error("select: %s\n", strerror(errno));
@@ -1104,6 +1252,11 @@
 
 		if (FD_ISSET(rdp_socket, &rfds))
 			return 1;
+
+#ifdef WITH_RDPSND
+		if (g_dsp_busy && FD_ISSET(g_dsp_fd, &wfds))
+			wave_out_play();
+#endif
 	}
 }
 
@@ -1119,11 +1272,24 @@
 	XImage *image;
 	Pixmap bitmap;
 	uint8 *tdata;
+	int bitmap_pad;
+
+	if (g_server_bpp == 8)
+	{
+		bitmap_pad = 8;
+	}
+	else
+	{
+		bitmap_pad = g_bpp;
+
+		if (g_bpp == 24)
+			bitmap_pad = 32;
+	}
 
 	tdata = (g_owncolmap ? data : translate_image(width, height, data));
 	bitmap = XCreatePixmap(g_display, g_wnd, width, height, g_depth);
 	image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
-			     (char *) tdata, width, height, g_server_bpp == 8 ? 8 : g_bpp, 0);
+			     (char *) tdata, width, height, bitmap_pad, 0);
 
 	XPutImage(g_display, bitmap, g_gc, image, 0, 0, 0, 0, width, height);
 
@@ -1138,9 +1304,23 @@
 {
 	XImage *image;
 	uint8 *tdata;
+	int bitmap_pad;
+
+	if (g_server_bpp == 8)
+	{
+		bitmap_pad = 8;
+	}
+	else
+	{
+		bitmap_pad = g_bpp;
+
+		if (g_bpp == 24)
+			bitmap_pad = 32;
+	}
+
 	tdata = (g_owncolmap ? data : translate_image(width, height, data));
 	image = XCreateImage(g_display, g_visual, g_depth, ZPixmap, 0,
-			     (char *) tdata, width, height, g_server_bpp == 8 ? 8 : g_bpp, 0);
+			     (char *) tdata, width, height, bitmap_pad, 0);
 
 	if (g_ownbackstore)
 	{
@@ -1279,6 +1459,12 @@
 	XFreeCursor(g_display, (Cursor) cursor);
 }
 
+void
+ui_set_null_cursor(void)
+{
+	ui_set_cursor(g_null_cursor);
+}
+
 #define MAKE_XCOLOR(xc,c) \
 		(xc)->red   = ((c)->red   << 8) | (c)->red; \
 		(xc)->green = ((c)->green << 8) | (c)->green; \
@@ -1360,9 +1546,7 @@
 
 			}
 
-
-			/* byte swap here to make translate_image faster */
-			map[i] = translate_colour(colour);
+			map[i] = colour;
 		}
 		return map;
 	}
@@ -1479,8 +1663,8 @@
 		case 2:	/* Hatch */
 			fill = (Pixmap) ui_create_glyph(8, 8,
 							hatch_patterns + brush->pattern[0] * 8);
-			SET_FOREGROUND(bgcolour);
-			SET_BACKGROUND(fgcolour);
+			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);