ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/SDL/video_sdl.cpp
Revision: 1.46
Committed: 2012-01-14T15:45:18Z (12 years, 10 months ago) by asvitkine
Branch: MAIN
CVS Tags: HEAD
Changes since 1.45: +5 -5 lines
Log Message:
fix some unused declaration warnings

File Contents

# User Rev Content
1 gbeauche 1.1 /*
2     * video_sdl.cpp - Video/graphics emulation, SDL specific stuff
3     *
4 gbeauche 1.34 * Basilisk II (C) 1997-2008 Christian Bauer
5 gbeauche 1.1 *
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
8     * the Free Software Foundation; either version 2 of the License, or
9     * (at your option) any later version.
10     *
11     * This program is distributed in the hope that it will be useful,
12     * but WITHOUT ANY WARRANTY; without even the implied warranty of
13     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14     * GNU General Public License for more details.
15     *
16     * You should have received a copy of the GNU General Public License
17     * along with this program; if not, write to the Free Software
18     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19     */
20    
21     /*
22     * NOTES:
23     * The Ctrl key works like a qualifier for special actions:
24 gbeauche 1.19 * Ctrl-Tab = suspend DGA mode (TODO)
25 gbeauche 1.1 * Ctrl-Esc = emergency quit
26     * Ctrl-F1 = mount floppy
27     * Ctrl-F5 = grab mouse (in windowed mode)
28     *
29     * FIXMEs and TODOs:
30 gbeauche 1.29 * - Windows requires an extra mouse event to update the actual cursor image?
31 gbeauche 1.19 * - Ctr-Tab for suspend/resume but how? SDL does not support that for non-Linux
32 gbeauche 1.1 * - 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?
35     * - Gamma tables support is likely to be broken here
36 gbeauche 1.2 * - 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.
39 gbeauche 1.6 * - Backport hw cursor acceleration to Basilisk II?
40 gbeauche 1.19 * - Factor out code
41 gbeauche 1.1 */
42    
43     #include "sysdeps.h"
44    
45     #include <SDL.h>
46     #include <SDL_mutex.h>
47     #include <SDL_thread.h>
48     #include <errno.h>
49 gbeauche 1.4 #include <vector>
50 gbeauche 1.1
51 gbeauche 1.28 #ifdef WIN32
52     #include <malloc.h> /* alloca() */
53     #endif
54    
55 gbeauche 1.1 #include "cpu_emulation.h"
56     #include "main.h"
57     #include "adb.h"
58     #include "macos_util.h"
59     #include "prefs.h"
60     #include "user_strings.h"
61     #include "video.h"
62 gbeauche 1.4 #include "video_defs.h"
63 gbeauche 1.1 #include "video_blit.h"
64 gbeauche 1.13 #include "vm_alloc.h"
65 gbeauche 1.1
66     #define DEBUG 0
67     #include "debug.h"
68    
69     // Supported video modes
70 gbeauche 1.4 using std::vector;
71     static vector<VIDEO_MODE> VideoModes;
72 gbeauche 1.1
73     // Display types
74 gbeauche 1.4 #ifdef SHEEPSHAVER
75 gbeauche 1.1 enum {
76 gbeauche 1.4 DISPLAY_WINDOW = DIS_WINDOW, // windowed display
77     DISPLAY_SCREEN = DIS_SCREEN // fullscreen display
78 gbeauche 1.1 };
79 gbeauche 1.4 extern int display_type; // See enum above
80     #else
81     enum {
82     DISPLAY_WINDOW, // windowed display
83     DISPLAY_SCREEN // fullscreen display
84     };
85     static int display_type = DISPLAY_WINDOW; // See enum above
86     #endif
87 gbeauche 1.1
88     // Constants
89 gbeauche 1.16 #ifdef WIN32
90     const char KEYCODE_FILE_NAME[] = "BasiliskII_keycodes";
91     #else
92 gbeauche 1.1 const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
93 gbeauche 1.16 #endif
94 gbeauche 1.1
95    
96     // Global variables
97     static int32 frame_skip; // Prefs items
98     static int16 mouse_wheel_mode;
99     static int16 mouse_wheel_lines;
100    
101     static uint8 *the_buffer = NULL; // Mac frame buffer (where MacOS draws into)
102     static uint8 *the_buffer_copy = NULL; // Copy of Mac frame buffer (for refreshed modes)
103     static uint32 the_buffer_size; // Size of allocated the_buffer
104    
105     static bool redraw_thread_active = false; // Flag: Redraw thread installed
106 gbeauche 1.20 #ifndef USE_CPU_EMUL_SERVICES
107 gbeauche 1.1 static volatile bool redraw_thread_cancel; // Flag: Cancel Redraw thread
108     static SDL_Thread *redraw_thread = NULL; // Redraw thread
109 gbeauche 1.20 #ifdef SHEEPSHAVER
110 gbeauche 1.13 static volatile bool thread_stop_req = false;
111     static volatile bool thread_stop_ack = false; // Acknowledge for thread_stop_req
112 gbeauche 1.20 #endif
113     #endif
114 gbeauche 1.1
115     #ifdef ENABLE_VOSF
116 gbeauche 1.7 static bool use_vosf = false; // Flag: VOSF enabled
117 gbeauche 1.1 #else
118     static const bool use_vosf = false; // VOSF not possible
119     #endif
120    
121     static bool ctrl_down = false; // Flag: Ctrl key pressed
122     static bool caps_on = false; // Flag: Caps Lock on
123     static bool quit_full_screen = false; // Flag: DGA close requested from redraw thread
124     static bool emerg_quit = false; // Flag: Ctrl-Esc pressed, emergency quit requested from MacOS thread
125     static bool emul_suspended = false; // Flag: Emulator suspended
126    
127     static bool classic_mode = false; // Flag: Classic Mac video mode
128    
129     static bool use_keycodes = false; // Flag: Use keycodes rather than keysyms
130     static int keycode_table[256]; // X keycode -> Mac keycode translation table
131    
132     // SDL variables
133     static int screen_depth; // Depth of current screen
134 gbeauche 1.6 static SDL_Cursor *sdl_cursor; // Copy of Mac cursor
135     static volatile bool cursor_changed = false; // Flag: cursor changed, redraw_func must update the cursor
136 gbeauche 1.1 static SDL_Color sdl_palette[256]; // Color palette to be used as CLUT and gamma table
137     static bool sdl_palette_changed = false; // Flag: Palette changed, redraw thread must set new colors
138 asvitkine 1.35 static const int sdl_eventmask = SDL_MOUSEEVENTMASK | SDL_KEYEVENTMASK | SDL_VIDEOEXPOSEMASK | SDL_QUITMASK | SDL_ACTIVEEVENTMASK;
139 gbeauche 1.1
140 gbeauche 1.22 // Mutex to protect SDL events
141     static SDL_mutex *sdl_events_lock = NULL;
142     #define LOCK_EVENTS SDL_LockMutex(sdl_events_lock)
143     #define UNLOCK_EVENTS SDL_UnlockMutex(sdl_events_lock)
144    
145 gbeauche 1.1 // Mutex to protect palette
146     static SDL_mutex *sdl_palette_lock = NULL;
147     #define LOCK_PALETTE SDL_LockMutex(sdl_palette_lock)
148     #define UNLOCK_PALETTE SDL_UnlockMutex(sdl_palette_lock)
149    
150     // Mutex to protect frame buffer
151     static SDL_mutex *frame_buffer_lock = NULL;
152     #define LOCK_FRAME_BUFFER SDL_LockMutex(frame_buffer_lock)
153     #define UNLOCK_FRAME_BUFFER SDL_UnlockMutex(frame_buffer_lock)
154    
155     // Video refresh function
156     static void VideoRefreshInit(void);
157     static void (*video_refresh)(void);
158    
159    
160     // Prototypes
161     static int redraw_func(void *arg);
162    
163     // From sys_unix.cpp
164     extern void SysMountFirstFloppy(void);
165    
166    
167     /*
168 gbeauche 1.21 * SDL surface locking glue
169     */
170    
171     #ifdef ENABLE_VOSF
172     #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE) do { \
173     if ((SURFACE)->flags & (SDL_HWSURFACE | SDL_FULLSCREEN)) \
174     the_host_buffer = (uint8 *)(SURFACE)->pixels; \
175     } while (0)
176     #else
177     #define SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE)
178     #endif
179    
180     #define SDL_VIDEO_LOCK_SURFACE(SURFACE) do { \
181     if (SDL_MUSTLOCK(SURFACE)) { \
182     SDL_LockSurface(SURFACE); \
183     SDL_VIDEO_LOCK_VOSF_SURFACE(SURFACE); \
184     } \
185     } while (0)
186    
187     #define SDL_VIDEO_UNLOCK_SURFACE(SURFACE) do { \
188     if (SDL_MUSTLOCK(SURFACE)) \
189     SDL_UnlockSurface(SURFACE); \
190     } while (0)
191    
192    
193     /*
194 gbeauche 1.13 * Framebuffer allocation routines
195     */
196    
197     static void *vm_acquire_framebuffer(uint32 size)
198     {
199 gbeauche 1.33 // always try to reallocate framebuffer at the same address
200     static void *fb = VM_MAP_FAILED;
201     if (fb != VM_MAP_FAILED) {
202     if (vm_acquire_fixed(fb, size) < 0) {
203     #ifndef SHEEPSHAVER
204     printf("FATAL: Could not reallocate framebuffer at previous address\n");
205     #endif
206     fb = VM_MAP_FAILED;
207     }
208     }
209     if (fb == VM_MAP_FAILED)
210     fb = vm_acquire(size, VM_MAP_DEFAULT | VM_MAP_32BIT);
211     return fb;
212 gbeauche 1.13 }
213    
214     static inline void vm_release_framebuffer(void *fb, uint32 size)
215     {
216     vm_release(fb, size);
217     }
218    
219    
220     /*
221 gbeauche 1.23 * Windows message handler
222     */
223    
224     #ifdef WIN32
225     #include <dbt.h>
226     static WNDPROC sdl_window_proc = NULL; // Window proc used by SDL
227    
228     extern void SysMediaArrived(void);
229     extern void SysMediaRemoved(void);
230     extern HWND GetMainWindowHandle(void);
231    
232     static LRESULT CALLBACK windows_message_handler(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
233     {
234     switch (msg) {
235     case WM_DEVICECHANGE:
236     if (wParam == DBT_DEVICEREMOVECOMPLETE) {
237     DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
238     if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
239     SysMediaRemoved();
240     }
241     else if (wParam == DBT_DEVICEARRIVAL) {
242     DEV_BROADCAST_HDR *p = (DEV_BROADCAST_HDR *)lParam;
243     if (p->dbch_devicetype == DBT_DEVTYP_VOLUME)
244     SysMediaArrived();
245     }
246     return 0;
247    
248     default:
249     if (sdl_window_proc)
250     return CallWindowProc(sdl_window_proc, hwnd, msg, wParam, lParam);
251     }
252    
253     return DefWindowProc(hwnd, msg, wParam, lParam);
254     }
255     #endif
256    
257    
258     /*
259 gbeauche 1.4 * SheepShaver glue
260     */
261    
262     #ifdef SHEEPSHAVER
263     // Color depth modes type
264     typedef int video_depth;
265    
266     // 1, 2, 4 and 8 bit depths use a color palette
267     static inline bool IsDirectMode(VIDEO_MODE const & mode)
268     {
269     return IsDirectMode(mode.viAppleMode);
270     }
271    
272     // Abstract base class representing one (possibly virtual) monitor
273     // ("monitor" = rectangular display with a contiguous frame buffer)
274     class monitor_desc {
275     public:
276     monitor_desc(const vector<VIDEO_MODE> &available_modes, video_depth default_depth, uint32 default_id) {}
277     virtual ~monitor_desc() {}
278    
279     // Get current Mac frame buffer base address
280     uint32 get_mac_frame_base(void) const {return screen_base;}
281    
282     // Set Mac frame buffer base address (called from switch_to_mode())
283     void set_mac_frame_base(uint32 base) {screen_base = base;}
284    
285     // Get current video mode
286     const VIDEO_MODE &get_current_mode(void) const {return VModes[cur_mode];}
287    
288     // Called by the video driver to switch the video mode on this display
289     // (must call set_mac_frame_base())
290     virtual void switch_to_current_mode(void) = 0;
291    
292     // Called by the video driver to set the color palette (in indexed modes)
293     // or the gamma table (in direct modes)
294     virtual void set_palette(uint8 *pal, int num) = 0;
295     };
296    
297     // Vector of pointers to available monitor descriptions, filled by VideoInit()
298     static vector<monitor_desc *> VideoMonitors;
299    
300     // Find Apple mode matching best specified dimensions
301     static int find_apple_resolution(int xsize, int ysize)
302     {
303 gbeauche 1.24 if (xsize == 640 && ysize == 480)
304     return APPLE_640x480;
305     if (xsize == 800 && ysize == 600)
306     return APPLE_800x600;
307     if (xsize == 1024 && ysize == 768)
308     return APPLE_1024x768;
309     if (xsize == 1152 && ysize == 768)
310     return APPLE_1152x768;
311     if (xsize == 1152 && ysize == 900)
312     return APPLE_1152x900;
313     if (xsize == 1280 && ysize == 1024)
314     return APPLE_1280x1024;
315     if (xsize == 1600 && ysize == 1200)
316     return APPLE_1600x1200;
317     return APPLE_CUSTOM;
318 gbeauche 1.4 }
319    
320     // Display error alert
321     static void ErrorAlert(int error)
322     {
323     ErrorAlert(GetString(error));
324     }
325 gbeauche 1.7
326     // Display warning alert
327     static void WarningAlert(int warning)
328     {
329     WarningAlert(GetString(warning));
330     }
331 gbeauche 1.4 #endif
332    
333    
334     /*
335 gbeauche 1.1 * monitor_desc subclass for SDL display
336     */
337    
338     class SDL_monitor_desc : public monitor_desc {
339     public:
340 gbeauche 1.4 SDL_monitor_desc(const vector<VIDEO_MODE> &available_modes, video_depth default_depth, uint32 default_id) : monitor_desc(available_modes, default_depth, default_id) {}
341 gbeauche 1.1 ~SDL_monitor_desc() {}
342    
343     virtual void switch_to_current_mode(void);
344     virtual void set_palette(uint8 *pal, int num);
345    
346     bool video_open(void);
347     void video_close(void);
348     };
349    
350    
351     /*
352     * Utility functions
353     */
354    
355 gbeauche 1.4 // Find palette size for given color depth
356     static int palette_size(int mode)
357     {
358     switch (mode) {
359     case VIDEO_DEPTH_1BIT: return 2;
360     case VIDEO_DEPTH_2BIT: return 4;
361     case VIDEO_DEPTH_4BIT: return 16;
362     case VIDEO_DEPTH_8BIT: return 256;
363     case VIDEO_DEPTH_16BIT: return 32;
364     case VIDEO_DEPTH_32BIT: return 256;
365     default: return 0;
366     }
367     }
368    
369     // Return bytes per pixel for requested depth
370     static inline int bytes_per_pixel(int depth)
371     {
372     int bpp;
373     switch (depth) {
374     case 8:
375     bpp = 1;
376     break;
377     case 15: case 16:
378     bpp = 2;
379     break;
380     case 24: case 32:
381     bpp = 4;
382     break;
383     default:
384     abort();
385     }
386     return bpp;
387     }
388    
389 gbeauche 1.1 // Map video_mode depth ID to numerical depth value
390 gbeauche 1.12 static int mac_depth_of_video_depth(int video_depth)
391 gbeauche 1.1 {
392     int depth = -1;
393     switch (video_depth) {
394 gbeauche 1.4 case VIDEO_DEPTH_1BIT:
395 gbeauche 1.1 depth = 1;
396     break;
397 gbeauche 1.4 case VIDEO_DEPTH_2BIT:
398 gbeauche 1.1 depth = 2;
399     break;
400 gbeauche 1.4 case VIDEO_DEPTH_4BIT:
401 gbeauche 1.1 depth = 4;
402     break;
403 gbeauche 1.4 case VIDEO_DEPTH_8BIT:
404 gbeauche 1.1 depth = 8;
405     break;
406 gbeauche 1.4 case VIDEO_DEPTH_16BIT:
407 gbeauche 1.1 depth = 16;
408     break;
409 gbeauche 1.4 case VIDEO_DEPTH_32BIT:
410 gbeauche 1.1 depth = 32;
411     break;
412     default:
413     abort();
414     }
415     return depth;
416     }
417    
418 gbeauche 1.12 // Map video_mode depth ID to SDL screen depth
419     static int sdl_depth_of_video_depth(int video_depth)
420     {
421     return (video_depth <= VIDEO_DEPTH_8BIT) ? 8 : mac_depth_of_video_depth(video_depth);
422     }
423    
424 gbeauche 1.24 // Get screen dimensions
425     static void sdl_display_dimensions(int &width, int &height)
426     {
427     static int max_width, max_height;
428     if (max_width == 0 && max_height == 0) {
429     max_width = 640 ; max_height = 480;
430     SDL_Rect **modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
431     if (modes && modes != (SDL_Rect **)-1) {
432     // It turns out that on some implementations, and contrary to the documentation,
433     // the returned list is not sorted from largest to smallest (e.g. Windows)
434     for (int i = 0; modes[i] != NULL; i++) {
435     const int w = modes[i]->w;
436     const int h = modes[i]->h;
437     if (w > max_width && h > max_height) {
438     max_width = w;
439     max_height = h;
440     }
441     }
442     }
443     }
444     width = max_width;
445     height = max_height;
446     }
447    
448     static inline int sdl_display_width(void)
449     {
450     int width, height;
451     sdl_display_dimensions(width, height);
452     return width;
453     }
454    
455     static inline int sdl_display_height(void)
456     {
457     int width, height;
458     sdl_display_dimensions(width, height);
459     return height;
460     }
461    
462 gbeauche 1.5 // Check wether specified mode is available
463 gbeauche 1.24 static bool has_mode(int type, int width, int height, int depth)
464 gbeauche 1.5 {
465     #ifdef SHEEPSHAVER
466 gbeauche 1.24 // Filter out Classic resolutions
467 gbeauche 1.5 if (width == 512 && height == 384)
468     return false;
469 gbeauche 1.24 #endif
470 gbeauche 1.5
471 gbeauche 1.24 // Filter out out-of-bounds resolutions
472     if (width > sdl_display_width() || height > sdl_display_height())
473     return false;
474 gbeauche 1.19
475 gbeauche 1.24 // Rely on SDL capabilities
476     return SDL_VideoModeOK(width, height,
477     sdl_depth_of_video_depth(depth),
478     SDL_HWSURFACE | (type == DISPLAY_SCREEN ? SDL_FULLSCREEN : 0));
479 gbeauche 1.5 }
480    
481 gbeauche 1.1 // Add mode to list of supported modes
482 gbeauche 1.4 static void add_mode(int type, int width, int height, int resolution_id, int bytes_per_row, int depth)
483 gbeauche 1.1 {
484 gbeauche 1.5 // Filter out unsupported modes
485 gbeauche 1.24 if (!has_mode(type, width, height, depth))
486 gbeauche 1.5 return;
487    
488     // Fill in VideoMode entry
489 gbeauche 1.4 VIDEO_MODE mode;
490     #ifdef SHEEPSHAVER
491 gbeauche 1.24 resolution_id = find_apple_resolution(width, height);
492 gbeauche 1.4 mode.viType = type;
493     #endif
494     VIDEO_MODE_X = width;
495     VIDEO_MODE_Y = height;
496     VIDEO_MODE_RESOLUTION = resolution_id;
497     VIDEO_MODE_ROW_BYTES = bytes_per_row;
498 gbeauche 1.10 VIDEO_MODE_DEPTH = (video_depth)depth;
499 gbeauche 1.1 VideoModes.push_back(mode);
500     }
501    
502     // Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
503 gbeauche 1.4 static void set_mac_frame_buffer(SDL_monitor_desc &monitor, int depth, bool native_byte_order)
504 gbeauche 1.1 {
505     #if !REAL_ADDRESSING && !DIRECT_ADDRESSING
506     int layout = FLAYOUT_DIRECT;
507 gbeauche 1.4 if (depth == VIDEO_DEPTH_16BIT)
508 gbeauche 1.1 layout = (screen_depth == 15) ? FLAYOUT_HOST_555 : FLAYOUT_HOST_565;
509 gbeauche 1.4 else if (depth == VIDEO_DEPTH_32BIT)
510 gbeauche 1.1 layout = (screen_depth == 24) ? FLAYOUT_HOST_888 : FLAYOUT_DIRECT;
511     if (native_byte_order)
512     MacFrameLayout = layout;
513     else
514     MacFrameLayout = FLAYOUT_DIRECT;
515     monitor.set_mac_frame_base(MacFrameBaseMac);
516    
517     // Set variables used by UAE memory banking
518 gbeauche 1.4 const VIDEO_MODE &mode = monitor.get_current_mode();
519 gbeauche 1.1 MacFrameBaseHost = the_buffer;
520 gbeauche 1.4 MacFrameSize = VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y;
521 gbeauche 1.1 InitFrameBufferMapping();
522     #else
523     monitor.set_mac_frame_base(Host2MacAddr(the_buffer));
524     #endif
525     D(bug("monitor.mac_frame_base = %08x\n", monitor.get_mac_frame_base()));
526     }
527    
528     // Set window name and class
529     static void set_window_name(int name)
530     {
531     const SDL_VideoInfo *vi = SDL_GetVideoInfo();
532     if (vi && vi->wm_available) {
533     const char *str = GetString(name);
534     SDL_WM_SetCaption(str, str);
535     }
536     }
537    
538     // Set mouse grab mode
539     static SDL_GrabMode set_grab_mode(SDL_GrabMode mode)
540     {
541 gbeauche 1.19 const SDL_VideoInfo *vi = SDL_GetVideoInfo();
542 gbeauche 1.1 return (vi && vi->wm_available ? SDL_WM_GrabInput(mode) : SDL_GRAB_OFF);
543     }
544    
545 gbeauche 1.24 // Migrate preferences items (XXX to be handled in MigratePrefs())
546     static void migrate_screen_prefs(void)
547     {
548     #ifdef SHEEPSHAVER
549     // Look-up priorities are: "screen", "screenmodes", "windowmodes".
550     if (PrefsFindString("screen"))
551     return;
552    
553     uint32 window_modes = PrefsFindInt32("windowmodes");
554     uint32 screen_modes = PrefsFindInt32("screenmodes");
555     int width = 0, height = 0;
556     if (screen_modes) {
557     static const struct {
558     int id;
559     int width;
560     int height;
561     }
562     modes[] = {
563     { 1, 640, 480 },
564     { 2, 800, 600 },
565     { 4, 1024, 768 },
566     { 64, 1152, 768 },
567     { 8, 1152, 900 },
568     { 16, 1280, 1024 },
569     { 32, 1600, 1200 },
570     { 0, }
571     };
572     for (int i = 0; modes[i].id != 0; i++) {
573     if (screen_modes & modes[i].id) {
574     if (width < modes[i].width && height < modes[i].height) {
575     width = modes[i].width;
576     height = modes[i].height;
577     }
578     }
579     }
580     } else {
581     if (window_modes & 1)
582     width = 640, height = 480;
583     if (window_modes & 2)
584     width = 800, height = 600;
585     }
586     if (width && height) {
587     char str[32];
588     sprintf(str, "%s/%d/%d", screen_modes ? "dga" : "win", width, height);
589     PrefsReplaceString("screen", str);
590     }
591     #endif
592     }
593    
594 gbeauche 1.1
595     /*
596     * Display "driver" classes
597     */
598    
599     class driver_base {
600     public:
601     driver_base(SDL_monitor_desc &m);
602     virtual ~driver_base();
603    
604     virtual void update_palette(void);
605     virtual void suspend(void) {}
606     virtual void resume(void) {}
607     virtual void toggle_mouse_grab(void) {}
608     virtual void mouse_moved(int x, int y) { ADBMouseMoved(x, y); }
609    
610     void disable_mouse_accel(void);
611     void restore_mouse_accel(void);
612    
613     virtual void grab_mouse(void) {}
614     virtual void ungrab_mouse(void) {}
615    
616     public:
617     SDL_monitor_desc &monitor; // Associated video monitor
618 gbeauche 1.4 const VIDEO_MODE &mode; // Video mode handled by the driver
619 gbeauche 1.1
620     bool init_ok; // Initialization succeeded (we can't use exceptions because of -fomit-frame-pointer)
621     SDL_Surface *s; // The surface we draw into
622     };
623    
624     class driver_window;
625 asvitkine 1.46 #ifdef ENABLE_VOSF
626 gbeauche 1.1 static void update_display_window_vosf(driver_window *drv);
627 asvitkine 1.46 #endif
628 asvitkine 1.38 static void update_display_static(driver_base *drv);
629 gbeauche 1.1
630     class driver_window : public driver_base {
631 asvitkine 1.46 #ifdef ENABLE_VOSF
632 gbeauche 1.1 friend void update_display_window_vosf(driver_window *drv);
633 asvitkine 1.46 #endif
634 asvitkine 1.38 friend void update_display_static(driver_base *drv);
635 gbeauche 1.1
636     public:
637     driver_window(SDL_monitor_desc &monitor);
638     ~driver_window();
639    
640     void toggle_mouse_grab(void);
641     void mouse_moved(int x, int y);
642    
643     void grab_mouse(void);
644     void ungrab_mouse(void);
645    
646     private:
647     bool mouse_grabbed; // Flag: mouse pointer grabbed, using relative mouse mode
648     int mouse_last_x, mouse_last_y; // Last mouse position (for relative mode)
649     };
650    
651 gbeauche 1.19 class driver_fullscreen : public driver_base {
652     public:
653     driver_fullscreen(SDL_monitor_desc &monitor);
654     ~driver_fullscreen();
655     };
656    
657 gbeauche 1.1 static driver_base *drv = NULL; // Pointer to currently used driver object
658    
659     #ifdef ENABLE_VOSF
660     # include "video_vosf.h"
661     #endif
662    
663     driver_base::driver_base(SDL_monitor_desc &m)
664     : monitor(m), mode(m.get_current_mode()), init_ok(false), s(NULL)
665     {
666     the_buffer = NULL;
667     the_buffer_copy = NULL;
668     }
669    
670     driver_base::~driver_base()
671     {
672     ungrab_mouse();
673     restore_mouse_accel();
674    
675     if (s)
676     SDL_FreeSurface(s);
677    
678 gbeauche 1.13 // the_buffer shall always be mapped through vm_acquire_framebuffer()
679     if (the_buffer != VM_MAP_FAILED) {
680     D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
681     vm_release_framebuffer(the_buffer, the_buffer_size);
682     the_buffer = NULL;
683     }
684    
685 gbeauche 1.1 // Free frame buffer(s)
686     if (!use_vosf) {
687     if (the_buffer_copy) {
688     free(the_buffer_copy);
689     the_buffer_copy = NULL;
690     }
691     }
692     #ifdef ENABLE_VOSF
693     else {
694     if (the_host_buffer) {
695     D(bug(" freeing the_host_buffer at %p\n", the_host_buffer));
696     free(the_host_buffer);
697     the_host_buffer = NULL;
698     }
699     if (the_buffer_copy) {
700     D(bug(" freeing the_buffer_copy at %p\n", the_buffer_copy));
701     free(the_buffer_copy);
702     the_buffer_copy = NULL;
703     }
704 gbeauche 1.13
705     // Deinitialize VOSF
706     video_vosf_exit();
707 gbeauche 1.1 }
708     #endif
709     }
710    
711     // Palette has changed
712     void driver_base::update_palette(void)
713     {
714 gbeauche 1.4 const VIDEO_MODE &mode = monitor.get_current_mode();
715 gbeauche 1.1
716 gbeauche 1.10 if ((int)VIDEO_MODE_DEPTH <= VIDEO_DEPTH_8BIT)
717 gbeauche 1.1 SDL_SetPalette(s, SDL_PHYSPAL, sdl_palette, 0, 256);
718     }
719    
720     // Disable mouse acceleration
721     void driver_base::disable_mouse_accel(void)
722     {
723     }
724    
725     // Restore mouse acceleration to original value
726     void driver_base::restore_mouse_accel(void)
727     {
728     }
729    
730    
731     /*
732     * Windowed display driver
733     */
734    
735 gbeauche 1.33 static bool SDL_display_opened = false;
736 asvitkine 1.30
737 gbeauche 1.1 // Open display
738     driver_window::driver_window(SDL_monitor_desc &m)
739     : driver_base(m), mouse_grabbed(false)
740     {
741 gbeauche 1.4 int width = VIDEO_MODE_X, height = VIDEO_MODE_Y;
742 gbeauche 1.1 int aligned_height = (height + 15) & ~15;
743    
744     // Set absolute mouse mode
745     ADBSetRelMouseMode(mouse_grabbed);
746    
747 asvitkine 1.30 // 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 asvitkine 1.32 // 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 asvitkine 1.30
757 gbeauche 1.1 // Create surface
758 gbeauche 1.12 int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
759 gbeauche 1.1 if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE)) == NULL)
760     return;
761    
762 gbeauche 1.33 SDL_display_opened = true;
763 asvitkine 1.30
764 gbeauche 1.1 #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 gbeauche 1.13 the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
770 gbeauche 1.1 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 gbeauche 1.7
773     // Check whether we can initialize the VOSF subsystem and it's profitable
774     if (!video_vosf_init(m)) {
775     WarningAlert(STR_VOSF_INIT_ERR);
776     use_vosf = false;
777     }
778     else if (!video_vosf_profitable()) {
779     video_vosf_exit();
780 gbeauche 1.8 printf("VOSF acceleration is not profitable on this platform, disabling it\n");
781 gbeauche 1.7 use_vosf = false;
782     }
783     if (!use_vosf) {
784     free(the_buffer_copy);
785     vm_release(the_buffer, the_buffer_size);
786     the_host_buffer = NULL;
787     }
788 gbeauche 1.1 #endif
789 gbeauche 1.7 if (!use_vosf) {
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 gbeauche 1.13 the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
794 gbeauche 1.7 D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
795     }
796    
797 gbeauche 1.6 #ifdef SHEEPSHAVER
798     // Create cursor
799     if ((sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, 0, 0)) != NULL) {
800     SDL_SetCursor(sdl_cursor);
801     cursor_changed = false;
802     }
803     #else
804     // Hide cursor
805     SDL_ShowCursor(0);
806     #endif
807    
808 gbeauche 1.1 // Set window name/class
809     set_window_name(STR_WINDOW_TITLE);
810    
811     // Init blitting routines
812     SDL_PixelFormat *f = s->format;
813     VisualFormat visualFormat;
814     visualFormat.depth = depth;
815     visualFormat.Rmask = f->Rmask;
816     visualFormat.Gmask = f->Gmask;
817     visualFormat.Bmask = f->Bmask;
818 gbeauche 1.12 Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
819 gbeauche 1.1
820     // Load gray ramp to 8->16/32 expand map
821     if (!IsDirectMode(mode))
822     for (int i=0; i<256; i++)
823     ExpandMap[i] = SDL_MapRGB(f, i, i, i);
824    
825     // Set frame buffer base
826 gbeauche 1.4 set_mac_frame_buffer(monitor, VIDEO_MODE_DEPTH, true);
827 gbeauche 1.1
828     // Everything went well
829     init_ok = true;
830     }
831    
832     // Close display
833     driver_window::~driver_window()
834     {
835     #ifdef ENABLE_VOSF
836     if (use_vosf)
837     the_host_buffer = NULL; // don't free() in driver_base dtor
838     #endif
839     if (s)
840     SDL_FreeSurface(s);
841     }
842    
843     // Toggle mouse grab
844     void driver_window::toggle_mouse_grab(void)
845     {
846     if (mouse_grabbed)
847     ungrab_mouse();
848     else
849     grab_mouse();
850     }
851    
852     // Grab mouse, switch to relative mouse mode
853     void driver_window::grab_mouse(void)
854     {
855     if (!mouse_grabbed) {
856     SDL_GrabMode new_mode = set_grab_mode(SDL_GRAB_ON);
857     if (new_mode == SDL_GRAB_ON) {
858     set_window_name(STR_WINDOW_TITLE_GRABBED);
859     disable_mouse_accel();
860     mouse_grabbed = true;
861     }
862     }
863     }
864    
865     // Ungrab mouse, switch to absolute mouse mode
866     void driver_window::ungrab_mouse(void)
867     {
868     if (mouse_grabbed) {
869     SDL_GrabMode new_mode = set_grab_mode(SDL_GRAB_OFF);
870     if (new_mode == SDL_GRAB_OFF) {
871     set_window_name(STR_WINDOW_TITLE);
872     restore_mouse_accel();
873     mouse_grabbed = false;
874     }
875     }
876     }
877    
878     // Mouse moved
879     void driver_window::mouse_moved(int x, int y)
880     {
881     mouse_last_x = x; mouse_last_y = y;
882     ADBMouseMoved(x, y);
883     }
884    
885 gbeauche 1.19
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_height = (height + 15) & ~15;
896    
897     // Set absolute mouse mode
898     ADBSetRelMouseMode(false);
899    
900     // Create surface
901     int depth = sdl_depth_of_video_depth(VIDEO_MODE_DEPTH);
902     if ((s = SDL_SetVideoMode(width, height, depth, SDL_HWSURFACE | SDL_FULLSCREEN)) == NULL)
903     return;
904    
905     #ifdef ENABLE_VOSF
906     use_vosf = true;
907     // Allocate memory for frame buffer (SIZE is extended to page-boundary)
908     the_host_buffer = (uint8 *)s->pixels;
909     the_buffer_size = page_extend((aligned_height + 2) * s->pitch);
910     the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
911     the_buffer_copy = (uint8 *)malloc(the_buffer_size);
912     D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
913    
914     // Check whether we can initialize the VOSF subsystem and it's profitable
915     if (!video_vosf_init(m)) {
916     WarningAlert(STR_VOSF_INIT_ERR);
917     use_vosf = false;
918     }
919     else if (!video_vosf_profitable()) {
920     video_vosf_exit();
921     printf("VOSF acceleration is not profitable on this platform, disabling it\n");
922     use_vosf = false;
923     }
924     if (!use_vosf) {
925     free(the_buffer_copy);
926     vm_release(the_buffer, the_buffer_size);
927     the_host_buffer = NULL;
928     }
929     #endif
930     if (!use_vosf) {
931     // Allocate memory for frame buffer
932     the_buffer_size = (aligned_height + 2) * s->pitch;
933     the_buffer_copy = (uint8 *)calloc(1, the_buffer_size);
934     the_buffer = (uint8 *)vm_acquire_framebuffer(the_buffer_size);
935     D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
936     }
937    
938     // Hide cursor
939     SDL_ShowCursor(0);
940    
941     // Init blitting routines
942     SDL_PixelFormat *f = s->format;
943     VisualFormat visualFormat;
944     visualFormat.depth = depth;
945     visualFormat.Rmask = f->Rmask;
946     visualFormat.Gmask = f->Gmask;
947     visualFormat.Bmask = f->Bmask;
948     Screen_blitter_init(visualFormat, true, mac_depth_of_video_depth(VIDEO_MODE_DEPTH));
949    
950     // Load gray ramp to 8->16/32 expand map
951     if (!IsDirectMode(mode))
952     for (int i=0; i<256; i++)
953     ExpandMap[i] = SDL_MapRGB(f, i, i, i);
954    
955     // Set frame buffer base
956     set_mac_frame_buffer(monitor, VIDEO_MODE_DEPTH, true);
957    
958     // Everything went well
959     init_ok = true;
960     }
961    
962     // Close display
963     driver_fullscreen::~driver_fullscreen()
964     {
965     #ifdef ENABLE_VOSF
966     if (use_vosf)
967     the_host_buffer = NULL; // don't free() in driver_base dtor
968     #endif
969     if (s)
970     SDL_FreeSurface(s);
971    
972     // Show cursor
973     SDL_ShowCursor(1);
974     }
975    
976    
977 gbeauche 1.1 /*
978     * Initialization
979     */
980    
981     // Init keycode translation table
982     static void keycode_init(void)
983     {
984     bool use_kc = PrefsFindBool("keycodes");
985     if (use_kc) {
986    
987     // Get keycode file path from preferences
988     const char *kc_path = PrefsFindString("keycodefile");
989    
990     // Open keycode table
991     FILE *f = fopen(kc_path ? kc_path : KEYCODE_FILE_NAME, "r");
992     if (f == NULL) {
993     char str[256];
994     sprintf(str, GetString(STR_KEYCODE_FILE_WARN), kc_path ? kc_path : KEYCODE_FILE_NAME, strerror(errno));
995     WarningAlert(str);
996     return;
997     }
998    
999     // Default translation table
1000     for (int i=0; i<256; i++)
1001     keycode_table[i] = -1;
1002    
1003     // Search for server vendor string, then read keycodes
1004     char video_driver[256];
1005     SDL_VideoDriverName(video_driver, sizeof(video_driver));
1006     bool video_driver_found = false;
1007     char line[256];
1008 gbeauche 1.14 int n_keys = 0;
1009 gbeauche 1.1 while (fgets(line, sizeof(line) - 1, f)) {
1010     // Read line
1011     int len = strlen(line);
1012     if (len == 0)
1013     continue;
1014     line[len-1] = 0;
1015    
1016     // Comments begin with "#" or ";"
1017     if (line[0] == '#' || line[0] == ';' || line[0] == 0)
1018     continue;
1019    
1020     if (video_driver_found) {
1021 gbeauche 1.14 // Skip aliases as long as we have read keycodes yet
1022     // Otherwise, it's another mapping and we have to stop
1023 gbeauche 1.9 static const char sdl_str[] = "sdl";
1024 gbeauche 1.14 if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0 && n_keys == 0)
1025 gbeauche 1.1 continue;
1026    
1027     // Read keycode
1028     int x_code, mac_code;
1029     if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
1030 gbeauche 1.14 keycode_table[x_code & 0xff] = mac_code, n_keys++;
1031 gbeauche 1.1 else
1032     break;
1033     } else {
1034     // Search for SDL video driver string
1035 gbeauche 1.9 static const char sdl_str[] = "sdl";
1036     if (strncmp(line, sdl_str, sizeof(sdl_str) - 1) == 0) {
1037     char *p = line + sizeof(sdl_str);
1038 gbeauche 1.1 if (strstr(video_driver, p) == video_driver)
1039     video_driver_found = true;
1040     }
1041     }
1042     }
1043    
1044     // Keycode file completely read
1045     fclose(f);
1046     use_keycodes = video_driver_found;
1047    
1048     // Vendor not found? Then display warning
1049     if (!video_driver_found) {
1050     char str[256];
1051     sprintf(str, GetString(STR_KEYCODE_VENDOR_WARN), video_driver, kc_path ? kc_path : KEYCODE_FILE_NAME);
1052     WarningAlert(str);
1053     return;
1054     }
1055 gbeauche 1.14
1056     D(bug("Using SDL/%s keycodes table, %d key mappings\n", video_driver, n_keys));
1057 gbeauche 1.1 }
1058     }
1059    
1060     // Open display for current mode
1061     bool SDL_monitor_desc::video_open(void)
1062     {
1063     D(bug("video_open()\n"));
1064 asvitkine 1.46 #if DEBUG
1065 gbeauche 1.4 const VIDEO_MODE &mode = get_current_mode();
1066 gbeauche 1.5 D(bug("Current video mode:\n"));
1067     D(bug(" %dx%d (ID %02x), %d bpp\n", VIDEO_MODE_X, VIDEO_MODE_Y, VIDEO_MODE_RESOLUTION, 1 << (VIDEO_MODE_DEPTH & 0x0f)));
1068     #endif
1069 gbeauche 1.1
1070     // Create display driver object of requested type
1071     switch (display_type) {
1072     case DISPLAY_WINDOW:
1073     drv = new(std::nothrow) driver_window(*this);
1074     break;
1075 gbeauche 1.19 case DISPLAY_SCREEN:
1076     drv = new(std::nothrow) driver_fullscreen(*this);
1077     break;
1078 gbeauche 1.1 }
1079     if (drv == NULL)
1080     return false;
1081     if (!drv->init_ok) {
1082     delete drv;
1083     drv = NULL;
1084     return false;
1085     }
1086    
1087 gbeauche 1.23 #ifdef WIN32
1088     // Chain in a new message handler for WM_DEVICECHANGE
1089     HWND the_window = GetMainWindowHandle();
1090     sdl_window_proc = (WNDPROC)GetWindowLongPtr(the_window, GWLP_WNDPROC);
1091     SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)windows_message_handler);
1092     #endif
1093    
1094 gbeauche 1.1 // Initialize VideoRefresh function
1095     VideoRefreshInit();
1096    
1097     // Lock down frame buffer
1098     LOCK_FRAME_BUFFER;
1099    
1100     // Start redraw/input thread
1101 gbeauche 1.20 #ifndef USE_CPU_EMUL_SERVICES
1102 gbeauche 1.1 redraw_thread_cancel = false;
1103 gbeauche 1.3 redraw_thread_active = ((redraw_thread = SDL_CreateThread(redraw_func, NULL)) != NULL);
1104 gbeauche 1.1 if (!redraw_thread_active) {
1105     printf("FATAL: cannot create redraw thread\n");
1106     return false;
1107     }
1108 gbeauche 1.20 #else
1109     redraw_thread_active = true;
1110     #endif
1111 gbeauche 1.1 return true;
1112     }
1113    
1114 gbeauche 1.4 #ifdef SHEEPSHAVER
1115     bool VideoInit(void)
1116     {
1117     const bool classic = false;
1118     #else
1119 gbeauche 1.1 bool VideoInit(bool classic)
1120     {
1121 gbeauche 1.4 #endif
1122 gbeauche 1.1 classic_mode = classic;
1123    
1124     #ifdef ENABLE_VOSF
1125     // Zero the mainBuffer structure
1126     mainBuffer.dirtyPages = NULL;
1127     mainBuffer.pageInfo = NULL;
1128     #endif
1129    
1130     // Create Mutexes
1131 gbeauche 1.22 if ((sdl_events_lock = SDL_CreateMutex()) == NULL)
1132     return false;
1133 gbeauche 1.1 if ((sdl_palette_lock = SDL_CreateMutex()) == NULL)
1134     return false;
1135     if ((frame_buffer_lock = SDL_CreateMutex()) == NULL)
1136     return false;
1137    
1138     // Init keycode translation
1139     keycode_init();
1140    
1141     // Read prefs
1142     frame_skip = PrefsFindInt32("frameskip");
1143     mouse_wheel_mode = PrefsFindInt32("mousewheelmode");
1144     mouse_wheel_lines = PrefsFindInt32("mousewheellines");
1145    
1146     // Get screen mode from preferences
1147 gbeauche 1.24 migrate_screen_prefs();
1148 gbeauche 1.5 const char *mode_str = NULL;
1149 gbeauche 1.1 if (classic_mode)
1150     mode_str = "win/512/342";
1151     else
1152     mode_str = PrefsFindString("screen");
1153    
1154     // Determine display type and default dimensions
1155 gbeauche 1.4 int default_width, default_height;
1156     if (classic) {
1157     default_width = 512;
1158     default_height = 384;
1159     }
1160     else {
1161     default_width = 640;
1162     default_height = 480;
1163     }
1164 gbeauche 1.1 display_type = DISPLAY_WINDOW;
1165     if (mode_str) {
1166     if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2)
1167     display_type = DISPLAY_WINDOW;
1168 gbeauche 1.19 else if (sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2)
1169     display_type = DISPLAY_SCREEN;
1170 gbeauche 1.1 }
1171     if (default_width <= 0)
1172 gbeauche 1.24 default_width = sdl_display_width();
1173     else if (default_width > sdl_display_width())
1174     default_width = sdl_display_width();
1175 gbeauche 1.1 if (default_height <= 0)
1176 gbeauche 1.24 default_height = sdl_display_height();
1177     else if (default_height > sdl_display_height())
1178     default_height = sdl_display_height();
1179 gbeauche 1.1
1180     // Mac screen depth follows X depth
1181     screen_depth = SDL_GetVideoInfo()->vfmt->BitsPerPixel;
1182 gbeauche 1.4 int default_depth;
1183 gbeauche 1.1 switch (screen_depth) {
1184     case 8:
1185 gbeauche 1.4 default_depth = VIDEO_DEPTH_8BIT;
1186 gbeauche 1.1 break;
1187     case 15: case 16:
1188 gbeauche 1.4 default_depth = VIDEO_DEPTH_16BIT;
1189 gbeauche 1.1 break;
1190     case 24: case 32:
1191 gbeauche 1.4 default_depth = VIDEO_DEPTH_32BIT;
1192 gbeauche 1.1 break;
1193     default:
1194 gbeauche 1.4 default_depth = VIDEO_DEPTH_1BIT;
1195 gbeauche 1.1 break;
1196     }
1197    
1198 gbeauche 1.24 // Initialize list of video modes to try
1199     struct {
1200     int w;
1201     int h;
1202     int resolution_id;
1203     }
1204     video_modes[] = {
1205     { -1, -1, 0x80 },
1206     { 512, 384, 0x80 },
1207     { 640, 480, 0x81 },
1208     { 800, 600, 0x82 },
1209     { 1024, 768, 0x83 },
1210     { 1152, 870, 0x84 },
1211     { 1280, 1024, 0x85 },
1212     { 1600, 1200, 0x86 },
1213     { 0, }
1214     };
1215     video_modes[0].w = default_width;
1216     video_modes[0].h = default_height;
1217    
1218 gbeauche 1.1 // Construct list of supported modes
1219     if (display_type == DISPLAY_WINDOW) {
1220     if (classic)
1221 gbeauche 1.4 add_mode(display_type, 512, 342, 0x80, 64, VIDEO_DEPTH_1BIT);
1222 gbeauche 1.1 else {
1223 gbeauche 1.24 for (int i = 0; video_modes[i].w != 0; i++) {
1224     const int w = video_modes[i].w;
1225     const int h = video_modes[i].h;
1226     if (i > 0 && (w >= default_width || h >= default_height))
1227     continue;
1228     for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1229     add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1230 gbeauche 1.1 }
1231     }
1232 gbeauche 1.19 } else if (display_type == DISPLAY_SCREEN) {
1233     for (int i = 0; video_modes[i].w != 0; i++) {
1234     const int w = video_modes[i].w;
1235     const int h = video_modes[i].h;
1236     if (i > 0 && (w >= default_width || h >= default_height))
1237     continue;
1238 gbeauche 1.24 if (w == 512 && h == 384)
1239     continue;
1240     for (int d = VIDEO_DEPTH_1BIT; d <= default_depth; d++)
1241     add_mode(display_type, w, h, video_modes[i].resolution_id, TrivialBytesPerRow(w, (video_depth)d), d);
1242 gbeauche 1.19 }
1243     }
1244    
1245 gbeauche 1.1 if (VideoModes.empty()) {
1246     ErrorAlert(STR_NO_XVISUAL_ERR);
1247     return false;
1248     }
1249    
1250     // Find requested default mode with specified dimensions
1251     uint32 default_id;
1252 gbeauche 1.4 std::vector<VIDEO_MODE>::const_iterator i, end = VideoModes.end();
1253 gbeauche 1.1 for (i = VideoModes.begin(); i != end; ++i) {
1254 gbeauche 1.4 const VIDEO_MODE & mode = (*i);
1255     if (VIDEO_MODE_X == default_width && VIDEO_MODE_Y == default_height && VIDEO_MODE_DEPTH == default_depth) {
1256     default_id = VIDEO_MODE_RESOLUTION;
1257     #ifdef SHEEPSHAVER
1258     std::vector<VIDEO_MODE>::const_iterator begin = VideoModes.begin();
1259     cur_mode = distance(begin, i);
1260     #endif
1261 gbeauche 1.1 break;
1262     }
1263     }
1264     if (i == end) { // not found, use first available mode
1265 gbeauche 1.4 const VIDEO_MODE & mode = VideoModes[0];
1266     default_depth = VIDEO_MODE_DEPTH;
1267     default_id = VIDEO_MODE_RESOLUTION;
1268     #ifdef SHEEPSHAVER
1269     cur_mode = 0;
1270     #endif
1271 gbeauche 1.1 }
1272    
1273 gbeauche 1.4 #ifdef SHEEPSHAVER
1274 gbeauche 1.5 for (int i = 0; i < VideoModes.size(); i++)
1275 gbeauche 1.4 VModes[i] = VideoModes[i];
1276 gbeauche 1.5 VideoInfo *p = &VModes[VideoModes.size()];
1277     p->viType = DIS_INVALID; // End marker
1278     p->viRowBytes = 0;
1279     p->viXsize = p->viYsize = 0;
1280     p->viAppleMode = 0;
1281     p->viAppleID = 0;
1282 gbeauche 1.4 #endif
1283    
1284 gbeauche 1.1 #if DEBUG
1285     D(bug("Available video modes:\n"));
1286     for (i = VideoModes.begin(); i != end; ++i) {
1287 gbeauche 1.4 const VIDEO_MODE & mode = (*i);
1288     int bits = 1 << VIDEO_MODE_DEPTH;
1289 gbeauche 1.1 if (bits == 16)
1290     bits = 15;
1291     else if (bits == 32)
1292     bits = 24;
1293 gbeauche 1.4 D(bug(" %dx%d (ID %02x), %d colors\n", VIDEO_MODE_X, VIDEO_MODE_Y, VIDEO_MODE_RESOLUTION, 1 << bits));
1294 gbeauche 1.1 }
1295     #endif
1296    
1297     // Create SDL_monitor_desc for this (the only) display
1298 gbeauche 1.4 SDL_monitor_desc *monitor = new SDL_monitor_desc(VideoModes, (video_depth)default_depth, default_id);
1299 gbeauche 1.1 VideoMonitors.push_back(monitor);
1300    
1301     // Open display
1302     return monitor->video_open();
1303     }
1304    
1305    
1306     /*
1307     * Deinitialization
1308     */
1309    
1310     // Close display
1311     void SDL_monitor_desc::video_close(void)
1312     {
1313     D(bug("video_close()\n"));
1314    
1315 gbeauche 1.23 #ifdef WIN32
1316     // Remove message handler for WM_DEVICECHANGE
1317     HWND the_window = GetMainWindowHandle();
1318     SetWindowLongPtr(the_window, GWLP_WNDPROC, (LONG_PTR)sdl_window_proc);
1319     #endif
1320    
1321 gbeauche 1.1 // Stop redraw thread
1322 gbeauche 1.20 #ifndef USE_CPU_EMUL_SERVICES
1323 gbeauche 1.1 if (redraw_thread_active) {
1324     redraw_thread_cancel = true;
1325 gbeauche 1.3 SDL_WaitThread(redraw_thread, NULL);
1326 gbeauche 1.1 }
1327 gbeauche 1.20 #endif
1328 gbeauche 1.1 redraw_thread_active = false;
1329    
1330     // Unlock frame buffer
1331     UNLOCK_FRAME_BUFFER;
1332     D(bug(" frame buffer unlocked\n"));
1333    
1334     // Close display
1335     delete drv;
1336     drv = NULL;
1337     }
1338    
1339     void VideoExit(void)
1340     {
1341     // Close displays
1342     vector<monitor_desc *>::iterator i, end = VideoMonitors.end();
1343     for (i = VideoMonitors.begin(); i != end; ++i)
1344     dynamic_cast<SDL_monitor_desc *>(*i)->video_close();
1345    
1346     // Destroy locks
1347     if (frame_buffer_lock)
1348     SDL_DestroyMutex(frame_buffer_lock);
1349     if (sdl_palette_lock)
1350     SDL_DestroyMutex(sdl_palette_lock);
1351 gbeauche 1.22 if (sdl_events_lock)
1352     SDL_DestroyMutex(sdl_events_lock);
1353 gbeauche 1.1 }
1354    
1355    
1356     /*
1357     * Close down full-screen mode (if bringing up error alerts is unsafe while in full-screen mode)
1358     */
1359    
1360     void VideoQuitFullScreen(void)
1361     {
1362     D(bug("VideoQuitFullScreen()\n"));
1363     quit_full_screen = true;
1364     }
1365    
1366    
1367     /*
1368     * Mac VBL interrupt
1369     */
1370    
1371 gbeauche 1.4 /*
1372     * Execute video VBL routine
1373     */
1374    
1375     #ifdef SHEEPSHAVER
1376     void VideoVBL(void)
1377     {
1378     // Emergency quit requested? Then quit
1379     if (emerg_quit)
1380     QuitEmulator();
1381    
1382     // Temporarily give up frame buffer lock (this is the point where
1383     // we are suspended when the user presses Ctrl-Tab)
1384     UNLOCK_FRAME_BUFFER;
1385     LOCK_FRAME_BUFFER;
1386    
1387     // Execute video VBL
1388     if (private_data != NULL && private_data->interruptsEnabled)
1389     VSLDoInterruptService(private_data->vslServiceID);
1390     }
1391     #else
1392 gbeauche 1.1 void VideoInterrupt(void)
1393     {
1394 gbeauche 1.2 // We must fill in the events queue in the same thread that did call SDL_SetVideoMode()
1395     SDL_PumpEvents();
1396    
1397 gbeauche 1.1 // Emergency quit requested? Then quit
1398     if (emerg_quit)
1399     QuitEmulator();
1400    
1401     // Temporarily give up frame buffer lock (this is the point where
1402     // we are suspended when the user presses Ctrl-Tab)
1403     UNLOCK_FRAME_BUFFER;
1404     LOCK_FRAME_BUFFER;
1405     }
1406 gbeauche 1.4 #endif
1407 gbeauche 1.1
1408    
1409     /*
1410     * Set palette
1411     */
1412    
1413 gbeauche 1.4 #ifdef SHEEPSHAVER
1414     void video_set_palette(void)
1415     {
1416     monitor_desc * monitor = VideoMonitors[0];
1417     int n_colors = palette_size(monitor->get_current_mode().viAppleMode);
1418     uint8 pal[256 * 3];
1419     for (int c = 0; c < n_colors; c++) {
1420     pal[c*3 + 0] = mac_pal[c].red;
1421     pal[c*3 + 1] = mac_pal[c].green;
1422     pal[c*3 + 2] = mac_pal[c].blue;
1423     }
1424     monitor->set_palette(pal, n_colors);
1425     }
1426     #endif
1427    
1428 gbeauche 1.1 void SDL_monitor_desc::set_palette(uint8 *pal, int num_in)
1429     {
1430 gbeauche 1.4 const VIDEO_MODE &mode = get_current_mode();
1431 gbeauche 1.1
1432     // FIXME: how can we handle the gamma ramp?
1433 gbeauche 1.10 if ((int)VIDEO_MODE_DEPTH > VIDEO_DEPTH_8BIT)
1434 gbeauche 1.1 return;
1435    
1436     LOCK_PALETTE;
1437    
1438     // Convert colors to XColor array
1439     int num_out = 256;
1440     bool stretch = false;
1441     SDL_Color *p = sdl_palette;
1442     for (int i=0; i<num_out; i++) {
1443     int c = (stretch ? (i * num_in) / num_out : i);
1444     p->r = pal[c*3 + 0] * 0x0101;
1445     p->g = pal[c*3 + 1] * 0x0101;
1446     p->b = pal[c*3 + 2] * 0x0101;
1447     p++;
1448     }
1449    
1450     // Recalculate pixel color expansion map
1451     if (!IsDirectMode(mode)) {
1452     for (int i=0; i<256; i++) {
1453     int c = i & (num_in-1); // If there are less than 256 colors, we repeat the first entries (this makes color expansion easier)
1454     ExpandMap[i] = SDL_MapRGB(drv->s->format, pal[c*3+0], pal[c*3+1], pal[c*3+2]);
1455     }
1456    
1457     #ifdef ENABLE_VOSF
1458 gbeauche 1.7 if (use_vosf) {
1459     // We have to redraw everything because the interpretation of pixel values changed
1460     LOCK_VOSF;
1461     PFLAG_SET_ALL;
1462     UNLOCK_VOSF;
1463     memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1464     }
1465 gbeauche 1.1 #endif
1466     }
1467    
1468     // Tell redraw thread to change palette
1469     sdl_palette_changed = true;
1470    
1471     UNLOCK_PALETTE;
1472     }
1473    
1474    
1475     /*
1476     * Switch video mode
1477     */
1478    
1479 gbeauche 1.4 #ifdef SHEEPSHAVER
1480     int16 video_mode_change(VidLocals *csSave, uint32 ParamPtr)
1481     {
1482     /* return if no mode change */
1483     if ((csSave->saveData == ReadMacInt32(ParamPtr + csData)) &&
1484     (csSave->saveMode == ReadMacInt16(ParamPtr + csMode))) return noErr;
1485    
1486     /* first find video mode in table */
1487     for (int i=0; VModes[i].viType != DIS_INVALID; i++) {
1488     if ((ReadMacInt16(ParamPtr + csMode) == VModes[i].viAppleMode) &&
1489     (ReadMacInt32(ParamPtr + csData) == VModes[i].viAppleID)) {
1490     csSave->saveMode = ReadMacInt16(ParamPtr + csMode);
1491     csSave->saveData = ReadMacInt32(ParamPtr + csData);
1492     csSave->savePage = ReadMacInt16(ParamPtr + csPage);
1493    
1494 gbeauche 1.13 // Disable interrupts and pause redraw thread
1495 gbeauche 1.4 DisableInterrupt();
1496 gbeauche 1.13 thread_stop_ack = false;
1497     thread_stop_req = true;
1498     while (!thread_stop_ack) ;
1499 gbeauche 1.4
1500     cur_mode = i;
1501     monitor_desc *monitor = VideoMonitors[0];
1502     monitor->switch_to_current_mode();
1503    
1504     WriteMacInt32(ParamPtr + csBaseAddr, screen_base);
1505     csSave->saveBaseAddr=screen_base;
1506     csSave->saveData=VModes[cur_mode].viAppleID;/* First mode ... */
1507     csSave->saveMode=VModes[cur_mode].viAppleMode;
1508    
1509 gbeauche 1.13 // Enable interrupts and resume redraw thread
1510     thread_stop_req = false;
1511 gbeauche 1.4 EnableInterrupt();
1512     return noErr;
1513     }
1514     }
1515     return paramErr;
1516     }
1517     #endif
1518    
1519 gbeauche 1.1 void SDL_monitor_desc::switch_to_current_mode(void)
1520     {
1521     // Close and reopen display
1522 gbeauche 1.22 LOCK_EVENTS;
1523 gbeauche 1.1 video_close();
1524     video_open();
1525 gbeauche 1.22 UNLOCK_EVENTS;
1526 gbeauche 1.1
1527     if (drv == NULL) {
1528     ErrorAlert(STR_OPEN_WINDOW_ERR);
1529     QuitEmulator();
1530     }
1531     }
1532    
1533    
1534     /*
1535 gbeauche 1.4 * Can we set the MacOS cursor image into the window?
1536     */
1537    
1538     #ifdef SHEEPSHAVER
1539     bool video_can_change_cursor(void)
1540     {
1541 asvitkine 1.36 static char driver[] = "Quartz?";
1542     static int quartzok = -1;
1543    
1544     if (display_type != DISPLAY_WINDOW)
1545     return false;
1546    
1547     if (quartzok < 0) {
1548     if (SDL_VideoDriverName(driver, sizeof driver) == NULL || strncmp(driver, "Quartz", sizeof driver))
1549     quartzok = true;
1550     else {
1551 asvitkine 1.44 // Quartz driver bug prevents cursor changing in SDL 1.2.11 to 1.2.14.
1552 asvitkine 1.36 const SDL_version *vp = SDL_Linked_Version();
1553 asvitkine 1.44 int version = SDL_VERSIONNUM(vp->major, vp->minor, vp->patch);
1554     quartzok = (version <= SDL_VERSIONNUM(1, 2, 10) || version >= SDL_VERSIONNUM(1, 2, 15));
1555 asvitkine 1.36 }
1556     }
1557    
1558     return quartzok;
1559 gbeauche 1.4 }
1560     #endif
1561    
1562    
1563     /*
1564     * Set cursor image for window
1565     */
1566    
1567     #ifdef SHEEPSHAVER
1568     void video_set_cursor(void)
1569     {
1570 gbeauche 1.6 cursor_changed = true;
1571 gbeauche 1.4 }
1572     #endif
1573    
1574    
1575     /*
1576 gbeauche 1.9 * Keyboard-related utilify functions
1577 gbeauche 1.1 */
1578    
1579 gbeauche 1.9 static bool is_modifier_key(SDL_KeyboardEvent const & e)
1580     {
1581     switch (e.keysym.sym) {
1582     case SDLK_NUMLOCK:
1583     case SDLK_CAPSLOCK:
1584     case SDLK_SCROLLOCK:
1585     case SDLK_RSHIFT:
1586     case SDLK_LSHIFT:
1587     case SDLK_RCTRL:
1588     case SDLK_LCTRL:
1589     case SDLK_RALT:
1590     case SDLK_LALT:
1591     case SDLK_RMETA:
1592     case SDLK_LMETA:
1593     case SDLK_LSUPER:
1594     case SDLK_RSUPER:
1595     case SDLK_MODE:
1596     case SDLK_COMPOSE:
1597     return true;
1598     }
1599     return false;
1600     }
1601    
1602 gbeauche 1.1 static bool is_ctrl_down(SDL_keysym const & ks)
1603     {
1604     return ctrl_down || (ks.mod & KMOD_CTRL);
1605     }
1606    
1607 gbeauche 1.9
1608     /*
1609     * Translate key event to Mac keycode, returns -1 if no keycode was found
1610     * and -2 if the key was recognized as a hotkey
1611     */
1612    
1613 gbeauche 1.1 static int kc_decode(SDL_keysym const & ks, bool key_down)
1614     {
1615     switch (ks.sym) {
1616     case SDLK_a: return 0x00;
1617     case SDLK_b: return 0x0b;
1618     case SDLK_c: return 0x08;
1619     case SDLK_d: return 0x02;
1620     case SDLK_e: return 0x0e;
1621     case SDLK_f: return 0x03;
1622     case SDLK_g: return 0x05;
1623     case SDLK_h: return 0x04;
1624     case SDLK_i: return 0x22;
1625     case SDLK_j: return 0x26;
1626     case SDLK_k: return 0x28;
1627     case SDLK_l: return 0x25;
1628     case SDLK_m: return 0x2e;
1629     case SDLK_n: return 0x2d;
1630     case SDLK_o: return 0x1f;
1631     case SDLK_p: return 0x23;
1632     case SDLK_q: return 0x0c;
1633     case SDLK_r: return 0x0f;
1634     case SDLK_s: return 0x01;
1635     case SDLK_t: return 0x11;
1636     case SDLK_u: return 0x20;
1637     case SDLK_v: return 0x09;
1638     case SDLK_w: return 0x0d;
1639     case SDLK_x: return 0x07;
1640     case SDLK_y: return 0x10;
1641     case SDLK_z: return 0x06;
1642    
1643     case SDLK_1: case SDLK_EXCLAIM: return 0x12;
1644     case SDLK_2: case SDLK_AT: return 0x13;
1645 gbeauche 1.18 case SDLK_3: case SDLK_HASH: return 0x14;
1646 gbeauche 1.1 case SDLK_4: case SDLK_DOLLAR: return 0x15;
1647 gbeauche 1.18 case SDLK_5: return 0x17;
1648 gbeauche 1.1 case SDLK_6: return 0x16;
1649     case SDLK_7: return 0x1a;
1650     case SDLK_8: return 0x1c;
1651     case SDLK_9: return 0x19;
1652     case SDLK_0: return 0x1d;
1653    
1654 gbeauche 1.18 case SDLK_BACKQUOTE: return 0x0a;
1655 gbeauche 1.1 case SDLK_MINUS: case SDLK_UNDERSCORE: return 0x1b;
1656     case SDLK_EQUALS: case SDLK_PLUS: return 0x18;
1657 gbeauche 1.18 case SDLK_LEFTBRACKET: return 0x21;
1658     case SDLK_RIGHTBRACKET: return 0x1e;
1659     case SDLK_BACKSLASH: return 0x2a;
1660 gbeauche 1.1 case SDLK_SEMICOLON: case SDLK_COLON: return 0x29;
1661 gbeauche 1.18 case SDLK_QUOTE: case SDLK_QUOTEDBL: return 0x27;
1662 gbeauche 1.1 case SDLK_COMMA: case SDLK_LESS: return 0x2b;
1663     case SDLK_PERIOD: case SDLK_GREATER: return 0x2f;
1664     case SDLK_SLASH: case SDLK_QUESTION: return 0x2c;
1665    
1666     case SDLK_TAB: if (is_ctrl_down(ks)) {if (!key_down) drv->suspend(); return -2;} else return 0x30;
1667     case SDLK_RETURN: return 0x24;
1668     case SDLK_SPACE: return 0x31;
1669     case SDLK_BACKSPACE: return 0x33;
1670    
1671     case SDLK_DELETE: return 0x75;
1672     case SDLK_INSERT: return 0x72;
1673     case SDLK_HOME: case SDLK_HELP: return 0x73;
1674     case SDLK_END: return 0x77;
1675     case SDLK_PAGEUP: return 0x74;
1676     case SDLK_PAGEDOWN: return 0x79;
1677    
1678     case SDLK_LCTRL: return 0x36;
1679     case SDLK_RCTRL: return 0x36;
1680     case SDLK_LSHIFT: return 0x38;
1681     case SDLK_RSHIFT: return 0x38;
1682 gbeauche 1.9 #if (defined(__APPLE__) && defined(__MACH__))
1683     case SDLK_LALT: return 0x3a;
1684     case SDLK_RALT: return 0x3a;
1685     case SDLK_LMETA: return 0x37;
1686     case SDLK_RMETA: return 0x37;
1687     #else
1688 gbeauche 1.1 case SDLK_LALT: return 0x37;
1689     case SDLK_RALT: return 0x37;
1690     case SDLK_LMETA: return 0x3a;
1691     case SDLK_RMETA: return 0x3a;
1692 gbeauche 1.9 #endif
1693 gbeauche 1.19 case SDLK_LSUPER: return 0x3a; // "Windows" key
1694     case SDLK_RSUPER: return 0x3a;
1695 gbeauche 1.1 case SDLK_MENU: return 0x32;
1696     case SDLK_CAPSLOCK: return 0x39;
1697     case SDLK_NUMLOCK: return 0x47;
1698    
1699     case SDLK_UP: return 0x3e;
1700     case SDLK_DOWN: return 0x3d;
1701     case SDLK_LEFT: return 0x3b;
1702     case SDLK_RIGHT: return 0x3c;
1703    
1704     case SDLK_ESCAPE: if (is_ctrl_down(ks)) {if (!key_down) { quit_full_screen = true; emerg_quit = true; } return -2;} else return 0x35;
1705    
1706     case SDLK_F1: if (is_ctrl_down(ks)) {if (!key_down) SysMountFirstFloppy(); return -2;} else return 0x7a;
1707     case SDLK_F2: return 0x78;
1708     case SDLK_F3: return 0x63;
1709     case SDLK_F4: return 0x76;
1710     case SDLK_F5: if (is_ctrl_down(ks)) {if (!key_down) drv->toggle_mouse_grab(); return -2;} else return 0x60;
1711     case SDLK_F6: return 0x61;
1712     case SDLK_F7: return 0x62;
1713     case SDLK_F8: return 0x64;
1714     case SDLK_F9: return 0x65;
1715     case SDLK_F10: return 0x6d;
1716     case SDLK_F11: return 0x67;
1717     case SDLK_F12: return 0x6f;
1718    
1719     case SDLK_PRINT: return 0x69;
1720     case SDLK_SCROLLOCK: return 0x6b;
1721     case SDLK_PAUSE: return 0x71;
1722    
1723     case SDLK_KP0: return 0x52;
1724     case SDLK_KP1: return 0x53;
1725     case SDLK_KP2: return 0x54;
1726     case SDLK_KP3: return 0x55;
1727     case SDLK_KP4: return 0x56;
1728     case SDLK_KP5: return 0x57;
1729     case SDLK_KP6: return 0x58;
1730     case SDLK_KP7: return 0x59;
1731     case SDLK_KP8: return 0x5b;
1732     case SDLK_KP9: return 0x5c;
1733     case SDLK_KP_PERIOD: return 0x41;
1734     case SDLK_KP_PLUS: return 0x45;
1735     case SDLK_KP_MINUS: return 0x4e;
1736     case SDLK_KP_MULTIPLY: return 0x43;
1737     case SDLK_KP_DIVIDE: return 0x4b;
1738     case SDLK_KP_ENTER: return 0x4c;
1739     case SDLK_KP_EQUALS: return 0x51;
1740     }
1741     D(bug("Unhandled SDL keysym: %d\n", ks.sym));
1742     return -1;
1743     }
1744    
1745     static int event2keycode(SDL_KeyboardEvent const &ev, bool key_down)
1746     {
1747     return kc_decode(ev.keysym, key_down);
1748     }
1749    
1750    
1751     /*
1752     * SDL event handling
1753     */
1754    
1755     static void handle_events(void)
1756     {
1757 gbeauche 1.2 SDL_Event events[10];
1758     const int n_max_events = sizeof(events) / sizeof(events[0]);
1759     int n_events;
1760    
1761     while ((n_events = SDL_PeepEvents(events, n_max_events, SDL_GETEVENT, sdl_eventmask)) > 0) {
1762     for (int i = 0; i < n_events; i++) {
1763     SDL_Event const & event = events[i];
1764     switch (event.type) {
1765 gbeauche 1.1
1766     // Mouse button
1767     case SDL_MOUSEBUTTONDOWN: {
1768     unsigned int button = event.button.button;
1769 asvitkine 1.37 if (button == SDL_BUTTON_LEFT)
1770     ADBMouseDown(0);
1771     else if (button == SDL_BUTTON_RIGHT)
1772     ADBMouseDown(1);
1773     else if (button == SDL_BUTTON_MIDDLE)
1774     ADBMouseDown(2);
1775 gbeauche 1.1 else if (button < 6) { // Wheel mouse
1776     if (mouse_wheel_mode == 0) {
1777     int key = (button == 5) ? 0x79 : 0x74; // Page up/down
1778     ADBKeyDown(key);
1779     ADBKeyUp(key);
1780     } else {
1781     int key = (button == 5) ? 0x3d : 0x3e; // Cursor up/down
1782     for(int i=0; i<mouse_wheel_lines; i++) {
1783     ADBKeyDown(key);
1784     ADBKeyUp(key);
1785     }
1786     }
1787     }
1788     break;
1789     }
1790     case SDL_MOUSEBUTTONUP: {
1791     unsigned int button = event.button.button;
1792 asvitkine 1.37 if (button == SDL_BUTTON_LEFT)
1793     ADBMouseUp(0);
1794     else if (button == SDL_BUTTON_RIGHT)
1795     ADBMouseUp(1);
1796     else if (button == SDL_BUTTON_MIDDLE)
1797     ADBMouseUp(2);
1798 gbeauche 1.1 break;
1799     }
1800    
1801     // Mouse moved
1802     case SDL_MOUSEMOTION:
1803     drv->mouse_moved(event.motion.x, event.motion.y);
1804     break;
1805    
1806     // Keyboard
1807     case SDL_KEYDOWN: {
1808     int code = -1;
1809 gbeauche 1.9 if (use_keycodes && !is_modifier_key(event.key)) {
1810 gbeauche 1.1 if (event2keycode(event.key, true) != -2) // This is called to process the hotkeys
1811     code = keycode_table[event.key.keysym.scancode & 0xff];
1812     } else
1813     code = event2keycode(event.key, true);
1814     if (code >= 0) {
1815     if (!emul_suspended) {
1816     if (code == 0x39) { // Caps Lock pressed
1817     if (caps_on) {
1818     ADBKeyUp(code);
1819     caps_on = false;
1820     } else {
1821     ADBKeyDown(code);
1822     caps_on = true;
1823     }
1824     } else
1825     ADBKeyDown(code);
1826     if (code == 0x36)
1827     ctrl_down = true;
1828     } else {
1829     if (code == 0x31)
1830     drv->resume(); // Space wakes us up
1831     }
1832     }
1833     break;
1834     }
1835     case SDL_KEYUP: {
1836     int code = -1;
1837 gbeauche 1.9 if (use_keycodes && !is_modifier_key(event.key)) {
1838 gbeauche 1.1 if (event2keycode(event.key, false) != -2) // This is called to process the hotkeys
1839     code = keycode_table[event.key.keysym.scancode & 0xff];
1840     } else
1841     code = event2keycode(event.key, false);
1842 gbeauche 1.9 if (code >= 0) {
1843     if (code == 0x39) { // Caps Lock released
1844     if (caps_on) {
1845     ADBKeyUp(code);
1846     caps_on = false;
1847     } else {
1848     ADBKeyDown(code);
1849     caps_on = true;
1850     }
1851     } else
1852     ADBKeyUp(code);
1853 gbeauche 1.1 if (code == 0x36)
1854     ctrl_down = false;
1855     }
1856     break;
1857     }
1858    
1859     // Hidden parts exposed, force complete refresh of window
1860     case SDL_VIDEOEXPOSE:
1861     if (display_type == DISPLAY_WINDOW) {
1862 gbeauche 1.4 const VIDEO_MODE &mode = VideoMonitors[0]->get_current_mode();
1863 gbeauche 1.1 #ifdef ENABLE_VOSF
1864     if (use_vosf) { // VOSF refresh
1865     LOCK_VOSF;
1866     PFLAG_SET_ALL;
1867     UNLOCK_VOSF;
1868 gbeauche 1.4 memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1869 gbeauche 1.1 }
1870     else
1871     #endif
1872 gbeauche 1.4 memset(the_buffer_copy, 0, VIDEO_MODE_ROW_BYTES * VIDEO_MODE_Y);
1873 gbeauche 1.1 }
1874     break;
1875    
1876     // Window "close" widget clicked
1877     case SDL_QUIT:
1878     ADBKeyDown(0x7f); // Power key
1879     ADBKeyUp(0x7f);
1880     break;
1881 asvitkine 1.35
1882     // Application activate/deactivate; consume the event but otherwise ignore it
1883     case SDL_ACTIVEEVENT:
1884     break;
1885 gbeauche 1.2 }
1886 gbeauche 1.1 }
1887     }
1888     }
1889    
1890    
1891     /*
1892     * Window display update
1893     */
1894    
1895     // Static display update (fixed frame rate, but incremental)
1896 asvitkine 1.38 static void update_display_static(driver_base *drv)
1897 gbeauche 1.1 {
1898     // Incremental update code
1899     int wide = 0, high = 0, x1, x2, y1, y2, i, j;
1900 gbeauche 1.4 const VIDEO_MODE &mode = drv->mode;
1901     int bytes_per_row = VIDEO_MODE_ROW_BYTES;
1902 gbeauche 1.1 uint8 *p, *p2;
1903    
1904     // Check for first line from top and first line from bottom that have changed
1905     y1 = 0;
1906 gbeauche 1.4 for (j=0; j<VIDEO_MODE_Y; j++) {
1907 gbeauche 1.1 if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
1908     y1 = j;
1909     break;
1910     }
1911     }
1912     y2 = y1 - 1;
1913 gbeauche 1.4 for (j=VIDEO_MODE_Y-1; j>=y1; j--) {
1914 gbeauche 1.1 if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
1915     y2 = j;
1916     break;
1917     }
1918     }
1919     high = y2 - y1 + 1;
1920    
1921     // Check for first column from left and first column from right that have changed
1922     if (high) {
1923 gbeauche 1.10 if ((int)VIDEO_MODE_DEPTH < VIDEO_DEPTH_8BIT) {
1924 gbeauche 1.1 const int src_bytes_per_row = bytes_per_row;
1925     const int dst_bytes_per_row = drv->s->pitch;
1926 gbeauche 1.4 const int pixels_per_byte = VIDEO_MODE_X / src_bytes_per_row;
1927 gbeauche 1.1
1928 gbeauche 1.4 x1 = VIDEO_MODE_X / pixels_per_byte;
1929 gbeauche 1.1 for (j = y1; j <= y2; j++) {
1930     p = &the_buffer[j * bytes_per_row];
1931     p2 = &the_buffer_copy[j * bytes_per_row];
1932     for (i = 0; i < x1; i++) {
1933     if (*p != *p2) {
1934     x1 = i;
1935     break;
1936     }
1937     p++; p2++;
1938     }
1939     }
1940     x2 = x1;
1941     for (j = y1; j <= y2; j++) {
1942     p = &the_buffer[j * bytes_per_row];
1943     p2 = &the_buffer_copy[j * bytes_per_row];
1944     p += bytes_per_row;
1945     p2 += bytes_per_row;
1946 gbeauche 1.4 for (i = (VIDEO_MODE_X / pixels_per_byte); i > x2; i--) {
1947 gbeauche 1.1 p--; p2--;
1948     if (*p != *p2) {
1949     x2 = i;
1950     break;
1951     }
1952     }
1953     }
1954     x1 *= pixels_per_byte;
1955     x2 *= pixels_per_byte;
1956     wide = (x2 - x1 + pixels_per_byte - 1) & -pixels_per_byte;
1957    
1958     // Update copy of the_buffer
1959     if (high && wide) {
1960    
1961     // Lock surface, if required
1962     if (SDL_MUSTLOCK(drv->s))
1963     SDL_LockSurface(drv->s);
1964    
1965     // Blit to screen surface
1966     int si = y1 * src_bytes_per_row + (x1 / pixels_per_byte);
1967     int di = y1 * dst_bytes_per_row + x1;
1968     for (j = y1; j <= y2; j++) {
1969     memcpy(the_buffer_copy + si, the_buffer + si, wide / pixels_per_byte);
1970     Screen_blit((uint8 *)drv->s->pixels + di, the_buffer + si, wide / pixels_per_byte);
1971     si += src_bytes_per_row;
1972     di += dst_bytes_per_row;
1973     }
1974    
1975     // Unlock surface, if required
1976     if (SDL_MUSTLOCK(drv->s))
1977     SDL_UnlockSurface(drv->s);
1978    
1979     // Refresh display
1980     SDL_UpdateRect(drv->s, x1, y1, wide, high);
1981     }
1982    
1983     } else {
1984 gbeauche 1.4 const int bytes_per_pixel = VIDEO_MODE_ROW_BYTES / VIDEO_MODE_X;
1985 asvitkine 1.38 const int dst_bytes_per_row = drv->s->pitch;
1986 gbeauche 1.1
1987 gbeauche 1.4 x1 = VIDEO_MODE_X;
1988 gbeauche 1.1 for (j=y1; j<=y2; j++) {
1989     p = &the_buffer[j * bytes_per_row];
1990     p2 = &the_buffer_copy[j * bytes_per_row];
1991     for (i=0; i<x1*bytes_per_pixel; i++) {
1992     if (*p != *p2) {
1993     x1 = i / bytes_per_pixel;
1994     break;
1995     }
1996     p++; p2++;
1997     }
1998     }
1999     x2 = x1;
2000     for (j=y1; j<=y2; j++) {
2001     p = &the_buffer[j * bytes_per_row];
2002     p2 = &the_buffer_copy[j * bytes_per_row];
2003     p += bytes_per_row;
2004     p2 += bytes_per_row;
2005 gbeauche 1.4 for (i=VIDEO_MODE_X*bytes_per_pixel; i>x2*bytes_per_pixel; i--) {
2006 gbeauche 1.1 p--;
2007     p2--;
2008     if (*p != *p2) {
2009     x2 = i / bytes_per_pixel;
2010     break;
2011     }
2012     }
2013     }
2014     wide = x2 - x1;
2015    
2016     // Update copy of the_buffer
2017     if (high && wide) {
2018    
2019     // Lock surface, if required
2020     if (SDL_MUSTLOCK(drv->s))
2021     SDL_LockSurface(drv->s);
2022    
2023     // Blit to screen surface
2024     for (j=y1; j<=y2; j++) {
2025     i = j * bytes_per_row + x1 * bytes_per_pixel;
2026 asvitkine 1.38 int dst_i = j * dst_bytes_per_row + x1 * bytes_per_pixel;
2027 gbeauche 1.1 memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * wide);
2028 asvitkine 1.38 Screen_blit((uint8 *)drv->s->pixels + dst_i, the_buffer + i, bytes_per_pixel * wide);
2029 gbeauche 1.1 }
2030    
2031     // Unlock surface, if required
2032     if (SDL_MUSTLOCK(drv->s))
2033     SDL_UnlockSurface(drv->s);
2034    
2035     // Refresh display
2036     SDL_UpdateRect(drv->s, x1, y1, wide, high);
2037     }
2038     }
2039     }
2040     }
2041    
2042 gbeauche 1.25 // Static display update (fixed frame rate, bounding boxes based)
2043     // XXX use NQD bounding boxes to help detect dirty areas?
2044 asvitkine 1.38 static void update_display_static_bbox(driver_base *drv)
2045 gbeauche 1.25 {
2046     const VIDEO_MODE &mode = drv->mode;
2047    
2048     // Allocate bounding boxes for SDL_UpdateRects()
2049     const int N_PIXELS = 64;
2050     const int n_x_boxes = (VIDEO_MODE_X + N_PIXELS - 1) / N_PIXELS;
2051     const int n_y_boxes = (VIDEO_MODE_Y + N_PIXELS - 1) / N_PIXELS;
2052     SDL_Rect *boxes = (SDL_Rect *)alloca(sizeof(SDL_Rect) * n_x_boxes * n_y_boxes);
2053     int nr_boxes = 0;
2054    
2055     // Lock surface, if required
2056     if (SDL_MUSTLOCK(drv->s))
2057     SDL_LockSurface(drv->s);
2058    
2059     // Update the surface from Mac screen
2060     const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2061     const int bytes_per_pixel = bytes_per_row / VIDEO_MODE_X;
2062 asvitkine 1.38 const int dst_bytes_per_row = drv->s->pitch;
2063 gbeauche 1.25 int x, y;
2064     for (y = 0; y < VIDEO_MODE_Y; y += N_PIXELS) {
2065     int h = N_PIXELS;
2066     if (h > VIDEO_MODE_Y - y)
2067     h = VIDEO_MODE_Y - y;
2068     for (x = 0; x < VIDEO_MODE_X; x += N_PIXELS) {
2069     int w = N_PIXELS;
2070     if (w > VIDEO_MODE_X - x)
2071     w = VIDEO_MODE_X - x;
2072     const int xs = w * bytes_per_pixel;
2073     const int xb = x * bytes_per_pixel;
2074     bool dirty = false;
2075     for (int j = y; j < (y + h); j++) {
2076     const int yb = j * bytes_per_row;
2077 asvitkine 1.38 const int dst_yb = j * dst_bytes_per_row;
2078 gbeauche 1.25 if (memcmp(&the_buffer[yb + xb], &the_buffer_copy[yb + xb], xs) != 0) {
2079     memcpy(&the_buffer_copy[yb + xb], &the_buffer[yb + xb], xs);
2080 asvitkine 1.38 Screen_blit((uint8 *)drv->s->pixels + dst_yb + xb, the_buffer + yb + xb, xs);
2081 gbeauche 1.25 dirty = true;
2082     }
2083     }
2084     if (dirty) {
2085     boxes[nr_boxes].x = x;
2086     boxes[nr_boxes].y = y;
2087     boxes[nr_boxes].w = w;
2088     boxes[nr_boxes].h = h;
2089     nr_boxes++;
2090     }
2091     }
2092     }
2093    
2094     // Unlock surface, if required
2095     if (SDL_MUSTLOCK(drv->s))
2096     SDL_UnlockSurface(drv->s);
2097    
2098     // Refresh display
2099     if (nr_boxes)
2100     SDL_UpdateRects(drv->s, nr_boxes, boxes);
2101     }
2102    
2103 gbeauche 1.1
2104     // We suggest the compiler to inline the next two functions so that it
2105     // may specialise the code according to the current screen depth and
2106     // display type. A clever compiler would do that job by itself though...
2107    
2108     // NOTE: update_display_vosf is inlined too
2109    
2110     static inline void possibly_quit_dga_mode()
2111     {
2112     // Quit DGA mode if requested (something terrible has happened and we
2113     // want to give control back to the user)
2114     if (quit_full_screen) {
2115     quit_full_screen = false;
2116     delete drv;
2117     drv = NULL;
2118     }
2119     }
2120    
2121     static inline void possibly_ungrab_mouse()
2122     {
2123     // Ungrab mouse if requested (something terrible has happened and we
2124     // want to give control back to the user)
2125     if (quit_full_screen) {
2126     quit_full_screen = false;
2127     if (drv)
2128     drv->ungrab_mouse();
2129     }
2130     }
2131    
2132     static inline void handle_palette_changes(void)
2133     {
2134     LOCK_PALETTE;
2135    
2136     if (sdl_palette_changed) {
2137     sdl_palette_changed = false;
2138     drv->update_palette();
2139     }
2140    
2141     UNLOCK_PALETTE;
2142     }
2143    
2144 asvitkine 1.38 static void video_refresh_window_static(void);
2145    
2146 gbeauche 1.1 static void video_refresh_dga(void)
2147     {
2148     // Quit DGA mode if requested
2149     possibly_quit_dga_mode();
2150 asvitkine 1.38 video_refresh_window_static();
2151 gbeauche 1.1 }
2152    
2153     #ifdef ENABLE_VOSF
2154     #if REAL_ADDRESSING || DIRECT_ADDRESSING
2155     static void video_refresh_dga_vosf(void)
2156     {
2157     // Quit DGA mode if requested
2158     possibly_quit_dga_mode();
2159    
2160     // Update display (VOSF variant)
2161     static int tick_counter = 0;
2162     if (++tick_counter >= frame_skip) {
2163     tick_counter = 0;
2164     if (mainBuffer.dirty) {
2165     LOCK_VOSF;
2166 gbeauche 1.19 update_display_dga_vosf(static_cast<driver_fullscreen *>(drv));
2167 gbeauche 1.1 UNLOCK_VOSF;
2168     }
2169     }
2170     }
2171     #endif
2172    
2173     static void video_refresh_window_vosf(void)
2174     {
2175     // Ungrab mouse if requested
2176     possibly_ungrab_mouse();
2177    
2178     // Update display (VOSF variant)
2179     static int tick_counter = 0;
2180     if (++tick_counter >= frame_skip) {
2181     tick_counter = 0;
2182     if (mainBuffer.dirty) {
2183     LOCK_VOSF;
2184     update_display_window_vosf(static_cast<driver_window *>(drv));
2185     UNLOCK_VOSF;
2186     }
2187     }
2188     }
2189     #endif // def ENABLE_VOSF
2190    
2191     static void video_refresh_window_static(void)
2192     {
2193     // Ungrab mouse if requested
2194     possibly_ungrab_mouse();
2195    
2196     // Update display (static variant)
2197     static int tick_counter = 0;
2198     if (++tick_counter >= frame_skip) {
2199     tick_counter = 0;
2200 gbeauche 1.25 const VIDEO_MODE &mode = drv->mode;
2201     if ((int)VIDEO_MODE_DEPTH >= VIDEO_DEPTH_8BIT)
2202 asvitkine 1.38 update_display_static_bbox(drv);
2203 gbeauche 1.25 else
2204 asvitkine 1.38 update_display_static(drv);
2205 gbeauche 1.1 }
2206     }
2207    
2208    
2209     /*
2210     * Thread for screen refresh, input handling etc.
2211     */
2212    
2213     static void VideoRefreshInit(void)
2214     {
2215     // TODO: set up specialised 8bpp VideoRefresh handlers ?
2216     if (display_type == DISPLAY_SCREEN) {
2217     #if ENABLE_VOSF && (REAL_ADDRESSING || DIRECT_ADDRESSING)
2218     if (use_vosf)
2219     video_refresh = video_refresh_dga_vosf;
2220     else
2221     #endif
2222     video_refresh = video_refresh_dga;
2223     }
2224     else {
2225     #ifdef ENABLE_VOSF
2226     if (use_vosf)
2227     video_refresh = video_refresh_window_vosf;
2228     else
2229     #endif
2230     video_refresh = video_refresh_window_static;
2231     }
2232     }
2233    
2234 gbeauche 1.20 static inline void do_video_refresh(void)
2235     {
2236     // Handle SDL events
2237     handle_events();
2238    
2239     // Update display
2240     video_refresh();
2241    
2242     #ifdef SHEEPSHAVER
2243     // Set new cursor image if it was changed
2244     if (cursor_changed && sdl_cursor) {
2245     cursor_changed = false;
2246 gbeauche 1.22 LOCK_EVENTS;
2247 gbeauche 1.20 SDL_FreeCursor(sdl_cursor);
2248     sdl_cursor = SDL_CreateCursor(MacCursor + 4, MacCursor + 36, 16, 16, MacCursor[2], MacCursor[3]);
2249 gbeauche 1.29 if (sdl_cursor) {
2250 asvitkine 1.36 SDL_ShowCursor(private_data == NULL || private_data->cursorVisible);
2251 gbeauche 1.20 SDL_SetCursor(sdl_cursor);
2252 gbeauche 1.29 #ifdef WIN32
2253     // XXX Windows apparently needs an extra mouse event to
2254     // make the new cursor image visible
2255     int visible = SDL_ShowCursor(-1);
2256     if (visible) {
2257     int x, y;
2258     SDL_GetMouseState(&x, &y);
2259     SDL_WarpMouse(x, y);
2260     }
2261     #endif
2262     }
2263 gbeauche 1.22 UNLOCK_EVENTS;
2264 gbeauche 1.20 }
2265     #endif
2266    
2267     // Set new palette if it was changed
2268     handle_palette_changes();
2269     }
2270    
2271     // This function is called on non-threaded platforms from a timer interrupt
2272     void VideoRefresh(void)
2273     {
2274     // We need to check redraw_thread_active to inhibit refreshed during
2275     // mode changes on non-threaded platforms
2276     if (!redraw_thread_active)
2277     return;
2278    
2279     // Process pending events and update display
2280     do_video_refresh();
2281     }
2282    
2283 gbeauche 1.4 const int VIDEO_REFRESH_HZ = 60;
2284     const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
2285    
2286 gbeauche 1.20 #ifndef USE_CPU_EMUL_SERVICES
2287 gbeauche 1.1 static int redraw_func(void *arg)
2288     {
2289     uint64 start = GetTicks_usec();
2290     int64 ticks = 0;
2291 gbeauche 1.4 uint64 next = GetTicks_usec() + VIDEO_REFRESH_DELAY;
2292 gbeauche 1.1
2293     while (!redraw_thread_cancel) {
2294    
2295     // Wait
2296 gbeauche 1.4 next += VIDEO_REFRESH_DELAY;
2297     int64 delay = next - GetTicks_usec();
2298     if (delay > 0)
2299     Delay_usec(delay);
2300     else if (delay < -VIDEO_REFRESH_DELAY)
2301     next = GetTicks_usec();
2302     ticks++;
2303 gbeauche 1.1
2304 gbeauche 1.13 #ifdef SHEEPSHAVER
2305     // Pause if requested (during video mode switches)
2306     if (thread_stop_req) {
2307     thread_stop_ack = true;
2308     continue;
2309     }
2310     #endif
2311    
2312 gbeauche 1.20 // Process pending events and update display
2313     do_video_refresh();
2314 gbeauche 1.1 }
2315    
2316     uint64 end = GetTicks_usec();
2317     D(bug("%lld refreshes in %lld usec = %f refreshes/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
2318     return 0;
2319     }
2320 gbeauche 1.20 #endif
2321 gbeauche 1.26
2322    
2323     /*
2324     * Record dirty area from NQD
2325     */
2326    
2327     #ifdef SHEEPSHAVER
2328     void video_set_dirty_area(int x, int y, int w, int h)
2329     {
2330 asvitkine 1.39 #ifdef ENABLE_VOSF
2331 gbeauche 1.26 const VIDEO_MODE &mode = drv->mode;
2332     const int screen_width = VIDEO_MODE_X;
2333     const int screen_height = VIDEO_MODE_Y;
2334     const int bytes_per_row = VIDEO_MODE_ROW_BYTES;
2335    
2336     if (use_vosf) {
2337 gbeauche 1.27 vosf_set_dirty_area(x, y, w, h, screen_width, screen_height, bytes_per_row);
2338 gbeauche 1.26 return;
2339     }
2340     #endif
2341    
2342     // XXX handle dirty bounding boxes for non-VOSF modes
2343     }
2344     #endif