ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/SheepShaver/src/Unix/video_x.cpp
(Generate patch)

Comparing SheepShaver/src/Unix/video_x.cpp (file contents):
Revision 1.5 by gbeauche, 2003-11-20T16:24:57Z vs.
Revision 1.25 by gbeauche, 2004-06-05T06:28:21Z

# Line 1 | Line 1
1   /*
2   *  video_x.cpp - Video/graphics emulation, X11 specific stuff
3   *
4 < *  SheepShaver (C) 1997-2002 Marc Hellwig and Christian Bauer
4 > *  SheepShaver (C) 1997-2004 Marc Hellwig and Christian Bauer
5   *
6   *  This program is free software; you can redistribute it and/or modify
7   *  it under the terms of the GNU General Public License as published by
# Line 18 | Line 18
18   *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19   */
20  
21 + #include "sysdeps.h"
22 +
23   #include <X11/Xlib.h>
24   #include <X11/Xutil.h>
25   #include <X11/keysym.h>
26   #include <X11/extensions/XShm.h>
27   #include <sys/ipc.h>
28   #include <sys/shm.h>
29 + #include <errno.h>
30   #include <pthread.h>
31  
32 < #include "sysdeps.h"
32 > #include <algorithm>
33 >
34 > #ifdef ENABLE_XF86_DGA
35 > # include <X11/extensions/xf86dga.h>
36 > #endif
37 >
38 > #ifdef ENABLE_XF86_VIDMODE
39 > # include <X11/extensions/xf86vmode.h>
40 > #endif
41 >
42   #include "main.h"
43   #include "adb.h"
44   #include "prefs.h"
# Line 38 | Line 50
50   #define DEBUG 0
51   #include "debug.h"
52  
53 < #ifdef ENABLE_XF86_DGA
54 < #include <X11/extensions/xf86dga.h>
53 > #ifndef NO_STD_NAMESPACE
54 > using std::sort;
55   #endif
56  
45 #ifdef ENABLE_XF86_VIDMODE
46 #include <X11/extensions/xf86vmode.h>
47 #endif
57  
58 + // Constants
59 + const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
60 + static const bool hw_mac_cursor_accl = true;    // Flag: Enable MacOS to X11 copy of cursor?
61  
62   // Global variables
63   static int32 frame_skip;
64 + static int16 mouse_wheel_mode;
65 + static int16 mouse_wheel_lines;
66   static bool redraw_thread_active = false;       // Flag: Redraw thread installed
67 + static pthread_attr_t redraw_thread_attr;       // Redraw thread attributes
68   static pthread_t redraw_thread;                         // Redraw thread
69  
70   static bool local_X11;                                          // Flag: X server running on local machine?
# Line 74 | Line 89 | static bool emerg_quit = false;                                // Fl
89   static bool emul_suspended = false;                     // Flag: emulator suspended
90   static Window suspend_win;                                      // "Suspend" window
91   static void *fb_save = NULL;                            // Saved frame buffer for suspend
92 + static bool use_keycodes = false;                       // Flag: Use keycodes rather than keysyms
93 + static int keycode_table[256];                          // X keycode -> Mac keycode translation table
94  
95   // X11 variables
96   static int screen;                                                      // Screen number
97   static int xdepth;                                                      // Depth of X screen
98   static int depth;                                                       // Depth of Mac frame buffer
99   static Window rootwin, the_win;                         // Root window and our window
100 + static int num_depths = 0;                                      // Number of available X depths
101 + static int *avail_depths = NULL;                        // List of available X depths
102   static XVisualInfo visualInfo;
103   static Visual *vis;
104 + static int color_class;
105 + static int rshift, rloss, gshift, gloss, bshift, bloss; // Pixel format of DirectColor/TrueColor modes
106   static Colormap cmap[2];                                        // Two colormaps (DGA) for 8-bit mode
107 + static XColor x_palette[256];                           // Color palette to be used as CLUT and gamma table
108 +
109   static XColor black, white;
110   static unsigned long black_pixel, white_pixel;
111   static int eventmask;
112 < static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask;
113 < static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
112 > static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask | StructureNotifyMask;
113 > static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask;
114  
115   // Variables for window mode
116   static GC the_gc;
# Line 104 | Line 127 | static uint8 *the_buffer_copy = NULL;          /
127   static uint32 the_buffer_size;                          // Size of allocated the_buffer
128  
129   // Variables for DGA mode
107 static char *dga_screen_base;
108 static int dga_fb_width;
130   static int current_dga_cmap;
131  
132   #ifdef ENABLE_XF86_VIDMODE
# Line 114 | Line 135 | static XF86VidModeModeInfo **x_video_mod
135   static int num_x_video_modes;
136   #endif
137  
138 + // Mutex to protect palette
139 + #ifdef HAVE_SPINLOCKS
140 + static spinlock_t x_palette_lock = SPIN_LOCK_UNLOCKED;
141 + #define LOCK_PALETTE spin_lock(&x_palette_lock)
142 + #define UNLOCK_PALETTE spin_unlock(&x_palette_lock)
143 + #elif defined(HAVE_PTHREADS)
144 + static pthread_mutex_t x_palette_lock = PTHREAD_MUTEX_INITIALIZER;
145 + #define LOCK_PALETTE pthread_mutex_lock(&x_palette_lock)
146 + #define UNLOCK_PALETTE pthread_mutex_unlock(&x_palette_lock)
147 + #else
148 + #define LOCK_PALETTE
149 + #define UNLOCK_PALETTE
150 + #endif
151 +
152  
153   // Prototypes
154   static void *redraw_func(void *arg);
# Line 126 | Line 161 | extern Display *x_display;
161   // From sys_unix.cpp
162   extern void SysMountFirstFloppy(void);
163  
164 + // From clip_unix.cpp
165 + extern void ClipboardSelectionClear(XSelectionClearEvent *);
166 + extern void ClipboardSelectionRequest(XSelectionRequestEvent *);
167 +
168  
169   // Video acceleration through SIGSEGV
170   #ifdef ENABLE_VOSF
# Line 134 | Line 173 | extern void SysMountFirstFloppy(void);
173  
174  
175   /*
176 + *  Utility functions
177 + */
178 +
179 + // Get current video mode
180 + static inline int get_current_mode(void)
181 + {
182 +        return VModes[cur_mode].viAppleMode;
183 + }
184 +
185 + // Find palette size for given color depth
186 + static int palette_size(int mode)
187 + {
188 +        switch (mode) {
189 +        case APPLE_1_BIT: return 2;
190 +        case APPLE_2_BIT: return 4;
191 +        case APPLE_4_BIT: return 16;
192 +        case APPLE_8_BIT: return 256;
193 +        case APPLE_16_BIT: return 32;
194 +        case APPLE_32_BIT: return 256;
195 +        default: return 0;
196 +        }
197 + }
198 +
199 + // Return bits per pixel for requested depth
200 + static inline int bytes_per_pixel(int depth)
201 + {
202 +        int bpp;
203 +        switch (depth) {
204 +        case 8:
205 +                bpp = 1;
206 +                break;
207 +        case 15: case 16:
208 +                bpp = 2;
209 +                break;
210 +        case 24: case 32:
211 +                bpp = 4;
212 +                break;
213 +        default:
214 +                abort();
215 +        }
216 +        return bpp;
217 + }
218 +
219 + // Map video_mode depth ID to numerical depth value
220 + static inline int depth_of_video_mode(int mode)
221 + {
222 +        int depth;
223 +        switch (mode) {
224 +        case APPLE_1_BIT:
225 +                depth = 1;
226 +                break;
227 +        case APPLE_2_BIT:
228 +                depth = 2;
229 +                break;
230 +        case APPLE_4_BIT:
231 +                depth = 4;
232 +                break;
233 +        case APPLE_8_BIT:
234 +                depth = 8;
235 +                break;
236 +        case APPLE_16_BIT:
237 +                depth = 16;
238 +                break;
239 +        case APPLE_32_BIT:
240 +                depth = 32;
241 +                break;
242 +        default:
243 +                abort();
244 +        }
245 +        return depth;
246 + }
247 +
248 + // Map RGB color to pixel value (this only works in TrueColor/DirectColor visuals)
249 + static inline uint32 map_rgb(uint8 red, uint8 green, uint8 blue)
250 + {
251 +        return ((red >> rloss) << rshift) | ((green >> gloss) << gshift) | ((blue >> bloss) << bshift);
252 + }
253 +
254 +
255 + // Do we have a visual for handling the specified Mac depth? If so, set the
256 + // global variables "xdepth", "visualInfo", "vis" and "color_class".
257 + static bool find_visual_for_depth(int depth)
258 + {
259 +        D(bug("have_visual_for_depth(%d)\n", depth_of_video_mode(depth)));
260 +
261 +        // 1-bit works always and uses default visual
262 +        if (depth == APPLE_1_BIT) {
263 +                vis = DefaultVisual(x_display, screen);
264 +                visualInfo.visualid = XVisualIDFromVisual(vis);
265 +                int num = 0;
266 +                XVisualInfo *vi = XGetVisualInfo(x_display, VisualIDMask, &visualInfo, &num);
267 +                visualInfo = vi[0];
268 +                XFree(vi);
269 +                xdepth = visualInfo.depth;
270 +                color_class = visualInfo.c_class;
271 +                D(bug(" found visual ID 0x%02x, depth %d\n", visualInfo.visualid, xdepth));
272 +                return true;
273 +        }
274 +
275 +        // Calculate minimum and maximum supported X depth
276 +        int min_depth = 1, max_depth = 32;
277 +        switch (depth) {
278 + #ifdef ENABLE_VOSF
279 +                case APPLE_2_BIT:
280 +                case APPLE_4_BIT:       // VOSF blitters can convert 2/4/8-bit -> 8/16/32-bit
281 +                case APPLE_8_BIT:
282 +                        min_depth = 8;
283 +                        max_depth = 32;
284 +                        break;
285 + #else
286 +                case APPLE_2_BIT:
287 +                case APPLE_4_BIT:       // 2/4-bit requires VOSF blitters
288 +                        return false;
289 +                case APPLE_8_BIT:       // 8-bit without VOSF requires an 8-bit visual
290 +                        min_depth = 8;
291 +                        max_depth = 8;
292 +                        break;
293 + #endif
294 +                case APPLE_16_BIT:      // 16-bit requires a 15/16-bit visual
295 +                        min_depth = 15;
296 +                        max_depth = 16;
297 +                        break;
298 +                case APPLE_32_BIT:      // 32-bit requires a 24/32-bit visual
299 +                        min_depth = 24;
300 +                        max_depth = 32;
301 +                        break;
302 +        }
303 +        D(bug(" minimum required X depth is %d, maximum supported X depth is %d\n", min_depth, max_depth));
304 +
305 +        // Try to find a visual for one of the color depths
306 +        bool visual_found = false;
307 +        for (int i=0; i<num_depths && !visual_found; i++) {
308 +
309 +                xdepth = avail_depths[i];
310 +                D(bug(" trying to find visual for depth %d\n", xdepth));
311 +                if (xdepth < min_depth || xdepth > max_depth)
312 +                        continue;
313 +
314 +                // Determine best color class for this depth
315 +                switch (xdepth) {
316 +                        case 1: // Try StaticGray or StaticColor
317 +                                if (XMatchVisualInfo(x_display, screen, xdepth, StaticGray, &visualInfo)
318 +                                 || XMatchVisualInfo(x_display, screen, xdepth, StaticColor, &visualInfo))
319 +                                        visual_found = true;
320 +                                break;
321 +                        case 8: // Need PseudoColor
322 +                                if (XMatchVisualInfo(x_display, screen, xdepth, PseudoColor, &visualInfo))
323 +                                        visual_found = true;
324 +                                break;
325 +                        case 15:
326 +                        case 16:
327 +                        case 24:
328 +                        case 32: // Try DirectColor first, as this will allow gamma correction
329 +                                if (XMatchVisualInfo(x_display, screen, xdepth, DirectColor, &visualInfo)
330 +                                 || XMatchVisualInfo(x_display, screen, xdepth, TrueColor, &visualInfo))
331 +                                        visual_found = true;
332 +                                break;
333 +                        default:
334 +                                D(bug("  not a supported depth\n"));
335 +                                break;
336 +                }
337 +        }
338 +        if (!visual_found)
339 +                return false;
340 +
341 +        // Visual was found
342 +        vis = visualInfo.visual;
343 +        color_class = visualInfo.c_class;
344 +        D(bug(" found visual ID 0x%02x, depth %d, class ", visualInfo.visualid, xdepth));
345 + #if DEBUG
346 +        switch (color_class) {
347 +                case StaticGray: D(bug("StaticGray\n")); break;
348 +                case GrayScale: D(bug("GrayScale\n")); break;
349 +                case StaticColor: D(bug("StaticColor\n")); break;
350 +                case PseudoColor: D(bug("PseudoColor\n")); break;
351 +                case TrueColor: D(bug("TrueColor\n")); break;
352 +                case DirectColor: D(bug("DirectColor\n")); break;
353 +        }
354 + #endif
355 +        return true;
356 + }
357 +
358 +
359 + /*
360   *  Open display (window or fullscreen)
361   */
362  
363 + // Set WM_DELETE_WINDOW protocol on window (preventing it from being destroyed by the WM when clicking on the "close" widget)
364 + static Atom WM_DELETE_WINDOW = (Atom)0;
365 + static void set_window_delete_protocol(Window w)
366 + {
367 +        WM_DELETE_WINDOW = XInternAtom(x_display, "WM_DELETE_WINDOW", false);
368 +        XSetWMProtocols(x_display, w, &WM_DELETE_WINDOW, 1);
369 + }
370 +
371 + // Wait until window is mapped/unmapped
372 + static void wait_mapped(Window w)
373 + {
374 +        XEvent e;
375 +        do {
376 +                XMaskEvent(x_display, StructureNotifyMask, &e);
377 +        } while ((e.type != MapNotify) || (e.xmap.event != w));
378 + }
379 +
380 + static void wait_unmapped(Window w)
381 + {
382 +        XEvent e;
383 +        do {
384 +                XMaskEvent(x_display, StructureNotifyMask, &e);
385 +        } while ((e.type != UnmapNotify) || (e.xmap.event != w));
386 + }
387 +
388   // Trap SHM errors
389   static bool shm_error = false;
390   static int (*old_error_handler)(Display *, XErrorEvent *);
# Line 159 | Line 407 | static bool open_window(int width, int h
407          // Set absolute mouse mode
408          ADBSetRelMouseMode(false);
409  
162        // Read frame skip prefs
163        frame_skip = PrefsFindInt32("frameskip");
164        if (frame_skip == 0)
165                frame_skip = 1;
166
410          // Create window
411          XSetWindowAttributes wattr;
412          wattr.event_mask = eventmask = win_eventmask;
413 <        wattr.background_pixel = black_pixel;
414 <        wattr.border_pixel = black_pixel;
413 >        wattr.background_pixel = (vis == DefaultVisual(x_display, screen) ? black_pixel : 0);
414 >        wattr.border_pixel = 0;
415          wattr.backing_store = NotUseful;
416 <
174 <        XSync(x_display, false);
416 >        wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]);
417          the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
418 <                InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore, &wattr);
419 <        XSync(x_display, false);
418 >                InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore | CWColormap, &wattr);
419 >
420 >        // Set window name
421          XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE));
179        XMapRaised(x_display, the_win);
180        XSync(x_display, false);
422  
423 <        // Set colormap
424 <        if (depth == 8) {
184 <                XSetWindowColormap(x_display, the_win, cmap[0]);
185 <                XSetWMColormapWindows(x_display, the_win, &the_win, 1);
186 <        }
423 >        // Set delete protocol property
424 >        set_window_delete_protocol(the_win);
425  
426          // Make window unresizable
427          XSizeHints *hints;
# Line 197 | Line 435 | static bool open_window(int width, int h
435                  XFree((char *)hints);
436          }
437  
438 +        // Show window
439 +        XMapWindow(x_display, the_win);
440 +        wait_mapped(the_win);
441 +
442          // 1-bit mode is big-endian; if the X server is little-endian, we can't
443          // use SHM because that doesn't allow changing the image byte order
444          bool need_msb_image = (depth == 1 && XImageByteOrder(x_display) == LSBFirst);
# Line 207 | Line 449 | static bool open_window(int width, int h
449  
450                  // Create SHM image ("height + 2" for safety)
451                  img = XShmCreateImage(x_display, vis, depth == 1 ? 1 : xdepth, depth == 1 ? XYBitmap : ZPixmap, 0, &shminfo, width, height);
452 <                shminfo.shmid = shmget(IPC_PRIVATE, (height + 2) * img->bytes_per_line, IPC_CREAT | 0777);
452 >                shminfo.shmid = shmget(IPC_PRIVATE, (aligned_height + 2) * img->bytes_per_line, IPC_CREAT | 0777);
453 >                D(bug(" shm image created\n"));
454                  the_buffer_copy = (uint8 *)shmat(shminfo.shmid, 0, 0);
455                  shminfo.shmaddr = img->data = (char *)the_buffer_copy;
456                  shminfo.readOnly = False;
# Line 226 | Line 469 | static bool open_window(int width, int h
469                          have_shm = true;
470                          shmctl(shminfo.shmid, IPC_RMID, 0);
471                  }
472 +                D(bug(" shm image attached\n"));
473          }
474  
475          // Create normal X image if SHM doesn't work ("height + 2" for safety)
476          if (!have_shm) {
477 <                int bytes_per_row = aligned_width;
234 <                switch (depth) {
235 <                        case 1:
236 <                                bytes_per_row /= 8;
237 <                                break;
238 <                        case 15:
239 <                        case 16:
240 <                                bytes_per_row *= 2;
241 <                                break;
242 <                        case 24:
243 <                        case 32:
244 <                                bytes_per_row *= 4;
245 <                                break;
246 <                }
477 >                int bytes_per_row = depth == 1 ? aligned_width/8 : TrivialBytesPerRow(aligned_width, DepthModeForPixelDepth(xdepth));
478                  the_buffer_copy = (uint8 *)malloc((aligned_height + 2) * bytes_per_row);
479                  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);
480 +                D(bug(" X image created\n"));
481          }
482  
483          // 1-Bit mode is big-endian
484 <    if (depth == 1) {
484 >    if (need_msb_image) {
485          img->byte_order = MSBFirst;
486          img->bitmap_bit_order = MSBFirst;
487      }
# Line 271 | Line 503 | static bool open_window(int width, int h
503  
504          // Create GC
505          the_gc = XCreateGC(x_display, the_win, 0, 0);
506 <        XSetForeground(x_display, the_gc, black_pixel);
506 >        XSetState(x_display, the_gc, black_pixel, white_pixel, GXcopy, AllPlanes);
507  
508          // Create cursor
509 <        cursor_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 4, 16, 16, 16, 2);
510 <        cursor_image->byte_order = MSBFirst;
511 <        cursor_image->bitmap_bit_order = MSBFirst;
512 <        cursor_mask_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 36, 16, 16, 16, 2);
513 <        cursor_mask_image->byte_order = MSBFirst;
514 <        cursor_mask_image->bitmap_bit_order = MSBFirst;
515 <        cursor_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
516 <        cursor_mask_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
517 <        cursor_gc = XCreateGC(x_display, cursor_map, 0, 0);
518 <        cursor_mask_gc = XCreateGC(x_display, cursor_mask_map, 0, 0);
519 <        mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, 0, 0);
520 <        cursor_changed = false;
509 >        if (hw_mac_cursor_accl) {
510 >                cursor_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 4, 16, 16, 16, 2);
511 >                cursor_image->byte_order = MSBFirst;
512 >                cursor_image->bitmap_bit_order = MSBFirst;
513 >                cursor_mask_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 36, 16, 16, 16, 2);
514 >                cursor_mask_image->byte_order = MSBFirst;
515 >                cursor_mask_image->bitmap_bit_order = MSBFirst;
516 >                cursor_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
517 >                cursor_mask_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
518 >                cursor_gc = XCreateGC(x_display, cursor_map, 0, 0);
519 >                cursor_mask_gc = XCreateGC(x_display, cursor_mask_map, 0, 0);
520 >                mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, 0, 0);
521 >                cursor_changed = false;
522 >        }
523 >
524 >        // Create no_cursor
525 >        else {
526 >                mac_cursor = XCreatePixmapCursor(x_display,
527 >                        XCreatePixmap(x_display, the_win, 1, 1, 1),
528 >                        XCreatePixmap(x_display, the_win, 1, 1, 1),
529 >                        &black, &white, 0, 0);
530 >                XDefineCursor(x_display, the_win, mac_cursor);
531 >        }
532  
533          // Init blitting routines
534          bool native_byte_order;
# Line 299 | Line 542 | static bool open_window(int width, int h
542   #endif
543  
544          // Set bytes per row
302        VModes[cur_mode].viRowBytes = img->bytes_per_line;
545          XSync(x_display, false);
546          return true;
547   }
# Line 311 | Line 553 | static bool open_dga(int width, int heig
553          // Set relative mouse mode
554          ADBSetRelMouseMode(true);
555  
556 +        // Create window
557 +        XSetWindowAttributes wattr;
558 +        wattr.event_mask = eventmask = dga_eventmask;
559 +        wattr.override_redirect = True;
560 +        wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]);
561 +        the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
562 +                InputOutput, vis, CWEventMask | CWOverrideRedirect |
563 +                (color_class == DirectColor ? CWColormap : 0), &wattr);
564 +
565 +        // Show window
566 +        XMapRaised(x_display, the_win);
567 +        wait_mapped(the_win);
568 +
569   #ifdef ENABLE_XF86_VIDMODE
570          // Switch to best mode
571          if (has_vidmode) {
# Line 327 | Line 582 | static bool open_dga(int width, int heig
582   #endif
583  
584          // Establish direct screen connection
585 +        XMoveResizeWindow(x_display, the_win, 0, 0, width, height);
586 +        XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0);
587          XGrabKeyboard(x_display, rootwin, True, GrabModeAsync, GrabModeAsync, CurrentTime);
588          XGrabPointer(x_display, rootwin, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
589 +
590 +        int v_width, v_bank, v_size;
591 +        XF86DGAGetVideo(x_display, screen, (char **)&the_buffer, &v_width, &v_bank, &v_size);
592          XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse);
593          XF86DGASetViewPort(x_display, screen, 0, 0);
594          XF86DGASetVidPage(x_display, screen, 0);
595  
596          // Set colormap
597 <        if (depth == 8)
597 >        if (!IsDirectMode(get_current_mode())) {
598 >                XSetWindowColormap(x_display, the_win, cmap[current_dga_cmap = 0]);
599                  XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
339
340        // Set bytes per row
341        int bytes_per_row = (dga_fb_width + 7) & ~7;
342        switch (depth) {
343                case 15:
344                case 16:
345                        bytes_per_row *= 2;
346                        break;
347                case 24:
348                case 32:
349                        bytes_per_row *= 4;
350                        break;
600          }
601 +        XSync(x_display, false);
602  
603 +        // Init blitting routines
604 +        int bytes_per_row = TrivialBytesPerRow((v_width + 7) & ~7, DepthModeForPixelDepth(depth));
605   #if ENABLE_VOSF
606          bool native_byte_order;
607   #ifdef WORDS_BIGENDIAN
# Line 368 | Line 620 | static bool open_dga(int width, int heig
620            the_buffer_size = page_extend((height + 2) * bytes_per_row);
621            the_buffer_copy = (uint8 *)malloc(the_buffer_size);
622            the_buffer = (uint8 *)vm_acquire(the_buffer_size);
623 +          D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
624          }
625   #else
626          use_vosf = false;
374        the_buffer = dga_screen_base;
627   #endif
628   #endif
377        screen_base = (uint32)the_buffer;
629  
630 +        // Set frame buffer base
631 +        D(bug("the_buffer = %p, use_vosf = %d\n", the_buffer, use_vosf));
632 +        screen_base = (uint32)the_buffer;
633          VModes[cur_mode].viRowBytes = bytes_per_row;
380        XSync(x_display, false);
634          return true;
635   #else
636          ErrorAlert("SheepShaver has been compiled with DGA support disabled.");
# Line 387 | Line 640 | static bool open_dga(int width, int heig
640  
641   static bool open_display(void)
642   {
643 <        display_type = VModes[cur_mode].viType;
644 <        switch (VModes[cur_mode].viAppleMode) {
645 <                case APPLE_1_BIT:
646 <                        depth = 1;
647 <                        break;
648 <                case APPLE_2_BIT:
649 <                        depth = 2;
397 <                        break;
398 <                case APPLE_4_BIT:
399 <                        depth = 4;
400 <                        break;
401 <                case APPLE_8_BIT:
402 <                        depth = 8;
403 <                        break;
404 <                case APPLE_16_BIT:
405 <                        depth = xdepth == 15 ? 15 : 16;
406 <                        break;
407 <                case APPLE_32_BIT:
408 <                        depth = 32;
409 <                        break;
643 >        D(bug("open_display()\n"));
644 >        const VideoInfo &mode = VModes[cur_mode];
645 >
646 >        // Find best available X visual
647 >        if (!find_visual_for_depth(mode.viAppleMode)) {
648 >                ErrorAlert(GetString(STR_NO_XVISUAL_ERR));
649 >                return false;
650          }
651  
652 +        // Create color maps
653 +        if (color_class == PseudoColor || color_class == DirectColor) {
654 +                cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
655 +                cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
656 +        } else {
657 +                cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocNone);
658 +                cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocNone);
659 +        }
660 +
661 +        // Find pixel format of direct modes
662 +        if (color_class == DirectColor || color_class == TrueColor) {
663 +                rshift = gshift = bshift = 0;
664 +                rloss = gloss = bloss = 8;
665 +                uint32 mask;
666 +                for (mask=vis->red_mask; !(mask&1); mask>>=1)
667 +                        ++rshift;
668 +                for (; mask&1; mask>>=1)
669 +                        --rloss;
670 +                for (mask=vis->green_mask; !(mask&1); mask>>=1)
671 +                        ++gshift;
672 +                for (; mask&1; mask>>=1)
673 +                        --gloss;
674 +                for (mask=vis->blue_mask; !(mask&1); mask>>=1)
675 +                        ++bshift;
676 +                for (; mask&1; mask>>=1)
677 +                        --bloss;
678 +        }
679 +
680 +        // Preset palette pixel values for CLUT or gamma table
681 +        if (color_class == DirectColor) {
682 +                int num = vis->map_entries;
683 +                for (int i=0; i<num; i++) {
684 +                        int c = (i * 256) / num;
685 +                        x_palette[i].pixel = map_rgb(c, c, c);
686 +                        x_palette[i].flags = DoRed | DoGreen | DoBlue;
687 +                }
688 +        } else if (color_class == PseudoColor) {
689 +                for (int i=0; i<256; i++) {
690 +                        x_palette[i].pixel = i;
691 +                        x_palette[i].flags = DoRed | DoGreen | DoBlue;
692 +                }
693 +        }
694 +
695 +        // Load gray ramp to color map
696 +        int num = (color_class == DirectColor ? vis->map_entries : 256);
697 +        for (int i=0; i<num; i++) {
698 +                int c = (i * 256) / num;
699 +                x_palette[i].red = c * 0x0101;
700 +                x_palette[i].green = c * 0x0101;
701 +                x_palette[i].blue = c * 0x0101;
702 +        }
703 +        if (color_class == PseudoColor || color_class == DirectColor) {
704 +                XStoreColors(x_display, cmap[0], x_palette, num);
705 +                XStoreColors(x_display, cmap[1], x_palette, num);
706 +        }
707 +
708 + #ifdef ENABLE_VOSF
709 +        // Load gray ramp to 8->16/32 expand map
710 +        if (!IsDirectMode(get_current_mode()) && xdepth > 8)
711 +                for (int i=0; i<256; i++)
712 +                        ExpandMap[i] = map_rgb(i, i, i);
713 + #endif
714 +
715 +        // Create display of requested type
716 +        display_type = mode.viType;
717 +        depth = depth_of_video_mode(mode.viAppleMode);
718 +
719          bool display_open = false;
720          if (display_type == DIS_SCREEN)
721                  display_open = open_dga(VModes[cur_mode].viXsize, VModes[cur_mode].viYsize);
# Line 456 | Line 763 | static void close_window(void)
763          if (the_gc)
764                  XFreeGC(x_display, the_gc);
765  
766 <        // Close window
767 <        XDestroyWindow(x_display, the_win);
766 >        XFlush(x_display);
767 >        XSync(x_display, false);
768   }
769  
770   // Close DGA mode
# Line 493 | Line 800 | static void close_display(void)
800          else if (display_type == DIS_WINDOW)
801                  close_window();
802  
803 +        // Close window
804 +        if (the_win) {
805 +                XUnmapWindow(x_display, the_win);
806 +                wait_unmapped(the_win);
807 +                XDestroyWindow(x_display, the_win);
808 +        }
809 +
810 +        // Free colormaps
811 +        if (cmap[0]) {
812 +                XFreeColormap(x_display, cmap[0]);
813 +                cmap[0] = 0;
814 +        }
815 +        if (cmap[1]) {
816 +                XFreeColormap(x_display, cmap[1]);
817 +                cmap[1] = 0;
818 +        }
819 +
820   #ifdef ENABLE_VOSF
821          if (use_vosf) {
822                  // Deinitialize VOSF
# Line 534 | Line 858 | static void close_display(void)
858   *  Initialization
859   */
860  
861 < static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, long apple_mode, long apple_id, int type)
861 > // Init keycode translation table
862 > static void keycode_init(void)
863 > {
864 >        bool use_kc = PrefsFindBool("keycodes");
865 >        if (use_kc) {
866 >
867 >                // Get keycode file path from preferences
868 >                const char *kc_path = PrefsFindString("keycodefile");
869 >
870 >                // Open keycode table
871 >                FILE *f = fopen(kc_path ? kc_path : KEYCODE_FILE_NAME, "r");
872 >                if (f == NULL) {
873 >                        char str[256];
874 >                        sprintf(str, GetString(STR_KEYCODE_FILE_WARN), kc_path ? kc_path : KEYCODE_FILE_NAME, strerror(errno));
875 >                        WarningAlert(str);
876 >                        return;
877 >                }
878 >
879 >                // Default translation table
880 >                for (int i=0; i<256; i++)
881 >                        keycode_table[i] = -1;
882 >
883 >                // Search for server vendor string, then read keycodes
884 >                const char *vendor = ServerVendor(x_display);
885 >                bool vendor_found = false;
886 >                char line[256];
887 >                while (fgets(line, 255, f)) {
888 >                        // Read line
889 >                        int len = strlen(line);
890 >                        if (len == 0)
891 >                                continue;
892 >                        line[len-1] = 0;
893 >
894 >                        // Comments begin with "#" or ";"
895 >                        if (line[0] == '#' || line[0] == ';' || line[0] == 0)
896 >                                continue;
897 >
898 >                        if (vendor_found) {
899 >                                // Read keycode
900 >                                int x_code, mac_code;
901 >                                if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
902 >                                        keycode_table[x_code & 0xff] = mac_code;
903 >                                else
904 >                                        break;
905 >                        } else {
906 >                                // Search for vendor string
907 >                                if (strstr(vendor, line) == vendor)
908 >                                        vendor_found = true;
909 >                        }
910 >                }
911 >
912 >                // Keycode file completely read
913 >                fclose(f);
914 >                use_keycodes = vendor_found;
915 >
916 >                // Vendor not found? Then display warning
917 >                if (!vendor_found) {
918 >                        char str[256];
919 >                        sprintf(str, GetString(STR_KEYCODE_VENDOR_WARN), vendor, kc_path ? kc_path : KEYCODE_FILE_NAME);
920 >                        WarningAlert(str);
921 >                        return;
922 >                }
923 >        }
924 > }
925 >
926 > // Find Apple mode matching best specified dimensions
927 > static int find_apple_resolution(int xsize, int ysize)
928 > {
929 >        int apple_id;
930 >        if (xsize < 800)
931 >                apple_id = APPLE_640x480;
932 >        else if (xsize < 1024)
933 >                apple_id = APPLE_800x600;
934 >        else if (xsize < 1152)
935 >                apple_id = APPLE_1024x768;
936 >        else if (xsize < 1280) {
937 >                if (ysize < 900)
938 >                        apple_id = APPLE_1152x768;
939 >                else
940 >                        apple_id = APPLE_1152x900;
941 >        }
942 >        else if (xsize < 1600)
943 >                apple_id = APPLE_1280x1024;
944 >        else
945 >                apple_id = APPLE_1600x1200;
946 >        return apple_id;
947 > }
948 >
949 > // Find mode in list of supported modes
950 > static int find_mode(int apple_mode, int apple_id, int type)
951 > {
952 >        for (VideoInfo *p = VModes; p->viType != DIS_INVALID; p++) {
953 >                if (p->viType == type && p->viAppleID == apple_id && p->viAppleMode == apple_mode)
954 >                        return p - VModes;
955 >        }
956 >        return -1;
957 > }
958 >
959 > // Add mode to list of supported modes
960 > static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, int apple_mode, int apple_id, int type)
961   {
962          if (allow & test) {
963                  p->viType = type;
# Line 553 | Line 976 | static void add_mode(VideoInfo *&p, uint
976                                  p->viXsize = 1024;
977                                  p->viYsize = 768;
978                                  break;
979 +                        case APPLE_1152x768:
980 +                                p->viXsize = 1152;
981 +                                p->viYsize = 768;
982 +                                break;
983                          case APPLE_1152x900:
984                                  p->viXsize = 1152;
985                                  p->viYsize = 900;
# Line 566 | Line 993 | static void add_mode(VideoInfo *&p, uint
993                                  p->viYsize = 1200;
994                                  break;
995                  }
996 <                switch (apple_mode) {
570 <                        case APPLE_8_BIT:
571 <                                p->viRowBytes = p->viXsize;
572 <                                break;
573 <                        case APPLE_16_BIT:
574 <                                p->viRowBytes = p->viXsize * 2;
575 <                                break;
576 <                        case APPLE_32_BIT:
577 <                                p->viRowBytes = p->viXsize * 4;
578 <                                break;
579 <                }
996 >                p->viRowBytes = TrivialBytesPerRow(p->viXsize, apple_mode);
997                  p->viAppleMode = apple_mode;
998                  p->viAppleID = apple_id;
999                  p++;
1000          }
1001   }
1002  
1003 + // Add standard list of windowed modes for given color depth
1004 + static void add_window_modes(VideoInfo *&p, int window_modes, int mode)
1005 + {
1006 +        add_mode(p, window_modes, 1, mode, APPLE_W_640x480, DIS_WINDOW);
1007 +        add_mode(p, window_modes, 2, mode, APPLE_W_800x600, DIS_WINDOW);
1008 + }
1009 +
1010   static bool has_mode(int x, int y)
1011   {
1012   #ifdef ENABLE_XF86_VIDMODE
# Line 607 | Line 1031 | bool VideoInit(void)
1031          local_X11 = (strncmp(XDisplayName(x_display_name), ":", 1) == 0)
1032                   || (strncmp(XDisplayName(x_display_name), "unix:", 5) == 0);
1033      
1034 +        // Init keycode translation
1035 +        keycode_init();
1036 +
1037 +        // Read frame skip prefs
1038 +        frame_skip = PrefsFindInt32("frameskip");
1039 +        if (frame_skip == 0)
1040 +                frame_skip = 1;
1041 +
1042 +        // Read mouse wheel prefs
1043 +        mouse_wheel_mode = PrefsFindInt32("mousewheelmode");
1044 +        mouse_wheel_lines = PrefsFindInt32("mousewheellines");
1045 +
1046          // Init variables
1047          private_data = NULL;
612        cur_mode = 0;   // Window 640x480
1048          video_activated = true;
1049  
1050          // Find screen and root window
1051          screen = XDefaultScreen(x_display);
1052          rootwin = XRootWindow(x_display, screen);
1053  
1054 +        // Get sorted list of available depths
1055 +        avail_depths = XListDepths(x_display, screen, &num_depths);
1056 +        if (avail_depths == NULL) {
1057 +                ErrorAlert(GetString(STR_UNSUPP_DEPTH_ERR));
1058 +                return false;
1059 +        }
1060 +        sort(avail_depths, avail_depths + num_depths);
1061 +        
1062          // Get screen depth
1063          xdepth = DefaultDepth(x_display, screen);
1064  
# Line 646 | Line 1089 | bool VideoInit(void)
1089          black_pixel = BlackPixel(x_display, screen);
1090          white_pixel = WhitePixel(x_display, screen);
1091  
649        // Get appropriate visual
650        int color_class;
651        switch (xdepth) {
652 #if 0
653                case 1:
654                        color_class = StaticGray;
655                        break;
656 #endif
657                case 8:
658                        color_class = PseudoColor;
659                        break;
660                case 15:
661                case 16:
662                case 24:
663                case 32:
664                        color_class = TrueColor;
665                        break;
666                default:
667                        ErrorAlert(GetString(STR_UNSUPP_DEPTH_ERR));
668                        return false;
669        }
670        if (!XMatchVisualInfo(x_display, screen, xdepth, color_class, &visualInfo)) {
671                ErrorAlert(GetString(STR_NO_XVISUAL_ERR));
672                return false;
673        }
674        if (visualInfo.depth != xdepth) {
675                ErrorAlert(GetString(STR_NO_XVISUAL_ERR));
676                return false;
677        }
678        vis = visualInfo.visual;
679
1092          // Mac screen depth follows X depth (for now)
1093 <        depth = xdepth;
1094 <
1095 <        // Create color maps for 8 bit mode
1096 <        if (depth == 8) {
1097 <                cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1098 <                cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1099 <                XInstallColormap(x_display, cmap[0]);
1100 <                XInstallColormap(x_display, cmap[1]);
1093 >        int default_mode = APPLE_8_BIT;
1094 >        switch (DefaultDepth(x_display, screen)) {
1095 >        case 1:
1096 >                default_mode = APPLE_1_BIT;
1097 >                break;
1098 >        case 8:
1099 >                default_mode = APPLE_8_BIT;
1100 >                break;
1101 >        case 15: case 16:
1102 >                default_mode = APPLE_16_BIT;
1103 >                break;
1104 >        case 24: case 32:
1105 >                default_mode = APPLE_32_BIT;
1106 >                break;
1107          }
1108  
1109          // Construct video mode table
692        int mode = APPLE_8_BIT;
693        int bpr_mult = 8;
694        switch (depth) {
695                case 1:
696                        mode = APPLE_1_BIT;
697                        bpr_mult = 1;
698                        break;
699                case 8:
700                        mode = APPLE_8_BIT;
701                        bpr_mult = 8;
702                        break;
703                case 15:
704                case 16:
705                        mode = APPLE_16_BIT;
706                        bpr_mult = 16;
707                        break;
708                case 24:
709                case 32:
710                        mode = APPLE_32_BIT;
711                        bpr_mult = 32;
712                        break;
713        }
714
1110          uint32 window_modes = PrefsFindInt32("windowmodes");
1111          uint32 screen_modes = PrefsFindInt32("screenmodes");
1112          if (!has_dga)
# Line 720 | Line 1115 | bool VideoInit(void)
1115                  window_modes |= 3;      // Allow at least 640x480 and 800x600 window modes
1116  
1117          VideoInfo *p = VModes;
1118 <        add_mode(p, window_modes, 1, mode, APPLE_W_640x480, DIS_WINDOW);
1119 <        add_mode(p, window_modes, 2, mode, APPLE_W_800x600, DIS_WINDOW);
1118 >        for (unsigned int d = APPLE_1_BIT; d <= APPLE_32_BIT; d++)
1119 >                if (find_visual_for_depth(d))
1120 >                        add_window_modes(p, window_modes, d);
1121 >
1122          if (has_vidmode) {
1123                  if (has_mode(640, 480))
1124 <                        add_mode(p, screen_modes, 1, mode, APPLE_640x480, DIS_SCREEN);
1124 >                        add_mode(p, screen_modes, 1, default_mode, APPLE_640x480, DIS_SCREEN);
1125                  if (has_mode(800, 600))
1126 <                        add_mode(p, screen_modes, 2, mode, APPLE_800x600, DIS_SCREEN);
1126 >                        add_mode(p, screen_modes, 2, default_mode, APPLE_800x600, DIS_SCREEN);
1127                  if (has_mode(1024, 768))
1128 <                        add_mode(p, screen_modes, 4, mode, APPLE_1024x768, DIS_SCREEN);
1128 >                        add_mode(p, screen_modes, 4, default_mode, APPLE_1024x768, DIS_SCREEN);
1129 >                if (has_mode(1152, 768))
1130 >                        add_mode(p, screen_modes, 64, default_mode, APPLE_1152x768, DIS_SCREEN);
1131                  if (has_mode(1152, 900))
1132 <                        add_mode(p, screen_modes, 8, mode, APPLE_1152x900, DIS_SCREEN);
1132 >                        add_mode(p, screen_modes, 8, default_mode, APPLE_1152x900, DIS_SCREEN);
1133                  if (has_mode(1280, 1024))
1134 <                        add_mode(p, screen_modes, 16, mode, APPLE_1280x1024, DIS_SCREEN);
1134 >                        add_mode(p, screen_modes, 16, default_mode, APPLE_1280x1024, DIS_SCREEN);
1135                  if (has_mode(1600, 1200))
1136 <                        add_mode(p, screen_modes, 32, mode, APPLE_1600x1200, DIS_SCREEN);
1136 >                        add_mode(p, screen_modes, 32, default_mode, APPLE_1600x1200, DIS_SCREEN);
1137          } else if (screen_modes) {
1138                  int xsize = DisplayWidth(x_display, screen);
1139                  int ysize = DisplayHeight(x_display, screen);
1140 <                int apple_id;
742 <                if (xsize < 800)
743 <                        apple_id = APPLE_640x480;
744 <                else if (xsize < 1024)
745 <                        apple_id = APPLE_800x600;
746 <                else if (xsize < 1152)
747 <                        apple_id = APPLE_1024x768;
748 <                else if (xsize < 1280)
749 <                        apple_id = APPLE_1152x900;
750 <                else if (xsize < 1600)
751 <                        apple_id = APPLE_1280x1024;
752 <                else
753 <                        apple_id = APPLE_1600x1200;
1140 >                int apple_id = find_apple_resolution(xsize, ysize);
1141                  p->viType = DIS_SCREEN;
1142                  p->viRowBytes = 0;
1143                  p->viXsize = xsize;
1144                  p->viYsize = ysize;
1145 <                p->viAppleMode = mode;
1145 >                p->viAppleMode = default_mode;
1146                  p->viAppleID = apple_id;
1147                  p++;
1148          }
# Line 765 | Line 1152 | bool VideoInit(void)
1152          p->viAppleMode = 0;
1153          p->viAppleID = 0;
1154  
1155 < #ifdef ENABLE_XF86_DGA
1155 >        // Find default mode (window 640x480)
1156 >        cur_mode = -1;
1157          if (has_dga && screen_modes) {
1158 <                int v_bank, v_size;
1159 <                XF86DGAGetVideo(x_display, screen, &dga_screen_base, &dga_fb_width, &v_bank, &v_size);
1160 <                D(bug("DGA screen_base %p, v_width %d\n", dga_screen_base, dga_fb_width));
1158 >                int screen_width = DisplayWidth(x_display, screen);
1159 >                int screen_height = DisplayHeight(x_display, screen);
1160 >                int apple_id = find_apple_resolution(screen_width, screen_height);
1161 >                if (apple_id != -1)
1162 >                        cur_mode = find_mode(default_mode, apple_id, DIS_SCREEN);
1163 >        }
1164 >        if (cur_mode == -1) {
1165 >                // pick up first windowed mode available
1166 >                for (VideoInfo *p = VModes; p->viType != DIS_INVALID; p++) {
1167 >                        if (p->viType == DIS_WINDOW && p->viAppleMode == default_mode) {
1168 >                                cur_mode = p - VModes;
1169 >                                break;
1170 >                        }
1171 >                }
1172 >        }
1173 >        if (cur_mode == -1)
1174 >                cur_mode = find_mode(default_mode, APPLE_W_640x480, DIS_WINDOW);
1175 >        assert(cur_mode != -1);
1176 >
1177 > #if DEBUG
1178 >        D(bug("Available video modes:\n"));
1179 >        for (p = VModes; p->viType != DIS_INVALID; p++) {
1180 >                int bits = depth_of_video_mode(p->viAppleMode);
1181 >                D(bug(" %dx%d (ID %02x), %d colors\n", p->viXsize, p->viYsize, p->viAppleID, 1 << bits));
1182          }
1183   #endif
1184  
# Line 784 | Line 1193 | bool VideoInit(void)
1193  
1194          // Start periodic thread
1195          XSync(x_display, false);
1196 <        redraw_thread_active = (pthread_create(&redraw_thread, NULL, redraw_func, NULL) == 0);
1196 >        Set_pthread_attr(&redraw_thread_attr, 0);
1197 >        redraw_thread_active = (pthread_create(&redraw_thread, &redraw_thread_attr, redraw_func, NULL) == 0);
1198          D(bug("Redraw thread installed (%ld)\n", redraw_thread));
1199          return true;
1200   }
# Line 816 | Line 1226 | void VideoExit(void)
1226                  close_display();
1227                  XFlush(x_display);
1228                  XSync(x_display, false);
819                if (depth == 8) {
820                        XFreeColormap(x_display, cmap[0]);
821                        XFreeColormap(x_display, cmap[1]);
822                }
1229          }
1230   }
1231  
# Line 883 | Line 1289 | static void resume_emul(void)
1289          // Reopen full screen display
1290          XGrabKeyboard(x_display, rootwin, 1, GrabModeAsync, GrabModeAsync, CurrentTime);
1291          XGrabPointer(x_display, rootwin, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
1292 + #ifdef ENABLE_XF86_DGA
1293          XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse);
1294          XF86DGASetViewPort(x_display, screen, 0, 0);
1295 + #endif
1296          XSync(x_display, false);
1297  
1298          // the_buffer already contains the data to restore. i.e. since a temporary
# Line 1078 | Line 1486 | static int kc_decode(KeySym ks)
1486          return -1;
1487   }
1488  
1489 < static int event2keycode(XKeyEvent *ev)
1489 > static int event2keycode(XKeyEvent &ev)
1490   {
1491          KeySym ks;
1492          int as;
1493          int i = 0;
1494  
1495          do {
1496 <                ks = XLookupKeysym(ev, i++);
1496 >                ks = XLookupKeysym(&ev, i++);
1497                  as = kc_decode(ks);
1498                  if (as != -1)
1499                          return as;
# Line 1100 | Line 1508 | static void handle_events(void)
1508          for (;;) {
1509                  XEvent event;
1510  
1511 <                if (!XCheckMaskEvent(x_display, eventmask, &event))
1511 >                XDisplayLock();
1512 >                if (!XCheckMaskEvent(x_display, eventmask, &event)) {
1513 >                        // Handle clipboard events
1514 >                        if (XCheckTypedEvent(x_display, SelectionRequest, &event))
1515 >                                ClipboardSelectionRequest(&event.xselectionrequest);
1516 >                        else if (XCheckTypedEvent(x_display, SelectionClear, &event))
1517 >                                ClipboardSelectionClear(&event.xselectionclear);
1518 >
1519 >                        // Window "close" widget clicked
1520 >                        else if (XCheckTypedEvent(x_display, ClientMessage, &event)) {
1521 >                                if (event.xclient.format == 32 && event.xclient.data.l[0] == WM_DELETE_WINDOW) {
1522 >                                        ADBKeyDown(0x7f);       // Power key
1523 >                                        ADBKeyUp(0x7f);
1524 >                                }
1525 >                        }
1526 >
1527 >                        XDisplayUnlock();
1528                          break;
1529 +                }
1530 +                XDisplayUnlock();
1531  
1532                  switch (event.type) {
1533                          // Mouse button
# Line 1109 | Line 1535 | static void handle_events(void)
1535                                  unsigned int button = ((XButtonEvent *)&event)->button;
1536                                  if (button < 4)
1537                                          ADBMouseDown(button - 1);
1538 +                                else if (button < 6) {  // Wheel mouse
1539 +                                        if (mouse_wheel_mode == 0) {
1540 +                                                int key = (button == 5) ? 0x79 : 0x74;  // Page up/down
1541 +                                                ADBKeyDown(key);
1542 +                                                ADBKeyUp(key);
1543 +                                        } else {
1544 +                                                int key = (button == 5) ? 0x3d : 0x3e;  // Cursor up/down
1545 +                                                for(int i=0; i<mouse_wheel_lines; i++) {
1546 +                                                        ADBKeyDown(key);
1547 +                                                        ADBKeyUp(key);
1548 +                                                }
1549 +                                        }
1550 +                                }
1551                                  break;
1552                          }
1553                          case ButtonRelease: {
# Line 1118 | Line 1557 | static void handle_events(void)
1557                                  break;
1558                          }
1559  
1560 <                        // Mouse moved
1560 >                        // Mouse entered window
1561                          case EnterNotify:
1562 <                                ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y);
1562 >                                if (event.xcrossing.mode != NotifyGrab && event.xcrossing.mode != NotifyUngrab)
1563 >                                        ADBMouseMoved(event.xmotion.x, event.xmotion.y);
1564                                  break;
1565 +
1566 +                        // Mouse moved
1567                          case MotionNotify:
1568 <                                ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y);
1568 >                                ADBMouseMoved(event.xmotion.x, event.xmotion.y);
1569                                  break;
1570  
1571                          // Keyboard
1572                          case KeyPress: {
1573 <                                int code;
1574 <                                if ((code = event2keycode((XKeyEvent *)&event)) != -1) {
1573 >                                int code = event2keycode(event.xkey);
1574 >                                if (use_keycodes && code != -1)
1575 >                                        code = keycode_table[event.xkey.keycode & 0xff];
1576 >                                if (code != -1) {
1577                                          if (!emul_suspended) {
1578                                                  ADBKeyDown(code);
1579                                                  if (code == 0x36)
# Line 1142 | Line 1586 | static void handle_events(void)
1586                                  break;
1587                          }
1588                          case KeyRelease: {
1589 <                                int code;
1590 <                                if ((code = event2keycode((XKeyEvent *)&event)) != -1) {
1589 >                                int code = event2keycode(event.xkey);
1590 >                                if (use_keycodes && code != 1)
1591 >                                        code = keycode_table[event.xkey.keycode & 0xff];
1592 >                                if (code != -1) {
1593                                          ADBKeyUp(code);
1594                                          if (code == 0x36)
1595                                                  ctrl_down = false;
# Line 1186 | Line 1632 | void VideoVBL(void)
1632   *  Install graphics acceleration
1633   */
1634  
1635 < #if 0
1636 < // Rectangle blitting
1637 < static void accl_bitblt(accl_params *p)
1635 > // Rectangle inversion
1636 > template< int bpp >
1637 > static inline void do_invrect(uint8 *dest, uint32 length)
1638   {
1639 <        D(bug("accl_bitblt\n"));
1639 > #define INVERT_1(PTR, OFS) ((uint8  *)(PTR))[OFS] = ~((uint8  *)(PTR))[OFS]
1640 > #define INVERT_2(PTR, OFS) ((uint16 *)(PTR))[OFS] = ~((uint16 *)(PTR))[OFS]
1641 > #define INVERT_4(PTR, OFS) ((uint32 *)(PTR))[OFS] = ~((uint32 *)(PTR))[OFS]
1642 > #define INVERT_8(PTR, OFS) ((uint64 *)(PTR))[OFS] = ~((uint64 *)(PTR))[OFS]
1643  
1644 <        // Get blitting parameters
1645 <        int16 src_X = p->src_rect[1] - p->src_bounds[1];
1646 <        int16 src_Y = p->src_rect[0] - p->src_bounds[0];
1647 <        int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
1648 <        int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
1649 <        int16 width = p->dest_rect[3] - p->dest_rect[1] - 1;
1201 <        int16 height = p->dest_rect[2] - p->dest_rect[0] - 1;
1202 <        D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y));
1203 <        D(bug(" width %d, height %d\n", width, height));
1644 > #ifndef UNALIGNED_PROFITABLE
1645 >        // Align on 16-bit boundaries
1646 >        if (bpp < 16 && (((uintptr)dest) & 1)) {
1647 >                INVERT_1(dest, 0);
1648 >                dest += 1; length -= 1;
1649 >        }
1650  
1651 <        // And perform the blit
1652 <        bitblt_hook(src_X, src_Y, dest_X, dest_Y, width, height);
1653 < }
1651 >        // Align on 32-bit boundaries
1652 >        if (bpp < 32 && (((uintptr)dest) & 2)) {
1653 >                INVERT_2(dest, 0);
1654 >                dest += 2; length -= 2;
1655 >        }
1656 > #endif
1657  
1658 < static bool accl_bitblt_hook(accl_params *p)
1659 < {
1660 <        D(bug("accl_draw_hook %p\n", p));
1658 >        // Invert 8-byte words
1659 >        if (length >= 8) {
1660 >                const int r = (length / 8) % 8;
1661 >                dest += r * 8;
1662  
1663 <        // Check if we can accelerate this bitblt
1664 <        if (p->src_base_addr == screen_base && p->dest_base_addr == screen_base &&
1665 <                display_type == DIS_SCREEN && bitblt_hook != NULL &&
1666 <                ((uint32 *)p)[0x18 >> 2] + ((uint32 *)p)[0x128 >> 2] == 0 &&
1667 <                ((uint32 *)p)[0x130 >> 2] == 0 &&
1668 <                p->transfer_mode == 0 &&
1669 <                p->src_row_bytes > 0 && ((uint32 *)p)[0x15c >> 2] > 0) {
1663 >                int n = ((length / 8) + 7) / 8;
1664 >                switch (r) {
1665 >                case 0: do {
1666 >                                dest += 64;
1667 >                                INVERT_8(dest, -8);
1668 >                case 7: INVERT_8(dest, -7);
1669 >                case 6: INVERT_8(dest, -6);
1670 >                case 5: INVERT_8(dest, -5);
1671 >                case 4: INVERT_8(dest, -4);
1672 >                case 3: INVERT_8(dest, -3);
1673 >                case 2: INVERT_8(dest, -2);
1674 >                case 1: INVERT_8(dest, -1);
1675 >                                } while (--n > 0);
1676 >                }
1677 >        }
1678  
1679 <                // Yes, set function pointer
1680 <                p->draw_proc = accl_bitblt;
1681 <                return true;
1679 >        // 32-bit cell to invert?
1680 >        if (length & 4) {
1681 >                INVERT_4(dest, 0);
1682 >                if (bpp <= 16)
1683 >                        dest += 4;
1684          }
1685 <        return false;
1685 >
1686 >        // 16-bit cell to invert?
1687 >        if (bpp <= 16 && (length & 2)) {
1688 >                INVERT_2(dest, 0);
1689 >                if (bpp <= 8)
1690 >                        dest += 2;
1691 >        }
1692 >
1693 >        // 8-bit cell to invert?
1694 >        if (bpp <= 8 && (length & 1))
1695 >                INVERT_1(dest, 0);
1696 >
1697 > #undef INVERT_1
1698 > #undef INVERT_2
1699 > #undef INVERT_4
1700 > #undef INVERT_8
1701   }
1702  
1703 < // Rectangle filling/inversion
1229 < static void accl_fillrect8(accl_params *p)
1703 > void NQD_invrect(uint32 p)
1704   {
1705 <        D(bug("accl_fillrect8\n"));
1705 >        D(bug("accl_invrect %08x\n", p));
1706  
1707 <        // Get filling parameters
1708 <        int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
1709 <        int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
1710 <        int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1;
1711 <        int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1;
1238 <        uint8 color = p->pen_mode == 8 ? p->fore_pen : p->back_pen;
1707 >        // Get inversion parameters
1708 >        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1709 >        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1710 >        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1711 >        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1712          D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1713 <        D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max));
1713 >        D(bug(" width %d, height %d, bytes_per_row %d\n", width, height, (int32)ReadMacInt32(p + acclDestRowBytes)));
1714  
1715 <        // And perform the fill
1716 <        fillrect8_hook(dest_X, dest_Y, dest_X_max, dest_Y_max, color);
1715 >        //!!?? pen_mode == 14
1716 >
1717 >        // And perform the inversion
1718 >        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1719 >        const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1720 >        uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1721 >        width *= bpp;
1722 >        switch (bpp) {
1723 >        case 1:
1724 >                for (int i = 0; i < height; i++) {
1725 >                        do_invrect<8>(dest, width);
1726 >                        dest += dest_row_bytes;
1727 >                }
1728 >                break;
1729 >        case 2:
1730 >                for (int i = 0; i < height; i++) {
1731 >                        do_invrect<16>(dest, width);
1732 >                        dest += dest_row_bytes;
1733 >                }
1734 >                break;
1735 >        case 4:
1736 >                for (int i = 0; i < height; i++) {
1737 >                        do_invrect<32>(dest, width);
1738 >                        dest += dest_row_bytes;
1739 >                }
1740 >                break;
1741 >        }
1742   }
1743  
1744 < static void accl_fillrect32(accl_params *p)
1744 > // Rectangle filling
1745 > template< int bpp >
1746 > static inline void do_fillrect(uint8 *dest, uint32 color, uint32 length)
1747   {
1748 <        D(bug("accl_fillrect32\n"));
1748 > #define FILL_1(PTR, OFS, VAL) ((uint8  *)(PTR))[OFS] = (VAL)
1749 > #define FILL_2(PTR, OFS, VAL) ((uint16 *)(PTR))[OFS] = (VAL)
1750 > #define FILL_4(PTR, OFS, VAL) ((uint32 *)(PTR))[OFS] = (VAL)
1751 > #define FILL_8(PTR, OFS, VAL) ((uint64 *)(PTR))[OFS] = (VAL)
1752  
1753 <        // Get filling parameters
1754 <        int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
1755 <        int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
1756 <        int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1;
1757 <        int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1;
1758 <        uint32 color = p->pen_mode == 8 ? p->fore_pen : p->back_pen;
1256 <        D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1257 <        D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max));
1753 > #ifndef UNALIGNED_PROFITABLE
1754 >        // Align on 16-bit boundaries
1755 >        if (bpp < 16 && (((uintptr)dest) & 1)) {
1756 >                FILL_1(dest, 0, color);
1757 >                dest += 1; length -= 1;
1758 >        }
1759  
1760 <        // And perform the fill
1761 <        fillrect32_hook(dest_X, dest_Y, dest_X_max, dest_Y_max, color);
1760 >        // Align on 32-bit boundaries
1761 >        if (bpp < 32 && (((uintptr)dest) & 2)) {
1762 >                FILL_2(dest, 0, color);
1763 >                dest += 2; length -= 2;
1764 >        }
1765 > #endif
1766 >
1767 >        // Fill 8-byte words
1768 >        if (length >= 8) {
1769 >                const uint64 c = (((uint64)color) << 32) | color;
1770 >                const int r = (length / 8) % 8;
1771 >                dest += r * 8;
1772 >
1773 >                int n = ((length / 8) + 7) / 8;
1774 >                switch (r) {
1775 >                case 0: do {
1776 >                                dest += 64;
1777 >                                FILL_8(dest, -8, c);
1778 >                case 7: FILL_8(dest, -7, c);
1779 >                case 6: FILL_8(dest, -6, c);
1780 >                case 5: FILL_8(dest, -5, c);
1781 >                case 4: FILL_8(dest, -4, c);
1782 >                case 3: FILL_8(dest, -3, c);
1783 >                case 2: FILL_8(dest, -2, c);
1784 >                case 1: FILL_8(dest, -1, c);
1785 >                                } while (--n > 0);
1786 >                }
1787 >        }
1788 >
1789 >        // 32-bit cell to fill?
1790 >        if (length & 4) {
1791 >                FILL_4(dest, 0, color);
1792 >                if (bpp <= 16)
1793 >                        dest += 4;
1794 >        }
1795 >
1796 >        // 16-bit cell to fill?
1797 >        if (bpp <= 16 && (length & 2)) {
1798 >                FILL_2(dest, 0, color);
1799 >                if (bpp <= 8)
1800 >                        dest += 2;
1801 >        }
1802 >
1803 >        // 8-bit cell to fill?
1804 >        if (bpp <= 8 && (length & 1))
1805 >                FILL_1(dest, 0, color);
1806 >
1807 > #undef FILL_1
1808 > #undef FILL_2
1809 > #undef FILL_4
1810 > #undef FILL_8
1811   }
1812  
1813 < static void accl_invrect(accl_params *p)
1813 > void NQD_fillrect(uint32 p)
1814   {
1815 <        D(bug("accl_invrect\n"));
1815 >        D(bug("accl_fillrect %08x\n", p));
1816  
1817 <        // Get inversion parameters
1818 <        int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
1819 <        int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
1820 <        int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1;
1821 <        int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1;
1817 >        // Get filling parameters
1818 >        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1819 >        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1820 >        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1821 >        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1822 >        uint32 color = htonl(ReadMacInt32(p + acclPenMode) == 8 ? ReadMacInt32(p + acclForePen) : ReadMacInt32(p + acclBackPen));
1823          D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1824 <        D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max));
1825 <
1275 <        //!!?? pen_mode == 14
1824 >        D(bug(" width %d, height %d\n", width, height));
1825 >        D(bug(" bytes_per_row %d color %08x\n", (int32)ReadMacInt32(p + acclDestRowBytes), color));
1826  
1827 <        // And perform the inversion
1828 <        invrect_hook(dest_X, dest_Y, dest_X_max, dest_Y_max);
1827 >        // And perform the fill
1828 >        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1829 >        const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1830 >        uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1831 >        width *= bpp;
1832 >        switch (bpp) {
1833 >        case 1:
1834 >                for (int i = 0; i < height; i++) {
1835 >                        memset(dest, color, width);
1836 >                        dest += dest_row_bytes;
1837 >                }
1838 >                break;
1839 >        case 2:
1840 >                for (int i = 0; i < height; i++) {
1841 >                        do_fillrect<16>(dest, color, width);
1842 >                        dest += dest_row_bytes;
1843 >                }
1844 >                break;
1845 >        case 4:
1846 >                for (int i = 0; i < height; i++) {
1847 >                        do_fillrect<32>(dest, color, width);
1848 >                        dest += dest_row_bytes;
1849 >                }
1850 >                break;
1851 >        }
1852   }
1853  
1854 < static bool accl_fillrect_hook(accl_params *p)
1854 > bool NQD_fillrect_hook(uint32 p)
1855   {
1856 <        D(bug("accl_fillrect_hook %p\n", p));
1856 >        D(bug("accl_fillrect_hook %08x\n", p));
1857  
1858          // Check if we can accelerate this fillrect
1859 <        if (p->dest_base_addr == screen_base && ((uint32 *)p)[0x284 >> 2] != 0 && display_type == DIS_SCREEN) {
1860 <                if (p->transfer_mode == 8) {
1859 >        if (ReadMacInt32(p + 0x284) != 0 && ReadMacInt32(p + acclDestPixelSize) >= 8) {
1860 >                const int transfer_mode = ReadMacInt32(p + acclTransferMode);
1861 >                if (transfer_mode == 8) {
1862                          // Fill
1863 <                        if (p->dest_pixel_size == 8 && fillrect8_hook != NULL) {
1864 <                                p->draw_proc = accl_fillrect8;
1865 <                                return true;
1866 <                        } else if (p->dest_pixel_size == 32 && fillrect32_hook != NULL) {
1293 <                                p->draw_proc = accl_fillrect32;
1294 <                                return true;
1295 <                        }
1296 <                } else if (p->transfer_mode == 10 && invrect_hook != NULL) {
1863 >                        WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_FILLRECT));
1864 >                        return true;
1865 >                }
1866 >                else if (transfer_mode == 10) {
1867                          // Invert
1868 <                        p->draw_proc = accl_invrect;
1868 >                        WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_INVRECT));
1869                          return true;
1870                  }
1871          }
1872          return false;
1873   }
1874  
1875 + // Rectangle blitting
1876 + // TODO: optimize for VOSF and target pixmap == screen
1877 + void NQD_bitblt(uint32 p)
1878 + {
1879 +        D(bug("accl_bitblt %08x\n", p));
1880 +
1881 +        // Get blitting parameters
1882 +        int16 src_X  = (int16)ReadMacInt16(p + acclSrcRect + 2) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 2);
1883 +        int16 src_Y  = (int16)ReadMacInt16(p + acclSrcRect + 0) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 0);
1884 +        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1885 +        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1886 +        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1887 +        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1888 +        D(bug(" src addr %08x, dest addr %08x\n", ReadMacInt32(p + acclSrcBaseAddr), ReadMacInt32(p + acclDestBaseAddr)));
1889 +        D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y));
1890 +        D(bug(" width %d, height %d\n", width, height));
1891 +
1892 +        // And perform the blit
1893 +        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclSrcPixelSize));
1894 +        width *= bpp;
1895 +        if ((int32)ReadMacInt32(p + acclSrcRowBytes) > 0) {
1896 +                const int src_row_bytes = (int32)ReadMacInt32(p + acclSrcRowBytes);
1897 +                const int dst_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1898 +                uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + (src_Y * src_row_bytes) + (src_X * bpp));
1899 +                uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dst_row_bytes) + (dest_X * bpp));
1900 +                for (int i = 0; i < height; i++) {
1901 +                        memmove(dst, src, width);
1902 +                        src += src_row_bytes;
1903 +                        dst += dst_row_bytes;
1904 +                }
1905 +        }
1906 +        else {
1907 +                const int src_row_bytes = -(int32)ReadMacInt32(p + acclSrcRowBytes);
1908 +                const int dst_row_bytes = -(int32)ReadMacInt32(p + acclDestRowBytes);
1909 +                uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + ((src_Y + height - 1) * src_row_bytes) + (src_X * bpp));
1910 +                uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + ((dest_Y + height - 1) * dst_row_bytes) + (dest_X * bpp));
1911 +                for (int i = height - 1; i >= 0; i--) {
1912 +                        memmove(dst, src, width);
1913 +                        src -= src_row_bytes;
1914 +                        dst -= dst_row_bytes;
1915 +                }
1916 +        }
1917 + }
1918 +
1919 + /*
1920 +  BitBlt transfer modes:
1921 +  0 : srcCopy
1922 +  1 : srcOr
1923 +  2 : srcXor
1924 +  3 : srcBic
1925 +  4 : notSrcCopy
1926 +  5 : notSrcOr
1927 +  6 : notSrcXor
1928 +  7 : notSrcBic
1929 +  32 : blend
1930 +  33 : addPin
1931 +  34 : addOver
1932 +  35 : subPin
1933 +  36 : transparent
1934 +  37 : adMax
1935 +  38 : subOver
1936 +  39 : adMin
1937 +  50 : hilite
1938 + */
1939 +
1940 + bool NQD_bitblt_hook(uint32 p)
1941 + {
1942 +        D(bug("accl_draw_hook %08x\n", p));
1943 +
1944 +        // Check if we can accelerate this bitblt
1945 +        if (ReadMacInt32(p + 0x018) + ReadMacInt32(p + 0x128) == 0 &&
1946 +                ReadMacInt32(p + 0x130) == 0 &&
1947 +                ReadMacInt32(p + acclSrcPixelSize) >= 8 &&
1948 +                ReadMacInt32(p + acclSrcPixelSize) == ReadMacInt32(p + acclDestPixelSize) &&
1949 +                (ReadMacInt32(p + acclSrcRowBytes) ^ ReadMacInt32(p + acclDestRowBytes)) >= 0 && // same sign?
1950 +                ReadMacInt32(p + acclTransferMode) == 0 &&                                                                               // srcCopy?
1951 +                ReadMacInt32(p + 0x15c) > 0) {
1952 +
1953 +                // Yes, set function pointer
1954 +                WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_BITBLT));
1955 +                return true;
1956 +        }
1957 +        return false;
1958 + }
1959 +
1960   // Wait for graphics operation to finish
1961 < static bool accl_sync_hook(void *arg)
1961 > bool NQD_sync_hook(uint32 arg)
1962   {
1963 <        D(bug("accl_sync_hook %p\n", arg));
1309 <        if (sync_hook != NULL)
1310 <                sync_hook();
1963 >        D(bug("accl_sync_hook %08x\n", arg));
1964          return true;
1965   }
1966  
1314 static struct accl_hook_info bitblt_hook_info = {accl_bitblt_hook, accl_sync_hook, ACCL_BITBLT};
1315 static struct accl_hook_info fillrect_hook_info = {accl_fillrect_hook, accl_sync_hook, ACCL_FILLRECT};
1316 #endif
1317
1967   void VideoInstallAccel(void)
1968   {
1969          // Install acceleration hooks
1970          if (PrefsFindBool("gfxaccel")) {
1971                  D(bug("Video: Installing acceleration hooks\n"));
1972 < //!!    NQDMisc(6, &bitblt_hook_info);
1973 < //              NQDMisc(6, &fillrect_hook_info);
1972 >                uint32 base;
1973 >
1974 >                SheepVar bitblt_hook_info(sizeof(accl_hook_info));
1975 >                base = bitblt_hook_info.addr();
1976 >                WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK));
1977 >                WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
1978 >                WriteMacInt32(base + 8, ACCL_BITBLT);
1979 >                NQDMisc(6, bitblt_hook_info.ptr());
1980 >
1981 >                SheepVar fillrect_hook_info(sizeof(accl_hook_info));
1982 >                base = fillrect_hook_info.addr();
1983 >                WriteMacInt32(base + 0, NativeTVECT(NATIVE_FILLRECT_HOOK));
1984 >                WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
1985 >                WriteMacInt32(base + 8, ACCL_FILLRECT);
1986 >                NQDMisc(6, fillrect_hook_info.ptr());
1987          }
1988   }
1989  
# Line 1384 | Line 2046 | int16 video_mode_change(VidLocals *csSav
2046  
2047   void video_set_palette(void)
2048   {
2049 +        LOCK_PALETTE;
2050 +
2051 +        // Convert colors to XColor array
2052 +        int mode = get_current_mode();
2053 +        int num_in = palette_size(mode);
2054 +        int num_out = 256;
2055 +        bool stretch = false;
2056 +        if (IsDirectMode(mode)) {
2057 +                // If X is in 565 mode we have to stretch the gamma table from 32 to 64 entries
2058 +                num_out = vis->map_entries;
2059 +                stretch = true;
2060 +        }
2061 +        XColor *p = x_palette;
2062 +        for (int i=0; i<num_out; i++) {
2063 +                int c = (stretch ? (i * num_in) / num_out : i);
2064 +                p->red = mac_pal[c].red * 0x0101;
2065 +                p->green = mac_pal[c].green * 0x0101;
2066 +                p->blue = mac_pal[c].blue * 0x0101;
2067 +                p++;
2068 +        }
2069 +
2070 + #ifdef ENABLE_VOSF
2071 +        // Recalculate pixel color expansion map
2072 +        if (!IsDirectMode(mode) && xdepth > 8) {
2073 +                for (int i=0; i<256; i++) {
2074 +                        int c = i & (num_in-1); // If there are less than 256 colors, we repeat the first entries (this makes color expansion easier)
2075 +                        ExpandMap[i] = map_rgb(mac_pal[c].red, mac_pal[c].green, mac_pal[c].blue);
2076 +                }
2077 +
2078 +                // We have to redraw everything because the interpretation of pixel values changed
2079 +                LOCK_VOSF;
2080 +                PFLAG_SET_ALL;
2081 +                UNLOCK_VOSF;
2082 +                memset(the_buffer_copy, 0, VModes[cur_mode].viRowBytes * VModes[cur_mode].viYsize);
2083 +        }
2084 + #endif
2085 +
2086 +        // Tell redraw thread to change palette
2087          palette_changed = true;
2088 +
2089 +        UNLOCK_PALETTE;
2090 + }
2091 +
2092 +
2093 + /*
2094 + *  Can we set the MacOS cursor image into the window?
2095 + */
2096 +
2097 + bool video_can_change_cursor(void)
2098 + {
2099 +        return hw_mac_cursor_accl && (display_type != DIS_SCREEN);
2100   }
2101  
2102  
# Line 1511 | Line 2223 | static void update_display(void)
2223  
2224          // Refresh display
2225          if (high && wide) {
2226 +                XDisplayLock();
2227                  if (have_shm)
2228                          XShmPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high, 0);
2229                  else
2230                          XPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high);
2231 +                XDisplayUnlock();
2232 +        }
2233 + }
2234 +
2235 + const int VIDEO_REFRESH_HZ = 60;
2236 + const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
2237 +
2238 + static void handle_palette_changes(void)
2239 + {
2240 +        LOCK_PALETTE;
2241 +
2242 +        if (palette_changed && !emul_suspended) {
2243 +                palette_changed = false;
2244 +
2245 +                int mode = get_current_mode();
2246 +                if (color_class == PseudoColor || color_class == DirectColor) {
2247 +                        int num = vis->map_entries;
2248 +                        bool set_clut = true;
2249 +                        if (!IsDirectMode(mode) && color_class == DirectColor) {
2250 +                                if (display_type == DIS_WINDOW)
2251 +                                        set_clut = false; // Indexed mode on true color screen, don't set CLUT
2252 +                        }
2253 +
2254 +                        if (set_clut) {
2255 +                                XDisplayLock();
2256 +                                XStoreColors(x_display, cmap[0], x_palette, num);
2257 +                                XStoreColors(x_display, cmap[1], x_palette, num);
2258 +                                XSync(x_display, false);
2259 +                                XDisplayUnlock();
2260 +                        }
2261 +                }
2262 +
2263 + #ifdef ENABLE_XF86_DGA
2264 +                if (display_type == DIS_SCREEN) {
2265 +                        current_dga_cmap ^= 1;
2266 +                        if (!IsDirectMode(mode) && cmap[current_dga_cmap])
2267 +                                XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
2268 +                }
2269 + #endif
2270          }
2271 +
2272 +        UNLOCK_PALETTE;
2273   }
2274  
2275   static void *redraw_func(void *arg)
2276   {
2277 <        int tick_counter = 0;
1524 <        struct timespec req = {0, 16666667};
2277 >        int fd = ConnectionNumber(x_display);
2278  
2279 <        for (;;) {
2279 >        uint64 start = GetTicks_usec();
2280 >        int64 ticks = 0;
2281 >        uint64 next = GetTicks_usec() + VIDEO_REFRESH_DELAY;
2282  
2283 <                // Wait
1529 <                nanosleep(&req, NULL);
2283 >        for (;;) {
2284  
2285                  // Pause if requested (during video mode switches)
2286                  while (thread_stop_req)
2287                          thread_stop_ack = true;
2288  
2289 <                // Handle X11 events
2290 <                handle_events();
2289 >                int64 delay = next - GetTicks_usec();
2290 >                if (delay < -VIDEO_REFRESH_DELAY) {
2291 >
2292 >                        // We are lagging far behind, so we reset the delay mechanism
2293 >                        next = GetTicks_usec();
2294 >
2295 >                } else if (delay <= 0) {
2296 >
2297 >                        // Delay expired, refresh display
2298 >                        next += VIDEO_REFRESH_DELAY;
2299 >                        ticks++;
2300  
2301 <                // Quit DGA mode if requested
2302 <                if (quit_full_screen) {
2303 <                        quit_full_screen = false;
2304 <                        if (display_type == DIS_SCREEN) {
2301 >                        // Handle X11 events
2302 >                        handle_events();
2303 >
2304 >                        // Quit DGA mode if requested
2305 >                        if (quit_full_screen) {
2306 >                                quit_full_screen = false;
2307 >                                if (display_type == DIS_SCREEN) {
2308 >                                        XDisplayLock();
2309   #ifdef ENABLE_XF86_DGA
2310 <                                XF86DGADirectVideo(x_display, screen, 0);
2311 <                                XUngrabPointer(x_display, CurrentTime);
2312 <                                XUngrabKeyboard(x_display, CurrentTime);
2313 < #endif
2314 <                                XSync(x_display, false);
2315 <                                quit_full_screen_ack = true;
2316 <                                return NULL;
2310 >                                        XF86DGADirectVideo(x_display, screen, 0);
2311 >                                        XUngrabPointer(x_display, CurrentTime);
2312 >                                        XUngrabKeyboard(x_display, CurrentTime);
2313 >                                        XUnmapWindow(x_display, the_win);
2314 >                                        wait_unmapped(the_win);
2315 >                                        XDestroyWindow(x_display, the_win);
2316 > #endif
2317 >                                        XSync(x_display, false);
2318 >                                        XDisplayUnlock();
2319 >                                        quit_full_screen_ack = true;
2320 >                                        return NULL;
2321 >                                }
2322                          }
1551                }
2323  
2324 <                // Refresh display and set cursor image in window mode
2325 <                if (display_type == DIS_WINDOW) {
2326 <                        tick_counter++;
2327 <                        if (tick_counter >= frame_skip) {
2328 <                                tick_counter = 0;
2324 >                        // Refresh display and set cursor image in window mode
2325 >                        static int tick_counter = 0;
2326 >                        if (display_type == DIS_WINDOW) {
2327 >                                tick_counter++;
2328 >                                if (tick_counter >= frame_skip) {
2329 >                                        tick_counter = 0;
2330  
2331 <                                // Update display
2331 >                                        // Update display
2332   #ifdef ENABLE_VOSF
2333 <                                if (use_vosf) {
2334 <                                        if (mainBuffer.dirty) {
2335 <                                                LOCK_VOSF;
2336 <                                                update_display_window_vosf();
2337 <                                                UNLOCK_VOSF;
2338 <                                                XSync(x_display, false); // Let the server catch up
2333 >                                        if (use_vosf) {
2334 >                                                XDisplayLock();
2335 >                                                if (mainBuffer.dirty) {
2336 >                                                        LOCK_VOSF;
2337 >                                                        update_display_window_vosf();
2338 >                                                        UNLOCK_VOSF;
2339 >                                                        XSync(x_display, false); // Let the server catch up
2340 >                                                }
2341 >                                                XDisplayUnlock();
2342                                          }
2343 <                                }
1569 <                                else
2343 >                                        else
2344   #endif
2345 <                                        update_display();
2345 >                                                update_display();
2346  
2347 <                                // Set new cursor image if it was changed
2348 <                                if (cursor_changed) {
2349 <                                        cursor_changed = false;
2350 <                                        memcpy(cursor_image->data, MacCursor + 4, 32);
2351 <                                        memcpy(cursor_mask_image->data, MacCursor + 36, 32);
2352 <                                        XFreeCursor(x_display, mac_cursor);
2353 <                                        XPutImage(x_display, cursor_map, cursor_gc, cursor_image, 0, 0, 0, 0, 16, 16);
2354 <                                        XPutImage(x_display, cursor_mask_map, cursor_mask_gc, cursor_mask_image, 0, 0, 0, 0, 16, 16);
2355 <                                        mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, MacCursor[2], MacCursor[3]);
2356 <                                        XDefineCursor(x_display, the_win, mac_cursor);
2347 >                                        // Set new cursor image if it was changed
2348 >                                        if (hw_mac_cursor_accl && cursor_changed) {
2349 >                                                cursor_changed = false;
2350 >                                                memcpy(cursor_image->data, MacCursor + 4, 32);
2351 >                                                memcpy(cursor_mask_image->data, MacCursor + 36, 32);
2352 >                                                XDisplayLock();
2353 >                                                XFreeCursor(x_display, mac_cursor);
2354 >                                                XPutImage(x_display, cursor_map, cursor_gc, cursor_image, 0, 0, 0, 0, 16, 16);
2355 >                                                XPutImage(x_display, cursor_mask_map, cursor_mask_gc, cursor_mask_image, 0, 0, 0, 0, 16, 16);
2356 >                                                mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, MacCursor[2], MacCursor[3]);
2357 >                                                XDefineCursor(x_display, the_win, mac_cursor);
2358 >                                                XDisplayUnlock();
2359 >                                        }
2360                                  }
2361                          }
1585                }
2362   #ifdef ENABLE_VOSF
2363 <                else if (use_vosf) {
2364 <                        // Update display (VOSF variant)
2365 <                        static int tick_counter = 0;
2366 <                        if (++tick_counter >= frame_skip) {
2367 <                                tick_counter = 0;
2368 <                                if (mainBuffer.dirty) {
2369 <                                        LOCK_VOSF;
2370 <                                        update_display_dga_vosf();
2371 <                                        UNLOCK_VOSF;
2363 >                        else if (use_vosf) {
2364 >                                // Update display (VOSF variant)
2365 >                                if (++tick_counter >= frame_skip) {
2366 >                                        tick_counter = 0;
2367 >                                        if (mainBuffer.dirty) {
2368 >                                                LOCK_VOSF;
2369 >                                                update_display_dga_vosf();
2370 >                                                UNLOCK_VOSF;
2371 >                                        }
2372                                  }
2373                          }
1598                }
2374   #endif
2375  
2376 <                // Set new palette if it was changed
2377 <                if (palette_changed && !emul_suspended) {
2378 <                        palette_changed = false;
2379 <                        XColor c[256];
2380 <                        for (int i=0; i<256; i++) {
2381 <                                c[i].pixel = i;
2382 <                                c[i].red = mac_pal[i].red * 0x0101;
2383 <                                c[i].green = mac_pal[i].green * 0x0101;
2384 <                                c[i].blue = mac_pal[i].blue * 0x0101;
2385 <                                c[i].flags = DoRed | DoGreen | DoBlue;
2386 <                        }
2387 <                        if (depth == 8) {
2388 <                                XStoreColors(x_display, cmap[0], c, 256);
2389 <                                XStoreColors(x_display, cmap[1], c, 256);
1615 < #ifdef ENABLE_XF86_DGA
1616 <                                if (display_type == DIS_SCREEN) {
1617 <                                        current_dga_cmap ^= 1;
1618 <                                        XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1619 <                                }
1620 < #endif
1621 <                        }
2376 >                        // Set new palette if it was changed
2377 >                        handle_palette_changes();
2378 >
2379 >                } else {
2380 >
2381 >                        // No display refresh pending, check for X events
2382 >                        fd_set readfds;
2383 >                        FD_ZERO(&readfds);
2384 >                        FD_SET(fd, &readfds);
2385 >                        struct timeval timeout;
2386 >                        timeout.tv_sec = 0;
2387 >                        timeout.tv_usec = delay;
2388 >                        if (select(fd+1, &readfds, NULL, NULL, &timeout) > 0)
2389 >                                handle_events();
2390                  }
2391          }
2392          return NULL;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines