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.44 by asvitkine, 2011-12-30T15:11:08Z

# 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 + #if (defined(__APPLE__) && defined(__MACH__))
67 + #include "utils_macosx.h"
68 + #endif
69  
70   #define DEBUG 0
71   #include "debug.h"
72  
64
73   // Supported video modes
74   using std::vector;
75   static vector<VIDEO_MODE> VideoModes;
# Line 82 | Line 90 | static int display_type = DISPLAY_WINDOW
90   #endif
91  
92   // Constants
93 + #ifdef WIN32
94 + const char KEYCODE_FILE_NAME[] = "BasiliskII_keycodes";
95 + #else
96   const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
97 + #endif
98  
99  
100   // Global variables
# Line 95 | Line 107 | static uint8 *the_buffer_copy = NULL;
107   static uint32 the_buffer_size;                                          // Size of allocated the_buffer
108  
109   static bool redraw_thread_active = false;                       // Flag: Redraw thread installed
110 + #ifndef USE_CPU_EMUL_SERVICES
111   static volatile bool redraw_thread_cancel;                      // Flag: Cancel Redraw thread
112   static SDL_Thread *redraw_thread = NULL;                        // Redraw thread
113 + #ifdef SHEEPSHAVER
114 + static volatile bool thread_stop_req = false;
115 + static volatile bool thread_stop_ack = false;           // Acknowledge for thread_stop_req
116 + #endif
117 + #endif
118  
119   #ifdef ENABLE_VOSF
120   static bool use_vosf = false;                                           // Flag: VOSF enabled
# Line 121 | Line 139 | static SDL_Cursor *sdl_cursor;                                         // C
139   static volatile bool cursor_changed = false;            // Flag: cursor changed, redraw_func must update the cursor
140   static SDL_Color sdl_palette[256];                                      // Color palette to be used as CLUT and gamma table
141   static bool sdl_palette_changed = false;                        // Flag: Palette changed, redraw thread must set new colors
142 < static const int sdl_eventmask = SDL_MOUSEBUTTONDOWNMASK | SDL_MOUSEBUTTONUPMASK | SDL_MOUSEMOTIONMASK | SDL_KEYUPMASK | SDL_KEYDOWNMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK;
142 > static const int sdl_eventmask = SDL_MOUSEEVENTMASK | SDL_KEYEVENTMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK | SDL_ACTIVEEVENTMASK;
143 >
144 > // Mutex to protect SDL events
145 > static SDL_mutex *sdl_events_lock = NULL;
146 > #define LOCK_EVENTS SDL_LockMutex(sdl_events_lock)
147 > #define UNLOCK_EVENTS SDL_UnlockMutex(sdl_events_lock)
148  
149   // Mutex to protect palette
150   static SDL_mutex *sdl_palette_lock = NULL;
# Line 146 | Line 169 | extern void SysMountFirstFloppy(void);
169  
170  
171   /*
172 + *  SDL surface locking glue
173 + */
174 +
175 + #ifdef ENABLE_VOSF
176 + #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE) do {                               \
177 +        if ((SURFACE)->flags & (SDL_HWSURFACE | SDL_FULLSCREEN))        \
178 +                the_host_buffer = (uint8 *)(SURFACE)->pixels;                   \
179 + } while (0)
180 + #else
181 + #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE)
182 + #endif
183 +
184 + #define SDL_VIDEO_LOCK_SURFACE(SURFACE) do {    \
185 +        if (SDL_MUSTLOCK(SURFACE)) {                            \
186 +                SDL_LockSurface(SURFACE);                               \
187 +                SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE);   \
188 +        }                                                                                       \
189 + } while (0)
190 +
191 + #define SDL_VIDEO_UNLOCK_SURFACE(SURFACE) do {  \
192 +        if (SDL_MUSTLOCK(SURFACE))                                      \
193 +                SDL_UnlockSurface(SURFACE);                             \
194 + } while (0)
195 +
196 +
197 + /*
198 + *  Framebuffer allocation routines
199 + */
200 +
201 + static void *vm_acquire_framebuffer(uint32 size)
202 + {
203 +        // always try to reallocate framebuffer at the same address
204 +        static void *fb = VM_MAP_FAILED;
205 +        if (fb != VM_MAP_FAILED) {
206 +                if (vm_acquire_fixed(fb, size) < 0) {
207 + #ifndef SHEEPSHAVER
208 +                        printf("FATAL: Could not reallocate framebuffer at previous address\n");
209 + #endif
210 +                        fb = VM_MAP_FAILED;
211 +                }
212 +        }
213 +        if (fb == VM_MAP_FAILED)
214 +                fb = vm_acquire(size, VM_MAP_DEFAULT | VM_MAP_32BIT);
215 +        return fb;
216 + }
217 +
218 + static inline void vm_release_framebuffer(void *fb, uint32 size)
219 + {
220 +        vm_release(fb, size);
221 + }
222 +
223 +
224 + /*
225 + *  Windows message handler
226 + */
227 +
228 + #ifdef WIN32
229 + #include <dbt.h>
230 + static WNDPROC sdl_window_proc = NULL;                          // Window proc used by SDL
231 +
232 + extern void SysMediaArrived(void);
233 + extern void SysMediaRemoved(void);
234 + extern HWND GetMainWindowHandle(void);
235 +
236 + static LRESULT CALLBACK windows_message_handler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
237 + {
238 +        switch (msg) {
239 +        case WM_DEVICECHANGE:
240 +                if (wParam == DBT_DEVICEREMOVECOMPLETE) {
241 +                        DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
242 +                        if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
243 +                                SysMediaRemoved();
244 +                }
245 +                else if (wParam == DBT_DEVICEARRIVAL) {
246 +                        DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
247 +                        if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
248 +                                SysMediaArrived();
249 +                }
250 +                return 0;
251 +
252 +        default:
253 +                if (sdl_window_proc)
254 +                        return CallWindowProc(sdl_window_proc, hwnd, msg, wParam, lParam);
255 +        }
256 +
257 +        return DefWindowProc(hwnd, msg, wParam, lParam);
258 + }
259 + #endif
260 +
261 +
262 + /*
263   *  SheepShaver glue
264   */
265  
# Line 190 | Line 304 | static vector<monitor_desc *> VideoMonit
304   // Find Apple mode matching best specified dimensions
305   static int find_apple_resolution(int xsize, int ysize)
306   {
307 <        int apple_id;
308 <        if (xsize < 800)
309 <                apple_id = APPLE_640x480;
310 <        else if (xsize < 1024)
311 <                apple_id = APPLE_800x600;
312 <        else if (xsize < 1152)
313 <                apple_id = APPLE_1024x768;
314 <        else if (xsize < 1280) {
315 <                if (ysize < 900)
316 <                        apple_id = APPLE_1152x768;
317 <                else
318 <                        apple_id = APPLE_1152x900;
319 <        }
320 <        else if (xsize < 1600)
321 <                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;
307 >        if (xsize == 640 && ysize == 480)
308 >                return APPLE_640x480;
309 >        if (xsize == 800 && ysize == 600)
310 >                return APPLE_800x600;
311 >        if (xsize == 1024 && ysize == 768)
312 >                return APPLE_1024x768;
313 >        if (xsize == 1152 && ysize == 768)
314 >                return APPLE_1152x768;
315 >        if (xsize == 1152 && ysize == 900)
316 >                return APPLE_1152x900;
317 >        if (xsize == 1280 && ysize == 1024)
318 >                return APPLE_1280x1024;
319 >        if (xsize == 1600 && ysize == 1200)
320 >                return APPLE_1600x1200;
321 >        return APPLE_CUSTOM;
322   }
323  
324   // Display error alert
# Line 325 | Line 391 | static inline int bytes_per_pixel(int de
391   }
392  
393   // Map video_mode depth ID to numerical depth value
394 < static int sdl_depth_of_video_depth(int video_depth)
394 > static int mac_depth_of_video_depth(int video_depth)
395   {
396          int depth = -1;
397          switch (video_depth) {
# Line 353 | Line 419 | static int sdl_depth_of_video_depth(int
419          return depth;
420   }
421  
422 < // Check wether specified mode is available
423 < static bool has_mode(int type, int width, int height)
422 > // Map video_mode depth ID to SDL screen depth
423 > static int sdl_depth_of_video_depth(int video_depth)
424   {
425 <        // FIXME: no fullscreen support yet
426 <        if (type == DISPLAY_SCREEN)
427 <                return false;
425 >        return (video_depth <= VIDEO_DEPTH_8BIT) ? 8 : mac_depth_of_video_depth(video_depth);
426 > }
427 >
428 > // Get screen dimensions
429 > static void sdl_display_dimensions(int &width, int &height)
430 > {
431 >        static int max_width, max_height;
432 >        if (max_width == 0 && max_height == 0) {
433 >                max_width = 640 ; max_height = 480;
434 >                SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
435 >                if (modes && modes != (SDL_Rect **)-1) {
436 >                        // It turns out that on some implementations, and contrary to the documentation,
437 >                        // the returned list is not sorted from largest to smallest (e.g. Windows)
438 >                        for (int i = 0; modes[i] != NULL; i++) {
439 >                                const int w = modes[i]->w;
440 >                                const int h = modes[i]->h;
441 >                                if (w > max_width && h > max_height) {
442 >                                        max_width = w;
443 >                                        max_height = h;
444 >                                }
445 >                        }
446 >                }
447 >        }
448 >        width = max_width;
449 >        height = max_height;
450 > }
451 >
452 > static inline int sdl_display_width(void)
453 > {
454 >        int width, height;
455 >        sdl_display_dimensions(width, height);
456 >        return width;
457 > }
458 >
459 > static inline int sdl_display_height(void)
460 > {
461 >        int width, height;
462 >        sdl_display_dimensions(width, height);
463 >        return height;
464 > }
465  
466 + // Check wether specified mode is available
467 + static bool has_mode(int type, int width, int height, int depth)
468 + {
469   #ifdef SHEEPSHAVER
470 <        // Filter out Classic resolutiosn
470 >        // Filter out Classic resolutions
471          if (width == 512 && height == 384)
472                  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;
473   #endif
474 <        return false;
474 >
475 >        // Filter out out-of-bounds resolutions
476 >        if (width > sdl_display_width() || height > sdl_display_height())
477 >                return false;
478 >
479 >        // Rely on SDL capabilities
480 >        return SDL_VideoModeOK(width, height,
481 >                                                   sdl_depth_of_video_depth(depth),
482 >                                                   SDL_HWSURFACE | (type == DISPLAY_SCREEN ? SDL_FULLSCREEN : 0));
483   }
484  
485   // Add mode to list of supported modes
486   static void add_mode(int type, int width, int height, int resolution_id, int bytes_per_row, int depth)
487   {
488          // Filter out unsupported modes
489 <        if (!has_mode(type, width, height))
489 >        if (!has_mode(type, width, height, depth))
490                  return;
491  
492          // Fill in VideoMode entry
493          VIDEO_MODE mode;
494   #ifdef SHEEPSHAVER
495 <        // Recalculate dimensions to fit Apple modes
409 <        resolution_id = match_apple_resolution(width, height);
495 >        resolution_id = find_apple_resolution(width, height);
496          mode.viType = type;
497   #endif
498          VIDEO_MODE_X = width;
499          VIDEO_MODE_Y = height;
500          VIDEO_MODE_RESOLUTION = resolution_id;
501          VIDEO_MODE_ROW_BYTES = bytes_per_row;
502 <        VIDEO_MODE_DEPTH = depth;
502 >        VIDEO_MODE_DEPTH = (video_depth)depth;
503          VideoModes.push_back(mode);
504   }
505  
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
506   // Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
507   static void set_mac_frame_buffer(SDL_monitor_desc &monitor, int depth, bool native_byte_order)
508   {
# Line 469 | Line 542 | static void set_window_name(int name)
542   // Set mouse grab mode
543   static SDL_GrabMode set_grab_mode(SDL_GrabMode mode)
544   {
545 <        const SDL_VideoInfo *vi =SDL_GetVideoInfo();
545 >        const SDL_VideoInfo *vi = SDL_GetVideoInfo();
546          return (vi && vi->wm_available ? SDL_WM_GrabInput(mode) : SDL_GRAB_OFF);
547   }
548  
549 + // Migrate preferences items (XXX to be handled in MigratePrefs())
550 + static void migrate_screen_prefs(void)
551 + {
552 + #ifdef SHEEPSHAVER
553 +        // Look-up priorities are: "screen", "screenmodes", "windowmodes".
554 +        if (PrefsFindString("screen"))
555 +                return;
556 +
557 +        uint32 window_modes = PrefsFindInt32("windowmodes");
558 +        uint32 screen_modes = PrefsFindInt32("screenmodes");
559 +        int width = 0, height = 0;
560 +        if (screen_modes) {
561 +                static const struct {
562 +                        int id;
563 +                        int width;
564 +                        int height;
565 +                }
566 +                modes[] = {
567 +                        {  1,    640,    480 },
568 +                        {  2,    800,    600 },
569 +                        {  4,   1024,    768 },
570 +                        { 64,   1152,    768 },
571 +                        {  8,   1152,    900 },
572 +                        { 16,   1280,   1024 },
573 +                        { 32,   1600,   1200 },
574 +                        { 0, }
575 +                };
576 +                for (int i = 0; modes[i].id != 0; i++) {
577 +                        if (screen_modes & modes[i].id) {
578 +                                if (width < modes[i].width && height < modes[i].height) {
579 +                                        width = modes[i].width;
580 +                                        height = modes[i].height;
581 +                                }
582 +                        }
583 +                }
584 +        } else {
585 +                if (window_modes & 1)
586 +                        width = 640, height = 480;
587 +                if (window_modes & 2)
588 +                        width = 800, height = 600;
589 +        }
590 +        if (width && height) {
591 +                char str[32];
592 +                sprintf(str, "%s/%d/%d", screen_modes ? "dga" : "win", width, height);
593 +                PrefsReplaceString("screen", str);
594 +        }
595 + #endif
596 + }
597 +
598  
599   /*
600   *  Display "driver" classes
# Line 506 | Line 628 | public:
628   class driver_window;
629   static void update_display_window_vosf(driver_window *drv);
630   static void update_display_dynamic(int ticker, driver_window *drv);
631 < static void update_display_static(driver_window *drv);
631 > static void update_display_static(driver_base *drv);
632  
633   class driver_window : public driver_base {
634          friend void update_display_window_vosf(driver_window *drv);
635          friend void update_display_dynamic(int ticker, driver_window *drv);
636 <        friend void update_display_static(driver_window *drv);
636 >        friend void update_display_static(driver_base *drv);
637  
638   public:
639          driver_window(SDL_monitor_desc &monitor);
# Line 528 | Line 650 | private:
650          int mouse_last_x, mouse_last_y; // Last mouse position (for relative mode)
651   };
652  
653 + class driver_fullscreen : public driver_base {
654 + public:
655 +        driver_fullscreen(SDL_monitor_desc &monitor);
656 +        ~driver_fullscreen();
657 + };
658 +
659   static driver_base *drv = NULL; // Pointer to currently used driver object
660  
661   #ifdef ENABLE_VOSF
# Line 549 | Line 677 | driver_base::~driver_base()
677          if (s)
678                  SDL_FreeSurface(s);
679  
680 +        // the_buffer shall always be mapped through vm_acquire_framebuffer()
681 +        if (the_buffer != VM_MAP_FAILED) {
682 +                D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
683 +                vm_release_framebuffer(the_buffer, the_buffer_size);
684 +                the_buffer = NULL;
685 +        }
686 +
687          // Free frame buffer(s)
688          if (!use_vosf) {
554                if (the_buffer) {
555                        free(the_buffer);
556                        the_buffer = NULL;
557                }
689                  if (the_buffer_copy) {
690                          free(the_buffer_copy);
691                          the_buffer_copy = NULL;
# Line 562 | Line 693 | driver_base::~driver_base()
693          }
694   #ifdef ENABLE_VOSF
695          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                }
696                  if (the_host_buffer) {
697                          D(bug(" freeing the_host_buffer at %p\n", the_host_buffer));
698                          free(the_host_buffer);
# Line 578 | Line 703 | driver_base::~driver_base()
703                          free(the_buffer_copy);
704                          the_buffer_copy = NULL;
705                  }
706 +
707 +                // Deinitialize VOSF
708 +                video_vosf_exit();
709          }
710   #endif
711   }
# Line 587 | Line 715 | void driver_base::update_palette(void)
715   {
716          const VIDEO_MODE &mode = monitor.get_current_mode();
717  
718 <        if (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
718 >        if ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
719                  SDL_SetPalette(s, SDL_PHYSPAL, sdl_palette, 0, 256);
720   }
721  
# Line 606 | Line 734 | void driver_base::restore_mouse_accel(vo
734   *  Windowed display driver
735   */
736  
737 + static bool SDL_display_opened = false;
738 +
739   // Open display
740   driver_window::driver_window(SDL_monitor_desc &m)
741          : driver_base(m), mouse_grabbed(false)
# Line 617 | Line 747 | driver_window::driver_window(SDL_monitor
747          // Set absolute mouse mode
748          ADBSetRelMouseMode(mouse_grabbed);
749  
750 +        // This is ugly:
751 +        // If we're switching resolutions (ie, not setting it for the first time),
752 +        // there's a bug in SDL where the SDL_Surface created will not be properly
753 +        // setup. The solution is to SDL_QuitSubSystem(SDL_INIT_VIDEO) before calling
754 +        // SDL_SetVideoMode for the second time (SDL_SetVideoMode will call SDL_Init()
755 +        // and all will be well). Without this, the video becomes corrupted (at least
756 +        // on Mac OS X), after the resolution switch.
757 +        if (SDL_display_opened)
758 +                SDL_QuitSubSystem(SDL_INIT_VIDEO);
759 +
760          // Create surface
761 <        int depth = (VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT ? 8 : screen_depth);
761 >        int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
762          if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
763                  return;
764  
765 +        SDL_display_opened = true;
766 +
767   #ifdef ENABLE_VOSF
768          use_vosf = true;
769          // Allocate memory for frame buffer (SIZE is extended to page-boundary)
770          the_host_buffer = (uint8 *)s->pixels;
771          the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
772 <        the_buffer = (uint8 *)vm_acquire(the_buffer_size);
772 >        the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
773          the_buffer_copy = (uint8 *)malloc(the_buffer_size);
774          D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
775  
# Line 651 | Line 793 | driver_window::driver_window(SDL_monitor
793                  // Allocate memory for frame buffer
794                  the_buffer_size = (aligned_height + 2) * s->pitch;
795                  the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
796 <                the_buffer = (uint8 *)calloc(1, the_buffer_size);
796 >                the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
797                  D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
798          }
799          
# Line 676 | Line 818 | driver_window::driver_window(SDL_monitor
818          visualFormat.Rmask = f->Rmask;
819          visualFormat.Gmask = f->Gmask;
820          visualFormat.Bmask = f->Bmask;
821 <        Screen_blitter_init(visualFormat, true, sdl_depth_of_video_depth(VIDEO_MODE_DEPTH));
821 >        Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
822  
823          // Load gray ramp to 8->16/32 expand map
824          if (!IsDirectMode(mode))
# Line 743 | Line 885 | void driver_window::mouse_moved(int x, i
885          ADBMouseMoved(x, y);
886   }
887  
888 +
889 + /*
890 + *  Full-screen display driver
891 + */
892 +
893 + // Open display
894 + driver_fullscreen::driver_fullscreen(SDL_monitor_desc &m)
895 +        : driver_base(m)
896 + {
897 +        int width = VIDEO_MODE_X, height = VIDEO_MODE_Y;
898 +        int aligned_width = (width + 15) & ~15;
899 +        int aligned_height = (height + 15) & ~15;
900 +
901 +        // Set absolute mouse mode
902 +        ADBSetRelMouseMode(false);
903 +
904 +        // Create surface
905 +        int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
906 +        if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE | SDL_FULLSCREEN)) == NULL)
907 +                return;
908 +
909 + #ifdef ENABLE_VOSF
910 +        use_vosf = true;
911 +        // Allocate memory for frame buffer (SIZE is extended to page-boundary)
912 +        the_host_buffer = (uint8 *)s->pixels;
913 +        the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
914 +        the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
915 +        the_buffer_copy = (uint8 *)malloc(the_buffer_size);
916 +        D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
917 +
918 +        // Check whether we can initialize the VOSF subsystem and it's profitable
919 +        if (!video_vosf_init(m)) {
920 +                WarningAlert(STR_VOSF_INIT_ERR);
921 +                use_vosf = false;
922 +        }
923 +        else if (!video_vosf_profitable()) {
924 +                video_vosf_exit();
925 +                printf("VOSF acceleration is not profitable on this platform, disabling it\n");
926 +                use_vosf = false;
927 +        }
928 +        if (!use_vosf) {
929 +                free(the_buffer_copy);
930 +                vm_release(the_buffer, the_buffer_size);
931 +                the_host_buffer = NULL;
932 +        }
933 + #endif
934 +        if (!use_vosf) {
935 +                // Allocate memory for frame buffer
936 +                the_buffer_size = (aligned_height + 2) * s->pitch;
937 +                the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
938 +                the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
939 +                D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
940 +        }
941 +        
942 +        // Hide cursor
943 +        SDL_ShowCursor(0);
944 +
945 +        // Init blitting routines
946 +        SDL_PixelFormat *f = s->format;
947 +        VisualFormat visualFormat;
948 +        visualFormat.depth = depth;
949 +        visualFormat.Rmask = f->Rmask;
950 +        visualFormat.Gmask = f->Gmask;
951 +        visualFormat.Bmask = f->Bmask;
952 +        Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
953 +
954 +        // Load gray ramp to 8->16/32 expand map
955 +        if (!IsDirectMode(mode))
956 +                for (int i=0; i<256; i++)
957 +                        ExpandMap[i] = SDL_MapRGB(f, i, i, i);
958 +
959 +        // Set frame buffer base
960 +        set_mac_frame_buffer(monitor, VIDEO_MODE_DEPTH, true);
961 +
962 +        // Everything went well
963 +        init_ok = true;
964 + }
965 +
966 + // Close display
967 + driver_fullscreen::~driver_fullscreen()
968 + {
969 + #ifdef ENABLE_VOSF
970 +        if (use_vosf)
971 +                the_host_buffer = NULL; // don't free() in driver_base dtor
972 + #endif
973 +        if (s)
974 +                SDL_FreeSurface(s);
975 +
976 +        // Show cursor
977 +        SDL_ShowCursor(1);
978 + }
979 +
980 +
981   /*
982   *  Initialization
983   */
# Line 774 | Line 1009 | static void keycode_init(void)
1009                  SDL_VideoDriverName(video_driver, sizeof(video_driver));
1010                  bool video_driver_found = false;
1011                  char line[256];
1012 +                int n_keys = 0;
1013                  while (fgets(line, sizeof(line) - 1, f)) {
1014                          // Read line
1015                          int len = strlen(line);
# Line 786 | Line 1022 | static void keycode_init(void)
1022                                  continue;
1023  
1024                          if (video_driver_found) {
1025 <                                // Skip aliases
1025 >                                // Skip aliases as long as we have read keycodes yet
1026 >                                // Otherwise, it's another mapping and we have to stop
1027                                  static const char sdl_str[] = "sdl";
1028 <                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0)
1028 >                                if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0 && n_keys == 0)
1029                                          continue;
1030  
1031                                  // Read keycode
1032                                  int x_code, mac_code;
1033                                  if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
1034 <                                        keycode_table[x_code & 0xff] = mac_code;
1034 >                                        keycode_table[x_code & 0xff] = mac_code, n_keys++;
1035                                  else
1036                                          break;
1037                          } else {
# Line 819 | Line 1056 | static void keycode_init(void)
1056                          WarningAlert(str);
1057                          return;
1058                  }
1059 +
1060 +                D(bug("Using SDL/%s keycodes table, %d key mappings\n", video_driver, n_keys));
1061          }
1062   }
1063  
# Line 837 | Line 1076 | bool SDL_monitor_desc::video_open(void)
1076          case DISPLAY_WINDOW:
1077                  drv = new(std::nothrow) driver_window(*this);
1078                  break;
1079 +        case DISPLAY_SCREEN:
1080 +                drv = new(std::nothrow) driver_fullscreen(*this);
1081 +                break;
1082          }
1083          if (drv == NULL)
1084                  return false;
# Line 846 | Line 1088 | bool SDL_monitor_desc::video_open(void)
1088                  return false;
1089          }
1090  
1091 + #ifdef WIN32
1092 +        // Chain in a new message handler for WM_DEVICECHANGE
1093 +        HWND the_window = GetMainWindowHandle();
1094 +        sdl_window_proc = (WNDPROC)GetWindowLongPtr(the_window, GWLP_WNDPROC);
1095 +        SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)windows_message_handler);
1096 + #endif
1097 +
1098          // Initialize VideoRefresh function
1099          VideoRefreshInit();
1100  
# Line 853 | Line 1102 | bool SDL_monitor_desc::video_open(void)
1102          LOCK_FRAME_BUFFER;
1103  
1104          // Start redraw/input thread
1105 + #ifndef USE_CPU_EMUL_SERVICES
1106          redraw_thread_cancel = false;
1107          redraw_thread_active = ((redraw_thread = SDL_CreateThread(redraw_func, NULL)) != NULL);
1108          if (!redraw_thread_active) {
1109                  printf("FATAL: cannot create redraw thread\n");
1110                  return false;
1111          }
1112 + #else
1113 +        redraw_thread_active = true;
1114 + #endif
1115          return true;
1116   }
1117  
# Line 879 | Line 1132 | bool VideoInit(bool classic)
1132   #endif
1133  
1134          // Create Mutexes
1135 +        if ((sdl_events_lock = SDL_CreateMutex()) == NULL)
1136 +                return false;
1137          if ((sdl_palette_lock = SDL_CreateMutex()) == NULL)
1138                  return false;
1139          if ((frame_buffer_lock = SDL_CreateMutex()) == NULL)
# Line 893 | Line 1148 | bool VideoInit(bool classic)
1148          mouse_wheel_lines = PrefsFindInt32("mousewheellines");
1149  
1150          // Get screen mode from preferences
1151 +        migrate_screen_prefs();
1152          const char *mode_str = NULL;
897 #ifndef SHEEPSHAVER
1153          if (classic_mode)
1154                  mode_str = "win/512/342";
1155          else
1156                  mode_str = PrefsFindString("screen");
902 #endif
1157  
1158          // Determine display type and default dimensions
1159          int default_width, default_height;
# Line 915 | Line 1169 | bool VideoInit(bool classic)
1169          if (mode_str) {
1170                  if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2)
1171                          display_type = DISPLAY_WINDOW;
1172 <        }
1173 <        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;
1172 >                else if (sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2)
1173 >                        display_type = DISPLAY_SCREEN;
1174          }
1175          if (default_width <= 0)
1176 <                default_width = max_width;
1176 >                default_width = sdl_display_width();
1177 >        else if (default_width > sdl_display_width())
1178 >                default_width = sdl_display_width();
1179          if (default_height <= 0)
1180 <                default_height = max_height;
1180 >                default_height = sdl_display_height();
1181 >        else if (default_height > sdl_display_height())
1182 >                default_height = sdl_display_height();
1183  
1184          // Mac screen depth follows X depth
1185          screen_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
# Line 949 | Line 1199 | bool VideoInit(bool classic)
1199                  break;
1200          }
1201  
1202 +        // Initialize list of video modes to try
1203 +        struct {
1204 +                int w;
1205 +                int h;
1206 +                int resolution_id;
1207 +        }
1208 +        video_modes[] = {
1209 +                {   -1,   -1, 0x80 },
1210 +                {  512,  384, 0x80 },
1211 +                {  640,  480, 0x81 },
1212 +                {  800,  600, 0x82 },
1213 +                { 1024,  768, 0x83 },
1214 +                { 1152,  870, 0x84 },
1215 +                { 1280, 1024, 0x85 },
1216 +                { 1600, 1200, 0x86 },
1217 +                { 0, }
1218 +        };
1219 +        video_modes[0].w = default_width;
1220 +        video_modes[0].h = default_height;
1221 +
1222          // Construct list of supported modes
1223          if (display_type == DISPLAY_WINDOW) {
1224                  if (classic)
1225                          add_mode(display_type, 512, 342, 0x80, 64, VIDEO_DEPTH_1BIT);
1226                  else {
1227 <                        for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++) {
1228 <                                int bpp = (d <= VIDEO_DEPTH_8BIT ? 8 : sdl_depth_of_video_depth(d));
1229 <                                if (SDL_VideoModeOK(max_width, max_height, bpp, SDL_HWSURFACE))
1230 <                                        add_window_modes(video_depth(d));
1227 >                        for (int i = 0; video_modes[i].w != 0; i++) {
1228 >                                const int w = video_modes[i].w;
1229 >                                const int h = video_modes[i].h;
1230 >                                if (i > 0 && (w >= default_width || h >= default_height))
1231 >                                        continue;
1232 >                                for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1233 >                                        add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1234                          }
1235                  }
1236 <        } else
1237 <                add_mode(display_type, default_width, default_height, 0x80, TrivialBytesPerRow(default_width, (video_depth)default_depth), default_depth);
1236 >        } else if (display_type == DISPLAY_SCREEN) {
1237 >                for (int i = 0; video_modes[i].w != 0; i++) {
1238 >                        const int w = video_modes[i].w;
1239 >                        const int h = video_modes[i].h;
1240 >                        if (i > 0 && (w >= default_width || h >= default_height))
1241 >                                continue;
1242 >                        if (w == 512 && h == 384)
1243 >                                continue;
1244 >                        for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1245 >                                add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1246 >                }
1247 >        }
1248 >
1249          if (VideoModes.empty()) {
1250                  ErrorAlert(STR_NO_XVISUAL_ERR);
1251                  return false;
# Line 1032 | Line 1316 | void SDL_monitor_desc::video_close(void)
1316   {
1317          D(bug("video_close()\n"));
1318  
1319 + #ifdef WIN32
1320 +        // Remove message handler for WM_DEVICECHANGE
1321 +        HWND the_window = GetMainWindowHandle();
1322 +        SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)sdl_window_proc);
1323 + #endif
1324 +
1325          // Stop redraw thread
1326 + #ifndef USE_CPU_EMUL_SERVICES
1327          if (redraw_thread_active) {
1328                  redraw_thread_cancel = true;
1329                  SDL_WaitThread(redraw_thread, NULL);
1330          }
1331 + #endif
1332          redraw_thread_active = false;
1333  
1334          // Unlock frame buffer
1335          UNLOCK_FRAME_BUFFER;
1336          D(bug(" frame buffer unlocked\n"));
1337  
1046 #ifdef ENABLE_VOSF
1047        if (use_vosf) {
1048                // Deinitialize VOSF
1049                video_vosf_exit();
1050        }
1051 #endif
1052
1338          // Close display
1339          delete drv;
1340          drv = NULL;
# Line 1067 | Line 1352 | void VideoExit(void)
1352                  SDL_DestroyMutex(frame_buffer_lock);
1353          if (sdl_palette_lock)
1354                  SDL_DestroyMutex(sdl_palette_lock);
1355 +        if (sdl_events_lock)
1356 +                SDL_DestroyMutex(sdl_events_lock);
1357   }
1358  
1359  
# Line 1147 | Line 1434 | void SDL_monitor_desc::set_palette(uint8
1434          const VIDEO_MODE &mode = get_current_mode();
1435  
1436          // FIXME: how can we handle the gamma ramp?
1437 <        if (VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1437 >        if ((int)VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1438                  return;
1439  
1440          LOCK_PALETTE;
# Line 1208 | Line 1495 | int16 video_mode_change(VidLocals *csSav
1495                          csSave->saveData = ReadMacInt32(ParamPtr + csData);
1496                          csSave->savePage = ReadMacInt16(ParamPtr + csPage);
1497  
1498 <                        // Disable interrupts
1498 >                        // Disable interrupts and pause redraw thread
1499                          DisableInterrupt();
1500 +                        thread_stop_ack = false;
1501 +                        thread_stop_req = true;
1502 +                        while (!thread_stop_ack) ;
1503  
1504                          cur_mode = i;
1505                          monitor_desc *monitor = VideoMonitors[0];
# Line 1220 | Line 1510 | int16 video_mode_change(VidLocals *csSav
1510                          csSave->saveData=VModes[cur_mode].viAppleID;/* First mode ... */
1511                          csSave->saveMode=VModes[cur_mode].viAppleMode;
1512  
1513 <                        // Enable interrupts
1513 >                        // Enable interrupts and resume redraw thread
1514 >                        thread_stop_req = false;
1515                          EnableInterrupt();
1516                          return noErr;
1517                  }
# Line 1232 | Line 1523 | int16 video_mode_change(VidLocals *csSav
1523   void SDL_monitor_desc::switch_to_current_mode(void)
1524   {
1525          // Close and reopen display
1526 +        LOCK_EVENTS;
1527          video_close();
1528          video_open();
1529 +        UNLOCK_EVENTS;
1530  
1531          if (drv == NULL) {
1532                  ErrorAlert(STR_OPEN_WINDOW_ERR);
# Line 1249 | Line 1542 | void SDL_monitor_desc::switch_to_current
1542   #ifdef SHEEPSHAVER
1543   bool video_can_change_cursor(void)
1544   {
1545 <        return (display_type == DISPLAY_WINDOW);
1546 < }
1254 < #endif
1545 >        static char driver[] = "Quartz?";
1546 >        static int quartzok = -1;
1547  
1548 +        if (display_type != DISPLAY_WINDOW)
1549 +                return false;
1550  
1551 < /*
1552 < *  Set cursor image for window
1553 < */
1551 >        if (quartzok < 0) {
1552 >                if (SDL_VideoDriverName(driver, sizeof driver) == NULL || strncmp(driver, "Quartz", sizeof driver))
1553 >                        quartzok = true;
1554 >                else {
1555 >                        // Quartz driver bug prevents cursor changing in SDL 1.2.11 to 1.2.14.
1556 >                        const SDL_version *vp = SDL_Linked_Version();
1557 >                        int version = SDL_VERSIONNUM(vp->major, vp->minor, vp->patch);
1558 >                        quartzok = (version <= SDL_VERSIONNUM(1, 2, 10) || version >= SDL_VERSIONNUM(1, 2, 15));
1559 >                }
1560 >        }
1561  
1562 < #ifdef SHEEPSHAVER
1262 < void video_set_cursor(void)
1263 < {
1264 <        cursor_changed = true;
1562 >        return quartzok;
1563   }
1564   #endif
1565  
1566  
1567   /*
1568 < *  Install graphics acceleration
1568 > *  Set cursor image for window
1569   */
1570  
1571   #ifdef SHEEPSHAVER
1572 < // 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)
1572 > void video_set_cursor(void)
1573   {
1574 <        // 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 <        }
1574 >        cursor_changed = true;
1575   }
1576   #endif
1577  
# Line 1698 | Line 1646 | static int kc_decode(SDL_keysym const &
1646  
1647          case SDLK_1: case SDLK_EXCLAIM: return 0x12;
1648          case SDLK_2: case SDLK_AT: return 0x13;
1649 < //      case SDLK_3: case SDLK_numbersign: return 0x14;
1649 >        case SDLK_3: case SDLK_HASH: return 0x14;
1650          case SDLK_4: case SDLK_DOLLAR: return 0x15;
1651 < //      case SDLK_5: case SDLK_percent: return 0x17;
1651 >        case SDLK_5: return 0x17;
1652          case SDLK_6: return 0x16;
1653          case SDLK_7: return 0x1a;
1654          case SDLK_8: return 0x1c;
1655          case SDLK_9: return 0x19;
1656          case SDLK_0: return 0x1d;
1657  
1658 < //      case SDLK_BACKQUOTE: case SDLK_asciitilde: return 0x0a;
1658 >        case SDLK_BACKQUOTE: return 0x0a;
1659          case SDLK_MINUS: case SDLK_UNDERSCORE: return 0x1b;
1660          case SDLK_EQUALS: case SDLK_PLUS: return 0x18;
1661 < //      case SDLK_bracketleft: case SDLK_braceleft: return 0x21;
1662 < //      case SDLK_bracketright: case SDLK_braceright: return 0x1e;
1663 < //      case SDLK_BACKSLASH: case SDLK_bar: return 0x2a;
1661 >        case SDLK_LEFTBRACKET: return 0x21;
1662 >        case SDLK_RIGHTBRACKET: return 0x1e;
1663 >        case SDLK_BACKSLASH: return 0x2a;
1664          case SDLK_SEMICOLON: case SDLK_COLON: return 0x29;
1665 < //      case SDLK_apostrophe: case SDLK_QUOTEDBL: return 0x27;
1665 >        case SDLK_QUOTE: case SDLK_QUOTEDBL: return 0x27;
1666          case SDLK_COMMA: case SDLK_LESS: return 0x2b;
1667          case SDLK_PERIOD: case SDLK_GREATER: return 0x2f;
1668          case SDLK_SLASH: case SDLK_QUESTION: return 0x2c;
# Line 1746 | Line 1694 | static int kc_decode(SDL_keysym const &
1694          case SDLK_LMETA: return 0x3a;
1695          case SDLK_RMETA: return 0x3a;
1696   #endif
1697 +        case SDLK_LSUPER: return 0x3a; // "Windows" key
1698 +        case SDLK_RSUPER: return 0x3a;
1699          case SDLK_MENU: return 0x32;
1700          case SDLK_CAPSLOCK: return 0x39;
1701          case SDLK_NUMLOCK: return 0x47;
# Line 1820 | Line 1770 | static void handle_events(void)
1770                          // Mouse button
1771                          case SDL_MOUSEBUTTONDOWN: {
1772                                  unsigned int button = event.button.button;
1773 <                                if (button < 4)
1774 <                                        ADBMouseDown(button - 1);
1773 >                                if (button == SDL_BUTTON_LEFT)
1774 >                                        ADBMouseDown(0);
1775 >                                else if (button == SDL_BUTTON_RIGHT)
1776 >                                        ADBMouseDown(1);
1777 >                                else if (button == SDL_BUTTON_MIDDLE)
1778 >                                        ADBMouseDown(2);
1779                                  else if (button < 6) {  // Wheel mouse
1780                                          if (mouse_wheel_mode == 0) {
1781                                                  int key = (button == 5) ? 0x79 : 0x74;  // Page up/down
# Line 1839 | Line 1793 | static void handle_events(void)
1793                          }
1794                          case SDL_MOUSEBUTTONUP: {
1795                                  unsigned int button = event.button.button;
1796 <                                if (button < 4)
1797 <                                        ADBMouseUp(button - 1);
1796 >                                if (button == SDL_BUTTON_LEFT)
1797 >                                        ADBMouseUp(0);
1798 >                                else if (button == SDL_BUTTON_RIGHT)
1799 >                                        ADBMouseUp(1);
1800 >                                else if (button == SDL_BUTTON_MIDDLE)
1801 >                                        ADBMouseUp(2);
1802                                  break;
1803                          }
1804  
# Line 1924 | Line 1882 | static void handle_events(void)
1882                                  ADBKeyDown(0x7f);       // Power key
1883                                  ADBKeyUp(0x7f);
1884                                  break;
1885 +
1886 +                        // Application activate/deactivate; consume the event but otherwise ignore it
1887 +                        case SDL_ACTIVEEVENT:
1888 +                                break;
1889                          }
1890                  }
1891          }
# Line 1935 | Line 1897 | static void handle_events(void)
1897   */
1898  
1899   // Static display update (fixed frame rate, but incremental)
1900 < static void update_display_static(driver_window *drv)
1900 > static void update_display_static(driver_base *drv)
1901   {
1902          // Incremental update code
1903          int wide = 0, high = 0, x1, x2, y1, y2, i, j;
# Line 1962 | Line 1924 | static void update_display_static(driver
1924  
1925          // Check for first column from left and first column from right that have changed
1926          if (high) {
1927 <                if (VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1927 >                if ((int)VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1928                          const int src_bytes_per_row = bytes_per_row;
1929                          const int dst_bytes_per_row = drv->s->pitch;
1930                          const int pixels_per_byte = VIDEO_MODE_X / src_bytes_per_row;
# Line 2024 | Line 1986 | static void update_display_static(driver
1986  
1987                  } else {
1988                          const int bytes_per_pixel = VIDEO_MODE_ROW_BYTES / VIDEO_MODE_X;
1989 +                        const int dst_bytes_per_row = drv->s->pitch;
1990  
1991                          x1 = VIDEO_MODE_X;
1992                          for (j=y1; j<=y2; j++) {
# Line 2064 | Line 2027 | static void update_display_static(driver
2027                                  // Blit to screen surface
2028                                  for (j=y1; j<=y2; j++) {
2029                                          i = j * bytes_per_row + x1 * bytes_per_pixel;
2030 +                                        int dst_i = j * dst_bytes_per_row + x1 * bytes_per_pixel;
2031                                          memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * wide);
2032 <                                        Screen_blit((uint8 *)drv->s->pixels + i, the_buffer + i, bytes_per_pixel * wide);
2032 >                                        Screen_blit((uint8 *)drv->s->pixels + dst_i, the_buffer + i, bytes_per_pixel * wide);
2033                                  }
2034  
2035                                  // Unlock surface, if required
# Line 2079 | Line 2043 | static void update_display_static(driver
2043          }
2044   }
2045  
2046 + // Static display update (fixed frame rate, bounding boxes based)
2047 + // XXX use NQD bounding boxes to help detect dirty areas?
2048 + static void update_display_static_bbox(driver_base *drv)
2049 + {
2050 +        const VIDEO_MODE &mode = drv->mode;
2051 +
2052 +        // Allocate bounding boxes for SDL_UpdateRects()
2053 +        const int N_PIXELS = 64;
2054 +        const int n_x_boxes = (VIDEO_MODE_X + N_PIXELS - 1) / N_PIXELS;
2055 +        const int n_y_boxes = (VIDEO_MODE_Y + N_PIXELS - 1) / N_PIXELS;
2056 +        SDL_Rect *boxes = (SDL_Rect *)alloca(sizeof(SDL_Rect) * n_x_boxes * n_y_boxes);
2057 +        int nr_boxes = 0;
2058 +
2059 +        // Lock surface, if required
2060 +        if (SDL_MUSTLOCK(drv->s))
2061 +                SDL_LockSurface(drv->s);
2062 +
2063 +        // Update the surface from Mac screen
2064 +        const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2065 +        const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2066 +        const int dst_bytes_per_row = drv->s->pitch;
2067 +        int x, y;
2068 +        for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2069 +                int h = N_PIXELS;
2070 +                if (h > VIDEO_MODE_Y - y)
2071 +                        h = VIDEO_MODE_Y - y;
2072 +                for (x = 0; x < VIDEO_MODE_X; x += N_PIXELS) {
2073 +                        int w = N_PIXELS;
2074 +                        if (w > VIDEO_MODE_X - x)
2075 +                                w = VIDEO_MODE_X - x;
2076 +                        const int xs = w * bytes_per_pixel;
2077 +                        const int xb = x * bytes_per_pixel;
2078 +                        bool dirty = false;
2079 +                        for (int j = y; j < (y + h); j++) {
2080 +                                const int yb = j * bytes_per_row;
2081 +                                const int dst_yb = j * dst_bytes_per_row;
2082 +                                if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2083 +                                        memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2084 +                                        Screen_blit((uint8 *)drv->s->pixels + dst_yb + xb, the_buffer + yb + xb, xs);
2085 +                                        dirty = true;
2086 +                                }
2087 +                        }
2088 +                        if (dirty) {
2089 +                                boxes[nr_boxes].x = x;
2090 +                                boxes[nr_boxes].y = y;
2091 +                                boxes[nr_boxes].w = w;
2092 +                                boxes[nr_boxes].h = h;
2093 +                                nr_boxes++;
2094 +                        }
2095 +                }
2096 +        }
2097 +
2098 +        // Unlock surface, if required
2099 +        if (SDL_MUSTLOCK(drv->s))
2100 +                SDL_UnlockSurface(drv->s);
2101 +
2102 +        // Refresh display
2103 +        if (nr_boxes)
2104 +                SDL_UpdateRects(drv->s, nr_boxes, boxes);
2105 + }
2106 +
2107  
2108   // We suggest the compiler to inline the next two functions so that it
2109   // may specialise the code according to the current screen depth and
# Line 2120 | Line 2145 | static inline void handle_palette_change
2145          UNLOCK_PALETTE;
2146   }
2147  
2148 + static void video_refresh_window_static(void);
2149 +
2150   static void video_refresh_dga(void)
2151   {
2152          // Quit DGA mode if requested
2153          possibly_quit_dga_mode();
2154 +        video_refresh_window_static();
2155   }
2156  
2157   #ifdef ENABLE_VOSF
# Line 2139 | Line 2167 | static void video_refresh_dga_vosf(void)
2167                  tick_counter = 0;
2168                  if (mainBuffer.dirty) {
2169                          LOCK_VOSF;
2170 <                        update_display_dga_vosf();
2170 >                        update_display_dga_vosf(static_cast<driver_fullscreen *>(drv));
2171                          UNLOCK_VOSF;
2172                  }
2173          }
# Line 2173 | Line 2201 | static void video_refresh_window_static(
2201          static int tick_counter = 0;
2202          if (++tick_counter >= frame_skip) {
2203                  tick_counter = 0;
2204 <                update_display_static(static_cast<driver_window *>(drv));
2204 >                const VIDEO_MODE &mode = drv->mode;
2205 >                if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2206 >                        update_display_static_bbox(drv);
2207 >                else
2208 >                        update_display_static(drv);
2209          }
2210   }
2211  
# Line 2203 | Line 2235 | static void VideoRefreshInit(void)
2235          }
2236   }
2237  
2238 + static inline void do_video_refresh(void)
2239 + {
2240 +        // Handle SDL events
2241 +        handle_events();
2242 +
2243 +        // Update display
2244 + #if (defined(__APPLE__) && defined(__MACH__))
2245 +        // SDL expects an auto-release pool to be present.
2246 +        NSAutoReleasePool_wrap(video_refresh);
2247 + #else
2248 +        video_refresh();
2249 + #endif
2250 +
2251 + #ifdef SHEEPSHAVER
2252 +        // Set new cursor image if it was changed
2253 +        if (cursor_changed && sdl_cursor) {
2254 +                cursor_changed = false;
2255 +                LOCK_EVENTS;
2256 +                SDL_FreeCursor(sdl_cursor);
2257 +                sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2258 +                if (sdl_cursor) {
2259 +                        SDL_ShowCursor(private_data == NULL || private_data->cursorVisible);
2260 +                        SDL_SetCursor(sdl_cursor);
2261 + #ifdef WIN32
2262 +                        // XXX Windows apparently needs an extra mouse event to
2263 +                        // make the new cursor image visible
2264 +                        int visible = SDL_ShowCursor(-1);
2265 +                        if (visible) {
2266 +                                int x, y;
2267 +                                SDL_GetMouseState(&x, &y);
2268 +                                SDL_WarpMouse(x, y);
2269 +                        }
2270 + #endif
2271 +                }
2272 +                UNLOCK_EVENTS;
2273 +        }
2274 + #endif
2275 +
2276 +        // Set new palette if it was changed
2277 +        handle_palette_changes();
2278 + }
2279 +
2280 + // This function is called on non-threaded platforms from a timer interrupt
2281 + void VideoRefresh(void)
2282 + {
2283 +        // We need to check redraw_thread_active to inhibit refreshed during
2284 +        // mode changes on non-threaded platforms
2285 +        if (!redraw_thread_active)
2286 +                return;
2287 +
2288 +        // Process pending events and update display
2289 +        do_video_refresh();
2290 + }
2291 +
2292   const int VIDEO_REFRESH_HZ = 60;
2293   const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
2294  
2295 + #ifndef USE_CPU_EMUL_SERVICES
2296   static int redraw_func(void *arg)
2297   {
2298          uint64 start = GetTicks_usec();
# Line 2223 | Line 2310 | static int redraw_func(void *arg)
2310                          next = GetTicks_usec();
2311                  ticks++;
2312  
2226                // Handle SDL events
2227                handle_events();
2228
2229                // Refresh display
2230                video_refresh();
2231
2313   #ifdef SHEEPSHAVER
2314 <                // Set new cursor image if it was changed
2315 <                if (cursor_changed && sdl_cursor) {
2316 <                        cursor_changed = false;
2317 <                        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);
2314 >                // Pause if requested (during video mode switches)
2315 >                if (thread_stop_req) {
2316 >                        thread_stop_ack = true;
2317 >                        continue;
2318                  }
2319   #endif
2320  
2321 <                // Set new palette if it was changed
2322 <                handle_palette_changes();
2321 >                // Process pending events and update display
2322 >                do_video_refresh();
2323          }
2324  
2325          uint64 end = GetTicks_usec();
2326          D(bug("%lld refreshes in %lld usec = %f refreshes/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
2327          return 0;
2328   }
2329 + #endif
2330 +
2331 +
2332 + /*
2333 + *  Record dirty area from NQD
2334 + */
2335 +
2336 + #ifdef SHEEPSHAVER
2337 + void video_set_dirty_area(int x, int y, int w, int h)
2338 + {
2339 + #ifdef ENABLE_VOSF
2340 +        const VIDEO_MODE &mode = drv->mode;
2341 +        const int screen_width = VIDEO_MODE_X;
2342 +        const int screen_height = VIDEO_MODE_Y;
2343 +        const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2344 +
2345 +        if (use_vosf) {
2346 +                vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2347 +                return;
2348 +        }
2349 + #endif
2350 +
2351 +        // XXX handle dirty bounding boxes for non-VOSF modes
2352 + }
2353 + #endif

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines