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.3 by gbeauche, 2003-05-22T22:12:05Z vs.
Revision 1.31 by gbeauche, 2004-06-30T22:03:34Z

# 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 34 | Line 46
46   #include "about_window.h"
47   #include "video.h"
48   #include "video_defs.h"
49 + #include "video_blit.h"
50  
51   #define DEBUG 0
52   #include "debug.h"
53  
54 < #ifdef ENABLE_XF86_DGA
55 < #include <X11/extensions/xf86dga.h>
54 > #ifndef NO_STD_NAMESPACE
55 > using std::sort;
56   #endif
57  
45 #ifdef ENABLE_XF86_VIDMODE
46 #include <X11/extensions/xf86vmode.h>
47 #endif
58  
59 + // Constants
60 + const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
61 + static const bool hw_mac_cursor_accl = true;    // Flag: Enable MacOS to X11 copy of cursor?
62  
63   // Global variables
64   static int32 frame_skip;
65 + static int16 mouse_wheel_mode;
66 + static int16 mouse_wheel_lines;
67   static bool redraw_thread_active = false;       // Flag: Redraw thread installed
68 + static pthread_attr_t redraw_thread_attr;       // Redraw thread attributes
69 + static volatile bool redraw_thread_cancel;      // Flag: Cancel Redraw thread
70   static pthread_t redraw_thread;                         // Redraw thread
71  
72 + static bool local_X11;                                          // Flag: X server running on local machine?
73   static volatile bool thread_stop_req = false;
74   static volatile bool thread_stop_ack = false;   // Acknowledge for thread_stop_req
75  
# Line 66 | Line 84 | static const bool use_vosf = false;                    //
84  
85   static bool palette_changed = false;            // Flag: Palette changed, redraw thread must update palette
86   static bool ctrl_down = false;                          // Flag: Ctrl key pressed
87 + static bool caps_on = false;                            // Flag: Caps Lock on
88   static bool quit_full_screen = false;           // Flag: DGA close requested from redraw thread
89   static volatile bool quit_full_screen_ack = false;      // Acknowledge for quit_full_screen
90   static bool emerg_quit = false;                         // Flag: Ctrl-Esc pressed, emergency quit requested from MacOS thread
# Line 73 | Line 92 | static bool emerg_quit = false;                                // Fl
92   static bool emul_suspended = false;                     // Flag: emulator suspended
93   static Window suspend_win;                                      // "Suspend" window
94   static void *fb_save = NULL;                            // Saved frame buffer for suspend
95 + static bool use_keycodes = false;                       // Flag: Use keycodes rather than keysyms
96 + static int keycode_table[256];                          // X keycode -> Mac keycode translation table
97  
98   // X11 variables
99   static int screen;                                                      // Screen number
100   static int xdepth;                                                      // Depth of X screen
101   static int depth;                                                       // Depth of Mac frame buffer
102   static Window rootwin, the_win;                         // Root window and our window
103 + static int num_depths = 0;                                      // Number of available X depths
104 + static int *avail_depths = NULL;                        // List of available X depths
105 + static VisualFormat visualFormat;
106   static XVisualInfo visualInfo;
107   static Visual *vis;
108 + static int color_class;
109 + static int rshift, rloss, gshift, gloss, bshift, bloss; // Pixel format of DirectColor/TrueColor modes
110   static Colormap cmap[2];                                        // Two colormaps (DGA) for 8-bit mode
111 + static XColor x_palette[256];                           // Color palette to be used as CLUT and gamma table
112 +
113   static XColor black, white;
114   static unsigned long black_pixel, white_pixel;
115   static int eventmask;
116 < static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask;
117 < static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
116 > static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask | StructureNotifyMask;
117 > static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask;
118  
119   // Variables for window mode
120   static GC the_gc;
# Line 103 | Line 131 | static uint8 *the_buffer_copy = NULL;          /
131   static uint32 the_buffer_size;                          // Size of allocated the_buffer
132  
133   // Variables for DGA mode
106 static char *dga_screen_base;
107 static int dga_fb_width;
134   static int current_dga_cmap;
135  
136   #ifdef ENABLE_XF86_VIDMODE
# Line 113 | Line 139 | static XF86VidModeModeInfo **x_video_mod
139   static int num_x_video_modes;
140   #endif
141  
142 + // Mutex to protect palette
143 + #ifdef HAVE_SPINLOCKS
144 + static spinlock_t x_palette_lock = SPIN_LOCK_UNLOCKED;
145 + #define LOCK_PALETTE spin_lock(&x_palette_lock)
146 + #define UNLOCK_PALETTE spin_unlock(&x_palette_lock)
147 + #elif defined(HAVE_PTHREADS)
148 + static pthread_mutex_t x_palette_lock = PTHREAD_MUTEX_INITIALIZER;
149 + #define LOCK_PALETTE pthread_mutex_lock(&x_palette_lock)
150 + #define UNLOCK_PALETTE pthread_mutex_unlock(&x_palette_lock)
151 + #else
152 + #define LOCK_PALETTE
153 + #define UNLOCK_PALETTE
154 + #endif
155 +
156  
157   // Prototypes
158   static void *redraw_func(void *arg);
159  
160  
161 < // From main_linux.cpp
161 > // From main_unix.cpp
162 > extern char *x_display_name;
163   extern Display *x_display;
164  
165   // From sys_unix.cpp
166   extern void SysMountFirstFloppy(void);
167  
168 + // From clip_unix.cpp
169 + extern void ClipboardSelectionClear(XSelectionClearEvent *);
170 + extern void ClipboardSelectionRequest(XSelectionRequestEvent *);
171 +
172  
173   // Video acceleration through SIGSEGV
174   #ifdef ENABLE_VOSF
# Line 132 | Line 177 | extern void SysMountFirstFloppy(void);
177  
178  
179   /*
180 + *  Utility functions
181 + */
182 +
183 + // Get current video mode
184 + static inline int get_current_mode(void)
185 + {
186 +        return VModes[cur_mode].viAppleMode;
187 + }
188 +
189 + // Find palette size for given color depth
190 + static int palette_size(int mode)
191 + {
192 +        switch (mode) {
193 +        case APPLE_1_BIT: return 2;
194 +        case APPLE_2_BIT: return 4;
195 +        case APPLE_4_BIT: return 16;
196 +        case APPLE_8_BIT: return 256;
197 +        case APPLE_16_BIT: return 32;
198 +        case APPLE_32_BIT: return 256;
199 +        default: return 0;
200 +        }
201 + }
202 +
203 + // Return bits per pixel for requested depth
204 + static inline int bytes_per_pixel(int depth)
205 + {
206 +        int bpp;
207 +        switch (depth) {
208 +        case 8:
209 +                bpp = 1;
210 +                break;
211 +        case 15: case 16:
212 +                bpp = 2;
213 +                break;
214 +        case 24: case 32:
215 +                bpp = 4;
216 +                break;
217 +        default:
218 +                abort();
219 +        }
220 +        return bpp;
221 + }
222 +
223 + // Map video_mode depth ID to numerical depth value
224 + static inline int depth_of_video_mode(int mode)
225 + {
226 +        int depth;
227 +        switch (mode) {
228 +        case APPLE_1_BIT:
229 +                depth = 1;
230 +                break;
231 +        case APPLE_2_BIT:
232 +                depth = 2;
233 +                break;
234 +        case APPLE_4_BIT:
235 +                depth = 4;
236 +                break;
237 +        case APPLE_8_BIT:
238 +                depth = 8;
239 +                break;
240 +        case APPLE_16_BIT:
241 +                depth = 16;
242 +                break;
243 +        case APPLE_32_BIT:
244 +                depth = 32;
245 +                break;
246 +        default:
247 +                abort();
248 +        }
249 +        return depth;
250 + }
251 +
252 + // Map RGB color to pixel value (this only works in TrueColor/DirectColor visuals)
253 + static inline uint32 map_rgb(uint8 red, uint8 green, uint8 blue)
254 + {
255 +        return ((red >> rloss) << rshift) | ((green >> gloss) << gshift) | ((blue >> bloss) << bshift);
256 + }
257 +
258 +
259 + // Do we have a visual for handling the specified Mac depth? If so, set the
260 + // global variables "xdepth", "visualInfo", "vis" and "color_class".
261 + static bool find_visual_for_depth(int depth)
262 + {
263 +        D(bug("have_visual_for_depth(%d)\n", depth_of_video_mode(depth)));
264 +
265 +        // 1-bit works always and uses default visual
266 +        if (depth == APPLE_1_BIT) {
267 +                vis = DefaultVisual(x_display, screen);
268 +                visualInfo.visualid = XVisualIDFromVisual(vis);
269 +                int num = 0;
270 +                XVisualInfo *vi = XGetVisualInfo(x_display, VisualIDMask, &visualInfo, &num);
271 +                visualInfo = vi[0];
272 +                XFree(vi);
273 +                xdepth = visualInfo.depth;
274 +                color_class = visualInfo.c_class;
275 +                D(bug(" found visual ID 0x%02x, depth %d\n", visualInfo.visualid, xdepth));
276 +                return true;
277 +        }
278 +
279 +        // Calculate minimum and maximum supported X depth
280 +        int min_depth = 1, max_depth = 32;
281 +        switch (depth) {
282 + #ifdef ENABLE_VOSF
283 +                case APPLE_2_BIT:
284 +                case APPLE_4_BIT:       // VOSF blitters can convert 2/4/8-bit -> 8/16/32-bit
285 +                case APPLE_8_BIT:
286 +                        min_depth = 8;
287 +                        max_depth = 32;
288 +                        break;
289 + #else
290 +                case APPLE_2_BIT:
291 +                case APPLE_4_BIT:       // 2/4-bit requires VOSF blitters
292 +                        return false;
293 +                case APPLE_8_BIT:       // 8-bit without VOSF requires an 8-bit visual
294 +                        min_depth = 8;
295 +                        max_depth = 8;
296 +                        break;
297 + #endif
298 +                case APPLE_16_BIT:      // 16-bit requires a 15/16-bit visual
299 +                        min_depth = 15;
300 +                        max_depth = 16;
301 +                        break;
302 +                case APPLE_32_BIT:      // 32-bit requires a 24/32-bit visual
303 +                        min_depth = 24;
304 +                        max_depth = 32;
305 +                        break;
306 +        }
307 +        D(bug(" minimum required X depth is %d, maximum supported X depth is %d\n", min_depth, max_depth));
308 +
309 +        // Try to find a visual for one of the color depths
310 +        bool visual_found = false;
311 +        for (int i=0; i<num_depths && !visual_found; i++) {
312 +
313 +                xdepth = avail_depths[i];
314 +                D(bug(" trying to find visual for depth %d\n", xdepth));
315 +                if (xdepth < min_depth || xdepth > max_depth)
316 +                        continue;
317 +
318 +                // Determine best color class for this depth
319 +                switch (xdepth) {
320 +                        case 1: // Try StaticGray or StaticColor
321 +                                if (XMatchVisualInfo(x_display, screen, xdepth, StaticGray, &visualInfo)
322 +                                 || XMatchVisualInfo(x_display, screen, xdepth, StaticColor, &visualInfo))
323 +                                        visual_found = true;
324 +                                break;
325 +                        case 8: // Need PseudoColor
326 +                                if (XMatchVisualInfo(x_display, screen, xdepth, PseudoColor, &visualInfo))
327 +                                        visual_found = true;
328 +                                break;
329 +                        case 15:
330 +                        case 16:
331 +                        case 24:
332 +                        case 32: // Try DirectColor first, as this will allow gamma correction
333 +                                if (XMatchVisualInfo(x_display, screen, xdepth, DirectColor, &visualInfo)
334 +                                 || XMatchVisualInfo(x_display, screen, xdepth, TrueColor, &visualInfo))
335 +                                        visual_found = true;
336 +                                break;
337 +                        default:
338 +                                D(bug("  not a supported depth\n"));
339 +                                break;
340 +                }
341 +        }
342 +        if (!visual_found)
343 +                return false;
344 +
345 +        // Visual was found
346 +        vis = visualInfo.visual;
347 +        color_class = visualInfo.c_class;
348 +        D(bug(" found visual ID 0x%02x, depth %d, class ", visualInfo.visualid, xdepth));
349 + #if DEBUG
350 +        switch (color_class) {
351 +                case StaticGray: D(bug("StaticGray\n")); break;
352 +                case GrayScale: D(bug("GrayScale\n")); break;
353 +                case StaticColor: D(bug("StaticColor\n")); break;
354 +                case PseudoColor: D(bug("PseudoColor\n")); break;
355 +                case TrueColor: D(bug("TrueColor\n")); break;
356 +                case DirectColor: D(bug("DirectColor\n")); break;
357 +        }
358 + #endif
359 +        return true;
360 + }
361 +
362 +
363 + /*
364   *  Open display (window or fullscreen)
365   */
366  
367 + // Set WM_DELETE_WINDOW protocol on window (preventing it from being destroyed by the WM when clicking on the "close" widget)
368 + static Atom WM_DELETE_WINDOW = (Atom)0;
369 + static void set_window_delete_protocol(Window w)
370 + {
371 +        WM_DELETE_WINDOW = XInternAtom(x_display, "WM_DELETE_WINDOW", false);
372 +        XSetWMProtocols(x_display, w, &WM_DELETE_WINDOW, 1);
373 + }
374 +
375 + // Wait until window is mapped/unmapped
376 + static void wait_mapped(Window w)
377 + {
378 +        XEvent e;
379 +        do {
380 +                XMaskEvent(x_display, StructureNotifyMask, &e);
381 +        } while ((e.type != MapNotify) || (e.xmap.event != w));
382 + }
383 +
384 + static void wait_unmapped(Window w)
385 + {
386 +        XEvent e;
387 +        do {
388 +                XMaskEvent(x_display, StructureNotifyMask, &e);
389 +        } while ((e.type != UnmapNotify) || (e.xmap.event != w));
390 + }
391 +
392   // Trap SHM errors
393   static bool shm_error = false;
394   static int (*old_error_handler)(Display *, XErrorEvent *);
# Line 157 | Line 411 | static bool open_window(int width, int h
411          // Set absolute mouse mode
412          ADBSetRelMouseMode(false);
413  
160        // Read frame skip prefs
161        frame_skip = PrefsFindInt32("frameskip");
162        if (frame_skip == 0)
163                frame_skip = 1;
164
414          // Create window
415          XSetWindowAttributes wattr;
416          wattr.event_mask = eventmask = win_eventmask;
417 <        wattr.background_pixel = black_pixel;
418 <        wattr.border_pixel = black_pixel;
417 >        wattr.background_pixel = (vis == DefaultVisual(x_display, screen) ? black_pixel : 0);
418 >        wattr.border_pixel = 0;
419          wattr.backing_store = NotUseful;
420 <
172 <        XSync(x_display, false);
420 >        wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]);
421          the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
422 <                InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore, &wattr);
423 <        XSync(x_display, false);
422 >                InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWBackingStore | CWColormap, &wattr);
423 >
424 >        // Set window name
425          XStoreName(x_display, the_win, GetString(STR_WINDOW_TITLE));
177        XMapRaised(x_display, the_win);
178        XSync(x_display, false);
426  
427 <        // Set colormap
428 <        if (depth == 8) {
182 <                XSetWindowColormap(x_display, the_win, cmap[0]);
183 <                XSetWMColormapWindows(x_display, the_win, &the_win, 1);
184 <        }
427 >        // Set delete protocol property
428 >        set_window_delete_protocol(the_win);
429  
430          // Make window unresizable
431          XSizeHints *hints;
# Line 195 | Line 439 | static bool open_window(int width, int h
439                  XFree((char *)hints);
440          }
441  
442 +        // Show window
443 +        XMapWindow(x_display, the_win);
444 +        wait_mapped(the_win);
445 +
446 +        // 1-bit mode is big-endian; if the X server is little-endian, we can't
447 +        // use SHM because that doesn't allow changing the image byte order
448 +        bool need_msb_image = (depth == 1 && XImageByteOrder(x_display) == LSBFirst);
449 +
450          // Try to create and attach SHM image
451          have_shm = false;
452 <        if (depth != 1 && XShmQueryExtension(x_display)) {
452 >        if (local_X11 && !need_msb_image && XShmQueryExtension(x_display)) {
453  
454                  // Create SHM image ("height + 2" for safety)
455 <                img = XShmCreateImage(x_display, vis, depth, depth == 1 ? XYBitmap : ZPixmap, 0, &shminfo, width, height);
456 <                shminfo.shmid = shmget(IPC_PRIVATE, (height + 2) * img->bytes_per_line, IPC_CREAT | 0777);
455 >                img = XShmCreateImage(x_display, vis, depth == 1 ? 1 : xdepth, depth == 1 ? XYBitmap : ZPixmap, 0, &shminfo, width, height);
456 >                shminfo.shmid = shmget(IPC_PRIVATE, (aligned_height + 2) * img->bytes_per_line, IPC_CREAT | 0777);
457 >                D(bug(" shm image created\n"));
458                  the_buffer_copy = (uint8 *)shmat(shminfo.shmid, 0, 0);
459                  shminfo.shmaddr = img->data = (char *)the_buffer_copy;
460                  shminfo.readOnly = False;
# Line 220 | Line 473 | static bool open_window(int width, int h
473                          have_shm = true;
474                          shmctl(shminfo.shmid, IPC_RMID, 0);
475                  }
476 +                D(bug(" shm image attached\n"));
477          }
478  
479          // Create normal X image if SHM doesn't work ("height + 2" for safety)
480          if (!have_shm) {
481 <                int bytes_per_row = aligned_width;
228 <                switch (depth) {
229 <                        case 1:
230 <                                bytes_per_row /= 8;
231 <                                break;
232 <                        case 15:
233 <                        case 16:
234 <                                bytes_per_row *= 2;
235 <                                break;
236 <                        case 24:
237 <                        case 32:
238 <                                bytes_per_row *= 4;
239 <                                break;
240 <                }
481 >                int bytes_per_row = depth == 1 ? aligned_width/8 : TrivialBytesPerRow(aligned_width, DepthModeForPixelDepth(xdepth));
482                  the_buffer_copy = (uint8 *)malloc((aligned_height + 2) * bytes_per_row);
483                  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);
484 +                D(bug(" X image created\n"));
485          }
486  
487          // 1-Bit mode is big-endian
488 <    if (depth == 1) {
488 >    if (need_msb_image) {
489          img->byte_order = MSBFirst;
490          img->bitmap_bit_order = MSBFirst;
491      }
# Line 265 | Line 507 | static bool open_window(int width, int h
507  
508          // Create GC
509          the_gc = XCreateGC(x_display, the_win, 0, 0);
510 <        XSetForeground(x_display, the_gc, black_pixel);
510 >        XSetState(x_display, the_gc, black_pixel, white_pixel, GXcopy, AllPlanes);
511  
512          // Create cursor
513 <        cursor_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 4, 16, 16, 16, 2);
514 <        cursor_image->byte_order = MSBFirst;
515 <        cursor_image->bitmap_bit_order = MSBFirst;
516 <        cursor_mask_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 36, 16, 16, 16, 2);
517 <        cursor_mask_image->byte_order = MSBFirst;
518 <        cursor_mask_image->bitmap_bit_order = MSBFirst;
519 <        cursor_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
520 <        cursor_mask_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
521 <        cursor_gc = XCreateGC(x_display, cursor_map, 0, 0);
522 <        cursor_mask_gc = XCreateGC(x_display, cursor_mask_map, 0, 0);
523 <        mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, 0, 0);
524 <        cursor_changed = false;
513 >        if (hw_mac_cursor_accl) {
514 >                cursor_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 4, 16, 16, 16, 2);
515 >                cursor_image->byte_order = MSBFirst;
516 >                cursor_image->bitmap_bit_order = MSBFirst;
517 >                cursor_mask_image = XCreateImage(x_display, vis, 1, XYPixmap, 0, (char *)MacCursor + 36, 16, 16, 16, 2);
518 >                cursor_mask_image->byte_order = MSBFirst;
519 >                cursor_mask_image->bitmap_bit_order = MSBFirst;
520 >                cursor_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
521 >                cursor_mask_map = XCreatePixmap(x_display, the_win, 16, 16, 1);
522 >                cursor_gc = XCreateGC(x_display, cursor_map, 0, 0);
523 >                cursor_mask_gc = XCreateGC(x_display, cursor_mask_map, 0, 0);
524 >                mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, 0, 0);
525 >                cursor_changed = false;
526 >        }
527 >
528 >        // Create no_cursor
529 >        else {
530 >                mac_cursor = XCreatePixmapCursor(x_display,
531 >                        XCreatePixmap(x_display, the_win, 1, 1, 1),
532 >                        XCreatePixmap(x_display, the_win, 1, 1, 1),
533 >                        &black, &white, 0, 0);
534 >                XDefineCursor(x_display, the_win, mac_cursor);
535 >        }
536  
537          // Init blitting routines
538          bool native_byte_order;
# Line 289 | Line 542 | static bool open_window(int width, int h
542          native_byte_order = (XImageByteOrder(x_display) == LSBFirst);
543   #endif
544   #ifdef ENABLE_VOSF
545 <        Screen_blitter_init(&visualInfo, native_byte_order, depth);
545 >        Screen_blitter_init(visualFormat, native_byte_order, depth);
546   #endif
547  
548          // Set bytes per row
296        VModes[cur_mode].viRowBytes = img->bytes_per_line;
549          XSync(x_display, false);
550          return true;
551   }
# Line 305 | Line 557 | static bool open_dga(int width, int heig
557          // Set relative mouse mode
558          ADBSetRelMouseMode(true);
559  
560 +        // Create window
561 +        XSetWindowAttributes wattr;
562 +        wattr.event_mask = eventmask = dga_eventmask;
563 +        wattr.override_redirect = True;
564 +        wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]);
565 +        the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
566 +                InputOutput, vis, CWEventMask | CWOverrideRedirect |
567 +                (color_class == DirectColor ? CWColormap : 0), &wattr);
568 +
569 +        // Show window
570 +        XMapRaised(x_display, the_win);
571 +        wait_mapped(the_win);
572 +
573   #ifdef ENABLE_XF86_VIDMODE
574          // Switch to best mode
575          if (has_vidmode) {
# Line 321 | Line 586 | static bool open_dga(int width, int heig
586   #endif
587  
588          // Establish direct screen connection
589 +        XMoveResizeWindow(x_display, the_win, 0, 0, width, height);
590 +        XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0);
591          XGrabKeyboard(x_display, rootwin, True, GrabModeAsync, GrabModeAsync, CurrentTime);
592          XGrabPointer(x_display, rootwin, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
593 +
594 +        int v_width, v_bank, v_size;
595 +        XF86DGAGetVideo(x_display, screen, (char **)&the_buffer, &v_width, &v_bank, &v_size);
596          XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse);
597          XF86DGASetViewPort(x_display, screen, 0, 0);
598          XF86DGASetVidPage(x_display, screen, 0);
599  
600          // Set colormap
601 <        if (depth == 8)
601 >        if (!IsDirectMode(get_current_mode())) {
602 >                XSetWindowColormap(x_display, the_win, cmap[current_dga_cmap = 0]);
603                  XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
333
334        // Set bytes per row
335        int bytes_per_row = (dga_fb_width + 7) & ~7;
336        switch (depth) {
337                case 15:
338                case 16:
339                        bytes_per_row *= 2;
340                        break;
341                case 24:
342                case 32:
343                        bytes_per_row *= 4;
344                        break;
604          }
605 +        XSync(x_display, false);
606  
607 +        // Init blitting routines
608 +        int bytes_per_row = TrivialBytesPerRow((v_width + 7) & ~7, DepthModeForPixelDepth(depth));
609   #if ENABLE_VOSF
610          bool native_byte_order;
611   #ifdef WORDS_BIGENDIAN
# Line 354 | Line 616 | static bool open_dga(int width, int heig
616   #if REAL_ADDRESSING || DIRECT_ADDRESSING
617          // Screen_blitter_init() returns TRUE if VOSF is mandatory
618          // i.e. the framebuffer update function is not Blit_Copy_Raw
619 <        use_vosf = Screen_blitter_init(&visualInfo, native_byte_order, depth);
619 >        use_vosf = Screen_blitter_init(visualFormat, native_byte_order, depth);
620          
621          if (use_vosf) {
622            // Allocate memory for frame buffer (SIZE is extended to page-boundary)
# Line 362 | Line 624 | static bool open_dga(int width, int heig
624            the_buffer_size = page_extend((height + 2) * bytes_per_row);
625            the_buffer_copy = (uint8 *)malloc(the_buffer_size);
626            the_buffer = (uint8 *)vm_acquire(the_buffer_size);
627 +          D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
628          }
629   #else
630          use_vosf = false;
368        the_buffer = dga_screen_base;
631   #endif
632   #endif
371        screen_base = (uint32)the_buffer;
633  
634 +        // Set frame buffer base
635 +        D(bug("the_buffer = %p, use_vosf = %d\n", the_buffer, use_vosf));
636 +        screen_base = (uint32)the_buffer;
637          VModes[cur_mode].viRowBytes = bytes_per_row;
374        XSync(x_display, false);
638          return true;
639   #else
640          ErrorAlert("SheepShaver has been compiled with DGA support disabled.");
# Line 381 | Line 644 | static bool open_dga(int width, int heig
644  
645   static bool open_display(void)
646   {
647 <        display_type = VModes[cur_mode].viType;
648 <        switch (VModes[cur_mode].viAppleMode) {
649 <                case APPLE_1_BIT:
650 <                        depth = 1;
651 <                        break;
652 <                case APPLE_2_BIT:
653 <                        depth = 2;
391 <                        break;
392 <                case APPLE_4_BIT:
393 <                        depth = 4;
394 <                        break;
395 <                case APPLE_8_BIT:
396 <                        depth = 8;
397 <                        break;
398 <                case APPLE_16_BIT:
399 <                        depth = xdepth == 15 ? 15 : 16;
400 <                        break;
401 <                case APPLE_32_BIT:
402 <                        depth = 32;
403 <                        break;
647 >        D(bug("open_display()\n"));
648 >        const VideoInfo &mode = VModes[cur_mode];
649 >
650 >        // Find best available X visual
651 >        if (!find_visual_for_depth(mode.viAppleMode)) {
652 >                ErrorAlert(GetString(STR_NO_XVISUAL_ERR));
653 >                return false;
654          }
655  
656 +        // Build up visualFormat structure
657 +        visualFormat.depth = visualInfo.depth;
658 +        visualFormat.Rmask = visualInfo.red_mask;
659 +        visualFormat.Gmask = visualInfo.green_mask;
660 +        visualFormat.Bmask = visualInfo.blue_mask;
661 +
662 +        // Create color maps
663 +        if (color_class == PseudoColor || color_class == DirectColor) {
664 +                cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
665 +                cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
666 +        } else {
667 +                cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocNone);
668 +                cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocNone);
669 +        }
670 +
671 +        // Find pixel format of direct modes
672 +        if (color_class == DirectColor || color_class == TrueColor) {
673 +                rshift = gshift = bshift = 0;
674 +                rloss = gloss = bloss = 8;
675 +                uint32 mask;
676 +                for (mask=vis->red_mask; !(mask&1); mask>>=1)
677 +                        ++rshift;
678 +                for (; mask&1; mask>>=1)
679 +                        --rloss;
680 +                for (mask=vis->green_mask; !(mask&1); mask>>=1)
681 +                        ++gshift;
682 +                for (; mask&1; mask>>=1)
683 +                        --gloss;
684 +                for (mask=vis->blue_mask; !(mask&1); mask>>=1)
685 +                        ++bshift;
686 +                for (; mask&1; mask>>=1)
687 +                        --bloss;
688 +        }
689 +
690 +        // Preset palette pixel values for CLUT or gamma table
691 +        if (color_class == DirectColor) {
692 +                int num = vis->map_entries;
693 +                for (int i=0; i<num; i++) {
694 +                        int c = (i * 256) / num;
695 +                        x_palette[i].pixel = map_rgb(c, c, c);
696 +                        x_palette[i].flags = DoRed | DoGreen | DoBlue;
697 +                }
698 +        } else if (color_class == PseudoColor) {
699 +                for (int i=0; i<256; i++) {
700 +                        x_palette[i].pixel = i;
701 +                        x_palette[i].flags = DoRed | DoGreen | DoBlue;
702 +                }
703 +        }
704 +
705 +        // Load gray ramp to color map
706 +        int num = (color_class == DirectColor ? vis->map_entries : 256);
707 +        for (int i=0; i<num; i++) {
708 +                int c = (i * 256) / num;
709 +                x_palette[i].red = c * 0x0101;
710 +                x_palette[i].green = c * 0x0101;
711 +                x_palette[i].blue = c * 0x0101;
712 +        }
713 +        if (color_class == PseudoColor || color_class == DirectColor) {
714 +                XStoreColors(x_display, cmap[0], x_palette, num);
715 +                XStoreColors(x_display, cmap[1], x_palette, num);
716 +        }
717 +
718 + #ifdef ENABLE_VOSF
719 +        // Load gray ramp to 8->16/32 expand map
720 +        if (!IsDirectMode(get_current_mode()) && xdepth > 8)
721 +                for (int i=0; i<256; i++)
722 +                        ExpandMap[i] = map_rgb(i, i, i);
723 + #endif
724 +
725 +        // Create display of requested type
726 +        display_type = mode.viType;
727 +        depth = depth_of_video_mode(mode.viAppleMode);
728 +
729          bool display_open = false;
730          if (display_type == DIS_SCREEN)
731                  display_open = open_dga(VModes[cur_mode].viXsize, VModes[cur_mode].viYsize);
# Line 450 | Line 773 | static void close_window(void)
773          if (the_gc)
774                  XFreeGC(x_display, the_gc);
775  
776 <        // Close window
777 <        XDestroyWindow(x_display, the_win);
776 >        XFlush(x_display);
777 >        XSync(x_display, false);
778   }
779  
780   // Close DGA mode
# Line 487 | Line 810 | static void close_display(void)
810          else if (display_type == DIS_WINDOW)
811                  close_window();
812  
813 +        // Close window
814 +        if (the_win) {
815 +                XUnmapWindow(x_display, the_win);
816 +                wait_unmapped(the_win);
817 +                XDestroyWindow(x_display, the_win);
818 +        }
819 +
820 +        // Free colormaps
821 +        if (cmap[0]) {
822 +                XFreeColormap(x_display, cmap[0]);
823 +                cmap[0] = 0;
824 +        }
825 +        if (cmap[1]) {
826 +                XFreeColormap(x_display, cmap[1]);
827 +                cmap[1] = 0;
828 +        }
829 +
830   #ifdef ENABLE_VOSF
831          if (use_vosf) {
832                  // Deinitialize VOSF
# Line 528 | Line 868 | static void close_display(void)
868   *  Initialization
869   */
870  
871 < static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, long apple_mode, long apple_id, int type)
871 > // Init keycode translation table
872 > static void keycode_init(void)
873 > {
874 >        bool use_kc = PrefsFindBool("keycodes");
875 >        if (use_kc) {
876 >
877 >                // Get keycode file path from preferences
878 >                const char *kc_path = PrefsFindString("keycodefile");
879 >
880 >                // Open keycode table
881 >                FILE *f = fopen(kc_path ? kc_path : KEYCODE_FILE_NAME, "r");
882 >                if (f == NULL) {
883 >                        char str[256];
884 >                        sprintf(str, GetString(STR_KEYCODE_FILE_WARN), kc_path ? kc_path : KEYCODE_FILE_NAME, strerror(errno));
885 >                        WarningAlert(str);
886 >                        return;
887 >                }
888 >
889 >                // Default translation table
890 >                for (int i=0; i<256; i++)
891 >                        keycode_table[i] = -1;
892 >
893 >                // Search for server vendor string, then read keycodes
894 >                const char *vendor = ServerVendor(x_display);
895 > #if (defined(__APPLE__) && defined(__MACH__))
896 >                // Force use of MacX mappings on MacOS X with Apple's X server
897 >                int dummy;
898 >                if (XQueryExtension(x_display, "Apple-DRI", &dummy, &dummy, &dummy))
899 >                        vendor = "MacX";
900 > #endif
901 >                bool vendor_found = false;
902 >                char line[256];
903 >                while (fgets(line, 255, f)) {
904 >                        // Read line
905 >                        int len = strlen(line);
906 >                        if (len == 0)
907 >                                continue;
908 >                        line[len-1] = 0;
909 >
910 >                        // Comments begin with "#" or ";"
911 >                        if (line[0] == '#' || line[0] == ';' || line[0] == 0)
912 >                                continue;
913 >
914 >                        if (vendor_found) {
915 >                                // Read keycode
916 >                                int x_code, mac_code;
917 >                                if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
918 >                                        keycode_table[x_code & 0xff] = mac_code;
919 >                                else
920 >                                        break;
921 >                        } else {
922 >                                // Search for vendor string
923 >                                if (strstr(vendor, line) == vendor)
924 >                                        vendor_found = true;
925 >                        }
926 >                }
927 >
928 >                // Keycode file completely read
929 >                fclose(f);
930 >                use_keycodes = vendor_found;
931 >
932 >                // Vendor not found? Then display warning
933 >                if (!vendor_found) {
934 >                        char str[256];
935 >                        sprintf(str, GetString(STR_KEYCODE_VENDOR_WARN), vendor, kc_path ? kc_path : KEYCODE_FILE_NAME);
936 >                        WarningAlert(str);
937 >                        return;
938 >                }
939 >        }
940 > }
941 >
942 > // Find Apple mode matching best specified dimensions
943 > static int find_apple_resolution(int xsize, int ysize)
944 > {
945 >        int apple_id;
946 >        if (xsize < 800)
947 >                apple_id = APPLE_640x480;
948 >        else if (xsize < 1024)
949 >                apple_id = APPLE_800x600;
950 >        else if (xsize < 1152)
951 >                apple_id = APPLE_1024x768;
952 >        else if (xsize < 1280) {
953 >                if (ysize < 900)
954 >                        apple_id = APPLE_1152x768;
955 >                else
956 >                        apple_id = APPLE_1152x900;
957 >        }
958 >        else if (xsize < 1600)
959 >                apple_id = APPLE_1280x1024;
960 >        else
961 >                apple_id = APPLE_1600x1200;
962 >        return apple_id;
963 > }
964 >
965 > // Find mode in list of supported modes
966 > static int find_mode(int apple_mode, int apple_id, int type)
967 > {
968 >        for (VideoInfo *p = VModes; p->viType != DIS_INVALID; p++) {
969 >                if (p->viType == type && p->viAppleID == apple_id && p->viAppleMode == apple_mode)
970 >                        return p - VModes;
971 >        }
972 >        return -1;
973 > }
974 >
975 > // Add mode to list of supported modes
976 > static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, int apple_mode, int apple_id, int type)
977   {
978          if (allow & test) {
979                  p->viType = type;
# Line 547 | Line 992 | static void add_mode(VideoInfo *&p, uint
992                                  p->viXsize = 1024;
993                                  p->viYsize = 768;
994                                  break;
995 +                        case APPLE_1152x768:
996 +                                p->viXsize = 1152;
997 +                                p->viYsize = 768;
998 +                                break;
999                          case APPLE_1152x900:
1000                                  p->viXsize = 1152;
1001                                  p->viYsize = 900;
# Line 560 | Line 1009 | static void add_mode(VideoInfo *&p, uint
1009                                  p->viYsize = 1200;
1010                                  break;
1011                  }
1012 <                switch (apple_mode) {
564 <                        case APPLE_8_BIT:
565 <                                p->viRowBytes = p->viXsize;
566 <                                break;
567 <                        case APPLE_16_BIT:
568 <                                p->viRowBytes = p->viXsize * 2;
569 <                                break;
570 <                        case APPLE_32_BIT:
571 <                                p->viRowBytes = p->viXsize * 4;
572 <                                break;
573 <                }
1012 >                p->viRowBytes = TrivialBytesPerRow(p->viXsize, apple_mode);
1013                  p->viAppleMode = apple_mode;
1014                  p->viAppleID = apple_id;
1015                  p++;
1016          }
1017   }
1018  
1019 + // Add standard list of windowed modes for given color depth
1020 + static void add_window_modes(VideoInfo *&p, int window_modes, int mode)
1021 + {
1022 +        add_mode(p, window_modes, 1, mode, APPLE_W_640x480, DIS_WINDOW);
1023 +        add_mode(p, window_modes, 2, mode, APPLE_W_800x600, DIS_WINDOW);
1024 + }
1025 +
1026   static bool has_mode(int x, int y)
1027   {
1028   #ifdef ENABLE_XF86_VIDMODE
# Line 597 | Line 1043 | bool VideoInit(void)
1043          mainBuffer.pageInfo = NULL;
1044   #endif
1045          
1046 +        // Check if X server runs on local machine
1047 +        local_X11 = (strncmp(XDisplayName(x_display_name), ":", 1) == 0)
1048 +                 || (strncmp(XDisplayName(x_display_name), "unix:", 5) == 0);
1049 +    
1050 +        // Init keycode translation
1051 +        keycode_init();
1052 +
1053 +        // Read frame skip prefs
1054 +        frame_skip = PrefsFindInt32("frameskip");
1055 +        if (frame_skip == 0)
1056 +                frame_skip = 1;
1057 +
1058 +        // Read mouse wheel prefs
1059 +        mouse_wheel_mode = PrefsFindInt32("mousewheelmode");
1060 +        mouse_wheel_lines = PrefsFindInt32("mousewheellines");
1061 +
1062          // Init variables
1063          private_data = NULL;
602        cur_mode = 0;   // Window 640x480
1064          video_activated = true;
1065  
1066          // Find screen and root window
1067          screen = XDefaultScreen(x_display);
1068          rootwin = XRootWindow(x_display, screen);
1069  
1070 +        // Get sorted list of available depths
1071 +        avail_depths = XListDepths(x_display, screen, &num_depths);
1072 +        if (avail_depths == NULL) {
1073 +                ErrorAlert(GetString(STR_UNSUPP_DEPTH_ERR));
1074 +                return false;
1075 +        }
1076 +        sort(avail_depths, avail_depths + num_depths);
1077 +        
1078          // Get screen depth
1079          xdepth = DefaultDepth(x_display, screen);
1080  
1081   #ifdef ENABLE_XF86_DGA
1082          // DGA available?
1083      int event_base, error_base;
1084 <    if (XF86DGAQueryExtension(x_display, &event_base, &error_base)) {
1084 >    if (local_X11 && XF86DGAQueryExtension(x_display, &event_base, &error_base)) {
1085                  int dga_flags = 0;
1086                  XF86DGAQueryDirectVideo(x_display, screen, &dga_flags);
1087                  has_dga = dga_flags & XF86DGADirectPresent;
# Line 636 | Line 1105 | bool VideoInit(void)
1105          black_pixel = BlackPixel(x_display, screen);
1106          white_pixel = WhitePixel(x_display, screen);
1107  
639        // Get appropriate visual
640        int color_class;
641        switch (xdepth) {
642 #if 0
643                case 1:
644                        color_class = StaticGray;
645                        break;
646 #endif
647                case 8:
648                        color_class = PseudoColor;
649                        break;
650                case 15:
651                case 16:
652                case 24:
653                case 32:
654                        color_class = TrueColor;
655                        break;
656                default:
657                        ErrorAlert(GetString(STR_UNSUPP_DEPTH_ERR));
658                        return false;
659        }
660        if (!XMatchVisualInfo(x_display, screen, xdepth, color_class, &visualInfo)) {
661                ErrorAlert(GetString(STR_NO_XVISUAL_ERR));
662                return false;
663        }
664        if (visualInfo.depth != xdepth) {
665                ErrorAlert(GetString(STR_NO_XVISUAL_ERR));
666                return false;
667        }
668        vis = visualInfo.visual;
669
1108          // Mac screen depth follows X depth (for now)
1109 <        depth = xdepth;
1110 <
1111 <        // Create color maps for 8 bit mode
1112 <        if (depth == 8) {
1113 <                cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1114 <                cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1115 <                XInstallColormap(x_display, cmap[0]);
1116 <                XInstallColormap(x_display, cmap[1]);
1109 >        int default_mode = APPLE_8_BIT;
1110 >        switch (DefaultDepth(x_display, screen)) {
1111 >        case 1:
1112 >                default_mode = APPLE_1_BIT;
1113 >                break;
1114 >        case 8:
1115 >                default_mode = APPLE_8_BIT;
1116 >                break;
1117 >        case 15: case 16:
1118 >                default_mode = APPLE_16_BIT;
1119 >                break;
1120 >        case 24: case 32:
1121 >                default_mode = APPLE_32_BIT;
1122 >                break;
1123          }
1124  
1125          // Construct video mode table
682        int mode = APPLE_8_BIT;
683        int bpr_mult = 8;
684        switch (depth) {
685                case 1:
686                        mode = APPLE_1_BIT;
687                        bpr_mult = 1;
688                        break;
689                case 8:
690                        mode = APPLE_8_BIT;
691                        bpr_mult = 8;
692                        break;
693                case 15:
694                case 16:
695                        mode = APPLE_16_BIT;
696                        bpr_mult = 16;
697                        break;
698                case 24:
699                case 32:
700                        mode = APPLE_32_BIT;
701                        bpr_mult = 32;
702                        break;
703        }
704
1126          uint32 window_modes = PrefsFindInt32("windowmodes");
1127          uint32 screen_modes = PrefsFindInt32("screenmodes");
1128          if (!has_dga)
# Line 710 | Line 1131 | bool VideoInit(void)
1131                  window_modes |= 3;      // Allow at least 640x480 and 800x600 window modes
1132  
1133          VideoInfo *p = VModes;
1134 <        add_mode(p, window_modes, 1, mode, APPLE_W_640x480, DIS_WINDOW);
1135 <        add_mode(p, window_modes, 2, mode, APPLE_W_800x600, DIS_WINDOW);
1134 >        for (unsigned int d = APPLE_1_BIT; d <= APPLE_32_BIT; d++)
1135 >                if (find_visual_for_depth(d))
1136 >                        add_window_modes(p, window_modes, d);
1137 >
1138          if (has_vidmode) {
1139                  if (has_mode(640, 480))
1140 <                        add_mode(p, screen_modes, 1, mode, APPLE_640x480, DIS_SCREEN);
1140 >                        add_mode(p, screen_modes, 1, default_mode, APPLE_640x480, DIS_SCREEN);
1141                  if (has_mode(800, 600))
1142 <                        add_mode(p, screen_modes, 2, mode, APPLE_800x600, DIS_SCREEN);
1142 >                        add_mode(p, screen_modes, 2, default_mode, APPLE_800x600, DIS_SCREEN);
1143                  if (has_mode(1024, 768))
1144 <                        add_mode(p, screen_modes, 4, mode, APPLE_1024x768, DIS_SCREEN);
1144 >                        add_mode(p, screen_modes, 4, default_mode, APPLE_1024x768, DIS_SCREEN);
1145 >                if (has_mode(1152, 768))
1146 >                        add_mode(p, screen_modes, 64, default_mode, APPLE_1152x768, DIS_SCREEN);
1147                  if (has_mode(1152, 900))
1148 <                        add_mode(p, screen_modes, 8, mode, APPLE_1152x900, DIS_SCREEN);
1148 >                        add_mode(p, screen_modes, 8, default_mode, APPLE_1152x900, DIS_SCREEN);
1149                  if (has_mode(1280, 1024))
1150 <                        add_mode(p, screen_modes, 16, mode, APPLE_1280x1024, DIS_SCREEN);
1150 >                        add_mode(p, screen_modes, 16, default_mode, APPLE_1280x1024, DIS_SCREEN);
1151                  if (has_mode(1600, 1200))
1152 <                        add_mode(p, screen_modes, 32, mode, APPLE_1600x1200, DIS_SCREEN);
1152 >                        add_mode(p, screen_modes, 32, default_mode, APPLE_1600x1200, DIS_SCREEN);
1153          } else if (screen_modes) {
1154                  int xsize = DisplayWidth(x_display, screen);
1155                  int ysize = DisplayHeight(x_display, screen);
1156 <                int apple_id;
732 <                if (xsize < 800)
733 <                        apple_id = APPLE_640x480;
734 <                else if (xsize < 1024)
735 <                        apple_id = APPLE_800x600;
736 <                else if (xsize < 1152)
737 <                        apple_id = APPLE_1024x768;
738 <                else if (xsize < 1280)
739 <                        apple_id = APPLE_1152x900;
740 <                else if (xsize < 1600)
741 <                        apple_id = APPLE_1280x1024;
742 <                else
743 <                        apple_id = APPLE_1600x1200;
1156 >                int apple_id = find_apple_resolution(xsize, ysize);
1157                  p->viType = DIS_SCREEN;
1158                  p->viRowBytes = 0;
1159                  p->viXsize = xsize;
1160                  p->viYsize = ysize;
1161 <                p->viAppleMode = mode;
1161 >                p->viAppleMode = default_mode;
1162                  p->viAppleID = apple_id;
1163                  p++;
1164          }
# Line 755 | Line 1168 | bool VideoInit(void)
1168          p->viAppleMode = 0;
1169          p->viAppleID = 0;
1170  
1171 < #ifdef ENABLE_XF86_DGA
1171 >        // Find default mode (window 640x480)
1172 >        cur_mode = -1;
1173          if (has_dga && screen_modes) {
1174 <                int v_bank, v_size;
1175 <                XF86DGAGetVideo(x_display, screen, &dga_screen_base, &dga_fb_width, &v_bank, &v_size);
1176 <                D(bug("DGA screen_base %p, v_width %d\n", dga_screen_base, dga_fb_width));
1174 >                int screen_width = DisplayWidth(x_display, screen);
1175 >                int screen_height = DisplayHeight(x_display, screen);
1176 >                int apple_id = find_apple_resolution(screen_width, screen_height);
1177 >                if (apple_id != -1)
1178 >                        cur_mode = find_mode(default_mode, apple_id, DIS_SCREEN);
1179 >        }
1180 >        if (cur_mode == -1) {
1181 >                // pick up first windowed mode available
1182 >                for (VideoInfo *p = VModes; p->viType != DIS_INVALID; p++) {
1183 >                        if (p->viType == DIS_WINDOW && p->viAppleMode == default_mode) {
1184 >                                cur_mode = p - VModes;
1185 >                                break;
1186 >                        }
1187 >                }
1188 >        }
1189 >        assert(cur_mode != -1);
1190 >
1191 > #if DEBUG
1192 >        D(bug("Available video modes:\n"));
1193 >        for (p = VModes; p->viType != DIS_INVALID; p++) {
1194 >                int bits = depth_of_video_mode(p->viAppleMode);
1195 >                D(bug(" %dx%d (ID %02x), %d colors\n", p->viXsize, p->viYsize, p->viAppleID, 1 << bits));
1196          }
1197   #endif
1198  
# Line 774 | Line 1207 | bool VideoInit(void)
1207  
1208          // Start periodic thread
1209          XSync(x_display, false);
1210 <        redraw_thread_active = (pthread_create(&redraw_thread, NULL, redraw_func, NULL) == 0);
1210 >        Set_pthread_attr(&redraw_thread_attr, 0);
1211 >        redraw_thread_cancel = false;
1212 >        redraw_thread_active = (pthread_create(&redraw_thread, &redraw_thread_attr, redraw_func, NULL) == 0);
1213          D(bug("Redraw thread installed (%ld)\n", redraw_thread));
1214          return true;
1215   }
# Line 788 | Line 1223 | void VideoExit(void)
1223   {
1224          // Stop redraw thread
1225          if (redraw_thread_active) {
1226 +                redraw_thread_cancel = true;
1227                  pthread_cancel(redraw_thread);
1228                  pthread_join(redraw_thread, NULL);
1229                  redraw_thread_active = false;
# Line 806 | Line 1242 | void VideoExit(void)
1242                  close_display();
1243                  XFlush(x_display);
1244                  XSync(x_display, false);
809                if (depth == 8) {
810                        XFreeColormap(x_display, cmap[0]);
811                        XFreeColormap(x_display, cmap[1]);
812                }
1245          }
1246   }
1247  
# Line 873 | Line 1305 | static void resume_emul(void)
1305          // Reopen full screen display
1306          XGrabKeyboard(x_display, rootwin, 1, GrabModeAsync, GrabModeAsync, CurrentTime);
1307          XGrabPointer(x_display, rootwin, 1, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
1308 + #ifdef ENABLE_XF86_DGA
1309          XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse);
1310          XF86DGASetViewPort(x_display, screen, 0, 0);
1311 + #endif
1312          XSync(x_display, false);
1313  
1314          // the_buffer already contains the data to restore. i.e. since a temporary
# Line 1068 | Line 1502 | static int kc_decode(KeySym ks)
1502          return -1;
1503   }
1504  
1505 < static int event2keycode(XKeyEvent *ev)
1505 > static int event2keycode(XKeyEvent &ev, bool key_down)
1506   {
1507          KeySym ks;
1074        int as;
1508          int i = 0;
1509  
1510          do {
1511 <                ks = XLookupKeysym(ev, i++);
1512 <                as = kc_decode(ks);
1513 <                if (as != -1)
1511 >                ks = XLookupKeysym(&ev, i++);
1512 >                int as = kc_decode(ks);
1513 >                if (as >= 0)
1514 >                        return as;
1515 >                if (as == -2)
1516                          return as;
1517          } while (ks != NoSymbol);
1518  
# Line 1090 | Line 1525 | static void handle_events(void)
1525          for (;;) {
1526                  XEvent event;
1527  
1528 <                if (!XCheckMaskEvent(x_display, eventmask, &event))
1528 >                XDisplayLock();
1529 >                if (!XCheckMaskEvent(x_display, eventmask, &event)) {
1530 >                        // Handle clipboard events
1531 >                        if (XCheckTypedEvent(x_display, SelectionRequest, &event))
1532 >                                ClipboardSelectionRequest(&event.xselectionrequest);
1533 >                        else if (XCheckTypedEvent(x_display, SelectionClear, &event))
1534 >                                ClipboardSelectionClear(&event.xselectionclear);
1535 >
1536 >                        // Window "close" widget clicked
1537 >                        else if (XCheckTypedEvent(x_display, ClientMessage, &event)) {
1538 >                                if (event.xclient.format == 32 && event.xclient.data.l[0] == WM_DELETE_WINDOW) {
1539 >                                        ADBKeyDown(0x7f);       // Power key
1540 >                                        ADBKeyUp(0x7f);
1541 >                                }
1542 >                        }
1543 >
1544 >                        XDisplayUnlock();
1545                          break;
1546 +                }
1547 +                XDisplayUnlock();
1548  
1549                  switch (event.type) {
1550                          // Mouse button
# Line 1099 | Line 1552 | static void handle_events(void)
1552                                  unsigned int button = ((XButtonEvent *)&event)->button;
1553                                  if (button < 4)
1554                                          ADBMouseDown(button - 1);
1555 +                                else if (button < 6) {  // Wheel mouse
1556 +                                        if (mouse_wheel_mode == 0) {
1557 +                                                int key = (button == 5) ? 0x79 : 0x74;  // Page up/down
1558 +                                                ADBKeyDown(key);
1559 +                                                ADBKeyUp(key);
1560 +                                        } else {
1561 +                                                int key = (button == 5) ? 0x3d : 0x3e;  // Cursor up/down
1562 +                                                for(int i=0; i<mouse_wheel_lines; i++) {
1563 +                                                        ADBKeyDown(key);
1564 +                                                        ADBKeyUp(key);
1565 +                                                }
1566 +                                        }
1567 +                                }
1568                                  break;
1569                          }
1570                          case ButtonRelease: {
# Line 1108 | Line 1574 | static void handle_events(void)
1574                                  break;
1575                          }
1576  
1577 <                        // Mouse moved
1577 >                        // Mouse entered window
1578                          case EnterNotify:
1579 <                                ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y);
1579 >                                if (event.xcrossing.mode != NotifyGrab && event.xcrossing.mode != NotifyUngrab)
1580 >                                        ADBMouseMoved(event.xmotion.x, event.xmotion.y);
1581                                  break;
1582 +
1583 +                        // Mouse moved
1584                          case MotionNotify:
1585 <                                ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y);
1585 >                                ADBMouseMoved(event.xmotion.x, event.xmotion.y);
1586                                  break;
1587  
1588                          // Keyboard
1589                          case KeyPress: {
1590 <                                int code;
1591 <                                if ((code = event2keycode((XKeyEvent *)&event)) != -1) {
1590 >                                int code = -1;
1591 >                                if (use_keycodes) {
1592 >                                        if (event2keycode(event.xkey, true) != -2)      // This is called to process the hotkeys
1593 >                                                code = keycode_table[event.xkey.keycode & 0xff];
1594 >                                } else
1595 >                                        code = event2keycode(event.xkey, true);
1596 >                                if (code >= 0) {
1597                                          if (!emul_suspended) {
1598 <                                                ADBKeyDown(code);
1598 >                                                if (code == 0x39) {     // Caps Lock pressed
1599 >                                                        if (caps_on) {
1600 >                                                                ADBKeyUp(code);
1601 >                                                                caps_on = false;
1602 >                                                        } else {
1603 >                                                                ADBKeyDown(code);
1604 >                                                                caps_on = true;
1605 >                                                        }
1606 >                                                } else
1607 >                                                        ADBKeyDown(code);
1608                                                  if (code == 0x36)
1609                                                          ctrl_down = true;
1610                                          } else {
# Line 1132 | Line 1615 | static void handle_events(void)
1615                                  break;
1616                          }
1617                          case KeyRelease: {
1618 <                                int code;
1619 <                                if ((code = event2keycode((XKeyEvent *)&event)) != -1) {
1618 >                                int code = -1;
1619 >                                if (use_keycodes) {
1620 >                                        if (event2keycode(event.xkey, false) != -2)     // This is called to process the hotkeys
1621 >                                                code = keycode_table[event.xkey.keycode & 0xff];
1622 >                                } else
1623 >                                        code = event2keycode(event.xkey, false);
1624 >                                if (code >= 0 && code != 0x39) {        // Don't propagate Caps Lock releases
1625                                          ADBKeyUp(code);
1626                                          if (code == 0x36)
1627                                                  ctrl_down = false;
# Line 1176 | Line 1664 | void VideoVBL(void)
1664   *  Install graphics acceleration
1665   */
1666  
1667 < #if 0
1668 < // Rectangle blitting
1669 < static void accl_bitblt(accl_params *p)
1667 > // Rectangle inversion
1668 > template< int bpp >
1669 > static inline void do_invrect(uint8 *dest, uint32 length)
1670   {
1671 <        D(bug("accl_bitblt\n"));
1671 > #define INVERT_1(PTR, OFS) ((uint8  *)(PTR))[OFS] = ~((uint8  *)(PTR))[OFS]
1672 > #define INVERT_2(PTR, OFS) ((uint16 *)(PTR))[OFS] = ~((uint16 *)(PTR))[OFS]
1673 > #define INVERT_4(PTR, OFS) ((uint32 *)(PTR))[OFS] = ~((uint32 *)(PTR))[OFS]
1674 > #define INVERT_8(PTR, OFS) ((uint64 *)(PTR))[OFS] = ~((uint64 *)(PTR))[OFS]
1675  
1676 <        // Get blitting parameters
1677 <        int16 src_X = p->src_rect[1] - p->src_bounds[1];
1678 <        int16 src_Y = p->src_rect[0] - p->src_bounds[0];
1679 <        int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
1680 <        int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
1681 <        int16 width = p->dest_rect[3] - p->dest_rect[1] - 1;
1191 <        int16 height = p->dest_rect[2] - p->dest_rect[0] - 1;
1192 <        D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y));
1193 <        D(bug(" width %d, height %d\n", width, height));
1676 > #ifndef UNALIGNED_PROFITABLE
1677 >        // Align on 16-bit boundaries
1678 >        if (bpp < 16 && (((uintptr)dest) & 1)) {
1679 >                INVERT_1(dest, 0);
1680 >                dest += 1; length -= 1;
1681 >        }
1682  
1683 <        // And perform the blit
1684 <        bitblt_hook(src_X, src_Y, dest_X, dest_Y, width, height);
1685 < }
1683 >        // Align on 32-bit boundaries
1684 >        if (bpp < 32 && (((uintptr)dest) & 2)) {
1685 >                INVERT_2(dest, 0);
1686 >                dest += 2; length -= 2;
1687 >        }
1688 > #endif
1689  
1690 < static bool accl_bitblt_hook(accl_params *p)
1691 < {
1692 <        D(bug("accl_draw_hook %p\n", p));
1690 >        // Invert 8-byte words
1691 >        if (length >= 8) {
1692 >                const int r = (length / 8) % 8;
1693 >                dest += r * 8;
1694  
1695 <        // Check if we can accelerate this bitblt
1696 <        if (p->src_base_addr == screen_base && p->dest_base_addr == screen_base &&
1697 <                display_type == DIS_SCREEN && bitblt_hook != NULL &&
1698 <                ((uint32 *)p)[0x18 >> 2] + ((uint32 *)p)[0x128 >> 2] == 0 &&
1699 <                ((uint32 *)p)[0x130 >> 2] == 0 &&
1700 <                p->transfer_mode == 0 &&
1701 <                p->src_row_bytes > 0 && ((uint32 *)p)[0x15c >> 2] > 0) {
1695 >                int n = ((length / 8) + 7) / 8;
1696 >                switch (r) {
1697 >                case 0: do {
1698 >                                dest += 64;
1699 >                                INVERT_8(dest, -8);
1700 >                case 7: INVERT_8(dest, -7);
1701 >                case 6: INVERT_8(dest, -6);
1702 >                case 5: INVERT_8(dest, -5);
1703 >                case 4: INVERT_8(dest, -4);
1704 >                case 3: INVERT_8(dest, -3);
1705 >                case 2: INVERT_8(dest, -2);
1706 >                case 1: INVERT_8(dest, -1);
1707 >                                } while (--n > 0);
1708 >                }
1709 >        }
1710  
1711 <                // Yes, set function pointer
1712 <                p->draw_proc = accl_bitblt;
1713 <                return true;
1711 >        // 32-bit cell to invert?
1712 >        if (length & 4) {
1713 >                INVERT_4(dest, 0);
1714 >                if (bpp <= 16)
1715 >                        dest += 4;
1716          }
1717 <        return false;
1717 >
1718 >        // 16-bit cell to invert?
1719 >        if (bpp <= 16 && (length & 2)) {
1720 >                INVERT_2(dest, 0);
1721 >                if (bpp <= 8)
1722 >                        dest += 2;
1723 >        }
1724 >
1725 >        // 8-bit cell to invert?
1726 >        if (bpp <= 8 && (length & 1))
1727 >                INVERT_1(dest, 0);
1728 >
1729 > #undef INVERT_1
1730 > #undef INVERT_2
1731 > #undef INVERT_4
1732 > #undef INVERT_8
1733   }
1734  
1735 < // Rectangle filling/inversion
1219 < static void accl_fillrect8(accl_params *p)
1735 > void NQD_invrect(uint32 p)
1736   {
1737 <        D(bug("accl_fillrect8\n"));
1737 >        D(bug("accl_invrect %08x\n", p));
1738  
1739 <        // Get filling parameters
1740 <        int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
1741 <        int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
1742 <        int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1;
1743 <        int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1;
1228 <        uint8 color = p->pen_mode == 8 ? p->fore_pen : p->back_pen;
1739 >        // Get inversion parameters
1740 >        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1741 >        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1742 >        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1743 >        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1744          D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1745 <        D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max));
1745 >        D(bug(" width %d, height %d, bytes_per_row %d\n", width, height, (int32)ReadMacInt32(p + acclDestRowBytes)));
1746  
1747 <        // And perform the fill
1748 <        fillrect8_hook(dest_X, dest_Y, dest_X_max, dest_Y_max, color);
1747 >        //!!?? pen_mode == 14
1748 >
1749 >        // And perform the inversion
1750 >        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1751 >        const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1752 >        uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1753 >        width *= bpp;
1754 >        switch (bpp) {
1755 >        case 1:
1756 >                for (int i = 0; i < height; i++) {
1757 >                        do_invrect<8>(dest, width);
1758 >                        dest += dest_row_bytes;
1759 >                }
1760 >                break;
1761 >        case 2:
1762 >                for (int i = 0; i < height; i++) {
1763 >                        do_invrect<16>(dest, width);
1764 >                        dest += dest_row_bytes;
1765 >                }
1766 >                break;
1767 >        case 4:
1768 >                for (int i = 0; i < height; i++) {
1769 >                        do_invrect<32>(dest, width);
1770 >                        dest += dest_row_bytes;
1771 >                }
1772 >                break;
1773 >        }
1774   }
1775  
1776 < static void accl_fillrect32(accl_params *p)
1776 > // Rectangle filling
1777 > template< int bpp >
1778 > static inline void do_fillrect(uint8 *dest, uint32 color, uint32 length)
1779   {
1780 <        D(bug("accl_fillrect32\n"));
1780 > #define FILL_1(PTR, OFS, VAL) ((uint8  *)(PTR))[OFS] = (VAL)
1781 > #define FILL_2(PTR, OFS, VAL) ((uint16 *)(PTR))[OFS] = (VAL)
1782 > #define FILL_4(PTR, OFS, VAL) ((uint32 *)(PTR))[OFS] = (VAL)
1783 > #define FILL_8(PTR, OFS, VAL) ((uint64 *)(PTR))[OFS] = (VAL)
1784  
1785 <        // Get filling parameters
1786 <        int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
1787 <        int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
1788 <        int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1;
1789 <        int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1;
1790 <        uint32 color = p->pen_mode == 8 ? p->fore_pen : p->back_pen;
1246 <        D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1247 <        D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max));
1785 > #ifndef UNALIGNED_PROFITABLE
1786 >        // Align on 16-bit boundaries
1787 >        if (bpp < 16 && (((uintptr)dest) & 1)) {
1788 >                FILL_1(dest, 0, color);
1789 >                dest += 1; length -= 1;
1790 >        }
1791  
1792 <        // And perform the fill
1793 <        fillrect32_hook(dest_X, dest_Y, dest_X_max, dest_Y_max, color);
1792 >        // Align on 32-bit boundaries
1793 >        if (bpp < 32 && (((uintptr)dest) & 2)) {
1794 >                FILL_2(dest, 0, color);
1795 >                dest += 2; length -= 2;
1796 >        }
1797 > #endif
1798 >
1799 >        // Fill 8-byte words
1800 >        if (length >= 8) {
1801 >                const uint64 c = (((uint64)color) << 32) | color;
1802 >                const int r = (length / 8) % 8;
1803 >                dest += r * 8;
1804 >
1805 >                int n = ((length / 8) + 7) / 8;
1806 >                switch (r) {
1807 >                case 0: do {
1808 >                                dest += 64;
1809 >                                FILL_8(dest, -8, c);
1810 >                case 7: FILL_8(dest, -7, c);
1811 >                case 6: FILL_8(dest, -6, c);
1812 >                case 5: FILL_8(dest, -5, c);
1813 >                case 4: FILL_8(dest, -4, c);
1814 >                case 3: FILL_8(dest, -3, c);
1815 >                case 2: FILL_8(dest, -2, c);
1816 >                case 1: FILL_8(dest, -1, c);
1817 >                                } while (--n > 0);
1818 >                }
1819 >        }
1820 >
1821 >        // 32-bit cell to fill?
1822 >        if (length & 4) {
1823 >                FILL_4(dest, 0, color);
1824 >                if (bpp <= 16)
1825 >                        dest += 4;
1826 >        }
1827 >
1828 >        // 16-bit cell to fill?
1829 >        if (bpp <= 16 && (length & 2)) {
1830 >                FILL_2(dest, 0, color);
1831 >                if (bpp <= 8)
1832 >                        dest += 2;
1833 >        }
1834 >
1835 >        // 8-bit cell to fill?
1836 >        if (bpp <= 8 && (length & 1))
1837 >                FILL_1(dest, 0, color);
1838 >
1839 > #undef FILL_1
1840 > #undef FILL_2
1841 > #undef FILL_4
1842 > #undef FILL_8
1843   }
1844  
1845 < static void accl_invrect(accl_params *p)
1845 > void NQD_fillrect(uint32 p)
1846   {
1847 <        D(bug("accl_invrect\n"));
1847 >        D(bug("accl_fillrect %08x\n", p));
1848  
1849 <        // Get inversion parameters
1850 <        int16 dest_X = p->dest_rect[1] - p->dest_bounds[1];
1851 <        int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0];
1852 <        int16 dest_X_max = p->dest_rect[3] - p->dest_bounds[1] - 1;
1853 <        int16 dest_Y_max = p->dest_rect[2] - p->dest_bounds[0] - 1;
1849 >        // Get filling parameters
1850 >        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1851 >        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1852 >        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1853 >        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1854 >        uint32 color = htonl(ReadMacInt32(p + acclPenMode) == 8 ? ReadMacInt32(p + acclForePen) : ReadMacInt32(p + acclBackPen));
1855          D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1856 <        D(bug(" dest X max %d, dest Y max %d\n", dest_X_max, dest_Y_max));
1857 <
1265 <        //!!?? pen_mode == 14
1856 >        D(bug(" width %d, height %d\n", width, height));
1857 >        D(bug(" bytes_per_row %d color %08x\n", (int32)ReadMacInt32(p + acclDestRowBytes), color));
1858  
1859 <        // And perform the inversion
1860 <        invrect_hook(dest_X, dest_Y, dest_X_max, dest_Y_max);
1859 >        // And perform the fill
1860 >        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1861 >        const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1862 >        uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1863 >        width *= bpp;
1864 >        switch (bpp) {
1865 >        case 1:
1866 >                for (int i = 0; i < height; i++) {
1867 >                        memset(dest, color, width);
1868 >                        dest += dest_row_bytes;
1869 >                }
1870 >                break;
1871 >        case 2:
1872 >                for (int i = 0; i < height; i++) {
1873 >                        do_fillrect<16>(dest, color, width);
1874 >                        dest += dest_row_bytes;
1875 >                }
1876 >                break;
1877 >        case 4:
1878 >                for (int i = 0; i < height; i++) {
1879 >                        do_fillrect<32>(dest, color, width);
1880 >                        dest += dest_row_bytes;
1881 >                }
1882 >                break;
1883 >        }
1884   }
1885  
1886 < static bool accl_fillrect_hook(accl_params *p)
1886 > bool NQD_fillrect_hook(uint32 p)
1887   {
1888 <        D(bug("accl_fillrect_hook %p\n", p));
1888 >        D(bug("accl_fillrect_hook %08x\n", p));
1889  
1890          // Check if we can accelerate this fillrect
1891 <        if (p->dest_base_addr == screen_base && ((uint32 *)p)[0x284 >> 2] != 0 && display_type == DIS_SCREEN) {
1892 <                if (p->transfer_mode == 8) {
1891 >        if (ReadMacInt32(p + 0x284) != 0 && ReadMacInt32(p + acclDestPixelSize) >= 8) {
1892 >                const int transfer_mode = ReadMacInt32(p + acclTransferMode);
1893 >                if (transfer_mode == 8) {
1894                          // Fill
1895 <                        if (p->dest_pixel_size == 8 && fillrect8_hook != NULL) {
1896 <                                p->draw_proc = accl_fillrect8;
1897 <                                return true;
1898 <                        } else if (p->dest_pixel_size == 32 && fillrect32_hook != NULL) {
1283 <                                p->draw_proc = accl_fillrect32;
1284 <                                return true;
1285 <                        }
1286 <                } else if (p->transfer_mode == 10 && invrect_hook != NULL) {
1895 >                        WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_FILLRECT));
1896 >                        return true;
1897 >                }
1898 >                else if (transfer_mode == 10) {
1899                          // Invert
1900 <                        p->draw_proc = accl_invrect;
1900 >                        WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_INVRECT));
1901                          return true;
1902                  }
1903          }
1904          return false;
1905   }
1906  
1907 + // Rectangle blitting
1908 + // TODO: optimize for VOSF and target pixmap == screen
1909 + void NQD_bitblt(uint32 p)
1910 + {
1911 +        D(bug("accl_bitblt %08x\n", p));
1912 +
1913 +        // Get blitting parameters
1914 +        int16 src_X  = (int16)ReadMacInt16(p + acclSrcRect + 2) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 2);
1915 +        int16 src_Y  = (int16)ReadMacInt16(p + acclSrcRect + 0) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 0);
1916 +        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1917 +        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1918 +        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1919 +        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1920 +        D(bug(" src addr %08x, dest addr %08x\n", ReadMacInt32(p + acclSrcBaseAddr), ReadMacInt32(p + acclDestBaseAddr)));
1921 +        D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y));
1922 +        D(bug(" width %d, height %d\n", width, height));
1923 +
1924 +        // And perform the blit
1925 +        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclSrcPixelSize));
1926 +        width *= bpp;
1927 +        if ((int32)ReadMacInt32(p + acclSrcRowBytes) > 0) {
1928 +                const int src_row_bytes = (int32)ReadMacInt32(p + acclSrcRowBytes);
1929 +                const int dst_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1930 +                uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + (src_Y * src_row_bytes) + (src_X * bpp));
1931 +                uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dst_row_bytes) + (dest_X * bpp));
1932 +                for (int i = 0; i < height; i++) {
1933 +                        memmove(dst, src, width);
1934 +                        src += src_row_bytes;
1935 +                        dst += dst_row_bytes;
1936 +                }
1937 +        }
1938 +        else {
1939 +                const int src_row_bytes = -(int32)ReadMacInt32(p + acclSrcRowBytes);
1940 +                const int dst_row_bytes = -(int32)ReadMacInt32(p + acclDestRowBytes);
1941 +                uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + ((src_Y + height - 1) * src_row_bytes) + (src_X * bpp));
1942 +                uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + ((dest_Y + height - 1) * dst_row_bytes) + (dest_X * bpp));
1943 +                for (int i = height - 1; i >= 0; i--) {
1944 +                        memmove(dst, src, width);
1945 +                        src -= src_row_bytes;
1946 +                        dst -= dst_row_bytes;
1947 +                }
1948 +        }
1949 + }
1950 +
1951 + /*
1952 +  BitBlt transfer modes:
1953 +  0 : srcCopy
1954 +  1 : srcOr
1955 +  2 : srcXor
1956 +  3 : srcBic
1957 +  4 : notSrcCopy
1958 +  5 : notSrcOr
1959 +  6 : notSrcXor
1960 +  7 : notSrcBic
1961 +  32 : blend
1962 +  33 : addPin
1963 +  34 : addOver
1964 +  35 : subPin
1965 +  36 : transparent
1966 +  37 : adMax
1967 +  38 : subOver
1968 +  39 : adMin
1969 +  50 : hilite
1970 + */
1971 +
1972 + bool NQD_bitblt_hook(uint32 p)
1973 + {
1974 +        D(bug("accl_draw_hook %08x\n", p));
1975 +
1976 +        // Check if we can accelerate this bitblt
1977 +        if (ReadMacInt32(p + 0x018) + ReadMacInt32(p + 0x128) == 0 &&
1978 +                ReadMacInt32(p + 0x130) == 0 &&
1979 +                ReadMacInt32(p + acclSrcPixelSize) >= 8 &&
1980 +                ReadMacInt32(p + acclSrcPixelSize) == ReadMacInt32(p + acclDestPixelSize) &&
1981 +                (ReadMacInt32(p + acclSrcRowBytes) ^ ReadMacInt32(p + acclDestRowBytes)) >= 0 && // same sign?
1982 +                ReadMacInt32(p + acclTransferMode) == 0 &&                                                                               // srcCopy?
1983 +                ReadMacInt32(p + 0x15c) > 0) {
1984 +
1985 +                // Yes, set function pointer
1986 +                WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_BITBLT));
1987 +                return true;
1988 +        }
1989 +        return false;
1990 + }
1991 +
1992   // Wait for graphics operation to finish
1993 < static bool accl_sync_hook(void *arg)
1993 > bool NQD_sync_hook(uint32 arg)
1994   {
1995 <        D(bug("accl_sync_hook %p\n", arg));
1299 <        if (sync_hook != NULL)
1300 <                sync_hook();
1995 >        D(bug("accl_sync_hook %08x\n", arg));
1996          return true;
1997   }
1998  
1304 static struct accl_hook_info bitblt_hook_info = {accl_bitblt_hook, accl_sync_hook, ACCL_BITBLT};
1305 static struct accl_hook_info fillrect_hook_info = {accl_fillrect_hook, accl_sync_hook, ACCL_FILLRECT};
1306 #endif
1307
1999   void VideoInstallAccel(void)
2000   {
2001          // Install acceleration hooks
2002          if (PrefsFindBool("gfxaccel")) {
2003                  D(bug("Video: Installing acceleration hooks\n"));
2004 < //!!    NQDMisc(6, &bitblt_hook_info);
2005 < //              NQDMisc(6, &fillrect_hook_info);
2004 >                uint32 base;
2005 >
2006 >                SheepVar bitblt_hook_info(sizeof(accl_hook_info));
2007 >                base = bitblt_hook_info.addr();
2008 >                WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK));
2009 >                WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
2010 >                WriteMacInt32(base + 8, ACCL_BITBLT);
2011 >                NQDMisc(6, bitblt_hook_info.ptr());
2012 >
2013 >                SheepVar fillrect_hook_info(sizeof(accl_hook_info));
2014 >                base = fillrect_hook_info.addr();
2015 >                WriteMacInt32(base + 0, NativeTVECT(NATIVE_FILLRECT_HOOK));
2016 >                WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
2017 >                WriteMacInt32(base + 8, ACCL_FILLRECT);
2018 >                NQDMisc(6, fillrect_hook_info.ptr());
2019          }
2020   }
2021  
# Line 1374 | Line 2078 | int16 video_mode_change(VidLocals *csSav
2078  
2079   void video_set_palette(void)
2080   {
2081 +        LOCK_PALETTE;
2082 +
2083 +        // Convert colors to XColor array
2084 +        int mode = get_current_mode();
2085 +        int num_in = palette_size(mode);
2086 +        int num_out = 256;
2087 +        bool stretch = false;
2088 +        if (IsDirectMode(mode)) {
2089 +                // If X is in 565 mode we have to stretch the gamma table from 32 to 64 entries
2090 +                num_out = vis->map_entries;
2091 +                stretch = true;
2092 +        }
2093 +        XColor *p = x_palette;
2094 +        for (int i=0; i<num_out; i++) {
2095 +                int c = (stretch ? (i * num_in) / num_out : i);
2096 +                p->red = mac_pal[c].red * 0x0101;
2097 +                p->green = mac_pal[c].green * 0x0101;
2098 +                p->blue = mac_pal[c].blue * 0x0101;
2099 +                p++;
2100 +        }
2101 +
2102 + #ifdef ENABLE_VOSF
2103 +        // Recalculate pixel color expansion map
2104 +        if (!IsDirectMode(mode) && xdepth > 8) {
2105 +                for (int i=0; i<256; i++) {
2106 +                        int c = i & (num_in-1); // If there are less than 256 colors, we repeat the first entries (this makes color expansion easier)
2107 +                        ExpandMap[i] = map_rgb(mac_pal[c].red, mac_pal[c].green, mac_pal[c].blue);
2108 +                }
2109 +
2110 +                // We have to redraw everything because the interpretation of pixel values changed
2111 +                LOCK_VOSF;
2112 +                PFLAG_SET_ALL;
2113 +                UNLOCK_VOSF;
2114 +                memset(the_buffer_copy, 0, VModes[cur_mode].viRowBytes * VModes[cur_mode].viYsize);
2115 +        }
2116 + #endif
2117 +
2118 +        // Tell redraw thread to change palette
2119          palette_changed = true;
2120 +
2121 +        UNLOCK_PALETTE;
2122 + }
2123 +
2124 +
2125 + /*
2126 + *  Can we set the MacOS cursor image into the window?
2127 + */
2128 +
2129 + bool video_can_change_cursor(void)
2130 + {
2131 +        return hw_mac_cursor_accl && (display_type != DIS_SCREEN);
2132   }
2133  
2134  
# Line 1501 | Line 2255 | static void update_display(void)
2255  
2256          // Refresh display
2257          if (high && wide) {
2258 +                XDisplayLock();
2259                  if (have_shm)
2260                          XShmPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high, 0);
2261                  else
2262                          XPutImage(x_display, the_win, the_gc, img, x1, y1, x1, y1, wide, high);
2263 +                XDisplayUnlock();
2264          }
2265   }
2266  
2267 + const int VIDEO_REFRESH_HZ = 60;
2268 + const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
2269 +
2270 + static void handle_palette_changes(void)
2271 + {
2272 +        LOCK_PALETTE;
2273 +
2274 +        if (palette_changed && !emul_suspended) {
2275 +                palette_changed = false;
2276 +
2277 +                int mode = get_current_mode();
2278 +                if (color_class == PseudoColor || color_class == DirectColor) {
2279 +                        int num = vis->map_entries;
2280 +                        bool set_clut = true;
2281 +                        if (!IsDirectMode(mode) && color_class == DirectColor) {
2282 +                                if (display_type == DIS_WINDOW)
2283 +                                        set_clut = false; // Indexed mode on true color screen, don't set CLUT
2284 +                        }
2285 +
2286 +                        if (set_clut) {
2287 +                                XDisplayLock();
2288 +                                XStoreColors(x_display, cmap[0], x_palette, num);
2289 +                                XStoreColors(x_display, cmap[1], x_palette, num);
2290 +                                XSync(x_display, false);
2291 +                                XDisplayUnlock();
2292 +                        }
2293 +                }
2294 +
2295 + #ifdef ENABLE_XF86_DGA
2296 +                if (display_type == DIS_SCREEN) {
2297 +                        current_dga_cmap ^= 1;
2298 +                        if (!IsDirectMode(mode) && cmap[current_dga_cmap])
2299 +                                XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
2300 +                }
2301 + #endif
2302 +        }
2303 +
2304 +        UNLOCK_PALETTE;
2305 + }
2306 +
2307   static void *redraw_func(void *arg)
2308   {
2309 <        int tick_counter = 0;
1514 <        struct timespec req = {0, 16666667};
2309 >        int fd = ConnectionNumber(x_display);
2310  
2311 <        for (;;) {
2311 >        uint64 start = GetTicks_usec();
2312 >        int64 ticks = 0;
2313 >        uint64 next = GetTicks_usec() + VIDEO_REFRESH_DELAY;
2314  
2315 <                // Wait
1519 <                nanosleep(&req, NULL);
2315 >        while (!redraw_thread_cancel) {
2316  
2317                  // Pause if requested (during video mode switches)
2318                  while (thread_stop_req)
2319                          thread_stop_ack = true;
2320  
2321 <                // Handle X11 events
2322 <                handle_events();
2321 >                int64 delay = next - GetTicks_usec();
2322 >                if (delay < -VIDEO_REFRESH_DELAY) {
2323 >
2324 >                        // We are lagging far behind, so we reset the delay mechanism
2325 >                        next = GetTicks_usec();
2326 >
2327 >                } else if (delay <= 0) {
2328 >
2329 >                        // Delay expired, refresh display
2330 >                        next += VIDEO_REFRESH_DELAY;
2331 >                        ticks++;
2332  
2333 <                // Quit DGA mode if requested
2334 <                if (quit_full_screen) {
2335 <                        quit_full_screen = false;
2336 <                        if (display_type == DIS_SCREEN) {
2333 >                        // Handle X11 events
2334 >                        handle_events();
2335 >
2336 >                        // Quit DGA mode if requested
2337 >                        if (quit_full_screen) {
2338 >                                quit_full_screen = false;
2339 >                                if (display_type == DIS_SCREEN) {
2340 >                                        XDisplayLock();
2341   #ifdef ENABLE_XF86_DGA
2342 <                                XF86DGADirectVideo(x_display, screen, 0);
2343 <                                XUngrabPointer(x_display, CurrentTime);
2344 <                                XUngrabKeyboard(x_display, CurrentTime);
2345 < #endif
2346 <                                XSync(x_display, false);
2347 <                                quit_full_screen_ack = true;
2348 <                                return NULL;
2342 >                                        XF86DGADirectVideo(x_display, screen, 0);
2343 >                                        XUngrabPointer(x_display, CurrentTime);
2344 >                                        XUngrabKeyboard(x_display, CurrentTime);
2345 >                                        XUnmapWindow(x_display, the_win);
2346 >                                        wait_unmapped(the_win);
2347 >                                        XDestroyWindow(x_display, the_win);
2348 > #endif
2349 >                                        XSync(x_display, false);
2350 >                                        XDisplayUnlock();
2351 >                                        quit_full_screen_ack = true;
2352 >                                        return NULL;
2353 >                                }
2354                          }
1541                }
2355  
2356 <                // Refresh display and set cursor image in window mode
2357 <                if (display_type == DIS_WINDOW) {
2358 <                        tick_counter++;
2359 <                        if (tick_counter >= frame_skip) {
2360 <                                tick_counter = 0;
2356 >                        // Refresh display and set cursor image in window mode
2357 >                        static int tick_counter = 0;
2358 >                        if (display_type == DIS_WINDOW) {
2359 >                                tick_counter++;
2360 >                                if (tick_counter >= frame_skip) {
2361 >                                        tick_counter = 0;
2362  
2363 <                                // Update display
2363 >                                        // Update display
2364   #ifdef ENABLE_VOSF
2365 <                                if (use_vosf) {
2366 <                                        if (mainBuffer.dirty) {
2367 <                                                LOCK_VOSF;
2368 <                                                update_display_window_vosf();
2369 <                                                UNLOCK_VOSF;
2370 <                                                XSync(x_display, false); // Let the server catch up
2365 >                                        if (use_vosf) {
2366 >                                                XDisplayLock();
2367 >                                                if (mainBuffer.dirty) {
2368 >                                                        LOCK_VOSF;
2369 >                                                        update_display_window_vosf();
2370 >                                                        UNLOCK_VOSF;
2371 >                                                        XSync(x_display, false); // Let the server catch up
2372 >                                                }
2373 >                                                XDisplayUnlock();
2374                                          }
2375 <                                }
1559 <                                else
2375 >                                        else
2376   #endif
2377 <                                        update_display();
2377 >                                                update_display();
2378  
2379 <                                // Set new cursor image if it was changed
2380 <                                if (cursor_changed) {
2381 <                                        cursor_changed = false;
2382 <                                        memcpy(cursor_image->data, MacCursor + 4, 32);
2383 <                                        memcpy(cursor_mask_image->data, MacCursor + 36, 32);
2384 <                                        XFreeCursor(x_display, mac_cursor);
2385 <                                        XPutImage(x_display, cursor_map, cursor_gc, cursor_image, 0, 0, 0, 0, 16, 16);
2386 <                                        XPutImage(x_display, cursor_mask_map, cursor_mask_gc, cursor_mask_image, 0, 0, 0, 0, 16, 16);
2387 <                                        mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, MacCursor[2], MacCursor[3]);
2388 <                                        XDefineCursor(x_display, the_win, mac_cursor);
2379 >                                        // Set new cursor image if it was changed
2380 >                                        if (hw_mac_cursor_accl && cursor_changed) {
2381 >                                                cursor_changed = false;
2382 >                                                uint8 *x_data = (uint8 *)cursor_image->data;
2383 >                                                uint8 *x_mask = (uint8 *)cursor_mask_image->data;
2384 >                                                for (int i = 0; i < 32; i++) {
2385 >                                                        x_mask[i] = MacCursor[4 + i] | MacCursor[36 + i];
2386 >                                                        x_data[i] = MacCursor[4 + i];
2387 >                                                }
2388 >                                                XDisplayLock();
2389 >                                                XFreeCursor(x_display, mac_cursor);
2390 >                                                XPutImage(x_display, cursor_map, cursor_gc, cursor_image, 0, 0, 0, 0, 16, 16);
2391 >                                                XPutImage(x_display, cursor_mask_map, cursor_mask_gc, cursor_mask_image, 0, 0, 0, 0, 16, 16);
2392 >                                                mac_cursor = XCreatePixmapCursor(x_display, cursor_map, cursor_mask_map, &black, &white, MacCursor[2], MacCursor[3]);
2393 >                                                XDefineCursor(x_display, the_win, mac_cursor);
2394 >                                                XDisplayUnlock();
2395 >                                        }
2396                                  }
2397                          }
1575                }
2398   #ifdef ENABLE_VOSF
2399 <                else if (use_vosf) {
2400 <                        // Update display (VOSF variant)
2401 <                        static int tick_counter = 0;
2402 <                        if (++tick_counter >= frame_skip) {
2403 <                                tick_counter = 0;
2404 <                                if (mainBuffer.dirty) {
2405 <                                        LOCK_VOSF;
2406 <                                        update_display_dga_vosf();
2407 <                                        UNLOCK_VOSF;
2399 >                        else if (use_vosf) {
2400 >                                // Update display (VOSF variant)
2401 >                                if (++tick_counter >= frame_skip) {
2402 >                                        tick_counter = 0;
2403 >                                        if (mainBuffer.dirty) {
2404 >                                                LOCK_VOSF;
2405 >                                                update_display_dga_vosf();
2406 >                                                UNLOCK_VOSF;
2407 >                                        }
2408                                  }
2409                          }
1588                }
2410   #endif
2411  
2412 <                // Set new palette if it was changed
2413 <                if (palette_changed && !emul_suspended) {
2414 <                        palette_changed = false;
2415 <                        XColor c[256];
2416 <                        for (int i=0; i<256; i++) {
2417 <                                c[i].pixel = i;
2418 <                                c[i].red = mac_pal[i].red * 0x0101;
2419 <                                c[i].green = mac_pal[i].green * 0x0101;
2420 <                                c[i].blue = mac_pal[i].blue * 0x0101;
2421 <                                c[i].flags = DoRed | DoGreen | DoBlue;
2422 <                        }
2423 <                        if (depth == 8) {
2424 <                                XStoreColors(x_display, cmap[0], c, 256);
2425 <                                XStoreColors(x_display, cmap[1], c, 256);
1605 < #ifdef ENABLE_XF86_DGA
1606 <                                if (display_type == DIS_SCREEN) {
1607 <                                        current_dga_cmap ^= 1;
1608 <                                        XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1609 <                                }
1610 < #endif
1611 <                        }
2412 >                        // Set new palette if it was changed
2413 >                        handle_palette_changes();
2414 >
2415 >                } else {
2416 >
2417 >                        // No display refresh pending, check for X events
2418 >                        fd_set readfds;
2419 >                        FD_ZERO(&readfds);
2420 >                        FD_SET(fd, &readfds);
2421 >                        struct timeval timeout;
2422 >                        timeout.tv_sec = 0;
2423 >                        timeout.tv_usec = delay;
2424 >                        if (select(fd+1, &readfds, NULL, NULL, &timeout) > 0)
2425 >                                handle_events();
2426                  }
2427          }
2428          return NULL;

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines