ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/Unix/video_x.cpp
Revision: 1.68
Committed: 2002-09-28T12:42:39Z (21 years, 9 months ago) by gbeauche
Branch: MAIN
CVS Tags: nigel-build-12, nigel-build-13
Changes since 1.67: +11 -3 lines
Log Message: 
- Let fullscreen DGA mode work again, even with a DirectColor visual. In
  that case, we do need add it when creating the window otherwise we
  result int a nice BadMatch for X_CreateWindow request. FIXME?
- Fix typo and do enable VOSF in DGA mode, if necessary.

File Contents

# Content
1 /*
2 * video_x.cpp - Video/graphics emulation, X11 specific stuff
3 *
4 * Basilisk II (C) 1997-2002 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
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 * Ctrl-Tab = suspend DGA mode
25 * Ctrl-Esc = emergency quit
26 * Ctrl-F1 = mount floppy
27 * Ctrl-F5 = grab mouse (in windowed mode)
28 */
29
30 #include "sysdeps.h"
31
32 #include <X11/Xlib.h>
33 #include <X11/Xutil.h>
34 #include <X11/keysym.h>
35 #include <X11/extensions/XShm.h>
36 #include <sys/ipc.h>
37 #include <sys/shm.h>
38 #include <errno.h>
39
40 #include <algorithm>
41
42 #ifdef HAVE_PTHREADS
43 # include <pthread.h>
44 #endif
45
46 #ifdef ENABLE_XF86_DGA
47 # include <X11/extensions/xf86dga.h>
48 #endif
49
50 #ifdef ENABLE_XF86_VIDMODE
51 # include <X11/extensions/xf86vmode.h>
52 #endif
53
54 #ifdef ENABLE_FBDEV_DGA
55 # include <sys/mman.h>
56 #endif
57
58 #include "cpu_emulation.h"
59 #include "main.h"
60 #include "adb.h"
61 #include "macos_util.h"
62 #include "prefs.h"
63 #include "user_strings.h"
64 #include "video.h"
65
66 #define DEBUG 0
67 #include "debug.h"
68
69
70 // Supported video modes
71 static vector<video_mode> VideoModes;
72
73 // Display types
74 enum {
75 DISPLAY_WINDOW, // X11 window, using MIT SHM extensions if possible
76 DISPLAY_DGA // DGA fullscreen display
77 };
78
79 // Constants
80 const char KEYCODE_FILE_NAME[] = DATADIR "/keycodes";
81
82 static const int win_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | EnterWindowMask | ExposureMask | StructureNotifyMask;
83 static const int dga_eventmask = KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | StructureNotifyMask;
84
85
86 // Global variables
87 static int32 frame_skip; // Prefs items
88 static int16 mouse_wheel_mode;
89 static int16 mouse_wheel_lines;
90
91 static int display_type = DISPLAY_WINDOW; // See enum above
92 static bool local_X11; // Flag: X server running on local machine?
93 static uint8 *the_buffer = NULL; // Mac frame buffer (where MacOS draws into)
94 static uint8 *the_buffer_copy = NULL; // Copy of Mac frame buffer (for refreshed modes)
95 static uint32 the_buffer_size; // Size of allocated the_buffer
96
97 static bool redraw_thread_active = false; // Flag: Redraw thread installed
98 #ifdef HAVE_PTHREADS
99 static pthread_attr_t redraw_thread_attr; // Redraw thread attributes
100 static volatile bool redraw_thread_cancel; // Flag: Cancel Redraw thread
101 static pthread_t redraw_thread; // Redraw thread
102 #endif
103
104 static bool has_dga = false; // Flag: Video DGA capable
105 static bool has_vidmode = false; // Flag: VidMode extension available
106
107 #ifdef ENABLE_VOSF
108 static bool use_vosf = true; // Flag: VOSF enabled
109 #else
110 static const bool use_vosf = false; // VOSF not possible
111 #endif
112
113 static bool ctrl_down = false; // Flag: Ctrl key pressed
114 static bool caps_on = false; // Flag: Caps Lock on
115 static bool quit_full_screen = false; // Flag: DGA close requested from redraw thread
116 static bool emerg_quit = false; // Flag: Ctrl-Esc pressed, emergency quit requested from MacOS thread
117 static bool emul_suspended = false; // Flag: Emulator suspended
118
119 static bool classic_mode = false; // Flag: Classic Mac video mode
120
121 static bool use_keycodes = false; // Flag: Use keycodes rather than keysyms
122 static int keycode_table[256]; // X keycode -> Mac keycode translation table
123
124 // X11 variables
125 static int screen; // Screen number
126 static Window rootwin; // Root window and our window
127 static int num_depths = 0; // Number of available X depths
128 static int *avail_depths = NULL; // List of available X depths
129 static XColor black, white;
130 static unsigned long black_pixel, white_pixel;
131 static int eventmask;
132
133 static int xdepth; // Depth of X screen
134 static XVisualInfo visualInfo;
135 static Visual *vis;
136 static int color_class;
137
138 static int rshift, rloss, gshift, gloss, bshift, bloss; // Pixel format of DirectColor/TrueColor modes
139
140 static Colormap cmap[2] = {0, 0}; // Colormaps for indexed modes (DGA needs two of them)
141
142 static XColor x_palette[256]; // Color palette to be used as CLUT and gamma table
143 static bool x_palette_changed = false; // Flag: Palette changed, redraw thread must set new colors
144
145 #ifdef ENABLE_FBDEV_DGA
146 static int fbdev_fd = -1;
147 #endif
148
149 #ifdef ENABLE_XF86_VIDMODE
150 static XF86VidModeModeInfo **x_video_modes = NULL; // Array of all available modes
151 static int num_x_video_modes;
152 #endif
153
154 // Mutex to protect palette
155 #ifdef HAVE_PTHREADS
156 static pthread_mutex_t x_palette_lock = PTHREAD_MUTEX_INITIALIZER;
157 #define LOCK_PALETTE pthread_mutex_lock(&x_palette_lock)
158 #define UNLOCK_PALETTE pthread_mutex_unlock(&x_palette_lock)
159 #else
160 #define LOCK_PALETTE
161 #define UNLOCK_PALETTE
162 #endif
163
164 // Mutex to protect frame buffer
165 #ifdef HAVE_PTHREADS
166 static pthread_mutex_t frame_buffer_lock = PTHREAD_MUTEX_INITIALIZER;
167 #define LOCK_FRAME_BUFFER pthread_mutex_lock(&frame_buffer_lock);
168 #define UNLOCK_FRAME_BUFFER pthread_mutex_unlock(&frame_buffer_lock);
169 #else
170 #define LOCK_FRAME_BUFFER
171 #define UNLOCK_FRAME_BUFFER
172 #endif
173
174 // Variables for non-VOSF incremental refresh
175 static const int sm_uptd[] = {4,1,6,3,0,5,2,7};
176 static int sm_no_boxes[] = {1,8,32,64,128,300};
177 static bool updt_box[17][17];
178 static int nr_boxes;
179
180 // Video refresh function
181 static void VideoRefreshInit(void);
182 static void (*video_refresh)(void);
183
184
185 // Prototypes
186 static void *redraw_func(void *arg);
187
188 // From main_unix.cpp
189 extern char *x_display_name;
190 extern Display *x_display;
191
192 // From sys_unix.cpp
193 extern void SysMountFirstFloppy(void);
194
195
196 /*
197 * monitor_desc subclass for X11 display
198 */
199
200 class X11_monitor_desc : public monitor_desc {
201 public:
202 X11_monitor_desc(const vector<video_mode> &available_modes, video_depth default_depth, uint32 default_id) : monitor_desc(available_modes, default_depth, default_id) {}
203 ~X11_monitor_desc() {}
204
205 virtual void switch_to_current_mode(void);
206 virtual void set_palette(uint8 *pal, int num);
207
208 bool video_open(void);
209 void video_close(void);
210 };
211
212
213 /*
214 * Utility functions
215 */
216
217 // Map RGB color to pixel value (this only works in TrueColor/DirectColor visuals)
218 static inline uint32 map_rgb(uint8 red, uint8 green, uint8 blue)
219 {
220 return ((red >> rloss) << rshift) | ((green >> gloss) << gshift) | ((blue >> bloss) << bshift);
221 }
222
223 // Do we have a visual for handling the specified Mac depth? If so, set the
224 // global variables "xdepth", "visualInfo", "vis" and "color_class".
225 static bool find_visual_for_depth(video_depth depth)
226 {
227 D(bug("have_visual_for_depth(%d)\n", 1 << depth));
228
229 // 1-bit works always and uses default visual
230 if (depth == VDEPTH_1BIT) {
231 vis = DefaultVisual(x_display, screen);
232 visualInfo.visualid = XVisualIDFromVisual(vis);
233 int num = 0;
234 XVisualInfo *vi = XGetVisualInfo(x_display, VisualIDMask, &visualInfo, &num);
235 visualInfo = vi[0];
236 XFree(vi);
237 xdepth = visualInfo.depth;
238 color_class = visualInfo.c_class;
239 D(bug(" found visual ID 0x%02x, depth %d\n", visualInfo.visualid, xdepth));
240 return true;
241 }
242
243 // Calculate minimum and maximum supported X depth
244 int min_depth = 1, max_depth = 32;
245 switch (depth) {
246 #ifdef ENABLE_VOSF
247 case VDEPTH_2BIT:
248 case VDEPTH_4BIT: // VOSF blitters can convert 2/4/8-bit -> 8/16/32-bit
249 case VDEPTH_8BIT:
250 min_depth = 8;
251 max_depth = 32;
252 break;
253 #else
254 case VDEPTH_2BIT:
255 case VDEPTH_4BIT: // 2/4-bit requires VOSF blitters
256 return false;
257 case VDEPTH_8BIT: // 8-bit without VOSF requires an 8-bit visual
258 min_depth = 8;
259 max_depth = 8;
260 break;
261 #endif
262 case VDEPTH_16BIT: // 16-bit requires a 15/16-bit visual
263 min_depth = 15;
264 max_depth = 16;
265 break;
266 case VDEPTH_32BIT: // 32-bit requires a 24/32-bit visual
267 min_depth = 24;
268 max_depth = 32;
269 break;
270 }
271 D(bug(" minimum required X depth is %d, maximum supported X depth is %d\n", min_depth, max_depth));
272
273 // Try to find a visual for one of the color depths
274 bool visual_found = false;
275 for (int i=0; i<num_depths && !visual_found; i++) {
276
277 xdepth = avail_depths[i];
278 D(bug(" trying to find visual for depth %d\n", xdepth));
279 if (xdepth < min_depth || xdepth > max_depth)
280 continue;
281
282 // Determine best color class for this depth
283 switch (xdepth) {
284 case 1: // Try StaticGray or StaticColor
285 if (XMatchVisualInfo(x_display, screen, xdepth, StaticGray, &visualInfo)
286 || XMatchVisualInfo(x_display, screen, xdepth, StaticColor, &visualInfo))
287 visual_found = true;
288 break;
289 case 8: // Need PseudoColor
290 if (XMatchVisualInfo(x_display, screen, xdepth, PseudoColor, &visualInfo))
291 visual_found = true;
292 break;
293 case 15:
294 case 16:
295 case 24:
296 case 32: // Try DirectColor first, as this will allow gamma correction
297 if (XMatchVisualInfo(x_display, screen, xdepth, DirectColor, &visualInfo)
298 || XMatchVisualInfo(x_display, screen, xdepth, TrueColor, &visualInfo))
299 visual_found = true;
300 break;
301 default:
302 D(bug(" not a supported depth\n"));
303 break;
304 }
305 }
306 if (!visual_found)
307 return false;
308
309 // Visual was found
310 vis = visualInfo.visual;
311 color_class = visualInfo.c_class;
312 D(bug(" found visual ID 0x%02x, depth %d, class ", visualInfo.visualid, xdepth));
313 #if DEBUG
314 switch (color_class) {
315 case StaticGray: D(bug("StaticGray\n")); break;
316 case GrayScale: D(bug("GrayScale\n")); break;
317 case StaticColor: D(bug("StaticColor\n")); break;
318 case PseudoColor: D(bug("PseudoColor\n")); break;
319 case TrueColor: D(bug("TrueColor\n")); break;
320 case DirectColor: D(bug("DirectColor\n")); break;
321 }
322 #endif
323 return true;
324 }
325
326 // Add mode to list of supported modes
327 static void add_mode(uint32 width, uint32 height, uint32 resolution_id, uint32 bytes_per_row, video_depth depth)
328 {
329 video_mode mode;
330 mode.x = width;
331 mode.y = height;
332 mode.resolution_id = resolution_id;
333 mode.bytes_per_row = bytes_per_row;
334 mode.depth = depth;
335 VideoModes.push_back(mode);
336 }
337
338 // Add standard list of windowed modes for given color depth
339 static void add_window_modes(video_depth depth)
340 {
341 add_mode(512, 384, 0x80, TrivialBytesPerRow(512, depth), depth);
342 add_mode(640, 480, 0x81, TrivialBytesPerRow(640, depth), depth);
343 add_mode(800, 600, 0x82, TrivialBytesPerRow(800, depth), depth);
344 add_mode(1024, 768, 0x83, TrivialBytesPerRow(1024, depth), depth);
345 add_mode(1152, 870, 0x84, TrivialBytesPerRow(1152, depth), depth);
346 add_mode(1280, 1024, 0x85, TrivialBytesPerRow(1280, depth), depth);
347 add_mode(1600, 1200, 0x86, TrivialBytesPerRow(1600, depth), depth);
348 }
349
350 // Set Mac frame layout and base address (uses the_buffer/MacFrameBaseMac)
351 static void set_mac_frame_buffer(X11_monitor_desc &monitor, video_depth depth, bool native_byte_order)
352 {
353 #if !REAL_ADDRESSING && !DIRECT_ADDRESSING
354 int layout = FLAYOUT_DIRECT;
355 if (depth == VDEPTH_16BIT)
356 layout = (xdepth == 15) ? FLAYOUT_HOST_555 : FLAYOUT_HOST_565;
357 else if (depth == VDEPTH_32BIT)
358 layout = (xdepth == 24) ? FLAYOUT_HOST_888 : FLAYOUT_DIRECT;
359 if (native_byte_order)
360 MacFrameLayout = layout;
361 else
362 MacFrameLayout = FLAYOUT_DIRECT;
363 monitor.set_mac_frame_base(MacFrameBaseMac);
364
365 // Set variables used by UAE memory banking
366 const video_mode &mode = monitor.get_current_mode();
367 MacFrameBaseHost = the_buffer;
368 MacFrameSize = mode.bytes_per_row * mode.y;
369 InitFrameBufferMapping();
370 #else
371 monitor.set_mac_frame_base(Host2MacAddr(the_buffer));
372 #endif
373 D(bug("monitor.mac_frame_base = %08x\n", monitor.get_mac_frame_base()));
374 }
375
376 // Set window name and class
377 static void set_window_name(Window w, int name)
378 {
379 const char *str = GetString(name);
380 XStoreName(x_display, w, str);
381 XSetIconName(x_display, w, str);
382
383 XClassHint *hints;
384 hints = XAllocClassHint();
385 if (hints) {
386 hints->res_name = "BasiliskII";
387 hints->res_class = "BasiliskII";
388 XSetClassHint(x_display, w, hints);
389 XFree(hints);
390 }
391 }
392
393 // Set window input focus flag
394 static void set_window_focus(Window w)
395 {
396 XWMHints *hints = XAllocWMHints();
397 if (hints) {
398 hints->input = True;
399 hints->initial_state = NormalState;
400 hints->flags = InputHint | StateHint;
401 XSetWMHints(x_display, w, hints);
402 XFree(hints);
403 }
404 }
405
406 // Set WM_DELETE_WINDOW protocol on window (preventing it from being destroyed by the WM when clicking on the "close" widget)
407 static Atom WM_DELETE_WINDOW = (Atom)0;
408 static void set_window_delete_protocol(Window w)
409 {
410 WM_DELETE_WINDOW = XInternAtom(x_display, "WM_DELETE_WINDOW", false);
411 XSetWMProtocols(x_display, w, &WM_DELETE_WINDOW, 1);
412 }
413
414 // Wait until window is mapped/unmapped
415 void wait_mapped(Window w)
416 {
417 XEvent e;
418 do {
419 XMaskEvent(x_display, StructureNotifyMask, &e);
420 } while ((e.type != MapNotify) || (e.xmap.event != w));
421 }
422
423 void wait_unmapped(Window w)
424 {
425 XEvent e;
426 do {
427 XMaskEvent(x_display, StructureNotifyMask, &e);
428 } while ((e.type != UnmapNotify) || (e.xmap.event != w));
429 }
430
431 // Trap SHM errors
432 static bool shm_error = false;
433 static int (*old_error_handler)(Display *, XErrorEvent *);
434
435 static int error_handler(Display *d, XErrorEvent *e)
436 {
437 if (e->error_code == BadAccess) {
438 shm_error = true;
439 return 0;
440 } else
441 return old_error_handler(d, e);
442 }
443
444
445 /*
446 * Display "driver" classes
447 */
448
449 class driver_base {
450 public:
451 driver_base(X11_monitor_desc &m);
452 virtual ~driver_base();
453
454 virtual void update_palette(void);
455 virtual void suspend(void) {}
456 virtual void resume(void) {}
457 virtual void toggle_mouse_grab(void) {}
458 virtual void mouse_moved(int x, int y) { ADBMouseMoved(x, y); }
459
460 void disable_mouse_accel(void);
461 void restore_mouse_accel(void);
462
463 virtual void grab_mouse(void) {}
464 virtual void ungrab_mouse(void) {}
465
466 public:
467 X11_monitor_desc &monitor; // Associated video monitor
468 const video_mode &mode; // Video mode handled by the driver
469
470 bool init_ok; // Initialization succeeded (we can't use exceptions because of -fomit-frame-pointer)
471 Window w; // The window we draw into
472
473 int orig_accel_numer, orig_accel_denom, orig_threshold; // Original mouse acceleration
474 };
475
476 class driver_window;
477 static void update_display_window_vosf(driver_window *drv);
478 static void update_display_dynamic(int ticker, driver_window *drv);
479 static void update_display_static(driver_window *drv);
480
481 class driver_window : public driver_base {
482 friend void update_display_window_vosf(driver_window *drv);
483 friend void update_display_dynamic(int ticker, driver_window *drv);
484 friend void update_display_static(driver_window *drv);
485
486 public:
487 driver_window(X11_monitor_desc &monitor);
488 ~driver_window();
489
490 void toggle_mouse_grab(void);
491 void mouse_moved(int x, int y);
492
493 void grab_mouse(void);
494 void ungrab_mouse(void);
495
496 private:
497 GC gc;
498 XImage *img;
499 bool have_shm; // Flag: SHM extensions available
500 XShmSegmentInfo shminfo;
501 Cursor mac_cursor;
502 bool mouse_grabbed; // Flag: mouse pointer grabbed, using relative mouse mode
503 int mouse_last_x, mouse_last_y; // Last mouse position (for relative mode)
504 };
505
506 static driver_base *drv = NULL; // Pointer to currently used driver object
507
508 #ifdef ENABLE_VOSF
509 # include "video_vosf.h"
510 #endif
511
512 driver_base::driver_base(X11_monitor_desc &m)
513 : monitor(m), mode(m.get_current_mode()), init_ok(false), w(0)
514 {
515 the_buffer = NULL;
516 the_buffer_copy = NULL;
517 XGetPointerControl(x_display, &orig_accel_numer, &orig_accel_denom, &orig_threshold);
518 }
519
520 driver_base::~driver_base()
521 {
522 ungrab_mouse();
523 restore_mouse_accel();
524
525 if (w) {
526 XUnmapWindow(x_display, w);
527 wait_unmapped(w);
528 XDestroyWindow(x_display, w);
529 }
530
531 XFlush(x_display);
532 XSync(x_display, false);
533
534 // Free frame buffer(s)
535 if (!use_vosf) {
536 if (the_buffer) {
537 free(the_buffer);
538 the_buffer = NULL;
539 }
540 if (the_buffer_copy) {
541 free(the_buffer_copy);
542 the_buffer_copy = NULL;
543 }
544 }
545 #ifdef ENABLE_VOSF
546 else {
547 // the_buffer shall always be mapped through vm_acquire() so that we can vm_protect() it at will
548 if (the_buffer != VM_MAP_FAILED) {
549 D(bug(" releasing the_buffer at %p (%d bytes)\n", the_buffer, the_buffer_size));
550 vm_release(the_buffer, the_buffer_size);
551 the_buffer = NULL;
552 }
553 if (the_host_buffer) {
554 D(bug(" freeing the_host_buffer at %p\n", the_host_buffer));
555 free(the_host_buffer);
556 the_host_buffer = NULL;
557 }
558 if (the_buffer_copy) {
559 D(bug(" freeing the_buffer_copy at %p\n", the_buffer_copy));
560 free(the_buffer_copy);
561 the_buffer_copy = NULL;
562 }
563 }
564 #endif
565 }
566
567 // Palette has changed
568 void driver_base::update_palette(void)
569 {
570 if (color_class == PseudoColor || color_class == DirectColor) {
571 int num = vis->map_entries;
572 if (!IsDirectMode(monitor.get_current_mode()) && color_class == DirectColor)
573 return; // Indexed mode on true color screen, don't set CLUT
574 XStoreColors(x_display, cmap[0], x_palette, num);
575 XStoreColors(x_display, cmap[1], x_palette, num);
576 }
577 XSync(x_display, false);
578 }
579
580 // Disable mouse acceleration
581 void driver_base::disable_mouse_accel(void)
582 {
583 XChangePointerControl(x_display, True, False, 1, 1, 0);
584 }
585
586 // Restore mouse acceleration to original value
587 void driver_base::restore_mouse_accel(void)
588 {
589 XChangePointerControl(x_display, True, True, orig_accel_numer, orig_accel_denom, orig_threshold);
590 }
591
592
593 /*
594 * Windowed display driver
595 */
596
597 // Open display
598 driver_window::driver_window(X11_monitor_desc &m)
599 : driver_base(m), gc(0), img(NULL), have_shm(false), mac_cursor(0), mouse_grabbed(false)
600 {
601 int width = mode.x, height = mode.y;
602 int aligned_width = (width + 15) & ~15;
603 int aligned_height = (height + 15) & ~15;
604
605 // Set absolute mouse mode
606 ADBSetRelMouseMode(mouse_grabbed);
607
608 // Create window (setting background_pixel, border_pixel and colormap is
609 // mandatory when using a non-default visual; in 1-bit mode we use the
610 // default visual, so we can also use the default colormap)
611 XSetWindowAttributes wattr;
612 wattr.event_mask = eventmask = win_eventmask;
613 wattr.background_pixel = (vis == DefaultVisual(x_display, screen) ? black_pixel : 0);
614 wattr.border_pixel = 0;
615 wattr.colormap = (mode.depth == VDEPTH_1BIT ? DefaultColormap(x_display, screen) : cmap[0]);
616 w = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
617 InputOutput, vis, CWEventMask | CWBackPixel | CWBorderPixel | CWColormap, &wattr);
618 D(bug(" window created\n"));
619
620 // Set window name/class
621 set_window_name(w, STR_WINDOW_TITLE);
622
623 // Indicate that we want keyboard input
624 set_window_focus(w);
625
626 // Set delete protocol property
627 set_window_delete_protocol(w);
628
629 // Make window unresizable
630 {
631 XSizeHints *hints = XAllocSizeHints();
632 if (hints) {
633 hints->min_width = width;
634 hints->max_width = width;
635 hints->min_height = height;
636 hints->max_height = height;
637 hints->flags = PMinSize | PMaxSize;
638 XSetWMNormalHints(x_display, w, hints);
639 XFree(hints);
640 }
641 }
642 D(bug(" window attributes set\n"));
643
644 // Show window
645 XMapWindow(x_display, w);
646 wait_mapped(w);
647 D(bug(" window mapped\n"));
648
649 // 1-bit mode is big-endian; if the X server is little-endian, we can't
650 // use SHM because that doesn't allow changing the image byte order
651 bool need_msb_image = (mode.depth == VDEPTH_1BIT && XImageByteOrder(x_display) == LSBFirst);
652
653 // Try to create and attach SHM image
654 if (local_X11 && !need_msb_image && XShmQueryExtension(x_display)) {
655
656 // Create SHM image ("height + 2" for safety)
657 img = XShmCreateImage(x_display, vis, mode.depth == VDEPTH_1BIT ? 1 : xdepth, mode.depth == VDEPTH_1BIT ? XYBitmap : ZPixmap, 0, &shminfo, width, height);
658 D(bug(" shm image created\n"));
659 shminfo.shmid = shmget(IPC_PRIVATE, (aligned_height + 2) * img->bytes_per_line, IPC_CREAT | 0777);
660 the_buffer_copy = (uint8 *)shmat(shminfo.shmid, 0, 0);
661 shminfo.shmaddr = img->data = (char *)the_buffer_copy;
662 shminfo.readOnly = False;
663
664 // Try to attach SHM image, catching errors
665 shm_error = false;
666 old_error_handler = XSetErrorHandler(error_handler);
667 XShmAttach(x_display, &shminfo);
668 XSync(x_display, false);
669 XSetErrorHandler(old_error_handler);
670 if (shm_error) {
671 shmdt(shminfo.shmaddr);
672 XDestroyImage(img);
673 img = NULL;
674 shminfo.shmid = -1;
675 } else {
676 have_shm = true;
677 shmctl(shminfo.shmid, IPC_RMID, 0);
678 }
679 D(bug(" shm image attached\n"));
680 }
681
682 // Create normal X image if SHM doesn't work ("height + 2" for safety)
683 if (!have_shm) {
684 int bytes_per_row = (mode.depth == VDEPTH_1BIT ? aligned_width/8 : TrivialBytesPerRow(aligned_width, DepthModeForPixelDepth(xdepth)));
685 the_buffer_copy = (uint8 *)malloc((aligned_height + 2) * bytes_per_row);
686 img = XCreateImage(x_display, vis, mode.depth == VDEPTH_1BIT ? 1 : xdepth, mode.depth == VDEPTH_1BIT ? XYBitmap : ZPixmap, 0, (char *)the_buffer_copy, aligned_width, aligned_height, 32, bytes_per_row);
687 D(bug(" X image created\n"));
688 }
689
690 if (need_msb_image) {
691 img->byte_order = MSBFirst;
692 img->bitmap_bit_order = MSBFirst;
693 }
694
695 #ifdef ENABLE_VOSF
696 use_vosf = true;
697 // Allocate memory for frame buffer (SIZE is extended to page-boundary)
698 the_host_buffer = the_buffer_copy;
699 the_buffer_size = page_extend((aligned_height + 2) * img->bytes_per_line);
700 the_buffer = (uint8 *)vm_acquire(the_buffer_size);
701 the_buffer_copy = (uint8 *)malloc(the_buffer_size);
702 D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer));
703 #else
704 // Allocate memory for frame buffer
705 the_buffer = (uint8 *)malloc((aligned_height + 2) * img->bytes_per_line);
706 D(bug("the_buffer = %p, the_buffer_copy = %p\n", the_buffer, the_buffer_copy));
707 #endif
708
709 // Create GC
710 gc = XCreateGC(x_display, w, 0, 0);
711 XSetState(x_display, gc, black_pixel, white_pixel, GXcopy, AllPlanes);
712
713 // Create no_cursor
714 mac_cursor = XCreatePixmapCursor(x_display,
715 XCreatePixmap(x_display, w, 1, 1, 1),
716 XCreatePixmap(x_display, w, 1, 1, 1),
717 &black, &white, 0, 0);
718 XDefineCursor(x_display, w, mac_cursor);
719
720 // Init blitting routines
721 bool native_byte_order;
722 #ifdef WORDS_BIGENDIAN
723 native_byte_order = (XImageByteOrder(x_display) == MSBFirst);
724 #else
725 native_byte_order = (XImageByteOrder(x_display) == LSBFirst);
726 #endif
727 #ifdef ENABLE_VOSF
728 Screen_blitter_init(&visualInfo, native_byte_order, mode.depth);
729 #endif
730
731 // Set frame buffer base
732 set_mac_frame_buffer(monitor, mode.depth, native_byte_order);
733
734 // Everything went well
735 init_ok = true;
736 }
737
738 // Close display
739 driver_window::~driver_window()
740 {
741 if (have_shm) {
742 XShmDetach(x_display, &shminfo);
743 #ifdef ENABLE_VOSF
744 the_host_buffer = NULL; // don't free() in driver_base dtor
745 #else
746 the_buffer_copy = NULL; // don't free() in driver_base dtor
747 #endif
748 }
749 if (img) {
750 if (!have_shm)
751 img->data = NULL;
752 XDestroyImage(img);
753 }
754 if (have_shm) {
755 shmdt(shminfo.shmaddr);
756 shmctl(shminfo.shmid, IPC_RMID, 0);
757 }
758 if (gc)
759 XFreeGC(x_display, gc);
760 }
761
762 // Toggle mouse grab
763 void driver_window::toggle_mouse_grab(void)
764 {
765 if (mouse_grabbed)
766 ungrab_mouse();
767 else
768 grab_mouse();
769 }
770
771 // Grab mouse, switch to relative mouse mode
772 void driver_window::grab_mouse(void)
773 {
774 int result;
775 for (int i=0; i<10; i++) {
776 result = XGrabPointer(x_display, w, True, 0,
777 GrabModeAsync, GrabModeAsync, w, None, CurrentTime);
778 if (result != AlreadyGrabbed)
779 break;
780 Delay_usec(100000);
781 }
782 if (result == GrabSuccess) {
783 XStoreName(x_display, w, GetString(STR_WINDOW_TITLE_GRABBED));
784 ADBSetRelMouseMode(mouse_grabbed = true);
785 disable_mouse_accel();
786 }
787 }
788
789 // Ungrab mouse, switch to absolute mouse mode
790 void driver_window::ungrab_mouse(void)
791 {
792 if (mouse_grabbed) {
793 XUngrabPointer(x_display, CurrentTime);
794 XStoreName(x_display, w, GetString(STR_WINDOW_TITLE));
795 ADBSetRelMouseMode(mouse_grabbed = false);
796 restore_mouse_accel();
797 }
798 }
799
800 // Mouse moved
801 void driver_window::mouse_moved(int x, int y)
802 {
803 if (!mouse_grabbed) {
804 mouse_last_x = x; mouse_last_y = y;
805 ADBMouseMoved(x, y);
806 return;
807 }
808
809 // Warped mouse motion (this code is taken from SDL)
810
811 // Post first mouse event
812 int width = monitor.get_current_mode().x, height = monitor.get_current_mode().y;
813 int delta_x = x - mouse_last_x, delta_y = y - mouse_last_y;
814 mouse_last_x = x; mouse_last_y = y;
815 ADBMouseMoved(delta_x, delta_y);
816
817 // Only warp the pointer when it has reached the edge
818 const int MOUSE_FUDGE_FACTOR = 8;
819 if (x < MOUSE_FUDGE_FACTOR || x > (width - MOUSE_FUDGE_FACTOR)
820 || y < MOUSE_FUDGE_FACTOR || y > (height - MOUSE_FUDGE_FACTOR)) {
821 XEvent event;
822 while (XCheckTypedEvent(x_display, MotionNotify, &event)) {
823 delta_x = x - mouse_last_x; delta_y = y - mouse_last_y;
824 mouse_last_x = x; mouse_last_y = y;
825 ADBMouseMoved(delta_x, delta_y);
826 }
827 mouse_last_x = width/2;
828 mouse_last_y = height/2;
829 XWarpPointer(x_display, None, w, 0, 0, 0, 0, mouse_last_x, mouse_last_y);
830 for (int i=0; i<10; i++) {
831 XMaskEvent(x_display, PointerMotionMask, &event);
832 if (event.xmotion.x > (mouse_last_x - MOUSE_FUDGE_FACTOR)
833 && event.xmotion.x < (mouse_last_x + MOUSE_FUDGE_FACTOR)
834 && event.xmotion.y > (mouse_last_y - MOUSE_FUDGE_FACTOR)
835 && event.xmotion.y < (mouse_last_y + MOUSE_FUDGE_FACTOR))
836 break;
837 }
838 }
839 }
840
841
842 #if defined(ENABLE_XF86_DGA) || defined(ENABLE_FBDEV_DGA)
843 /*
844 * DGA display driver base class
845 */
846
847 class driver_dga : public driver_base {
848 public:
849 driver_dga(X11_monitor_desc &monitor);
850 ~driver_dga();
851
852 void suspend(void);
853 void resume(void);
854
855 private:
856 Window suspend_win; // "Suspend" information window
857 void *fb_save; // Saved frame buffer for suspend/resume
858 };
859
860 driver_dga::driver_dga(X11_monitor_desc &m)
861 : driver_base(m), suspend_win(0), fb_save(NULL)
862 {
863 }
864
865 driver_dga::~driver_dga()
866 {
867 XUngrabPointer(x_display, CurrentTime);
868 XUngrabKeyboard(x_display, CurrentTime);
869 }
870
871 // Suspend emulation
872 void driver_dga::suspend(void)
873 {
874 // Release ctrl key
875 ADBKeyUp(0x36);
876 ctrl_down = false;
877
878 // Lock frame buffer (this will stop the MacOS thread)
879 LOCK_FRAME_BUFFER;
880
881 // Save frame buffer
882 fb_save = malloc(mode.y * mode.bytes_per_row);
883 if (fb_save)
884 memcpy(fb_save, the_buffer, mode.y * mode.bytes_per_row);
885
886 // Close full screen display
887 #ifdef ENABLE_XF86_DGA
888 XF86DGADirectVideo(x_display, screen, 0);
889 #endif
890 XUngrabPointer(x_display, CurrentTime);
891 XUngrabKeyboard(x_display, CurrentTime);
892 restore_mouse_accel();
893 XUnmapWindow(x_display, w);
894 wait_unmapped(w);
895
896 // Open "suspend" window
897 XSetWindowAttributes wattr;
898 wattr.event_mask = KeyPressMask;
899 wattr.background_pixel = black_pixel;
900
901 suspend_win = XCreateWindow(x_display, rootwin, 0, 0, 512, 1, 0, xdepth,
902 InputOutput, vis, CWEventMask | CWBackPixel, &wattr);
903 set_window_name(suspend_win, STR_SUSPEND_WINDOW_TITLE);
904 set_window_focus(suspend_win);
905 XMapWindow(x_display, suspend_win);
906 emul_suspended = true;
907 }
908
909 // Resume emulation
910 void driver_dga::resume(void)
911 {
912 // Close "suspend" window
913 XDestroyWindow(x_display, suspend_win);
914 XSync(x_display, false);
915
916 // Reopen full screen display
917 XMapRaised(x_display, w);
918 wait_mapped(w);
919 XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0);
920 XGrabKeyboard(x_display, rootwin, True, GrabModeAsync, GrabModeAsync, CurrentTime);
921 XGrabPointer(x_display, rootwin, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
922 disable_mouse_accel();
923 #ifdef ENABLE_XF86_DGA
924 XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse);
925 XF86DGASetViewPort(x_display, screen, 0, 0);
926 #endif
927 XSync(x_display, false);
928
929 // the_buffer already contains the data to restore. i.e. since a temporary
930 // frame buffer is used when VOSF is actually used, fb_save is therefore
931 // not necessary.
932 #ifdef ENABLE_VOSF
933 if (use_vosf) {
934 LOCK_VOSF;
935 PFLAG_SET_ALL;
936 UNLOCK_VOSF;
937 memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
938 }
939 #endif
940
941 // Restore frame buffer
942 if (fb_save) {
943 #ifdef ENABLE_VOSF
944 // Don't copy fb_save to the temporary frame buffer in VOSF mode
945 if (!use_vosf)
946 #endif
947 memcpy(the_buffer, fb_save, mode.y * mode.bytes_per_row);
948 free(fb_save);
949 fb_save = NULL;
950 }
951
952 // Unlock frame buffer (and continue MacOS thread)
953 UNLOCK_FRAME_BUFFER;
954 emul_suspended = false;
955 }
956 #endif
957
958
959 #ifdef ENABLE_FBDEV_DGA
960 /*
961 * fbdev DGA display driver
962 */
963
964 const char FBDEVICES_FILE_NAME[] = DATADIR "/fbdevices";
965 const char FBDEVICE_FILE_NAME[] = "/dev/fb";
966
967 class driver_fbdev : public driver_dga {
968 public:
969 driver_fbdev(X11_monitor_desc &monitor);
970 ~driver_fbdev();
971 };
972
973 // Open display
974 driver_fbdev::driver_fbdev(X11_monitor_desc &m) : driver_dga(m)
975 {
976 int width = mode.x, height = mode.y;
977
978 // Set absolute mouse mode
979 ADBSetRelMouseMode(false);
980
981 // Find the maximum depth available
982 int ndepths, max_depth(0);
983 int *depths = XListDepths(x_display, screen, &ndepths);
984 if (depths == NULL) {
985 printf("FATAL: Could not determine the maximal depth available\n");
986 return;
987 } else {
988 while (ndepths-- > 0) {
989 if (depths[ndepths] > max_depth)
990 max_depth = depths[ndepths];
991 }
992 }
993
994 // Get fbdevices file path from preferences
995 const char *fbd_path = PrefsFindString("fbdevicefile");
996
997 // Open fbdevices file
998 FILE *fp = fopen(fbd_path ? fbd_path : FBDEVICES_FILE_NAME, "r");
999 if (fp == NULL) {
1000 char str[256];
1001 sprintf(str, GetString(STR_NO_FBDEVICE_FILE_ERR), fbd_path ? fbd_path : FBDEVICES_FILE_NAME, strerror(errno));
1002 ErrorAlert(str);
1003 return;
1004 }
1005
1006 int fb_depth; // supported depth
1007 uint32 fb_offset; // offset used for mmap(2)
1008 char fb_name[20];
1009 char line[256];
1010 bool device_found = false;
1011 while (fgets(line, 255, fp)) {
1012 // Read line
1013 int len = strlen(line);
1014 if (len == 0)
1015 continue;
1016 line[len - 1] = '\0';
1017
1018 // Comments begin with "#" or ";"
1019 if ((line[0] == '#') || (line[0] == ';') || (line[0] == '\0'))
1020 continue;
1021
1022 if ((sscanf(line, "%19s %d %x", fb_name, &fb_depth, &fb_offset) == 3)
1023 && (strcmp(fb_name, fb_name) == 0) && (fb_depth == max_depth)) {
1024 device_found = true;
1025 break;
1026 }
1027 }
1028
1029 // fbdevices file completely read
1030 fclose(fp);
1031
1032 // Frame buffer name not found ? Then, display warning
1033 if (!device_found) {
1034 char str[256];
1035 sprintf(str, GetString(STR_FBDEV_NAME_ERR), fb_name, max_depth);
1036 ErrorAlert(str);
1037 return;
1038 }
1039
1040 // Create window
1041 XSetWindowAttributes wattr;
1042 wattr.event_mask = eventmask = dga_eventmask;
1043 wattr.background_pixel = white_pixel;
1044 wattr.override_redirect = True;
1045 wattr.colormap = cmap[0];
1046
1047 w = XCreateWindow(x_display, rootwin,
1048 0, 0, width, height,
1049 0, xdepth, InputOutput, vis,
1050 CWEventMask | CWBackPixel | CWOverrideRedirect | (fb_depth <= 8 ? CWColormap : 0),
1051 &wattr);
1052
1053 // Set window name/class
1054 set_window_name(w, STR_WINDOW_TITLE);
1055
1056 // Indicate that we want keyboard input
1057 set_window_focus(w);
1058
1059 // Show window
1060 XMapRaised(x_display, w);
1061 wait_mapped(w);
1062
1063 // Grab mouse and keyboard
1064 XGrabKeyboard(x_display, w, True,
1065 GrabModeAsync, GrabModeAsync, CurrentTime);
1066 XGrabPointer(x_display, w, True,
1067 PointerMotionMask | ButtonPressMask | ButtonReleaseMask,
1068 GrabModeAsync, GrabModeAsync, w, None, CurrentTime);
1069 disable_mouse_accel();
1070
1071 // Calculate bytes per row
1072 int bytes_per_row = TrivialBytesPerRow(mode.x, mode.depth);
1073
1074 // Map frame buffer
1075 the_buffer_size = height * bytes_per_row;
1076 if ((the_buffer = (uint8 *) mmap(NULL, the_buffer_size, PROT_READ | PROT_WRITE, MAP_PRIVATE, fbdev_fd, fb_offset)) == MAP_FAILED) {
1077 if ((the_buffer = (uint8 *) mmap(NULL, the_buffer_size, PROT_READ | PROT_WRITE, MAP_SHARED, fbdev_fd, fb_offset)) == MAP_FAILED) {
1078 char str[256];
1079 sprintf(str, GetString(STR_FBDEV_MMAP_ERR), strerror(errno));
1080 ErrorAlert(str);
1081 return;
1082 }
1083 }
1084
1085 #if ENABLE_VOSF
1086 #if REAL_ADDRESSING || DIRECT_ADDRESSING
1087 // Screen_blitter_init() returns TRUE if VOSF is mandatory
1088 // i.e. the framebuffer update function is not Blit_Copy_Raw
1089 use_vosf = Screen_blitter_init(&visualInfo, true, mode.depth);
1090
1091 if (use_vosf) {
1092 // Allocate memory for frame buffer (SIZE is extended to page-boundary)
1093 the_host_buffer = the_buffer;
1094 the_buffer_size = page_extend((height + 2) * bytes_per_row);
1095 the_buffer_copy = (uint8 *)malloc(the_buffer_size);
1096 the_buffer = (uint8 *)vm_acquire(the_buffer_size);
1097 }
1098 #else
1099 use_vosf = false;
1100 #endif
1101 #endif
1102
1103 // Set frame buffer base
1104 const_cast<video_mode *>(&mode)->bytes_per_row = bytes_per_row;
1105 const_cast<video_mode *>(&mode)->depth = DepthModeForPixelDepth(fb_depth);
1106 set_mac_frame_buffer(monitor, mode.depth, true);
1107
1108 // Everything went well
1109 init_ok = true;
1110 }
1111
1112 // Close display
1113 driver_fbdev::~driver_fbdev()
1114 {
1115 if (!use_vosf) {
1116 if (the_buffer != MAP_FAILED) {
1117 // don't free() the screen buffer in driver_base dtor
1118 munmap(the_buffer, the_buffer_size);
1119 the_buffer = NULL;
1120 }
1121 }
1122 #ifdef ENABLE_VOSF
1123 else {
1124 if (the_host_buffer != MAP_FAILED) {
1125 // don't free() the screen buffer in driver_base dtor
1126 munmap(the_host_buffer, the_buffer_size);
1127 the_host_buffer = NULL;
1128 }
1129 }
1130 #endif
1131 }
1132 #endif
1133
1134
1135 #ifdef ENABLE_XF86_DGA
1136 /*
1137 * XFree86 DGA display driver
1138 */
1139
1140 class driver_xf86dga : public driver_dga {
1141 public:
1142 driver_xf86dga(X11_monitor_desc &monitor);
1143 ~driver_xf86dga();
1144
1145 void update_palette(void);
1146 void resume(void);
1147
1148 private:
1149 int current_dga_cmap; // Number (0 or 1) of currently installed DGA colormap
1150 };
1151
1152 // Open display
1153 driver_xf86dga::driver_xf86dga(X11_monitor_desc &m)
1154 : driver_dga(m), current_dga_cmap(0)
1155 {
1156 int width = mode.x, height = mode.y;
1157
1158 // Set relative mouse mode
1159 ADBSetRelMouseMode(true);
1160
1161 #ifdef ENABLE_XF86_VIDMODE
1162 // Switch to best mode
1163 if (has_vidmode) {
1164 int best = 0;
1165 for (int i=1; i<num_x_video_modes; i++) {
1166 if (x_video_modes[i]->hdisplay >= width && x_video_modes[i]->vdisplay >= height &&
1167 x_video_modes[i]->hdisplay <= x_video_modes[best]->hdisplay && x_video_modes[i]->vdisplay <= x_video_modes[best]->vdisplay) {
1168 best = i;
1169 }
1170 }
1171 XF86VidModeSwitchToMode(x_display, screen, x_video_modes[best]);
1172 XF86VidModeSetViewPort(x_display, screen, 0, 0);
1173 XSync(x_display, false);
1174 }
1175 #endif
1176
1177 // Create window
1178 XSetWindowAttributes wattr;
1179 wattr.event_mask = eventmask = dga_eventmask;
1180 wattr.override_redirect = True;
1181 wattr.colormap = (mode.depth == VDEPTH_1BIT ? DefaultColormap(x_display, screen) : cmap[0]);
1182
1183 w = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth,
1184 InputOutput, vis, CWEventMask | CWOverrideRedirect |
1185 (color_class == DirectColor ? CWColormap : 0), &wattr);
1186
1187 // Set window name/class
1188 set_window_name(w, STR_WINDOW_TITLE);
1189
1190 // Indicate that we want keyboard input
1191 set_window_focus(w);
1192
1193 // Show window
1194 XMapRaised(x_display, w);
1195 wait_mapped(w);
1196
1197 // Establish direct screen connection
1198 XMoveResizeWindow(x_display, w, 0, 0, width, height);
1199 XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0);
1200 XGrabKeyboard(x_display, rootwin, True, GrabModeAsync, GrabModeAsync, CurrentTime);
1201 XGrabPointer(x_display, rootwin, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime);
1202 disable_mouse_accel();
1203
1204 int v_width, v_bank, v_size;
1205 XF86DGAGetVideo(x_display, screen, (char **)&the_buffer, &v_width, &v_bank, &v_size);
1206 XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse);
1207 XF86DGASetViewPort(x_display, screen, 0, 0);
1208 XF86DGASetVidPage(x_display, screen, 0);
1209
1210 // Set colormap
1211 if (!IsDirectMode(mode)) {
1212 XSetWindowColormap(x_display, w, cmap[current_dga_cmap = 0]);
1213 XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1214 }
1215 XSync(x_display, false);
1216
1217 // Init blitting routines
1218 int bytes_per_row = TrivialBytesPerRow((v_width + 7) & ~7, mode.depth);
1219 #if ENABLE_VOSF
1220 bool native_byte_order;
1221 #ifdef WORDS_BIGENDIAN
1222 native_byte_order = (XImageByteOrder(x_display) == MSBFirst);
1223 #else
1224 native_byte_order = (XImageByteOrder(x_display) == LSBFirst);
1225 #endif
1226 #if REAL_ADDRESSING || DIRECT_ADDRESSING
1227 // Screen_blitter_init() returns TRUE if VOSF is mandatory
1228 // i.e. the framebuffer update function is not Blit_Copy_Raw
1229 use_vosf = Screen_blitter_init(&visualInfo, native_byte_order, mode.depth);
1230
1231 if (use_vosf) {
1232 // Allocate memory for frame buffer (SIZE is extended to page-boundary)
1233 the_host_buffer = the_buffer;
1234 the_buffer_size = page_extend((height + 2) * bytes_per_row);
1235 the_buffer_copy = (uint8 *)malloc(the_buffer_size);
1236 the_buffer = (uint8 *)vm_acquire(the_buffer_size);
1237 }
1238 #else
1239 use_vosf = false;
1240 #endif
1241 #endif
1242
1243 // Set frame buffer base
1244 const_cast<video_mode *>(&mode)->bytes_per_row = bytes_per_row;
1245 set_mac_frame_buffer(monitor, mode.depth, true);
1246
1247 // Everything went well
1248 init_ok = true;
1249 }
1250
1251 // Close display
1252 driver_xf86dga::~driver_xf86dga()
1253 {
1254 XF86DGADirectVideo(x_display, screen, 0);
1255 if (!use_vosf) {
1256 // don't free() the screen buffer in driver_base dtor
1257 the_buffer = NULL;
1258 }
1259 #ifdef ENABLE_VOSF
1260 else {
1261 // don't free() the screen buffer in driver_base dtor
1262 the_host_buffer = NULL;
1263 }
1264 #endif
1265 #ifdef ENABLE_XF86_VIDMODE
1266 if (has_vidmode)
1267 XF86VidModeSwitchToMode(x_display, screen, x_video_modes[0]);
1268 #endif
1269 }
1270
1271 // Palette has changed
1272 void driver_xf86dga::update_palette(void)
1273 {
1274 driver_dga::update_palette();
1275 current_dga_cmap ^= 1;
1276 if (!IsDirectMode(monitor.get_current_mode()) && cmap[current_dga_cmap])
1277 XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1278 }
1279
1280 // Resume emulation
1281 void driver_xf86dga::resume(void)
1282 {
1283 driver_dga::resume();
1284 if (!IsDirectMode(monitor.get_current_mode()))
1285 XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]);
1286 }
1287 #endif
1288
1289
1290 /*
1291 * Initialization
1292 */
1293
1294 // Init keycode translation table
1295 static void keycode_init(void)
1296 {
1297 bool use_kc = PrefsFindBool("keycodes");
1298 if (use_kc) {
1299
1300 // Get keycode file path from preferences
1301 const char *kc_path = PrefsFindString("keycodefile");
1302
1303 // Open keycode table
1304 FILE *f = fopen(kc_path ? kc_path : KEYCODE_FILE_NAME, "r");
1305 if (f == NULL) {
1306 char str[256];
1307 sprintf(str, GetString(STR_KEYCODE_FILE_WARN), kc_path ? kc_path : KEYCODE_FILE_NAME, strerror(errno));
1308 WarningAlert(str);
1309 return;
1310 }
1311
1312 // Default translation table
1313 for (int i=0; i<256; i++)
1314 keycode_table[i] = -1;
1315
1316 // Search for server vendor string, then read keycodes
1317 const char *vendor = ServerVendor(x_display);
1318 bool vendor_found = false;
1319 char line[256];
1320 while (fgets(line, 255, f)) {
1321 // Read line
1322 int len = strlen(line);
1323 if (len == 0)
1324 continue;
1325 line[len-1] = 0;
1326
1327 // Comments begin with "#" or ";"
1328 if (line[0] == '#' || line[0] == ';' || line[0] == 0)
1329 continue;
1330
1331 if (vendor_found) {
1332 // Read keycode
1333 int x_code, mac_code;
1334 if (sscanf(line, "%d %d", &x_code, &mac_code) == 2)
1335 keycode_table[x_code & 0xff] = mac_code;
1336 else
1337 break;
1338 } else {
1339 // Search for vendor string
1340 if (strstr(vendor, line) == vendor)
1341 vendor_found = true;
1342 }
1343 }
1344
1345 // Keycode file completely read
1346 fclose(f);
1347 use_keycodes = vendor_found;
1348
1349 // Vendor not found? Then display warning
1350 if (!vendor_found) {
1351 char str[256];
1352 sprintf(str, GetString(STR_KEYCODE_VENDOR_WARN), vendor, kc_path ? kc_path : KEYCODE_FILE_NAME);
1353 WarningAlert(str);
1354 return;
1355 }
1356 }
1357 }
1358
1359 // Open display for current mode
1360 bool X11_monitor_desc::video_open(void)
1361 {
1362 D(bug("video_open()\n"));
1363 const video_mode &mode = get_current_mode();
1364
1365 // Find best available X visual
1366 if (!find_visual_for_depth(mode.depth)) {
1367 ErrorAlert(STR_NO_XVISUAL_ERR);
1368 return false;
1369 }
1370
1371 // Create color maps
1372 if (color_class == PseudoColor || color_class == DirectColor) {
1373 cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1374 cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocAll);
1375 } else {
1376 cmap[0] = XCreateColormap(x_display, rootwin, vis, AllocNone);
1377 cmap[1] = XCreateColormap(x_display, rootwin, vis, AllocNone);
1378 }
1379
1380 // Find pixel format of direct modes
1381 if (color_class == DirectColor || color_class == TrueColor) {
1382 rshift = gshift = bshift = 0;
1383 rloss = gloss = bloss = 8;
1384 uint32 mask;
1385 for (mask=vis->red_mask; !(mask&1); mask>>=1)
1386 ++rshift;
1387 for (; mask&1; mask>>=1)
1388 --rloss;
1389 for (mask=vis->green_mask; !(mask&1); mask>>=1)
1390 ++gshift;
1391 for (; mask&1; mask>>=1)
1392 --gloss;
1393 for (mask=vis->blue_mask; !(mask&1); mask>>=1)
1394 ++bshift;
1395 for (; mask&1; mask>>=1)
1396 --bloss;
1397 }
1398
1399 // Preset palette pixel values for CLUT or gamma table
1400 if (color_class == DirectColor) {
1401 int num = vis->map_entries;
1402 for (int i=0; i<num; i++) {
1403 int c = (i * 256) / num;
1404 x_palette[i].pixel = map_rgb(c, c, c);
1405 x_palette[i].flags = DoRed | DoGreen | DoBlue;
1406 }
1407 } else if (color_class == PseudoColor) {
1408 for (int i=0; i<256; i++) {
1409 x_palette[i].pixel = i;
1410 x_palette[i].flags = DoRed | DoGreen | DoBlue;
1411 }
1412 }
1413
1414 // Load gray ramp to color map
1415 int num = (color_class == DirectColor ? vis->map_entries : 256);
1416 for (int i=0; i<num; i++) {
1417 int c = (i * 256) / num;
1418 x_palette[i].red = c * 0x0101;
1419 x_palette[i].green = c * 0x0101;
1420 x_palette[i].blue = c * 0x0101;
1421 }
1422 if (color_class == PseudoColor || color_class == DirectColor) {
1423 XStoreColors(x_display, cmap[0], x_palette, num);
1424 XStoreColors(x_display, cmap[1], x_palette, num);
1425 }
1426
1427 #ifdef ENABLE_VOSF
1428 // Load gray ramp to 8->16/32 expand map
1429 if (!IsDirectMode(mode) && xdepth > 8)
1430 for (int i=0; i<256; i++)
1431 ExpandMap[i] = map_rgb(i, i, i);
1432 #endif
1433
1434 // Create display driver object of requested type
1435 switch (display_type) {
1436 case DISPLAY_WINDOW:
1437 drv = new driver_window(*this);
1438 break;
1439 #ifdef ENABLE_FBDEV_DGA
1440 case DISPLAY_DGA:
1441 drv = new driver_fbdev(*this);
1442 break;
1443 #endif
1444 #ifdef ENABLE_XF86_DGA
1445 case DISPLAY_DGA:
1446 drv = new driver_xf86dga(*this);
1447 break;
1448 #endif
1449 }
1450 if (drv == NULL)
1451 return false;
1452 if (!drv->init_ok) {
1453 delete drv;
1454 drv = NULL;
1455 return false;
1456 }
1457
1458 #ifdef ENABLE_VOSF
1459 if (use_vosf) {
1460 // Initialize the VOSF system
1461 if (!video_vosf_init(*this)) {
1462 ErrorAlert(STR_VOSF_INIT_ERR);
1463 return false;
1464 }
1465 }
1466 #endif
1467
1468 // Initialize VideoRefresh function
1469 VideoRefreshInit();
1470
1471 // Lock down frame buffer
1472 XSync(x_display, false);
1473 LOCK_FRAME_BUFFER;
1474
1475 // Start redraw/input thread
1476 #ifdef HAVE_PTHREADS
1477 redraw_thread_cancel = false;
1478 Set_pthread_attr(&redraw_thread_attr, 0);
1479 redraw_thread_active = (pthread_create(&redraw_thread, &redraw_thread_attr, redraw_func, NULL) == 0);
1480 if (!redraw_thread_active) {
1481 printf("FATAL: cannot create redraw thread\n");
1482 return false;
1483 }
1484 #else
1485 redraw_thread_active = true;
1486 #endif
1487
1488 return true;
1489 }
1490
1491 bool VideoInit(bool classic)
1492 {
1493 classic_mode = classic;
1494
1495 #ifdef ENABLE_VOSF
1496 // Zero the mainBuffer structure
1497 mainBuffer.dirtyPages = NULL;
1498 mainBuffer.pageInfo = NULL;
1499 #endif
1500
1501 // Check if X server runs on local machine
1502 local_X11 = (strncmp(XDisplayName(x_display_name), ":", 1) == 0)
1503 || (strncmp(XDisplayName(x_display_name), "unix:", 5) == 0);
1504
1505 // Init keycode translation
1506 keycode_init();
1507
1508 // Read prefs
1509 frame_skip = PrefsFindInt32("frameskip");
1510 mouse_wheel_mode = PrefsFindInt32("mousewheelmode");
1511 mouse_wheel_lines = PrefsFindInt32("mousewheellines");
1512
1513 // Find screen and root window
1514 screen = XDefaultScreen(x_display);
1515 rootwin = XRootWindow(x_display, screen);
1516
1517 // Get sorted list of available depths
1518 avail_depths = XListDepths(x_display, screen, &num_depths);
1519 if (avail_depths == NULL) {
1520 ErrorAlert(STR_UNSUPP_DEPTH_ERR);
1521 return false;
1522 }
1523 std::sort(avail_depths, avail_depths + num_depths);
1524
1525 #ifdef ENABLE_FBDEV_DGA
1526 // Frame buffer name
1527 char fb_name[20];
1528
1529 // Could do fbdev DGA?
1530 if ((fbdev_fd = open(FBDEVICE_FILE_NAME, O_RDWR)) != -1)
1531 has_dga = true;
1532 else
1533 has_dga = false;
1534 #endif
1535
1536 #ifdef ENABLE_XF86_DGA
1537 // DGA available?
1538 int dga_event_base, dga_error_base;
1539 if (local_X11 && XF86DGAQueryExtension(x_display, &dga_event_base, &dga_error_base)) {
1540 int dga_flags = 0;
1541 XF86DGAQueryDirectVideo(x_display, screen, &dga_flags);
1542 has_dga = dga_flags & XF86DGADirectPresent;
1543 } else
1544 has_dga = false;
1545 #endif
1546
1547 #ifdef ENABLE_XF86_VIDMODE
1548 // VidMode available?
1549 int vm_event_base, vm_error_base;
1550 has_vidmode = XF86VidModeQueryExtension(x_display, &vm_event_base, &vm_error_base);
1551 if (has_vidmode)
1552 XF86VidModeGetAllModeLines(x_display, screen, &num_x_video_modes, &x_video_modes);
1553 #endif
1554
1555 // Find black and white colors
1556 XParseColor(x_display, DefaultColormap(x_display, screen), "rgb:00/00/00", &black);
1557 XAllocColor(x_display, DefaultColormap(x_display, screen), &black);
1558 XParseColor(x_display, DefaultColormap(x_display, screen), "rgb:ff/ff/ff", &white);
1559 XAllocColor(x_display, DefaultColormap(x_display, screen), &white);
1560 black_pixel = BlackPixel(x_display, screen);
1561 white_pixel = WhitePixel(x_display, screen);
1562
1563 // Get screen mode from preferences
1564 const char *mode_str;
1565 if (classic_mode)
1566 mode_str = "win/512/342";
1567 else
1568 mode_str = PrefsFindString("screen");
1569
1570 // Determine display type and default dimensions
1571 int default_width = 512, default_height = 384;
1572 display_type = DISPLAY_WINDOW;
1573 if (mode_str) {
1574 if (sscanf(mode_str, "win/%d/%d", &default_width, &default_height) == 2) {
1575 display_type = DISPLAY_WINDOW;
1576 #ifdef ENABLE_FBDEV_DGA
1577 } else if (has_dga && sscanf(mode_str, "dga/%19s", fb_name) == 1) {
1578 display_type = DISPLAY_DGA;
1579 default_width = -1; default_height = -1; // use entire screen
1580 #endif
1581 #ifdef ENABLE_XF86_DGA
1582 } else if (has_dga && sscanf(mode_str, "dga/%d/%d", &default_width, &default_height) == 2) {
1583 display_type = DISPLAY_DGA;
1584 #endif
1585 }
1586 }
1587 if (default_width <= 0)
1588 default_width = DisplayWidth(x_display, screen);
1589 else if (default_width > DisplayWidth(x_display, screen))
1590 default_width = DisplayWidth(x_display, screen);
1591 if (default_height <= 0)
1592 default_height = DisplayHeight(x_display, screen);
1593 else if (default_height > DisplayHeight(x_display, screen))
1594 default_height = DisplayHeight(x_display, screen);
1595
1596 // Mac screen depth follows X depth
1597 video_depth default_depth = VDEPTH_1BIT;
1598 switch (DefaultDepth(x_display, screen)) {
1599 case 8:
1600 default_depth = VDEPTH_8BIT;
1601 break;
1602 case 15: case 16:
1603 default_depth = VDEPTH_16BIT;
1604 break;
1605 case 24: case 32:
1606 default_depth = VDEPTH_32BIT;
1607 break;
1608 }
1609
1610 // Construct list of supported modes
1611 if (display_type == DISPLAY_WINDOW) {
1612 if (classic)
1613 add_mode(512, 342, 0x80, 64, VDEPTH_1BIT);
1614 else {
1615 for (unsigned d=VDEPTH_1BIT; d<=VDEPTH_32BIT; d++) {
1616 if (find_visual_for_depth(video_depth(d)))
1617 add_window_modes(video_depth(d));
1618 }
1619 }
1620 } else
1621 add_mode(default_width, default_height, 0x80, TrivialBytesPerRow(default_width, default_depth), default_depth);
1622 if (VideoModes.empty()) {
1623 ErrorAlert(STR_NO_XVISUAL_ERR);
1624 return false;
1625 }
1626
1627 // Find requested default mode with specified dimensions
1628 uint32 default_id;
1629 std::vector<video_mode>::const_iterator i, end = VideoModes.end();
1630 for (i = VideoModes.begin(); i != end; ++i) {
1631 if (i->x == default_width && i->y == default_height && i->depth == default_depth) {
1632 default_id = i->resolution_id;
1633 break;
1634 }
1635 }
1636 if (i == end) { // not found, use first available mode
1637 default_depth = VideoModes[0].depth;
1638 default_id = VideoModes[0].resolution_id;
1639 }
1640
1641 #if DEBUG
1642 D(bug("Available video modes:\n"));
1643 for (i = VideoModes.begin(); i != end; ++i) {
1644 int bits = 1 << i->depth;
1645 if (bits == 16)
1646 bits = 15;
1647 else if (bits == 32)
1648 bits = 24;
1649 D(bug(" %dx%d (ID %02x), %d colors\n", i->x, i->y, i->resolution_id, 1 << bits));
1650 }
1651 #endif
1652
1653 // Create X11_monitor_desc for this (the only) display
1654 X11_monitor_desc *monitor = new X11_monitor_desc(VideoModes, default_depth, default_id);
1655 VideoMonitors.push_back(monitor);
1656
1657 // Open display
1658 return monitor->video_open();
1659 }
1660
1661
1662 /*
1663 * Deinitialization
1664 */
1665
1666 // Close display
1667 void X11_monitor_desc::video_close(void)
1668 {
1669 D(bug("video_close()\n"));
1670
1671 // Stop redraw thread
1672 #ifdef HAVE_PTHREADS
1673 if (redraw_thread_active) {
1674 redraw_thread_cancel = true;
1675 #ifdef HAVE_PTHREAD_CANCEL
1676 pthread_cancel(redraw_thread);
1677 #endif
1678 pthread_join(redraw_thread, NULL);
1679 }
1680 #endif
1681 redraw_thread_active = false;
1682
1683 // Unlock frame buffer
1684 UNLOCK_FRAME_BUFFER;
1685 XSync(x_display, false);
1686 D(bug(" frame buffer unlocked\n"));
1687
1688 #ifdef ENABLE_VOSF
1689 if (use_vosf) {
1690 // Deinitialize VOSF
1691 video_vosf_exit();
1692 }
1693 #endif
1694
1695 // Close display
1696 delete drv;
1697 drv = NULL;
1698
1699 // Free colormaps
1700 if (cmap[0]) {
1701 XFreeColormap(x_display, cmap[0]);
1702 cmap[0] = 0;
1703 }
1704 if (cmap[1]) {
1705 XFreeColormap(x_display, cmap[1]);
1706 cmap[1] = 0;
1707 }
1708 }
1709
1710 void VideoExit(void)
1711 {
1712 // Close displays
1713 vector<monitor_desc *>::iterator i, end = VideoMonitors.end();
1714 for (i = VideoMonitors.begin(); i != end; ++i)
1715 dynamic_cast<X11_monitor_desc *>(*i)->video_close();
1716
1717 #ifdef ENABLE_XF86_VIDMODE
1718 // Free video mode list
1719 if (x_video_modes) {
1720 XFree(x_video_modes);
1721 x_video_modes = NULL;
1722 }
1723 #endif
1724
1725 #ifdef ENABLE_FBDEV_DGA
1726 // Close framebuffer device
1727 if (fbdev_fd >= 0) {
1728 close(fbdev_fd);
1729 fbdev_fd = -1;
1730 }
1731 #endif
1732
1733 // Free depth list
1734 if (avail_depths) {
1735 XFree(avail_depths);
1736 avail_depths = NULL;
1737 }
1738 }
1739
1740
1741 /*
1742 * Close down full-screen mode (if bringing up error alerts is unsafe while in full-screen mode)
1743 */
1744
1745 void VideoQuitFullScreen(void)
1746 {
1747 D(bug("VideoQuitFullScreen()\n"));
1748 quit_full_screen = true;
1749 }
1750
1751
1752 /*
1753 * Mac VBL interrupt
1754 */
1755
1756 void VideoInterrupt(void)
1757 {
1758 // Emergency quit requested? Then quit
1759 if (emerg_quit)
1760 QuitEmulator();
1761
1762 // Temporarily give up frame buffer lock (this is the point where
1763 // we are suspended when the user presses Ctrl-Tab)
1764 UNLOCK_FRAME_BUFFER;
1765 LOCK_FRAME_BUFFER;
1766 }
1767
1768
1769 /*
1770 * Set palette
1771 */
1772
1773 void X11_monitor_desc::set_palette(uint8 *pal, int num_in)
1774 {
1775 const video_mode &mode = get_current_mode();
1776
1777 LOCK_PALETTE;
1778
1779 // Convert colors to XColor array
1780 int num_out = 256;
1781 bool stretch = false;
1782 if (IsDirectMode(mode)) {
1783 // If X is in 565 mode we have to stretch the gamma table from 32 to 64 entries
1784 num_out = vis->map_entries;
1785 stretch = true;
1786 }
1787 XColor *p = x_palette;
1788 for (int i=0; i<num_out; i++) {
1789 int c = (stretch ? (i * num_in) / num_out : i);
1790 p->red = pal[c*3 + 0] * 0x0101;
1791 p->green = pal[c*3 + 1] * 0x0101;
1792 p->blue = pal[c*3 + 2] * 0x0101;
1793 p++;
1794 }
1795
1796 #ifdef ENABLE_VOSF
1797 // Recalculate pixel color expansion map
1798 if (!IsDirectMode(mode) && xdepth > 8) {
1799 for (int i=0; i<256; i++) {
1800 int c = i & (num_in-1); // If there are less than 256 colors, we repeat the first entries (this makes color expansion easier)
1801 ExpandMap[i] = map_rgb(pal[c*3+0], pal[c*3+1], pal[c*3+2]);
1802 }
1803
1804 // We have to redraw everything because the interpretation of pixel values changed
1805 LOCK_VOSF;
1806 PFLAG_SET_ALL;
1807 UNLOCK_VOSF;
1808 memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
1809 }
1810 #endif
1811
1812 // Tell redraw thread to change palette
1813 x_palette_changed = true;
1814
1815 UNLOCK_PALETTE;
1816 }
1817
1818
1819 /*
1820 * Switch video mode
1821 */
1822
1823 void X11_monitor_desc::switch_to_current_mode(void)
1824 {
1825 // Close and reopen display
1826 video_close();
1827 video_open();
1828
1829 if (drv == NULL) {
1830 ErrorAlert(STR_OPEN_WINDOW_ERR);
1831 QuitEmulator();
1832 }
1833 }
1834
1835
1836 /*
1837 * Translate key event to Mac keycode, returns -1 if no keycode was found
1838 * and -2 if the key was recognized as a hotkey
1839 */
1840
1841 static int kc_decode(KeySym ks, bool key_down)
1842 {
1843 switch (ks) {
1844 case XK_A: case XK_a: return 0x00;
1845 case XK_B: case XK_b: return 0x0b;
1846 case XK_C: case XK_c: return 0x08;
1847 case XK_D: case XK_d: return 0x02;
1848 case XK_E: case XK_e: return 0x0e;
1849 case XK_F: case XK_f: return 0x03;
1850 case XK_G: case XK_g: return 0x05;
1851 case XK_H: case XK_h: return 0x04;
1852 case XK_I: case XK_i: return 0x22;
1853 case XK_J: case XK_j: return 0x26;
1854 case XK_K: case XK_k: return 0x28;
1855 case XK_L: case XK_l: return 0x25;
1856 case XK_M: case XK_m: return 0x2e;
1857 case XK_N: case XK_n: return 0x2d;
1858 case XK_O: case XK_o: return 0x1f;
1859 case XK_P: case XK_p: return 0x23;
1860 case XK_Q: case XK_q: return 0x0c;
1861 case XK_R: case XK_r: return 0x0f;
1862 case XK_S: case XK_s: return 0x01;
1863 case XK_T: case XK_t: return 0x11;
1864 case XK_U: case XK_u: return 0x20;
1865 case XK_V: case XK_v: return 0x09;
1866 case XK_W: case XK_w: return 0x0d;
1867 case XK_X: case XK_x: return 0x07;
1868 case XK_Y: case XK_y: return 0x10;
1869 case XK_Z: case XK_z: return 0x06;
1870
1871 case XK_1: case XK_exclam: return 0x12;
1872 case XK_2: case XK_at: return 0x13;
1873 case XK_3: case XK_numbersign: return 0x14;
1874 case XK_4: case XK_dollar: return 0x15;
1875 case XK_5: case XK_percent: return 0x17;
1876 case XK_6: return 0x16;
1877 case XK_7: return 0x1a;
1878 case XK_8: return 0x1c;
1879 case XK_9: return 0x19;
1880 case XK_0: return 0x1d;
1881
1882 case XK_grave: case XK_asciitilde: return 0x0a;
1883 case XK_minus: case XK_underscore: return 0x1b;
1884 case XK_equal: case XK_plus: return 0x18;
1885 case XK_bracketleft: case XK_braceleft: return 0x21;
1886 case XK_bracketright: case XK_braceright: return 0x1e;
1887 case XK_backslash: case XK_bar: return 0x2a;
1888 case XK_semicolon: case XK_colon: return 0x29;
1889 case XK_apostrophe: case XK_quotedbl: return 0x27;
1890 case XK_comma: case XK_less: return 0x2b;
1891 case XK_period: case XK_greater: return 0x2f;
1892 case XK_slash: case XK_question: return 0x2c;
1893
1894 case XK_Tab: if (ctrl_down) {if (key_down) drv->suspend(); return -2;} else return 0x30;
1895 case XK_Return: return 0x24;
1896 case XK_space: return 0x31;
1897 case XK_BackSpace: return 0x33;
1898
1899 case XK_Delete: return 0x75;
1900 case XK_Insert: return 0x72;
1901 case XK_Home: case XK_Help: return 0x73;
1902 case XK_End: return 0x77;
1903 #ifdef __hpux
1904 case XK_Prior: return 0x74;
1905 case XK_Next: return 0x79;
1906 #else
1907 case XK_Page_Up: return 0x74;
1908 case XK_Page_Down: return 0x79;
1909 #endif
1910
1911 case XK_Control_L: return 0x36;
1912 case XK_Control_R: return 0x36;
1913 case XK_Shift_L: return 0x38;
1914 case XK_Shift_R: return 0x38;
1915 case XK_Alt_L: return 0x37;
1916 case XK_Alt_R: return 0x37;
1917 case XK_Meta_L: return 0x3a;
1918 case XK_Meta_R: return 0x3a;
1919 case XK_Menu: return 0x32;
1920 case XK_Caps_Lock: return 0x39;
1921 case XK_Num_Lock: return 0x47;
1922
1923 case XK_Up: return 0x3e;
1924 case XK_Down: return 0x3d;
1925 case XK_Left: return 0x3b;
1926 case XK_Right: return 0x3c;
1927
1928 case XK_Escape: if (ctrl_down) {if (key_down) { quit_full_screen = true; emerg_quit = true; } return -2;} else return 0x35;
1929
1930 case XK_F1: if (ctrl_down) {if (key_down) SysMountFirstFloppy(); return -2;} else return 0x7a;
1931 case XK_F2: return 0x78;
1932 case XK_F3: return 0x63;
1933 case XK_F4: return 0x76;
1934 case XK_F5: if (ctrl_down) {if (key_down) drv->toggle_mouse_grab(); return -2;} else return 0x60;
1935 case XK_F6: return 0x61;
1936 case XK_F7: return 0x62;
1937 case XK_F8: return 0x64;
1938 case XK_F9: return 0x65;
1939 case XK_F10: return 0x6d;
1940 case XK_F11: return 0x67;
1941 case XK_F12: return 0x6f;
1942
1943 case XK_Print: return 0x69;
1944 case XK_Scroll_Lock: return 0x6b;
1945 case XK_Pause: return 0x71;
1946
1947 #if defined(XK_KP_Prior) && defined(XK_KP_Left) && defined(XK_KP_Insert) && defined (XK_KP_End)
1948 case XK_KP_0: case XK_KP_Insert: return 0x52;
1949 case XK_KP_1: case XK_KP_End: return 0x53;
1950 case XK_KP_2: case XK_KP_Down: return 0x54;
1951 case XK_KP_3: case XK_KP_Next: return 0x55;
1952 case XK_KP_4: case XK_KP_Left: return 0x56;
1953 case XK_KP_5: case XK_KP_Begin: return 0x57;
1954 case XK_KP_6: case XK_KP_Right: return 0x58;
1955 case XK_KP_7: case XK_KP_Home: return 0x59;
1956 case XK_KP_8: case XK_KP_Up: return 0x5b;
1957 case XK_KP_9: case XK_KP_Prior: return 0x5c;
1958 case XK_KP_Decimal: case XK_KP_Delete: return 0x41;
1959 #else
1960 case XK_KP_0: return 0x52;
1961 case XK_KP_1: return 0x53;
1962 case XK_KP_2: return 0x54;
1963 case XK_KP_3: return 0x55;
1964 case XK_KP_4: return 0x56;
1965 case XK_KP_5: return 0x57;
1966 case XK_KP_6: return 0x58;
1967 case XK_KP_7: return 0x59;
1968 case XK_KP_8: return 0x5b;
1969 case XK_KP_9: return 0x5c;
1970 case XK_KP_Decimal: return 0x41;
1971 #endif
1972 case XK_KP_Add: return 0x45;
1973 case XK_KP_Subtract: return 0x4e;
1974 case XK_KP_Multiply: return 0x43;
1975 case XK_KP_Divide: return 0x4b;
1976 case XK_KP_Enter: return 0x4c;
1977 case XK_KP_Equal: return 0x51;
1978 }
1979 return -1;
1980 }
1981
1982 static int event2keycode(XKeyEvent &ev, bool key_down)
1983 {
1984 KeySym ks;
1985 int i = 0;
1986
1987 do {
1988 ks = XLookupKeysym(&ev, i++);
1989 int as = kc_decode(ks, key_down);
1990 if (as >= 0)
1991 return as;
1992 if (as == -2)
1993 return as;
1994 } while (ks != NoSymbol);
1995
1996 return -1;
1997 }
1998
1999
2000 /*
2001 * X event handling
2002 */
2003
2004 static void handle_events(void)
2005 {
2006 while (XPending(x_display)) {
2007 XEvent event;
2008 XNextEvent(x_display, &event);
2009
2010 switch (event.type) {
2011
2012 // Mouse button
2013 case ButtonPress: {
2014 unsigned int button = event.xbutton.button;
2015 if (button < 4)
2016 ADBMouseDown(button - 1);
2017 else if (button < 6) { // Wheel mouse
2018 if (mouse_wheel_mode == 0) {
2019 int key = (button == 5) ? 0x79 : 0x74; // Page up/down
2020 ADBKeyDown(key);
2021 ADBKeyUp(key);
2022 } else {
2023 int key = (button == 5) ? 0x3d : 0x3e; // Cursor up/down
2024 for(int i=0; i<mouse_wheel_lines; i++) {
2025 ADBKeyDown(key);
2026 ADBKeyUp(key);
2027 }
2028 }
2029 }
2030 break;
2031 }
2032 case ButtonRelease: {
2033 unsigned int button = event.xbutton.button;
2034 if (button < 4)
2035 ADBMouseUp(button - 1);
2036 break;
2037 }
2038
2039 // Mouse moved
2040 case MotionNotify:
2041 drv->mouse_moved(event.xmotion.x, event.xmotion.y);
2042 break;
2043
2044 // Mouse entered window
2045 case EnterNotify:
2046 if (event.xcrossing.mode != NotifyGrab && event.xcrossing.mode != NotifyUngrab)
2047 drv->mouse_moved(event.xmotion.x, event.xmotion.y);
2048 break;
2049
2050 // Keyboard
2051 case KeyPress: {
2052 int code = -1;
2053 if (use_keycodes) {
2054 if (event2keycode(event.xkey, true) != -2) // This is called to process the hotkeys
2055 code = keycode_table[event.xkey.keycode & 0xff];
2056 } else
2057 code = event2keycode(event.xkey, true);
2058 if (code >= 0) {
2059 if (!emul_suspended) {
2060 if (code == 0x39) { // Caps Lock pressed
2061 if (caps_on) {
2062 ADBKeyUp(code);
2063 caps_on = false;
2064 } else {
2065 ADBKeyDown(code);
2066 caps_on = true;
2067 }
2068 } else
2069 ADBKeyDown(code);
2070 if (code == 0x36)
2071 ctrl_down = true;
2072 } else {
2073 if (code == 0x31)
2074 drv->resume(); // Space wakes us up
2075 }
2076 }
2077 break;
2078 }
2079 case KeyRelease: {
2080 int code = -1;
2081 if (use_keycodes) {
2082 if (event2keycode(event.xkey, false) != -2) // This is called to process the hotkeys
2083 code = keycode_table[event.xkey.keycode & 0xff];
2084 } else
2085 code = event2keycode(event.xkey, false);
2086 if (code >= 0 && code != 0x39) { // Don't propagate Caps Lock releases
2087 ADBKeyUp(code);
2088 if (code == 0x36)
2089 ctrl_down = false;
2090 }
2091 break;
2092 }
2093
2094 // Hidden parts exposed, force complete refresh of window
2095 case Expose:
2096 if (display_type == DISPLAY_WINDOW) {
2097 const video_mode &mode = VideoMonitors[0]->get_current_mode();
2098 #ifdef ENABLE_VOSF
2099 if (use_vosf) { // VOSF refresh
2100 LOCK_VOSF;
2101 PFLAG_SET_ALL;
2102 UNLOCK_VOSF;
2103 memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
2104 }
2105 else
2106 #endif
2107 if (frame_skip == 0) { // Dynamic refresh
2108 int x1, y1;
2109 for (y1=0; y1<16; y1++)
2110 for (x1=0; x1<16; x1++)
2111 updt_box[x1][y1] = true;
2112 nr_boxes = 16 * 16;
2113 } else // Static refresh
2114 memset(the_buffer_copy, 0, mode.bytes_per_row * mode.y);
2115 }
2116 break;
2117
2118 // Window "close" widget clicked
2119 case ClientMessage:
2120 if (event.xclient.format == 32 && event.xclient.data.l[0] == WM_DELETE_WINDOW) {
2121 ADBKeyDown(0x7f); // Power key
2122 ADBKeyUp(0x7f);
2123 }
2124 break;
2125 }
2126 }
2127 }
2128
2129
2130 /*
2131 * Window display update
2132 */
2133
2134 // Dynamic display update (variable frame rate for each box)
2135 static void update_display_dynamic(int ticker, driver_window *drv)
2136 {
2137 int y1, y2, y2s, y2a, i, x1, xm, xmo, ymo, yo, yi, yil, xi;
2138 int xil = 0;
2139 int rxm = 0, rxmo = 0;
2140 const video_mode &mode = drv->monitor.get_current_mode();
2141 int bytes_per_row = mode.bytes_per_row;
2142 int bytes_per_pixel = mode.bytes_per_row / mode.x;
2143 int rx = mode.bytes_per_row / 16;
2144 int ry = mode.y / 16;
2145 int max_box;
2146
2147 y2s = sm_uptd[ticker % 8];
2148 y2a = 8;
2149 for (i = 0; i < 6; i++)
2150 if (ticker % (2 << i))
2151 break;
2152 max_box = sm_no_boxes[i];
2153
2154 if (y2a) {
2155 for (y1=0; y1<16; y1++) {
2156 for (y2=y2s; y2 < ry; y2 += y2a) {
2157 i = ((y1 * ry) + y2) * bytes_per_row;
2158 for (x1=0; x1<16; x1++, i += rx) {
2159 if (updt_box[x1][y1] == false) {
2160 if (memcmp(&the_buffer_copy[i], &the_buffer[i], rx)) {
2161 updt_box[x1][y1] = true;
2162 nr_boxes++;
2163 }
2164 }
2165 }
2166 }
2167 }
2168 }
2169
2170 if ((nr_boxes <= max_box) && (nr_boxes)) {
2171 for (y1=0; y1<16; y1++) {
2172 for (x1=0; x1<16; x1++) {
2173 if (updt_box[x1][y1] == true) {
2174 if (rxm == 0)
2175 xm = x1;
2176 rxm += rx;
2177 updt_box[x1][y1] = false;
2178 }
2179 if (((updt_box[x1+1][y1] == false) || (x1 == 15)) && (rxm)) {
2180 if ((rxmo != rxm) || (xmo != xm) || (yo != y1 - 1)) {
2181 if (rxmo) {
2182 xi = xmo * rx;
2183 yi = ymo * ry;
2184 xil = rxmo;
2185 yil = (yo - ymo +1) * ry;
2186 }
2187 rxmo = rxm;
2188 xmo = xm;
2189 ymo = y1;
2190 }
2191 rxm = 0;
2192 yo = y1;
2193 }
2194 if (xil) {
2195 i = (yi * bytes_per_row) + xi;
2196 for (y2=0; y2 < yil; y2++, i += bytes_per_row)
2197 memcpy(&the_buffer_copy[i], &the_buffer[i], xil);
2198 if (mode.depth == VDEPTH_1BIT) {
2199 if (drv->have_shm)
2200 XShmPutImage(x_display, drv->w, drv->gc, drv->img, xi * 8, yi, xi * 8, yi, xil * 8, yil, 0);
2201 else
2202 XPutImage(x_display, drv->w, drv->gc, drv->img, xi * 8, yi, xi * 8, yi, xil * 8, yil);
2203 } else {
2204 if (drv->have_shm)
2205 XShmPutImage(x_display, drv->w, drv->gc, drv->img, xi / bytes_per_pixel, yi, xi / bytes_per_pixel, yi, xil / bytes_per_pixel, yil, 0);
2206 else
2207 XPutImage(x_display, drv->w, drv->gc, drv->img, xi / bytes_per_pixel, yi, xi / bytes_per_pixel, yi, xil / bytes_per_pixel, yil);
2208 }
2209 xil = 0;
2210 }
2211 if ((x1 == 15) && (y1 == 15) && (rxmo)) {
2212 x1--;
2213 xi = xmo * rx;
2214 yi = ymo * ry;
2215 xil = rxmo;
2216 yil = (yo - ymo +1) * ry;
2217 rxmo = 0;
2218 }
2219 }
2220 }
2221 nr_boxes = 0;
2222 }
2223 }
2224
2225 // Static display update (fixed frame rate, but incremental)
2226 static void update_display_static(driver_window *drv)
2227 {
2228 // Incremental update code
2229 unsigned wide = 0, high = 0, x1, x2, y1, y2, i, j;
2230 const video_mode &mode = drv->monitor.get_current_mode();
2231 int bytes_per_row = mode.bytes_per_row;
2232 int bytes_per_pixel = mode.bytes_per_row / mode.x;
2233 uint8 *p, *p2;
2234
2235 // Check for first line from top and first line from bottom that have changed
2236 y1 = 0;
2237 for (j=0; j<mode.y; j++) {
2238 if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
2239 y1 = j;
2240 break;
2241 }
2242 }
2243 y2 = y1 - 1;
2244 for (j=mode.y-1; j>=y1; j--) {
2245 if (memcmp(&the_buffer[j * bytes_per_row], &the_buffer_copy[j * bytes_per_row], bytes_per_row)) {
2246 y2 = j;
2247 break;
2248 }
2249 }
2250 high = y2 - y1 + 1;
2251
2252 // Check for first column from left and first column from right that have changed
2253 if (high) {
2254 if (mode.depth == VDEPTH_1BIT) {
2255 x1 = mode.x - 1;
2256 for (j=y1; j<=y2; j++) {
2257 p = &the_buffer[j * bytes_per_row];
2258 p2 = &the_buffer_copy[j * bytes_per_row];
2259 for (i=0; i<(x1>>3); i++) {
2260 if (*p != *p2) {
2261 x1 = i << 3;
2262 break;
2263 }
2264 p++; p2++;
2265 }
2266 }
2267 x2 = x1;
2268 for (j=y1; j<=y2; j++) {
2269 p = &the_buffer[j * bytes_per_row];
2270 p2 = &the_buffer_copy[j * bytes_per_row];
2271 p += bytes_per_row;
2272 p2 += bytes_per_row;
2273 for (i=(mode.x>>3); i>(x2>>3); i--) {
2274 p--; p2--;
2275 if (*p != *p2) {
2276 x2 = (i << 3) + 7;
2277 break;
2278 }
2279 }
2280 }
2281 wide = x2 - x1 + 1;
2282
2283 // Update copy of the_buffer
2284 if (high && wide) {
2285 for (j=y1; j<=y2; j++) {
2286 i = j * bytes_per_row + (x1 >> 3);
2287 memcpy(the_buffer_copy + i, the_buffer + i, wide >> 3);
2288 }
2289 }
2290
2291 } else {
2292 x1 = mode.x;
2293 for (j=y1; j<=y2; j++) {
2294 p = &the_buffer[j * bytes_per_row];
2295 p2 = &the_buffer_copy[j * bytes_per_row];
2296 for (i=0; i<x1*bytes_per_pixel; i++) {
2297 if (*p != *p2) {
2298 x1 = i / bytes_per_pixel;
2299 break;
2300 }
2301 p++; p2++;
2302 }
2303 }
2304 x2 = x1;
2305 for (j=y1; j<=y2; j++) {
2306 p = &the_buffer[j * bytes_per_row];
2307 p2 = &the_buffer_copy[j * bytes_per_row];
2308 p += bytes_per_row;
2309 p2 += bytes_per_row;
2310 for (i=mode.x*bytes_per_pixel; i>x2*bytes_per_pixel; i--) {
2311 p--;
2312 p2--;
2313 if (*p != *p2) {
2314 x2 = i / bytes_per_pixel;
2315 break;
2316 }
2317 }
2318 }
2319 wide = x2 - x1;
2320
2321 // Update copy of the_buffer
2322 if (high && wide) {
2323 for (j=y1; j<=y2; j++) {
2324 i = j * bytes_per_row + x1 * bytes_per_pixel;
2325 memcpy(the_buffer_copy + i, the_buffer + i, bytes_per_pixel * wide);
2326 }
2327 }
2328 }
2329 }
2330
2331 // Refresh display
2332 if (high && wide) {
2333 if (drv->have_shm)
2334 XShmPutImage(x_display, drv->w, drv->gc, drv->img, x1, y1, x1, y1, wide, high, 0);
2335 else
2336 XPutImage(x_display, drv->w, drv->gc, drv->img, x1, y1, x1, y1, wide, high);
2337 }
2338 }
2339
2340
2341 /*
2342 * Screen refresh functions
2343 */
2344
2345 // We suggest the compiler to inline the next two functions so that it
2346 // may specialise the code according to the current screen depth and
2347 // display type. A clever compiler would do that job by itself though...
2348
2349 // NOTE: update_display_vosf is inlined too
2350
2351 static inline void possibly_quit_dga_mode()
2352 {
2353 // Quit DGA mode if requested (something terrible has happened and we
2354 // want to give control back to the user)
2355 if (quit_full_screen) {
2356 quit_full_screen = false;
2357 delete drv;
2358 drv = NULL;
2359 }
2360 }
2361
2362 static inline void possibly_ungrab_mouse()
2363 {
2364 // Ungrab mouse if requested (something terrible has happened and we
2365 // want to give control back to the user)
2366 if (quit_full_screen) {
2367 quit_full_screen = false;
2368 if (drv)
2369 drv->ungrab_mouse();
2370 }
2371 }
2372
2373 static inline void handle_palette_changes(void)
2374 {
2375 LOCK_PALETTE;
2376
2377 if (x_palette_changed) {
2378 x_palette_changed = false;
2379 drv->update_palette();
2380 }
2381
2382 UNLOCK_PALETTE;
2383 }
2384
2385 static void video_refresh_dga(void)
2386 {
2387 // Quit DGA mode if requested
2388 possibly_quit_dga_mode();
2389 }
2390
2391 #ifdef ENABLE_VOSF
2392 #if REAL_ADDRESSING || DIRECT_ADDRESSING
2393 static void video_refresh_dga_vosf(void)
2394 {
2395 // Quit DGA mode if requested
2396 possibly_quit_dga_mode();
2397
2398 // Update display (VOSF variant)
2399 static int tick_counter = 0;
2400 if (++tick_counter >= frame_skip) {
2401 tick_counter = 0;
2402 if (mainBuffer.dirty) {
2403 LOCK_VOSF;
2404 update_display_dga_vosf();
2405 UNLOCK_VOSF;
2406 }
2407 }
2408 }
2409 #endif
2410
2411 static void video_refresh_window_vosf(void)
2412 {
2413 // Ungrab mouse if requested
2414 possibly_ungrab_mouse();
2415
2416 // Update display (VOSF variant)
2417 static int tick_counter = 0;
2418 if (++tick_counter >= frame_skip) {
2419 tick_counter = 0;
2420 if (mainBuffer.dirty) {
2421 LOCK_VOSF;
2422 update_display_window_vosf(static_cast<driver_window *>(drv));
2423 UNLOCK_VOSF;
2424 XSync(x_display, false); // Let the server catch up
2425 }
2426 }
2427 }
2428 #endif // def ENABLE_VOSF
2429
2430 static void video_refresh_window_static(void)
2431 {
2432 // Ungrab mouse if requested
2433 possibly_ungrab_mouse();
2434
2435 // Update display (static variant)
2436 static int tick_counter = 0;
2437 if (++tick_counter >= frame_skip) {
2438 tick_counter = 0;
2439 update_display_static(static_cast<driver_window *>(drv));
2440 }
2441 }
2442
2443 static void video_refresh_window_dynamic(void)
2444 {
2445 // Ungrab mouse if requested
2446 possibly_ungrab_mouse();
2447
2448 // Update display (dynamic variant)
2449 static int tick_counter = 0;
2450 tick_counter++;
2451 update_display_dynamic(tick_counter, static_cast<driver_window *>(drv));
2452 }
2453
2454
2455 /*
2456 * Thread for screen refresh, input handling etc.
2457 */
2458
2459 static void VideoRefreshInit(void)
2460 {
2461 // TODO: set up specialised 8bpp VideoRefresh handlers ?
2462 if (display_type == DISPLAY_DGA) {
2463 #if ENABLE_VOSF && (REAL_ADDRESSING || DIRECT_ADDRESSING)
2464 if (use_vosf)
2465 video_refresh = video_refresh_dga_vosf;
2466 else
2467 #endif
2468 video_refresh = video_refresh_dga;
2469 }
2470 else {
2471 #ifdef ENABLE_VOSF
2472 if (use_vosf)
2473 video_refresh = video_refresh_window_vosf;
2474 else
2475 #endif
2476 if (frame_skip == 0)
2477 video_refresh = video_refresh_window_dynamic;
2478 else
2479 video_refresh = video_refresh_window_static;
2480 }
2481 }
2482
2483 // This function is called on non-threaded platforms from a timer interrupt
2484 void VideoRefresh(void)
2485 {
2486 // We need to check redraw_thread_active to inhibit refreshed during
2487 // mode changes on non-threaded platforms
2488 if (!redraw_thread_active)
2489 return;
2490
2491 // Handle X events
2492 handle_events();
2493
2494 // Handle palette changes
2495 handle_palette_changes();
2496
2497 // Update display
2498 video_refresh();
2499 }
2500
2501 const int VIDEO_REFRESH_HZ = 60;
2502 const int VIDEO_REFRESH_DELAY = 1000000 / VIDEO_REFRESH_HZ;
2503
2504 #ifdef HAVE_PTHREADS
2505 static void *redraw_func(void *arg)
2506 {
2507 int fd = ConnectionNumber(x_display);
2508
2509 uint64 start = GetTicks_usec();
2510 int64 ticks = 0;
2511 uint64 next = GetTicks_usec() + VIDEO_REFRESH_DELAY;
2512
2513 while (!redraw_thread_cancel) {
2514
2515 int64 delay = next - GetTicks_usec();
2516 if (delay < -VIDEO_REFRESH_DELAY) {
2517
2518 // We are lagging far behind, so we reset the delay mechanism
2519 next = GetTicks_usec();
2520
2521 } else if (delay <= 0) {
2522
2523 // Delay expired, refresh display
2524 handle_events();
2525 handle_palette_changes();
2526 video_refresh();
2527 next += VIDEO_REFRESH_DELAY;
2528 ticks++;
2529
2530 } else {
2531
2532 // No display refresh pending, check for X events
2533 fd_set readfds;
2534 FD_ZERO(&readfds);
2535 FD_SET(fd, &readfds);
2536 struct timeval timeout;
2537 timeout.tv_sec = 0;
2538 timeout.tv_usec = delay;
2539 if (select(fd+1, &readfds, NULL, NULL, &timeout) > 0)
2540 handle_events();
2541 }
2542 }
2543
2544 uint64 end = GetTicks_usec();
2545 D(bug("%Ld refreshes in %Ld usec = %f refreshes/sec\n", ticks, end - start, ticks * 1000000.0 / (end - start)));
2546 return NULL;
2547 }
2548 #endif