--- sourceforge.net/trunk/rdesktop/xwin.c	2002/11/19 14:48:02	275
+++ sourceforge.net/trunk/rdesktop/xwin.c	2003/02/18 13:44:27	331
@@ -31,6 +31,8 @@
 extern BOOL grab_keyboard;
 extern BOOL hide_decorations;
 extern char title[];
+extern int server_bpp;
+extern int win_button_size;
 BOOL enable_compose = False;
 BOOL focused;
 BOOL mouse_in_wnd;
@@ -62,14 +64,21 @@
 #define PROP_MOTIF_WM_HINTS_ELEMENTS    5
 typedef struct
 {
-	unsigned long flags;
-	unsigned long functions;
-	unsigned long decorations;
-	long inputMode;
-	unsigned long status;
+	uint32 flags;
+	uint32 functions;
+	uint32 decorations;
+	sint32 inputMode;
+	uint32 status;
 }
 PropMotifWmHints;
 
+typedef struct
+{
+	uint32 red;
+	uint32 green;
+	uint32 blue;
+}
+PixelColour;
 
 #define FILL_RECTANGLE(x,y,cx,cy)\
 { \
@@ -78,12 +87,19 @@
 		XFillRectangle(display, backstore, gc, x, y, cx, cy); \
 }
 
+#define FILL_RECTANGLE_BACKSTORE(x,y,cx,cy)\
+{ \
+	XFillRectangle(display, ownbackstore ? backstore : wnd, gc, x, y, cx, cy); \
+}
+
 /* colour maps */
+BOOL owncolmap = False;
 static Colormap xcolmap;
 static uint32 *colmap;
 
-#define SET_FOREGROUND(col)	XSetForeground(display, gc, translate_colour(colmap[col]));
-#define SET_BACKGROUND(col)	XSetBackground(display, gc, translate_colour(colmap[col]));
+#define TRANSLATE(col)		( server_bpp != 8 ? translate_colour(col) : owncolmap ? col : translate_colour(colmap[col]) )
+#define SET_FOREGROUND(col)	XSetForeground(display, gc, TRANSLATE(col));
+#define SET_BACKGROUND(col)	XSetBackground(display, gc, TRANSLATE(col));
 
 static int rop2_map[] = {
 	GXclear,		/* 0 */
@@ -107,7 +123,7 @@
 #define SET_FUNCTION(rop2)	{ if (rop2 != ROP2_COPY) XSetFunction(display, gc, rop2_map[rop2]); }
 #define RESET_FUNCTION(rop2)	{ if (rop2 != ROP2_COPY) XSetFunction(display, gc, GXcopy); }
 
-void
+static void
 mwm_hide_decorations(void)
 {
 	PropMotifWmHints motif_hints;
@@ -121,7 +137,7 @@
 	hintsatom = XInternAtom(display, "_MOTIF_WM_HINTS", False);
 	if (!hintsatom)
 	{
-		error("Failed to get atom _MOTIF_WM_HINTS\n");
+		warning("Failed to get atom _MOTIF_WM_HINTS: probably your window manager does not support MWM hints\n");
 		return;
 	}
 
@@ -129,15 +145,144 @@
 			(unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
 }
 
+static PixelColour
+split_colour15(uint32 colour)
+{
+	PixelColour rv;
+	rv.red = (colour & 0x7c00) >> 10;
+	rv.red = (rv.red * 0xff) / 0x1f;
+	rv.green = (colour & 0x03e0) >> 5;
+	rv.green = (rv.green * 0xff) / 0x1f;
+	rv.blue = (colour & 0x1f);
+	rv.blue = (rv.blue * 0xff) / 0x1f;
+	return rv;
+}
+
+static PixelColour
+split_colour16(uint32 colour)
+{
+	PixelColour rv;
+	rv.red = (colour & 0xf800) >> 11;
+	rv.red = (rv.red * 0xff) / 0x1f;
+	rv.green = (colour & 0x07e0) >> 5;
+	rv.green = (rv.green * 0xff) / 0x3f;
+	rv.blue = (colour & 0x001f);
+	rv.blue = (rv.blue * 0xff) / 0x1f;
+	return rv;
+}
+
+static PixelColour
+split_colour24(uint32 colour)
+{
+	PixelColour rv;
+	rv.blue = (colour & 0xff0000) >> 16;
+	rv.green = (colour & 0xff00) >> 8;
+	rv.red = (colour & 0xff);
+	return rv;
+}
+
+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)
+{
+	return (pc.red << 16) | (pc.green << 8) | pc.blue;
+}
+
+static uint32
+make_colour32(PixelColour pc)
+{
+	return (pc.red << 16) | (pc.green << 8) | pc.blue;
+}
+
+#define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }
+#define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | ((x >> 8) & 0xff00)); }
+#define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \
+			x = (x << 16) | (x >> 16); }
+
+static uint32
+translate_colour(uint32 colour)
+{
+	switch (server_bpp)
+	{
+		case 15:
+			switch (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;
+			}
+			break;
+		case 16:
+			switch (bpp)
+			{
+				case 16:
+					break;
+				case 24:
+					colour = make_colour24(split_colour16(colour));
+					break;
+				case 32:
+					colour = make_colour32(split_colour16(colour));
+					break;
+			}
+			break;
+		case 24:
+			switch (bpp)
+			{
+				case 16:
+					colour = make_colour16(split_colour24(colour));
+					break;
+				case 24:
+					break;
+				case 32:
+					colour = make_colour32(split_colour24(colour));
+					break;
+			}
+			break;
+	}
+	switch (bpp)
+	{
+		case 16:
+			if (host_be != xserver_be)
+				BSWAP16(colour);
+			break;
+
+		case 24:
+			if (xserver_be)
+				BSWAP24(colour);
+			break;
+
+		case 32:
+			if (host_be != xserver_be)
+				BSWAP32(colour);
+			break;
+	}
+
+	return colour;
+}
+
 static void
-translate8(uint8 * data, uint8 * out, uint8 * end)
+translate8to8(uint8 * data, uint8 * out, uint8 * end)
 {
 	while (out < end)
 		*(out++) = (uint8) colmap[*(data++)];
 }
 
 static void
-translate16(uint8 * data, uint16 * out, uint16 * end)
+translate8to16(uint8 * data, uint16 * out, uint16 * end)
 {
 	while (out < end)
 		*(out++) = (uint16) colmap[*(data++)];
@@ -145,7 +290,7 @@
 
 /* little endian - conversion happens when colourmap is built */
 static void
-translate24(uint8 * data, uint8 * out, uint8 * end)
+translate8to24(uint8 * data, uint8 * out, uint8 * end)
 {
 	uint32 value;
 
@@ -159,68 +304,179 @@
 }
 
 static void
-translate32(uint8 * data, uint32 * out, uint32 * end)
+translate8to32(uint8 * data, uint32 * out, uint32 * end)
 {
 	while (out < end)
 		*(out++) = colmap[*(data++)];
 }
 
-static uint8 *
-translate_image(int width, int height, uint8 * data)
+/* todo the remaining translate function might need some big endian check ?? */
+
+static void
+translate15to16(uint16 * data, uint16 * out, uint16 * end)
 {
-	int size = width * height * bpp / 8;
-	uint8 *out = xmalloc(size);
-	uint8 *end = out + size;
+	while (out < end)
+		*(out++) = (uint16) make_colour16(split_colour15(*(data++)));
+}
 
-	switch (bpp)
+static void
+translate15to24(uint16 * data, uint8 * out, uint8 * end)
+{
+	uint32 value;
+
+	while (out < end)
 	{
-		case 8:
-			translate8(data, out, end);
-			break;
+		value = make_colour24(split_colour15(*(data++)));
+		*(out++) = value;
+		*(out++) = value >> 8;
+		*(out++) = value >> 16;
+	}
+}
 
-		case 16:
-			translate16(data, (uint16 *) out, (uint16 *) end);
-			break;
+static void
+translate15to32(uint16 * data, uint32 * out, uint32 * end)
+{
+	while (out < end)
+		*(out++) = make_colour32(split_colour15(*(data++)));
+}
 
-		case 24:
-			translate24(data, out, end);
-			break;
+static void
+translate16to16(uint16 * data, uint16 * out, uint16 * end)
+{
+	while (out < end)
+		*(out++) = (uint16) (*(data++));
+}
 
-		case 32:
-			translate32(data, (uint32 *) out, (uint32 *) end);
-			break;
+
+static void
+translate16to24(uint16 * data, uint8 * out, uint8 * end)
+{
+	uint32 value;
+
+	while (out < end)
+	{
+		value = make_colour24(split_colour16(*(data++)));
+		*(out++) = value;
+		*(out++) = value >> 8;
+		*(out++) = value >> 16;
 	}
+}
 
-	return out;
+static void
+translate16to32(uint16 * data, uint32 * out, uint32 * end)
+{
+	while (out < end)
+		*(out++) = make_colour32(split_colour16(*(data++)));
 }
 
-#define BSWAP16(x) { x = (((x & 0xff) << 8) | (x >> 8)); }
-#define BSWAP24(x) { x = (((x & 0xff) << 16) | (x >> 16) | ((x >> 8) & 0xff00)); }
-#define BSWAP32(x) { x = (((x & 0xff00ff) << 8) | ((x >> 8) & 0xff00ff)); \
-			x = (x << 16) | (x >> 16); }
+static void
+translate24to16(uint8 * data, uint16 * out, uint16 * end)
+{
+	uint32 pixel = 0;
+	while (out < end)
+	{
+		pixel = *(data++) << 16;
+		pixel |= *(data++) << 8;
+		pixel |= *(data++);
+		*(out++) = (uint16) make_colour16(split_colour24(pixel));
+	}
+}
 
-static uint32
-translate_colour(uint32 colour)
+static void
+translate24to24(uint8 * data, uint8 * out, uint8 * end)
 {
-	switch (bpp)
+	while (out < end)
 	{
-		case 16:
-			if (host_be != xserver_be)
-				BSWAP16(colour);
-			break;
+		*(out++) = (*(data++));
+	}
+}
+
+static void
+translate24to32(uint8 * data, uint32 * out, uint32 * end)
+{
+	uint32 pixel = 0;
+	while (out < end)
+	{
+		memcpy(&pixel, data, 3);
+		data += 3;
+		*(out++) = pixel;
+	}
+}
 
+static uint8 *
+translate_image(int width, int height, uint8 * data)
+{
+	int size = width * height * bpp / 8;
+	uint8 *out = xmalloc(size);
+	uint8 *end = out + size;
+
+	switch (server_bpp)
+	{
 		case 24:
-			if (xserver_be)
-				BSWAP24(colour);
+			switch (bpp)
+			{
+				case 32:
+					translate24to32(data, (uint32 *) out, (uint32 *) end);
+					break;
+				case 24:
+					translate24to24(data, out, end);
+					break;
+				case 16:
+					translate24to16(data, (uint16 *) out, (uint16 *) end);
+					break;
+			}
 			break;
-
-		case 32:
-			if (host_be != xserver_be)
-				BSWAP32(colour);
+		case 16:
+			switch (bpp)
+			{
+				case 32:
+					translate16to32((uint16 *) data, (uint32 *) out,
+							(uint32 *) end);
+					break;
+				case 24:
+					translate16to24((uint16 *) data, out, end);
+					break;
+				case 16:
+					translate16to16((uint16 *) data, (uint16 *) out,
+							(uint16 *) end);
+					break;
+			}
+			break;
+		case 15:
+			switch (bpp)
+			{
+				case 32:
+					translate15to32((uint16 *) data, (uint32 *) out,
+							(uint32 *) end);
+					break;
+				case 24:
+					translate15to24((uint16 *) data, out, end);
+					break;
+				case 16:
+					translate15to16((uint16 *) data, (uint16 *) out,
+							(uint16 *) end);
+					break;
+			}
+			break;
+		case 8:
+			switch (bpp)
+			{
+				case 8:
+					translate8to8(data, out, end);
+					break;
+				case 16:
+					translate8to16(data, (uint16 *) out, (uint16 *) end);
+					break;
+				case 24:
+					translate8to24(data, out, end);
+					break;
+				case 32:
+					translate8to32(data, (uint32 *) out, (uint32 *) end);
+					break;
+			}
 			break;
 	}
-
-	return colour;
+	return out;
 }
 
 BOOL
@@ -289,7 +545,13 @@
 		return False;
 	}
 
-	xcolmap = DefaultColormapOfScreen(screen);
+	if (owncolmap != True)
+	{
+		xcolmap = DefaultColormapOfScreen(screen);
+		if (depth <= 8)
+			warning("Screen depth is 8 bits or lower: you may want to use -C for a private colourmap\n");
+	}
+
 	gc = XCreateGC(display, RootWindowOfScreen(screen), 0, NULL);
 
 	if (DoesBackingStore(screen) != Always)
@@ -302,13 +564,16 @@
 	if ((width == 0) || (height == 0))
 	{
 		/* Fetch geometry from _NET_WORKAREA */
-		uint32 xpos, ypos;
+		uint32 x, y, cx, cy;
 
-		if (get_current_workarea(&xpos, &ypos, &width, &height) < 0)
+		if (get_current_workarea(&x, &y, &cx, &cy) == 0)
+		{
+			width = cx;
+			height = cy;
+		}
+		else
 		{
-			error("Failed to get workarea.\n");
-			error("Perhaps your window manager does not support EWMH?\n");
-			error("Defaulting to geometry 800x600\n");
+			warning("Failed to get workarea: probably your window manager does not support extended hints\n");
 			width = 800;
 			height = 600;
 		}
@@ -339,6 +604,10 @@
 		IM = XOpenIM(display, NULL, NULL, NULL);
 
 	xkeymap_init();
+
+	/* todo take this out when high colour is done */
+	printf("server bpp %d client bpp %d depth %d\n", server_bpp, bpp, depth);
+
 	return True;
 }
 
@@ -586,11 +855,44 @@
 				if (button == 0)
 					break;
 
+				/* If win_button_size is nonzero, enable single app mode */
+				if (xevent.xbutton.y < win_button_size)
+				{
+					if (xevent.xbutton.x < win_button_size)
+					{
+						/* The system menu, do not send to server */
+						break;
+					}
+					else if (xevent.xbutton.x >= width - win_button_size)
+					{
+						/* The close button, continue */
+						;
+					}
+					else if (xevent.xbutton.x >= width - win_button_size * 2)
+					{
+						/* The maximize/restore button. Do not send to
+						   server.  It might be a good idea to change the
+						   cursor or give some other visible indication 
+						   that rdesktop inhibited this click */
+						break;
+					}
+					else if (xevent.xbutton.x >= width - win_button_size * 3)
+					{
+						/* The minimize button. Iconify window. */
+						XIconifyWindow(display, wnd,
+							       DefaultScreen(display));
+						break;
+					}
+				}
+
 				rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
 					       flags | button, xevent.xbutton.x, xevent.xbutton.y);
 				break;
 
 			case MotionNotify:
+				if (fullscreen && !focused)
+					XSetInputFocus(display, wnd, RevertToPointerRoot,
+						       CurrentTime);
 				rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
 					       MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);
 				break;
@@ -711,15 +1013,16 @@
 	Pixmap bitmap;
 	uint8 *tdata;
 
-	tdata = translate_image(width, height, data);
+	tdata = (owncolmap ? data : translate_image(width, height, data));
 	bitmap = XCreatePixmap(display, wnd, width, height, depth);
 	image = XCreateImage(display, visual, depth, ZPixmap, 0,
-			     (char *) tdata, width, height, 8, 0);
+			     (char *) tdata, width, height, server_bpp == 8 ? 8 : bpp, 0);
 
 	XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);
 
 	XFree(image);
-	xfree(tdata);
+	if (!owncolmap)
+		xfree(tdata);
 	return (HBITMAP) bitmap;
 }
 
@@ -728,10 +1031,9 @@
 {
 	XImage *image;
 	uint8 *tdata;
-
-	tdata = translate_image(width, height, data);
+	tdata = (owncolmap ? data : translate_image(width, height, data));
 	image = XCreateImage(display, visual, depth, ZPixmap, 0,
-			     (char *) tdata, width, height, 8, 0);
+			     (char *) tdata, width, height, server_bpp == 8 ? 8 : bpp, 0);
 
 	if (ownbackstore)
 	{
@@ -744,7 +1046,8 @@
 	}
 
 	XFree(image);
-	xfree(tdata);
+	if (!owncolmap)
+		xfree(tdata);
 }
 
 void
@@ -875,95 +1178,125 @@
 		(xc)->blue  = ((c)->blue  << 8) | (c)->blue; \
 		(xc)->flags = DoRed | DoGreen | DoBlue;
 
+
 HCOLOURMAP
 ui_create_colourmap(COLOURMAP * colours)
 {
 	COLOURENTRY *entry;
 	int i, ncolours = colours->ncolours;
-	uint32 *map = xmalloc(sizeof(*colmap) * ncolours);
-	XColor xentry;
-	XColor xc_cache[256];
-	uint32 colour;
-	int colLookup = 256;
-	for (i = 0; i < ncolours; i++)
+	if (!owncolmap)
 	{
-		entry = &colours->colours[i];
-		MAKE_XCOLOR(&xentry, entry);
-
-		if (XAllocColor(display, xcolmap, &xentry) == 0)
+		uint32 *map = xmalloc(sizeof(*colmap) * ncolours);
+		XColor xentry;
+		XColor xc_cache[256];
+		uint32 colour;
+		int colLookup = 256;
+		for (i = 0; i < ncolours; i++)
 		{
-			/* Allocation failed, find closest match. */
-			int j = 256;
-			int nMinDist = 3 * 256 * 256;
-			long nDist = nMinDist;
+			entry = &colours->colours[i];
+			MAKE_XCOLOR(&xentry, entry);
 
-			/* only get the colors once */
-			while (colLookup--)
+			if (XAllocColor(display, xcolmap, &xentry) == 0)
 			{
-				xc_cache[colLookup].pixel = colLookup;
-				xc_cache[colLookup].red = xc_cache[colLookup].green =
-					xc_cache[colLookup].blue = 0;
-				xc_cache[colLookup].flags = 0;
-				XQueryColor(display,
-					    DefaultColormap(display, DefaultScreen(display)),
-					    &xc_cache[colLookup]);
-			}
-			colLookup = 0;
+				/* Allocation failed, find closest match. */
+				int j = 256;
+				int nMinDist = 3 * 256 * 256;
+				long nDist = nMinDist;
 
-			/* approximate the pixel */
-			while (j--)
-			{
-				if (xc_cache[j].flags)
+				/* only get the colors once */
+				while (colLookup--)
 				{
-					nDist = ((long) (xc_cache[j].red >> 8) -
-						 (long) (xentry.red >> 8)) *
-						((long) (xc_cache[j].red >> 8) -
-						 (long) (xentry.red >> 8)) +
-						((long) (xc_cache[j].green >> 8) -
-						 (long) (xentry.green >> 8)) *
-						((long) (xc_cache[j].green >> 8) -
-						 (long) (xentry.green >> 8)) +
-						((long) (xc_cache[j].blue >> 8) -
-						 (long) (xentry.blue >> 8)) *
-						((long) (xc_cache[j].blue >> 8) -
-						 (long) (xentry.blue >> 8));
+					xc_cache[colLookup].pixel = colLookup;
+					xc_cache[colLookup].red = xc_cache[colLookup].green =
+						xc_cache[colLookup].blue = 0;
+					xc_cache[colLookup].flags = 0;
+					XQueryColor(display,
+						    DefaultColormap(display,
+								    DefaultScreen(display)),
+						    &xc_cache[colLookup]);
 				}
-				if (nDist < nMinDist)
+				colLookup = 0;
+
+				/* approximate the pixel */
+				while (j--)
 				{
-					nMinDist = nDist;
-					xentry.pixel = j;
+					if (xc_cache[j].flags)
+					{
+						nDist = ((long) (xc_cache[j].red >> 8) -
+							 (long) (xentry.red >> 8)) *
+							((long) (xc_cache[j].red >> 8) -
+							 (long) (xentry.red >> 8)) +
+							((long) (xc_cache[j].green >> 8) -
+							 (long) (xentry.green >> 8)) *
+							((long) (xc_cache[j].green >> 8) -
+							 (long) (xentry.green >> 8)) +
+							((long) (xc_cache[j].blue >> 8) -
+							 (long) (xentry.blue >> 8)) *
+							((long) (xc_cache[j].blue >> 8) -
+							 (long) (xentry.blue >> 8));
+					}
+					if (nDist < nMinDist)
+					{
+						nMinDist = nDist;
+						xentry.pixel = j;
+					}
 				}
 			}
+			colour = xentry.pixel;
+
+			/* update our cache */
+			if (xentry.pixel < 256)
+			{
+				xc_cache[xentry.pixel].red = xentry.red;
+				xc_cache[xentry.pixel].green = xentry.green;
+				xc_cache[xentry.pixel].blue = xentry.blue;
+
+			}
+
+
+			/* byte swap here to make translate_image faster */
+			map[i] = translate_colour(colour);
 		}
-		colour = xentry.pixel;
+		return map;
+	}
+	else
+	{
+		XColor *xcolours, *xentry;
+		Colormap map;
 
-		/* update our cache */
-		if (xentry.pixel < 256)
+		xcolours = xmalloc(sizeof(XColor) * ncolours);
+		for (i = 0; i < ncolours; i++)
 		{
-			xc_cache[xentry.pixel].red = xentry.red;
-			xc_cache[xentry.pixel].green = xentry.green;
-			xc_cache[xentry.pixel].blue = xentry.blue;
-
+			entry = &colours->colours[i];
+			xentry = &xcolours[i];
+			xentry->pixel = i;
+			MAKE_XCOLOR(xentry, entry);
 		}
 
+		map = XCreateColormap(display, wnd, visual, AllocAll);
+		XStoreColors(display, map, xcolours, ncolours);
 
-		/* byte swap here to make translate_image faster */
-		map[i] = translate_colour(colour);
+		xfree(xcolours);
+		return (HCOLOURMAP) map;
 	}
-
-	return map;
 }
 
 void
 ui_destroy_colourmap(HCOLOURMAP map)
 {
-	xfree(map);
+	if (!owncolmap)
+		xfree(map);
+	else
+		XFreeColormap(display, (Colormap) map);
 }
 
 void
 ui_set_colourmap(HCOLOURMAP map)
 {
-	colmap = map;
+	if (!owncolmap)
+		colmap = map;
+	else
+		XSetWindowColormap(display, wnd, (Colormap) map);
 }
 
 void
@@ -1126,6 +1459,7 @@
 	FILL_RECTANGLE(x, y, cx, cy);
 }
 
+/* warning, this function only draws on wnd or backstore, not both */
 void
 ui_draw_glyph(int mixmode,
 	      /* dest */ int x, int y, int cx, int cy,
@@ -1140,7 +1474,7 @@
 	XSetStipple(display, gc, (Pixmap) glyph);
 	XSetTSOrigin(display, gc, x, y);
 
-	FILL_RECTANGLE(x, y, cx, cy);
+	FILL_RECTANGLE_BACKSTORE(x, y, cx, cy);
 
 	XSetFillStyle(display, gc, FillSolid);
 }
@@ -1169,8 +1503,8 @@
     }\
   if (glyph != NULL)\
     {\
-      ui_draw_glyph (mixmode, x + (short) glyph->offset,\
-		     y + (short) glyph->baseline,\
+      ui_draw_glyph (mixmode, x + glyph->offset,\
+		     y + glyph->baseline,\
 		     glyph->width, glyph->height,\
 		     glyph->pixmap, 0, 0, bgcolour, fgcolour);\
       if (flags & TEXT2_IMPLICIT_X)\
@@ -1192,11 +1526,11 @@
 
 	if (boxcx > 1)
 	{
-		FILL_RECTANGLE(boxx, boxy, boxcx, boxcy);
+		FILL_RECTANGLE_BACKSTORE(boxx, boxy, boxcx, boxcy);
 	}
 	else if (mixmode == MIX_OPAQUE)
 	{
-		FILL_RECTANGLE(clipx, clipy, clipcx, clipcy);
+		FILL_RECTANGLE_BACKSTORE(clipx, clipy, clipcx, clipcy);
 	}
 
 	/* Paint text, character by character */
@@ -1230,17 +1564,17 @@
 						else
 							x += text[i + 2];
 					}
-					if (i + 2 < length)
-						i += 3;
-					else
-						i += 2;
-					length -= i;
-					/* this will move pointer from start to first character after FE command */
-					text = &(text[i]);
-					i = 0;
 					for (j = 0; j < entry->size; j++)
 						DO_GLYPH(((uint8 *) (entry->data)), j);
 				}
+				if (i + 2 < length)
+					i += 3;
+				else
+					i += 2;
+				length -= i;
+				/* this will move pointer from start to first character after FE command */
+				text = &(text[i]);
+				i = 0;
 				break;
 
 			default:
@@ -1249,8 +1583,15 @@
 				break;
 		}
 	}
-
-
+	if (ownbackstore)
+	{
+		if (boxcx > 1)
+			XCopyArea(display, backstore, wnd, gc, boxx,
+				  boxy, boxcx, boxcy, boxx, boxy);
+		else
+			XCopyArea(display, backstore, wnd, gc, clipx,
+				  clipy, clipcx, clipcy, clipx, clipy);
+	}
 }
 
 void