--- sourceforge.net/trunk/rdesktop/xwin.c	2003/02/05 14:16:33	311
+++ sourceforge.net/trunk/rdesktop/xwin.c	2003/05/15 14:26:15	373
@@ -32,6 +32,7 @@
 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;
@@ -58,6 +59,11 @@
 static BOOL ownbackstore;
 static Pixmap backstore;
 
+/* Moving in single app mode */
+static BOOL moving_wnd;
+static int move_x_offset = 0;
+static int move_y_offset = 0;
+
 /* MWM decorations */
 #define MWM_HINTS_DECORATIONS   (1L << 1)
 #define PROP_MOTIF_WM_HINTS_ELEMENTS    5
@@ -71,6 +77,13 @@
 }
 PropMotifWmHints;
 
+typedef struct
+{
+	uint32 red;
+	uint32 green;
+	uint32 blue;
+}
+PixelColour;
 
 #define FILL_RECTANGLE(x,y,cx,cy)\
 { \
@@ -115,7 +128,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;
@@ -137,31 +150,61 @@
 			(unsigned char *) &motif_hints, PROP_MOTIF_WM_HINTS_ELEMENTS);
 }
 
-uint32
-colour16to24(uint32 colour)
+static PixelColour
+split_colour15(uint32 colour)
 {
-	int r;
-	int g;
-	int b;
-	r = (colour & 0xf800) >> 11;
-	r = (r * 0xff) / 0x1f;
-	g = (colour & 0x07e0) >> 5;
-	g = (g * 0xff) / 0x3f;
-	b = (colour & 0x001f);
-	b = (b * 0xff) / 0x1f;
-	return (r << 16) | (g << 8) | b;
+	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;
 }
 
-uint32
-colour16to32(uint32 colour)
+static uint32
+make_colour16(PixelColour pc)
 {
-	return colour16to24(colour);
+	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;
 }
 
-uint32
-colour24to32(uint32 colour)
+static uint32
+make_colour24(PixelColour pc)
 {
-	return colour;
+	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)); }
@@ -174,26 +217,43 @@
 {
 	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 = colour16to24(colour);
+					colour = make_colour24(split_colour16(colour));
 					break;
 				case 32:
-					colour = colour16to32(colour);
+					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 = colour24to32(colour);
+					colour = make_colour32(split_colour24(colour));
 					break;
 			}
 			break;
@@ -233,22 +293,45 @@
 		*(out++) = (uint16) colmap[*(data++)];
 }
 
+/* little endian - conversion happens when colourmap is built */
 static void
-translate16to16(uint16 * data, uint16 * out, uint16 * end)
+translate8to24(uint8 * data, uint8 * out, uint8 * end)
 {
+	uint32 value;
+
 	while (out < end)
-		*(out++) = (uint16) translate_colour(*(data++));
+	{
+		value = colmap[*(data++)];
+		*(out++) = value;
+		*(out++) = value >> 8;
+		*(out++) = value >> 16;
+	}
 }
 
-/* little endian - conversion happens when colourmap is built */
 static void
-translate8to24(uint8 * data, uint8 * out, uint8 * end)
+translate8to32(uint8 * data, uint32 * out, uint32 * end)
+{
+	while (out < end)
+		*(out++) = colmap[*(data++)];
+}
+
+/* todo the remaining translate function might need some big endian check ?? */
+
+static void
+translate15to16(uint16 * data, uint16 * out, uint16 * end)
+{
+	while (out < end)
+		*(out++) = (uint16) make_colour16(split_colour15(*(data++)));
+}
+
+static void
+translate15to24(uint16 * data, uint8 * out, uint8 * end)
 {
 	uint32 value;
 
 	while (out < end)
 	{
-		value = colmap[*(data++)];
+		value = make_colour24(split_colour15(*(data++)));
 		*(out++) = value;
 		*(out++) = value >> 8;
 		*(out++) = value >> 16;
@@ -256,13 +339,28 @@
 }
 
 static void
+translate15to32(uint16 * data, uint32 * out, uint32 * end)
+{
+	while (out < end)
+		*(out++) = make_colour32(split_colour15(*(data++)));
+}
+
+static void
+translate16to16(uint16 * data, uint16 * out, uint16 * end)
+{
+	while (out < end)
+		*(out++) = (uint16) (*(data++));
+}
+
+
+static void
 translate16to24(uint16 * data, uint8 * out, uint8 * end)
 {
 	uint32 value;
 
 	while (out < end)
 	{
-		value = translate_colour(*(data++));
+		value = make_colour24(split_colour16(*(data++)));
 		*(out++) = value;
 		*(out++) = value >> 8;
 		*(out++) = value >> 16;
@@ -270,17 +368,45 @@
 }
 
 static void
-translate8to32(uint8 * data, uint32 * out, uint32 * end)
+translate16to32(uint16 * data, uint32 * out, uint32 * end)
 {
 	while (out < end)
-		*(out++) = colmap[*(data++)];
+		*(out++) = make_colour32(split_colour16(*(data++)));
 }
 
 static void
-translate16to32(uint16 * data, uint32 * out, uint32 * end)
+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 void
+translate24to24(uint8 * data, uint8 * out, uint8 * end)
 {
 	while (out < end)
-		*(out++) = translate_colour(*(data++));
+	{
+		*(out++) = (*(data++));
+	}
+}
+
+static void
+translate24to32(uint8 * data, uint32 * out, uint32 * end)
+{
+	uint32 pixel = 0;
+	while (out < end)
+	{
+		pixel = *(data++);
+		pixel |= *(data++) << 8;
+		pixel |= *(data++) << 16;
+		*(out++) = pixel;
+	}
 }
 
 static uint8 *
@@ -290,36 +416,72 @@
 	uint8 *out = xmalloc(size);
 	uint8 *end = out + size;
 
-	if (server_bpp == 16)
-	{
-		if (bpp == 16)
-			translate16to16((uint16 *) data, (uint16 *) out, (uint16 *) end);
-		else if (bpp == 24)
-			translate16to24((uint16 *) data, out, end); /* todo, check this one */
-		else if (bpp == 32)
-			translate16to32((uint16 *) data, (uint32 *) out, (uint32 *) end);
-		return out;
-	}
-	/* todo needs server_bpp == 24 */
-	switch (bpp)
+	switch (server_bpp)
 	{
-		case 8:
-			translate8to8(data, out, end);
+		case 24:
+			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 16:
-			translate8to16(data, (uint16 *) out, (uint16 *) end);
+			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 24:
-			translate8to24(data, out, end);
+		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 32:
-			translate8to32(data, (uint32 *) out, (uint32 *) end);
+		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 out;
 }
 
@@ -448,6 +610,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;
 }
 
@@ -695,11 +861,68 @@
 				if (button == 0)
 					break;
 
+				/* If win_button_size is nonzero, enable single app mode */
+				if (xevent.xbutton.y < win_button_size)
+				{
+					/* Stop moving window when button is released, regardless of cursor position */
+					if (moving_wnd && (xevent.type == ButtonRelease))
+						moving_wnd = False;
+
+					/*  Check from right to left: */
+
+					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;
+					}
+					else if (xevent.xbutton.x <= win_button_size)
+					{
+						/* The system menu. Ignore. */
+						break;
+					}
+					else
+					{
+						/* The title bar. */
+						if ((xevent.type == ButtonPress) && !fullscreen
+						    && hide_decorations)
+						{
+							moving_wnd = True;
+							move_x_offset = xevent.xbutton.x;
+							move_y_offset = xevent.xbutton.y;
+						}
+						break;
+
+					}
+				}
+
 				rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
 					       flags | button, xevent.xbutton.x, xevent.xbutton.y);
 				break;
 
 			case MotionNotify:
+				if (moving_wnd)
+				{
+					XMoveWindow(display, wnd,
+						    xevent.xmotion.x_root - move_x_offset,
+						    xevent.xmotion.y_root - move_y_offset);
+					break;
+				}
+
 				if (fullscreen && !focused)
 					XSetInputFocus(display, wnd, RevertToPointerRoot,
 						       CurrentTime);
@@ -1148,6 +1371,15 @@
 	RESET_FUNCTION(opcode);
 }
 
+static uint8 hatch_patterns[] = {
+	0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, /* 0 - bsHorizontal */
+	0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, /* 1 - bsVertical */
+	0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01, /* 2 - bsFDiagonal */
+	0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, /* 3 - bsBDiagonal */
+	0x08, 0x08, 0x08, 0xff, 0x08, 0x08, 0x08, 0x08, /* 4 - bsCross */
+	0x81, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x81  /* 5 - bsDiagCross */
+};
+
 void
 ui_patblt(uint8 opcode,
 	  /* dest */ int x, int y, int cx, int cy,
@@ -1165,6 +1397,19 @@
 			FILL_RECTANGLE(x, y, cx, cy);
 			break;
 
+		case 2:	/* Hatch */
+			fill = (Pixmap) ui_create_glyph(8, 8, hatch_patterns + brush->pattern[0] * 8);
+			SET_FOREGROUND(bgcolour);
+			SET_BACKGROUND(fgcolour);
+			XSetFillStyle(display, gc, FillOpaqueStippled);
+			XSetStipple(display, gc, fill);
+			XSetTSOrigin(display, gc, brush->xorigin, brush->yorigin);
+			FILL_RECTANGLE(x, y, cx, cy);
+			XSetFillStyle(display, gc, FillSolid);
+			XSetTSOrigin(display, gc, 0, 0);
+			ui_destroy_glyph((HGLYPH) fill);
+			break;
+
 		case 3:	/* Pattern */
 			for (i = 0; i != 8; i++)
 				ipattern[7 - i] = brush->pattern[i];