static int
vopen( video_desc_t *vm )
{
XDGADevice *dev;
int mask;
if( dga.is_open )
return 1;
if( !XDGAOpenFramebuffer( x11.disp, x11.screen ) ) {
printm("XDGAOpenFramebuffer failed\n");
return 1;
}
if( !(dev=XDGASetMode( x11.disp, x11.screen, (int)vm->module_data )) ) {
printf("XDGASetMode failure\n");
XDGACloseFramebuffer( x11.disp, x11.screen );
return 1;
}
printm("%d x %d: %d (%08x/%x)\n", vm->w, vm->h, vm->depth, (int)dev->data, vm->rowbytes );
vm->lvbase = (char *)dev->data;
vm->mmu_flags = get_bool_res("use_fb_cache")? MAPPING_FORCE_CACHE : MAPPING_MACOS_CONTROLS_CACHE;
vm->map_base = 0;
XFree( dev );
dga.is_open = 1;
use_hw_cursor(0);
mask = KeyPressMask | KeyReleaseMask;
if( mouse_activate(1) )
mask |= ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
XDGASelectInput( x11.disp, x11.screen, mask );
return 0;
}
int kbd_interface_start(void)
{
int mask;
#ifdef USE_XDGA
if (dgaModeCurrent >= 0)
{
mask= KeyPressMask;
#ifdef USE_MOUSE
if (MouseInUse) mask |= ButtonPressMask;
#endif
XDGASelectInput(disp, scrno, mask);
flush_all_pane(PT_FOREGROUND);
}
else
#endif
{
mask = ExposureMask | KeyPressMask |
StructureNotifyMask | SubstructureNotifyMask |
VisibilityChangeMask;
#ifdef USE_MOUSE
if (MouseInUse) mask |= ButtonPressMask;
#endif
XSelectInput(disp, wnd, mask);
WMProtAtom = XInternAtom(disp, "WM_PROTOCOLS", True);
WMDelAtom = XInternAtom(disp, "WM_DELETE_WINDOW", True);
if (WMProtAtom != (Atom)None && WMDelAtom != (Atom)None)
XSetWMProtocols(disp, wnd, &WMDelAtom, 1);
XMapWindow(disp, wnd);
flush_all_pane(PT_FOREGROUND);
/* if (cm_type == CM_PALETTE) */
{ XWarpPointer(disp, None, wnd, 0, 0, 0, 0, 10, 10);
/* XSetInputFocus(disp, wnd, RevertToParent, CurrentTime); */
}
}
#ifdef USE_MOUSE
if (MouseInUse) mouse_interface_start();
#endif
return 1;
}
/* _xdga2_gfxdrv_init_drv:
* Initializes driver and creates screen bitmap.
*/
static BITMAP *_xdga2_private_gfxdrv_init_drv(GFX_DRIVER *drv, int w, int h, int vw, int vh, int depth, int accel)
{
int dga_error_base, dga_major_version, dga_minor_version;
int mode, mask, red_shift = 0, green_shift = 0, blue_shift = 0;
long input_mask;
char tmp1[128], tmp2[128];
BITMAP *bmp;
/* This is just to test if the system driver has been installed properly */
if (_xwin.window == None)
return NULL;
/* Test that display is local. */
if (!_xdga2_private_display_is_local()) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("This driver needs local display"));
return NULL;
}
/* Choose convenient size. */
if ((w == 0) && (h == 0)) {
w = 640;
h = 480;
}
if ((w < 80) || (h < 80) || (w > 4096) || (h > 4096)) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Unsupported screen size"));
return NULL;
}
if (vw < w)
vw = w;
if (vh < h)
vh = h;
if (1
#ifdef ALLEGRO_COLOR8
&& (depth != 8)
#endif
#ifdef ALLEGRO_COLOR16
&& (depth != 15)
&& (depth != 16)
#endif
#ifdef ALLEGRO_COLOR24
&& (depth != 24)
#endif
#ifdef ALLEGRO_COLOR32
&& (depth != 32)
#endif
) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Unsupported color depth"));
return NULL;
}
/* Checks presence of DGA extension */
if (!XDGAQueryExtension(_xwin.display, &dga_event_base, &dga_error_base) ||
!XDGAQueryVersion(_xwin.display, &dga_major_version, &dga_minor_version)) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("DGA extension is not supported"));
return NULL;
}
/* Works only with DGA 2.0 or newer */
if (dga_major_version < 2) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("DGA 2.0 or newer is required"));
return NULL;
}
/* Attempts to access the framebuffer */
if (!XDGAOpenFramebuffer(_xwin.display, _xwin.screen)) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Can not open framebuffer"));
return NULL;
}
/* Finds suitable video mode number */
mode = _xdga2_find_mode(w, h, vw, vh, depth);
if (!mode) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Resolution not supported"));
return NULL;
}
/* Sets DGA video mode */
dga_device = XDGASetMode(_xwin.display, _xwin.screen, mode);
if (dga_device == NULL) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Can not switch to DGA mode"));
return NULL;
}
_xwin.in_dga_mode = 2;
_set_current_refresh_rate(dga_device->mode.verticalRefresh);
set_display_switch_mode(SWITCH_NONE);
/* Installs DGA color map */
if (_dga_cmap) {
XFreeColormap(_xwin.display, _dga_cmap);
_dga_cmap = 0;
}
if ((dga_device->mode.visualClass == PseudoColor)
|| (dga_device->mode.visualClass == GrayScale)
|| (dga_device->mode.visualClass == DirectColor))
_dga_cmap = XDGACreateColormap(_xwin.display, _xwin.screen, dga_device, AllocAll);
else
_dga_cmap = XDGACreateColormap(_xwin.display, _xwin.screen, dga_device, AllocNone);
XDGAInstallColormap(_xwin.display, _xwin.screen, _dga_cmap);
/* Sets up direct color shifts */
if (depth != 8) {
for (mask = dga_device->mode.redMask, red_shift = 0; (mask & 1) == 0;
mask >>= 1, red_shift++);
for (mask = dga_device->mode.greenMask, green_shift = 0; (mask & 1) == 0;
mask >>= 1, green_shift++);
for (mask = dga_device->mode.blueMask, blue_shift = 0; (mask & 1) == 0;
mask >>= 1, blue_shift++);
}
switch (depth) {
case 15:
_rgb_r_shift_15 = red_shift;
_rgb_g_shift_15 = green_shift;
_rgb_b_shift_15 = blue_shift;
break;
case 16:
_rgb_r_shift_16 = red_shift;
_rgb_g_shift_16 = green_shift;
_rgb_b_shift_16 = blue_shift;
break;
case 24:
_rgb_r_shift_24 = red_shift;
_rgb_g_shift_24 = green_shift;
_rgb_b_shift_24 = blue_shift;
break;
case 32:
_rgb_r_shift_32 = red_shift;
_rgb_g_shift_32 = green_shift;
_rgb_b_shift_32 = blue_shift;
break;
}
/* Enables input */
XSync(_xwin.display, True);
input_mask = KeyPressMask | KeyReleaseMask | ButtonPressMask
| ButtonReleaseMask | PointerMotionMask;
XDGASelectInput(_xwin.display, _xwin.screen, input_mask);
if (_xwin_keyboard_focused) {
(*_xwin_keyboard_focused)(FALSE, 0);
keyboard_got_focus = TRUE;
}
_mouse_on = TRUE;
/* Creates screen bitmap */
drv->linear = TRUE;
bmp = _make_bitmap(dga_device->mode.imageWidth, dga_device->mode.imageHeight,
(uintptr_t)dga_device->data, drv, depth,
dga_device->mode.bytesPerScanline);
if (!bmp) {
ustrzcpy(allegro_error, ALLEGRO_ERROR_SIZE, get_config_text("Not enough memory"));
return NULL;
}
drv->w = bmp->cr = w;
drv->h = bmp->cb = h;
drv->vid_mem = dga_device->mode.imageWidth * dga_device->mode.imageHeight
* BYTES_PER_PIXEL(depth);
if (accel) {
/* Hardware acceleration has been requested */
/* Updates line switcher to accommodate framebuffer synchronization */
#ifdef ALLEGRO_NO_ASM
bmp->write_bank = _xdga2_write_line;
bmp->read_bank = _xdga2_write_line;
#else
bmp->write_bank = _xdga2_write_line_asm;
bmp->read_bank = _xdga2_write_line_asm;
#endif
_screen_vtable.acquire = _xdga2_acquire;
/* Checks for hardware acceleration support */
if (dga_device->mode.flags & XDGASolidFillRect) {
/* XDGAFillRectangle is available */
_orig_hline = _screen_vtable.hline;
_orig_vline = _screen_vtable.vline;
_orig_rectfill = _screen_vtable.rectfill;
_screen_vtable.hline = _xaccel_hline;
_screen_vtable.vline = _xaccel_vline;
_screen_vtable.rectfill = _xaccel_rectfill;
_screen_vtable.clear_to_color = _xaccel_clear_to_color;
gfx_capabilities |= (GFX_HW_HLINE | GFX_HW_FILL);
}
if (dga_device->mode.flags & XDGABlitRect) {
/* XDGACopyArea is available */
_screen_vtable.blit_to_self = _xaccel_blit_to_self;
_screen_vtable.blit_to_self_forward = _xaccel_blit_to_self;
_screen_vtable.blit_to_self_backward = _xaccel_blit_to_self;
gfx_capabilities |= GFX_HW_VRAM_BLIT;
}
if (dga_device->mode.flags & XDGABlitTransRect) {
/* XDGACopyTransparentArea is available */
_orig_draw_sprite = _screen_vtable.draw_sprite;
_orig_masked_blit = _screen_vtable.masked_blit;
_screen_vtable.masked_blit = _xaccel_masked_blit;
_screen_vtable.draw_sprite = _xaccel_draw_sprite;
if (_screen_vtable.color_depth == 8)
_screen_vtable.draw_256_sprite = _xaccel_draw_sprite;
gfx_capabilities |= GFX_HW_VRAM_BLIT_MASKED;
}
RESYNC();
}
/* Checks for triple buffering */
if (dga_device->mode.viewportFlags & XDGAFlipRetrace)
gfx_capabilities |= GFX_CAN_TRIPLE_BUFFER;
/* Sets up driver description */
uszprintf(_xdga2_driver_desc, sizeof(_xdga2_driver_desc),
uconvert_ascii("X-Windows DGA 2.0 graphics%s", tmp1),
uconvert_ascii(accel ? (gfx_capabilities ? " (accelerated)" : "") : " (software only)", tmp2));
drv->desc = _xdga2_driver_desc;
return bmp;
}
int GIIdl_xf86dga(gii_input *inp, const char *args, void *argptr)
{
gii_inputxf86dga_arg *xdgaarg = argptr;
xdga_priv *priv;
int minkey, maxkey;
DPRINT_MISC("GIIdlinit(%p) called for input-dga\n", inp);
/* TODO: use XOpenDisplay to get a display if one wasnt
* provided? */
if (xdgaarg == NULL || xdgaarg->disp == NULL) {
return GGI_EARGREQ;
}
if ((priv = malloc(sizeof(xdga_priv))) == NULL) {
return GGI_ENOMEM;
}
priv->disp = xdgaarg->disp;
priv->screen = xdgaarg->screen;
memset(priv->key_vector,0,sizeof(priv->key_vector));
inp->priv = priv;
inp->GIIsendevent = GIIsendevent;
inp->GIIeventpoll = GII_xdga_eventpoll;
inp->GIIclose = GII_xdga_close;
if (0 == (priv->origin[XDGA_DEV_KEY] =
_giiRegisterDevice(inp,&key_devinfo,NULL)))
{
GII_xdga_close(inp);
return GGI_ENOMEM;
}
/*
if (0 == (priv->origin[XDGA_DEV_MOUSE] =
_giiRegisterDevice(inp,&mouse_devinfo,NULL)))
{
GII_xdga_close(inp);
return GGI_ENOMEM;
}
*/
inp->targetcan = emKey; /* | emPointer; */
inp->curreventmask = emKey; /* | emPointer;*/
inp->maxfd = ConnectionNumber(priv->disp) + 1;
FD_SET(ConnectionNumber(priv->disp), &inp->fdset);
/*
mouse_devinfo.num_buttons = XGetPointerMapping(priv->disp, NULL, 0);
*/
XDisplayKeycodes(priv->disp, &minkey, &maxkey);
key_devinfo.num_buttons = (maxkey - minkey) + 1;
send_devinfo(inp, XDGA_DEV_KEY);
/*
send_devinfo(inp, XDGA_DEV_MOUSE);
*/
XDGAQueryExtension( priv->disp, &priv->event_base, &priv->error_base);
XSync( priv->disp, True );
XDGASelectInput( priv->disp, priv->screen, KeyPressMask|KeyReleaseMask);
return 0;
}
