32 |
|
#include <algorithm> |
33 |
|
|
34 |
|
#ifdef ENABLE_XF86_DGA |
35 |
< |
#include <X11/extensions/xf86dga.h> |
35 |
> |
# include <X11/extensions/xf86dga.h> |
36 |
|
#endif |
37 |
|
|
38 |
|
#ifdef ENABLE_XF86_VIDMODE |
63 |
|
static int16 mouse_wheel_mode; |
64 |
|
static int16 mouse_wheel_lines; |
65 |
|
static bool redraw_thread_active = false; // Flag: Redraw thread installed |
66 |
+ |
static pthread_attr_t redraw_thread_attr; // Redraw thread attributes |
67 |
|
static pthread_t redraw_thread; // Redraw thread |
68 |
|
|
69 |
|
static bool local_X11; // Flag: X server running on local machine? |
126 |
|
static uint32 the_buffer_size; // Size of allocated the_buffer |
127 |
|
|
128 |
|
// Variables for DGA mode |
128 |
– |
static char *dga_screen_base; |
129 |
– |
static int dga_fb_width; |
129 |
|
static int current_dga_cmap; |
130 |
|
|
131 |
|
#ifdef ENABLE_XF86_VIDMODE |
195 |
|
} |
196 |
|
} |
197 |
|
|
198 |
+ |
// Return bits per pixel for requested depth |
199 |
+ |
static inline int bytes_per_pixel(int depth) |
200 |
+ |
{ |
201 |
+ |
int bpp; |
202 |
+ |
switch (depth) { |
203 |
+ |
case 8: |
204 |
+ |
bpp = 1; |
205 |
+ |
break; |
206 |
+ |
case 15: case 16: |
207 |
+ |
bpp = 2; |
208 |
+ |
break; |
209 |
+ |
case 24: case 32: |
210 |
+ |
bpp = 4; |
211 |
+ |
break; |
212 |
+ |
default: |
213 |
+ |
abort(); |
214 |
+ |
} |
215 |
+ |
return bpp; |
216 |
+ |
} |
217 |
+ |
|
218 |
|
// Map video_mode depth ID to numerical depth value |
219 |
|
static inline int depth_of_video_mode(int mode) |
220 |
|
{ |
221 |
< |
int depth = -1; |
221 |
> |
int depth; |
222 |
|
switch (mode) { |
223 |
|
case APPLE_1_BIT: |
224 |
|
depth = 1; |
368 |
|
} |
369 |
|
|
370 |
|
// Wait until window is mapped/unmapped |
371 |
< |
void wait_mapped(Window w) |
371 |
> |
static void wait_mapped(Window w) |
372 |
|
{ |
373 |
|
XEvent e; |
374 |
|
do { |
376 |
|
} while ((e.type != MapNotify) || (e.xmap.event != w)); |
377 |
|
} |
378 |
|
|
379 |
< |
void wait_unmapped(Window w) |
379 |
> |
static void wait_unmapped(Window w) |
380 |
|
{ |
381 |
|
XEvent e; |
382 |
|
do { |
541 |
|
// Set relative mouse mode |
542 |
|
ADBSetRelMouseMode(true); |
543 |
|
|
544 |
+ |
// Create window |
545 |
+ |
XSetWindowAttributes wattr; |
546 |
+ |
wattr.event_mask = eventmask = dga_eventmask; |
547 |
+ |
wattr.override_redirect = True; |
548 |
+ |
wattr.colormap = (depth == 1 ? DefaultColormap(x_display, screen) : cmap[0]); |
549 |
+ |
the_win = XCreateWindow(x_display, rootwin, 0, 0, width, height, 0, xdepth, |
550 |
+ |
InputOutput, vis, CWEventMask | CWOverrideRedirect | |
551 |
+ |
(color_class == DirectColor ? CWColormap : 0), &wattr); |
552 |
+ |
|
553 |
+ |
// Show window |
554 |
+ |
XMapRaised(x_display, the_win); |
555 |
+ |
wait_mapped(the_win); |
556 |
+ |
|
557 |
|
#ifdef ENABLE_XF86_VIDMODE |
558 |
|
// Switch to best mode |
559 |
|
if (has_vidmode) { |
570 |
|
#endif |
571 |
|
|
572 |
|
// Establish direct screen connection |
573 |
+ |
XMoveResizeWindow(x_display, the_win, 0, 0, width, height); |
574 |
+ |
XWarpPointer(x_display, None, rootwin, 0, 0, 0, 0, 0, 0); |
575 |
|
XGrabKeyboard(x_display, rootwin, True, GrabModeAsync, GrabModeAsync, CurrentTime); |
576 |
|
XGrabPointer(x_display, rootwin, True, PointerMotionMask | ButtonPressMask | ButtonReleaseMask, GrabModeAsync, GrabModeAsync, None, None, CurrentTime); |
577 |
+ |
|
578 |
+ |
int v_width, v_bank, v_size; |
579 |
+ |
XF86DGAGetVideo(x_display, screen, (char **)&the_buffer, &v_width, &v_bank, &v_size); |
580 |
|
XF86DGADirectVideo(x_display, screen, XF86DGADirectGraphics | XF86DGADirectKeyb | XF86DGADirectMouse); |
581 |
|
XF86DGASetViewPort(x_display, screen, 0, 0); |
582 |
|
XF86DGASetVidPage(x_display, screen, 0); |
583 |
|
|
584 |
|
// Set colormap |
585 |
< |
if (depth == 8) |
585 |
> |
if (!IsDirectMode(get_current_mode())) { |
586 |
> |
XSetWindowColormap(x_display, the_win, cmap[current_dga_cmap = 0]); |
587 |
|
XF86DGAInstallColormap(x_display, screen, cmap[current_dga_cmap]); |
588 |
+ |
} |
589 |
+ |
XSync(x_display, false); |
590 |
|
|
591 |
< |
// Set bytes per row |
592 |
< |
int bytes_per_row = TrivialBytesPerRow((dga_fb_width + 7) & ~7, DepthModeForPixelDepth(depth)); |
553 |
< |
|
591 |
> |
// Init blitting routines |
592 |
> |
int bytes_per_row = TrivialBytesPerRow((v_width + 7) & ~7, DepthModeForPixelDepth(depth)); |
593 |
|
#if ENABLE_VOSF |
594 |
|
bool native_byte_order; |
595 |
|
#ifdef WORDS_BIGENDIAN |
608 |
|
the_buffer_size = page_extend((height + 2) * bytes_per_row); |
609 |
|
the_buffer_copy = (uint8 *)malloc(the_buffer_size); |
610 |
|
the_buffer = (uint8 *)vm_acquire(the_buffer_size); |
611 |
+ |
D(bug("the_buffer = %p, the_buffer_copy = %p, the_host_buffer = %p\n", the_buffer, the_buffer_copy, the_host_buffer)); |
612 |
|
} |
613 |
|
#else |
614 |
|
use_vosf = false; |
575 |
– |
the_buffer = dga_screen_base; |
615 |
|
#endif |
616 |
|
#endif |
578 |
– |
screen_base = (uint32)the_buffer; |
617 |
|
|
618 |
+ |
// Set frame buffer base |
619 |
+ |
D(bug("the_buffer = %p, use_vosf = %d\n", the_buffer, use_vosf)); |
620 |
+ |
screen_base = (uint32)the_buffer; |
621 |
|
VModes[cur_mode].viRowBytes = bytes_per_row; |
581 |
– |
XSync(x_display, false); |
622 |
|
return true; |
623 |
|
#else |
624 |
|
ErrorAlert("SheepShaver has been compiled with DGA support disabled."); |
751 |
|
if (the_gc) |
752 |
|
XFreeGC(x_display, the_gc); |
753 |
|
|
714 |
– |
// Close window |
715 |
– |
if (the_win) { |
716 |
– |
XUnmapWindow(x_display, the_win); |
717 |
– |
wait_unmapped(the_win); |
718 |
– |
XDestroyWindow(x_display, the_win); |
719 |
– |
} |
720 |
– |
|
754 |
|
XFlush(x_display); |
755 |
|
XSync(x_display, false); |
756 |
|
} |
788 |
|
else if (display_type == DIS_WINDOW) |
789 |
|
close_window(); |
790 |
|
|
791 |
+ |
// Close window |
792 |
+ |
if (the_win) { |
793 |
+ |
XUnmapWindow(x_display, the_win); |
794 |
+ |
wait_unmapped(the_win); |
795 |
+ |
XDestroyWindow(x_display, the_win); |
796 |
+ |
} |
797 |
+ |
|
798 |
|
// Free colormaps |
799 |
|
if (cmap[0]) { |
800 |
|
XFreeColormap(x_display, cmap[0]); |
911 |
|
} |
912 |
|
} |
913 |
|
|
914 |
+ |
// Find Apple mode matching best specified dimensions |
915 |
+ |
static int find_apple_resolution(int xsize, int ysize) |
916 |
+ |
{ |
917 |
+ |
int apple_id; |
918 |
+ |
if (xsize < 800) |
919 |
+ |
apple_id = APPLE_640x480; |
920 |
+ |
else if (xsize < 1024) |
921 |
+ |
apple_id = APPLE_800x600; |
922 |
+ |
else if (xsize < 1152) |
923 |
+ |
apple_id = APPLE_1024x768; |
924 |
+ |
else if (xsize < 1280) { |
925 |
+ |
if (ysize < 900) |
926 |
+ |
apple_id = APPLE_1152x768; |
927 |
+ |
else |
928 |
+ |
apple_id = APPLE_1152x900; |
929 |
+ |
} |
930 |
+ |
else if (xsize < 1600) |
931 |
+ |
apple_id = APPLE_1280x1024; |
932 |
+ |
else |
933 |
+ |
apple_id = APPLE_1600x1200; |
934 |
+ |
return apple_id; |
935 |
+ |
} |
936 |
+ |
|
937 |
+ |
// Find mode in list of supported modes |
938 |
+ |
static int find_mode(int apple_mode, int apple_id, int type) |
939 |
+ |
{ |
940 |
+ |
for (VideoInfo *p = VModes; p->viType != DIS_INVALID; p++) { |
941 |
+ |
if (p->viType == type && p->viAppleID == apple_id && p->viAppleMode == apple_mode) |
942 |
+ |
return p - VModes; |
943 |
+ |
} |
944 |
+ |
return -1; |
945 |
+ |
} |
946 |
+ |
|
947 |
|
// Add mode to list of supported modes |
948 |
|
static void add_mode(VideoInfo *&p, uint32 allow, uint32 test, int apple_mode, int apple_id, int type) |
949 |
|
{ |
964 |
|
p->viXsize = 1024; |
965 |
|
p->viYsize = 768; |
966 |
|
break; |
967 |
+ |
case APPLE_1152x768: |
968 |
+ |
p->viXsize = 1152; |
969 |
+ |
p->viYsize = 768; |
970 |
+ |
break; |
971 |
|
case APPLE_1152x900: |
972 |
|
p->viXsize = 1152; |
973 |
|
p->viYsize = 900; |
1114 |
|
add_mode(p, screen_modes, 2, default_mode, APPLE_800x600, DIS_SCREEN); |
1115 |
|
if (has_mode(1024, 768)) |
1116 |
|
add_mode(p, screen_modes, 4, default_mode, APPLE_1024x768, DIS_SCREEN); |
1117 |
+ |
if (has_mode(1152, 768)) |
1118 |
+ |
add_mode(p, screen_modes, 64, default_mode, APPLE_1152x768, DIS_SCREEN); |
1119 |
|
if (has_mode(1152, 900)) |
1120 |
|
add_mode(p, screen_modes, 8, default_mode, APPLE_1152x900, DIS_SCREEN); |
1121 |
|
if (has_mode(1280, 1024)) |
1125 |
|
} else if (screen_modes) { |
1126 |
|
int xsize = DisplayWidth(x_display, screen); |
1127 |
|
int ysize = DisplayHeight(x_display, screen); |
1128 |
< |
int apple_id; |
1050 |
< |
if (xsize < 800) |
1051 |
< |
apple_id = APPLE_640x480; |
1052 |
< |
else if (xsize < 1024) |
1053 |
< |
apple_id = APPLE_800x600; |
1054 |
< |
else if (xsize < 1152) |
1055 |
< |
apple_id = APPLE_1024x768; |
1056 |
< |
else if (xsize < 1280) |
1057 |
< |
apple_id = APPLE_1152x900; |
1058 |
< |
else if (xsize < 1600) |
1059 |
< |
apple_id = APPLE_1280x1024; |
1060 |
< |
else |
1061 |
< |
apple_id = APPLE_1600x1200; |
1128 |
> |
int apple_id = find_apple_resolution(xsize, ysize); |
1129 |
|
p->viType = DIS_SCREEN; |
1130 |
|
p->viRowBytes = 0; |
1131 |
|
p->viXsize = xsize; |
1142 |
|
|
1143 |
|
// Find default mode (window 640x480) |
1144 |
|
cur_mode = -1; |
1145 |
< |
for (p = VModes; p->viType != DIS_INVALID; p++) { |
1146 |
< |
if (p->viType == DIS_WINDOW |
1147 |
< |
&& p->viAppleID == APPLE_W_640x480 |
1148 |
< |
&& p->viAppleMode == default_mode) { |
1149 |
< |
cur_mode = p - VModes; |
1150 |
< |
break; |
1084 |
< |
} |
1145 |
> |
if (has_dga && screen_modes) { |
1146 |
> |
int screen_width = DisplayWidth(x_display, screen); |
1147 |
> |
int screen_height = DisplayHeight(x_display, screen); |
1148 |
> |
int apple_id = find_apple_resolution(screen_width, screen_height); |
1149 |
> |
if (apple_id != -1) |
1150 |
> |
cur_mode = find_mode(default_mode, apple_id, DIS_SCREEN); |
1151 |
|
} |
1152 |
+ |
if (cur_mode == -1) |
1153 |
+ |
cur_mode = find_mode(default_mode, APPLE_W_640x480, DIS_WINDOW); |
1154 |
|
assert(cur_mode != -1); |
1155 |
|
|
1156 |
|
#if DEBUG |
1161 |
|
} |
1162 |
|
#endif |
1163 |
|
|
1096 |
– |
#ifdef ENABLE_XF86_DGA |
1097 |
– |
if (has_dga && screen_modes) { |
1098 |
– |
int v_bank, v_size; |
1099 |
– |
XF86DGAGetVideo(x_display, screen, &dga_screen_base, &dga_fb_width, &v_bank, &v_size); |
1100 |
– |
D(bug("DGA screen_base %p, v_width %d\n", dga_screen_base, dga_fb_width)); |
1101 |
– |
} |
1102 |
– |
#endif |
1103 |
– |
|
1164 |
|
// Open window/screen |
1165 |
|
if (!open_display()) |
1166 |
|
return false; |
1172 |
|
|
1173 |
|
// Start periodic thread |
1174 |
|
XSync(x_display, false); |
1175 |
< |
redraw_thread_active = (pthread_create(&redraw_thread, NULL, redraw_func, NULL) == 0); |
1175 |
> |
Set_pthread_attr(&redraw_thread_attr, 0); |
1176 |
> |
redraw_thread_active = (pthread_create(&redraw_thread, &redraw_thread_attr, redraw_func, NULL) == 0); |
1177 |
|
D(bug("Redraw thread installed (%ld)\n", redraw_thread)); |
1178 |
|
return true; |
1179 |
|
} |
1536 |
|
break; |
1537 |
|
} |
1538 |
|
|
1539 |
< |
// Mouse moved |
1539 |
> |
// Mouse entered window |
1540 |
|
case EnterNotify: |
1541 |
< |
ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y); |
1541 |
> |
if (event.xcrossing.mode != NotifyGrab && event.xcrossing.mode != NotifyUngrab) |
1542 |
> |
ADBMouseMoved(event.xmotion.x, event.xmotion.y); |
1543 |
|
break; |
1544 |
+ |
|
1545 |
+ |
// Mouse moved |
1546 |
|
case MotionNotify: |
1547 |
< |
ADBMouseMoved(((XMotionEvent *)&event)->x, ((XMotionEvent *)&event)->y); |
1547 |
> |
ADBMouseMoved(event.xmotion.x, event.xmotion.y); |
1548 |
|
break; |
1549 |
|
|
1550 |
|
// Keyboard |
1612 |
|
*/ |
1613 |
|
|
1614 |
|
#if 0 |
1551 |
– |
// Rectangle blitting |
1552 |
– |
static void accl_bitblt(accl_params *p) |
1553 |
– |
{ |
1554 |
– |
D(bug("accl_bitblt\n")); |
1555 |
– |
|
1556 |
– |
// Get blitting parameters |
1557 |
– |
int16 src_X = p->src_rect[1] - p->src_bounds[1]; |
1558 |
– |
int16 src_Y = p->src_rect[0] - p->src_bounds[0]; |
1559 |
– |
int16 dest_X = p->dest_rect[1] - p->dest_bounds[1]; |
1560 |
– |
int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0]; |
1561 |
– |
int16 width = p->dest_rect[3] - p->dest_rect[1] - 1; |
1562 |
– |
int16 height = p->dest_rect[2] - p->dest_rect[0] - 1; |
1563 |
– |
D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y)); |
1564 |
– |
D(bug(" width %d, height %d\n", width, height)); |
1565 |
– |
|
1566 |
– |
// And perform the blit |
1567 |
– |
bitblt_hook(src_X, src_Y, dest_X, dest_Y, width, height); |
1568 |
– |
} |
1569 |
– |
|
1570 |
– |
static bool accl_bitblt_hook(accl_params *p) |
1571 |
– |
{ |
1572 |
– |
D(bug("accl_draw_hook %p\n", p)); |
1573 |
– |
|
1574 |
– |
// Check if we can accelerate this bitblt |
1575 |
– |
if (p->src_base_addr == screen_base && p->dest_base_addr == screen_base && |
1576 |
– |
display_type == DIS_SCREEN && bitblt_hook != NULL && |
1577 |
– |
((uint32 *)p)[0x18 >> 2] + ((uint32 *)p)[0x128 >> 2] == 0 && |
1578 |
– |
((uint32 *)p)[0x130 >> 2] == 0 && |
1579 |
– |
p->transfer_mode == 0 && |
1580 |
– |
p->src_row_bytes > 0 && ((uint32 *)p)[0x15c >> 2] > 0) { |
1581 |
– |
|
1582 |
– |
// Yes, set function pointer |
1583 |
– |
p->draw_proc = accl_bitblt; |
1584 |
– |
return true; |
1585 |
– |
} |
1586 |
– |
return false; |
1587 |
– |
} |
1588 |
– |
|
1615 |
|
// Rectangle filling/inversion |
1616 |
|
static void accl_fillrect8(accl_params *p) |
1617 |
|
{ |
1689 |
|
return false; |
1690 |
|
} |
1691 |
|
|
1692 |
+ |
static struct accl_hook_info fillrect_hook_info = {accl_fillrect_hook, accl_sync_hook, ACCL_FILLRECT}; |
1693 |
+ |
#endif |
1694 |
+ |
|
1695 |
+ |
// Rectangle blitting |
1696 |
+ |
// TODO: optimize for VOSF and target pixmap == screen |
1697 |
+ |
void NQD_bitblt(uint32 arg) |
1698 |
+ |
{ |
1699 |
+ |
D(bug("accl_bitblt %08x\n", arg)); |
1700 |
+ |
accl_params *p = (accl_params *)arg; |
1701 |
+ |
|
1702 |
+ |
// Get blitting parameters |
1703 |
+ |
int16 src_X = p->src_rect[1] - p->src_bounds[1]; |
1704 |
+ |
int16 src_Y = p->src_rect[0] - p->src_bounds[0]; |
1705 |
+ |
int16 dest_X = p->dest_rect[1] - p->dest_bounds[1]; |
1706 |
+ |
int16 dest_Y = p->dest_rect[0] - p->dest_bounds[0]; |
1707 |
+ |
int16 width = p->dest_rect[3] - p->dest_rect[1]; |
1708 |
+ |
int16 height = p->dest_rect[2] - p->dest_rect[0]; |
1709 |
+ |
D(bug(" src addr %08x, dest addr %08x\n", p->src_base_addr, p->dest_base_addr)); |
1710 |
+ |
D(bug(" src X %d, src Y %d, dest X %d, dest Y %d\n", src_X, src_Y, dest_X, dest_Y)); |
1711 |
+ |
D(bug(" width %d, height %d\n", width, height)); |
1712 |
+ |
|
1713 |
+ |
// And perform the blit |
1714 |
+ |
const int bpp = bytes_per_pixel(p->src_pixel_size); |
1715 |
+ |
width *= bpp; |
1716 |
+ |
if (p->src_row_bytes > 0) { |
1717 |
+ |
const int src_row_bytes = p->src_row_bytes; |
1718 |
+ |
const int dst_row_bytes = p->dest_row_bytes; |
1719 |
+ |
uint8 *src = (uint8 *)p->src_base_addr + (src_Y * src_row_bytes) + (src_X * bpp); |
1720 |
+ |
uint8 *dst = (uint8 *)p->dest_base_addr + (dest_Y * dst_row_bytes) + (dest_X * bpp); |
1721 |
+ |
for (int i = 0; i < height; i++) { |
1722 |
+ |
memcpy(dst, src, width); |
1723 |
+ |
src += src_row_bytes; |
1724 |
+ |
dst += dst_row_bytes; |
1725 |
+ |
} |
1726 |
+ |
} |
1727 |
+ |
else { |
1728 |
+ |
const int src_row_bytes = -p->src_row_bytes; |
1729 |
+ |
const int dst_row_bytes = -p->dest_row_bytes; |
1730 |
+ |
uint8 *src = (uint8 *)p->src_base_addr + ((src_Y + height - 1) * src_row_bytes) + (src_X * bpp); |
1731 |
+ |
uint8 *dst = (uint8 *)p->dest_base_addr + ((dest_Y + height - 1) * dst_row_bytes) + (dest_X * bpp); |
1732 |
+ |
for (int i = height - 1; i >= 0; i--) { |
1733 |
+ |
memcpy(dst, src, width); |
1734 |
+ |
src -= src_row_bytes; |
1735 |
+ |
dst -= dst_row_bytes; |
1736 |
+ |
} |
1737 |
+ |
} |
1738 |
+ |
} |
1739 |
+ |
|
1740 |
+ |
bool NQD_bitblt_hook(uint32 arg) |
1741 |
+ |
{ |
1742 |
+ |
D(bug("accl_draw_hook %08x\n", arg)); |
1743 |
+ |
accl_params *p = (accl_params *)arg; |
1744 |
+ |
|
1745 |
+ |
// Check if we can accelerate this bitblt |
1746 |
+ |
if (((uint32 *)p)[0x18 >> 2] + ((uint32 *)p)[0x128 >> 2] == 0 && |
1747 |
+ |
((uint32 *)p)[0x130 >> 2] == 0 && |
1748 |
+ |
p->src_pixel_size >= 8 && p->src_pixel_size == p->dest_pixel_size && |
1749 |
+ |
((p->src_row_bytes ^ p->dest_row_bytes) >> 31) == 0 && |
1750 |
+ |
p->transfer_mode == 0 && |
1751 |
+ |
((uint32 *)p)[0x15c >> 2] > 0) { |
1752 |
+ |
|
1753 |
+ |
// Yes, set function pointer |
1754 |
+ |
p->draw_proc = NativeTVECT(NATIVE_BITBLT); |
1755 |
+ |
return true; |
1756 |
+ |
} |
1757 |
+ |
return false; |
1758 |
+ |
} |
1759 |
+ |
|
1760 |
|
// Wait for graphics operation to finish |
1761 |
< |
static bool accl_sync_hook(void *arg) |
1761 |
> |
bool NQD_sync_hook(uint32 arg) |
1762 |
|
{ |
1763 |
< |
D(bug("accl_sync_hook %p\n", arg)); |
1670 |
< |
if (sync_hook != NULL) |
1671 |
< |
sync_hook(); |
1763 |
> |
D(bug("accl_sync_hook %08x\n", arg)); |
1764 |
|
return true; |
1765 |
|
} |
1766 |
|
|
1675 |
– |
static struct accl_hook_info bitblt_hook_info = {accl_bitblt_hook, accl_sync_hook, ACCL_BITBLT}; |
1676 |
– |
static struct accl_hook_info fillrect_hook_info = {accl_fillrect_hook, accl_sync_hook, ACCL_FILLRECT}; |
1677 |
– |
#endif |
1678 |
– |
|
1767 |
|
void VideoInstallAccel(void) |
1768 |
|
{ |
1769 |
|
// Install acceleration hooks |
1770 |
|
if (PrefsFindBool("gfxaccel")) { |
1771 |
|
D(bug("Video: Installing acceleration hooks\n")); |
1772 |
< |
//!! NQDMisc(6, &bitblt_hook_info); |
1772 |
> |
uint32 base; |
1773 |
> |
|
1774 |
> |
SheepVar bitblt_hook_info(sizeof(accl_hook_info)); |
1775 |
> |
base = bitblt_hook_info.addr(); |
1776 |
> |
WriteMacInt32(base + 0, NativeTVECT(NATIVE_BITBLT_HOOK)); |
1777 |
> |
WriteMacInt32(base + 4, NativeTVECT(NATIVE_SYNC_HOOK)); |
1778 |
> |
WriteMacInt32(base + 8, ACCL_BITBLT); |
1779 |
> |
NQDMisc(6, bitblt_hook_info.ptr()); |
1780 |
> |
|
1781 |
|
// NQDMisc(6, &fillrect_hook_info); |
1782 |
|
} |
1783 |
|
} |
2095 |
|
XF86DGADirectVideo(x_display, screen, 0); |
2096 |
|
XUngrabPointer(x_display, CurrentTime); |
2097 |
|
XUngrabKeyboard(x_display, CurrentTime); |
2098 |
+ |
XUnmapWindow(x_display, the_win); |
2099 |
+ |
wait_unmapped(the_win); |
2100 |
+ |
XDestroyWindow(x_display, the_win); |
2101 |
|
#endif |
2102 |
|
XSync(x_display, false); |
2103 |
|
XDisplayUnlock(); |