--- SheepShaver/src/Unix/video_x.cpp	2003/12/04 22:29:15	1.7
+++ SheepShaver/src/Unix/video_x.cpp	2005/06/25 11:39:47	1.46
@@ -1,7 +1,7 @@
 /*
  *  video_x.cpp - Video/graphics emulation, X11 specific stuff
  *
- *  SheepShaver (C) 1997-2002 Marc Hellwig and Christian Bauer
+ *  SheepShaver (C) 1997-2005 Marc Hellwig and Christian Bauer
  *
  *  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
@@ -18,6 +18,15 @@
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  */
 
+/*
+ *  NOTES:
+ *    The Ctrl key works like a qualifier for special actions:
+ *      Ctrl-Tab = suspend DGA mode
+ *      Ctrl-Esc = emergency quit
+ *      Ctrl-F1 = mount floppy
+ *      Ctrl-F5 = grab mouse (in windowed mode)
+ */
+
 #include "sysdeps.h"
 
 #include <X11/Xlib.h>
@@ -29,14 +38,25 @@
 #include <errno.h>
 #include <pthread.h>
 
+#include <algorithm>
+
+#ifdef ENABLE_FBDEV_DGA
+# include <linux/fb.h>
+# include <sys/ioctl.h>
+#endif
+
 #ifdef ENABLE_XF86_DGA
-#include <X11/extensions/xf86dga.h>
+# include <X11/extensions/xf86dga.h>
 #endif
 
 #ifdef ENABLE_XF86_VIDMODE
 # include <X11/extensions/xf86vmode.h>
 #endif
 
+#ifdef ENABLE_FBDEV_DGA
+# include <sys/mman.h>
+#endif
+
 #include "main.h"
 #include "adb.h"
 #include "prefs.h"
@@ -44,17 +64,27 @@
 #include "about_window.h"
 #include "video.h"
 #include "video_defs.h"
+#include "video_blit.h"
 
 #define DEBUG 0
 #include "debug.h"
 
+#ifndef NO_STD_NAMESPACE
+using std::sort;
+#endif
+
 
 // Constants
 const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
+static const bool hw_mac_cursor_accl = true;	// Flag: Enable MacOS to X11 copy of cursor?
 
 // Global variables
 static int32 frame_skip;
+static int16 mouse_wheel_mode;
+static int16 mouse_wheel_lines;
 static bool redraw_thread_active = false;	// Flag: Redraw thread installed
+static pthread_attr_t redraw_thread_attr;	// Redraw thread attributes
+static volatile bool redraw_thread_cancel;	// Flag: Cancel Redraw thread
 static pthread_t redraw_thread;				// Redraw thread
 
 static bool local_X11;						// Flag: X server running on local machine?
@@ -72,6 +102,7 @@ static const bool use_vosf = false;			//
 
 static bool palette_changed = false;		// Flag: Palette changed, redraw thread must update palette
 static bool ctrl_down = false;				// Flag: Ctrl key pressed
+static bool caps_on = false;				// Flag: Caps Lock on
 static bool quit_full_screen = false;		// Flag: DGA close requested from redraw thread
 static volatile bool quit_full_screen_ack = false;	// Acknowledge for quit_full_screen
 static bool emerg_quit = false;				// Flag: Ctrl-Esc pressed, emergency quit requested from MacOS thread
@@ -87,14 +118,22 @@ static int screen;							// Screen numbe
 static int xdepth;							// Depth of X screen
 static int depth;							// Depth of Mac frame buffer
 static Window rootwin, the_win;				// Root window and our window
+static int num_depths = 0;					// Number of available X depths
+static int *avail_depths = NULL;			// List of available X depths
+static VisualFormat visualFormat;
 static XVisualInfo visualInfo;
 static Visual *vis;
+static int color_class;
+static int rshift, rloss, gshift, gloss, bshift, bloss;	// Pixel format of DirectColor/TrueColor modes
 static Colormap cmap[2];					// Two colormaps (DGA) for 8-bit mode
+static XColor x_palette[256];				// Color palette to be used as CLUT and gamma table
+static int orig_accel_numer, orig_accel_denom, orig_threshold;	// Original mouse acceleration
+
 static XColor black, white;
 static unsigned long black_pixel, white_pixel;
 static int eventmask;
-static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask;
-static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
+static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask | StructureNotifyMask;
+static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask;
 
 // Variables for window mode
 static GC the_gc;
@@ -111,16 +150,51 @@ static uint8 *the_buffer_copy = NULL;		/
 static uint32 the_buffer_size;				// Size of allocated the_buffer
 
 // Variables for DGA mode
-static char *dga_screen_base;
-static int dga_fb_width;
+static bool is_fbdev_dga_mode = false;		// Flag: Use FBDev DGA mode?
 static int current_dga_cmap;
 
+#ifdef ENABLE_FBDEV_DGA
+static int fb_dev_fd = -1;						// Handle to fb device name
+static struct fb_fix_screeninfo fb_finfo;		// Fixed info
+static struct fb_var_screeninfo fb_vinfo;		// Variable info
+static struct fb_var_screeninfo fb_orig_vinfo;	// Variable info to restore later
+static struct fb_cmap fb_oldcmap;				// Colormap to restore later
+#endif
+
 #ifdef ENABLE_XF86_VIDMODE
 // Variables for XF86 VidMode support
 static XF86VidModeModeInfo **x_video_modes;		// Array of all available modes
 static int num_x_video_modes;
 #endif
 
+// Mutex to protect palette
+#if defined(HAVE_PTHREADS)
+static pthread_mutex_t x_palette_lock = PTHREAD_MUTEX_INITIALIZER;
+#define LOCK_PALETTE pthread_mutex_lock(&x_palette_lock)
+#define UNLOCK_PALETTE pthread_mutex_unlock(&x_palette_lock)
+#elif defined(HAVE_SPINLOCKS)
+static spinlock_t x_palette_lock = SPIN_LOCK_UNLOCKED;
+#define LOCK_PALETTE spin_lock(&x_palette_lock)
+#define UNLOCK_PALETTE spin_unlock(&x_palette_lock)
+#else
+#define LOCK_PALETTE
+#define UNLOCK_PALETTE
+#endif
+
+// Mutex to protect frame buffer
+#if defined(HAVE_PTHREADS)
+static pthread_mutex_t frame_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
+#define LOCK_FRAME_BUFFER pthread_mutex_lock(&frame_buffer_lock);
+#define UNLOCK_FRAME_BUFFER pthread_mutex_unlock(&frame_buffer_lock);
+#elif defined(HAVE_SPINLOCKS)
+static spinlock_t frame_buffer_lock = SPIN_LOCK_UNLOCKED;
+#define LOCK_FRAME_BUFFER spin_lock(&frame_buffer_lock)
+#define UNLOCK_FRAME_BUFFER spin_unlock(&frame_buffer_lock)
+#else
+#define LOCK_FRAME_BUFFER
+#define UNLOCK_FRAME_BUFFER
+#endif
+
 
 // Prototypes
 static void *redraw_func(void *arg);
@@ -133,6 +207,10 @@ extern Display *x_display;
 // From sys_unix.cpp
 extern void SysMountFirstFloppy(void);
 
+// From clip_unix.cpp
+extern void ClipboardSelectionClear(XSelectionClearEvent *);
+extern void ClipboardSelectionRequest(XSelectionRequestEvent *);
+
 
 // Video acceleration through SIGSEGV
 #ifdef ENABLE_VOSF
@@ -141,9 +219,260 @@ extern void SysMountFirstFloppy(void);
 
 
 /*
+ *  Utility functions
+ */
+
+// Get current video mode
+static inline int get_current_mode(void)
+{
+	return VModes[cur_mode].viAppleMode;
+}
+
+// Find palette size for given color depth
+static int palette_size(int mode)
+{
+	switch (mode) {
+	case APPLE_1_BIT: return 2;
+	case APPLE_2_BIT: return 4;
+	case APPLE_4_BIT: return 16;
+	case APPLE_8_BIT: return 256;
+	case APPLE_16_BIT: return 32;
+	case APPLE_32_BIT: return 256;
+	default: return 0;
+	}
+}
+
+// Return bits per pixel for requested depth
+static inline int bytes_per_pixel(int depth)
+{
+	int bpp;
+	switch (depth) {
+	case 8:
+		bpp = 1;
+		break;
+	case 15: case 16:
+		bpp = 2;
+		break;
+	case 24: case 32:
+		bpp = 4;
+		break;
+	default:
+		abort();
+	}
+	return bpp;
+}
+
+// Map video_mode depth ID to numerical depth value
+static inline int depth_of_video_mode(int mode)
+{
+	int depth;
+	switch (mode) {
+	case APPLE_1_BIT:
+		depth = 1;
+		break;
+	case APPLE_2_BIT:
+		depth = 2;
+		break;
+	case APPLE_4_BIT:
+		depth = 4;
+		break;
+	case APPLE_8_BIT:
+		depth = 8;
+		break;
+	case APPLE_16_BIT:
+		depth = 16;
+		break;
+	case APPLE_32_BIT:
+		depth = 32;
+		break;
+	default:
+		abort();
+	}
+	return depth;
+}
+
+// Map RGB color to pixel value (this only works in TrueColor/DirectColor visuals)
+static inline uint32 map_rgb(uint8 red, uint8 green, uint8 blue)
+{
+	return ((red >> rloss) << rshift) | ((green >> gloss) << gshift) | ((blue >> bloss) << bshift);
+}
+
+
+// Do we have a visual for handling the specified Mac depth? If so, set the
+// global variables "xdepth", "visualInfo", "vis" and "color_class".
+static bool find_visual_for_depth(int depth)
+{
+	D(bug("have_visual_for_depth(%d)\n", depth_of_video_mode(depth)));
+
+	// 1-bit works always and uses default visual
+	if (depth == APPLE_1_BIT) {
+		vis = DefaultVisual(x_display, screen);
+		visualInfo.visualid = XVisualIDFromVisual(vis);
+		int num = 0;
+		XVisualInfo *vi = XGetVisualInfo(x_display, VisualIDMask, &visualInfo, &num);
+		visualInfo = vi[0];
+		XFree(vi);
+		xdepth = visualInfo.depth;
+		color_class = visualInfo.c_class;
+		D(bug(" found visual ID 0x%02x, depth %d\n", visualInfo.visualid, xdepth));
+		return true;
+	}
+
+	// Calculate minimum and maximum supported X depth
+	int min_depth = 1, max_depth = 32;
+	switch (depth) {
+#ifdef ENABLE_VOSF
+		case APPLE_2_BIT:
+		case APPLE_4_BIT:	// VOSF blitters can convert 2/4/8-bit -> 8/16/32-bit
+		case APPLE_8_BIT:
+			min_depth = 8;
+			max_depth = 32;
+			break;
+#else
+		case APPLE_2_BIT:
+		case APPLE_4_BIT:	// 2/4-bit requires VOSF blitters
+			return false;
+		case APPLE_8_BIT:	// 8-bit without VOSF requires an 8-bit visual
+			min_depth = 8;
+			max_depth = 8;
+			break;
+#endif
+		case APPLE_16_BIT:	// 16-bit requires a 15/16-bit visual
+			min_depth = 15;
+			max_depth = 16;
+			break;
+		case APPLE_32_BIT:	// 32-bit requires a 24/32-bit visual
+			min_depth = 24;
+			max_depth = 32;
+			break;
+	}
+	D(bug(" minimum required X depth is %d, maximum supported X depth is %d\n", min_depth, max_depth));
+
+	// Try to find a visual for one of the color depths
+	bool visual_found = false;
+	for (int i=0; i<num_depths && !visual_found; i++) {
+
+		xdepth = avail_depths[i];
+		D(bug(" trying to find visual for depth %d\n", xdepth));
+		if (xdepth < min_depth || xdepth > max_depth)
+			continue;
+
+		// Determine best color class for this depth
+		switch (xdepth) {
+			case 1:	// Try StaticGray or StaticColor
+				if (XMatchVisualInfo(x_display, screen, xdepth, StaticGray, &visualInfo)
+				 || XMatchVisualInfo(x_display, screen, xdepth, StaticColor, &visualInfo))
+					visual_found = true;
+				break;
+			case 8:	// Need PseudoColor
+				if (XMatchVisualInfo(x_display, screen, xdepth, PseudoColor, &visualInfo))
+					visual_found = true;
+				break;
+			case 15:
+			case 16:
+			case 24:
+			case 32: // Try DirectColor first, as this will allow gamma correction
+				if (XMatchVisualInfo(x_display, screen, xdepth, DirectColor, &visualInfo)
+				 || XMatchVisualInfo(x_display, screen, xdepth, TrueColor, &visualInfo))
+					visual_found = true;
+				break;
+			default:
+				D(bug("  not a supported depth\n"));
+				break;
+		}
+	}
+	if (!visual_found)
+		return false;
+
+	// Visual was found
+	vis = visualInfo.visual;
+	color_class = visualInfo.c_class;
+	D(bug(" found visual ID 0x%02x, depth %d, class ", visualInfo.visualid, xdepth));
+#if DEBUG
+	switch (color_class) {
+		case StaticGray: D(bug("StaticGray\n")); break;
+		case GrayScale: D(bug("GrayScale\n")); break;
+		case StaticColor: D(bug("StaticColor\n")); break;
+		case PseudoColor: D(bug("PseudoColor\n")); break;
+		case TrueColor: D(bug("TrueColor\n")); break;
+		case DirectColor: D(bug("DirectColor\n")); break;
+	}
+#endif
+	return true;
+}
+
+
+/*
  *  Open display (window or fullscreen)
  */
 
+// Set window name and class
+static void set_window_name(Window w, int name)
+{
+	const char *str = GetString(name);
+	XStoreName(x_display, w, str);
+	XSetIconName(x_display, w, str);
+
+	XClassHint *hints;
+	hints = XAllocClassHint();
+	if (hints) {
+		hints->res_name = "SheepShaver";
+		hints->res_class = "SheepShaver";
+		XSetClassHint(x_display, w, hints);
+		XFree(hints);
+	}
+}
+
+// Set window input focus flag
+static void set_window_focus(Window w)
+{
+	XWMHints *hints = XAllocWMHints();
+	if (hints) {
+		hints->input = True;
+		hints->initial_state = NormalState;
+		hints->flags = InputHint | StateHint;
+		XSetWMHints(x_display, w, hints);
+		XFree(hints);
+	}
+}
+
+// Set WM_DELETE_WINDOW protocol on window (preventing it from being destroyed by the WM when clicking on the "close" widget)
+static Atom WM_DELETE_WINDOW = (Atom)0;
+static void set_window_delete_protocol(Window w)
+{
+	WM_DELETE_WINDOW = XInternAtom(x_display, "WM_DELETE_WINDOW", false);
+	XSetWMProtocols(x_display, w, &WM_DELETE_WINDOW, 1);
+}
+
+// Wait until window is mapped/unmapped
+static void wait_mapped(Window w)
+{
+	XEvent e;
+	do {
+		XMaskEvent(x_display, StructureNotifyMask, &e);
+	} while ((e.type != MapNotify) || (e.xmap.event != w));
+}
+
+static void wait_unmapped(Window w)
+{
+	XEvent e;
+	do {
+		XMaskEvent(x_display, StructureNotifyMask, &e);
+	} while ((e.type != UnmapNotify) || (e.xmap.event != w));
+}
+
+// Disable mouse acceleration
+static void disable_mouse_accel(void)
+{
+	XChangePointerControl(x_display, True, False, 1, 1, 0);
+}
+
+// Restore mouse acceleration to original value
+static void restore_mouse_accel(void)
+{
+	XChangePointerControl(x_display, True, True, orig_accel_numer, orig_accel_denom, orig_threshold);
+}
+
 // Trap SHM errors
 static bool shm_error = false;
 static int (*old_error_handler)(Display *, XErrorEvent *);
@@ -166,31 +495,24 @@ static bool open_window(int width, int h
 	// Set absolute mouse mode
 	ADBSetRelMouseMode(false);
 
-	// Read frame skip prefs
-	frame_skip = PrefsFindInt32("frameskip");
-	if (frame_skip == 0)
-		frame_skip = 1;
-
 	// Create window
 	XSetWindowAttributes wattr;
 	wattr.event_mask = eventmask = win_eventmask;
-	wattr.background_pixel = black_pixel;
-	wattr.border_pixel = black_pixel;
+	wattr.background_pixel = (vis == DefaultVisual(x_display, screen) ? black_pixel : 0);
+	wattr.border_pixel = 0;
 	wattr.backing_store = NotUseful;
-
-	XSync(x_display, false);
+	wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]);
 	the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
-		InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore, &wattr);
-	XSync(x_display, false);
-	XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE));
-	XMapRaised(x_display, the_win);
-	XSync(x_display, false);
+		InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore | CWColormap, &wattr);
 
-	// Set colormap
-	if (depth == 8) {
-		XSetWindowColormap(x_display, the_win, cmap[0]);
-		XSetWMColormapWindows(x_display, the_win, &the_win, 1);
-	}
+	// Set window name/class
+	set_window_name(the_win, STR_WINDOW_TITLE);
+
+	// Indicate that we want keyboard input
+	set_window_focus(the_win);
+
+	// Set delete protocol property
+	set_window_delete_protocol(the_win);
 
 	// Make window unresizable
 	XSizeHints *hints;
@@ -204,6 +526,10 @@ static bool open_window(int width, int h
 		XFree((char *)hints);
 	}
 
+	// Show window
+	XMapWindow(x_display, the_win);
+	wait_mapped(the_win);
+
 	// 1-bit mode is big-endian; if the X server is little-endian, we can't
 	// use SHM because that doesn't allow changing the image byte order
 	bool need_msb_image = (depth == 1 && XImageByteOrder(x_display) == LSBFirst);
@@ -214,7 +540,8 @@ static bool open_window(int width, int h
 
 		// Create SHM image ("height + 2" for safety)
 		img = XShmCreateImage(x_display, vis, depth == 1 ? 1 : xdepth, depth == 1 ? XYBitmap : ZPixmap, 0, &shminfo, width, height);
-		shminfo.shmid = shmget(IPC_PRIVATE, (height + 2) * img->bytes_per_line, IPC_CREAT | 0777);
+		shminfo.shmid = shmget(IPC_PRIVATE, (aligned_height + 2) * img->bytes_per_line, IPC_CREAT | 0777);
+		D(bug(" shm image created\n"));
 		the_buffer_copy = (uint8 *)shmat(shminfo.shmid, 0, 0);
 		shminfo.shmaddr = img->data = (char *)the_buffer_copy;
 		shminfo.readOnly = False;
@@ -233,30 +560,19 @@ static bool open_window(int width, int h
 			have_shm = true;
 			shmctl(shminfo.shmid, IPC_RMID, 0);
 		}
+		D(bug(" shm image attached\n"));
 	}
 
 	// Create normal X image if SHM doesn't work ("height + 2" for safety)
 	if (!have_shm) {
-		int bytes_per_row = aligned_width;
-		switch (depth) {
-			case 1:
-				bytes_per_row /= 8;
-				break;
-			case 15:
-			case 16:
-				bytes_per_row *= 2;
-				break;
-			case 24:
-			case 32:
-				bytes_per_row *= 4;
-				break;
-		}
+		int bytes_per_row = depth == 1 ? aligned_width/8 : TrivialBytesPerRow(aligned_width, DepthModeForPixelDepth(xdepth));
 		the_buffer_copy = (uint8 *)malloc((aligned_height + 2) * bytes_per_row);
 		img = XCreateImage(x_display, vis, depth == 1 ? 1 : xdepth, depth == 1 ? XYBitmap : ZPixmap, 0, (char *)the_buffer_copy, aligned_width, aligned_height, 32, bytes_per_row);
+		D(bug(" X image created\n"));
 	}
 
 	// 1-Bit mode is big-endian
-    if (depth == 1) {
+    if (need_msb_image) {
         img->byte_order = MSBFirst;
         img->bitmap_bit_order = MSBFirst;
     }
@@ -274,25 +590,36 @@ static bool open_window(int width, int h
 	the_buffer = (uint8 *)malloc((aligned_height + 2) * img->bytes_per_line);
 	D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
 #endif
-	screen_base = (uint32)the_buffer;
+	screen_base = Host2MacAddr(the_buffer);
 
 	// Create GC
 	the_gc = XCreateGC(x_display, the_win, 0, 0);
-	XSetForeground(x_display, the_gc, black_pixel);
+	XSetState(x_display, the_gc, black_pixel, white_pixel, GXcopy, AllPlanes);
 
 	// Create cursor
-	cursor_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 4, 16, 16, 16, 2);
-	cursor_image->byte_order = MSBFirst;
-	cursor_image->bitmap_bit_order = MSBFirst;
-	cursor_mask_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 36, 16, 16, 16, 2);
-	cursor_mask_image->byte_order = MSBFirst;
-	cursor_mask_image->bitmap_bit_order = MSBFirst;
-	cursor_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
-	cursor_mask_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
-	cursor_gc = XCreateGC(x_display, cursor_map, 0, 0);
-	cursor_mask_gc = XCreateGC(x_display, cursor_mask_map, 0, 0);
-	mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, 0, 0);
-	cursor_changed = false;
+	if (hw_mac_cursor_accl) {
+		cursor_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 4, 16, 16, 16, 2);
+		cursor_image->byte_order = MSBFirst;
+		cursor_image->bitmap_bit_order = MSBFirst;
+		cursor_mask_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 36, 16, 16, 16, 2);
+		cursor_mask_image->byte_order = MSBFirst;
+		cursor_mask_image->bitmap_bit_order = MSBFirst;
+		cursor_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
+		cursor_mask_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
+		cursor_gc = XCreateGC(x_display, cursor_map, 0, 0);
+		cursor_mask_gc = XCreateGC(x_display, cursor_mask_map, 0, 0);
+		mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, 0, 0);
+		cursor_changed = false;
+	}
+
+	// Create no_cursor
+	else {
+		mac_cursor = XCreatePixmapCursor(x_display,
+			XCreatePixmap(x_display, the_win, 1, 1, 1),
+			XCreatePixmap(x_display, the_win, 1, 1, 1),
+			&black, &white, 0, 0);
+		XDefineCursor(x_display, the_win, mac_cursor);
+	}
 
 	// Init blitting routines
 	bool native_byte_order;
@@ -302,22 +629,184 @@ static bool open_window(int width, int h
 	native_byte_order = (XImageByteOrder(x_display) == LSBFirst);
 #endif
 #ifdef ENABLE_VOSF
-	Screen_blitter_init(&visualInfo, native_byte_order, depth);
+	Screen_blitter_init(visualFormat, native_byte_order, depth);
 #endif
 
 	// Set bytes per row
-	VModes[cur_mode].viRowBytes = img->bytes_per_line;
 	XSync(x_display, false);
 	return true;
 }
 
-// Open DGA display (!! should use X11 VidMode extensions to set mode)
-static bool open_dga(int width, int height)
+// Open FBDev DGA display
+static bool open_fbdev_dga(int width, int height)
+{
+#ifdef ENABLE_FBDEV_DGA
+#ifdef ENABLE_XF86_VIDMODE
+	// Switch to best mode
+	if (has_vidmode) {
+		int best = -1;
+		for (int i = 0; i < num_x_video_modes; i++) {
+			if (x_video_modes[i]->hdisplay == width && x_video_modes[i]->vdisplay == height) {
+				best = i;
+				break;
+			}
+		};
+		assert(best != -1);
+		XF86VidModeSwitchToMode(x_display, screen, x_video_modes[best]);
+		XF86VidModeSetViewPort(x_display, screen, 0, 0);
+		D(bug("[fbdev] VideoMode %d: %d x %d @ %d\n", best,
+			  x_video_modes[best]->hdisplay, x_video_modes[best]->vdisplay,
+			  1000 * x_video_modes[best]->dotclock / (x_video_modes[best]->htotal * x_video_modes[best]->vtotal)));
+	}
+#endif
+
+	if (ioctl(fb_dev_fd, FBIOGET_FSCREENINFO, &fb_finfo) != 0) {
+		D(bug("[fbdev] Can't get FSCREENINFO: %s\n", strerror(errno)));
+		return false;
+	}
+	D(bug("[fbdev] Device ID: %s\n", fb_finfo.id));
+	D(bug("[fbdev] smem_start: %p [%d bytes]\n", fb_finfo.smem_start, fb_finfo.smem_len));
+
+	int fb_type = fb_finfo.type;
+	const char *fb_type_str = NULL;
+	switch (fb_type) {
+	case FB_TYPE_PACKED_PIXELS:			fb_type_str = "Packed Pixels";			break;
+	case FB_TYPE_PLANES:				fb_type_str = "Non interleaved planes";	break;
+	case FB_TYPE_INTERLEAVED_PLANES:	fb_type_str = "Interleaved planes";		break;
+	case FB_TYPE_TEXT:					fb_type_str = "Text/attributes";		break;
+	case FB_TYPE_VGA_PLANES:			fb_type_str = "EGA/VGA planes";			break;
+	default:							fb_type_str = "<unknown>";				break;
+	}
+	D(bug("[fbdev] type: %s\n", fb_type_str));
+
+	if (fb_type != FB_TYPE_PACKED_PIXELS) {
+		D(bug("[fbdev] type '%s' not supported\n", fb_type_str));
+		return false;
+	}
+
+	int fb_visual = fb_finfo.visual;
+	const char *fb_visual_str;
+	switch (fb_visual) {
+	case FB_VISUAL_MONO01:				fb_visual_str = "Monochrome 1=Black 0=White";	break;
+	case FB_VISUAL_MONO10:				fb_visual_str = "Monochrome 1=While 0=Black";	break;
+	case FB_VISUAL_TRUECOLOR:			fb_visual_str = "True color";					break;
+	case FB_VISUAL_PSEUDOCOLOR:			fb_visual_str = "Pseudo color (like atari)";	break;
+	case FB_VISUAL_DIRECTCOLOR:			fb_visual_str = "Direct color";					break;
+	case FB_VISUAL_STATIC_PSEUDOCOLOR:	fb_visual_str = "Pseudo color readonly";		break;
+	default:							fb_visual_str = "<unknown>";					break;
+	}
+	D(bug("[fbdev] visual: %s\n", fb_visual_str));
+
+	if (fb_visual != FB_VISUAL_TRUECOLOR && fb_visual != FB_VISUAL_DIRECTCOLOR) {
+		D(bug("[fbdev] visual '%s' not supported\n", fb_visual_str));
+		return false;
+	}
+	
+	// Map frame buffer
+	the_buffer = (uint8 *)mmap(NULL, fb_finfo.smem_len, PROT_READ | PROT_WRITE, MAP_SHARED, fb_dev_fd, 0);
+	if (the_buffer == MAP_FAILED) {
+		D(bug("[fbdev] Can't mmap /dev/fb0: %s\n", strerror(errno)));
+		return false;
+	}
+
+	// Set absolute mouse mode
+	ADBSetRelMouseMode(false);
+
+	// Create window
+	XSetWindowAttributes wattr;
+	wattr.event_mask = eventmask = dga_eventmask;
+	wattr.override_redirect = True;
+	the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
+							InputOutput, DefaultVisual(x_display, screen),
+							CWEventMask | CWOverrideRedirect, &wattr);
+
+	// Show window
+	XMapRaised(x_display, the_win);
+	wait_mapped(the_win);
+
+	// Grab mouse and keyboard
+	XGrabKeyboard(x_display, the_win, True,
+				  GrabModeAsync, GrabModeAsync, CurrentTime);
+	XGrabPointer(x_display, the_win, True,
+				 PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
+				 GrabModeAsync, GrabModeAsync, the_win, None, CurrentTime);
+	disable_mouse_accel();
+
+	// Create no_cursor
+	mac_cursor = XCreatePixmapCursor(x_display,
+									 XCreatePixmap(x_display, the_win, 1, 1, 1),
+									 XCreatePixmap(x_display, the_win, 1, 1, 1),
+									 &black, &white, 0, 0);
+	XDefineCursor(x_display, the_win, mac_cursor);
+
+	// Init blitting routines
+	int bytes_per_row = TrivialBytesPerRow((width + 7) & ~7, DepthModeForPixelDepth(depth));
+#if ENABLE_VOSF
+	// Extract current screen color masks (we are in True Color mode)
+	VisualFormat visualFormat;
+	visualFormat.depth = xdepth = DefaultDepth(x_display, screen);
+	XMatchVisualInfo(x_display, screen, xdepth, TrueColor, &visualInfo);
+	assert(visualFormat.depth == visualInfo.depth);
+	visualFormat.Rmask = visualInfo.red_mask;
+	visualFormat.Gmask = visualInfo.green_mask;
+	visualFormat.Bmask = visualInfo.blue_mask;
+	D(bug("[fbdev] %d bpp, (%08x,%08x,%08x)\n", 
+		  visualFormat.depth,
+		  visualFormat.Rmask, visualFormat.Gmask, visualFormat.Bmask));
+	D(bug("[fbdev] Mac depth %d bpp\n", depth));
+
+	// Screen_blitter_init() returns TRUE if VOSF is mandatory
+	// i.e. the framebuffer update function is not Blit_Copy_Raw
+#ifdef WORDS_BIGENDIAN
+	const bool native_byte_order = (XImageByteOrder(x_display) == MSBFirst);
+#else
+	const bool native_byte_order = (XImageByteOrder(x_display) == LSBFirst);
+#endif
+	Screen_blitter_init(visualFormat, native_byte_order, depth);
+	
+	// Allocate memory for frame buffer (SIZE is extended to page-boundary)
+	use_vosf = true;
+	the_host_buffer = the_buffer;
+	the_buffer_size = page_extend((height + 2) * bytes_per_row);
+	the_buffer_copy = (uint8 *)malloc(the_buffer_size);
+	the_buffer = (uint8 *)vm_acquire(the_buffer_size);
+	D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
+#endif
+
+	// Set frame buffer base
+	D(bug("the_buffer = %p, use_vosf = %d\n", the_buffer, use_vosf));
+	screen_base = Host2MacAddr(the_buffer);
+	VModes[cur_mode].viRowBytes = bytes_per_row;
+	return true;
+#else
+	ErrorAlert("SheepShaver has been compiled with DGA support disabled.");
+	return false;
+#endif
+}
+
+// Open XF86 DGA display (!! should use X11 VidMode extensions to set mode)
+static bool open_xf86_dga(int width, int height)
 {
+	if (is_fbdev_dga_mode)
+		return false;
+
 #ifdef ENABLE_XF86_DGA
 	// Set relative mouse mode
 	ADBSetRelMouseMode(true);
 
+	// Create window
+	XSetWindowAttributes wattr;
+	wattr.event_mask = eventmask = dga_eventmask;
+	wattr.override_redirect = True;
+	wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]);
+	the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
+		InputOutput, vis, CWEventMask | CWOverrideRedirect |
+		(color_class == DirectColor ? CWColormap : 0), &wattr);
+
+	// Show window
+	XMapRaised(x_display, the_win);
+	wait_mapped(the_win);
+
 #ifdef ENABLE_XF86_VIDMODE
 	// Switch to best mode
 	if (has_vidmode) {
@@ -334,29 +823,26 @@ static bool open_dga(int width, int heig
 #endif
 
 	// Establish direct screen connection
+	XMoveResizeWindow(x_display, the_win, 0, 0, width, height);
+	XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0);
 	XGrabKeyboard(x_display, rootwin, True, GrabModeAsync, GrabModeAsync, CurrentTime);
 	XGrabPointer(x_display, rootwin, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
+
+	int v_width, v_bank, v_size;
+	XF86DGAGetVideo(x_display, screen, (char **)&the_buffer, &v_width, &v_bank, &v_size);
 	XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse);
 	XF86DGASetViewPort(x_display, screen, 0, 0);
 	XF86DGASetVidPage(x_display, screen, 0);
 
 	// Set colormap
-	if (depth == 8)
+	if (!IsDirectMode(get_current_mode())) {
+		XSetWindowColormap(x_display, the_win, cmap[current_dga_cmap = 0]);
 		XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
-
-	// Set bytes per row
-	int bytes_per_row = (dga_fb_width + 7) & ~7;
-	switch (depth) {
-		case 15:
-		case 16:
-			bytes_per_row *= 2;
-			break;
-		case 24:
-		case 32:
-			bytes_per_row *= 4;
-			break;
 	}
+	XSync(x_display, false);
 
+	// Init blitting routines
+	int bytes_per_row = TrivialBytesPerRow((v_width + 7) & ~7, DepthModeForPixelDepth(depth));
 #if ENABLE_VOSF
 	bool native_byte_order;
 #ifdef WORDS_BIGENDIAN
@@ -367,7 +853,7 @@ static bool open_dga(int width, int heig
 #if REAL_ADDRESSING || DIRECT_ADDRESSING
 	// Screen_blitter_init() returns TRUE if VOSF is mandatory
 	// i.e. the framebuffer update function is not Blit_Copy_Raw
-	use_vosf = Screen_blitter_init(&visualInfo, native_byte_order, depth);
+	use_vosf = Screen_blitter_init(visualFormat, native_byte_order, depth);
 	
 	if (use_vosf) {
 	  // Allocate memory for frame buffer (SIZE is extended to page-boundary)
@@ -375,16 +861,17 @@ static bool open_dga(int width, int heig
 	  the_buffer_size = page_extend((height + 2) * bytes_per_row);
 	  the_buffer_copy = (uint8 *)malloc(the_buffer_size);
 	  the_buffer = (uint8 *)vm_acquire(the_buffer_size);
+	  D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
 	}
 #else
 	use_vosf = false;
-	the_buffer = dga_screen_base;
 #endif
 #endif
-	screen_base = (uint32)the_buffer;
 
+	// Set frame buffer base
+	D(bug("the_buffer = %p, use_vosf = %d\n", the_buffer, use_vosf));
+	screen_base = Host2MacAddr(the_buffer);
 	VModes[cur_mode].viRowBytes = bytes_per_row;
-	XSync(x_display, false);
 	return true;
 #else
 	ErrorAlert("SheepShaver has been compiled with DGA support disabled.");
@@ -392,46 +879,154 @@ static bool open_dga(int width, int heig
 #endif
 }
 
+// Open DGA display
+static bool open_dga(int width, int height)
+{
+	bool display_open;
+
+	display_open = open_xf86_dga(width, height);
+#ifdef ENABLE_FBDEV_DGA
+	// Try to fallback to FBDev DGA mode
+	if (!display_open) {
+		is_fbdev_dga_mode = true;
+		display_open = open_fbdev_dga(width, height);
+	}
+#endif
+
+	// Common DGA display initialization
+	if (display_open) {
+
+		// Fake image to get display bounds in the refresh function
+		if ((img = (XImage *)malloc(sizeof(*img))) == NULL)
+			return false;
+		img->width = DisplayWidth(x_display, screen);
+		img->height = DisplayHeight(x_display, screen);
+		img->depth = is_fbdev_dga_mode ? xdepth : depth;
+		img->bytes_per_line = TrivialBytesPerRow(img->width, DepthModeForPixelDepth(img->depth));
+	}
+
+	return display_open;
+}
+
 static bool open_display(void)
 {
-	display_type = VModes[cur_mode].viType;
-	switch (VModes[cur_mode].viAppleMode) {
-		case APPLE_1_BIT:
-			depth = 1;
-			break;
-		case APPLE_2_BIT:
-			depth = 2;
-			break;
-		case APPLE_4_BIT:
-			depth = 4;
-			break;
-		case APPLE_8_BIT:
-			depth = 8;
-			break;
-		case APPLE_16_BIT:
-			depth = xdepth == 15 ? 15 : 16;
-			break;
-		case APPLE_32_BIT:
-			depth = 32;
-			break;
+	D(bug("open_display()\n"));
+	const VideoInfo &mode = VModes[cur_mode];
+
+	// Get original mouse acceleration
+	XGetPointerControl(x_display, &orig_accel_numer, &orig_accel_denom, &orig_threshold);
+
+	// Find best available X visual
+	if (!find_visual_for_depth(mode.viAppleMode)) {
+		ErrorAlert(GetString(STR_NO_XVISUAL_ERR));
+		return false;
 	}
 
-	bool display_open = false;
-	if (display_type == DIS_SCREEN)
+	// Build up visualFormat structure
+	visualFormat.fullscreen = (display_type == DIS_SCREEN);
+	visualFormat.depth = visualInfo.depth;
+	visualFormat.Rmask = visualInfo.red_mask;
+	visualFormat.Gmask = visualInfo.green_mask;
+	visualFormat.Bmask = visualInfo.blue_mask;
+
+	// Create color maps
+	if (color_class == PseudoColor || color_class == DirectColor) {
+		cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
+		cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
+	} else {
+		cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocNone);
+		cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocNone);
+	}
+
+	// Find pixel format of direct modes
+	if (color_class == DirectColor || color_class == TrueColor) {
+		rshift = gshift = bshift = 0;
+		rloss = gloss = bloss = 8;
+		uint32 mask;
+		for (mask=vis->red_mask; !(mask&1); mask>>=1)
+			++rshift;
+		for (; mask&1; mask>>=1)
+			--rloss;
+		for (mask=vis->green_mask; !(mask&1); mask>>=1)
+			++gshift;
+		for (; mask&1; mask>>=1)
+			--gloss;
+		for (mask=vis->blue_mask; !(mask&1); mask>>=1)
+			++bshift;
+		for (; mask&1; mask>>=1)
+			--bloss;
+	}
+
+	// Preset palette pixel values for CLUT or gamma table
+	if (color_class == DirectColor) {
+		int num = vis->map_entries;
+		for (int i=0; i<num; i++) {
+			int c = (i * 256) / num;
+			x_palette[i].pixel = map_rgb(c, c, c);
+			x_palette[i].flags = DoRed | DoGreen | DoBlue;
+		}
+	} else if (color_class == PseudoColor) {
+		for (int i=0; i<256; i++) {
+			x_palette[i].pixel = i;
+			x_palette[i].flags = DoRed | DoGreen | DoBlue;
+		}
+	}
+
+	// Load gray ramp to color map
+	int num = (color_class == DirectColor ? vis->map_entries : 256);
+	for (int i=0; i<num; i++) {
+		int c = (i * 256) / num;
+		x_palette[i].red = c * 0x0101;
+		x_palette[i].green = c * 0x0101;
+		x_palette[i].blue = c * 0x0101;
+	}
+	if (color_class == PseudoColor || color_class == DirectColor) {
+		XStoreColors(x_display, cmap[0], x_palette, num);
+		XStoreColors(x_display, cmap[1], x_palette, num);
+	}
+
+#ifdef ENABLE_VOSF
+	// Load gray ramp to 8->16/32 expand map
+	if (!IsDirectMode(get_current_mode()) && xdepth > 8)
+		for (int i=0; i<256; i++)
+			ExpandMap[i] = map_rgb(i, i, i);
+#endif
+
+	// Create display of requested type
+	display_type = mode.viType;
+	depth = depth_of_video_mode(mode.viAppleMode);
+
+	bool display_open;
+	switch (display_type) {
+	case DIS_SCREEN:
 		display_open = open_dga(VModes[cur_mode].viXsize, VModes[cur_mode].viYsize);
-	else if (display_type == DIS_WINDOW)
+		break;
+	case DIS_WINDOW:
 		display_open = open_window(VModes[cur_mode].viXsize, VModes[cur_mode].viYsize);
+		break;
+	default:
+		display_open = false;
+		break;
+	}
 
 #ifdef ENABLE_VOSF
 	if (use_vosf) {
 		// Initialize the VOSF system
+		LOCK_VOSF;
 		if (!video_vosf_init()) {
 			ErrorAlert(GetString(STR_VOSF_INIT_ERR));
+			UNLOCK_VOSF;
 			return false;
 		}
+		UNLOCK_VOSF;
 	}
 #endif
-	
+
+	// Zero screen buffers, viRowBytes is initialized at this stage
+	if (display_open) {
+		memset(the_buffer, 0, VModes[cur_mode].viRowBytes * VModes[cur_mode].viYsize);
+		memset(the_buffer_copy, 0, VModes[cur_mode].viRowBytes * VModes[cur_mode].viYsize);
+	}
 	return display_open;
 }
 
@@ -463,24 +1058,53 @@ static void close_window(void)
 	if (the_gc)
 		XFreeGC(x_display, the_gc);
 
-	// Close window
-	XDestroyWindow(x_display, the_win);
+	XFlush(x_display);
+	XSync(x_display, false);
 }
 
-// Close DGA mode
-static void close_dga(void)
+// Close FBDev mode
+static void close_fbdev_dga(void)
+{
+#ifdef ENABLE_FBDEV_DGA
+	uint8 *fb_base;
+	if (!use_vosf)
+		fb_base = the_buffer;
+#ifdef ENABLE_VOSF
+	else
+		fb_base = the_host_buffer;
+#endif
+	munmap(fb_base, fb_finfo.smem_len);
+#endif
+}
+
+// Close XF86 DGA mode
+static void close_xf86_dga(void)
 {
 #ifdef ENABLE_XF86_DGA
 	XF86DGADirectVideo(x_display, screen, 0);
+#endif
+}
+
+// Close DGA mode
+static void close_dga(void)
+{
+	if (is_fbdev_dga_mode)
+		close_fbdev_dga();
+	else
+		close_xf86_dga();
+
 	XUngrabPointer(x_display, CurrentTime);
 	XUngrabKeyboard(x_display, CurrentTime);
-#endif
 
 #ifdef ENABLE_XF86_VIDMODE
 	if (has_vidmode)
 		XF86VidModeSwitchToMode(x_display, screen, x_video_modes[0]);
 #endif
 
+	// Release fake image (it's not a normal XImage!)
+	free(img);
+	img = NULL;
+
 	if (!use_vosf) {
 		// don't free() the screen buffer in driver_base dtor
 		the_buffer = NULL;
@@ -500,6 +1124,23 @@ static void close_display(void)
 	else if (display_type == DIS_WINDOW)
 		close_window();
 
+	// Close window
+	if (the_win) {
+		XUnmapWindow(x_display, the_win);
+		wait_unmapped(the_win);
+		XDestroyWindow(x_display, the_win);
+	}
+
+	// Free colormaps
+	if (cmap[0]) {
+		XFreeColormap(x_display, cmap[0]);
+		cmap[0] = 0;
+	}
+	if (cmap[1]) {
+		XFreeColormap(x_display, cmap[1]);
+		cmap[1] = 0;
+	}
+
 #ifdef ENABLE_VOSF
 	if (use_vosf) {
 		// Deinitialize VOSF
@@ -534,6 +1175,9 @@ static void close_display(void)
 		}
 	}
 #endif
+
+	// Restore mouse acceleration
+	restore_mouse_accel();
 }
 
 
@@ -565,6 +1209,10 @@ static void keycode_init(void)
 
 		// Search for server vendor string, then read keycodes
 		const char *vendor = ServerVendor(x_display);
+		// Force use of MacX mappings on MacOS X with Apple's X server
+		int dummy;
+		if (XQueryExtension(x_display, "Apple-DRI", &dummy, &dummy, &dummy))
+			vendor = "MacX";
 		bool vendor_found = false;
 		char line[256];
 		while (fgets(line, 255, f)) {
@@ -606,65 +1254,110 @@ static void keycode_init(void)
 	}
 }
 
-static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, long apple_mode, long apple_id, int type)
+// Find Apple mode matching best specified dimensions
+static int find_apple_resolution(int xsize, int ysize)
+{
+	int apple_id;
+	if (xsize < 800)
+		apple_id = APPLE_640x480;
+	else if (xsize < 1024)
+		apple_id = APPLE_800x600;
+	else if (xsize < 1152)
+		apple_id = APPLE_1024x768;
+	else if (xsize < 1280) {
+		if (ysize < 900)
+			apple_id = APPLE_1152x768;
+		else
+			apple_id = APPLE_1152x900;
+	}
+	else if (xsize < 1600)
+		apple_id = APPLE_1280x1024;
+	else
+		apple_id = APPLE_1600x1200;
+	return apple_id;
+}
+
+// Find mode in list of supported modes
+static int find_mode(int apple_mode, int apple_id, int type)
+{
+	for (VideoInfo *p = VModes; p->viType != DIS_INVALID; p++) {
+		if (p->viType == type && p->viAppleID == apple_id && p->viAppleMode == apple_mode)
+			return p - VModes;
+	}
+	return -1;
+}
+
+// Add custom video mode
+static void add_custom_mode(VideoInfo *&p, int type, uint32 x, uint32 y, int apple_mode, int apple_id)
+{
+	p->viType = type;
+	p->viXsize = x;
+	p->viYsize = y;
+	p->viRowBytes = TrivialBytesPerRow(p->viXsize, apple_mode);
+	p->viAppleMode = apple_mode;
+	p->viAppleID = apple_id;
+	p++;
+}
+
+// Add mode to list of supported modes
+static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, int apple_mode, int apple_id, int type)
 {
 	if (allow & test) {
-		p->viType = type;
+		uint32 x = 0, y = 0;
 		switch (apple_id) {
 			case APPLE_W_640x480:
 			case APPLE_640x480:
-				p->viXsize = 640;
-				p->viYsize = 480;
+				x = 640;
+				y = 480;
 				break;
 			case APPLE_W_800x600:
 			case APPLE_800x600:
-				p->viXsize = 800;
-				p->viYsize = 600;
+				x = 800;
+				y = 600;
 				break;
 			case APPLE_1024x768:
-				p->viXsize = 1024;
-				p->viYsize = 768;
+				x = 1024;
+				y = 768;
+				break;
+			case APPLE_1152x768:
+				x = 1152;
+				y = 768;
 				break;
 			case APPLE_1152x900:
-				p->viXsize = 1152;
-				p->viYsize = 900;
+				x = 1152;
+				y = 900;
 				break;
 			case APPLE_1280x1024:
-				p->viXsize = 1280;
-				p->viYsize = 1024;
+				x = 1280;
+				y = 1024;
 				break;
 			case APPLE_1600x1200:
-				p->viXsize = 1600;
-				p->viYsize = 1200;
+				x = 1600;
+				y = 1200;
 				break;
 		}
-		switch (apple_mode) {
-			case APPLE_8_BIT:
-				p->viRowBytes = p->viXsize;
-				break;
-			case APPLE_16_BIT:
-				p->viRowBytes = p->viXsize * 2;
-				break;
-			case APPLE_32_BIT:
-				p->viRowBytes = p->viXsize * 4;
-				break;
-		}
-		p->viAppleMode = apple_mode;
-		p->viAppleID = apple_id;
-		p++;
+		add_custom_mode(p, type, x, y, apple_mode, apple_id);
 	}
 }
 
+// Add standard list of windowed modes for given color depth
+static void add_window_modes(VideoInfo *&p, int window_modes, int mode)
+{
+	add_mode(p, window_modes, 1, mode, APPLE_W_640x480, DIS_WINDOW);
+	add_mode(p, window_modes, 2, mode, APPLE_W_800x600, DIS_WINDOW);
+}
+
 static bool has_mode(int x, int y)
 {
 #ifdef ENABLE_XF86_VIDMODE
-	for (int i=0; i<num_x_video_modes; i++)
-		if (x_video_modes[i]->hdisplay >= x && x_video_modes[i]->vdisplay >= y)
-			return true;
-	return false;
-#else
-	return DisplayWidth(x_display, screen) >= x && DisplayHeight(x_display, screen) >= y;
+	if (has_vidmode) {
+		for (int i=0; i<num_x_video_modes; i++)
+			if (x_video_modes[i]->hdisplay == x && x_video_modes[i]->vdisplay == y)
+				return true;
+		return false;
+	}
 #endif
+	return DisplayWidth(x_display, screen) >= x && DisplayHeight(x_display, screen) >= y;
 }
 
 bool VideoInit(void)
@@ -682,25 +1375,47 @@ bool VideoInit(void)
 	// Init keycode translation
 	keycode_init();
 
+	// Read frame skip prefs
+	frame_skip = PrefsFindInt32("frameskip");
+	if (frame_skip == 0)
+		frame_skip = 1;
+
+	// Read mouse wheel prefs
+	mouse_wheel_mode = PrefsFindInt32("mousewheelmode");
+	mouse_wheel_lines = PrefsFindInt32("mousewheellines");
+
 	// Init variables
 	private_data = NULL;
-	cur_mode = 0;	// Window 640x480
 	video_activated = true;
 
 	// Find screen and root window
 	screen = XDefaultScreen(x_display);
 	rootwin = XRootWindow(x_display, screen);
 
+	// Get sorted list of available depths
+	avail_depths = XListDepths(x_display, screen, &num_depths);
+	if (avail_depths == NULL) {
+		ErrorAlert(GetString(STR_UNSUPP_DEPTH_ERR));
+		return false;
+	}
+	sort(avail_depths, avail_depths + num_depths);
+	
 	// Get screen depth
 	xdepth = DefaultDepth(x_display, screen);
 
 #ifdef ENABLE_XF86_DGA
 	// DGA available?
     int event_base, error_base;
+    is_fbdev_dga_mode = false;
     if (local_X11 && XF86DGAQueryExtension(x_display, &event_base, &error_base)) {
 		int dga_flags = 0;
 		XF86DGAQueryDirectVideo(x_display, screen, &dga_flags);
 		has_dga = dga_flags & XF86DGADirectPresent;
+#if defined(__linux__)
+		// Check r/w permission on /dev/mem for DGA mode to work
+		if (has_dga && access("/dev/mem", R_OK | W_OK) != 0)
+			has_dga = false;
+#endif
 	} else
 		has_dga = false;
 #endif
@@ -709,8 +1424,33 @@ bool VideoInit(void)
 	// VidMode available?
 	int vm_event_base, vm_error_base;
 	has_vidmode = XF86VidModeQueryExtension(x_display, &vm_event_base, &vm_error_base);
-	if (has_vidmode)
+	if (has_vidmode) {
+		int vm_major_version, vm_minor_version;
+		XF86VidModeQueryVersion(x_display, &vm_major_version, &vm_minor_version);
+		D(bug("VidMode extension %d.%d available\n", vm_major_version, vm_minor_version));
 		XF86VidModeGetAllModeLines(x_display, screen, &num_x_video_modes, &x_video_modes);
+	}
+#endif
+
+#ifdef ENABLE_FBDEV_DGA
+	// FBDev available?
+	bool has_fbdev_dga = false;
+	if (local_X11) {
+		if ((fb_dev_fd = open("/dev/fb0", O_RDWR)) > 0) {
+			if (ioctl(fb_dev_fd, FBIOGET_VSCREENINFO, &fb_vinfo) != 0)
+				close(fb_dev_fd);
+			else {
+				has_fbdev_dga = true;
+				if (!has_dga) {
+					// Fallback to FBDev DGA mode if XF86 DGA is not possible
+					has_dga = true;
+					is_fbdev_dga_mode = true;
+				}
+				fb_orig_vinfo = fb_vinfo;
+				D(bug("Frame buffer device initial resolution: %dx%dx%d\n", fb_vinfo.xres, fb_vinfo.yres, fb_vinfo.bits_per_pixel));
+			}
+		}
+	}
 #endif
 
 	// Find black and white colors
@@ -721,116 +1461,150 @@ bool VideoInit(void)
 	black_pixel = BlackPixel(x_display, screen);
 	white_pixel = WhitePixel(x_display, screen);
 
-	// Get appropriate visual
-	int color_class;
-	switch (xdepth) {
-#if 0
-		case 1:
-			color_class = StaticGray;
-			break;
-#endif
-		case 8:
-			color_class = PseudoColor;
-			break;
-		case 15:
-		case 16:
-		case 24:
-		case 32:
-			color_class = TrueColor;
-			break;
-		default:
-			ErrorAlert(GetString(STR_UNSUPP_DEPTH_ERR));
-			return false;
-	}
-	if (!XMatchVisualInfo(x_display, screen, xdepth, color_class, &visualInfo)) {
-		ErrorAlert(GetString(STR_NO_XVISUAL_ERR));
-		return false;
-	}
-	if (visualInfo.depth != xdepth) {
-		ErrorAlert(GetString(STR_NO_XVISUAL_ERR));
-		return false;
-	}
-	vis = visualInfo.visual;
-
 	// Mac screen depth follows X depth (for now)
-	depth = xdepth;
-
-	// Create color maps for 8 bit mode
-	if (depth == 8) {
-		cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
-		cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
-		XInstallColormap(x_display, cmap[0]);
-		XInstallColormap(x_display, cmap[1]);
+	int default_mode = APPLE_8_BIT;
+	switch (DefaultDepth(x_display, screen)) {
+	case 1:
+		default_mode = APPLE_1_BIT;
+		break;
+	case 8:
+		default_mode = APPLE_8_BIT;
+		break;
+	case 15: case 16:
+		default_mode = APPLE_16_BIT;
+		break;
+	case 24: case 32:
+		default_mode = APPLE_32_BIT;
+		break;
+	}
+
+	// Get screen mode from preferences
+	const char *mode_str = PrefsFindString("screen");
+	int default_width = 640, default_height = 480;
+	if (mode_str) {
+		display_type = DIS_INVALID;
+		if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2)
+			display_type = DIS_WINDOW;
+#ifdef ENABLE_XF86_DGA
+		else if (has_dga && sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2)
+			display_type = DIS_SCREEN;
+#endif
+#ifdef ENABLE_FBDEV_DGA
+		else if (has_fbdev_dga && sscanf(mode_str, "fbdev/%d/%d", &default_width, &default_height) == 2) {
+			is_fbdev_dga_mode = true;
+			display_type = DIS_SCREEN;
+		}
+#endif
+		if (display_type == DIS_INVALID) {
+			D(bug("Invalid screen mode specified, defaulting to old modes selection\n"));
+			mode_str = NULL;
+		}
+		else {
+			if (default_width <= 0)
+				default_width = DisplayWidth(x_display, screen);
+			else if (default_width > DisplayWidth(x_display, screen))
+				default_width = DisplayWidth(x_display, screen);
+			if (default_height <= 0)
+				default_height = DisplayHeight(x_display, screen);
+			else if (default_height > DisplayHeight(x_display, screen))
+				default_height = DisplayHeight(x_display, screen);
+		}
 	}
 
 	// Construct video mode table
-	int mode = APPLE_8_BIT;
-	int bpr_mult = 8;
-	switch (depth) {
-		case 1:
-			mode = APPLE_1_BIT;
-			bpr_mult = 1;
-			break;
-		case 8:
-			mode = APPLE_8_BIT;
-			bpr_mult = 8;
-			break;
-		case 15:
-		case 16:
-			mode = APPLE_16_BIT;
-			bpr_mult = 16;
-			break;
-		case 24:
-		case 32:
-			mode = APPLE_32_BIT;
-			bpr_mult = 32;
-			break;
-	}
-
 	uint32 window_modes = PrefsFindInt32("windowmodes");
 	uint32 screen_modes = PrefsFindInt32("screenmodes");
 	if (!has_dga)
 		screen_modes = 0;
-	if (window_modes == 0 && screen_modes == 0)
+	if (mode_str)
+		window_modes = screen_modes = 0;
+	else if (window_modes == 0 && screen_modes == 0)
 		window_modes |= 3;	// Allow at least 640x480 and 800x600 window modes
 
 	VideoInfo *p = VModes;
-	add_mode(p, window_modes, 1, mode, APPLE_W_640x480, DIS_WINDOW);
-	add_mode(p, window_modes, 2, mode, APPLE_W_800x600, DIS_WINDOW);
-	if (has_vidmode) {
+	if (mode_str) {
+		if (display_type == DIS_WINDOW) {
+			for (unsigned int d = APPLE_1_BIT; d <= APPLE_32_BIT; d++) {
+				if (find_visual_for_depth(d)) {
+					if (default_width > 640 && default_height > 480)
+						add_mode(p, 3, 1, d, APPLE_W_640x480, DIS_WINDOW);
+					if (default_width > 800 && default_height > 600)
+						add_mode(p, 3, 2, d, APPLE_W_800x600, DIS_WINDOW);
+					add_custom_mode(p, display_type, default_width, default_height, d, APPLE_CUSTOM);
+				}
+			}
+#ifdef ENABLE_VOSF
+		} else if (display_type == DIS_SCREEN && is_fbdev_dga_mode) {
+			for (unsigned int d = APPLE_1_BIT; d <= default_mode; d++)
+				if (find_visual_for_depth(d))
+					add_custom_mode(p, display_type, default_width, default_height, d, APPLE_CUSTOM);
+#endif
+		} else
+			add_custom_mode(p, display_type, default_width, default_height, default_mode, APPLE_CUSTOM);
+
+		// Add extra VidMode capable modes
+		if (display_type == DIS_SCREEN) {
+			struct {
+				int w;
+				int h;
+				int apple_id;
+			}
+			video_modes[] = {
+				{  640,  480, APPLE_640x480   },
+				{  800,  600, APPLE_800x600   },
+				{ 1024,  768, APPLE_1024x768  },
+				{ 1152,  768, APPLE_1152x768  },
+				{ 1152,  900, APPLE_1152x900  },
+				{ 1280, 1024, APPLE_1280x1024 },
+				{ 1600, 1200, APPLE_1600x1200 },
+				{ 0, }
+			};
+
+			for (int i = 0; video_modes[i].w != 0; i++) {
+				const int w = video_modes[i].w;
+				const int h = video_modes[i].h;
+				if (w >= default_width || h >= default_height)
+					continue;
+				if (has_mode(w, h)) {
+#ifdef ENABLE_VOSF
+					if (is_fbdev_dga_mode) {
+						for (unsigned int d = APPLE_1_BIT; d <= default_mode; d++)
+							if (find_visual_for_depth(d))
+								add_custom_mode(p, display_type, w, h, d, video_modes[i].apple_id);
+					} else
+#endif
+						add_custom_mode(p, display_type, w, h, default_mode, video_modes[i].apple_id);
+				}
+			}
+		}
+	} else if (window_modes) {
+		for (unsigned int d = APPLE_1_BIT; d <= APPLE_32_BIT; d++)
+			if (find_visual_for_depth(d))
+				add_window_modes(p, window_modes, d);
+	} else if (has_vidmode) {
 		if (has_mode(640, 480))
-			add_mode(p, screen_modes, 1, mode, APPLE_640x480, DIS_SCREEN);
+			add_mode(p, screen_modes, 1, default_mode, APPLE_640x480, DIS_SCREEN);
 		if (has_mode(800, 600))
-			add_mode(p, screen_modes, 2, mode, APPLE_800x600, DIS_SCREEN);
+			add_mode(p, screen_modes, 2, default_mode, APPLE_800x600, DIS_SCREEN);
 		if (has_mode(1024, 768))
-			add_mode(p, screen_modes, 4, mode, APPLE_1024x768, DIS_SCREEN);
+			add_mode(p, screen_modes, 4, default_mode, APPLE_1024x768, DIS_SCREEN);
+		if (has_mode(1152, 768))
+			add_mode(p, screen_modes, 64, default_mode, APPLE_1152x768, DIS_SCREEN);
 		if (has_mode(1152, 900))
-			add_mode(p, screen_modes, 8, mode, APPLE_1152x900, DIS_SCREEN);
+			add_mode(p, screen_modes, 8, default_mode, APPLE_1152x900, DIS_SCREEN);
 		if (has_mode(1280, 1024))
-			add_mode(p, screen_modes, 16, mode, APPLE_1280x1024, DIS_SCREEN);
+			add_mode(p, screen_modes, 16, default_mode, APPLE_1280x1024, DIS_SCREEN);
 		if (has_mode(1600, 1200))
-			add_mode(p, screen_modes, 32, mode, APPLE_1600x1200, DIS_SCREEN);
+			add_mode(p, screen_modes, 32, default_mode, APPLE_1600x1200, DIS_SCREEN);
 	} else if (screen_modes) {
 		int xsize = DisplayWidth(x_display, screen);
 		int ysize = DisplayHeight(x_display, screen);
-		int apple_id;
-		if (xsize < 800)
-			apple_id = APPLE_640x480;
-		else if (xsize < 1024)
-			apple_id = APPLE_800x600;
-		else if (xsize < 1152)
-			apple_id = APPLE_1024x768;
-		else if (xsize < 1280)
-			apple_id = APPLE_1152x900;
-		else if (xsize < 1600)
-			apple_id = APPLE_1280x1024;
-		else
-			apple_id = APPLE_1600x1200;
+		int apple_id = find_apple_resolution(xsize, ysize);
 		p->viType = DIS_SCREEN;
 		p->viRowBytes = 0;
 		p->viXsize = xsize;
 		p->viYsize = ysize;
-		p->viAppleMode = mode;
+		p->viAppleMode = default_mode;
 		p->viAppleID = apple_id;
 		p++;
 	}
@@ -840,26 +1614,56 @@ bool VideoInit(void)
 	p->viAppleMode = 0;
 	p->viAppleID = 0;
 
-#ifdef ENABLE_XF86_DGA
+	// Find default mode (window 640x480)
+	cur_mode = -1;
 	if (has_dga && screen_modes) {
-		int v_bank, v_size;
-		XF86DGAGetVideo(x_display, screen, &dga_screen_base, &dga_fb_width, &v_bank, &v_size);
-		D(bug("DGA screen_base %p, v_width %d\n", dga_screen_base, dga_fb_width));
+		int screen_width = DisplayWidth(x_display, screen);
+		int screen_height = DisplayHeight(x_display, screen);
+		int apple_id = find_apple_resolution(screen_width, screen_height);
+		if (apple_id != -1)
+			cur_mode = find_mode(default_mode, apple_id, DIS_SCREEN);
+	} else if (has_dga && mode_str)
+		cur_mode = find_mode(default_mode, APPLE_CUSTOM, DIS_SCREEN);
+
+	if (cur_mode == -1) {
+		// pick up first windowed mode available
+		for (VideoInfo *p = VModes; p->viType != DIS_INVALID; p++) {
+			if (p->viType == DIS_WINDOW && p->viAppleMode == default_mode) {
+				cur_mode = p - VModes;
+				break;
+			}
+		}
+	}
+	assert(cur_mode != -1);
+
+#if DEBUG
+	D(bug("Available video modes:\n"));
+	for (p = VModes; p->viType != DIS_INVALID; p++) {
+		int bits = depth_of_video_mode(p->viAppleMode);
+		D(bug(" %dx%d (ID %02x), %d colors\n", p->viXsize, p->viYsize, p->viAppleID, 1 << bits));
 	}
 #endif
 
 	// Open window/screen
-	if (!open_display())
+	if (!open_display()) {
+		ErrorAlert(GetString(STR_OPEN_WINDOW_ERR));
 		return false;
+	}
 
 #if 0
 	// Ignore errors from now on
 	XSetErrorHandler(ignore_errors);
 #endif
 
+	// Lock down frame buffer
+	XSync(x_display, false);
+	LOCK_FRAME_BUFFER;
+
 	// Start periodic thread
 	XSync(x_display, false);
-	redraw_thread_active = (pthread_create(&redraw_thread, NULL, redraw_func, NULL) == 0);
+	Set_pthread_attr(&redraw_thread_attr, 0);
+	redraw_thread_cancel = false;
+	redraw_thread_active = (pthread_create(&redraw_thread, &redraw_thread_attr, redraw_func, NULL) == 0);
 	D(bug("Redraw thread installed (%ld)\n", redraw_thread));
 	return true;
 }
@@ -873,11 +1677,17 @@ void VideoExit(void)
 {
 	// Stop redraw thread
 	if (redraw_thread_active) {
+		redraw_thread_cancel = true;
 		pthread_cancel(redraw_thread);
 		pthread_join(redraw_thread, NULL);
 		redraw_thread_active = false;
 	}
 
+	// Unlock frame buffer
+	UNLOCK_FRAME_BUFFER;
+	XSync(x_display, false);
+	D(bug(" frame buffer unlocked\n"));
+
 #ifdef ENABLE_VOSF
 	if (use_vosf) {
 		// Deinitialize VOSF
@@ -891,11 +1701,15 @@ void VideoExit(void)
 		close_display();
 		XFlush(x_display);
 		XSync(x_display, false);
-		if (depth == 8) {
-			XFreeColormap(x_display, cmap[0]);
-			XFreeColormap(x_display, cmap[1]);
-		}
 	}
+
+#ifdef ENABLE_FBDEV_DGA
+	// Close framebuffer device
+	if (fb_dev_fd >= 0) {
+		close(fb_dev_fd);
+		fb_dev_fd = -1;
+	}
+#endif
 }
 
 
@@ -903,9 +1717,6 @@ void VideoExit(void)
  *  Suspend/resume emulator
  */
 
-extern void PauseEmulator(void);
-extern void ResumeEmulator(void);
-
 static void suspend_emul(void)
 {
 	if (display_type == DIS_SCREEN) {
@@ -913,39 +1724,41 @@ static void suspend_emul(void)
 		ADBKeyUp(0x36);
 		ctrl_down = false;
 
-		// Pause MacOS thread
-		PauseEmulator();
-		emul_suspended = true;
+		// Lock frame buffer (this will stop the MacOS thread)
+		LOCK_FRAME_BUFFER;
 
 		// Save frame buffer
 		fb_save = malloc(VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
 		if (fb_save)
-			memcpy(fb_save, (void *)screen_base, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
+			Mac2Host_memcpy(fb_save, screen_base, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
 
 		// Close full screen display
+#if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA)
 #ifdef ENABLE_XF86_DGA
-		XF86DGADirectVideo(x_display, screen, 0);
+		if (!is_fbdev_dga_mode)
+			XF86DGADirectVideo(x_display, screen, 0);
+#endif
 		XUngrabPointer(x_display, CurrentTime);
 		XUngrabKeyboard(x_display, CurrentTime);
 #endif
+		restore_mouse_accel();
+		XUnmapWindow(x_display, the_win);
+		wait_unmapped(the_win);
 		XSync(x_display, false);
 
 		// Open "suspend" window
 		XSetWindowAttributes wattr;
 		wattr.event_mask = KeyPressMask;
-		wattr.background_pixel = black_pixel;
-		wattr.border_pixel = black_pixel;
+		wattr.background_pixel = (vis == DefaultVisual(x_display, screen) ? black_pixel : 0);
 		wattr.backing_store = Always;
-		wattr.backing_planes = xdepth;
-		wattr.colormap = DefaultColormap(x_display, screen);
-		XSync(x_display, false);
+		wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]);
+
 		suspend_win = XCreateWindow(x_display, rootwin, 0, 0, 512, 1, 0, xdepth,
-			InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel |
-			CWBackingStore | CWBackingPlanes | (xdepth == 8 ? CWColormap : 0), &wattr);
-		XSync(x_display, false);
-		XStoreName(x_display, suspend_win, GetString(STR_SUSPEND_WINDOW_TITLE));
-		XMapRaised(x_display, suspend_win);
-		XSync(x_display, false);
+									InputOutput, vis, CWEventMask | CWBackPixel | CWBackingStore | CWColormap, &wattr);
+		set_window_name(suspend_win, STR_SUSPEND_WINDOW_TITLE);
+		set_window_focus(suspend_win);
+		XMapWindow(x_display, suspend_win);
+		emul_suspended = true;
 	}
 }
 
@@ -956,10 +1769,19 @@ static void resume_emul(void)
 	XSync(x_display, false);
 
 	// Reopen full screen display
-	XGrabKeyboard(x_display, rootwin, 1, GrabModeAsync, GrabModeAsync, CurrentTime);
-	XGrabPointer(x_display, rootwin, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
-	XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse);
-	XF86DGASetViewPort(x_display, screen, 0, 0);
+	XMapRaised(x_display, the_win);
+	wait_mapped(the_win);
+	XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0);
+	Window w = is_fbdev_dga_mode ? the_win : rootwin;
+	XGrabKeyboard(x_display, w, True, GrabModeAsync, GrabModeAsync, CurrentTime);
+	XGrabPointer(x_display, w, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, is_fbdev_dga_mode ? w : None, None, CurrentTime);
+	disable_mouse_accel();
+#ifdef ENABLE_XF86_DGA
+	if (!is_fbdev_dga_mode) {
+		XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse);
+		XF86DGASetViewPort(x_display, screen, 0, 0);
+	}
+#endif
 	XSync(x_display, false);
 
 	// the_buffer already contains the data to restore. i.e. since a temporary
@@ -969,8 +1791,8 @@ static void resume_emul(void)
 	if (use_vosf) {
 		LOCK_VOSF;
 		PFLAG_SET_ALL;
-		UNLOCK_VOSF;
 		memset(the_buffer_copy, 0, VModes[cur_mode].viRowBytes * VModes[cur_mode].viYsize);
+		UNLOCK_VOSF;
 	}
 #endif
 	
@@ -980,16 +1802,14 @@ static void resume_emul(void)
 		// Don't copy fb_save to the temporary frame buffer in VOSF mode
 		if (!use_vosf)
 #endif
-		memcpy((void *)screen_base, fb_save, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
+		Host2Mac_memcpy(screen_base, fb_save, VModes[cur_mode].viYsize * VModes[cur_mode].viRowBytes);
 		free(fb_save);
 		fb_save = NULL;
 	}
-	if (depth == 8)
-		palette_changed = true;
 
-	// Resume MacOS thread
+	// Unlock frame buffer (and continue MacOS thread)
+	UNLOCK_FRAME_BUFFER;
 	emul_suspended = false;
-	ResumeEmulator();
 }
 
 
@@ -1153,16 +1973,17 @@ static int kc_decode(KeySym ks)
 	return -1;
 }
 
-static int event2keycode(XKeyEvent &ev)
+static int event2keycode(XKeyEvent &ev, bool key_down)
 {
 	KeySym ks;
-	int as;
 	int i = 0;
 
 	do {
 		ks = XLookupKeysym(&ev, i++);
-		as = kc_decode(ks);
-		if (as != -1)
+		int as = kc_decode(ks);
+		if (as >= 0)
+			return as;
+		if (as == -2)
 			return as;
 	} while (ks != NoSymbol);
 
@@ -1175,8 +1996,26 @@ static void handle_events(void)
 	for (;;) {
 		XEvent event;
 
-		if (!XCheckMaskEvent(x_display, eventmask, &event))
+		XDisplayLock();
+		if (!XCheckMaskEvent(x_display, eventmask, &event)) {
+			// Handle clipboard events
+			if (XCheckTypedEvent(x_display, SelectionRequest, &event))
+				ClipboardSelectionRequest(&event.xselectionrequest);
+			else if (XCheckTypedEvent(x_display, SelectionClear, &event))
+				ClipboardSelectionClear(&event.xselectionclear);
+
+			// Window "close" widget clicked
+			else if (XCheckTypedEvent(x_display, ClientMessage, &event)) {
+				if (event.xclient.format == 32 && event.xclient.data.l[0] == WM_DELETE_WINDOW) {
+					ADBKeyDown(0x7f);	// Power key
+					ADBKeyUp(0x7f);
+				}
+			}
+
+			XDisplayUnlock();
 			break;
+		}
+		XDisplayUnlock();
 
 		switch (event.type) {
 			// Mouse button
@@ -1184,6 +2023,19 @@ static void handle_events(void)
 				unsigned int button = ((XButtonEvent *)&event)->button;
 				if (button < 4)
 					ADBMouseDown(button - 1);
+				else if (button < 6) {	// Wheel mouse
+					if (mouse_wheel_mode == 0) {
+						int key = (button == 5) ? 0x79 : 0x74;	// Page up/down
+						ADBKeyDown(key);
+						ADBKeyUp(key);
+					} else {
+						int key = (button == 5) ? 0x3d : 0x3e;	// Cursor up/down
+						for(int i=0; i<mouse_wheel_lines; i++) {
+							ADBKeyDown(key);
+							ADBKeyUp(key);
+						}
+					}
+				}
 				break;
 			}
 			case ButtonRelease: {
@@ -1193,22 +2045,37 @@ static void handle_events(void)
 				break;
 			}
 
-			// Mouse moved
+			// Mouse entered window
 			case EnterNotify:
-				ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y);
+				if (event.xcrossing.mode != NotifyGrab && event.xcrossing.mode != NotifyUngrab)
+					ADBMouseMoved(event.xmotion.x, event.xmotion.y);
 				break;
+
+			// Mouse moved
 			case MotionNotify:
-				ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y);
+				ADBMouseMoved(event.xmotion.x, event.xmotion.y);
 				break;
 
 			// Keyboard
 			case KeyPress: {
-				int code = event2keycode(event.xkey);
-				if (use_keycodes && code != -1)
-					code = keycode_table[event.xkey.keycode & 0xff];
-				if (code != -1) {
+				int code = -1;
+				if (use_keycodes) {
+					if (event2keycode(event.xkey, true) != -2)	// This is called to process the hotkeys
+						code = keycode_table[event.xkey.keycode & 0xff];
+				} else
+					code = event2keycode(event.xkey, true);
+				if (code >= 0) {
 					if (!emul_suspended) {
-						ADBKeyDown(code);
+						if (code == 0x39) {	// Caps Lock pressed
+							if (caps_on) {
+								ADBKeyUp(code);
+								caps_on = false;
+							} else {
+								ADBKeyDown(code);
+								caps_on = true;
+							}
+						} else
+							ADBKeyDown(code);
 						if (code == 0x36)
 							ctrl_down = true;
 					} else {
@@ -1219,10 +2086,13 @@ static void handle_events(void)
 				break;
 			}
 			case KeyRelease: {
-				int code = event2keycode(event.xkey);
-				if (use_keycodes && code != 1)
-					code = keycode_table[event.xkey.keycode & 0xff];
-				if (code != -1) {
+				int code = -1;
+				if (use_keycodes) {
+					if (event2keycode(event.xkey, false) != -2)	// This is called to process the hotkeys
+						code = keycode_table[event.xkey.keycode & 0xff];
+				} else
+					code = event2keycode(event.xkey, false);
+				if (code >= 0 && code != 0x39) {	// Don't propagate Caps Lock releases
 					ADBKeyUp(code);
 					if (code == 0x36)
 						ctrl_down = false;
@@ -1236,10 +2106,12 @@ static void handle_events(void)
 				if (use_vosf) {			// VOSF refresh
 					LOCK_VOSF;
 					PFLAG_SET_ALL;
+					memset(the_buffer_copy, 0, VModes[cur_mode].viRowBytes * VModes[cur_mode].viYsize);
 					UNLOCK_VOSF;
 				}
+				else
 #endif
-				memset(the_buffer_copy, 0, VModes[cur_mode].viRowBytes * VModes[cur_mode].viYsize);
+					memset(the_buffer_copy, 0, VModes[cur_mode].viRowBytes * VModes[cur_mode].viYsize);
 				break;
 		}
 	}
@@ -1255,6 +2127,11 @@ void VideoVBL(void)
 	if (emerg_quit)
 		QuitEmulator();
 
+	// Temporarily give up frame buffer lock (this is the point where
+	// we are suspended when the user presses Ctrl-Tab)
+	UNLOCK_FRAME_BUFFER;
+	LOCK_FRAME_BUFFER;
+
 	// Execute video VBL
 	if (private_data != NULL && private_data->interruptsEnabled)
 		VSLDoInterruptService(private_data->vslServiceID);
@@ -1262,150 +2139,6 @@ void VideoVBL(void)
 
 
 /*
- *  Install graphics acceleration
- */
-
-#if 0
-// Rectangle blitting
-static void accl_bitblt(accl_params *p)
-{
-	D(bug("accl_bitblt\n"));
-
-	// Get blitting parameters
-	int16 src_X = p->src_rect[1] - p->src_bounds[1];
-	int16 src_Y = p->src_rect[0] - p->src_bounds[0];
-	int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
-	int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
-	int16 width = p->dest_rect[3] - p->dest_rect[1] - 1;
-	int16 height = p->dest_rect[2] - p->dest_rect[0] - 1;
-	D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y));
-	D(bug(" width %d, height %d\n", width, height));
-
-	// And perform the blit
-	bitblt_hook(src_X, src_Y, dest_X, dest_Y, width, height);
-}
-
-static bool accl_bitblt_hook(accl_params *p)
-{
-	D(bug("accl_draw_hook %p\n", p));
-
-	// Check if we can accelerate this bitblt
-	if (p->src_base_addr == screen_base && p->dest_base_addr == screen_base &&
-		display_type == DIS_SCREEN && bitblt_hook != NULL &&
-		((uint32 *)p)[0x18 >> 2] + ((uint32 *)p)[0x128 >> 2] == 0 &&
-		((uint32 *)p)[0x130 >> 2] == 0 &&
-		p->transfer_mode == 0 &&
-		p->src_row_bytes > 0 && ((uint32 *)p)[0x15c >> 2] > 0) {
-
-		// Yes, set function pointer
-		p->draw_proc = accl_bitblt;
-		return true;
-	}
-	return false;
-}
-
-// Rectangle filling/inversion
-static void accl_fillrect8(accl_params *p)
-{
-	D(bug("accl_fillrect8\n"));
-
-	// Get filling parameters
-	int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
-	int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
-	int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1;
-	int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1;
-	uint8 color = p->pen_mode == 8 ? p->fore_pen : p->back_pen;
-	D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
-	D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max));
-
-	// And perform the fill
-	fillrect8_hook(dest_X, dest_Y, dest_X_max, dest_Y_max, color);
-}
-
-static void accl_fillrect32(accl_params *p)
-{
-	D(bug("accl_fillrect32\n"));
-
-	// Get filling parameters
-	int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
-	int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
-	int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1;
-	int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1;
-	uint32 color = p->pen_mode == 8 ? p->fore_pen : p->back_pen;
-	D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
-	D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max));
-
-	// And perform the fill
-	fillrect32_hook(dest_X, dest_Y, dest_X_max, dest_Y_max, color);
-}
-
-static void accl_invrect(accl_params *p)
-{
-	D(bug("accl_invrect\n"));
-
-	// Get inversion parameters
-	int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
-	int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
-	int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1;
-	int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1;
-	D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
-	D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max));
-
-	//!!?? pen_mode == 14
-
-	// And perform the inversion
-	invrect_hook(dest_X, dest_Y, dest_X_max, dest_Y_max);
-}
-
-static bool accl_fillrect_hook(accl_params *p)
-{
-	D(bug("accl_fillrect_hook %p\n", p));
-
-	// Check if we can accelerate this fillrect
-	if (p->dest_base_addr == screen_base && ((uint32 *)p)[0x284 >> 2] != 0 && display_type == DIS_SCREEN) {
-		if (p->transfer_mode == 8) {
-			// Fill
-			if (p->dest_pixel_size == 8 && fillrect8_hook != NULL) {
-				p->draw_proc = accl_fillrect8;
-				return true;
-			} else if (p->dest_pixel_size == 32 && fillrect32_hook != NULL) {
-				p->draw_proc = accl_fillrect32;
-				return true;
-			}
-		} else if (p->transfer_mode == 10 && invrect_hook != NULL) {
-			// Invert
-			p->draw_proc = accl_invrect;
-			return true;
-		}
-	}
-	return false;
-}
-
-// Wait for graphics operation to finish
-static bool accl_sync_hook(void *arg)
-{
-	D(bug("accl_sync_hook %p\n", arg));
-	if (sync_hook != NULL)
-		sync_hook();
-	return true;
-}
-
-static struct accl_hook_info bitblt_hook_info = {accl_bitblt_hook, accl_sync_hook, ACCL_BITBLT};
-static struct accl_hook_info fillrect_hook_info = {accl_fillrect_hook, accl_sync_hook, ACCL_FILLRECT};
-#endif
-
-void VideoInstallAccel(void)
-{
-	// Install acceleration hooks
-	if (PrefsFindBool("gfxaccel")) {
-		D(bug("Video: Installing acceleration hooks\n"));
-//!!	NQDMisc(6, &bitblt_hook_info);
-//		NQDMisc(6, &fillrect_hook_info);
-	}
-}
-
-
-/*
  *  Change video mode
  */
 
@@ -1463,7 +2196,58 @@ int16 video_mode_change(VidLocals *csSav
 
 void video_set_palette(void)
 {
+	LOCK_PALETTE;
+
+	// Convert colors to XColor array
+	int mode = get_current_mode();
+	int num_in = palette_size(mode);
+	int num_out = 256;
+	bool stretch = false;
+	if (IsDirectMode(mode)) {
+		// If X is in 565 mode we have to stretch the gamma table from 32 to 64 entries
+		num_out = vis->map_entries;
+		stretch = true;
+	}
+	XColor *p = x_palette;
+	for (int i=0; i<num_out; i++) {
+		int c = (stretch ? (i * num_in) / num_out : i);
+		p->red = mac_pal[c].red * 0x0101;
+		p->green = mac_pal[c].green * 0x0101;
+		p->blue = mac_pal[c].blue * 0x0101;
+		p++;
+	}
+
+#ifdef ENABLE_VOSF
+	// Recalculate pixel color expansion map
+	if (!IsDirectMode(mode) && xdepth > 8) {
+		for (int i=0; i<256; i++) {
+			int c = i & (num_in-1); // If there are less than 256 colors, we repeat the first entries (this makes color expansion easier)
+			ExpandMap[i] = map_rgb(mac_pal[c].red, mac_pal[c].green, mac_pal[c].blue);
+		}
+
+		// We have to redraw everything because the interpretation of pixel values changed
+		LOCK_VOSF;
+		PFLAG_SET_ALL;
+		if (display_type == DIS_SCREEN)
+			PFLAG_SET_VERY_DIRTY;
+		UNLOCK_VOSF;
+	}
+#endif
+
+	// Tell redraw thread to change palette
 	palette_changed = true;
+
+	UNLOCK_PALETTE;
+}
+
+
+/*
+ *  Can we set the MacOS cursor image into the window?
+ */
+
+bool video_can_change_cursor(void)
+{
+	return hw_mac_cursor_accl && (display_type != DIS_SCREEN);
 }
 
 
@@ -1590,114 +2374,177 @@ static void update_display(void)
 
 	// Refresh display
 	if (high && wide) {
+		XDisplayLock();
 		if (have_shm)
 			XShmPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high, 0);
 		else
 			XPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high);
+		XDisplayUnlock();
 	}
 }
 
+const int VIDEO_REFRESH_HZ = 60;
+const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
+
+static void handle_palette_changes(void)
+{
+	LOCK_PALETTE;
+
+	if (palette_changed && !emul_suspended) {
+		palette_changed = false;
+
+		int mode = get_current_mode();
+		if (color_class == PseudoColor || color_class == DirectColor) {
+			int num = vis->map_entries;
+			bool set_clut = true;
+			if (!IsDirectMode(mode) && color_class == DirectColor) {
+				if (display_type == DIS_WINDOW)
+					set_clut = false; // Indexed mode on true color screen, don't set CLUT
+			}
+
+			if (set_clut) {
+				XDisplayLock();
+				XStoreColors(x_display, cmap[0], x_palette, num);
+				XStoreColors(x_display, cmap[1], x_palette, num);
+				XSync(x_display, false);
+				XDisplayUnlock();
+			}
+		}
+
+#ifdef ENABLE_XF86_DGA
+		if (display_type == DIS_SCREEN && !is_fbdev_dga_mode) {
+			current_dga_cmap ^= 1;
+			if (!IsDirectMode(mode) && cmap[current_dga_cmap])
+				XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
+		}
+#endif
+	}
+
+	UNLOCK_PALETTE;
+}
+
 static void *redraw_func(void *arg)
 {
-	int tick_counter = 0;
-	struct timespec req = {0, 16666667};
+	int fd = ConnectionNumber(x_display);
 
-	for (;;) {
+	uint64 start = GetTicks_usec();
+	int64 ticks = 0;
+	uint64 next = GetTicks_usec() + VIDEO_REFRESH_DELAY;
 
-		// Wait
-		nanosleep(&req, NULL);
+	while (!redraw_thread_cancel) {
 
 		// Pause if requested (during video mode switches)
 		while (thread_stop_req)
 			thread_stop_ack = true;
 
-		// Handle X11 events
-		handle_events();
+		int64 delay = next - GetTicks_usec();
+		if (delay < -VIDEO_REFRESH_DELAY) {
 
-		// Quit DGA mode if requested
-		if (quit_full_screen) {
-			quit_full_screen = false;
-			if (display_type == DIS_SCREEN) {
+			// We are lagging far behind, so we reset the delay mechanism
+			next = GetTicks_usec();
+
+		} else if (delay <= 0) {
+
+			// Delay expired, refresh display
+			next += VIDEO_REFRESH_DELAY;
+			ticks++;
+
+			// Handle X11 events
+			handle_events();
+
+			// Quit DGA mode if requested
+			if (quit_full_screen) {
+				quit_full_screen = false;
+				if (display_type == DIS_SCREEN) {
+					XDisplayLock();
+#if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA)
 #ifdef ENABLE_XF86_DGA
-				XF86DGADirectVideo(x_display, screen, 0);
-				XUngrabPointer(x_display, CurrentTime);
-				XUngrabKeyboard(x_display, CurrentTime);
+					if (!is_fbdev_dga_mode)
+						XF86DGADirectVideo(x_display, screen, 0);
 #endif
-				XSync(x_display, false);
-				quit_full_screen_ack = true;
-				return NULL;
+					XUngrabPointer(x_display, CurrentTime);
+					XUngrabKeyboard(x_display, CurrentTime);
+					XUnmapWindow(x_display, the_win);
+					wait_unmapped(the_win);
+					XDestroyWindow(x_display, the_win);
+#endif
+					XSync(x_display, false);
+					XDisplayUnlock();
+					quit_full_screen_ack = true;
+					return NULL;
+				}
 			}
-		}
 
-		// Refresh display and set cursor image in window mode
-		if (display_type == DIS_WINDOW) {
-			tick_counter++;
-			if (tick_counter >= frame_skip) {
-				tick_counter = 0;
+			// Refresh display and set cursor image in window mode
+			static int tick_counter = 0;
+			if (display_type == DIS_WINDOW) {
+				tick_counter++;
+				if (tick_counter >= frame_skip) {
+					tick_counter = 0;
 
-				// Update display
+					// Update display
 #ifdef ENABLE_VOSF
-				if (use_vosf) {
-					if (mainBuffer.dirty) {
-						LOCK_VOSF;
-						update_display_window_vosf();
-						UNLOCK_VOSF;
-						XSync(x_display, false); // Let the server catch up
+					if (use_vosf) {
+						XDisplayLock();
+						if (mainBuffer.dirty) {
+							LOCK_VOSF;
+							update_display_window_vosf();
+							UNLOCK_VOSF;
+							XSync(x_display, false); // Let the server catch up
+						}
+						XDisplayUnlock();
 					}
-				}
-				else
+					else
 #endif
-					update_display();
+						update_display();
 
-				// Set new cursor image if it was changed
-				if (cursor_changed) {
-					cursor_changed = false;
-					memcpy(cursor_image->data, MacCursor + 4, 32);
-					memcpy(cursor_mask_image->data, MacCursor + 36, 32);
-					XFreeCursor(x_display, mac_cursor);
-					XPutImage(x_display, cursor_map, cursor_gc, cursor_image, 0, 0, 0, 0, 16, 16);
-					XPutImage(x_display, cursor_mask_map, cursor_mask_gc, cursor_mask_image, 0, 0, 0, 0, 16, 16);
-					mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, MacCursor[2], MacCursor[3]);
-					XDefineCursor(x_display, the_win, mac_cursor);
+					// Set new cursor image if it was changed
+					if (hw_mac_cursor_accl && cursor_changed) {
+						cursor_changed = false;
+						uint8 *x_data = (uint8 *)cursor_image->data;
+						uint8 *x_mask = (uint8 *)cursor_mask_image->data;
+						for (int i = 0; i < 32; i++) {
+							x_mask[i] = MacCursor[4 + i] | MacCursor[36 + i];
+							x_data[i] = MacCursor[4 + i];
+						}
+						XDisplayLock();
+						XFreeCursor(x_display, mac_cursor);
+						XPutImage(x_display, cursor_map, cursor_gc, cursor_image, 0, 0, 0, 0, 16, 16);
+						XPutImage(x_display, cursor_mask_map, cursor_mask_gc, cursor_mask_image, 0, 0, 0, 0, 16, 16);
+						mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, MacCursor[2], MacCursor[3]);
+						XDefineCursor(x_display, the_win, mac_cursor);
+						XDisplayUnlock();
+					}
 				}
 			}
-		}
 #ifdef ENABLE_VOSF
-		else if (use_vosf) {
-			// Update display (VOSF variant)
-			static int tick_counter = 0;
-			if (++tick_counter >= frame_skip) {
-				tick_counter = 0;
-				if (mainBuffer.dirty) {
-					LOCK_VOSF;
-					update_display_dga_vosf();
-					UNLOCK_VOSF;
+			else if (use_vosf) {
+				// Update display (VOSF variant)
+				if (++tick_counter >= frame_skip) {
+					tick_counter = 0;
+					if (mainBuffer.dirty) {
+						LOCK_VOSF;
+						update_display_dga_vosf();
+						UNLOCK_VOSF;
+					}
 				}
 			}
-		}
 #endif
 
-		// Set new palette if it was changed
-		if (palette_changed && !emul_suspended) {
-			palette_changed = false;
-			XColor c[256];
-			for (int i=0; i<256; i++) {
-				c[i].pixel = i;
-				c[i].red = mac_pal[i].red * 0x0101;
-				c[i].green = mac_pal[i].green * 0x0101;
-				c[i].blue = mac_pal[i].blue * 0x0101;
-				c[i].flags = DoRed | DoGreen | DoBlue;
-			}
-			if (depth == 8) {
-				XStoreColors(x_display, cmap[0], c, 256);
-				XStoreColors(x_display, cmap[1], c, 256);
-#ifdef ENABLE_XF86_DGA
-				if (display_type == DIS_SCREEN) {
-					current_dga_cmap ^= 1;
-					XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
-				}
-#endif
-			}
+			// Set new palette if it was changed
+			handle_palette_changes();
+
+		} else {
+
+			// No display refresh pending, check for X events
+			fd_set readfds;
+			FD_ZERO(&readfds);
+			FD_SET(fd, &readfds);
+			struct timeval timeout;
+			timeout.tv_sec = 0;
+			timeout.tv_usec = delay;
+			if (select(fd+1, &readfds, NULL, NULL, &timeout) > 0)
+				handle_events();
 		}
 	}
 	return NULL;