--- sourceforge.net/trunk/rdesktop/xwin.c	2002/07/14 04:20:25	59
+++ sourceforge.net/trunk/rdesktop/xwin.c	2002/11/11 23:15:27	257
@@ -1,7 +1,7 @@
 /*
    rdesktop: A Remote Desktop Protocol client.
    User interface services - X Window System
-   Copyright (C) Matthew Chapman 1999-2001
+   Copyright (C) Matthew Chapman 1999-2002
 
    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
@@ -20,26 +20,32 @@
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
-#include <X11/XKBlib.h>
 #include <time.h>
 #include <errno.h>
 #include "rdesktop.h"
 
-extern char keymapname[16];
-extern int keylayout;
 extern int width;
 extern int height;
 extern BOOL sendmotion;
 extern BOOL fullscreen;
+extern BOOL grab_keyboard;
+extern char title[];
+BOOL enable_compose = False;
+BOOL focused;
+BOOL mouse_in_wnd;
 
 Display *display;
-XkbDescPtr xkb;
 static int x_socket;
+static Screen *screen;
 static Window wnd;
 static GC gc;
 static Visual *visual;
 static int depth;
 static int bpp;
+static XIM IM;
+static XIC IC;
+static XModifierKeymap *mod_map;
+static Cursor current_cursor;
 
 /* endianness */
 static BOOL host_be;
@@ -49,23 +55,6 @@
 static BOOL ownbackstore;
 static Pixmap backstore;
 
-/* needed to keep track of the modifiers */
-static unsigned int numlock_modifier_mask = 0;
-static unsigned int key_down_state = 0;
-
-
-#define DShift1Mask   (1<<0)
-#define DLockMask     (1<<1)
-#define DControl1Mask (1<<2)
-#define DMod1Mask     (1<<3)
-#define DMod2Mask     (1<<4)
-#define DMod3Mask     (1<<5)
-#define DMod4Mask     (1<<6)
-#define DMod5Mask     (1<<7)
-#define DShift2Mask   (1<<8)
-#define DControl2Mask (1<<9)
-#define DNumLockMask  (1<<10)
-
 #define FILL_RECTANGLE(x,y,cx,cy)\
 { \
 	XFillRectangle(display, wnd, gc, x, y, cx, cy); \
@@ -74,14 +63,11 @@
 }
 
 /* colour maps */
-static BOOL owncolmap;
 static Colormap xcolmap;
-static uint32 white;
 static uint32 *colmap;
 
-#define TRANSLATE(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));
+#define SET_FOREGROUND(col)	XSetForeground(display, gc, translate_colour(colmap[col]));
+#define SET_BACKGROUND(col)	XSetBackground(display, gc, translate_colour(colmap[col]));
 
 static int rop2_map[] = {
 	GXclear,		/* 0 */
@@ -105,28 +91,23 @@
 #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 xwin_get_numlock_mask();
-void xwin_mod_update(uint32 state, uint32 ev_time );
-void xwin_mod_release(uint32 state, uint32 ev_time, uint32 scancode);
-void xwin_mod_press(uint32 state, uint32 ev_time, uint32 scancode);
-
 static void
-translate8(uint8 *data, uint8 *out, uint8 *end)
+translate8(uint8 * data, uint8 * out, uint8 * end)
 {
 	while (out < end)
-		*(out++) = (uint8)colmap[*(data++)];
+		*(out++) = (uint8) colmap[*(data++)];
 }
 
 static void
-translate16(uint8 *data, uint16 *out, uint16 *end)
+translate16(uint8 * data, uint16 * out, uint16 * end)
 {
 	while (out < end)
-		*(out++) = (uint16)colmap[*(data++)];
+		*(out++) = (uint16) colmap[*(data++)];
 }
 
 /* little endian - conversion happens when colourmap is built */
 static void
-translate24(uint8 *data, uint8 *out, uint8 *end)
+translate24(uint8 * data, uint8 * out, uint8 * end)
 {
 	uint32 value;
 
@@ -140,16 +121,16 @@
 }
 
 static void
-translate32(uint8 *data, uint32 *out, uint32 *end)
+translate32(uint8 * data, uint32 * out, uint32 * end)
 {
 	while (out < end)
 		*(out++) = colmap[*(data++)];
 }
 
 static uint8 *
-translate_image(int width, int height, uint8 *data)
+translate_image(int width, int height, uint8 * data)
 {
-	int size = width * height * bpp/8;
+	int size = width * height * bpp / 8;
 	uint8 *out = xmalloc(size);
 	uint8 *end = out + size;
 
@@ -160,7 +141,7 @@
 			break;
 
 		case 16:
-			translate16(data, (uint16 *)out, (uint16 *)end);
+			translate16(data, (uint16 *) out, (uint16 *) end);
 			break;
 
 		case 24:
@@ -168,7 +149,7 @@
 			break;
 
 		case 32:
-			translate32(data, (uint32 *)out, (uint32 *)end);
+			translate32(data, (uint32 *) out, (uint32 *) end);
 			break;
 	}
 
@@ -205,53 +186,41 @@
 }
 
 BOOL
-ui_create_window(char *title)
+get_key_state(unsigned int state, uint32 keysym)
 {
-	XSetWindowAttributes attribs;
-	XClassHint *classhints;
-	XSizeHints *sizehints;
-	unsigned long input_mask;
-	XPixmapFormatValues *pfm;
-	Screen *screen;
-	uint16 test;
-	int i;
-	
-	int xkb_minor, xkb_major;
-	int xkb_event, xkb_error, xkb_reason;
-
-	/* compare compiletime libs with runtime libs. */
-	xkb_major = XkbMajorVersion;
-	xkb_minor = XkbMinorVersion;
-	if( XkbLibraryVersion( &xkb_major, &xkb_minor ) == False )
-	{
-		error("please re-compile rdesktop\ncompile time version of xkb is not compatible with\nyour runtime version of the library\n");
-		return False;
-	}
+	int modifierpos, key, keysymMask = 0;
+	int offset;
+
+	KeyCode keycode = XKeysymToKeycode(display, keysym);
 
+	if (keycode == NoSymbol)
+		return False;
 
-	display = XkbOpenDisplay( NULL, &xkb_event, &xkb_error, &xkb_major, &xkb_minor, &xkb_reason );
-	switch(xkb_reason)
+	for (modifierpos = 0; modifierpos < 8; modifierpos++)
 	{
-		case XkbOD_BadLibraryVersion:
-			error("XkbOD_BadLibraryVersion: XKB extensions in server and the library rdesktop is linked against aren't compatible with each other.\n");
-			break;
-		case XkbOD_ConnectionRefused:
-			error("XkbOD_ConnectionRefused\n");
-			break;
-		case XkbOD_BadServerVersion:
-			error("XkbOD_BadServerVersion\n");
-			break;
-		case XkbOD_NonXkbServer:
-			error("XkbOD_NonXkbServer: XKB extension not present in server\nupdate your X server.\n");
-			break;
-		case XkbOD_Success:
-			DEBUG("XkbOD_Success: Connection established with display\n");
-			break;
+		offset = mod_map->max_keypermod * modifierpos;
+
+		for (key = 0; key < mod_map->max_keypermod; key++)
+		{
+			if (mod_map->modifiermap[offset + key] == keycode)
+				keysymMask |= 1 << modifierpos;
+		}
 	}
 
+	return (state & keysymMask) ? True : False;
+}
+
+BOOL
+ui_init(void)
+{
+	XPixmapFormatValues *pfm;
+	uint16 test;
+	int i;
+
+	display = XOpenDisplay(NULL);
 	if (display == NULL)
 	{
-		error("Failed to open display\n");
+		error("Failed to open display: %s\n", XDisplayName(NULL));
 		return False;
 	}
 
@@ -259,7 +228,7 @@
 	screen = DefaultScreenOfDisplay(display);
 	visual = DefaultVisualOfScreen(screen);
 	depth = DefaultDepthOfScreen(screen);
-	
+
 	pfm = XListPixmapFormats(display, &i);
 	if (pfm != NULL)
 	{
@@ -267,8 +236,7 @@
 		   desirable, e.g. 24 bits->32 bits. */
 		while (i--)
 		{
-			if ((pfm[i].depth == depth)
-			    && (pfm[i].bits_per_pixel > bpp))
+			if ((pfm[i].depth == depth) && (pfm[i].bits_per_pixel > bpp))
 			{
 				bpp = pfm[i].bits_per_pixel;
 			}
@@ -283,40 +251,80 @@
 		return False;
 	}
 
-	if (depth <= 8)
-		owncolmap = True;
-	else
-		xcolmap = DefaultColormapOfScreen(screen);
+	xcolmap = DefaultColormapOfScreen(screen);
+	gc = XCreateGC(display, RootWindowOfScreen(screen), 0, NULL);
+
+	if (DoesBackingStore(screen) != Always)
+		ownbackstore = True;
 
 	test = 1;
-	host_be = !(BOOL)(*(uint8 *)(&test));
+	host_be = !(BOOL) (*(uint8 *) (&test));
 	xserver_be = (ImageByteOrder(display) == MSBFirst);
 
-	white = WhitePixelOfScreen(screen);
-	attribs.background_pixel = BlackPixelOfScreen(screen);
-	attribs.backing_store = DoesBackingStore(screen);
-
-	if (attribs.backing_store == NotUseful)
-		ownbackstore = True;
-
 	if (fullscreen)
 	{
-		attribs.override_redirect = True;
 		width = WidthOfScreen(screen);
 		height = HeightOfScreen(screen);
 	}
-	else
+
+	/* make sure width is a multiple of 4 */
+	width = (width + 3) & ~3;
+
+	if (ownbackstore)
 	{
-		attribs.override_redirect = False;
+		backstore =
+			XCreatePixmap(display, RootWindowOfScreen(screen), width, height, depth);
+
+		/* clear to prevent rubbish being exposed at startup */
+		XSetForeground(display, gc, BlackPixelOfScreen(screen));
+		XFillRectangle(display, backstore, gc, 0, 0, width, height);
 	}
 
-	width = (width + 3) & ~3; /* make width a multiple of 32 bits */
+	mod_map = XGetModifierMapping(display);
+
+	if (enable_compose)
+		IM = XOpenIM(display, NULL, NULL, NULL);
+
+	xkeymap_init();
+	return True;
+}
+
+void
+ui_deinit(void)
+{
+	if (IM != NULL)
+		XCloseIM(IM);
+
+	XFreeModifiermap(mod_map);
 
-	wnd = XCreateWindow(display, RootWindowOfScreen(screen),
-			    0, 0, width, height, 0, CopyFromParent,
-			    InputOutput, CopyFromParent,
-			    CWBackingStore | CWBackPixel | CWOverrideRedirect,
-			    &attribs);
+	if (ownbackstore)
+		XFreePixmap(display, backstore);
+
+	XFreeGC(display, gc);
+	XCloseDisplay(display);
+	display = NULL;
+}
+
+BOOL
+ui_create_window(void)
+{
+	XSetWindowAttributes attribs;
+	XClassHint *classhints;
+	XSizeHints *sizehints;
+	int wndwidth, wndheight;
+	long input_mask, ic_input_mask;
+	XEvent xevent;
+
+	wndwidth = fullscreen ? WidthOfScreen(screen) : width;
+	wndheight = fullscreen ? HeightOfScreen(screen) : height;
+
+	attribs.background_pixel = BlackPixelOfScreen(screen);
+	attribs.backing_store = ownbackstore ? NotUseful : Always;
+	attribs.override_redirect = fullscreen;
+
+	wnd = XCreateWindow(display, RootWindowOfScreen(screen), 0, 0, wndwidth, wndheight,
+			    0, CopyFromParent, InputOutput, CopyFromParent,
+			    CWBackPixel | CWBackingStore | CWOverrideRedirect, &attribs);
 
 	XStoreName(display, wnd, title);
 
@@ -338,137 +346,164 @@
 		XFree(sizehints);
 	}
 
-	xkeymap_init();
+	input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
+		VisibilityChangeMask | FocusChangeMask;
 
-	input_mask = KeyPressMask | KeyReleaseMask |
-			 ButtonPressMask | ButtonReleaseMask |
-			 EnterWindowMask | LeaveWindowMask;
 	if (sendmotion)
 		input_mask |= PointerMotionMask;
-
 	if (ownbackstore)
 		input_mask |= ExposureMask;
+	if (fullscreen || grab_keyboard)
+		input_mask |= EnterWindowMask;
+	if (grab_keyboard)
+		input_mask |= LeaveWindowMask;
+
+	if (IM != NULL)
+	{
+		IC = XCreateIC(IM, XNInputStyle, (XIMPreeditNothing | XIMStatusNothing),
+			       XNClientWindow, wnd, XNFocusWindow, wnd, NULL);
+
+		if ((IC != NULL)
+		    && (XGetICValues(IC, XNFilterEvents, &ic_input_mask, NULL) == NULL))
+			input_mask |= ic_input_mask;
+	}
 
 	XSelectInput(display, wnd, input_mask);
-	gc = XCreateGC(display, wnd, 0, NULL);
-
-	if (ownbackstore)
-		backstore = XCreatePixmap(display, wnd, width, height, depth);
-
 	XMapWindow(display, wnd);
 
-	/* TODO: error texts... make them friendly. */
-	xkb = XkbGetKeyboard(display, XkbAllComponentsMask, XkbUseCoreKbd);
-	if ((int)xkb == BadAlloc || xkb == NULL)
-      	{
-        		error( "XkbGetKeyboard failed.\n");
-        		exit(0);
-      	}
-
-	/* TODO: error texts... make them friendly. */
-	if( XkbSelectEvents(display, xkb->device_spec, XkbAllEventsMask, XkbAllEventsMask) == False )
+	/* wait for VisibilityNotify */
+	do
 	{
-			error( "XkbSelectEvents failed.\n");
-			exit(0);
+		XMaskEvent(display, VisibilityChangeMask, &xevent);
 	}
-	
-	xwin_get_numlock_mask();
+	while (xevent.type != VisibilityNotify);
+
+	focused = False;
+	mouse_in_wnd = False;
 
 	return True;
 }
 
 void
-xwin_get_numlock_mask()
+ui_destroy_window(void)
 {
-	KeyCode numlockcode;
-	KeyCode* keycode;
-	XModifierKeymap *modmap;
-	int i,j;
-
-	/* Find out if numlock is already defined as a modifier key, and if so where */
-	numlockcode = XKeysymToKeycode(display, 0xFF7F);	/* XF_Num_Lock = 0xFF7F */
-	if (numlockcode) {
-		modmap = XGetModifierMapping(display);
-		if (modmap) {
-			keycode = modmap->modifiermap;
-			for (i = 0; i < 8; i++)
-				for (j = modmap->max_keypermod; j--;) {
-					if (*keycode == numlockcode) {
-						numlock_modifier_mask = (1 << i);
-						i = 8;
-						break;
-					}
-					keycode++;
-				}
-		if (!numlock_modifier_mask) {
-				modmap->modifiermap[7 * modmap->max_keypermod] = numlockcode;
-				if (XSetModifierMapping(display, modmap) == MappingSuccess)
-					numlock_modifier_mask = (1 << 7);
-				else
-					printf("XSetModifierMapping failed!\n");
-			}
-			XFreeModifiermap(modmap);
-		}
-	}
+	if (IC != NULL)
+		XDestroyIC(IC);
 
-	if (!numlock_modifier_mask)
-		printf("WARNING: Failed to get a numlock modifier mapping.\n");
-		
+	XDestroyWindow(display, wnd);
 }
 
 void
-ui_destroy_window()
+xwin_toggle_fullscreen(void)
 {
-	if( xkb != NULL )
-		XkbFreeKeyboard(xkb, XkbAllControlsMask, True);
+	Pixmap contents = 0;
 
-	if (ownbackstore)
-		XFreePixmap(display, backstore);
+	if (!ownbackstore)
+	{
+		/* need to save contents of window */
+		contents = XCreatePixmap(display, wnd, width, height, depth);
+		XCopyArea(display, wnd, contents, gc, 0, 0, width, height, 0, 0);
+	}
 
-	XFreeGC(display, gc);
-	XDestroyWindow(display, wnd);
-	XCloseDisplay(display);
-	display = NULL;
+	ui_destroy_window();
+	fullscreen = !fullscreen;
+	ui_create_window();
+
+	XDefineCursor(display, wnd, current_cursor);
+
+	if (!ownbackstore)
+	{
+		XCopyArea(display, contents, wnd, gc, 0, 0, width, height, 0, 0);
+		XFreePixmap(display, contents);
+	}
 }
 
+/* Process all events in Xlib queue */
 static void
-xwin_process_events()
+xwin_process_events(void)
 {
 	XEvent xevent;
-
 	KeySym keysym;
-	uint8 scancode;
 	uint16 button, flags;
 	uint32 ev_time;
-	uint32 tmpmods;
+	key_translation tr;
+	char str[256];
+	Status status;
+	unsigned int state;
+	Window wdummy;
+	int dummy;
 
-	while (XCheckMaskEvent(display, ~0, &xevent))
+	while (XPending(display) > 0)
 	{
-		ev_time = time(NULL);
+		XNextEvent(display, &xevent);
+
+		if ((IC != NULL) && (XFilterEvent(&xevent, None) == True))
+		{
+			DEBUG_KBD(("Filtering event\n"));
+			continue;
+		}
+
 		flags = 0;
 
 		switch (xevent.type)
 		{
-			case KeyRelease:
-				flags = KBD_FLAG_DOWN | KBD_FLAG_UP;
-				/* fall through */
 			case KeyPress:
-				if( XkbTranslateKeyCode(xkb, xevent.xkey.keycode, xevent.xkey.state, &tmpmods, &keysym) == False )
+				if (IC != NULL)
+					/* Multi_key compatible version */
+				{
+					XmbLookupString(IC,
+							(XKeyPressedEvent *) &
+							xevent, str, sizeof(str), &keysym, &status);
+					if (!((status == XLookupKeySym) || (status == XLookupBoth)))
+					{
+						error("XmbLookupString failed with status 0x%x\n",
+						      status);
+						break;
+					}
+				}
+				else
+				{
+					/* Plain old XLookupString */
+					DEBUG_KBD(("\nNo input context, using XLookupString\n"));
+					XLookupString((XKeyEvent *) & xevent,
+						      str, sizeof(str), &keysym, NULL);
+				}
+
+				DEBUG_KBD(("KeyPress for (keysym 0x%lx, %s)\n", keysym, get_ksname(keysym)));
+
+				ev_time = time(NULL);
+				if (handle_special_keys(keysym, xevent.xkey.state, ev_time, True))
 					break;
-				scancode = xkeymap_translate_key(keysym, xevent.xkey.keycode, &flags);
 
-				if (scancode == 0 )
+				tr = xkeymap_translate_key(keysym,
+							   xevent.xkey.keycode, xevent.xkey.state);
+
+				if (tr.scancode == 0)
 					break;
 
-				/* keep track of the modifiers -- needed for stickykeys... */
-				if( xevent.type == KeyPress )
-					xwin_mod_press( xevent.xkey.state, ev_time, scancode );
+				ensure_remote_modifiers(ev_time, tr);
+
+				rdp_send_scancode(ev_time, RDP_KEYPRESS, tr.scancode);
+				break;
+
+			case KeyRelease:
+				XLookupString((XKeyEvent *) & xevent, str,
+					      sizeof(str), &keysym, NULL);
+
+				DEBUG_KBD(("\nKeyRelease for (keysym 0x%lx, %s)\n", keysym,
+					   get_ksname(keysym)));
+
+				ev_time = time(NULL);
+				if (handle_special_keys(keysym, xevent.xkey.state, ev_time, False))
+					break;
 
-				rdp_send_input(ev_time, RDP_INPUT_SCANCODE, flags, scancode, 0);
+				tr = xkeymap_translate_key(keysym,
+							   xevent.xkey.keycode, xevent.xkey.state);
 
-				if( xevent.type == KeyRelease )
-					xwin_mod_release( xevent.xkey.state, ev_time, scancode );
+				if (tr.scancode == 0)
+					break;
 
+				rdp_send_scancode(ev_time, RDP_KEYRELEASE, tr.scancode);
 				break;
 
 			case ButtonPress:
@@ -480,209 +515,96 @@
 				if (button == 0)
 					break;
 
-				rdp_send_input(ev_time, RDP_INPUT_MOUSE,
-					       flags | button,
-					       xevent.xbutton.x,
-					       xevent.xbutton.y);
+				rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
+					       flags | button, xevent.xbutton.x, xevent.xbutton.y);
 				break;
 
 			case MotionNotify:
-				rdp_send_input(ev_time, RDP_INPUT_MOUSE,
-					       MOUSE_FLAG_MOVE,
-					       xevent.xmotion.x,
-					       xevent.xmotion.y);
+				rdp_send_input(time(NULL), RDP_INPUT_MOUSE,
+					       MOUSE_FLAG_MOVE, xevent.xmotion.x, xevent.xmotion.y);
 				break;
 
-			case EnterNotify:
-				XGrabKeyboard(display, wnd, True, GrabModeAsync,
-					      GrabModeAsync, CurrentTime);
+			case FocusIn:
+				if (xevent.xfocus.mode == NotifyGrab)
+					break;
+				focused = True;
+				XQueryPointer(display, wnd, &wdummy, &wdummy, &dummy, &dummy, &dummy, &dummy, &state);
+				reset_modifier_keys(state);
+				if (grab_keyboard && mouse_in_wnd)
+					XGrabKeyboard(display, wnd, True,
+						      GrabModeAsync, GrabModeAsync, CurrentTime);
+				break;
 
-				 xwin_mod_update( xevent.xcrossing.state, ev_time );
+			case FocusOut:
+				if (xevent.xfocus.mode == NotifyUngrab)
+					break;
+				focused = False;
+				if (xevent.xfocus.mode == NotifyWhileGrabbed)
+					XUngrabKeyboard(display, CurrentTime);
+				break;
+
+			case EnterNotify:
+				/* we only register for this event when in fullscreen mode */
+				/* or grab_keyboard */
+				mouse_in_wnd = True;
+				if (fullscreen)
+				{
+					XSetInputFocus(display, wnd, RevertToPointerRoot, CurrentTime);
+					break;
+				}
+				if (focused)
+					XGrabKeyboard(display, wnd, True,
+						      GrabModeAsync, GrabModeAsync, CurrentTime);
 				break;
 
 			case LeaveNotify:
+				/* we only register for this event when grab_keyboard */
+				mouse_in_wnd = False;
 				XUngrabKeyboard(display, CurrentTime);
 				break;
 
 			case Expose:
 				XCopyArea(display, backstore, wnd, gc,
 					  xevent.xexpose.x, xevent.xexpose.y,
-					  xevent.xexpose.width, xevent.xexpose.height,
+					  xevent.xexpose.width,
+					  xevent.xexpose.height,
 					  xevent.xexpose.x, xevent.xexpose.y);
 				break;
-		}
-	}
-}
 
-void
-xwin_mod_update(uint32 state, uint32 ev_time )
-{
-	xwin_mod_press(state, ev_time, 0);
-	xwin_mod_release(state, ev_time, 0);
-}
-
-void
-xwin_mod_release(uint32 state, uint32 ev_time, uint32 scancode)
-{
-	switch (scancode) {
-	case 0x2a:
-		key_down_state &= ~DShift1Mask;
-		break;
-	case 0x36:
-		key_down_state &= ~DShift2Mask;
-		break;
-	case 0x1d:
-		key_down_state &= ~DControl1Mask;
-		break;
-	case 0x9d:
-		key_down_state &= ~DControl2Mask;
-		break;
-	case 0x38:
-		key_down_state &= ~DMod1Mask;
-		break;
-	case 0xb8:
-		key_down_state &= ~DMod2Mask;
-		break;
-	}
-
-	if( !(numlock_modifier_mask & state) && (key_down_state & DNumLockMask) )
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x45, 0);
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN | KBD_FLAG_UP, 0x45, 0);
-		key_down_state &= ~DNumLockMask;
-	}
-
-	if( !(LockMask & state) && (key_down_state & DLockMask))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x3a, 0);
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN | KBD_FLAG_UP, 0x3a, 0);
-		key_down_state &= ~DLockMask;
-
-	}
-
-
-	if( !(ShiftMask & state) && (key_down_state & DShift1Mask))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x2a, 0);
-		key_down_state &= ~DShift1Mask;
-
-	}
-
-	if( !(ControlMask & state) && (key_down_state & DControl1Mask))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x1d, 0);
-		key_down_state &= ~DControl1Mask;
-
-	}
-
-	if( !(Mod1Mask & state) && (key_down_state & DMod1Mask))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0x38, 0);
-		key_down_state &= ~DMod1Mask;
-
-	}
-
-	if( !(Mod2Mask & state) && (key_down_state & DMod2Mask))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_UP, 0xb8, 0);
-		key_down_state &= ~DMod2Mask;
-	}
-}
-
-
-void
-xwin_mod_press(uint32 state, uint32 ev_time, uint32 scancode)
-{
-
-	switch (scancode) {
-	case 0x2a:
-		key_down_state |= DShift1Mask;
-		break;
-	case 0x36:
-		key_down_state |= DShift2Mask;
-		break;
-	case 0x1d:
-		key_down_state |= DControl1Mask;
-		break;
-	case 0x9d:
-		key_down_state |= DControl2Mask;
-		break;
-	case 0x3a:
-		key_down_state ^= DLockMask;
-		break;
-	case 0x45:
-		key_down_state ^= DNumLockMask;
-		break;
-	case 0x38:
-		key_down_state |= DMod1Mask;
-		break;
-	case 0xb8:
-		key_down_state |= DMod2Mask;
-		break;
-	}
-
-	if( (numlock_modifier_mask && state) && !(key_down_state & DNumLockMask) )
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x45, 0);
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN | KBD_FLAG_UP, 0x45, 0);
-		key_down_state |= DNumLockMask;
-	}
-
-	if( (LockMask & state) && !(key_down_state & DLockMask))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, 0, 0x3a, 0);
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN | KBD_FLAG_UP, 0x3a, 0);
-		key_down_state |= DLockMask;
-
-	}
-
-
-	if( (ShiftMask & state) && !((key_down_state & DShift1Mask) || (key_down_state & DShift2Mask)))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN, 0x2a, 0);
-		key_down_state |= DShift1Mask;
+			case MappingNotify:
+				/* Refresh keyboard mapping if it has changed. This is important for
+				   Xvnc, since it allocates keycodes dynamically */
+				if (xevent.xmapping.request == MappingKeyboard
+				    || xevent.xmapping.request == MappingModifier)
+					XRefreshKeyboardMapping(&xevent.xmapping);
 
-	}
-
-	if( (ControlMask & state) && !((key_down_state & DControl1Mask) || (key_down_state & DControl2Mask)))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN, 0x1d, 0);
-		key_down_state |= DControl1Mask;
-
-	}
-
-	if( (Mod1Mask & state) && !(key_down_state & DMod1Mask))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN, 0x38, 0);
-		key_down_state |= DMod1Mask;
-
-	}
-
-	if( (Mod2Mask & state) && !(key_down_state & DMod2Mask))
-	{
-		rdp_send_input(ev_time, RDP_INPUT_SCANCODE, KBD_FLAG_DOWN, 0xb8, 0);
-		key_down_state |= DMod2Mask;
+				if (xevent.xmapping.request == MappingModifier)
+				{
+					XFreeModifiermap(mod_map);
+					mod_map = XGetModifierMapping(display);
+				}
+				break;
 
+		}
 	}
 }
 
 void
 ui_select(int rdp_socket)
 {
-	int n = (rdp_socket > x_socket) ? rdp_socket+1 : x_socket+1;
+	int n = (rdp_socket > x_socket) ? rdp_socket + 1 : x_socket + 1;
 	fd_set rfds;
 
 	FD_ZERO(&rfds);
 
 	while (True)
 	{
+		/* Process any events already waiting */
+		xwin_process_events();
+
 		FD_ZERO(&rfds);
 		FD_SET(rdp_socket, &rfds);
-		if (display != NULL)
-		{
-			FD_SET(x_socket, &rfds);
-			XFlush(display);
-		}
+		FD_SET(x_socket, &rfds);
 
 		switch (select(n, &rfds, NULL, NULL, NULL))
 		{
@@ -693,9 +615,6 @@
 				continue;
 		}
 
-		if (FD_ISSET(x_socket, &rfds))
-			xwin_process_events();
-
 		if (FD_ISSET(rdp_socket, &rfds))
 			return;
 	}
@@ -708,35 +627,33 @@
 }
 
 HBITMAP
-ui_create_bitmap(int width, int height, uint8 *data)
+ui_create_bitmap(int width, int height, uint8 * data)
 {
 	XImage *image;
 	Pixmap bitmap;
 	uint8 *tdata;
 
-	tdata = (owncolmap ? data : translate_image(width, height, data));
+	tdata = translate_image(width, height, data);
 	bitmap = XCreatePixmap(display, wnd, width, height, depth);
-	image = XCreateImage(display, visual, depth, ZPixmap,
-			     0, tdata, width, height, 8, 0);
+	image = XCreateImage(display, visual, depth, ZPixmap, 0,
+			     (char *) tdata, width, height, 8, 0);
 
 	XPutImage(display, bitmap, gc, image, 0, 0, 0, 0, width, height);
 
 	XFree(image);
-	if (!owncolmap)
-		xfree(tdata);
+	xfree(tdata);
 	return (HBITMAP) bitmap;
 }
 
 void
-ui_paint_bitmap(int x, int y, int cx, int cy,
-		int width, int height, uint8 *data)
+ui_paint_bitmap(int x, int y, int cx, int cy, int width, int height, uint8 * data)
 {
 	XImage *image;
 	uint8 *tdata;
 
-	tdata = (owncolmap ? data : translate_image(width, height, data));
-	image = XCreateImage(display, visual, depth, ZPixmap,
-			     0, tdata, width, height, 8, 0);
+	tdata = translate_image(width, height, data);
+	image = XCreateImage(display, visual, depth, ZPixmap, 0,
+			     (char *) tdata, width, height, 8, 0);
 
 	if (ownbackstore)
 	{
@@ -749,18 +666,17 @@
 	}
 
 	XFree(image);
-	if (!owncolmap)
-		xfree(tdata);
+	xfree(tdata);
 }
 
 void
 ui_destroy_bitmap(HBITMAP bmp)
 {
-	XFreePixmap(display, (Pixmap)bmp);
+	XFreePixmap(display, (Pixmap) bmp);
 }
 
 HGLYPH
-ui_create_glyph(int width, int height, uint8 *data)
+ui_create_glyph(int width, int height, uint8 * data)
 {
 	XImage *image;
 	Pixmap bitmap;
@@ -772,8 +688,8 @@
 	bitmap = XCreatePixmap(display, wnd, width, height, 1);
 	gc = XCreateGC(display, bitmap, 0, NULL);
 
-	image = XCreateImage(display, visual, 1, ZPixmap, 0,
-			     data, width, height, 8, scanline);
+	image = XCreateImage(display, visual, 1, ZPixmap, 0, (char *) data,
+			     width, height, 8, scanline);
 	image->byte_order = MSBFirst;
 	image->bitmap_bit_order = MSBFirst;
 	XInitImage(image);
@@ -782,18 +698,18 @@
 
 	XFree(image);
 	XFreeGC(display, gc);
-	return (HGLYPH)bitmap;
+	return (HGLYPH) bitmap;
 }
 
 void
 ui_destroy_glyph(HGLYPH glyph)
 {
-	XFreePixmap(display, (Pixmap)glyph);
+	XFreePixmap(display, (Pixmap) glyph);
 }
 
 HCURSOR
-ui_create_cursor(unsigned int x, unsigned int y, int width,
-		 int height, uint8 *andmask, uint8 *xormask)
+ui_create_cursor(unsigned int x, unsigned int y, int width, int height,
+		 uint8 * andmask, uint8 * xormask)
 {
 	HGLYPH maskglyph, cursorglyph;
 	XColor bg, fg;
@@ -850,27 +766,29 @@
 
 	cursorglyph = ui_create_glyph(width, height, cursor);
 	maskglyph = ui_create_glyph(width, height, mask);
-	
-	xcursor = XCreatePixmapCursor(display, (Pixmap)cursorglyph,
-				(Pixmap)maskglyph, &fg, &bg, x, y);
+
+	xcursor =
+		XCreatePixmapCursor(display, (Pixmap) cursorglyph,
+				    (Pixmap) maskglyph, &fg, &bg, x, y);
 
 	ui_destroy_glyph(maskglyph);
 	ui_destroy_glyph(cursorglyph);
 	xfree(mask);
 	xfree(cursor);
-	return (HCURSOR)xcursor;
+	return (HCURSOR) xcursor;
 }
 
 void
 ui_set_cursor(HCURSOR cursor)
 {
-	XDefineCursor(display, wnd, (Cursor)cursor);
+	current_cursor = (Cursor) cursor;
+	XDefineCursor(display, wnd, current_cursor);
 }
 
 void
 ui_destroy_cursor(HCURSOR cursor)
 {
-	XFreeCursor(display, (Cursor)cursor);
+	XFreeCursor(display, (Cursor) cursor);
 }
 
 #define MAKE_XCOLOR(xc,c) \
@@ -880,71 +798,94 @@
 		(xc)->flags = DoRed | DoGreen | DoBlue;
 
 HCOLOURMAP
-ui_create_colourmap(COLOURMAP *colours)
+ui_create_colourmap(COLOURMAP * colours)
 {
 	COLOURENTRY *entry;
 	int i, ncolours = colours->ncolours;
-
-	if (owncolmap)
+	uint32 *map = xmalloc(sizeof(*colmap) * ncolours);
+	XColor xentry;
+	XColor xc_cache[256];
+	uint32 colour;
+	int colLookup = 256;
+	for (i = 0; i < ncolours; i++)
 	{
-		XColor *xcolours, *xentry;
-		Colormap map;
+		entry = &colours->colours[i];
+		MAKE_XCOLOR(&xentry, entry);
 
-		xcolours = xmalloc(sizeof(XColor) * ncolours);
-		for (i = 0; i < ncolours; i++)
+		if (XAllocColor(display, xcolmap, &xentry) == 0)
 		{
-			entry = &colours->colours[i];
-			xentry = &xcolours[i];
-			xentry->pixel = i;
-			MAKE_XCOLOR(xentry, entry);
-		}
+			/* Allocation failed, find closest match. */
+			int j = 256;
+			int nMinDist = 3 * 256 * 256;
+			long nDist = nMinDist;
 
-		map = XCreateColormap(display, wnd, visual, AllocAll);
-		XStoreColors(display, map, xcolours, ncolours);
+			/* only get the colors once */
+			while (colLookup--)
+			{
+				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;
 
-		xfree(xcolours);
-		return (HCOLOURMAP)map;
-	}
-	else
-	{
-		uint32 *map = xmalloc(sizeof(*colmap) * ncolours);
-		XColor xentry;
-		uint32 colour;
+			/* approximate the pixel */
+			while (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;
 
-		for (i = 0; i < ncolours; i++)
+		/* update our cache */
+		if (xentry.pixel < 256)
 		{
-			entry = &colours->colours[i];
-			MAKE_XCOLOR(&xentry, entry);
+			xc_cache[xentry.pixel].red = xentry.red;
+			xc_cache[xentry.pixel].green = xentry.green;
+			xc_cache[xentry.pixel].blue = xentry.blue;
 
-			if (XAllocColor(display, xcolmap, &xentry) != 0)
-				colour = xentry.pixel;
-			else
-				colour = white;
-
-			/* byte swap here to make translate_image faster */
-			map[i] = translate_colour(colour);
 		}
 
-		return map;
+
+		/* byte swap here to make translate_image faster */
+		map[i] = translate_colour(colour);
 	}
+
+	return map;
 }
 
 void
 ui_destroy_colourmap(HCOLOURMAP map)
 {
-	if (owncolmap)
-		XFreeColormap(display, (Colormap)map);
-	else
-		xfree(map);
+	xfree(map);
 }
 
 void
 ui_set_colourmap(HCOLOURMAP map)
 {
-	if (owncolmap)
-		XSetWindowColormap(display, wnd, (Colormap)map);
-	else
-		colmap = map;
+	colmap = map;
 }
 
 void
@@ -960,7 +901,7 @@
 }
 
 void
-ui_reset_clip()
+ui_reset_clip(void)
 {
 	XRectangle rect;
 
@@ -972,7 +913,7 @@
 }
 
 void
-ui_bell()
+ui_bell(void)
 {
 	XBell(display, 0);
 }
@@ -989,7 +930,7 @@
 void
 ui_patblt(uint8 opcode,
 	  /* dest */ int x, int y, int cx, int cy,
-	  /* brush */ BRUSH *brush, int bgcolour, int fgcolour)
+	  /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
 {
 	Pixmap fill;
 	uint8 i, ipattern[8];
@@ -1017,7 +958,8 @@
 			FILL_RECTANGLE(x, y, cx, cy);
 
 			XSetFillStyle(display, gc, FillSolid);
-			ui_destroy_glyph((HGLYPH)fill);
+			XSetTSOrigin(display, gc, 0, 0);
+			ui_destroy_glyph((HGLYPH) fill);
 			break;
 
 		default:
@@ -1035,8 +977,7 @@
 	SET_FUNCTION(opcode);
 	XCopyArea(display, wnd, wnd, gc, srcx, srcy, cx, cy, x, y);
 	if (ownbackstore)
-		XCopyArea(display, backstore, backstore, gc, srcx, srcy,
-			  cx, cy, x, y);
+		XCopyArea(display, backstore, backstore, gc, srcx, srcy, cx, cy, x, y);
 	RESET_FUNCTION(opcode);
 }
 
@@ -1046,10 +987,9 @@
 	  /* src */ HBITMAP src, int srcx, int srcy)
 {
 	SET_FUNCTION(opcode);
-	XCopyArea(display, (Pixmap)src, wnd, gc, srcx, srcy, cx, cy, x, y);
+	XCopyArea(display, (Pixmap) src, wnd, gc, srcx, srcy, cx, cy, x, y);
 	if (ownbackstore)
-		XCopyArea(display, (Pixmap)src, backstore, gc, srcx, srcy,
-			  cx, cy, x, y);
+		XCopyArea(display, (Pixmap) src, backstore, gc, srcx, srcy, cx, cy, x, y);
 	RESET_FUNCTION(opcode);
 }
 
@@ -1057,7 +997,7 @@
 ui_triblt(uint8 opcode,
 	  /* dest */ int x, int y, int cx, int cy,
 	  /* src */ HBITMAP src, int srcx, int srcy,
-	  /* brush */ BRUSH *brush, int bgcolour, int fgcolour)
+	  /* brush */ BRUSH * brush, int bgcolour, int fgcolour)
 {
 	/* This is potentially difficult to do in general. Until someone
 	   comes up with a more efficient way of doing it I am using cases. */
@@ -1066,22 +1006,18 @@
 	{
 		case 0x69:	/* PDSxxn */
 			ui_memblt(ROP2_XOR, x, y, cx, cy, src, srcx, srcy);
-			ui_patblt(ROP2_NXOR, x, y, cx, cy,
-				  brush, bgcolour, fgcolour);
+			ui_patblt(ROP2_NXOR, x, y, cx, cy, brush, bgcolour, fgcolour);
 			break;
 
 		case 0xb8:	/* PSDPxax */
-			ui_patblt(ROP2_XOR, x, y, cx, cy,
-				  brush, bgcolour, fgcolour);
+			ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
 			ui_memblt(ROP2_AND, x, y, cx, cy, src, srcx, srcy);
-			ui_patblt(ROP2_XOR, x, y, cx, cy,
-				  brush, bgcolour, fgcolour);
+			ui_patblt(ROP2_XOR, x, y, cx, cy, brush, bgcolour, fgcolour);
 			break;
 
 		case 0xc0:	/* PSa */
 			ui_memblt(ROP2_COPY, x, y, cx, cy, src, srcx, srcy);
-			ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour,
-				  fgcolour);
+			ui_patblt(ROP2_AND, x, y, cx, cy, brush, bgcolour, fgcolour);
 			break;
 
 		default:
@@ -1093,7 +1029,7 @@
 void
 ui_line(uint8 opcode,
 	/* dest */ int startx, int starty, int endx, int endy,
-	/* pen */ PEN *pen)
+	/* pen */ PEN * pen)
 {
 	SET_FUNCTION(opcode);
 	SET_FOREGROUND(pen->colour);
@@ -1115,15 +1051,15 @@
 void
 ui_draw_glyph(int mixmode,
 	      /* dest */ int x, int y, int cx, int cy,
-	      /* src */ HGLYPH glyph, int srcx, int srcy, int bgcolour,
-	      int fgcolour)
+	      /* src */ HGLYPH glyph, int srcx, int srcy,
+	      int bgcolour, int fgcolour)
 {
 	SET_FOREGROUND(fgcolour);
 	SET_BACKGROUND(bgcolour);
 
-	XSetFillStyle(display, gc, (mixmode == MIX_TRANSPARENT)
-		      ? FillStippled : FillOpaqueStippled);
-	XSetStipple(display, gc, (Pixmap)glyph);
+	XSetFillStyle(display, gc,
+		      (mixmode == MIX_TRANSPARENT) ? FillStippled : FillOpaqueStippled);
+	XSetStipple(display, gc, (Pixmap) glyph);
 	XSetTSOrigin(display, gc, x, y);
 
 	FILL_RECTANGLE(x, y, cx, cy);
@@ -1140,9 +1076,10 @@
       if ((xyoffset & 0x80))\
 	{\
 	  if (flags & TEXT2_VERTICAL) \
-	    y += ttext[++idx] | (ttext[++idx] << 8);\
+	    y += ttext[idx+1] | (ttext[idx+2] << 8);\
 	  else\
-	    x += ttext[++idx] | (ttext[++idx] << 8);\
+	    x += ttext[idx+1] | (ttext[idx+2] << 8);\
+	  idx += 2;\
 	}\
       else\
 	{\
@@ -1165,8 +1102,8 @@
 
 void
 ui_draw_text(uint8 font, uint8 flags, 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 clipx, int clipy, int clipcx, int clipcy,
+	     int boxx, int boxy, int boxcx, int boxcy, int bgcolour,
 	     int fgcolour, uint8 * text, uint8 length)
 {
 	FONTGLYPH *glyph;
@@ -1185,48 +1122,53 @@
 	}
 
 	/* Paint text, character by character */
-	for (i = 0; i < length;) {
-		switch (text[i]) {
-		case 0xff:
-			if (i + 2 < length)
-				cache_put_text(text[i + 1], text, text[i + 2]);
-			else {
-				error("this shouldn't be happening\n");
+	for (i = 0; i < length;)
+	{
+		switch (text[i])
+		{
+			case 0xff:
+				if (i + 2 < length)
+					cache_put_text(text[i + 1], text, text[i + 2]);
+				else
+				{
+					error("this shouldn't be happening\n");
+					break;
+				}
+				/* this will move pointer from start to first character after FF command */
+				length -= i + 3;
+				text = &(text[i + 3]);
+				i = 0;
 				break;
-			}
-			/* this will move pointer from start to first character after FF command */
-			length -= i + 3;
-			text = &(text[i + 3]);
-			i = 0;
-			break;
 
-		case 0xfe:
-			entry = cache_get_text(text[i + 1]);
-			if (entry != NULL) {
-				if ((((uint8 *) (entry->data))[1] == 0)
-				    && (!(flags & TEXT2_IMPLICIT_X))) {
-					if (flags & TEXT2_VERTICAL)
-						y += text[i + 2];
+			case 0xfe:
+				entry = cache_get_text(text[i + 1]);
+				if (entry != NULL)
+				{
+					if ((((uint8 *) (entry->data))[1] ==
+					     0) && (!(flags & TEXT2_IMPLICIT_X)))
+					{
+						if (flags & TEXT2_VERTICAL)
+							y += text[i + 2];
+						else
+							x += text[i + 2];
+					}
+					if (i + 2 < length)
+						i += 3;
 					else
-					    	x += text[i + 2];
+						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;
-				for (j = 0; j < entry->size; j++)
-					DO_GLYPH(((uint8 *) (entry->data)), j);
-			}
-			break;
+				break;
 
-		default:
-			DO_GLYPH(text, i);
-			i++;
-			break;
+			default:
+				DO_GLYPH(text, i);
+				i++;
+				break;
 		}
 	}
 
@@ -1241,21 +1183,18 @@
 
 	if (ownbackstore)
 	{
-		image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes,
-				  ZPixmap);
+		image = XGetImage(display, backstore, x, y, cx, cy, AllPlanes, ZPixmap);
 	}
 	else
 	{
 		pix = XCreatePixmap(display, wnd, cx, cy, depth);
 		XCopyArea(display, wnd, pix, gc, x, y, cx, cy, 0, 0);
-		image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes,
-				  ZPixmap);
+		image = XGetImage(display, pix, 0, 0, cx, cy, AllPlanes, ZPixmap);
 		XFreePixmap(display, pix);
 	}
 
-	offset *= bpp/8;
-	cache_put_desktop(offset, cx, cy, image->bytes_per_line,
-			  bpp/8, (uint8 *)image->data);
+	offset *= bpp / 8;
+	cache_put_desktop(offset, cx, cy, image->bytes_per_line, bpp / 8, (uint8 *) image->data);
 
 	XDestroyImage(image);
 }
@@ -1266,14 +1205,13 @@
 	XImage *image;
 	uint8 *data;
 
-	offset *= bpp/8;
-	data = cache_get_desktop(offset, cx, cy, bpp/8);
+	offset *= bpp / 8;
+	data = cache_get_desktop(offset, cx, cy, bpp / 8);
 	if (data == NULL)
 		return;
 
-	image = XCreateImage(display, visual, depth, ZPixmap,
-			     0, data, cx, cy, BitmapPad(display),
-			     cx * bpp/8);
+	image = XCreateImage(display, visual, depth, ZPixmap, 0,
+			     (char *) data, cx, cy, BitmapPad(display), cx * bpp / 8);
 
 	if (ownbackstore)
 	{