ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/SDL/video_sdl.cpp
(Generate patch)

Comparing BasiliskII/src/SDL/video_sdl.cpp (file contents):
Revision 1.9 by gbeauche, 2004-06-27T17:31:21Z vs.
Revision 1.40 by asvitkine, 2011-12-28T21:35:42Z

# Line 1 | Line 1
1   /*
2   *  video_sdl.cpp - Video/graphics emulation, SDL specific stuff
3   *
4 < *  Basilisk II (C) 1997-2004 Christian Bauer
4 > *  Basilisk II (C) 1997-2008 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 21 | Line 21
21   /*
22   *  NOTES:
23   *    The Ctrl key works like a qualifier for special actions:
24 < *      Ctrl-Tab = suspend DGA mode
24 > *      Ctrl-Tab = suspend DGA mode (TODO)
25   *      Ctrl-Esc = emergency quit
26   *      Ctrl-F1 = mount floppy
27   *      Ctrl-F5 = grab mouse (in windowed mode)
28   *
29   *  FIXMEs and TODOs:
30 + *  - Windows requires an extra mouse event to update the actual cursor image?
31 + *  - Ctr-Tab for suspend/resume but how? SDL does not support that for non-Linux
32   *  - Ctrl-Fn doesn't generate SDL_KEYDOWN events (SDL bug?)
33   *  - Mouse acceleration, there is no API in SDL yet for that
34   *  - Force relative mode in Grab mode even if SDL provides absolute coordinates?
33 *  - Fullscreen mode
35   *  - Gamma tables support is likely to be broken here
36   *  - Events processing is bound to the general emulation thread as SDL requires
37   *    to PumpEvents() within the same thread as the one that called SetVideoMode().
38   *    Besides, there can't seem to be a way to call SetVideoMode() from a child thread.
38 *  - Refresh performance is still slow. Use SDL_CreateRGBSurface()?
39   *  - Backport hw cursor acceleration to Basilisk II?
40 < *  - Move generic Native QuickDraw acceleration routines to gfxaccel.cpp
40 > *  - Factor out code
41   */
42  
43   #include "sysdeps.h"
# Line 48 | Line 48
48   #include <errno.h>
49   #include <vector>
50  
51 + #ifdef WIN32
52 + #include <malloc.h> /* alloca() */
53 + #endif
54 +
55   #include "cpu_emulation.h"
56   #include "main.h"
57   #include "adb.h"
# Line 57 | Line 61
61   #include "video.h"
62   #include "video_defs.h"
63   #include "video_blit.h"
64 + #include "vm_alloc.h"
65  
66   #define DEBUG 0
67   #include "debug.h"
# Line 82 | Line 87 | static int display_type = DISPLAY_WINDOW
87   #endif
88  
89   // Constants
90 + #ifdef WIN32
91 + const char KEYCODE_FILE_NAME[] = "BasiliskII_keycodes";
92 + #else
93   const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
94 + #endif
95  
96  
97   // Global variables
# Line 95 | Line 104 | static uint8 *the_buffer_copy = NULL;
104   static uint32 the_buffer_size;                                          // Size of allocated the_buffer
105  
106   static bool redraw_thread_active = false;                       // Flag: Redraw thread installed
107 + #ifndef USE_CPU_EMUL_SERVICES
108   static volatile bool redraw_thread_cancel;                      // Flag: Cancel Redraw thread
109   static SDL_Thread *redraw_thread = NULL;                        // Redraw thread
110 + #ifdef SHEEPSHAVER
111 + static volatile bool thread_stop_req = false;
112 + static volatile bool thread_stop_ack = false;           // Acknowledge for thread_stop_req
113 + #endif
114 + #endif
115  
116   #ifdef ENABLE_VOSF
117   static bool use_vosf = false;                                           // Flag: VOSF enabled
# Line 121 | Line 136 | static SDL_Cursor *sdl_cursor;                                         // C
136   static volatile bool cursor_changed = false;            // Flag: cursor changed, redraw_func must update the cursor
137   static SDL_Color sdl_palette[256];                                      // Color palette to be used as CLUT and gamma table
138   static bool sdl_palette_changed = false;                        // Flag: Palette changed, redraw thread must set new colors
139 < static const int sdl_eventmask = SDL_MOUSEBUTTONDOWNMASK | SDL_MOUSEBUTTONUPMASK | SDL_MOUSEMOTIONMASK | SDL_KEYUPMASK | SDL_KEYDOWNMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK;
139 > static const int sdl_eventmask = SDL_MOUSEEVENTMASK | SDL_KEYEVENTMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK | SDL_ACTIVEEVENTMASK;
140 >
141 > // Mutex to protect SDL events
142 > static SDL_mutex *sdl_events_lock = NULL;
143 > #define LOCK_EVENTS SDL_LockMutex(sdl_events_lock)
144 > #define UNLOCK_EVENTS SDL_UnlockMutex(sdl_events_lock)
145  
146   // Mutex to protect palette
147   static SDL_mutex *sdl_palette_lock = NULL;
# Line 146 | Line 166 | extern void SysMountFirstFloppy(void);
166  
167  
168   /*
169 + *  SDL surface locking glue
170 + */
171 +
172 + #ifdef ENABLE_VOSF
173 + #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE) do {                               \
174 +        if ((SURFACE)->flags & (SDL_HWSURFACE | SDL_FULLSCREEN))        \
175 +                the_host_buffer = (uint8 *)(SURFACE)->pixels;                   \
176 + } while (0)
177 + #else
178 + #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE)
179 + #endif
180 +
181 + #define SDL_VIDEO_LOCK_SURFACE(SURFACE) do {    \
182 +        if (SDL_MUSTLOCK(SURFACE)) {                            \
183 +                SDL_LockSurface(SURFACE);                               \
184 +                SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE);   \
185 +        }                                                                                       \
186 + } while (0)
187 +
188 + #define SDL_VIDEO_UNLOCK_SURFACE(SURFACE) do {  \
189 +        if (SDL_MUSTLOCK(SURFACE))                                      \
190 +                SDL_UnlockSurface(SURFACE);                             \
191 + } while (0)
192 +
193 +
194 + /*
195 + *  Framebuffer allocation routines
196 + */
197 +
198 + static void *vm_acquire_framebuffer(uint32 size)
199 + {
200 +        // always try to reallocate framebuffer at the same address
201 +        static void *fb = VM_MAP_FAILED;
202 +        if (fb != VM_MAP_FAILED) {
203 +                if (vm_acquire_fixed(fb, size) < 0) {
204 + #ifndef SHEEPSHAVER
205 +                        printf("FATAL: Could not reallocate framebuffer at previous address\n");
206 + #endif
207 +                        fb = VM_MAP_FAILED;
208 +                }
209 +        }
210 +        if (fb == VM_MAP_FAILED)
211 +                fb = vm_acquire(size, VM_MAP_DEFAULT | VM_MAP_32BIT);
212 +        return fb;
213 + }
214 +
215 + static inline void vm_release_framebuffer(void *fb, uint32 size)
216 + {
217 +        vm_release(fb, size);
218 + }
219 +
220 +
221 + /*
222 + *  Windows message handler
223 + */
224 +
225 + #ifdef WIN32
226 + #include <dbt.h>
227 + static WNDPROC sdl_window_proc = NULL;                          // Window proc used by SDL
228 +
229 + extern void SysMediaArrived(void);
230 + extern void SysMediaRemoved(void);
231 + extern HWND GetMainWindowHandle(void);
232 +
233 + static LRESULT CALLBACK windows_message_handler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
234 + {
235 +        switch (msg) {
236 +        case WM_DEVICECHANGE:
237 +                if (wParam == DBT_DEVICEREMOVECOMPLETE) {
238 +                        DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
239 +                        if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
240 +                                SysMediaRemoved();
241 +                }
242 +                else if (wParam == DBT_DEVICEARRIVAL) {
243 +                        DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
244 +                        if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
245 +                                SysMediaArrived();
246 +                }
247 +                return 0;
248 +
249 +        default:
250 +                if (sdl_window_proc)
251 +                        return CallWindowProc(sdl_window_proc, hwnd, msg, wParam, lParam);
252 +        }
253 +
254 +        return DefWindowProc(hwnd, msg, wParam, lParam);
255 + }
256 + #endif
257 +
258 +
259 + /*
260   *  SheepShaver glue
261   */
262  
# Line 190 | Line 301 | static vector<monitor_desc *> VideoMonit
301   // Find Apple mode matching best specified dimensions
302   static int find_apple_resolution(int xsize, int ysize)
303   {
304 <        int apple_id;
305 <        if (xsize < 800)
306 <                apple_id = APPLE_640x480;
307 <        else if (xsize < 1024)
308 <                apple_id = APPLE_800x600;
309 <        else if (xsize < 1152)
310 <                apple_id = APPLE_1024x768;
311 <        else if (xsize < 1280) {
312 <                if (ysize < 900)
313 <                        apple_id = APPLE_1152x768;
314 <                else
315 <                        apple_id = APPLE_1152x900;
316 <        }
317 <        else if (xsize < 1600)
318 <                apple_id = APPLE_1280x1024;
208 <        else
209 <                apple_id = APPLE_1600x1200;
210 <        return apple_id;
211 < }
212 <
213 < // Set parameters to specified Apple mode
214 < static void set_apple_resolution(int apple_id, int &xsize, int &ysize)
215 < {
216 <        switch (apple_id) {
217 <        case APPLE_640x480:
218 <                xsize = 640;
219 <                ysize = 480;
220 <                break;
221 <        case APPLE_800x600:
222 <                xsize = 800;
223 <                ysize = 600;
224 <                break;
225 <        case APPLE_1024x768:
226 <                xsize = 1024;
227 <                ysize = 768;
228 <                break;
229 <        case APPLE_1152x768:
230 <                xsize = 1152;
231 <                ysize = 768;
232 <                break;
233 <        case APPLE_1152x900:
234 <                xsize = 1152;
235 <                ysize = 900;
236 <                break;
237 <        case APPLE_1280x1024:
238 <                xsize = 1280;
239 <                ysize = 1024;
240 <                break;
241 <        case APPLE_1600x1200:
242 <                xsize = 1600;
243 <                ysize = 1200;
244 <                break;
245 <        default:
246 <                abort();
247 <        }
248 < }
249 <
250 < // Match Apple mode matching best specified dimensions
251 < static int match_apple_resolution(int &xsize, int &ysize)
252 < {
253 <        int apple_id = find_apple_resolution(xsize, ysize);
254 <        set_apple_resolution(apple_id, xsize, ysize);
255 <        return apple_id;
304 >        if (xsize == 640 && ysize == 480)
305 >                return APPLE_640x480;
306 >        if (xsize == 800 && ysize == 600)
307 >                return APPLE_800x600;
308 >        if (xsize == 1024 && ysize == 768)
309 >                return APPLE_1024x768;
310 >        if (xsize == 1152 && ysize == 768)
311 >                return APPLE_1152x768;
312 >        if (xsize == 1152 && ysize == 900)
313 >                return APPLE_1152x900;
314 >        if (xsize == 1280 && ysize == 1024)
315 >                return APPLE_1280x1024;
316 >        if (xsize == 1600 && ysize == 1200)
317 >                return APPLE_1600x1200;
318 >        return APPLE_CUSTOM;
319   }
320  
321   // Display error alert
# Line 325 | Line 388 | static inline int bytes_per_pixel(int de
388   }
389  
390   // Map video_mode depth ID to numerical depth value
391 < static int sdl_depth_of_video_depth(int video_depth)
391 > static int mac_depth_of_video_depth(int video_depth)
392   {
393          int depth = -1;
394          switch (video_depth) {
# Line 353 | Line 416 | static int sdl_depth_of_video_depth(int
416          return depth;
417   }
418  
419 < // Check wether specified mode is available
420 < static bool has_mode(int type, int width, int height)
419 > // Map video_mode depth ID to SDL screen depth
420 > static int sdl_depth_of_video_depth(int video_depth)
421   {
422 <        // FIXME: no fullscreen support yet
423 <        if (type == DISPLAY_SCREEN)
361 <                return false;
422 >        return (video_depth <= VIDEO_DEPTH_8BIT) ? 8 : mac_depth_of_video_depth(video_depth);
423 > }
424  
425 + // Get screen dimensions
426 + static void sdl_display_dimensions(int &width, int &height)
427 + {
428 +        static int max_width, max_height;
429 +        if (max_width == 0 && max_height == 0) {
430 +                max_width = 640 ; max_height = 480;
431 +                SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
432 +                if (modes && modes != (SDL_Rect **)-1) {
433 +                        // It turns out that on some implementations, and contrary to the documentation,
434 +                        // the returned list is not sorted from largest to smallest (e.g. Windows)
435 +                        for (int i = 0; modes[i] != NULL; i++) {
436 +                                const int w = modes[i]->w;
437 +                                const int h = modes[i]->h;
438 +                                if (w > max_width && h > max_height) {
439 +                                        max_width = w;
440 +                                        max_height = h;
441 +                                }
442 +                        }
443 +                }
444 +        }
445 +        width = max_width;
446 +        height = max_height;
447 + }
448 +
449 + static inline int sdl_display_width(void)
450 + {
451 +        int width, height;
452 +        sdl_display_dimensions(width, height);
453 +        return width;
454 + }
455 +
456 + static inline int sdl_display_height(void)
457 + {
458 +        int width, height;
459 +        sdl_display_dimensions(width, height);
460 +        return height;
461 + }
462 +
463 + // Check wether specified mode is available
464 + static bool has_mode(int type, int width, int height, int depth)
465 + {
466   #ifdef SHEEPSHAVER
467 <        // Filter out Classic resolutiosn
467 >        // Filter out Classic resolutions
468          if (width == 512 && height == 384)
469                  return false;
367
368        // Read window modes prefs
369        static uint32 window_modes = 0;
370        static uint32 screen_modes = 0;
371        if (window_modes == 0 || screen_modes == 0) {
372                window_modes = PrefsFindInt32("windowmodes");
373                screen_modes = PrefsFindInt32("screenmodes");
374                if (window_modes == 0 || screen_modes == 0)
375                        window_modes |= 3;                      // Allow at least 640x480 and 800x600 window modes
376        }
377
378        if (type == DISPLAY_WINDOW) {
379                int apple_mask, apple_id = find_apple_resolution(width, height);
380                switch (apple_id) {
381                case APPLE_640x480:             apple_mask = 0x01; break;
382                case APPLE_800x600:             apple_mask = 0x02; break;
383                case APPLE_1024x768:    apple_mask = 0x04; break;
384                case APPLE_1152x768:    apple_mask = 0x40; break;
385                case APPLE_1152x900:    apple_mask = 0x08; break;
386                case APPLE_1280x1024:   apple_mask = 0x10; break;
387                case APPLE_1600x1200:   apple_mask = 0x20; break;
388                default:                                apple_mask = 0x00; break;
389                }
390                return (window_modes & apple_mask);
391        }
392 #else
393        return true;
470   #endif
471 <        return false;
471 >
472 >        // Filter out out-of-bounds resolutions
473 >        if (width > sdl_display_width() || height > sdl_display_height())
474 >                return false;
475 >
476 >        // Rely on SDL capabilities
477 >        return SDL_VideoModeOK(width, height,
478 >                                                   sdl_depth_of_video_depth(depth),
479 >                                                   SDL_HWSURFACE | (type == DISPLAY_SCREEN ? SDL_FULLSCREEN : 0));
480   }
481  
482   // Add mode to list of supported modes
483   static void add_mode(int type, int width, int height, int resolution_id, int bytes_per_row, int depth)
484   {
485          // Filter out unsupported modes
486 <        if (!has_mode(type, width, height))
486 >        if (!has_mode(type, width, height, depth))
487                  return;
488  
489          // Fill in VideoMode entry
490          VIDEO_MODE mode;
491   #ifdef SHEEPSHAVER
492 <        // Recalculate dimensions to fit Apple modes
409 <        resolution_id = match_apple_resolution(width, height);
492 >        resolution_id = find_apple_resolution(width, height);
493          mode.viType = type;
494   #endif
495          VIDEO_MODE_X = width;
496          VIDEO_MODE_Y = height;
497          VIDEO_MODE_RESOLUTION = resolution_id;
498          VIDEO_MODE_ROW_BYTES = bytes_per_row;
499 <        VIDEO_MODE_DEPTH = depth;
499 >        VIDEO_MODE_DEPTH = (video_depth)depth;
500          VideoModes.push_back(mode);
501   }
502  
420 // Add standard list of windowed modes for given color depth
421 static void add_window_modes(int depth)
422 {
423        video_depth vdepth = (video_depth)depth;
424        add_mode(DISPLAY_WINDOW, 512, 384, 0x80, TrivialBytesPerRow(512, vdepth), depth);
425        add_mode(DISPLAY_WINDOW, 640, 480, 0x81, TrivialBytesPerRow(640, vdepth), depth);
426        add_mode(DISPLAY_WINDOW, 800, 600, 0x82, TrivialBytesPerRow(800, vdepth), depth);
427        add_mode(DISPLAY_WINDOW, 1024, 768, 0x83, TrivialBytesPerRow(1024, vdepth), depth);
428        add_mode(DISPLAY_WINDOW, 1152, 870, 0x84, TrivialBytesPerRow(1152, vdepth), depth);
429        add_mode(DISPLAY_WINDOW, 1280, 1024, 0x85, TrivialBytesPerRow(1280, vdepth), depth);
430        add_mode(DISPLAY_WINDOW, 1600, 1200, 0x86, TrivialBytesPerRow(1600, vdepth), depth);
431 }
432
503   // Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
504   static void set_mac_frame_buffer(SDL_monitor_desc &monitor, int depth, bool native_byte_order)
505   {
# Line 469 | Line 539 | static void set_window_name(int name)
539   // Set mouse grab mode
540   static SDL_GrabMode set_grab_mode(SDL_GrabMode mode)
541   {
542 <        const SDL_VideoInfo *vi =SDL_GetVideoInfo();
542 >        const SDL_VideoInfo *vi = SDL_GetVideoInfo();
543          return (vi && vi->wm_available ? SDL_WM_GrabInput(mode) : SDL_GRAB_OFF);
544   }
545  
546 + // Migrate preferences items (XXX to be handled in MigratePrefs())
547 + static void migrate_screen_prefs(void)
548 + {
549 + #ifdef SHEEPSHAVER
550 +        // Look-up priorities are: "screen", "screenmodes", "windowmodes".
551 +        if (PrefsFindString("screen"))
552 +                return;
553 +
554 +        uint32 window_modes = PrefsFindInt32("windowmodes");
555 +        uint32 screen_modes = PrefsFindInt32("screenmodes");
556 +        int width = 0, height = 0;
557 +        if (screen_modes) {
558 +                static const struct {
559 +                        int id;
560 +                        int width;
561 +                        int height;
562 +                }
563 +                modes[] = {
564 +                        {  1,    640,    480 },
565 +                        {  2,    800,    600 },
566 +                        {  4,   1024,    768 },
567 +                        { 64,   1152,    768 },
568 +                        {  8,   1152,    900 },
569 +                        { 16,   1280,   1024 },
570 +                        { 32,   1600,   1200 },
571 +                        { 0, }
572 +                };
573 +                for (int i = 0; modes[i].id != 0; i++) {
574 +                        if (screen_modes & modes[i].id) {
575 +                                if (width < modes[i].width && height < modes[i].height) {
576 +                                        width = modes[i].width;
577 +                                        height = modes[i].height;
578 +                                }
579 +                        }
580 +                }
581 +        } else {
582 +                if (window_modes & 1)
583 +                        width = 640, height = 480;
584 +                if (window_modes & 2)
585 +                        width = 800, height = 600;
586 +        }
587 +        if (width && height) {
588 +                char str[32];
589 +                sprintf(str, "%s/%d/%d", screen_modes ? "dga" : "win", width, height);
590 +                PrefsReplaceString("screen", str);
591 +        }
592 + #endif
593 + }
594 +
595  
596   /*
597   *  Display "driver" classes
# Line 506 | Line 625 | public:
625   class driver_window;
626   static void update_display_window_vosf(driver_window *drv);
627   static void update_display_dynamic(int ticker, driver_window *drv);
628 < static void update_display_static(driver_window *drv);
628 > static void update_display_static(driver_base *drv);
629  
630   class driver_window : public driver_base {
631          friend void update_display_window_vosf(driver_window *drv);
632          friend void update_display_dynamic(int ticker, driver_window *drv);
633 <        friend void update_display_static(driver_window *drv);
633 >        friend void update_display_static(driver_base *drv);
634  
635   public:
636          driver_window(SDL_monitor_desc &monitor);
# Line 528 | Line 647 | private:
647          int mouse_last_x, mouse_last_y; // Last mouse position (for relative mode)
648   };
649  
650 + class driver_fullscreen : public driver_base {
651 + public:
652 +        driver_fullscreen(SDL_monitor_desc &monitor);
653 +        ~driver_fullscreen();
654 + };
655 +
656   static driver_base *drv = NULL; // Pointer to currently used driver object
657  
658   #ifdef ENABLE_VOSF
# Line 549 | Line 674 | driver_base::~driver_base()
674          if (s)
675                  SDL_FreeSurface(s);
676  
677 +        // the_buffer shall always be mapped through vm_acquire_framebuffer()
678 +        if (the_buffer != VM_MAP_FAILED) {
679 +                D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
680 +                vm_release_framebuffer(the_buffer, the_buffer_size);
681 +                the_buffer = NULL;
682 +        }
683 +
684          // Free frame buffer(s)
685          if (!use_vosf) {
554                if (the_buffer) {
555                        free(the_buffer);
556                        the_buffer = NULL;
557                }
686                  if (the_buffer_copy) {
687                          free(the_buffer_copy);
688                          the_buffer_copy = NULL;
# Line 562 | Line 690 | driver_base::~driver_base()
690          }
691   #ifdef ENABLE_VOSF
692          else {
565                // the_buffer shall always be mapped through vm_acquire() so that we can vm_protect() it at will
566                if (the_buffer != VM_MAP_FAILED) {
567                        D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
568                        vm_release(the_buffer, the_buffer_size);
569                        the_buffer = NULL;
570                }
693                  if (the_host_buffer) {
694                          D(bug(" freeing the_host_buffer at %p\n", the_host_buffer));
695                          free(the_host_buffer);
# Line 578 | Line 700 | driver_base::~driver_base()
700                          free(the_buffer_copy);
701                          the_buffer_copy = NULL;
702                  }
703 +
704 +                // Deinitialize VOSF
705 +                video_vosf_exit();
706          }
707   #endif
708   }
# Line 587 | Line 712 | void driver_base::update_palette(void)
712   {
713          const VIDEO_MODE &mode = monitor.get_current_mode();
714  
715 <        if (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
715 >        if ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
716                  SDL_SetPalette(s, SDL_PHYSPAL, sdl_palette, 0, 256);
717   }
718  
# Line 606 | Line 731 | void driver_base::restore_mouse_accel(vo
731   *  Windowed display driver
732   */
733  
734 + static bool SDL_display_opened = false;
735 +
736   // Open display
737   driver_window::driver_window(SDL_monitor_desc &m)
738          : driver_base(m), mouse_grabbed(false)
# Line 617 | Line 744 | driver_window::driver_window(SDL_monitor
744          // Set absolute mouse mode
745          ADBSetRelMouseMode(mouse_grabbed);
746  
747 +        // This is ugly:
748 +        // If we're switching resolutions (ie, not setting it for the first time),
749 +        // there's a bug in SDL where the SDL_Surface created will not be properly
750 +        // setup. The solution is to SDL_QuitSubSystem(SDL_INIT_VIDEO) before calling
751 +        // SDL_SetVideoMode for the second time (SDL_SetVideoMode will call SDL_Init()
752 +        // and all will be well). Without this, the video becomes corrupted (at least
753 +        // on Mac OS X), after the resolution switch.
754 +        if (SDL_display_opened)
755 +                SDL_QuitSubSystem(SDL_INIT_VIDEO);
756 +
757          // Create surface
758 <        int depth = (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
758 >        int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
759          if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
760                  return;
761  
762 +        SDL_display_opened = true;
763 +
764   #ifdef ENABLE_VOSF
765          use_vosf = true;
766          // Allocate memory for frame buffer (SIZE is extended to page-boundary)
767          the_host_buffer = (uint8 *)s->pixels;
768          the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
769 <        the_buffer = (uint8 *)vm_acquire(the_buffer_size);
769 >        the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
770          the_buffer_copy = (uint8 *)malloc(the_buffer_size);
771          D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
772  
# Line 651 | Line 790 | driver_window::driver_window(SDL_monitor
790                  // Allocate memory for frame buffer
791                  the_buffer_size = (aligned_height + 2) * s->pitch;
792                  the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
793 <                the_buffer = (uint8 *)calloc(1, the_buffer_size);
793 >                the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
794                  D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
795          }
796          
# Line 676 | Line 815 | driver_window::driver_window(SDL_monitor
815          visualFormat.Rmask = f->Rmask;
816          visualFormat.Gmask = f->Gmask;
817          visualFormat.Bmask = f->Bmask;
818 <        Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(VIDEO_MODE_DEPTH));
818 >        Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
819  
820          // Load gray ramp to 8->16/32 expand map
821          if (!IsDirectMode(mode))
# Line 743 | Line 882 | void driver_window::mouse_moved(int x, i
882          ADBMouseMoved(x, y);
883   }
884  
885 +
886 + /*
887 + *  Full-screen display driver
888 + */
889 +
890 + // Open display
891 + driver_fullscreen::driver_fullscreen(SDL_monitor_desc &m)
892 +        : driver_base(m)
893 + {
894 +        int width = VIDEO_MODE_X, height = VIDEO_MODE_Y;
895 +        int aligned_width = (width + 15) & ~15;
896 +        int aligned_height = (height + 15) & ~15;
897 +
898 +        // Set absolute mouse mode
899 +        ADBSetRelMouseMode(false);
900 +
901 +        // Create surface
902 +        int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
903 +        if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE | SDL_FULLSCREEN)) == NULL)
904 +                return;
905 +
906 + #ifdef ENABLE_VOSF
907 +        use_vosf = true;
908 +        // Allocate memory for frame buffer (SIZE is extended to page-boundary)
909 +        the_host_buffer = (uint8 *)s->pixels;
910 +        the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
911 +        the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
912 +        the_buffer_copy = (uint8 *)malloc(the_buffer_size);
913 +        D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
914 +
915 +        // Check whether we can initialize the VOSF subsystem and it's profitable
916 +        if (!video_vosf_init(m)) {
917 +                WarningAlert(STR_VOSF_INIT_ERR);
918 +                use_vosf = false;
919 +        }
920 +        else if (!video_vosf_profitable()) {
921 +                video_vosf_exit();
922 +                printf("VOSF acceleration is not profitable on this platform, disabling it\n");
923 +                use_vosf = false;
924 +        }
925 +        if (!use_vosf) {
926 +                free(the_buffer_copy);
927 +                vm_release(the_buffer, the_buffer_size);
928 +                the_host_buffer = NULL;
929 +        }
930 + #endif
931 +        if (!use_vosf) {
932 +                // Allocate memory for frame buffer
933 +                the_buffer_size = (aligned_height + 2) * s->pitch;
934 +                the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
935 +                the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
936 +                D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
937 +        }
938 +        
939 +        // Hide cursor
940 +        SDL_ShowCursor(0);
941 +
942 +        // Init blitting routines
943 +        SDL_PixelFormat *f = s->format;
944 +        VisualFormat visualFormat;
945 +        visualFormat.depth = depth;
946 +        visualFormat.Rmask = f->Rmask;
947 +        visualFormat.Gmask = f->Gmask;
948 +        visualFormat.Bmask = f->Bmask;
949 +        Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
950 +
951 +        // Load gray ramp to 8->16/32 expand map
952 +        if (!IsDirectMode(mode))
953 +                for (int i=0; i<256; i++)
954 +                        ExpandMap[i] = SDL_MapRGB(f, i, i, i);
955 +
956 +        // Set frame buffer base
957 +        set_mac_frame_buffer(monitor, VIDEO_MODE_DEPTH, true);
958 +
959 +        // Everything went well
960 +        init_ok = true;
961 + }
962 +
963 + // Close display
964 + driver_fullscreen::~driver_fullscreen()
965 + {
966 + #ifdef ENABLE_VOSF
967 +        if (use_vosf)
968 +                the_host_buffer = NULL; // don't free() in driver_base dtor
969 + #endif
970 +        if (s)
971 +                SDL_FreeSurface(s);
972 +
973 +        // Show cursor
974 +        SDL_ShowCursor(1);
975 + }
976 +
977 +
978   /*
979   *  Initialization
980   */
# Line 774 | Line 1006 | static void keycode_init(void)
1006                  SDL_VideoDriverName(video_driver, sizeof(video_driver));
1007                  bool video_driver_found = false;
1008                  char line[256];
1009 +                int n_keys = 0;
1010                  while (fgets(line, sizeof(line) - 1, f)) {
1011                          // Read line
1012                          int len = strlen(line);
# Line 786 | Line 1019 | static void keycode_init(void)
1019                                  continue;
1020  
1021                          if (video_driver_found) {
1022 <                                // Skip aliases
1022 >                                // Skip aliases as long as we have read keycodes yet
1023 >                                // Otherwise, it's another mapping and we have to stop
1024                                  static const char sdl_str[] = "sdl";
1025 <                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0)
1025 >                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0 && n_keys == 0)
1026                                          continue;
1027  
1028                                  // Read keycode
1029                                  int x_code, mac_code;
1030                                  if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
1031 <                                        keycode_table[x_code & 0xff] = mac_code;
1031 >                                        keycode_table[x_code & 0xff] = mac_code, n_keys++;
1032                                  else
1033                                          break;
1034                          } else {
# Line 819 | Line 1053 | static void keycode_init(void)
1053                          WarningAlert(str);
1054                          return;
1055                  }
1056 +
1057 +                D(bug("Using SDL/%s keycodes table, %d key mappings\n", video_driver, n_keys));
1058          }
1059   }
1060  
# Line 837 | Line 1073 | bool SDL_monitor_desc::video_open(void)
1073          case DISPLAY_WINDOW:
1074                  drv = new(std::nothrow) driver_window(*this);
1075                  break;
1076 +        case DISPLAY_SCREEN:
1077 +                drv = new(std::nothrow) driver_fullscreen(*this);
1078 +                break;
1079          }
1080          if (drv == NULL)
1081                  return false;
# Line 846 | Line 1085 | bool SDL_monitor_desc::video_open(void)
1085                  return false;
1086          }
1087  
1088 + #ifdef WIN32
1089 +        // Chain in a new message handler for WM_DEVICECHANGE
1090 +        HWND the_window = GetMainWindowHandle();
1091 +        sdl_window_proc = (WNDPROC)GetWindowLongPtr(the_window, GWLP_WNDPROC);
1092 +        SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)windows_message_handler);
1093 + #endif
1094 +
1095          // Initialize VideoRefresh function
1096          VideoRefreshInit();
1097  
# Line 853 | Line 1099 | bool SDL_monitor_desc::video_open(void)
1099          LOCK_FRAME_BUFFER;
1100  
1101          // Start redraw/input thread
1102 + #ifndef USE_CPU_EMUL_SERVICES
1103          redraw_thread_cancel = false;
1104          redraw_thread_active = ((redraw_thread = SDL_CreateThread(redraw_func, NULL)) != NULL);
1105          if (!redraw_thread_active) {
1106                  printf("FATAL: cannot create redraw thread\n");
1107                  return false;
1108          }
1109 + #else
1110 +        redraw_thread_active = true;
1111 + #endif
1112          return true;
1113   }
1114  
# Line 879 | Line 1129 | bool VideoInit(bool classic)
1129   #endif
1130  
1131          // Create Mutexes
1132 +        if ((sdl_events_lock = SDL_CreateMutex()) == NULL)
1133 +                return false;
1134          if ((sdl_palette_lock = SDL_CreateMutex()) == NULL)
1135                  return false;
1136          if ((frame_buffer_lock = SDL_CreateMutex()) == NULL)
# Line 893 | Line 1145 | bool VideoInit(bool classic)
1145          mouse_wheel_lines = PrefsFindInt32("mousewheellines");
1146  
1147          // Get screen mode from preferences
1148 +        migrate_screen_prefs();
1149          const char *mode_str = NULL;
897 #ifndef SHEEPSHAVER
1150          if (classic_mode)
1151                  mode_str = "win/512/342";
1152          else
1153                  mode_str = PrefsFindString("screen");
902 #endif
1154  
1155          // Determine display type and default dimensions
1156          int default_width, default_height;
# Line 915 | Line 1166 | bool VideoInit(bool classic)
1166          if (mode_str) {
1167                  if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2)
1168                          display_type = DISPLAY_WINDOW;
1169 <        }
1170 <        int max_width = 640, max_height = 480;
920 <        SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
921 <        if (modes && modes != (SDL_Rect **)-1) {
922 <                max_width = modes[0]->w;
923 <                max_height = modes[0]->h;
924 <                if (default_width > max_width)
925 <                        default_width = max_width;
926 <                if (default_height > max_height)
927 <                        default_height = max_height;
1169 >                else if (sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2)
1170 >                        display_type = DISPLAY_SCREEN;
1171          }
1172          if (default_width <= 0)
1173 <                default_width = max_width;
1173 >                default_width = sdl_display_width();
1174 >        else if (default_width > sdl_display_width())
1175 >                default_width = sdl_display_width();
1176          if (default_height <= 0)
1177 <                default_height = max_height;
1177 >                default_height = sdl_display_height();
1178 >        else if (default_height > sdl_display_height())
1179 >                default_height = sdl_display_height();
1180  
1181          // Mac screen depth follows X depth
1182          screen_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
# Line 949 | Line 1196 | bool VideoInit(bool classic)
1196                  break;
1197          }
1198  
1199 +        // Initialize list of video modes to try
1200 +        struct {
1201 +                int w;
1202 +                int h;
1203 +                int resolution_id;
1204 +        }
1205 +        video_modes[] = {
1206 +                {   -1,   -1, 0x80 },
1207 +                {  512,  384, 0x80 },
1208 +                {  640,  480, 0x81 },
1209 +                {  800,  600, 0x82 },
1210 +                { 1024,  768, 0x83 },
1211 +                { 1152,  870, 0x84 },
1212 +                { 1280, 1024, 0x85 },
1213 +                { 1600, 1200, 0x86 },
1214 +                { 0, }
1215 +        };
1216 +        video_modes[0].w = default_width;
1217 +        video_modes[0].h = default_height;
1218 +
1219          // Construct list of supported modes
1220          if (display_type == DISPLAY_WINDOW) {
1221                  if (classic)
1222                          add_mode(display_type, 512, 342, 0x80, 64, VIDEO_DEPTH_1BIT);
1223                  else {
1224 <                        for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++) {
1225 <                                int bpp = (d <= VIDEO_DEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
1226 <                                if (SDL_VideoModeOK(max_width, max_height, bpp, SDL_HWSURFACE))
1227 <                                        add_window_modes(video_depth(d));
1224 >                        for (int i = 0; video_modes[i].w != 0; i++) {
1225 >                                const int w = video_modes[i].w;
1226 >                                const int h = video_modes[i].h;
1227 >                                if (i > 0 && (w >= default_width || h >= default_height))
1228 >                                        continue;
1229 >                                for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1230 >                                        add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1231                          }
1232                  }
1233 <        } else
1234 <                add_mode(display_type, default_width, default_height, 0x80, TrivialBytesPerRow(default_width, (video_depth)default_depth), default_depth);
1233 >        } else if (display_type == DISPLAY_SCREEN) {
1234 >                for (int i = 0; video_modes[i].w != 0; i++) {
1235 >                        const int w = video_modes[i].w;
1236 >                        const int h = video_modes[i].h;
1237 >                        if (i > 0 && (w >= default_width || h >= default_height))
1238 >                                continue;
1239 >                        if (w == 512 && h == 384)
1240 >                                continue;
1241 >                        for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1242 >                                add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1243 >                }
1244 >        }
1245 >
1246          if (VideoModes.empty()) {
1247                  ErrorAlert(STR_NO_XVISUAL_ERR);
1248                  return false;
# Line 1032 | Line 1313 | void SDL_monitor_desc::video_close(void)
1313   {
1314          D(bug("video_close()\n"));
1315  
1316 + #ifdef WIN32
1317 +        // Remove message handler for WM_DEVICECHANGE
1318 +        HWND the_window = GetMainWindowHandle();
1319 +        SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)sdl_window_proc);
1320 + #endif
1321 +
1322          // Stop redraw thread
1323 + #ifndef USE_CPU_EMUL_SERVICES
1324          if (redraw_thread_active) {
1325                  redraw_thread_cancel = true;
1326                  SDL_WaitThread(redraw_thread, NULL);
1327          }
1328 + #endif
1329          redraw_thread_active = false;
1330  
1331          // Unlock frame buffer
1332          UNLOCK_FRAME_BUFFER;
1333          D(bug(" frame buffer unlocked\n"));
1334  
1046 #ifdef ENABLE_VOSF
1047        if (use_vosf) {
1048                // Deinitialize VOSF
1049                video_vosf_exit();
1050        }
1051 #endif
1052
1335          // Close display
1336          delete drv;
1337          drv = NULL;
# Line 1067 | Line 1349 | void VideoExit(void)
1349                  SDL_DestroyMutex(frame_buffer_lock);
1350          if (sdl_palette_lock)
1351                  SDL_DestroyMutex(sdl_palette_lock);
1352 +        if (sdl_events_lock)
1353 +                SDL_DestroyMutex(sdl_events_lock);
1354   }
1355  
1356  
# Line 1147 | Line 1431 | void SDL_monitor_desc::set_palette(uint8
1431          const VIDEO_MODE &mode = get_current_mode();
1432  
1433          // FIXME: how can we handle the gamma ramp?
1434 <        if (VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1434 >        if ((int)VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1435                  return;
1436  
1437          LOCK_PALETTE;
# Line 1208 | Line 1492 | int16 video_mode_change(VidLocals *csSav
1492                          csSave->saveData = ReadMacInt32(ParamPtr + csData);
1493                          csSave->savePage = ReadMacInt16(ParamPtr + csPage);
1494  
1495 <                        // Disable interrupts
1495 >                        // Disable interrupts and pause redraw thread
1496                          DisableInterrupt();
1497 +                        thread_stop_ack = false;
1498 +                        thread_stop_req = true;
1499 +                        while (!thread_stop_ack) ;
1500  
1501                          cur_mode = i;
1502                          monitor_desc *monitor = VideoMonitors[0];
# Line 1220 | Line 1507 | int16 video_mode_change(VidLocals *csSav
1507                          csSave->saveData=VModes[cur_mode].viAppleID;/* First mode ... */
1508                          csSave->saveMode=VModes[cur_mode].viAppleMode;
1509  
1510 <                        // Enable interrupts
1510 >                        // Enable interrupts and resume redraw thread
1511 >                        thread_stop_req = false;
1512                          EnableInterrupt();
1513                          return noErr;
1514                  }
# Line 1232 | Line 1520 | int16 video_mode_change(VidLocals *csSav
1520   void SDL_monitor_desc::switch_to_current_mode(void)
1521   {
1522          // Close and reopen display
1523 +        LOCK_EVENTS;
1524          video_close();
1525          video_open();
1526 +        UNLOCK_EVENTS;
1527  
1528          if (drv == NULL) {
1529                  ErrorAlert(STR_OPEN_WINDOW_ERR);
# Line 1249 | Line 1539 | void SDL_monitor_desc::switch_to_current
1539   #ifdef SHEEPSHAVER
1540   bool video_can_change_cursor(void)
1541   {
1542 <        return (display_type == DISPLAY_WINDOW);
1543 < }
1254 < #endif
1542 >        static char driver[] = "Quartz?";
1543 >        static int quartzok = -1;
1544  
1545 +        if (display_type != DISPLAY_WINDOW)
1546 +                return false;
1547  
1548 < /*
1549 < *  Set cursor image for window
1550 < */
1548 >        if (quartzok < 0) {
1549 >                if (SDL_VideoDriverName(driver, sizeof driver) == NULL || strncmp(driver, "Quartz", sizeof driver))
1550 >                        quartzok = true;
1551 >                else {
1552 >                        // Quartz driver bug prevents cursor changing in SDL 1.2.11 to 1.2.13.
1553 >                        const SDL_version *vp = SDL_Linked_Version();
1554 >                        int version = SDL_VERSIONNUM(vp->major, vp->minor, vp->patch);
1555 >                        quartzok = (version <= SDL_VERSIONNUM(1, 2, 10) || version >= SDL_VERSIONNUM(1, 2, 14));
1556 >                }
1557 >        }
1558  
1559 < #ifdef SHEEPSHAVER
1262 < void video_set_cursor(void)
1263 < {
1264 <        cursor_changed = true;
1559 >        return quartzok;
1560   }
1561   #endif
1562  
1563  
1564   /*
1565 < *  Install graphics acceleration
1565 > *  Set cursor image for window
1566   */
1567  
1568   #ifdef SHEEPSHAVER
1569 < // Rectangle inversion
1275 < template< int bpp >
1276 < static inline void do_invrect(uint8 *dest, uint32 length)
1277 < {
1278 < #define INVERT_1(PTR, OFS) ((uint8  *)(PTR))[OFS] = ~((uint8  *)(PTR))[OFS]
1279 < #define INVERT_2(PTR, OFS) ((uint16 *)(PTR))[OFS] = ~((uint16 *)(PTR))[OFS]
1280 < #define INVERT_4(PTR, OFS) ((uint32 *)(PTR))[OFS] = ~((uint32 *)(PTR))[OFS]
1281 < #define INVERT_8(PTR, OFS) ((uint64 *)(PTR))[OFS] = ~((uint64 *)(PTR))[OFS]
1282 <
1283 < #ifndef UNALIGNED_PROFITABLE
1284 <        // Align on 16-bit boundaries
1285 <        if (bpp < 16 && (((uintptr)dest) & 1)) {
1286 <                INVERT_1(dest, 0);
1287 <                dest += 1; length -= 1;
1288 <        }
1289 <
1290 <        // Align on 32-bit boundaries
1291 <        if (bpp < 32 && (((uintptr)dest) & 2)) {
1292 <                INVERT_2(dest, 0);
1293 <                dest += 2; length -= 2;
1294 <        }
1295 < #endif
1296 <
1297 <        // Invert 8-byte words
1298 <        if (length >= 8) {
1299 <                const int r = (length / 8) % 8;
1300 <                dest += r * 8;
1301 <
1302 <                int n = ((length / 8) + 7) / 8;
1303 <                switch (r) {
1304 <                case 0: do {
1305 <                                dest += 64;
1306 <                                INVERT_8(dest, -8);
1307 <                case 7: INVERT_8(dest, -7);
1308 <                case 6: INVERT_8(dest, -6);
1309 <                case 5: INVERT_8(dest, -5);
1310 <                case 4: INVERT_8(dest, -4);
1311 <                case 3: INVERT_8(dest, -3);
1312 <                case 2: INVERT_8(dest, -2);
1313 <                case 1: INVERT_8(dest, -1);
1314 <                                } while (--n > 0);
1315 <                }
1316 <        }
1317 <
1318 <        // 32-bit cell to invert?
1319 <        if (length & 4) {
1320 <                INVERT_4(dest, 0);
1321 <                if (bpp <= 16)
1322 <                        dest += 4;
1323 <        }
1324 <
1325 <        // 16-bit cell to invert?
1326 <        if (bpp <= 16 && (length & 2)) {
1327 <                INVERT_2(dest, 0);
1328 <                if (bpp <= 8)
1329 <                        dest += 2;
1330 <        }
1331 <
1332 <        // 8-bit cell to invert?
1333 <        if (bpp <= 8 && (length & 1))
1334 <                INVERT_1(dest, 0);
1335 <
1336 < #undef INVERT_1
1337 < #undef INVERT_2
1338 < #undef INVERT_4
1339 < #undef INVERT_8
1340 < }
1341 <
1342 < void NQD_invrect(uint32 p)
1343 < {
1344 <        D(bug("accl_invrect %08x\n", p));
1345 <
1346 <        // Get inversion parameters
1347 <        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1348 <        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1349 <        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1350 <        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1351 <        D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1352 <        D(bug(" width %d, height %d, bytes_per_row %d\n", width, height, (int32)ReadMacInt32(p + acclDestRowBytes)));
1353 <
1354 <        //!!?? pen_mode == 14
1355 <
1356 <        // And perform the inversion
1357 <        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1358 <        const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1359 <        uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1360 <        width *= bpp;
1361 <        switch (bpp) {
1362 <        case 1:
1363 <                for (int i = 0; i < height; i++) {
1364 <                        do_invrect<8>(dest, width);
1365 <                        dest += dest_row_bytes;
1366 <                }
1367 <                break;
1368 <        case 2:
1369 <                for (int i = 0; i < height; i++) {
1370 <                        do_invrect<16>(dest, width);
1371 <                        dest += dest_row_bytes;
1372 <                }
1373 <                break;
1374 <        case 4:
1375 <                for (int i = 0; i < height; i++) {
1376 <                        do_invrect<32>(dest, width);
1377 <                        dest += dest_row_bytes;
1378 <                }
1379 <                break;
1380 <        }
1381 < }
1382 <
1383 < // Rectangle filling
1384 < template< int bpp >
1385 < static inline void do_fillrect(uint8 *dest, uint32 color, uint32 length)
1386 < {
1387 < #define FILL_1(PTR, OFS, VAL) ((uint8  *)(PTR))[OFS] = (VAL)
1388 < #define FILL_2(PTR, OFS, VAL) ((uint16 *)(PTR))[OFS] = (VAL)
1389 < #define FILL_4(PTR, OFS, VAL) ((uint32 *)(PTR))[OFS] = (VAL)
1390 < #define FILL_8(PTR, OFS, VAL) ((uint64 *)(PTR))[OFS] = (VAL)
1391 <
1392 < #ifndef UNALIGNED_PROFITABLE
1393 <        // Align on 16-bit boundaries
1394 <        if (bpp < 16 && (((uintptr)dest) & 1)) {
1395 <                FILL_1(dest, 0, color);
1396 <                dest += 1; length -= 1;
1397 <        }
1398 <
1399 <        // Align on 32-bit boundaries
1400 <        if (bpp < 32 && (((uintptr)dest) & 2)) {
1401 <                FILL_2(dest, 0, color);
1402 <                dest += 2; length -= 2;
1403 <        }
1404 < #endif
1405 <
1406 <        // Fill 8-byte words
1407 <        if (length >= 8) {
1408 <                const uint64 c = (((uint64)color) << 32) | color;
1409 <                const int r = (length / 8) % 8;
1410 <                dest += r * 8;
1411 <
1412 <                int n = ((length / 8) + 7) / 8;
1413 <                switch (r) {
1414 <                case 0: do {
1415 <                                dest += 64;
1416 <                                FILL_8(dest, -8, c);
1417 <                case 7: FILL_8(dest, -7, c);
1418 <                case 6: FILL_8(dest, -6, c);
1419 <                case 5: FILL_8(dest, -5, c);
1420 <                case 4: FILL_8(dest, -4, c);
1421 <                case 3: FILL_8(dest, -3, c);
1422 <                case 2: FILL_8(dest, -2, c);
1423 <                case 1: FILL_8(dest, -1, c);
1424 <                                } while (--n > 0);
1425 <                }
1426 <        }
1427 <
1428 <        // 32-bit cell to fill?
1429 <        if (length & 4) {
1430 <                FILL_4(dest, 0, color);
1431 <                if (bpp <= 16)
1432 <                        dest += 4;
1433 <        }
1434 <
1435 <        // 16-bit cell to fill?
1436 <        if (bpp <= 16 && (length & 2)) {
1437 <                FILL_2(dest, 0, color);
1438 <                if (bpp <= 8)
1439 <                        dest += 2;
1440 <        }
1441 <
1442 <        // 8-bit cell to fill?
1443 <        if (bpp <= 8 && (length & 1))
1444 <                FILL_1(dest, 0, color);
1445 <
1446 < #undef FILL_1
1447 < #undef FILL_2
1448 < #undef FILL_4
1449 < #undef FILL_8
1450 < }
1451 <
1452 < void NQD_fillrect(uint32 p)
1453 < {
1454 <        D(bug("accl_fillrect %08x\n", p));
1455 <
1456 <        // Get filling parameters
1457 <        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1458 <        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1459 <        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1460 <        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1461 <        uint32 color = htonl(ReadMacInt32(p + acclPenMode) == 8 ? ReadMacInt32(p + acclForePen) : ReadMacInt32(p + acclBackPen));
1462 <        D(bug(" dest X %d, dest Y %d\n", dest_X, dest_Y));
1463 <        D(bug(" width %d, height %d\n", width, height));
1464 <        D(bug(" bytes_per_row %d color %08x\n", (int32)ReadMacInt32(p + acclDestRowBytes), color));
1465 <
1466 <        // And perform the fill
1467 <        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclDestPixelSize));
1468 <        const int dest_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1469 <        uint8 *dest = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dest_row_bytes) + (dest_X * bpp));
1470 <        width *= bpp;
1471 <        switch (bpp) {
1472 <        case 1:
1473 <                for (int i = 0; i < height; i++) {
1474 <                        memset(dest, color, width);
1475 <                        dest += dest_row_bytes;
1476 <                }
1477 <                break;
1478 <        case 2:
1479 <                for (int i = 0; i < height; i++) {
1480 <                        do_fillrect<16>(dest, color, width);
1481 <                        dest += dest_row_bytes;
1482 <                }
1483 <                break;
1484 <        case 4:
1485 <                for (int i = 0; i < height; i++) {
1486 <                        do_fillrect<32>(dest, color, width);
1487 <                        dest += dest_row_bytes;
1488 <                }
1489 <                break;
1490 <        }
1491 < }
1492 <
1493 < bool NQD_fillrect_hook(uint32 p)
1494 < {
1495 <        D(bug("accl_fillrect_hook %08x\n", p));
1496 <
1497 <        // Check if we can accelerate this fillrect
1498 <        if (ReadMacInt32(p + 0x284) != 0 && ReadMacInt32(p + acclDestPixelSize) >= 8) {
1499 <                const int transfer_mode = ReadMacInt32(p + acclTransferMode);
1500 <                if (transfer_mode == 8) {
1501 <                        // Fill
1502 <                        WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_FILLRECT));
1503 <                        return true;
1504 <                }
1505 <                else if (transfer_mode == 10) {
1506 <                        // Invert
1507 <                        WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_INVRECT));
1508 <                        return true;
1509 <                }
1510 <        }
1511 <        return false;
1512 < }
1513 <
1514 < // Rectangle blitting
1515 < // TODO: optimize for VOSF and target pixmap == screen
1516 < void NQD_bitblt(uint32 p)
1517 < {
1518 <        D(bug("accl_bitblt %08x\n", p));
1519 <
1520 <        // Get blitting parameters
1521 <        int16 src_X  = (int16)ReadMacInt16(p + acclSrcRect + 2) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 2);
1522 <        int16 src_Y  = (int16)ReadMacInt16(p + acclSrcRect + 0) - (int16)ReadMacInt16(p + acclSrcBoundsRect + 0);
1523 <        int16 dest_X = (int16)ReadMacInt16(p + acclDestRect + 2) - (int16)ReadMacInt16(p + acclDestBoundsRect + 2);
1524 <        int16 dest_Y = (int16)ReadMacInt16(p + acclDestRect + 0) - (int16)ReadMacInt16(p + acclDestBoundsRect + 0);
1525 <        int16 width  = (int16)ReadMacInt16(p + acclDestRect + 6) - (int16)ReadMacInt16(p + acclDestRect + 2);
1526 <        int16 height = (int16)ReadMacInt16(p + acclDestRect + 4) - (int16)ReadMacInt16(p + acclDestRect + 0);
1527 <        D(bug(" src addr %08x, dest addr %08x\n", ReadMacInt32(p + acclSrcBaseAddr), ReadMacInt32(p + acclDestBaseAddr)));
1528 <        D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y));
1529 <        D(bug(" width %d, height %d\n", width, height));
1530 <
1531 <        // And perform the blit
1532 <        const int bpp = bytes_per_pixel(ReadMacInt32(p + acclSrcPixelSize));
1533 <        width *= bpp;
1534 <        if ((int32)ReadMacInt32(p + acclSrcRowBytes) > 0) {
1535 <                const int src_row_bytes = (int32)ReadMacInt32(p + acclSrcRowBytes);
1536 <                const int dst_row_bytes = (int32)ReadMacInt32(p + acclDestRowBytes);
1537 <                uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + (src_Y * src_row_bytes) + (src_X * bpp));
1538 <                uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + (dest_Y * dst_row_bytes) + (dest_X * bpp));
1539 <                for (int i = 0; i < height; i++) {
1540 <                        memmove(dst, src, width);
1541 <                        src += src_row_bytes;
1542 <                        dst += dst_row_bytes;
1543 <                }
1544 <        }
1545 <        else {
1546 <                const int src_row_bytes = -(int32)ReadMacInt32(p + acclSrcRowBytes);
1547 <                const int dst_row_bytes = -(int32)ReadMacInt32(p + acclDestRowBytes);
1548 <                uint8 *src = Mac2HostAddr(ReadMacInt32(p + acclSrcBaseAddr) + ((src_Y + height - 1) * src_row_bytes) + (src_X * bpp));
1549 <                uint8 *dst = Mac2HostAddr(ReadMacInt32(p + acclDestBaseAddr) + ((dest_Y + height - 1) * dst_row_bytes) + (dest_X * bpp));
1550 <                for (int i = height - 1; i >= 0; i--) {
1551 <                        memmove(dst, src, width);
1552 <                        src -= src_row_bytes;
1553 <                        dst -= dst_row_bytes;
1554 <                }
1555 <        }
1556 < }
1557 <
1558 < /*
1559 <  BitBlt transfer modes:
1560 <  0 : srcCopy
1561 <  1 : srcOr
1562 <  2 : srcXor
1563 <  3 : srcBic
1564 <  4 : notSrcCopy
1565 <  5 : notSrcOr
1566 <  6 : notSrcXor
1567 <  7 : notSrcBic
1568 <  32 : blend
1569 <  33 : addPin
1570 <  34 : addOver
1571 <  35 : subPin
1572 <  36 : transparent
1573 <  37 : adMax
1574 <  38 : subOver
1575 <  39 : adMin
1576 <  50 : hilite
1577 < */
1578 <
1579 < bool NQD_bitblt_hook(uint32 p)
1580 < {
1581 <        D(bug("accl_draw_hook %08x\n", p));
1582 <
1583 <        // Check if we can accelerate this bitblt
1584 <        if (ReadMacInt32(p + 0x018) + ReadMacInt32(p + 0x128) == 0 &&
1585 <                ReadMacInt32(p + 0x130) == 0 &&
1586 <                ReadMacInt32(p + acclSrcPixelSize) >= 8 &&
1587 <                ReadMacInt32(p + acclSrcPixelSize) == ReadMacInt32(p + acclDestPixelSize) &&
1588 <                (ReadMacInt32(p + acclSrcRowBytes) ^ ReadMacInt32(p + acclDestRowBytes)) >= 0 && // same sign?
1589 <                ReadMacInt32(p + acclTransferMode) == 0 &&                                                                               // srcCopy?
1590 <                ReadMacInt32(p + 0x15c) > 0) {
1591 <
1592 <                // Yes, set function pointer
1593 <                WriteMacInt32(p + acclDrawProc, NativeTVECT(NATIVE_BITBLT));
1594 <                return true;
1595 <        }
1596 <        return false;
1597 < }
1598 <
1599 < // Wait for graphics operation to finish
1600 < bool NQD_sync_hook(uint32 arg)
1601 < {
1602 <        D(bug("accl_sync_hook %08x\n", arg));
1603 <        return true;
1604 < }
1605 <
1606 < void VideoInstallAccel(void)
1569 > void video_set_cursor(void)
1570   {
1571 <        // Install acceleration hooks
1609 <        if (PrefsFindBool("gfxaccel")) {
1610 <                D(bug("Video: Installing acceleration hooks\n"));
1611 <                uint32 base;
1612 <
1613 <                SheepVar bitblt_hook_info(sizeof(accl_hook_info));
1614 <                base = bitblt_hook_info.addr();
1615 <                WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK));
1616 <                WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
1617 <                WriteMacInt32(base + 8, ACCL_BITBLT);
1618 <                NQDMisc(6, bitblt_hook_info.ptr());
1619 <
1620 <                SheepVar fillrect_hook_info(sizeof(accl_hook_info));
1621 <                base = fillrect_hook_info.addr();
1622 <                WriteMacInt32(base + 0, NativeTVECT(NATIVE_FILLRECT_HOOK));
1623 <                WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK));
1624 <                WriteMacInt32(base + 8, ACCL_FILLRECT);
1625 <                NQDMisc(6, fillrect_hook_info.ptr());
1626 <        }
1571 >        cursor_changed = true;
1572   }
1573   #endif
1574  
# Line 1698 | Line 1643 | static int kc_decode(SDL_keysym const &
1643  
1644          case SDLK_1: case SDLK_EXCLAIM: return 0x12;
1645          case SDLK_2: case SDLK_AT: return 0x13;
1646 < //      case SDLK_3: case SDLK_numbersign: return 0x14;
1646 >        case SDLK_3: case SDLK_HASH: return 0x14;
1647          case SDLK_4: case SDLK_DOLLAR: return 0x15;
1648 < //      case SDLK_5: case SDLK_percent: return 0x17;
1648 >        case SDLK_5: return 0x17;
1649          case SDLK_6: return 0x16;
1650          case SDLK_7: return 0x1a;
1651          case SDLK_8: return 0x1c;
1652          case SDLK_9: return 0x19;
1653          case SDLK_0: return 0x1d;
1654  
1655 < //      case SDLK_BACKQUOTE: case SDLK_asciitilde: return 0x0a;
1655 >        case SDLK_BACKQUOTE: return 0x0a;
1656          case SDLK_MINUS: case SDLK_UNDERSCORE: return 0x1b;
1657          case SDLK_EQUALS: case SDLK_PLUS: return 0x18;
1658 < //      case SDLK_bracketleft: case SDLK_braceleft: return 0x21;
1659 < //      case SDLK_bracketright: case SDLK_braceright: return 0x1e;
1660 < //      case SDLK_BACKSLASH: case SDLK_bar: return 0x2a;
1658 >        case SDLK_LEFTBRACKET: return 0x21;
1659 >        case SDLK_RIGHTBRACKET: return 0x1e;
1660 >        case SDLK_BACKSLASH: return 0x2a;
1661          case SDLK_SEMICOLON: case SDLK_COLON: return 0x29;
1662 < //      case SDLK_apostrophe: case SDLK_QUOTEDBL: return 0x27;
1662 >        case SDLK_QUOTE: case SDLK_QUOTEDBL: return 0x27;
1663          case SDLK_COMMA: case SDLK_LESS: return 0x2b;
1664          case SDLK_PERIOD: case SDLK_GREATER: return 0x2f;
1665          case SDLK_SLASH: case SDLK_QUESTION: return 0x2c;
# Line 1746 | Line 1691 | static int kc_decode(SDL_keysym const &
1691          case SDLK_LMETA: return 0x3a;
1692          case SDLK_RMETA: return 0x3a;
1693   #endif
1694 +        case SDLK_LSUPER: return 0x3a; // "Windows" key
1695 +        case SDLK_RSUPER: return 0x3a;
1696          case SDLK_MENU: return 0x32;
1697          case SDLK_CAPSLOCK: return 0x39;
1698          case SDLK_NUMLOCK: return 0x47;
# Line 1820 | Line 1767 | static void handle_events(void)
1767                          // Mouse button
1768                          case SDL_MOUSEBUTTONDOWN: {
1769                                  unsigned int button = event.button.button;
1770 <                                if (button < 4)
1771 <                                        ADBMouseDown(button - 1);
1770 >                                if (button == SDL_BUTTON_LEFT)
1771 >                                        ADBMouseDown(0);
1772 >                                else if (button == SDL_BUTTON_RIGHT)
1773 >                                        ADBMouseDown(1);
1774 >                                else if (button == SDL_BUTTON_MIDDLE)
1775 >                                        ADBMouseDown(2);
1776                                  else if (button < 6) {  // Wheel mouse
1777                                          if (mouse_wheel_mode == 0) {
1778                                                  int key = (button == 5) ? 0x79 : 0x74;  // Page up/down
# Line 1839 | Line 1790 | static void handle_events(void)
1790                          }
1791                          case SDL_MOUSEBUTTONUP: {
1792                                  unsigned int button = event.button.button;
1793 <                                if (button < 4)
1794 <                                        ADBMouseUp(button - 1);
1793 >                                if (button == SDL_BUTTON_LEFT)
1794 >                                        ADBMouseUp(0);
1795 >                                else if (button == SDL_BUTTON_RIGHT)
1796 >                                        ADBMouseUp(1);
1797 >                                else if (button == SDL_BUTTON_MIDDLE)
1798 >                                        ADBMouseUp(2);
1799                                  break;
1800                          }
1801  
# Line 1924 | Line 1879 | static void handle_events(void)
1879                                  ADBKeyDown(0x7f);       // Power key
1880                                  ADBKeyUp(0x7f);
1881                                  break;
1882 +
1883 +                        // Application activate/deactivate; consume the event but otherwise ignore it
1884 +                        case SDL_ACTIVEEVENT:
1885 +                                break;
1886                          }
1887                  }
1888          }
# Line 1935 | Line 1894 | static void handle_events(void)
1894   */
1895  
1896   // Static display update (fixed frame rate, but incremental)
1897 < static void update_display_static(driver_window *drv)
1897 > static void update_display_static(driver_base *drv)
1898   {
1899          // Incremental update code
1900          int wide = 0, high = 0, x1, x2, y1, y2, i, j;
# Line 1962 | Line 1921 | static void update_display_static(driver
1921  
1922          // Check for first column from left and first column from right that have changed
1923          if (high) {
1924 <                if (VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1924 >                if ((int)VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1925                          const int src_bytes_per_row = bytes_per_row;
1926                          const int dst_bytes_per_row = drv->s->pitch;
1927                          const int pixels_per_byte = VIDEO_MODE_X / src_bytes_per_row;
# Line 2024 | Line 1983 | static void update_display_static(driver
1983  
1984                  } else {
1985                          const int bytes_per_pixel = VIDEO_MODE_ROW_BYTES / VIDEO_MODE_X;
1986 +                        const int dst_bytes_per_row = drv->s->pitch;
1987  
1988                          x1 = VIDEO_MODE_X;
1989                          for (j=y1; j<=y2; j++) {
# Line 2064 | Line 2024 | static void update_display_static(driver
2024                                  // Blit to screen surface
2025                                  for (j=y1; j<=y2; j++) {
2026                                          i = j * bytes_per_row + x1 * bytes_per_pixel;
2027 +                                        int dst_i = j * dst_bytes_per_row + x1 * bytes_per_pixel;
2028                                          memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * wide);
2029 <                                        Screen_blit((uint8 *)drv->s->pixels + i, the_buffer + i, bytes_per_pixel * wide);
2029 >                                        Screen_blit((uint8 *)drv->s->pixels + dst_i, the_buffer + i, bytes_per_pixel * wide);
2030                                  }
2031  
2032                                  // Unlock surface, if required
# Line 2079 | Line 2040 | static void update_display_static(driver
2040          }
2041   }
2042  
2043 + // Static display update (fixed frame rate, bounding boxes based)
2044 + // XXX use NQD bounding boxes to help detect dirty areas?
2045 + static void update_display_static_bbox(driver_base *drv)
2046 + {
2047 +        const VIDEO_MODE &mode = drv->mode;
2048 +
2049 +        // Allocate bounding boxes for SDL_UpdateRects()
2050 +        const int N_PIXELS = 64;
2051 +        const int n_x_boxes = (VIDEO_MODE_X + N_PIXELS - 1) / N_PIXELS;
2052 +        const int n_y_boxes = (VIDEO_MODE_Y + N_PIXELS - 1) / N_PIXELS;
2053 +        SDL_Rect *boxes = (SDL_Rect *)alloca(sizeof(SDL_Rect) * n_x_boxes * n_y_boxes);
2054 +        int nr_boxes = 0;
2055 +
2056 +        // Lock surface, if required
2057 +        if (SDL_MUSTLOCK(drv->s))
2058 +                SDL_LockSurface(drv->s);
2059 +
2060 +        // Update the surface from Mac screen
2061 +        const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2062 +        const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2063 +        const int dst_bytes_per_row = drv->s->pitch;
2064 +        int x, y;
2065 +        for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2066 +                int h = N_PIXELS;
2067 +                if (h > VIDEO_MODE_Y - y)
2068 +                        h = VIDEO_MODE_Y - y;
2069 +                for (x = 0; x < VIDEO_MODE_X; x += N_PIXELS) {
2070 +                        int w = N_PIXELS;
2071 +                        if (w > VIDEO_MODE_X - x)
2072 +                                w = VIDEO_MODE_X - x;
2073 +                        const int xs = w * bytes_per_pixel;
2074 +                        const int xb = x * bytes_per_pixel;
2075 +                        bool dirty = false;
2076 +                        for (int j = y; j < (y + h); j++) {
2077 +                                const int yb = j * bytes_per_row;
2078 +                                const int dst_yb = j * dst_bytes_per_row;
2079 +                                if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2080 +                                        memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2081 +                                        Screen_blit((uint8 *)drv->s->pixels + dst_yb + xb, the_buffer + yb + xb, xs);
2082 +                                        dirty = true;
2083 +                                }
2084 +                        }
2085 +                        if (dirty) {
2086 +                                boxes[nr_boxes].x = x;
2087 +                                boxes[nr_boxes].y = y;
2088 +                                boxes[nr_boxes].w = w;
2089 +                                boxes[nr_boxes].h = h;
2090 +                                nr_boxes++;
2091 +                        }
2092 +                }
2093 +        }
2094 +
2095 +        // Unlock surface, if required
2096 +        if (SDL_MUSTLOCK(drv->s))
2097 +                SDL_UnlockSurface(drv->s);
2098 +
2099 +        // Refresh display
2100 +        if (nr_boxes)
2101 +                SDL_UpdateRects(drv->s, nr_boxes, boxes);
2102 + }
2103 +
2104  
2105   // We suggest the compiler to inline the next two functions so that it
2106   // may specialise the code according to the current screen depth and
# Line 2120 | Line 2142 | static inline void handle_palette_change
2142          UNLOCK_PALETTE;
2143   }
2144  
2145 + static void video_refresh_window_static(void);
2146 +
2147   static void video_refresh_dga(void)
2148   {
2149          // Quit DGA mode if requested
2150          possibly_quit_dga_mode();
2151 +        video_refresh_window_static();
2152   }
2153  
2154   #ifdef ENABLE_VOSF
# Line 2139 | Line 2164 | static void video_refresh_dga_vosf(void)
2164                  tick_counter = 0;
2165                  if (mainBuffer.dirty) {
2166                          LOCK_VOSF;
2167 <                        update_display_dga_vosf();
2167 >                        update_display_dga_vosf(static_cast<driver_fullscreen *>(drv));
2168                          UNLOCK_VOSF;
2169                  }
2170          }
# Line 2173 | Line 2198 | static void video_refresh_window_static(
2198          static int tick_counter = 0;
2199          if (++tick_counter >= frame_skip) {
2200                  tick_counter = 0;
2201 <                update_display_static(static_cast<driver_window *>(drv));
2201 >                const VIDEO_MODE &mode = drv->mode;
2202 >                if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2203 >                        update_display_static_bbox(drv);
2204 >                else
2205 >                        update_display_static(drv);
2206          }
2207   }
2208  
# Line 2203 | Line 2232 | static void VideoRefreshInit(void)
2232          }
2233   }
2234  
2235 + static inline void do_video_refresh(void)
2236 + {
2237 +        // Handle SDL events
2238 +        handle_events();
2239 +
2240 +        // Update display
2241 +        video_refresh();
2242 +
2243 + #ifdef SHEEPSHAVER
2244 +        // Set new cursor image if it was changed
2245 +        if (cursor_changed && sdl_cursor) {
2246 +                cursor_changed = false;
2247 +                LOCK_EVENTS;
2248 +                SDL_FreeCursor(sdl_cursor);
2249 +                sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2250 +                if (sdl_cursor) {
2251 +                        SDL_ShowCursor(private_data == NULL || private_data->cursorVisible);
2252 +                        SDL_SetCursor(sdl_cursor);
2253 + #ifdef WIN32
2254 +                        // XXX Windows apparently needs an extra mouse event to
2255 +                        // make the new cursor image visible
2256 +                        int visible = SDL_ShowCursor(-1);
2257 +                        if (visible) {
2258 +                                int x, y;
2259 +                                SDL_GetMouseState(&x, &y);
2260 +                                SDL_WarpMouse(x, y);
2261 +                        }
2262 + #endif
2263 +                }
2264 +                UNLOCK_EVENTS;
2265 +        }
2266 + #endif
2267 +
2268 +        // Set new palette if it was changed
2269 +        handle_palette_changes();
2270 + }
2271 +
2272 + // This function is called on non-threaded platforms from a timer interrupt
2273 + void VideoRefresh(void)
2274 + {
2275 +        // We need to check redraw_thread_active to inhibit refreshed during
2276 +        // mode changes on non-threaded platforms
2277 +        if (!redraw_thread_active)
2278 +                return;
2279 +
2280 +        // Process pending events and update display
2281 +        do_video_refresh();
2282 + }
2283 +
2284   const int VIDEO_REFRESH_HZ = 60;
2285   const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
2286  
2287 + #ifndef USE_CPU_EMUL_SERVICES
2288   static int redraw_func(void *arg)
2289   {
2290          uint64 start = GetTicks_usec();
# Line 2223 | Line 2302 | static int redraw_func(void *arg)
2302                          next = GetTicks_usec();
2303                  ticks++;
2304  
2226                // Handle SDL events
2227                handle_events();
2228
2229                // Refresh display
2230                video_refresh();
2231
2305   #ifdef SHEEPSHAVER
2306 <                // Set new cursor image if it was changed
2307 <                if (cursor_changed && sdl_cursor) {
2308 <                        cursor_changed = false;
2309 <                        SDL_FreeCursor(sdl_cursor);
2237 <                        sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2238 <                        if (sdl_cursor)
2239 <                                SDL_SetCursor(sdl_cursor);
2306 >                // Pause if requested (during video mode switches)
2307 >                if (thread_stop_req) {
2308 >                        thread_stop_ack = true;
2309 >                        continue;
2310                  }
2311   #endif
2312  
2313 <                // Set new palette if it was changed
2314 <                handle_palette_changes();
2313 >                // Process pending events and update display
2314 >                do_video_refresh();
2315          }
2316  
2317          uint64 end = GetTicks_usec();
2318          D(bug("%lld refreshes in %lld usec = %f refreshes/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
2319          return 0;
2320   }
2321 + #endif
2322 +
2323 +
2324 + /*
2325 + *  Record dirty area from NQD
2326 + */
2327 +
2328 + #ifdef SHEEPSHAVER
2329 + void video_set_dirty_area(int x, int y, int w, int h)
2330 + {
2331 + #ifdef ENABLE_VOSF
2332 +        const VIDEO_MODE &mode = drv->mode;
2333 +        const int screen_width = VIDEO_MODE_X;
2334 +        const int screen_height = VIDEO_MODE_Y;
2335 +        const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2336 +
2337 +        if (use_vosf) {
2338 +                vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2339 +                return;
2340 +        }
2341 + #endif
2342 +
2343 +        // XXX handle dirty bounding boxes for non-VOSF modes
2344 + }
2345 + #endif

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines