Skip to content

L
libSDL
Commit 532023bd authored by Sam Lantinga's avatar Sam Lantinga
Browse files
Options

Starting fresh with the X11 driver 

--HG--
extra : convert_revision : svn%3Ac70aab31-4412-0410-b14c-859654838e24/trunk%401994
parent fe52e82b
Hide whitespace changes
Inline Side-by-side
Showing with 0 additions and 7241 deletions
src/video/x11/SDL_x11dyn.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2004 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#define DEBUG_DYNAMIC_X11 0
#include "SDL_x11dyn.h"
#if DEBUG_DYNAMIC_X11
#include <stdio.h>
#endif
#ifdef SDL_VIDEO_DRIVER_X11_DYNAMIC
#include "SDL_name.h"
#include "SDL_loadso.h"
typedef struct
{
void *lib;
const char *libname;
} x11dynlib;
#ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC
#define SDL_VIDEO_DRIVER_X11_DYNAMIC NULL
#endif
#ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT
#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT NULL
#endif
#ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER
#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER NULL
#endif
#ifndef SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR
#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR NULL
#endif
static x11dynlib x11libs[] = {
{NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC},
{NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT},
{NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XRENDER},
{NULL, SDL_VIDEO_DRIVER_X11_DYNAMIC_XRANDR},
};
static void
X11_GetSym(const char *fnname, int *rc, void **fn)
{
int i;
for (i = 0; i < SDL_TABLESIZE(x11libs); i++) {
if (x11libs[i].lib != NULL) {
*fn = SDL_LoadFunction(x11libs[i].lib, fnname);
if (*fn != NULL)
break;
}
}
#if DEBUG_DYNAMIC_X11
if (*fn != NULL)
printf("X11: Found '%s' in %s (%p)\n", fnname, x11libs[i].libname,
*fn);
else
printf("X11: Symbol '%s' NOT FOUND!\n", fnname);
#endif
if (*fn == NULL)
*rc = 0; /* kill this module. */
}
/* Define all the function pointers and wrappers... */
#define SDL_X11_MODULE(modname)
#define SDL_X11_SYM(rc,fn,params,args,ret) \
static rc (*p##fn) params = NULL; \
rc fn params { ret p##fn args ; }
#include "SDL_x11sym.h"
#undef SDL_X11_MODULE
#undef SDL_X11_SYM
#endif /* SDL_VIDEO_DRIVER_X11_DYNAMIC */
/* Annoying varargs entry point... */
#ifdef X_HAVE_UTF8_STRING
XIC(*pXCreateIC) (XIM,...) = NULL;
#endif
/* These SDL_X11_HAVE_* flags are here whether you have dynamic X11 or not. */
#define SDL_X11_MODULE(modname) int SDL_X11_HAVE_##modname = 1;
#define SDL_X11_SYM(rc,fn,params,args,ret)
#include "SDL_x11sym.h"
#undef SDL_X11_MODULE
#undef SDL_X11_SYM
static int x11_load_refcount = 0;
void
SDL_X11_UnloadSymbols(void)
{
#ifdef SDL_VIDEO_DRIVER_X11_DYNAMIC
/* Don't actually unload if more than one module is using the libs... */
if (x11_load_refcount > 0) {
if (--x11_load_refcount == 0) {
int i;
/* set all the function pointers to NULL. */
#define SDL_X11_MODULE(modname) SDL_X11_HAVE_##modname = 1;
#define SDL_X11_SYM(rc,fn,params,args,ret) p##fn = NULL;
#include "SDL_x11sym.h"
#undef SDL_X11_MODULE
#undef SDL_X11_SYM
#ifdef X_HAVE_UTF8_STRING
pXCreateIC = NULL;
#endif
for (i = 0; i < SDL_TABLESIZE(x11libs); i++) {
if (x11libs[i].lib != NULL) {
SDL_UnloadObject(x11libs[i].lib);
x11libs[i].lib = NULL;
}
}
}
}
#endif
}
/* returns non-zero if all needed symbols were loaded. */
int
SDL_X11_LoadSymbols(void)
{
int rc = 1; /* always succeed if not using Dynamic X11 stuff. */
#ifdef SDL_VIDEO_DRIVER_X11_DYNAMIC
/* deal with multiple modules (dga, x11, etc) needing these symbols... */
if (x11_load_refcount++ == 0) {
int i;
int *thismod = NULL;
for (i = 0; i < SDL_TABLESIZE(x11libs); i++) {
if (x11libs[i].libname != NULL) {
x11libs[i].lib = SDL_LoadObject(x11libs[i].libname);
}
}
#define SDL_X11_MODULE(modname) thismod = &SDL_X11_HAVE_##modname;
#define SDL_X11_SYM(a,fn,x,y,z) X11_GetSym(#fn,thismod,(void**)&p##fn);
#include "SDL_x11sym.h"
#undef SDL_X11_MODULE
#undef SDL_X11_SYM
#ifdef X_HAVE_UTF8_STRING
X11_GetSym("XCreateIC", &SDL_X11_HAVE_UTF8, (void **) &pXCreateIC);
#endif
if (!SDL_X11_HAVE_BASEXLIB) { /* some required symbol didn't load. */
SDL_X11_UnloadSymbols(); /* in case something got loaded... */
rc = 0;
}
}
#else
#ifdef X_HAVE_UTF8_STRING
pXCreateIC = XCreateIC;
#endif
#endif
return rc;
}
/* end of SDL_x11dyn.c ... */
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11dyn.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2004 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#ifndef _SDL_x11dyn_h
#define _SDL_x11dyn_h
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include <X11/Xlibint.h>
#include <X11/Xproto.h>
#include "../Xext/extensions/Xext.h"
#include "../Xext/extensions/extutil.h"
#ifndef NO_SHARED_MEMORY
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>
#endif
#if SDL_VIDEO_DRIVER_X11_XRANDR
#include <X11/extensions/Xrandr.h>
#endif
/*
* When using the "dynamic X11" functionality, we duplicate all the Xlib
* symbols that would be referenced by SDL inside of SDL itself.
* These duplicated symbols just serve as passthroughs to the functions
* in Xlib, that was dynamically loaded.
*
* This allows us to use Xlib as-is when linking against it directly, but
* also handles all the strange cases where there was code in the Xlib
* headers that may or may not exist or vary on a given platform.
*/
#ifdef __cplusplus
extern "C"
{
#endif
/* evil function signatures... */
typedef Bool(*SDL_X11_XESetWireToEventRetType) (Display *, XEvent *,
xEvent *);
typedef int (*SDL_X11_XSynchronizeRetType) (Display *);
typedef Status(*SDL_X11_XESetEventToWireRetType) (Display *, XEvent *,
xEvent *);
int SDL_X11_LoadSymbols(void);
void SDL_X11_UnloadSymbols(void);
/* That's really annoying...make this a function pointer no matter what. */
#ifdef X_HAVE_UTF8_STRING
extern XIC(*pXCreateIC) (XIM, ...);
#endif
/* These SDL_X11_HAVE_* flags are here whether you have dynamic X11 or not. */
#define SDL_X11_MODULE(modname) extern int SDL_X11_HAVE_##modname;
#define SDL_X11_SYM(rc,fn,params,args,ret)
#include "SDL_x11sym.h"
#undef SDL_X11_MODULE
#undef SDL_X11_SYM
#ifdef __cplusplus
}
#endif
#endif /* !defined _SDL_x11dyn_h */
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11events.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
/* Handle the event stream, converting X11 events into SDL events */
#include <setjmp.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>
#ifdef __SVR4
#include <X11/Sunkeysym.h>
#endif
#include <sys/types.h>
#include <sys/time.h>
#include <unistd.h>
#include "SDL_timer.h"
#include "SDL_syswm.h"
#include "../SDL_sysvideo.h"
#include "../../events/SDL_sysevents.h"
#include "../../events/SDL_events_c.h"
#include "SDL_x11video.h"
#include "SDL_x11dga_c.h"
#include "SDL_x11modes_c.h"
#include "SDL_x11image_c.h"
#include "SDL_x11gamma_c.h"
#include "SDL_x11wm_c.h"
#include "SDL_x11mouse_c.h"
#include "SDL_x11events_c.h"
/* Define this if you want to debug X11 events */
/*#define DEBUG_XEVENTS*/
/* The translation tables from an X11 keysym to a SDL keysym */
static SDLKey ODD_keymap[256];
static SDLKey MISC_keymap[256];
SDLKey X11_TranslateKeycode(Display * display, KeyCode kc);
#ifdef X_HAVE_UTF8_STRING
Uint32
Utf8ToUcs4(const Uint8 * utf8)
{
Uint32 c;
int i = 1;
int noOctets = 0;
int firstOctetMask = 0;
unsigned char firstOctet = utf8[0];
if (firstOctet < 0x80) {
/*
Characters in the range:
00000000 to 01111111 (ASCII Range)
are stored in one octet:
0xxxxxxx (The same as its ASCII representation)
The least 6 significant bits of the first octet is the most 6 significant nonzero bits
of the UCS4 representation.
*/
noOctets = 1;
firstOctetMask = 0x7F; /* 0(1111111) - The most significant bit is ignored */
} else if ((firstOctet & 0xE0) /* get the most 3 significant bits by AND'ing with 11100000 */
== 0xC0) { /* see if those 3 bits are 110. If so, the char is in this range */
/*
Characters in the range:
00000000 10000000 to 00000111 11111111
are stored in two octets:
110xxxxx 10xxxxxx
The least 5 significant bits of the first octet is the most 5 significant nonzero bits
of the UCS4 representation.
*/
noOctets = 2;
firstOctetMask = 0x1F; /* 000(11111) - The most 3 significant bits are ignored */
} else if ((firstOctet & 0xF0) /* get the most 4 significant bits by AND'ing with 11110000 */
== 0xE0) { /* see if those 4 bits are 1110. If so, the char is in this range */
/*
Characters in the range:
00001000 00000000 to 11111111 11111111
are stored in three octets:
1110xxxx 10xxxxxx 10xxxxxx
The least 4 significant bits of the first octet is the most 4 significant nonzero bits
of the UCS4 representation.
*/
noOctets = 3;
firstOctetMask = 0x0F; /* 0000(1111) - The most 4 significant bits are ignored */
} else if ((firstOctet & 0xF8) /* get the most 5 significant bits by AND'ing with 11111000 */
== 0xF0) { /* see if those 5 bits are 11110. If so, the char is in this range */
/*
Characters in the range:
00000001 00000000 00000000 to 00011111 11111111 11111111
are stored in four octets:
11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
The least 3 significant bits of the first octet is the most 3 significant nonzero bits
of the UCS4 representation.
*/
noOctets = 4;
firstOctetMask = 0x07; /* 11110(111) - The most 5 significant bits are ignored */
} else if ((firstOctet & 0xFC) /* get the most 6 significant bits by AND'ing with 11111100 */
== 0xF8) { /* see if those 6 bits are 111110. If so, the char is in this range */
/*
Characters in the range:
00000000 00100000 00000000 00000000 to
00000011 11111111 11111111 11111111
are stored in five octets:
111110xx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
The least 2 significant bits of the first octet is the most 2 significant nonzero bits
of the UCS4 representation.
*/
noOctets = 5;
firstOctetMask = 0x03; /* 111110(11) - The most 6 significant bits are ignored */
} else if ((firstOctet & 0xFE) /* get the most 7 significant bits by AND'ing with 11111110 */
== 0xFC) { /* see if those 7 bits are 1111110. If so, the char is in this range */
/*
Characters in the range:
00000100 00000000 00000000 00000000 to
01111111 11111111 11111111 11111111
are stored in six octets:
1111110x 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx 10xxxxxx
The least significant bit of the first octet is the most significant nonzero bit
of the UCS4 representation.
*/
noOctets = 6;
firstOctetMask = 0x01; /* 1111110(1) - The most 7 significant bits are ignored */
} else
return 0; /* The given chunk is not a valid UTF-8 encoded Unicode character */
/*
The least noOctets significant bits of the first octet is the most 2 significant nonzero bits
of the UCS4 representation.
The first 6 bits of the UCS4 representation is the least 8-noOctets-1 significant bits of
firstOctet if the character is not ASCII. If so, it's the least 7 significant bits of firstOctet.
This done by AND'ing firstOctet with its mask to trim the bits used for identifying the
number of continuing octets (if any) and leave only the free bits (the x's)
Sample:
1-octet: 0xxxxxxx & 01111111 = 0xxxxxxx
2-octets: 110xxxxx & 00011111 = 000xxxxx
*/
c = firstOctet & firstOctetMask;
/* Now, start filling c.ucs4 with the bits from the continuing octets from utf8. */
for (i = 1; i < noOctets; i++) {
/* A valid continuing octet is of the form 10xxxxxx */
if ((utf8[i] & 0xC0) /* get the most 2 significant bits by AND'ing with 11000000 */
!=0x80)
/* see if those 2 bits are 10. If not, the is a malformed sequence. */
/*The given chunk is a partial sequence at the end of a string that could
begin a valid character */
return 0;
/* Make room for the next 6-bits */
c <<= 6;
/*
Take only the least 6 significance bits of the current octet (utf8[i]) and fill the created room
of c.ucs4 with them.
This done by AND'ing utf8[i] with 00111111 and the OR'ing the result with c.ucs4.
*/
c |= utf8[i] & 0x3F;
}
return c;
}
#endif
/* Check to see if this is a repeated key.
(idea shamelessly lifted from GII -- thanks guys! :)
*/
static int
X11_KeyRepeat(Display * display, XEvent * event)
{
XEvent peekevent;
int repeated;
repeated = 0;
if (XPending(display)) {
XPeekEvent(display, &peekevent);
if ((peekevent.type == KeyPress) &&
(peekevent.xkey.keycode == event->xkey.keycode) &&
((peekevent.xkey.time - event->xkey.time) < 2)) {
repeated = 1;
XNextEvent(display, &peekevent);
}
}
return (repeated);
}
/* Note: The X server buffers and accumulates mouse motion events, so
the motion event generated by the warp may not appear exactly as we
expect it to. We work around this (and improve performance) by only
warping the pointer when it reaches the edge, and then wait for it.
*/
#define MOUSE_FUDGE_FACTOR 8
static __inline__ int
X11_WarpedMotion(_THIS, XEvent * xevent)
{
int w, h, i;
int deltax, deltay;
int posted;
w = SDL_VideoSurface->w;
h = SDL_VideoSurface->h;
deltax = xevent->xmotion.x - mouse_last.x;
deltay = xevent->xmotion.y - mouse_last.y;
#ifdef DEBUG_MOTION
printf("Warped mouse motion: %d,%d\n", deltax, deltay);
#endif
mouse_last.x = xevent->xmotion.x;
mouse_last.y = xevent->xmotion.y;
posted = SDL_PrivateMouseMotion(0, 1, deltax, deltay);
if ((xevent->xmotion.x < MOUSE_FUDGE_FACTOR) ||
(xevent->xmotion.x > (w - MOUSE_FUDGE_FACTOR)) ||
(xevent->xmotion.y < MOUSE_FUDGE_FACTOR) ||
(xevent->xmotion.y > (h - MOUSE_FUDGE_FACTOR))) {
/* Get the events that have accumulated */
while (XCheckTypedEvent(SDL_Display, MotionNotify, xevent)) {
deltax = xevent->xmotion.x - mouse_last.x;
deltay = xevent->xmotion.y - mouse_last.y;
#ifdef DEBUG_MOTION
printf("Extra mouse motion: %d,%d\n", deltax, deltay);
#endif
mouse_last.x = xevent->xmotion.x;
mouse_last.y = xevent->xmotion.y;
posted += SDL_PrivateMouseMotion(0, 1, deltax, deltay);
}
mouse_last.x = w / 2;
mouse_last.y = h / 2;
XWarpPointer(SDL_Display, None, SDL_Window, 0, 0, 0, 0,
mouse_last.x, mouse_last.y);
for (i = 0; i < 10; ++i) {
XMaskEvent(SDL_Display, PointerMotionMask, xevent);
if ((xevent->xmotion.x >
(mouse_last.x - MOUSE_FUDGE_FACTOR)) &&
(xevent->xmotion.x <
(mouse_last.x + MOUSE_FUDGE_FACTOR)) &&
(xevent->xmotion.y >
(mouse_last.y - MOUSE_FUDGE_FACTOR)) &&
(xevent->xmotion.y < (mouse_last.y + MOUSE_FUDGE_FACTOR))) {
break;
}
#ifdef DEBUG_XEVENTS
printf("Lost mouse motion: %d,%d\n", xevent->xmotion.x,
xevent->xmotion.y);
#endif
}
#ifdef DEBUG_XEVENTS
if (i == 10) {
printf("Warning: didn't detect mouse warp motion\n");
}
#endif
}
return (posted);
}
static int
X11_DispatchEvent(_THIS)
{
int posted;
XEvent xevent;
SDL_memset(&xevent, '\0', sizeof(XEvent)); /* valgrind fix. --ryan. */
XNextEvent(SDL_Display, &xevent);
posted = 0;
switch (xevent.type) {
/* Gaining mouse coverage? */
case EnterNotify:
{
#ifdef DEBUG_XEVENTS
printf("EnterNotify! (%d,%d)\n", xevent.xcrossing.x,
xevent.xcrossing.y);
if (xevent.xcrossing.mode == NotifyGrab)
printf("Mode: NotifyGrab\n");
if (xevent.xcrossing.mode == NotifyUngrab)
printf("Mode: NotifyUngrab\n");
#endif
if ((xevent.xcrossing.mode != NotifyGrab) &&
(xevent.xcrossing.mode != NotifyUngrab)) {
if (SDL_CurrentWindow.input_grab == SDL_GRAB_OFF) {
posted = SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
}
posted = SDL_PrivateMouseMotion(0, 0,
xevent.xcrossing.x,
xevent.xcrossing.y);
}
}
break;
/* Losing mouse coverage? */
case LeaveNotify:
{
#ifdef DEBUG_XEVENTS
printf("LeaveNotify! (%d,%d)\n", xevent.xcrossing.x,
xevent.xcrossing.y);
if (xevent.xcrossing.mode == NotifyGrab)
printf("Mode: NotifyGrab\n");
if (xevent.xcrossing.mode == NotifyUngrab)
printf("Mode: NotifyUngrab\n");
#endif
if ((xevent.xcrossing.mode != NotifyGrab) &&
(xevent.xcrossing.mode != NotifyUngrab) &&
(xevent.xcrossing.detail != NotifyInferior)) {
if (SDL_CurrentWindow.input_grab == SDL_GRAB_OFF) {
posted = SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
} else {
posted = SDL_PrivateMouseMotion(0, 0,
xevent.xcrossing.x,
xevent.xcrossing.y);
}
}
}
break;
/* Gaining input focus? */
case FocusIn:
{
#ifdef DEBUG_XEVENTS
printf("FocusIn!\n");
#endif
posted = SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
#ifdef X_HAVE_UTF8_STRING
if (SDL_IC != NULL) {
XSetICFocus(SDL_IC);
}
#endif
/* Queue entry into fullscreen mode */
switch_waiting = 0x01 | SDL_FULLSCREEN;
switch_time = SDL_GetTicks() + 1500;
}
break;
/* Losing input focus? */
case FocusOut:
{
#ifdef DEBUG_XEVENTS
printf("FocusOut!\n");
#endif
posted = SDL_PrivateAppActive(0, SDL_APPINPUTFOCUS);
#ifdef X_HAVE_UTF8_STRING
if (SDL_IC != NULL) {
XUnsetICFocus(SDL_IC);
}
#endif
/* Queue leaving fullscreen mode */
switch_waiting = 0x01;
switch_time = SDL_GetTicks() + 200;
}
break;
/* Generated upon EnterWindow and FocusIn */
case KeymapNotify:
{
#ifdef DEBUG_XEVENTS
printf("KeymapNotify!\n");
#endif
X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector);
}
break;
/* Mouse motion? */
case MotionNotify:
{
if (SDL_VideoSurface) {
if (mouse_relative) {
if (using_dga & DGA_MOUSE) {
#ifdef DEBUG_MOTION
printf("DGA motion: %d,%d\n",
xevent.xmotion.x_root, xevent.xmotion.y_root);
#endif
posted = SDL_PrivateMouseMotion(0, 1,
xevent.
xmotion.
x_root,
xevent.
xmotion.y_root);
} else {
posted = X11_WarpedMotion(_this, &xevent);
}
} else {
#ifdef DEBUG_MOTION
printf("X11 motion: %d,%d\n", xevent.xmotion.x,
xevent.xmotion.y);
#endif
posted = SDL_PrivateMouseMotion(0, 0,
xevent.xmotion.x,
xevent.xmotion.y);
}
}
}
break;
/* Mouse button press? */
case ButtonPress:
{
posted = SDL_PrivateMouseButton(SDL_PRESSED,
xevent.xbutton.button, 0, 0);
}
break;
/* Mouse button release? */
case ButtonRelease:
{
posted = SDL_PrivateMouseButton(SDL_RELEASED,
xevent.xbutton.button, 0, 0);
}
break;
/* Key press? */
case KeyPress:
{
static SDL_keysym saved_keysym;
SDL_keysym keysym;
KeyCode keycode = xevent.xkey.keycode;
#ifdef DEBUG_XEVENTS
printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
/* Get the translated SDL virtual keysym */
if (keycode) {
keysym.scancode = keycode;
keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
keysym.mod = KMOD_NONE;
keysym.unicode = 0;
} else {
keysym = saved_keysym;
}
/* If we're not doing translation, we're done! */
if (!SDL_TranslateUNICODE) {
posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
break;
}
if (XFilterEvent(&xevent, None)) {
if (xevent.xkey.keycode) {
posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
} else {
/* Save event to be associated with IM text
In 1.3 we'll have a text event instead.. */
saved_keysym = keysym;
}
break;
}
/* Look up the translated value for the key event */
#ifdef X_HAVE_UTF8_STRING
if (SDL_IC != NULL) {
static Status state;
/* A UTF-8 character can be at most 6 bytes */
char keybuf[6];
if (Xutf8LookupString(SDL_IC, &xevent.xkey,
keybuf, sizeof(keybuf), NULL, &state)) {
keysym.unicode = Utf8ToUcs4((Uint8 *) keybuf);
}
} else
#endif
{
static XComposeStatus state;
char keybuf[32];
if (XLookupString(&xevent.xkey,
keybuf, sizeof(keybuf), NULL, &state)) {
/*
* FIXME: XLookupString() may yield more than one
* character, so we need a mechanism to allow for
* this (perhaps null keypress events with a
* unicode value)
*/
keysym.unicode = (Uint8) keybuf[0];
}
}
posted = SDL_PrivateKeyboard(SDL_PRESSED, &keysym);
}
break;
/* Key release? */
case KeyRelease:
{
SDL_keysym keysym;
KeyCode keycode = xevent.xkey.keycode;
#ifdef DEBUG_XEVENTS
printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
/* Check to see if this is a repeated key */
if (X11_KeyRepeat(SDL_Display, &xevent)) {
break;
}
/* Get the translated SDL virtual keysym */
keysym.scancode = keycode;
keysym.sym = X11_TranslateKeycode(SDL_Display, keycode);
keysym.mod = KMOD_NONE;
keysym.unicode = 0;
posted = SDL_PrivateKeyboard(SDL_RELEASED, &keysym);
}
break;
/* Have we been iconified? */
case UnmapNotify:
{
#ifdef DEBUG_XEVENTS
printf("UnmapNotify!\n");
#endif
/* If we're active, make ourselves inactive */
if (SDL_GetAppState() & SDL_APPACTIVE) {
/* Swap out the gamma before we go inactive */
X11_SwapVidModeGamma(_this);
/* Send an internal deactivate event */
posted = SDL_PrivateAppActive(0,
SDL_APPACTIVE |
SDL_APPINPUTFOCUS);
}
}
break;
/* Have we been restored? */
case MapNotify:
{
#ifdef DEBUG_XEVENTS
printf("MapNotify!\n");
#endif
/* If we're not active, make ourselves active */
if (!(SDL_GetAppState() & SDL_APPACTIVE)) {
/* Send an internal activate event */
posted = SDL_PrivateAppActive(1, SDL_APPACTIVE);
/* Now that we're active, swap the gamma back */
X11_SwapVidModeGamma(_this);
}
if (SDL_VideoSurface &&
(SDL_VideoSurface->flags & SDL_FULLSCREEN)) {
X11_EnterFullScreen(_this);
} else {
X11_GrabInputNoLock(_this, SDL_CurrentWindow.input_grab);
}
X11_CheckMouseModeNoLock(_this);
if (SDL_VideoSurface) {
X11_RefreshDisplay(_this);
}
}
break;
/* Have we been resized or moved? */
case ConfigureNotify:
{
#ifdef DEBUG_XEVENTS
printf("ConfigureNotify! (resize: %dx%d)\n",
xevent.xconfigure.width, xevent.xconfigure.height);
#endif
if (SDL_VideoSurface) {
if ((xevent.xconfigure.width != SDL_VideoSurface->w) ||
(xevent.xconfigure.height != SDL_VideoSurface->h)) {
/* FIXME: Find a better fix for the bug with KDE 1.2 */
if (!((xevent.xconfigure.width == 32) &&
(xevent.xconfigure.height == 32))) {
SDL_PrivateResize(xevent.xconfigure.width,
xevent.xconfigure.height);
}
} else {
/* OpenGL windows need to know about the change */
if (SDL_VideoSurface->flags & SDL_INTERNALOPENGL) {
SDL_PrivateExpose();
}
}
}
}
break;
/* Have we been requested to quit (or another client message?) */
case ClientMessage:
{
if ((xevent.xclient.format == 32) &&
(xevent.xclient.data.l[0] == WM_DELETE_WINDOW)) {
posted = SDL_PrivateQuit();
} else if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.subsystem = SDL_SYSWM_X11;
wmmsg.event.xevent = xevent;
posted = SDL_PrivateSysWMEvent(&wmmsg);
}
}
break;
/* Do we need to refresh ourselves? */
case Expose:
{
#ifdef DEBUG_XEVENTS
printf("Expose (count = %d)\n", xevent.xexpose.count);
#endif
if (SDL_VideoSurface && (xevent.xexpose.count == 0)) {
X11_RefreshDisplay(_this);
}
}
break;
default:
{
#ifdef DEBUG_XEVENTS
printf("Unhandled event %d\n", xevent.type);
#endif
/* Only post the event if we're watching for it */
if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.subsystem = SDL_SYSWM_X11;
wmmsg.event.xevent = xevent;
posted = SDL_PrivateSysWMEvent(&wmmsg);
}
}
break;
}
return (posted);
}
/* Ack! XPending() actually performs a blocking read if no events available */
int
X11_Pending(Display * display)
{
/* Flush the display connection and look to see if events are queued */
XFlush(display);
if (XEventsQueued(display, QueuedAlready)) {
return (1);
}
/* More drastic measures are required -- see if X is ready to talk */
{
static struct timeval zero_time; /* static == 0 */
int x11_fd;
fd_set fdset;
x11_fd = ConnectionNumber(display);
FD_ZERO(&fdset);
FD_SET(x11_fd, &fdset);
if (select(x11_fd + 1, &fdset, NULL, NULL, &zero_time) == 1) {
return (XPending(display));
}
}
/* Oh well, nothing is ready .. */
return (0);
}
void
X11_PumpEvents(_THIS)
{
int pending;
/* Keep processing pending events */
pending = 0;
while (X11_Pending(SDL_Display)) {
X11_DispatchEvent(_this);
++pending;
}
if (switch_waiting) {
Uint32 now;
now = SDL_GetTicks();
if (pending || !SDL_VideoSurface) {
/* Try again later... */
if (switch_waiting & SDL_FULLSCREEN) {
switch_time = now + 1500;
} else {
switch_time = now + 200;
}
} else if ((int) (switch_time - now) <= 0) {
Uint32 go_fullscreen;
go_fullscreen = switch_waiting & SDL_FULLSCREEN;
switch_waiting = 0;
if (SDL_VideoSurface->flags & SDL_FULLSCREEN) {
if (go_fullscreen) {
X11_EnterFullScreen(_this);
} else {
X11_LeaveFullScreen(_this);
}
}
/* Handle focus in/out when grabbed */
if (go_fullscreen) {
X11_GrabInputNoLock(_this, SDL_CurrentWindow.input_grab);
} else {
X11_GrabInputNoLock(_this, SDL_GRAB_OFF);
}
X11_CheckMouseModeNoLock(_this);
}
}
}
void
X11_InitKeymap(void)
{
int i;
/* Odd keys used in international keyboards */
for (i = 0; i < SDL_arraysize(ODD_keymap); ++i)
ODD_keymap[i] = SDLK_UNKNOWN;
/* Some of these might be mappable to an existing SDLK_ code */
ODD_keymap[XK_dead_grave & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_acute & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_tilde & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_macron & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_breve & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_abovedot & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_diaeresis & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_abovering & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_doubleacute & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_caron & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_cedilla & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_ogonek & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_iota & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_voiced_sound & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_semivoiced_sound & 0xFF] = SDLK_COMPOSE;
ODD_keymap[XK_dead_belowdot & 0xFF] = SDLK_COMPOSE;
#ifdef XK_dead_hook
ODD_keymap[XK_dead_hook & 0xFF] = SDLK_COMPOSE;
#endif
#ifdef XK_dead_horn
ODD_keymap[XK_dead_horn & 0xFF] = SDLK_COMPOSE;
#endif
#ifdef XK_dead_circumflex
/* These X keysyms have 0xFE as the high byte */
ODD_keymap[XK_dead_circumflex & 0xFF] = SDLK_CARET;
#endif
#ifdef XK_ISO_Level3_Shift
ODD_keymap[XK_ISO_Level3_Shift & 0xFF] = SDLK_MODE; /* "Alt Gr" key */
#endif
/* Map the miscellaneous keys */
for (i = 0; i < SDL_arraysize(MISC_keymap); ++i)
MISC_keymap[i] = SDLK_UNKNOWN;
/* These X keysyms have 0xFF as the high byte */
MISC_keymap[XK_BackSpace & 0xFF] = SDLK_BACKSPACE;
MISC_keymap[XK_Tab & 0xFF] = SDLK_TAB;
MISC_keymap[XK_Clear & 0xFF] = SDLK_CLEAR;
MISC_keymap[XK_Return & 0xFF] = SDLK_RETURN;
MISC_keymap[XK_Pause & 0xFF] = SDLK_PAUSE;
MISC_keymap[XK_Escape & 0xFF] = SDLK_ESCAPE;
MISC_keymap[XK_Delete & 0xFF] = SDLK_DELETE;
MISC_keymap[XK_KP_0 & 0xFF] = SDLK_KP0; /* Keypad 0-9 */
MISC_keymap[XK_KP_1 & 0xFF] = SDLK_KP1;
MISC_keymap[XK_KP_2 & 0xFF] = SDLK_KP2;
MISC_keymap[XK_KP_3 & 0xFF] = SDLK_KP3;
MISC_keymap[XK_KP_4 & 0xFF] = SDLK_KP4;
MISC_keymap[XK_KP_5 & 0xFF] = SDLK_KP5;
MISC_keymap[XK_KP_6 & 0xFF] = SDLK_KP6;
MISC_keymap[XK_KP_7 & 0xFF] = SDLK_KP7;
MISC_keymap[XK_KP_8 & 0xFF] = SDLK_KP8;
MISC_keymap[XK_KP_9 & 0xFF] = SDLK_KP9;
MISC_keymap[XK_KP_Insert & 0xFF] = SDLK_KP0;
MISC_keymap[XK_KP_End & 0xFF] = SDLK_KP1;
MISC_keymap[XK_KP_Down & 0xFF] = SDLK_KP2;
MISC_keymap[XK_KP_Page_Down & 0xFF] = SDLK_KP3;
MISC_keymap[XK_KP_Left & 0xFF] = SDLK_KP4;
MISC_keymap[XK_KP_Begin & 0xFF] = SDLK_KP5;
MISC_keymap[XK_KP_Right & 0xFF] = SDLK_KP6;
MISC_keymap[XK_KP_Home & 0xFF] = SDLK_KP7;
MISC_keymap[XK_KP_Up & 0xFF] = SDLK_KP8;
MISC_keymap[XK_KP_Page_Up & 0xFF] = SDLK_KP9;
MISC_keymap[XK_KP_Delete & 0xFF] = SDLK_KP_PERIOD;
MISC_keymap[XK_KP_Decimal & 0xFF] = SDLK_KP_PERIOD;
MISC_keymap[XK_KP_Divide & 0xFF] = SDLK_KP_DIVIDE;
MISC_keymap[XK_KP_Multiply & 0xFF] = SDLK_KP_MULTIPLY;
MISC_keymap[XK_KP_Subtract & 0xFF] = SDLK_KP_MINUS;
MISC_keymap[XK_KP_Add & 0xFF] = SDLK_KP_PLUS;
MISC_keymap[XK_KP_Enter & 0xFF] = SDLK_KP_ENTER;
MISC_keymap[XK_KP_Equal & 0xFF] = SDLK_KP_EQUALS;
MISC_keymap[XK_Up & 0xFF] = SDLK_UP;
MISC_keymap[XK_Down & 0xFF] = SDLK_DOWN;
MISC_keymap[XK_Right & 0xFF] = SDLK_RIGHT;
MISC_keymap[XK_Left & 0xFF] = SDLK_LEFT;
MISC_keymap[XK_Insert & 0xFF] = SDLK_INSERT;
MISC_keymap[XK_Home & 0xFF] = SDLK_HOME;
MISC_keymap[XK_End & 0xFF] = SDLK_END;
MISC_keymap[XK_Page_Up & 0xFF] = SDLK_PAGEUP;
MISC_keymap[XK_Page_Down & 0xFF] = SDLK_PAGEDOWN;
MISC_keymap[XK_F1 & 0xFF] = SDLK_F1;
MISC_keymap[XK_F2 & 0xFF] = SDLK_F2;
MISC_keymap[XK_F3 & 0xFF] = SDLK_F3;
MISC_keymap[XK_F4 & 0xFF] = SDLK_F4;
MISC_keymap[XK_F5 & 0xFF] = SDLK_F5;
MISC_keymap[XK_F6 & 0xFF] = SDLK_F6;
MISC_keymap[XK_F7 & 0xFF] = SDLK_F7;
MISC_keymap[XK_F8 & 0xFF] = SDLK_F8;
MISC_keymap[XK_F9 & 0xFF] = SDLK_F9;
MISC_keymap[XK_F10 & 0xFF] = SDLK_F10;
MISC_keymap[XK_F11 & 0xFF] = SDLK_F11;
MISC_keymap[XK_F12 & 0xFF] = SDLK_F12;
MISC_keymap[XK_F13 & 0xFF] = SDLK_F13;
MISC_keymap[XK_F14 & 0xFF] = SDLK_F14;
MISC_keymap[XK_F15 & 0xFF] = SDLK_F15;
MISC_keymap[XK_Num_Lock & 0xFF] = SDLK_NUMLOCK;
MISC_keymap[XK_Caps_Lock & 0xFF] = SDLK_CAPSLOCK;
MISC_keymap[XK_Scroll_Lock & 0xFF] = SDLK_SCROLLOCK;
MISC_keymap[XK_Shift_R & 0xFF] = SDLK_RSHIFT;
MISC_keymap[XK_Shift_L & 0xFF] = SDLK_LSHIFT;
MISC_keymap[XK_Control_R & 0xFF] = SDLK_RCTRL;
MISC_keymap[XK_Control_L & 0xFF] = SDLK_LCTRL;
MISC_keymap[XK_Alt_R & 0xFF] = SDLK_RALT;
MISC_keymap[XK_Alt_L & 0xFF] = SDLK_LALT;
MISC_keymap[XK_Meta_R & 0xFF] = SDLK_RMETA;
MISC_keymap[XK_Meta_L & 0xFF] = SDLK_LMETA;
MISC_keymap[XK_Super_L & 0xFF] = SDLK_LSUPER; /* Left "Windows" */
MISC_keymap[XK_Super_R & 0xFF] = SDLK_RSUPER; /* Right "Windows */
MISC_keymap[XK_Mode_switch & 0xFF] = SDLK_MODE; /* "Alt Gr" key */
MISC_keymap[XK_Multi_key & 0xFF] = SDLK_COMPOSE; /* Multi-key compose */
MISC_keymap[XK_Help & 0xFF] = SDLK_HELP;
MISC_keymap[XK_Print & 0xFF] = SDLK_PRINT;
MISC_keymap[XK_Sys_Req & 0xFF] = SDLK_SYSREQ;
MISC_keymap[XK_Break & 0xFF] = SDLK_BREAK;
MISC_keymap[XK_Menu & 0xFF] = SDLK_MENU;
MISC_keymap[XK_Hyper_R & 0xFF] = SDLK_MENU; /* Windows "Menu" key */
}
/* Get the translated SDL virtual keysym */
SDLKey
X11_TranslateKeycode(Display * display, KeyCode kc)
{
KeySym xsym;
SDLKey key;
xsym = XKeycodeToKeysym(display, kc, 0);
#ifdef DEBUG_KEYS
fprintf(stderr, "Translating key code %d -> 0x%.4x\n", kc, xsym);
#endif
key = SDLK_UNKNOWN;
if (xsym) {
switch (xsym >> 8) {
case 0x1005FF:
#ifdef SunXK_F36
if (xsym == SunXK_F36)
key = SDLK_F11;
#endif
#ifdef SunXK_F37
if (xsym == SunXK_F37)
key = SDLK_F12;
#endif
break;
case 0x00: /* Latin 1 */
key = (SDLKey) (xsym & 0xFF);
break;
case 0x01: /* Latin 2 */
case 0x02: /* Latin 3 */
case 0x03: /* Latin 4 */
case 0x04: /* Katakana */
case 0x05: /* Arabic */
case 0x06: /* Cyrillic */
case 0x07: /* Greek */
case 0x08: /* Technical */
case 0x0A: /* Publishing */
case 0x0C: /* Hebrew */
case 0x0D: /* Thai */
/* These are wrong, but it's better than nothing */
key = (SDLKey) (xsym & 0xFF);
break;
case 0xFE:
key = ODD_keymap[xsym & 0xFF];
break;
case 0xFF:
key = MISC_keymap[xsym & 0xFF];
break;
default:
/*
fprintf(stderr, "X11: Unhandled xsym, sym = 0x%04x\n",
(unsigned int)xsym);
*/
break;
}
} else {
/* X11 doesn't know how to translate the key! */
switch (kc) {
/* Caution:
These keycodes are from the Microsoft Keyboard
*/
case 115:
key = SDLK_LSUPER;
break;
case 116:
key = SDLK_RSUPER;
break;
case 117:
key = SDLK_MENU;
break;
default:
/*
* no point in an error message; happens for
* several keys when we get a keymap notify
*/
break;
}
}
return key;
}
/* X11 modifier masks for various keys */
static unsigned meta_l_mask, meta_r_mask, alt_l_mask, alt_r_mask;
static unsigned num_mask, mode_switch_mask;
static void
get_modifier_masks(Display * display)
{
static unsigned got_masks;
int i, j;
XModifierKeymap *xmods;
unsigned n;
if (got_masks)
return;
xmods = XGetModifierMapping(display);
n = xmods->max_keypermod;
for (i = 3; i < 8; i++) {
for (j = 0; j < n; j++) {
KeyCode kc = xmods->modifiermap[i * n + j];
KeySym ks = XKeycodeToKeysym(display, kc, 0);
unsigned mask = 1 << i;
switch (ks) {
case XK_Num_Lock:
num_mask = mask;
break;
case XK_Alt_L:
alt_l_mask = mask;
break;
case XK_Alt_R:
alt_r_mask = mask;
break;
case XK_Meta_L:
meta_l_mask = mask;
break;
case XK_Meta_R:
meta_r_mask = mask;
break;
case XK_Mode_switch:
mode_switch_mask = mask;
break;
}
}
}
XFreeModifiermap(xmods);
got_masks = 1;
}
/*
* This function is semi-official; it is not officially exported and should
* not be considered part of the SDL API, but may be used by client code
* that *really* needs it (including legacy code).
* It is slow, though, and should be avoided if possible.
*
* Note that it isn't completely accurate either; in particular, multi-key
* sequences (dead accents, compose key sequences) will not work since the
* state has been irrevocably lost.
*/
Uint16
X11_KeyToUnicode(SDLKey keysym, SDLMod modifiers)
{
SDL_VideoDevice *_this = SDL_GetVideoDevice();
char keybuf[32];
int i;
KeySym xsym = 0;
XKeyEvent xkey;
Uint16 unicode;
if (!_this || !SDL_Display) {
return 0;
}
SDL_memset(&xkey, 0, sizeof(xkey));
xkey.display = SDL_Display;
xsym = keysym; /* last resort if not found */
for (i = 0; i < 256; ++i) {
if (MISC_keymap[i] == keysym) {
xsym = 0xFF00 | i;
break;
} else if (ODD_keymap[i] == keysym) {
xsym = 0xFE00 | i;
break;
}
}
xkey.keycode = XKeysymToKeycode(xkey.display, xsym);
get_modifier_masks(SDL_Display);
if (modifiers & KMOD_SHIFT)
xkey.state |= ShiftMask;
if (modifiers & KMOD_CAPS)
xkey.state |= LockMask;
if (modifiers & KMOD_CTRL)
xkey.state |= ControlMask;
if (modifiers & KMOD_MODE)
xkey.state |= mode_switch_mask;
if (modifiers & KMOD_LALT)
xkey.state |= alt_l_mask;
if (modifiers & KMOD_RALT)
xkey.state |= alt_r_mask;
if (modifiers & KMOD_LMETA)
xkey.state |= meta_l_mask;
if (modifiers & KMOD_RMETA)
xkey.state |= meta_r_mask;
if (modifiers & KMOD_NUM)
xkey.state |= num_mask;
unicode = 0;
if (XLookupString(&xkey, keybuf, sizeof(keybuf), NULL, NULL))
unicode = (unsigned char) keybuf[0];
return (unicode);
}
/*
* Called when focus is regained, to read the keyboard state and generate
* synthetic keypress/release events.
* key_vec is a bit vector of keycodes (256 bits)
*/
void
X11_SetKeyboardState(Display * display, const char *key_vec)
{
char keys_return[32];
int i;
Uint8 *kstate = SDL_GetKeyState(NULL);
SDLMod modstate;
Window junk_window;
int x, y;
unsigned int mask;
/* The first time the window is mapped, we initialize key state */
if (!key_vec) {
XQueryKeymap(display, keys_return);
key_vec = keys_return;
}
/* Get the keyboard modifier state */
modstate = 0;
get_modifier_masks(display);
if (XQueryPointer(display, DefaultRootWindow(display),
&junk_window, &junk_window, &x, &y, &x, &y, &mask)) {
if (mask & LockMask) {
modstate |= KMOD_CAPS;
}
if (mask & mode_switch_mask) {
modstate |= KMOD_MODE;
}
if (mask & num_mask) {
modstate |= KMOD_NUM;
}
}
/* Zero the new keyboard state and generate it */
SDL_memset(kstate, 0, SDLK_LAST);
/*
* An obvious optimisation is to check entire longwords at a time in
* both loops, but we can't be sure the arrays are aligned so it's not
* worth the extra complexity
*/
for (i = 0; i < 32; i++) {
int j;
if (!key_vec[i])
continue;
for (j = 0; j < 8; j++) {
if (key_vec[i] & (1 << j)) {
SDLKey key;
KeyCode kc = (i << 3 | j);
key = X11_TranslateKeycode(display, kc);
if (key == SDLK_UNKNOWN) {
continue;
}
kstate[key] = SDL_PRESSED;
switch (key) {
case SDLK_LSHIFT:
modstate |= KMOD_LSHIFT;
break;
case SDLK_RSHIFT:
modstate |= KMOD_RSHIFT;
break;
case SDLK_LCTRL:
modstate |= KMOD_LCTRL;
break;
case SDLK_RCTRL:
modstate |= KMOD_RCTRL;
break;
case SDLK_LALT:
modstate |= KMOD_LALT;
break;
case SDLK_RALT:
modstate |= KMOD_RALT;
break;
case SDLK_LMETA:
modstate |= KMOD_LMETA;
break;
case SDLK_RMETA:
modstate |= KMOD_RMETA;
break;
default:
break;
}
}
}
}
/* Hack - set toggle key state */
if (modstate & KMOD_CAPS) {
kstate[SDLK_CAPSLOCK] = SDL_PRESSED;
} else {
kstate[SDLK_CAPSLOCK] = SDL_RELEASED;
}
if (modstate & KMOD_NUM) {
kstate[SDLK_NUMLOCK] = SDL_PRESSED;
} else {
kstate[SDLK_NUMLOCK] = SDL_RELEASED;
}
/* Set the final modifier state */
SDL_SetModState(modstate);
}
void
X11_InitOSKeymap(_THIS)
{
X11_InitKeymap();
}
void
X11_SaveScreenSaver(Display * display, int *saved_timeout, BOOL * dpms)
{
int timeout, interval, prefer_blank, allow_exp;
XGetScreenSaver(display, &timeout, &interval, &prefer_blank, &allow_exp);
*saved_timeout = timeout;
#if SDL_VIDEO_DRIVER_X11_DPMS
if (SDL_X11_HAVE_DPMS) {
int dummy;
if (DPMSQueryExtension(display, &dummy, &dummy)) {
CARD16 state;
DPMSInfo(display, &state, dpms);
}
}
#else
*dpms = 0;
#endif /* SDL_VIDEO_DRIVER_X11_DPMS */
}
void
X11_DisableScreenSaver(Display * display)
{
int timeout, interval, prefer_blank, allow_exp;
XGetScreenSaver(display, &timeout, &interval, &prefer_blank, &allow_exp);
timeout = 0;
XSetScreenSaver(display, timeout, interval, prefer_blank, allow_exp);
#if SDL_VIDEO_DRIVER_X11_DPMS
if (SDL_X11_HAVE_DPMS) {
int dummy;
if (DPMSQueryExtension(display, &dummy, &dummy)) {
DPMSDisable(display);
}
}
#endif /* SDL_VIDEO_DRIVER_X11_DPMS */
}
void
X11_RestoreScreenSaver(Display * display, int saved_timeout, BOOL dpms)
{
int timeout, interval, prefer_blank, allow_exp;
XGetScreenSaver(display, &timeout, &interval, &prefer_blank, &allow_exp);
timeout = saved_timeout;
XSetScreenSaver(display, timeout, interval, prefer_blank, allow_exp);
#if SDL_VIDEO_DRIVER_X11_DPMS
if (SDL_X11_HAVE_DPMS) {
int dummy;
if (DPMSQueryExtension(display, &dummy, &dummy)) {
if (dpms) {
DPMSEnable(display);
}
}
}
#endif /* SDL_VIDEO_DRIVER_X11_DPMS */
}
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11events_c.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_x11video.h"
/* Functions to be exported */
extern void X11_InitOSKeymap(_THIS);
extern void X11_PumpEvents(_THIS);
extern void X11_SetKeyboardState(Display * display, const char *key_vec);
extern void X11_SaveScreenSaver(Display * display, int *saved_timeout,
BOOL * dpms);
extern void X11_DisableScreenSaver(Display * display);
extern void X11_RestoreScreenSaver(Display * display, int saved_timeout,
BOOL dpms);
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11gamma.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL.h"
#include "SDL_events.h"
#include "../../events/SDL_events_c.h"
#include "SDL_x11video.h"
/* From the X server sources... */
#define MAX_GAMMA 10.0
#define MIN_GAMMA (1.0/MAX_GAMMA)
static int
X11_SetGammaNoLock(_THIS, float red, float green, float blue)
{
#if SDL_VIDEO_DRIVER_X11_VIDMODE
if (use_vidmode >= 200) {
SDL_NAME(XF86VidModeGamma) gamma;
Bool succeeded;
/* Clamp the gamma values */
if (red < MIN_GAMMA) {
gamma.red = MIN_GAMMA;
} else if (red > MAX_GAMMA) {
gamma.red = MAX_GAMMA;
} else {
gamma.red = red;
}
if (green < MIN_GAMMA) {
gamma.green = MIN_GAMMA;
} else if (green > MAX_GAMMA) {
gamma.green = MAX_GAMMA;
} else {
gamma.green = green;
}
if (blue < MIN_GAMMA) {
gamma.blue = MIN_GAMMA;
} else if (blue > MAX_GAMMA) {
gamma.blue = MAX_GAMMA;
} else {
gamma.blue = blue;
}
if (SDL_GetAppState() & SDL_APPACTIVE) {
succeeded =
SDL_NAME(XF86VidModeSetGamma) (SDL_Display, SDL_Screen,
&gamma);
XSync(SDL_Display, False);
} else {
gamma_saved[0] = gamma.red;
gamma_saved[1] = gamma.green;
gamma_saved[2] = gamma.blue;
succeeded = True;
}
if (succeeded) {
++gamma_changed;
}
return succeeded ? 0 : -1;
}
#endif
SDL_SetError("Gamma correction not supported");
return -1;
}
int
X11_SetVidModeGamma(_THIS, float red, float green, float blue)
{
int result;
SDL_Lock_EventThread();
result = X11_SetGammaNoLock(this, red, green, blue);
SDL_Unlock_EventThread();
return (result);
}
static int
X11_GetGammaNoLock(_THIS, float *red, float *green, float *blue)
{
#if SDL_VIDEO_DRIVER_X11_VIDMODE
if (use_vidmode >= 200) {
SDL_NAME(XF86VidModeGamma) gamma;
if (SDL_NAME(XF86VidModeGetGamma)
(SDL_Display, SDL_Screen, &gamma)) {
*red = gamma.red;
*green = gamma.green;
*blue = gamma.blue;
return 0;
}
return -1;
}
#endif
return -1;
}
int
X11_GetVidModeGamma(_THIS, float *red, float *green, float *blue)
{
int result;
SDL_Lock_EventThread();
result = X11_GetGammaNoLock(this, red, green, blue);
SDL_Unlock_EventThread();
return (result);
}
void
X11_SaveVidModeGamma(_THIS)
{
/* Try to save the current gamma, otherwise disable gamma control */
if (X11_GetGammaNoLock(this,
&gamma_saved[0], &gamma_saved[1],
&gamma_saved[2]) < 0) {
this->SetGamma = 0;
this->GetGamma = 0;
}
gamma_changed = 0;
}
void
X11_SwapVidModeGamma(_THIS)
{
float new_gamma[3];
if (gamma_changed) {
new_gamma[0] = gamma_saved[0];
new_gamma[1] = gamma_saved[1];
new_gamma[2] = gamma_saved[2];
X11_GetGammaNoLock(this, &gamma_saved[0], &gamma_saved[1],
&gamma_saved[2]);
X11_SetGammaNoLock(this, new_gamma[0], new_gamma[1], new_gamma[2]);
}
}
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11gamma_c.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#ifndef _SDL_x11gamma_h
#define _SDL_x11gamma_h
extern int X11_SetVidModeGamma(_THIS, float red, float green, float blue);
extern int X11_GetVidModeGamma(_THIS, float *red, float *green, float *blue);
extern void X11_SaveVidModeGamma(_THIS);
extern void X11_SwapVidModeGamma(_THIS);
#endif
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11gl.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_x11video.h"
#include "../../events/SDL_events_c.h"
#include "SDL_x11dga_c.h"
#include "SDL_x11gl_c.h"
#if defined(__IRIX__)
/* IRIX doesn't have a GL library versioning system */
#define DEFAULT_OPENGL "libGL.so"
#elif defined(__MACOSX__)
#define DEFAULT_OPENGL "/usr/X11R6/lib/libGL.1.dylib"
#elif defined(__QNXNTO__)
#define DEFAULT_OPENGL "libGL.so.3"
#else
#define DEFAULT_OPENGL "libGL.so.1"
#endif
#ifndef GLX_ARB_multisample
#define GLX_ARB_multisample
#define GLX_SAMPLE_BUFFERS_ARB 100000
#define GLX_SAMPLES_ARB 100001
#endif
#ifndef GLX_EXT_visual_rating
#define GLX_EXT_visual_rating
#define GLX_VISUAL_CAVEAT_EXT 0x20
#define GLX_NONE_EXT 0x8000
#define GLX_SLOW_VISUAL_EXT 0x8001
#define GLX_NON_CONFORMANT_VISUAL_EXT 0x800D
#endif
#if SDL_VIDEO_OPENGL_GLX
static int
glXExtensionSupported(_THIS, const char *extension)
{
const char *extensions;
const char *start;
const char *where, *terminator;
/* Extension names should not have spaces. */
where = SDL_strchr(extension, ' ');
if (where || *extension == '\0') {
return 0;
}
extensions =
this->gl_data->glXQueryExtensionsString(GFX_Display, SDL_Screen);
/* It takes a bit of care to be fool-proof about parsing the
* OpenGL extensions string. Don't be fooled by sub-strings, etc.
*/
start = extensions;
for (;;) {
where = SDL_strstr(start, extension);
if (!where)
break;
terminator = where + strlen(extension);
if (where == start || *(where - 1) == ' ')
if (*terminator == ' ' || *terminator == '\0')
return 1;
start = terminator;
}
return 0;
}
#endif /* SDL_VIDEO_OPENGL_GLX */
XVisualInfo *
X11_GL_GetVisual(_THIS)
{
#if SDL_VIDEO_OPENGL_GLX
/* 64 seems nice. */
int attribs[64];
int i;
/* load the gl driver from a default path */
if (!this->gl_config.driver_loaded) {
/* no driver has been loaded, use default (ourselves) */
if (X11_GL_LoadLibrary(this, NULL) < 0) {
return NULL;
}
}
/* See if we already have a window which we must use */
if (SDL_windowid) {
XWindowAttributes a;
XVisualInfo vi_in;
int out_count;
XGetWindowAttributes(SDL_Display, SDL_Window, &a);
vi_in.screen = SDL_Screen;
vi_in.visualid = XVisualIDFromVisual(a.visual);
glx_visualinfo = XGetVisualInfo(SDL_Display,
VisualScreenMask | VisualIDMask,
&vi_in, &out_count);
return glx_visualinfo;
}
/* Setup our GLX attributes according to the gl_config. */
i = 0;
attribs[i++] = GLX_RGBA;
attribs[i++] = GLX_RED_SIZE;
attribs[i++] = this->gl_config.red_size;
attribs[i++] = GLX_GREEN_SIZE;
attribs[i++] = this->gl_config.green_size;
attribs[i++] = GLX_BLUE_SIZE;
attribs[i++] = this->gl_config.blue_size;
if (this->gl_config.alpha_size) {
attribs[i++] = GLX_ALPHA_SIZE;
attribs[i++] = this->gl_config.alpha_size;
}
if (this->gl_config.buffer_size) {
attribs[i++] = GLX_BUFFER_SIZE;
attribs[i++] = this->gl_config.buffer_size;
}
if (this->gl_config.double_buffer) {
attribs[i++] = GLX_DOUBLEBUFFER;
}
attribs[i++] = GLX_DEPTH_SIZE;
attribs[i++] = this->gl_config.depth_size;
if (this->gl_config.stencil_size) {
attribs[i++] = GLX_STENCIL_SIZE;
attribs[i++] = this->gl_config.stencil_size;
}
if (this->gl_config.accum_red_size) {
attribs[i++] = GLX_ACCUM_RED_SIZE;
attribs[i++] = this->gl_config.accum_red_size;
}
if (this->gl_config.accum_green_size) {
attribs[i++] = GLX_ACCUM_GREEN_SIZE;
attribs[i++] = this->gl_config.accum_green_size;
}
if (this->gl_config.accum_blue_size) {
attribs[i++] = GLX_ACCUM_BLUE_SIZE;
attribs[i++] = this->gl_config.accum_blue_size;
}
if (this->gl_config.accum_alpha_size) {
attribs[i++] = GLX_ACCUM_ALPHA_SIZE;
attribs[i++] = this->gl_config.accum_alpha_size;
}
if (this->gl_config.stereo) {
attribs[i++] = GLX_STEREO;
}
if (this->gl_config.multisamplebuffers) {
attribs[i++] = GLX_SAMPLE_BUFFERS_ARB;
attribs[i++] = this->gl_config.multisamplebuffers;
}
if (this->gl_config.multisamplesamples) {
attribs[i++] = GLX_SAMPLES_ARB;
attribs[i++] = this->gl_config.multisamplesamples;
}
if (this->gl_config.accelerated >= 0 &&
glXExtensionSupported(this, "GLX_EXT_visual_rating")) {
attribs[i++] = GLX_VISUAL_CAVEAT_EXT;
attribs[i++] = GLX_NONE_EXT;
}
#ifdef GLX_DIRECT_COLOR /* Try for a DirectColor visual for gamma support */
if (!SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR")) {
attribs[i++] = GLX_X_VISUAL_TYPE;
attribs[i++] = GLX_DIRECT_COLOR;
}
#endif
attribs[i++] = None;
glx_visualinfo = this->gl_data->glXChooseVisual(GFX_Display,
SDL_Screen, attribs);
#ifdef GLX_DIRECT_COLOR
if (!glx_visualinfo && !SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR")) { /* No DirectColor visual? Try again.. */
attribs[i - 3] = None;
glx_visualinfo = this->gl_data->glXChooseVisual(GFX_Display,
SDL_Screen, attribs);
}
#endif
if (!glx_visualinfo) {
SDL_SetError("Couldn't find matching GLX visual");
return NULL;
}
/*
printf("Found GLX visual 0x%x\n", glx_visualinfo->visualid);
*/
return glx_visualinfo;
#else
SDL_SetError("X11 driver not configured with OpenGL");
return NULL;
#endif
}
int
X11_GL_CreateWindow(_THIS, int w, int h)
{
int retval;
#if SDL_VIDEO_OPENGL_GLX
XSetWindowAttributes attributes;
unsigned long mask;
unsigned long black;
black = (glx_visualinfo->visual == DefaultVisual(SDL_Display, SDL_Screen))
? BlackPixel(SDL_Display, SDL_Screen) : 0;
attributes.background_pixel = black;
attributes.border_pixel = black;
attributes.colormap = SDL_XColorMap;
mask = CWBackPixel | CWBorderPixel | CWColormap;
SDL_Window = XCreateWindow(SDL_Display, WMwindow,
0, 0, w, h, 0, glx_visualinfo->depth,
InputOutput, glx_visualinfo->visual,
mask, &attributes);
if (!SDL_Window) {
SDL_SetError("Could not create window");
return -1;
}
retval = 0;
#else
SDL_SetError("X11 driver not configured with OpenGL");
retval = -1;
#endif
return (retval);
}
int
X11_GL_CreateContext(_THIS)
{
int retval;
#if SDL_VIDEO_OPENGL_GLX
/* We do this to create a clean separation between X and GLX errors. */
XSync(SDL_Display, False);
glx_context = this->gl_data->glXCreateContext(GFX_Display,
glx_visualinfo, NULL, True);
XSync(GFX_Display, False);
if (glx_context == NULL) {
SDL_SetError("Could not create GL context");
return (-1);
}
if (X11_GL_MakeCurrent(this) < 0) {
return (-1);
}
gl_active = 1;
if (!glXExtensionSupported(this, "SGI_swap_control")) {
this->gl_data->glXSwapIntervalSGI = NULL;
}
if (!glXExtensionSupported(this, "GLX_MESA_swap_control")) {
this->gl_data->glXSwapIntervalMESA = NULL;
this->gl_data->glXGetSwapIntervalMESA = NULL;
}
if (this->gl_config.swap_control >= 0) {
if (this->gl_data->glXSwapIntervalMESA) {
this->gl_data->glXSwapIntervalMESA(this->gl_config.swap_control);
} else if (this->gl_data->glXSwapIntervalSGI) {
this->gl_data->glXSwapIntervalSGI(this->gl_config.swap_control);
}
}
#else
SDL_SetError("X11 driver not configured with OpenGL");
#endif
if (gl_active) {
retval = 0;
} else {
retval = -1;
}
return (retval);
}
void
X11_GL_Shutdown(_THIS)
{
#if SDL_VIDEO_OPENGL_GLX
/* Clean up OpenGL */
if (glx_context) {
this->gl_data->glXMakeCurrent(GFX_Display, None, NULL);
if (glx_context != NULL)
this->gl_data->glXDestroyContext(GFX_Display, glx_context);
glx_context = NULL;
}
gl_active = 0;
#endif /* SDL_VIDEO_OPENGL_GLX */
}
#if SDL_VIDEO_OPENGL_GLX
/* Make the current context active */
int
X11_GL_MakeCurrent(_THIS)
{
int retval;
retval = 0;
if (!this->gl_data->glXMakeCurrent(GFX_Display, SDL_Window, glx_context)) {
SDL_SetError("Unable to make GL context current");
retval = -1;
}
XSync(GFX_Display, False);
/* More Voodoo X server workarounds... Grr... */
SDL_Lock_EventThread();
X11_CheckDGAMouse(this);
SDL_Unlock_EventThread();
return (retval);
}
/* Get attribute data from glX. */
int
X11_GL_GetAttribute(_THIS, SDL_GLattr attrib, int *value)
{
int retval;
int glx_attrib = None;
switch (attrib) {
case SDL_GL_RED_SIZE:
glx_attrib = GLX_RED_SIZE;
break;
case SDL_GL_GREEN_SIZE:
glx_attrib = GLX_GREEN_SIZE;
break;
case SDL_GL_BLUE_SIZE:
glx_attrib = GLX_BLUE_SIZE;
break;
case SDL_GL_ALPHA_SIZE:
glx_attrib = GLX_ALPHA_SIZE;
break;
case SDL_GL_DOUBLEBUFFER:
glx_attrib = GLX_DOUBLEBUFFER;
break;
case SDL_GL_BUFFER_SIZE:
glx_attrib = GLX_BUFFER_SIZE;
break;
case SDL_GL_DEPTH_SIZE:
glx_attrib = GLX_DEPTH_SIZE;
break;
case SDL_GL_STENCIL_SIZE:
glx_attrib = GLX_STENCIL_SIZE;
break;
case SDL_GL_ACCUM_RED_SIZE:
glx_attrib = GLX_ACCUM_RED_SIZE;
break;
case SDL_GL_ACCUM_GREEN_SIZE:
glx_attrib = GLX_ACCUM_GREEN_SIZE;
break;
case SDL_GL_ACCUM_BLUE_SIZE:
glx_attrib = GLX_ACCUM_BLUE_SIZE;
break;
case SDL_GL_ACCUM_ALPHA_SIZE:
glx_attrib = GLX_ACCUM_ALPHA_SIZE;
break;
case SDL_GL_STEREO:
glx_attrib = GLX_STEREO;
break;
case SDL_GL_MULTISAMPLEBUFFERS:
glx_attrib = GLX_SAMPLE_BUFFERS_ARB;
break;
case SDL_GL_MULTISAMPLESAMPLES:
glx_attrib = GLX_SAMPLES_ARB;
break;
case SDL_GL_ACCELERATED_VISUAL:
if (glXExtensionSupported(this, "GLX_EXT_visual_rating")) {
glx_attrib = GLX_VISUAL_CAVEAT_EXT;
retval =
this->gl_data->glXGetConfig(GFX_Display, glx_visualinfo,
glx_attrib, value);
if (*value == GLX_SLOW_VISUAL_EXT) {
*value = SDL_FALSE;
} else {
*value = SDL_TRUE;
}
return retval;
} else {
return (-1);
}
break;
case SDL_GL_SWAP_CONTROL:
if (this->gl_data->glXGetSwapIntervalMESA) {
*value = this->gl_data->glXGetSwapIntervalMESA();
return (0);
} else {
return (-1);
}
break;
default:
return (-1);
}
retval =
this->gl_data->glXGetConfig(GFX_Display, glx_visualinfo, glx_attrib,
value);
return retval;
}
void
X11_GL_SwapBuffers(_THIS)
{
this->gl_data->glXSwapBuffers(GFX_Display, SDL_Window);
}
#endif /* SDL_VIDEO_OPENGL_GLX */
#define OPENGL_REQUIRS_DLOPEN
#if defined(OPENGL_REQUIRS_DLOPEN) && defined(SDL_LOADSO_DLOPEN)
#include <dlfcn.h>
#define GL_LoadObject(X) dlopen(X, (RTLD_NOW|RTLD_GLOBAL))
#define GL_LoadFunction dlsym
#define GL_UnloadObject dlclose
#else
#define GL_LoadObject SDL_LoadObject
#define GL_LoadFunction SDL_LoadFunction
#define GL_UnloadObject SDL_UnloadObject
#endif
void
X11_GL_UnloadLibrary(_THIS)
{
#if SDL_VIDEO_OPENGL_GLX
if (this->gl_config.driver_loaded) {
GL_UnloadObject(this->gl_config.dll_handle);
this->gl_data->glXGetProcAddress = NULL;
this->gl_data->glXChooseVisual = NULL;
this->gl_data->glXCreateContext = NULL;
this->gl_data->glXDestroyContext = NULL;
this->gl_data->glXMakeCurrent = NULL;
this->gl_data->glXSwapBuffers = NULL;
this->gl_data->glXSwapIntervalSGI = NULL;
this->gl_data->glXSwapIntervalMESA = NULL;
this->gl_data->glXGetSwapIntervalMESA = NULL;
this->gl_config.dll_handle = NULL;
this->gl_config.driver_loaded = 0;
}
#endif
}
#if SDL_VIDEO_OPENGL_GLX
/* Passing a NULL path means load pointers from the application */
int
X11_GL_LoadLibrary(_THIS, const char *path)
{
void *handle = NULL;
if (gl_active) {
SDL_SetError("OpenGL context already created");
return -1;
}
if (path == NULL) {
path = SDL_getenv("SDL_VIDEO_GL_DRIVER");
if (path == NULL) {
path = DEFAULT_OPENGL;
}
}
handle = GL_LoadObject(path);
if (handle == NULL) {
/* SDL_LoadObject() will call SDL_SetError() for us. */
return -1;
}
/* Unload the old driver and reset the pointers */
X11_GL_UnloadLibrary(this);
/* Load new function pointers */
this->gl_data->glXGetProcAddress =
(void *(*)(const GLubyte *)) GL_LoadFunction(handle,
"glXGetProcAddressARB");
this->gl_data->glXChooseVisual =
(XVisualInfo * (*)(Display *, int, int *)) GL_LoadFunction(handle,
"glXChooseVisual");
this->gl_data->glXCreateContext =
(GLXContext(*)(Display *, XVisualInfo *, GLXContext, int))
GL_LoadFunction(handle, "glXCreateContext");
this->gl_data->glXDestroyContext =
(void (*)(Display *, GLXContext)) GL_LoadFunction(handle,
"glXDestroyContext");
this->gl_data->glXMakeCurrent =
(int (*)(Display *, GLXDrawable, GLXContext)) GL_LoadFunction(handle,
"glXMakeCurrent");
this->gl_data->glXSwapBuffers =
(void (*)(Display *, GLXDrawable)) GL_LoadFunction(handle,
"glXSwapBuffers");
this->gl_data->glXGetConfig =
(int (*)(Display *, XVisualInfo *, int, int *))
GL_LoadFunction(handle, "glXGetConfig");
this->gl_data->glXQueryExtensionsString =
(const char *(*)(Display *, int)) GL_LoadFunction(handle,
"glXQueryExtensionsString");
this->gl_data->glXSwapIntervalSGI =
(int (*)(int)) GL_LoadFunction(handle, "glXSwapIntervalSGI");
this->gl_data->glXSwapIntervalMESA =
(GLint(*)(unsigned)) GL_LoadFunction(handle, "glXSwapIntervalMESA");
this->gl_data->glXGetSwapIntervalMESA =
(GLint(*)(void)) GL_LoadFunction(handle, "glXGetSwapIntervalMESA");
if ((this->gl_data->glXChooseVisual == NULL) ||
(this->gl_data->glXCreateContext == NULL) ||
(this->gl_data->glXDestroyContext == NULL) ||
(this->gl_data->glXMakeCurrent == NULL) ||
(this->gl_data->glXSwapBuffers == NULL) ||
(this->gl_data->glXGetConfig == NULL) ||
(this->gl_data->glXQueryExtensionsString == NULL)) {
SDL_SetError("Could not retrieve OpenGL functions");
return -1;
}
this->gl_config.dll_handle = handle;
this->gl_config.driver_loaded = 1;
if (path) {
SDL_strlcpy(this->gl_config.driver_path, path,
SDL_arraysize(this->gl_config.driver_path));
} else {
*this->gl_config.driver_path = '\0';
}
return 0;
}
void *
X11_GL_GetProcAddress(_THIS, const char *proc)
{
void *handle;
handle = this->gl_config.dll_handle;
if (this->gl_data->glXGetProcAddress) {
return this->gl_data->glXGetProcAddress((const GLubyte *) proc);
}
return GL_LoadFunction(handle, proc);
}
#endif /* SDL_VIDEO_OPENGL_GLX */
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11gl_c.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#if SDL_VIDEO_OPENGL_GLX
#include <GL/glx.h>
#include "SDL_loadso.h"
#endif
#include "../SDL_sysvideo.h"
struct SDL_PrivateGLData
{
int gl_active; /* to stop switching drivers while we have a valid context */
#if SDL_VIDEO_OPENGL_GLX
GLXContext glx_context; /* Current GL context */
XVisualInfo *glx_visualinfo; /* XVisualInfo* returned by glXChooseVisual */
void *(*glXGetProcAddress) (const GLubyte * procName);
XVisualInfo *(*glXChooseVisual)
(Display * dpy, int screen, int *attribList);
GLXContext(*glXCreateContext)
(Display * dpy, XVisualInfo * vis, GLXContext shareList, Bool direct);
void (*glXDestroyContext) (Display * dpy, GLXContext ctx);
Bool(*glXMakeCurrent)
(Display * dpy, GLXDrawable drawable, GLXContext ctx);
void (*glXSwapBuffers) (Display * dpy, GLXDrawable drawable);
int (*glXGetConfig)
(Display * dpy, XVisualInfo * visual_info, int attrib, int *value);
const char *(*glXQueryExtensionsString) (Display * dpy, int screen);
int (*glXSwapIntervalSGI) (int interval);
GLint(*glXSwapIntervalMESA) (unsigned interval);
GLint(*glXGetSwapIntervalMESA) (void);
#endif /* SDL_VIDEO_OPENGL_GLX */
};
/* Old variable names */
#define gl_active (this->gl_data->gl_active)
#define glx_context (this->gl_data->glx_context)
#define glx_visualinfo (this->gl_data->glx_visualinfo)
/* OpenGL functions */
extern XVisualInfo *X11_GL_GetVisual(_THIS);
extern int X11_GL_CreateWindow(_THIS, int w, int h);
extern int X11_GL_CreateContext(_THIS);
extern void X11_GL_Shutdown(_THIS);
#if SDL_VIDEO_OPENGL_GLX
extern int X11_GL_MakeCurrent(_THIS);
extern int X11_GL_GetAttribute(_THIS, SDL_GLattr attrib, int *value);
extern void X11_GL_SwapBuffers(_THIS);
extern int X11_GL_LoadLibrary(_THIS, const char *path);
extern void *X11_GL_GetProcAddress(_THIS, const char *proc);
#endif
extern void X11_GL_UnloadLibrary(_THIS);
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11image.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include <stdio.h>
#include <unistd.h>
#include "SDL_endian.h"
#include "../../events/SDL_events_c.h"
#include "SDL_x11image_c.h"
#ifndef NO_SHARED_MEMORY
/* Shared memory error handler routine */
static int shm_error;
static int (*X_handler) (Display *, XErrorEvent *) = NULL;
static int
shm_errhandler(Display * d, XErrorEvent * e)
{
if (e->error_code == BadAccess) {
shm_error = True;
return (0);
} else
return (X_handler(d, e));
}
static void
try_mitshm(_THIS, SDL_Surface * screen)
{
/* Dynamic X11 may not have SHM entry points on this box. */
if ((use_mitshm) && (!SDL_X11_HAVE_SHM))
use_mitshm = 0;
if (!use_mitshm)
return;
shminfo.shmid = shmget(IPC_PRIVATE, screen->h * screen->pitch,
IPC_CREAT | 0777);
if (shminfo.shmid >= 0) {
shminfo.shmaddr = (char *) shmat(shminfo.shmid, 0, 0);
shminfo.readOnly = False;
if (shminfo.shmaddr != (char *) -1) {
shm_error = False;
X_handler = XSetErrorHandler(shm_errhandler);
XShmAttach(SDL_Display, &shminfo);
XSync(SDL_Display, True);
XSetErrorHandler(X_handler);
if (shm_error)
shmdt(shminfo.shmaddr);
} else {
shm_error = True;
}
shmctl(shminfo.shmid, IPC_RMID, NULL);
} else {
shm_error = True;
}
if (shm_error)
use_mitshm = 0;
if (use_mitshm)
screen->pixels = shminfo.shmaddr;
}
#endif /* ! NO_SHARED_MEMORY */
/* Various screen update functions available */
static void X11_NormalUpdate(_THIS, int numrects, SDL_Rect * rects);
static void X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect * rects);
int
X11_SetupImage(_THIS, SDL_Surface * screen)
{
#ifndef NO_SHARED_MEMORY
try_mitshm(this, screen);
if (use_mitshm) {
SDL_Ximage = XShmCreateImage(SDL_Display, SDL_Visual,
this->hidden->depth, ZPixmap,
shminfo.shmaddr, &shminfo,
screen->w, screen->h);
if (!SDL_Ximage) {
XShmDetach(SDL_Display, &shminfo);
XSync(SDL_Display, False);
shmdt(shminfo.shmaddr);
screen->pixels = NULL;
goto error;
}
this->UpdateRects = X11_MITSHMUpdate;
}
if (!use_mitshm)
#endif /* not NO_SHARED_MEMORY */
{
int bpp;
screen->pixels = SDL_malloc(screen->h * screen->pitch);
if (screen->pixels == NULL) {
SDL_OutOfMemory();
return -1;
}
bpp = screen->format->BytesPerPixel;
SDL_Ximage = XCreateImage(SDL_Display, SDL_Visual,
this->hidden->depth, ZPixmap, 0,
(char *) screen->pixels,
screen->w, screen->h, 32, 0);
if (SDL_Ximage == NULL)
goto error;
/* XPutImage will convert byte sex automatically */
SDL_Ximage->byte_order = (SDL_BYTEORDER == SDL_BIG_ENDIAN)
? MSBFirst : LSBFirst;
this->UpdateRects = X11_NormalUpdate;
}
screen->pitch = SDL_Ximage->bytes_per_line;
return (0);
error:
SDL_SetError("Couldn't create XImage");
return 1;
}
void
X11_DestroyImage(_THIS, SDL_Surface * screen)
{
if (SDL_Ximage) {
XDestroyImage(SDL_Ximage);
#ifndef NO_SHARED_MEMORY
if (use_mitshm) {
XShmDetach(SDL_Display, &shminfo);
XSync(SDL_Display, False);
shmdt(shminfo.shmaddr);
}
#endif /* ! NO_SHARED_MEMORY */
SDL_Ximage = NULL;
}
if (screen) {
screen->pixels = NULL;
}
}
/* Determine the number of CPUs in the system */
static int
num_CPU(void)
{
static int num_cpus = 0;
if (!num_cpus) {
#if defined(__LINUX__)
char line[BUFSIZ];
FILE *pstat = fopen("/proc/stat", "r");
if (pstat) {
while (fgets(line, sizeof(line), pstat)) {
if (SDL_memcmp(line, "cpu", 3) == 0 && line[3] != ' ') {
++num_cpus;
}
}
fclose(pstat);
}
#elif defined(__IRIX__)
num_cpus = sysconf(_SC_NPROC_ONLN);
#elif defined(_SC_NPROCESSORS_ONLN)
/* number of processors online (SVR4.0MP compliant machines) */
num_cpus = sysconf(_SC_NPROCESSORS_ONLN);
#elif defined(_SC_NPROCESSORS_CONF)
/* number of processors configured (SVR4.0MP compliant machines) */
num_cpus = sysconf(_SC_NPROCESSORS_CONF);
#endif
if (num_cpus <= 0) {
num_cpus = 1;
}
}
return num_cpus;
}
int
X11_ResizeImage(_THIS, SDL_Surface * screen, Uint32 flags)
{
int retval;
X11_DestroyImage(this, screen);
if (flags & SDL_INTERNALOPENGL) { /* No image when using GL */
retval = 0;
} else {
retval = X11_SetupImage(this, screen);
/* We support asynchronous blitting on the display */
if (flags & SDL_ASYNCBLIT) {
/* This is actually slower on single-CPU systems,
probably because of CPU contention between the
X server and the application.
Note: Is this still true with XFree86 4.0?
*/
if (num_CPU() > 1) {
screen->flags |= SDL_ASYNCBLIT;
}
}
}
return (retval);
}
/* We don't actually allow hardware surfaces other than the main one */
int
X11_AllocHWSurface(_THIS, SDL_Surface * surface)
{
return (-1);
}
void
X11_FreeHWSurface(_THIS, SDL_Surface * surface)
{
return;
}
int
X11_LockHWSurface(_THIS, SDL_Surface * surface)
{
if ((surface == SDL_VideoSurface) && blit_queued) {
XSync(GFX_Display, False);
blit_queued = 0;
}
return (0);
}
void
X11_UnlockHWSurface(_THIS, SDL_Surface * surface)
{
return;
}
int
X11_FlipHWSurface(_THIS, SDL_Surface * surface)
{
return (0);
}
static void
X11_NormalUpdate(_THIS, int numrects, SDL_Rect * rects)
{
int i;
for (i = 0; i < numrects; ++i) {
if (rects[i].w == 0 || rects[i].h == 0) { /* Clipped? */
continue;
}
XPutImage(GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
rects[i].x, rects[i].y,
rects[i].x, rects[i].y, rects[i].w, rects[i].h);
}
if (SDL_VideoSurface->flags & SDL_ASYNCBLIT) {
XFlush(GFX_Display);
blit_queued = 1;
} else {
XSync(GFX_Display, False);
}
}
static void
X11_MITSHMUpdate(_THIS, int numrects, SDL_Rect * rects)
{
#ifndef NO_SHARED_MEMORY
int i;
for (i = 0; i < numrects; ++i) {
if (rects[i].w == 0 || rects[i].h == 0) { /* Clipped? */
continue;
}
XShmPutImage(GFX_Display, SDL_Window, SDL_GC, SDL_Ximage,
rects[i].x, rects[i].y,
rects[i].x, rects[i].y, rects[i].w, rects[i].h, False);
}
if (SDL_VideoSurface->flags & SDL_ASYNCBLIT) {
XFlush(GFX_Display);
blit_queued = 1;
} else {
XSync(GFX_Display, False);
}
#endif /* ! NO_SHARED_MEMORY */
}
/* There's a problem with the automatic refreshing of the display.
Even though the XVideo code uses the GFX_Display to update the
video memory, it appears that updating the window asynchronously
from a different thread will cause "blackouts" of the window.
This is a sort of a hacked workaround for the problem.
*/
static int enable_autorefresh = 1;
void
X11_DisableAutoRefresh(_THIS)
{
--enable_autorefresh;
}
void
X11_EnableAutoRefresh(_THIS)
{
++enable_autorefresh;
}
void
X11_RefreshDisplay(_THIS)
{
/* Don't refresh a display that doesn't have an image (like GL)
Instead, post an expose event so the application can refresh.
*/
if (!SDL_Ximage || (enable_autorefresh <= 0)) {
SDL_PrivateExpose();
return;
}
#ifndef NO_SHARED_MEMORY
if (this->UpdateRects == X11_MITSHMUpdate) {
XShmPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
0, 0, SDL_CurrentWindow.offset_x,
SDL_CurrentWindow.offset_y,
SDL_CurrentDisplay.current_mode.w,
SDL_CurrentDisplay.current_mode.h, False);
} else
#endif /* ! NO_SHARED_MEMORY */
{
XPutImage(SDL_Display, SDL_Window, SDL_GC, SDL_Ximage,
0, 0, SDL_CurrentWindow.offset_x,
SDL_CurrentWindow.offset_y,
SDL_CurrentDisplay.current_mode.w,
SDL_CurrentDisplay.current_mode.h);
}
XSync(SDL_Display, False);
}
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11image_c.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_x11video.h"
extern int X11_SetupImage(_THIS, SDL_Surface * screen);
extern void X11_DestroyImage(_THIS, SDL_Surface * screen);
extern int X11_ResizeImage(_THIS, SDL_Surface * screen, Uint32 flags);
extern int X11_AllocHWSurface(_THIS, SDL_Surface * surface);
extern void X11_FreeHWSurface(_THIS, SDL_Surface * surface);
extern int X11_LockHWSurface(_THIS, SDL_Surface * surface);
extern void X11_UnlockHWSurface(_THIS, SDL_Surface * surface);
extern int X11_FlipHWSurface(_THIS, SDL_Surface * surface);
extern void X11_DisableAutoRefresh(_THIS);
extern void X11_EnableAutoRefresh(_THIS);
extern void X11_RefreshDisplay(_THIS);
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11modes.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
/* Utilities for getting and setting the X display mode */
#include <stdio.h>
#include "SDL_timer.h"
#include "SDL_events.h"
#include "../../events/SDL_events_c.h"
#include "SDL_x11video.h"
#include "SDL_x11wm_c.h"
#include "SDL_x11modes_c.h"
#include "SDL_x11image_c.h"
/*#define X11MODES_DEBUG*/
#define MAX(a, b) (a > b ? a : b)
#if SDL_VIDEO_DRIVER_X11_VIDMODE
int
vidmode_refreshrate(SDL_NAME(XF86VidModeModeInfo) * mode)
{
return (mode->htotal
&& mode->vtotal) ? (1000 * mode->dotclock / (mode->htotal *
mode->vtotal)) : 0;
}
#endif
#if SDL_VIDEO_DRIVER_X11_VIDMODE
Bool SDL_NAME(XF86VidModeGetModeInfo) (Display * dpy, int scr,
SDL_NAME(XF86VidModeModeInfo) * info)
{
SDL_NAME(XF86VidModeModeLine) * l =
(SDL_NAME(XF86VidModeModeLine) *) ((char *) info +
sizeof info->dotclock);
return SDL_NAME(XF86VidModeGetModeLine) (dpy, scr,
(int *) &info->dotclock, l);
}
#endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */
#if SDL_VIDEO_DRIVER_X11_VIDMODE
static void
save_mode(_THIS)
{
SDL_memset(&saved_mode, 0, sizeof(saved_mode));
SDL_NAME(XF86VidModeGetModeInfo) (SDL_Display, SDL_Screen, &saved_mode);
SDL_NAME(XF86VidModeGetViewPort) (SDL_Display, SDL_Screen, &saved_view.x,
&saved_view.y);
}
#endif
#if SDL_VIDEO_DRIVER_X11_VIDMODE
static void
restore_mode(_THIS)
{
SDL_NAME(XF86VidModeModeLine) mode;
int unused;
if (SDL_NAME(XF86VidModeGetModeLine)
(SDL_Display, SDL_Screen, &unused, &mode)) {
if ((saved_mode.hdisplay != mode.hdisplay) ||
(saved_mode.vdisplay != mode.vdisplay)) {
SDL_NAME(XF86VidModeSwitchToMode) (SDL_Display, SDL_Screen,
&saved_mode);
}
}
if ((saved_view.x != 0) || (saved_view.y != 0)) {
SDL_NAME(XF86VidModeSetViewPort) (SDL_Display, SDL_Screen,
saved_view.x, saved_view.y);
}
}
#endif
static void get_real_resolution(_THIS, int *w, int *h);
static void
set_best_resolution(_THIS, int width, int height)
{
SDL_DisplayMode mode;
mode.format = 0;
mode.w = width;
mode.h = height;
mode.refresh_rate = 0;
SDL_GetClosestDisplayMode(&mode, &mode, SDL_FULLSCREEN);
#if SDL_VIDEO_DRIVER_X11_VIDMODE
if (use_vidmode) {
SDL_NAME(XF86VidModeModeLine) vmode;
SDL_NAME(XF86VidModeModeInfo) vinfo;
SDL_NAME(XF86VidModeModeInfo) ** modes;
int i, dotclock;
int nmodes;
int best = -1;
if (SDL_NAME(XF86VidModeGetModeLine)
(SDL_Display, SDL_Screen, &dotclock, &vmode)
&& SDL_NAME(XF86VidModeGetAllModeLines) (SDL_Display,
SDL_Screen, &nmodes,
&modes)) {
vinfo.dotclock = dotclock;
SDL_memcpy(&vinfo.hdisplay, &vmode, sizeof(vmode));
for (i = 0; i < nmodes; i++) {
if ((modes[i]->hdisplay == mode.w) &&
(modes[i]->vdisplay == mode.h) &&
(vidmode_refreshrate(modes[i]) == mode.refresh_rate)) {
best = i;
break;
}
}
if (best >= 0 &&
((modes[best]->hdisplay != vmode.hdisplay) ||
(modes[best]->vdisplay != vmode.vdisplay) ||
(vidmode_refreshrate(modes[best]) !=
vidmode_refreshrate(&vinfo)))) {
#ifdef X11MODES_DEBUG
printf("Best Mode %d: %d x %d @ %d\n", best,
modes[best]->hdisplay, modes[best]->vdisplay,
vidmode_refreshrate(modes[best]));
#endif
SDL_NAME(XF86VidModeSwitchToMode) (SDL_Display,
SDL_Screen, modes[best]);
}
XFree(modes);
}
}
#endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */
/* XiG */
#if SDL_VIDEO_DRIVER_X11_XME
if (use_xme) {
int i;
int w, h;
/* check current mode so we can avoid uneccessary mode changes */
get_real_resolution(this, &w, &h);
if ((mode.w != w) || (mode.h != h)) {
#ifdef X11MODES_DEBUG
fprintf(stderr, "XME: set_best_resolution: "
"XiGMiscChangeResolution: %d %d\n", mode.w, mode.h);
#endif
XiGMiscChangeResolution(SDL_Display, SDL_Screen, 0, /* view */
mode.w, mode.h, 0);
XSync(SDL_Display, False);
}
}
#endif /* SDL_VIDEO_DRIVER_X11_XME */
#if SDL_VIDEO_DRIVER_X11_XRANDR
if (use_xrandr) {
int i, nsizes;
XRRScreenSize *sizes;
/* find the smallest resolution that is at least as big as the user requested */
sizes = XRRConfigSizes(screen_config, &nsizes);
for (i = (nsizes - 1); i >= 0; i--) {
if ((mode.w >= width) && (mode.h >= height)) {
break;
}
}
if (i >= 0) { /* found one, lets try it */
int w, h;
/* check current mode so we can avoid uneccessary mode changes */
get_real_resolution(this, &w, &h);
if ((mode.w != w) || (mode.h != h)) {
int size_id;
#ifdef X11MODES_DEBUG
fprintf(stderr, "XRANDR: set_best_resolution: "
"XXRSetScreenConfig: %d %d\n", mode.w, mode.h);
#endif
/* find the matching size entry index */
for (size_id = 0; size_id < nsizes; ++size_id) {
if ((sizes[size_id].width == mode.w) &&
(sizes[size_id].height == mode.h))
break;
}
XRRSetScreenConfig(SDL_Display, screen_config,
SDL_Root, size_id, saved_rotation,
CurrentTime);
}
}
}
#endif /* SDL_VIDEO_DRIVER_X11_XRANDR */
}
static void
get_real_resolution(_THIS, int *w, int *h)
{
#if SDL_VIDEO_DRIVER_X11_XME
if (use_xme) {
int ractive;
XiGMiscResolutionInfo *modelist;
XiGMiscQueryResolutions(SDL_Display, SDL_Screen, 0, /* view */
&ractive, &modelist);
*w = modelist[ractive].width;
*h = modelist[ractive].height;
#ifdef X11MODES_DEBUG
fprintf(stderr, "XME: get_real_resolution: w = %d h = %d\n", *w, *h);
#endif
XFree(modelist);
return;
}
#endif /* SDL_VIDEO_DRIVER_X11_XME */
#if SDL_VIDEO_DRIVER_X11_VIDMODE
if (use_vidmode) {
SDL_NAME(XF86VidModeModeLine) mode;
int unused;
if (SDL_NAME(XF86VidModeGetModeLine)
(SDL_Display, SDL_Screen, &unused, &mode)) {
*w = mode.hdisplay;
*h = mode.vdisplay;
return;
}
}
#endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */
#if SDL_VIDEO_DRIVER_X11_XRANDR
if (use_xrandr) {
int nsizes;
XRRScreenSize *sizes;
sizes = XRRConfigSizes(screen_config, &nsizes);
if (nsizes > 0) {
int cur_size;
Rotation cur_rotation;
cur_size =
XRRConfigCurrentConfiguration(screen_config, &cur_rotation);
if (cur_size >= 0 && cur_size < nsizes) {
*w = sizes[cur_size].width;
*h = sizes[cur_size].height;
}
#ifdef X11MODES_DEBUG
fprintf(stderr,
"XRANDR: get_real_resolution: w = %d h = %d\n", *w, *h);
#endif
return;
}
}
#endif /* SDL_VIDEO_DRIVER_X11_XRANDR */
#if SDL_VIDEO_DRIVER_X11_XINERAMA
if (use_xinerama) {
*w = xinerama[this->current_display].width;
*h = xinerama[this->current_display].height;
return;
}
#endif /* SDL_VIDEO_DRIVER_X11_XINERAMA */
*w = DisplayWidth(SDL_Display, SDL_Screen);
*h = DisplayHeight(SDL_Display, SDL_Screen);
}
/* Called after mapping a window - waits until the window is mapped */
void
X11_WaitMapped(_THIS, Window win)
{
XEvent event;
do {
XMaskEvent(SDL_Display, StructureNotifyMask, &event);
}
while ((event.type != MapNotify) || (event.xmap.event != win));
}
/* Called after unmapping a window - waits until the window is unmapped */
void
X11_WaitUnmapped(_THIS, Window win)
{
XEvent event;
do {
XMaskEvent(SDL_Display, StructureNotifyMask, &event);
}
while ((event.type != UnmapNotify) || (event.xunmap.event != win));
}
static void
move_cursor_to(_THIS, int x, int y)
{
XWarpPointer(SDL_Display, None, SDL_Root, 0, 0, 0, 0, x, y);
}
static int
add_visual(_THIS, int depth, int class)
{
XVisualInfo vi;
if (XMatchVisualInfo(SDL_Display, SDL_Screen, depth, class, &vi)) {
int n = this->hidden->nvisuals;
this->hidden->visuals[n].depth = vi.depth;
this->hidden->visuals[n].visual = vi.visual;
this->hidden->nvisuals++;
}
return (this->hidden->nvisuals);
}
static int
add_visual_byid(_THIS, const char *visual_id)
{
XVisualInfo *vi, template;
int nvis;
if (visual_id) {
SDL_memset(&template, 0, (sizeof template));
template.visualid = SDL_strtol(visual_id, NULL, 0);
vi = XGetVisualInfo(SDL_Display, VisualIDMask, &template, &nvis);
if (vi) {
int n = this->hidden->nvisuals;
this->hidden->visuals[n].depth = vi->depth;
this->hidden->visuals[n].visual = vi->visual;
this->hidden->nvisuals++;
XFree(vi);
}
}
return (this->hidden->nvisuals);
}
int
X11_GetVisuals(_THIS)
{
/* It's interesting to note that if we allow 32 bit depths,
we get a visual with an alpha mask on composite servers.
static int depth_list[] = { 32, 24, 16, 15, 8 };
*/
static int depth_list[] = { 24, 16, 15, 8 };
int i, j, np;
int use_directcolor = 1;
XPixmapFormatValues *pf;
/* Search for the visuals in deepest-first order, so that the first
will be the richest one */
if (SDL_getenv("SDL_VIDEO_X11_NODIRECTCOLOR")) {
use_directcolor = 0;
}
this->hidden->nvisuals = 0;
if (!add_visual_byid(this, SDL_getenv("SDL_VIDEO_X11_VISUALID"))) {
for (i = 0; i < SDL_arraysize(depth_list); ++i) {
if (depth_list[i] > 8) {
if (use_directcolor) {
add_visual(this, depth_list[i], DirectColor);
}
add_visual(this, depth_list[i], TrueColor);
} else {
add_visual(this, depth_list[i], PseudoColor);
add_visual(this, depth_list[i], StaticColor);
}
}
}
if (this->hidden->nvisuals == 0) {
SDL_SetError("Found no sufficiently capable X11 visuals");
return -1;
}
/* look up the pixel quantum for each depth */
pf = XListPixmapFormats(SDL_Display, &np);
for (i = 0; i < this->hidden->nvisuals; i++) {
int d = this->hidden->visuals[i].depth;
for (j = 0; j < np; j++)
if (pf[j].depth == d)
break;
this->hidden->visuals[i].bpp = j < np ? pf[j].bits_per_pixel : d;
}
XFree(pf);
return 0;
}
/* Global for the error handler */
int vm_event, vm_error = -1;
#if SDL_VIDEO_DRIVER_X11_XINERAMA
static int
CheckXinerama(_THIS, int *major, int *minor)
{
const char *env;
/* Default the extension not available */
*major = *minor = 0;
/* Allow environment override */
env = getenv("SDL_VIDEO_X11_XINERAMA");
if (env && !SDL_atoi(env)) {
return 0;
}
/* Query the extension version */
if (!SDL_NAME(XineramaQueryExtension) (SDL_Display, major, minor) ||
!SDL_NAME(XineramaIsActive) (SDL_Display)) {
return 0;
}
return 1;
}
#endif /* SDL_VIDEO_DRIVER_X11_XINERAMA */
#if SDL_VIDEO_DRIVER_X11_XRANDR
static int
CheckXRandR(_THIS, int *major, int *minor)
{
const char *env;
/* Default the extension not available */
*major = *minor = 0;
/* Allow environment override */
env = getenv("SDL_VIDEO_X11_XRANDR");
if (env && !SDL_atoi(env)) {
return 0;
}
/* This defaults off now, due to KDE window maximize problems */
if (!env) {
return 0;
}
if (!SDL_X11_HAVE_XRANDR) {
return 0;
}
/* Query the extension version */
if (!XRRQueryVersion(SDL_Display, major, minor)) {
return 0;
}
return 1;
}
#endif /* SDL_VIDEO_DRIVER_X11_XRANDR */
#if SDL_VIDEO_DRIVER_X11_VIDMODE
static int
CheckVidMode(_THIS, int *major, int *minor)
{
const char *env;
/* Default the extension not available */
*major = *minor = 0;
/* Allow environment override */
env = getenv("SDL_VIDEO_X11_VIDMODE");
if (env && !SDL_atoi(env)) {
return 0;
}
/* Metro-X 4.3.0 and earlier has a broken implementation of
XF86VidModeGetAllModeLines() - it hangs the client.
*/
if (SDL_strcmp(ServerVendor(SDL_Display), "Metro Link Incorporated") == 0) {
FILE *metro_fp;
metro_fp = fopen("/usr/X11R6/lib/X11/Metro/.version", "r");
if (metro_fp != NULL) {
int major, minor, patch, version;
major = 0;
minor = 0;
patch = 0;
fscanf(metro_fp, "%d.%d.%d", &major, &minor, &patch);
fclose(metro_fp);
version = major * 100 + minor * 10 + patch;
if (version < 431) {
return 0;
}
}
}
/* Query the extension version */
vm_error = -1;
if (!SDL_NAME(XF86VidModeQueryExtension)
(SDL_Display, &vm_event, &vm_error)
|| !SDL_NAME(XF86VidModeQueryVersion) (SDL_Display, major, minor)) {
return 0;
}
return 1;
}
#endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */
#if SDL_VIDEO_DRIVER_X11_XME
static int
CheckXME(_THIS, int *major, int *minor)
{
const char *env;
/* Default the extension not available */
*major = *minor = 0;
/* Allow environment override */
env = getenv("SDL_VIDEO_X11_VIDMODE");
if (env && !SDL_atoi(env)) {
return 0;
}
/* Query the extension version */
if (!XiGMiscQueryVersion(SDL_Display, major, minor)) {
return 0;
}
return 1;
}
#endif /* SDL_VIDEO_DRIVER_X11_XME */
int
X11_GetVideoModes(_THIS)
{
#if SDL_VIDEO_DRIVER_X11_XINERAMA
int xinerama_major, xinerama_minor;
#endif
#if SDL_VIDEO_DRIVER_X11_XRANDR
int xrandr_major, xrandr_minor;
int nsizes;
XRRScreenSize *sizes;
int nrates;
short *rates;
#endif
#if SDL_VIDEO_DRIVER_X11_VIDMODE
int vm_major, vm_minor;
int nmodes;
SDL_NAME(XF86VidModeModeInfo) ** modes;
#endif
#if SDL_VIDEO_DRIVER_X11_XME
int xme_major, xme_minor;
int ractive, nummodes;
XiGMiscResolutionInfo *modelist;
#endif
int i;
int screen_w;
int screen_h;
SDL_DisplayMode mode;
use_xinerama = 0;
use_xrandr = 0;
use_vidmode = 0;
use_xme = 0;
screen_w = DisplayWidth(SDL_Display, SDL_Screen);
screen_h = DisplayHeight(SDL_Display, SDL_Screen);
mode.format = this->displays[this->current_display].desktop_mode.format;
mode.w = screen_w;
mode.h = screen_h;
mode.refresh_rate = 0;
SDL_AddDisplayMode(0, &mode);
#if SDL_VIDEO_DRIVER_X11_XINERAMA
/* Query Xinerama extention */
if (CheckXinerama(this, &xinerama_major, &xinerama_minor)) {
int screens;
#ifdef X11MODES_DEBUG
printf("X11 detected Xinerama:\n");
#endif
xinerama = SDL_NAME(XineramaQueryScreens) (SDL_Display, &screens);
for (i = 0; i < screens; i++) {
#ifdef X11MODES_DEBUG
printf("xinerama %d: %dx%d+%d+%d\n",
xinerama[i].screen_number,
xinerama[i].width, xinerama[i].height,
xinerama[i].x_org, xinerama[i].y_org);
#endif
if (xinerama[i].screen_number != 0) {
SDL_AddVideoDisplay(&mode);
}
mode.w = xinerama[i].width;
mode.h = xinerama[i].height;
SDL_AddDisplayMode(xinerama[i].screen_number, &mode);
}
use_xinerama = 1;
}
#endif /* SDL_VIDEO_DRIVER_X11_XINERAMA */
#if SDL_VIDEO_DRIVER_X11_XRANDR
/* XRandR */
/* require at least XRandR v1.0 (arbitrary) */
if (CheckXRandR(this, &xrandr_major, &xrandr_minor)
&& (xrandr_major >= 1)) {
#ifdef X11MODES_DEBUG
fprintf(stderr, "XRANDR: XRRQueryVersion: V%d.%d\n",
xrandr_major, xrandr_minor);
#endif
/* save the screen configuration since we must reference it
each time we toggle modes.
*/
screen_config = XRRGetScreenInfo(SDL_Display, SDL_Root);
/* retrieve the list of resolution */
sizes = XRRConfigSizes(screen_config, &nsizes);
if (nsizes > 0) {
for (i = 0; i < nsizes; i++) {
mode.w = sizes[i].width;
mode.h = sizes[i].height;
rates = XRRConfigRates(screen_config, i, &nrates);
if (nrates == 0) {
mode.refresh_rate = 0;
SDL_AddDisplayMode(0, &mode);
} else {
int j;
for (j = 0; j < nrates; ++j) {
mode.refresh_rate = rates[j];
SDL_AddDisplayMode(0, &mode);
}
}
}
use_xrandr = xrandr_major * 100 + xrandr_minor;
saved_size_id =
XRRConfigCurrentConfiguration(screen_config, &saved_rotation);
}
}
#endif /* SDL_VIDEO_DRIVER_X11_XRANDR */
#if SDL_VIDEO_DRIVER_X11_VIDMODE
/* XVidMode */
if (!use_xrandr &&
CheckVidMode(this, &vm_major, &vm_minor) &&
SDL_NAME(XF86VidModeGetAllModeLines) (SDL_Display, SDL_Screen,
&nmodes, &modes)) {
#ifdef X11MODES_DEBUG
printf("VidMode modes: (unsorted)\n");
for (i = 0; i < nmodes; ++i) {
printf("Mode %d: %d x %d @ %d\n", i,
modes[i]->hdisplay, modes[i]->vdisplay,
vidmode_refreshrate(modes[i]));
}
#endif
for (i = 0; i < nmodes; ++i) {
mode.w = modes[i]->hdisplay;
mode.h = modes[i]->vdisplay;
mode.refresh_rate = vidmode_refreshrate(modes[i]);
SDL_AddDisplayMode(0, &mode);
}
XFree(modes);
use_vidmode = vm_major * 100 + vm_minor;
save_mode(this);
}
#endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */
#if SDL_VIDEO_DRIVER_X11_XME
/* XiG */
modelist = NULL;
/* first lets make sure we have the extension, and it's at least v2.0 */
if (CheckXME(this, &xme_major, &xme_minor) && xme_major >= 2 && (nummodes = XiGMiscQueryResolutions(SDL_Display, SDL_Screen, 0, /* view */
&ractive,
&modelist))
> 1) { /* then we actually have some */
/* We get the list already sorted in descending order.
We'll copy it in reverse order so SDL is happy */
#ifdef X11MODES_DEBUG
fprintf(stderr, "XME: nummodes = %d, active mode = %d\n",
nummodes, ractive);
#endif
mode.refresh_rate = 0;
for (i = 0; i < nummodes; ++i) {
#ifdef X11MODES_DEBUG
fprintf(stderr, "XME: mode = %4d, w = %4d, h = %4d\n",
i, modelist[i].width, modelist[i].height);
#endif
mode.w = modelist[i].width;
mode.h = modelist[i].height;
SDL_AddDisplayMode(0, &mode);
}
use_xme = xme_major * 100 + xme_minor;
saved_res = modelist[ractive]; /* save the current resolution */
}
if (modelist) {
XFree(modelist);
}
#endif /* SDL_VIDEO_DRIVER_X11_XME */
#ifdef X11MODES_DEBUG
if (use_xinerama) {
printf("Xinerama is enabled\n");
}
if (use_xrandr) {
printf("XRandR is enabled\n");
}
if (use_vidmode) {
printf("VidMode is enabled\n");
}
if (use_xme) {
printf("Xi Graphics XME fullscreen is enabled\n");
}
#endif /* X11MODES_DEBUG */
return 0;
}
void
X11_FreeVideoModes(_THIS)
{
#if SDL_VIDEO_DRIVER_X11_XRANDR
/* Free the Xrandr screen configuration */
if (screen_config) {
XRRFreeScreenConfigInfo(screen_config);
screen_config = NULL;
}
#endif /* SDL_VIDEO_DRIVER_X11_XRANDR */
}
int
X11_ResizeFullScreen(_THIS)
{
int x = 0, y = 0;
int real_w, real_h;
int screen_w;
int screen_h;
screen_w = DisplayWidth(SDL_Display, SDL_Screen);
screen_h = DisplayHeight(SDL_Display, SDL_Screen);
#if SDL_VIDEO_DRIVER_X11_XINERAMA
if (use_xinerama &&
window_w <= xinerama[this->current_display].width &&
window_h <= xinerama[this->current_display].height) {
x = xinerama[this->current_display].x_org;
y = xinerama[this->current_display].y_org;
}
#endif /* SDL_VIDEO_DRIVER_X11_XINERAMA */
if (currently_fullscreen) {
/* Switch resolution and cover it with the FSwindow */
move_cursor_to(this, x, y);
set_best_resolution(this, window_w, window_h);
move_cursor_to(this, x, y);
get_real_resolution(this, &real_w, &real_h);
if (window_w > real_w) {
real_w = MAX(real_w, screen_w);
}
if (window_h > real_h) {
real_h = MAX(real_h, screen_h);
}
XMoveResizeWindow(SDL_Display, FSwindow, x, y, real_w, real_h);
move_cursor_to(this, real_w / 2, real_h / 2);
/* Center and reparent the drawing window */
x = (real_w - window_w) / 2;
y = (real_h - window_h) / 2;
XReparentWindow(SDL_Display, SDL_Window, FSwindow, x, y);
/* FIXME: move the mouse to the old relative location */
XSync(SDL_Display, True); /* Flush spurious mode change events */
}
return (1);
}
void
X11_QueueEnterFullScreen(_THIS)
{
switch_waiting = 0x01 | SDL_FULLSCREEN;
switch_time = SDL_GetTicks() + 1500;
#if 0 /* This causes a BadMatch error if the window is iconified (not needed) */
XSetInputFocus(SDL_Display, WMwindow, RevertToNone, CurrentTime);
#endif
}
int
X11_EnterFullScreen(_THIS)
{
int okay;
#if 0
Window tmpwin, *windows;
int i, nwindows;
#endif
int x = 0, y = 0;
int real_w, real_h;
int screen_w;
int screen_h;
okay = 1;
if (currently_fullscreen) {
return (okay);
}
/* Ungrab the input so that we can move the mouse around */
X11_GrabInputNoLock(this, SDL_GRAB_OFF);
#if SDL_VIDEO_DRIVER_X11_XINERAMA
if (use_xinerama &&
window_w <= xinerama[this->current_display].width &&
window_h <= xinerama[this->current_display].height) {
x = xinerama[this->current_display].x_org;
y = xinerama[this->current_display].y_org;
}
#endif /* SDL_VIDEO_DRIVER_X11_XINERAMA */
/* Map the fullscreen window to blank the screen */
screen_w = DisplayWidth(SDL_Display, SDL_Screen);
screen_h = DisplayHeight(SDL_Display, SDL_Screen);
get_real_resolution(this, &real_w, &real_h);
if (window_w > real_w) {
real_w = MAX(real_w, screen_w);
}
if (window_h > real_h) {
real_h = MAX(real_h, screen_h);
}
XMoveResizeWindow(SDL_Display, FSwindow, x, y, real_w, real_h);
XMapRaised(SDL_Display, FSwindow);
X11_WaitMapped(this, FSwindow);
#if 0 /* This seems to break WindowMaker in focus-follows-mouse mode */
/* Make sure we got to the top of the window stack */
if (XQueryTree(SDL_Display, SDL_Root, &tmpwin, &tmpwin,
&windows, &nwindows) && windows) {
/* If not, try to put us there - if fail... oh well */
if (windows[nwindows - 1] != FSwindow) {
tmpwin = windows[nwindows - 1];
for (i = 0; i < nwindows; ++i) {
if (windows[i] == FSwindow) {
SDL_memcpy(&windows[i], &windows[i + 1],
(nwindows - i - 1) * sizeof(windows[i]));
break;
}
}
windows[nwindows - 1] = FSwindow;
XRestackWindows(SDL_Display, windows, nwindows);
XSync(SDL_Display, False);
}
XFree(windows);
}
#else
XRaiseWindow(SDL_Display, FSwindow);
#endif
#if SDL_VIDEO_DRIVER_X11_VIDMODE
/* Save the current video mode */
if (use_vidmode) {
SDL_NAME(XF86VidModeLockModeSwitch) (SDL_Display, SDL_Screen, True);
}
#endif
currently_fullscreen = 1;
/* Set the new resolution */
okay = X11_ResizeFullScreen(this);
if (!okay) {
X11_LeaveFullScreen(this);
}
/* Set the colormap */
if (SDL_XColorMap) {
XInstallColormap(SDL_Display, SDL_XColorMap);
}
if (okay) {
X11_GrabInputNoLock(this,
SDL_CurrentWindow.
input_grab | SDL_GRAB_FULLSCREEN);
}
/* We may need to refresh the screen at this point (no backing store)
We also don't get an event, which is why we explicitly refresh. */
if (SDL_VideoSurface) {
if (SDL_VideoSurface->flags & SDL_INTERNALOPENGL) {
SDL_PrivateExpose();
} else {
X11_RefreshDisplay(this);
}
}
return (okay);
}
int
X11_LeaveFullScreen(_THIS)
{
if (currently_fullscreen) {
XReparentWindow(SDL_Display, SDL_Window, WMwindow, 0, 0);
#if SDL_VIDEO_DRIVER_X11_VIDMODE
if (use_vidmode) {
restore_mode(this);
SDL_NAME(XF86VidModeLockModeSwitch) (SDL_Display, SDL_Screen,
False);
}
#endif
#if SDL_VIDEO_DRIVER_X11_XME
if (use_xme) {
int rw, rh;
/* check current mode so we can avoid uneccessary mode changes */
get_real_resolution(this, &rw, &rh);
if (rw != saved_res.width || rh != saved_res.height) {
XiGMiscChangeResolution(SDL_Display, SDL_Screen, 0, /* view */
saved_res.width, saved_res.height, 0);
XSync(SDL_Display, False);
}
}
#endif
#if SDL_VIDEO_DRIVER_X11_XRANDR
if (use_xrandr) {
XRRSetScreenConfig(SDL_Display, screen_config, SDL_Root,
saved_size_id, saved_rotation, CurrentTime);
}
#endif
XUnmapWindow(SDL_Display, FSwindow);
X11_WaitUnmapped(this, FSwindow);
XSync(SDL_Display, True); /* Flush spurious mode change events */
currently_fullscreen = 0;
}
/* If we get popped out of fullscreen mode for some reason, input_grab
will still have the SDL_GRAB_FULLSCREEN flag set, since this is only
temporary. In this case, release the grab unless the input has been
explicitly grabbed.
*/
X11_GrabInputNoLock(this,
SDL_CurrentWindow.input_grab & ~SDL_GRAB_FULLSCREEN);
/* We may need to refresh the screen at this point (no backing store)
We also don't get an event, which is why we explicitly refresh. */
if (SDL_VideoSurface) {
if (SDL_VideoSurface->flags & SDL_INTERNALOPENGL) {
SDL_PrivateExpose();
} else {
X11_RefreshDisplay(this);
}
}
return (0);
}
Uint32
X11_VisualToFormat(const Visual * visual, int depth, int bpp)
{
Uint32 Rmask = visual->red_mask;
Uint32 Gmask = visual->green_mask;
Uint32 Bmask = visual->blue_mask;
Uint32 Amask;
if (depth == 32) {
Amask = (0xFFFFFFFF & ~(Rmask | Gmask | Bmask));
} else {
Amask = 0;
}
return (SDL_MasksToPixelFormatEnum(bpp, Rmask, Gmask, Bmask, Amask));
}
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11modes_c.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
/* Utilities for getting and setting the X display mode */
#include "SDL_x11video.h"
/* Define this if you want to grab the keyboard in fullscreen mode.
If you do not define this, SDL will return from SDL_SetVideoMode()
immediately, but will not actually go fullscreen until the window
manager is idle.
*/
#define GRAB_FULLSCREEN
extern int X11_GetVisuals(_THIS);
extern int X11_GetVideoModes(_THIS);
extern int X11_ResizeFullScreen(_THIS);
extern void X11_WaitMapped(_THIS, Window win);
extern void X11_WaitUnmapped(_THIS, Window win);
extern void X11_QueueEnterFullScreen(_THIS);
extern int X11_EnterFullScreen(_THIS);
extern int X11_LeaveFullScreen(_THIS);
extern Uint32 X11_VisualToFormat(const Visual * visual, int depth, int bpp);
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11mouse.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "SDL_mouse.h"
#include "../../events/SDL_events_c.h"
#include "../SDL_cursor_c.h"
#include "SDL_x11dga_c.h"
#include "SDL_x11mouse_c.h"
/* The implementation dependent data for the window manager cursor */
struct WMcursor
{
Cursor x_cursor;
};
void
X11_FreeWMCursor(_THIS, WMcursor * cursor)
{
if (SDL_Display != NULL) {
SDL_Lock_EventThread();
XFreeCursor(SDL_Display, cursor->x_cursor);
XSync(SDL_Display, False);
SDL_Unlock_EventThread();
}
SDL_free(cursor);
}
WMcursor *
X11_CreateWMCursor(_THIS,
Uint8 * data, Uint8 * mask, int w, int h, int hot_x,
int hot_y)
{
WMcursor *cursor;
XGCValues GCvalues;
GC GCcursor;
XImage *data_image, *mask_image;
Pixmap data_pixmap, mask_pixmap;
int clen, i;
char *x_data, *x_mask;
static XColor black = { 0, 0, 0, 0 };
static XColor white = { 0xffff, 0xffff, 0xffff, 0xffff };
/* Allocate the cursor memory */
cursor = (WMcursor *) SDL_malloc(sizeof(WMcursor));
if (cursor == NULL) {
SDL_OutOfMemory();
return (NULL);
}
/* Mix the mask and the data */
clen = (w / 8) * h;
x_data = (char *) SDL_malloc(clen);
if (x_data == NULL) {
SDL_free(cursor);
SDL_OutOfMemory();
return (NULL);
}
x_mask = (char *) SDL_malloc(clen);
if (x_mask == NULL) {
SDL_free(cursor);
SDL_free(x_data);
SDL_OutOfMemory();
return (NULL);
}
for (i = 0; i < clen; ++i) {
/* The mask is OR'd with the data to turn inverted color
pixels black since inverted color cursors aren't supported
under X11.
*/
x_mask[i] = data[i] | mask[i];
x_data[i] = data[i];
}
/* Prevent the event thread from running while we use the X server */
SDL_Lock_EventThread();
/* Create the data image */
data_image = XCreateImage(SDL_Display,
DefaultVisual(SDL_Display, SDL_Screen),
1, XYBitmap, 0, x_data, w, h, 8, w / 8);
data_image->byte_order = MSBFirst;
data_image->bitmap_bit_order = MSBFirst;
data_pixmap = XCreatePixmap(SDL_Display, SDL_Root, w, h, 1);
/* Create the data mask */
mask_image = XCreateImage(SDL_Display,
DefaultVisual(SDL_Display, SDL_Screen),
1, XYBitmap, 0, x_mask, w, h, 8, w / 8);
mask_image->byte_order = MSBFirst;
mask_image->bitmap_bit_order = MSBFirst;
mask_pixmap = XCreatePixmap(SDL_Display, SDL_Root, w, h, 1);
/* Create the graphics context */
GCvalues.function = GXcopy;
GCvalues.foreground = ~0;
GCvalues.background = 0;
GCvalues.plane_mask = AllPlanes;
GCcursor = XCreateGC(SDL_Display, data_pixmap,
(GCFunction | GCForeground | GCBackground |
GCPlaneMask), &GCvalues);
/* Blit the images to the pixmaps */
XPutImage(SDL_Display, data_pixmap, GCcursor, data_image,
0, 0, 0, 0, w, h);
XPutImage(SDL_Display, mask_pixmap, GCcursor, mask_image,
0, 0, 0, 0, w, h);
XFreeGC(SDL_Display, GCcursor);
/* These free the x_data and x_mask memory pointers */
XDestroyImage(data_image);
XDestroyImage(mask_image);
/* Create the cursor */
cursor->x_cursor = XCreatePixmapCursor(SDL_Display, data_pixmap,
mask_pixmap, &black, &white,
hot_x, hot_y);
XFreePixmap(SDL_Display, data_pixmap);
XFreePixmap(SDL_Display, mask_pixmap);
/* Release the event thread */
XSync(SDL_Display, False);
SDL_Unlock_EventThread();
return (cursor);
}
int
X11_ShowWMCursor(_THIS, WMcursor * cursor)
{
/* Don't do anything if the display is gone */
if (SDL_Display == NULL) {
return (0);
}
/* Set the X11 cursor cursor, or blank if cursor is NULL */
if (SDL_Window) {
SDL_Lock_EventThread();
if (cursor == NULL) {
if (SDL_BlankCursor != NULL) {
XDefineCursor(SDL_Display, SDL_Window,
SDL_BlankCursor->x_cursor);
}
} else {
XDefineCursor(SDL_Display, SDL_Window, cursor->x_cursor);
}
XSync(SDL_Display, False);
SDL_Unlock_EventThread();
}
return (1);
}
void
X11_WarpWMCursor(_THIS, Uint16 x, Uint16 y)
{
if (using_dga & DGA_MOUSE) {
SDL_PrivateMouseMotion(0, 0, x, y);
} else if (mouse_relative) {
/* RJR: March 28, 2000
leave physical cursor at center of screen if
mouse hidden and grabbed */
SDL_PrivateMouseMotion(0, 0, x, y);
} else {
SDL_Lock_EventThread();
XWarpPointer(SDL_Display, None, SDL_Window, 0, 0, 0, 0, x, y);
XSync(SDL_Display, False);
SDL_Unlock_EventThread();
}
}
/* Sets the mouse acceleration from a string of the form:
2/1/0
The first number is the numerator, followed by the acceleration
denumenator and threshold.
*/
static void
SetMouseAccel(_THIS, const char *accel_param)
{
int i;
size_t len;
int accel_value[3];
char *mouse_param, *mouse_param_buf, *pin;
len = SDL_strlen(accel_param) + 1;
mouse_param_buf = SDL_stack_alloc(char, len);
if (!mouse_param_buf) {
return;
}
SDL_strlcpy(mouse_param_buf, accel_param, len);
mouse_param = mouse_param_buf;
for (i = 0; (i < 3) && mouse_param; ++i) {
pin = SDL_strchr(mouse_param, '/');
if (pin) {
*pin = '\0';
}
accel_value[i] = atoi(mouse_param);
if (pin) {
mouse_param = pin + 1;
} else {
mouse_param = NULL;
}
}
if (mouse_param_buf) {
XChangePointerControl(SDL_Display, True, True,
accel_value[0], accel_value[1], accel_value[2]);
SDL_free(mouse_param_buf);
}
}
/* Check to see if we need to enter or leave mouse relative mode */
void
X11_CheckMouseModeNoLock(_THIS)
{
const Uint8 full_focus =
(SDL_APPACTIVE | SDL_APPINPUTFOCUS | SDL_APPMOUSEFOCUS);
char *env_override;
int enable_relative = 1;
/* Allow the user to override the relative mouse mode.
They almost never want to do this, as it seriously affects
applications that rely on continuous relative mouse motion.
*/
env_override = SDL_getenv("SDL_MOUSE_RELATIVE");
if (env_override) {
enable_relative = atoi(env_override);
}
/* If the mouse is hidden and input is grabbed, we use relative mode */
if (enable_relative &&
!(SDL_cursorstate & CURSOR_VISIBLE) &&
(SDL_CurrentWindow.input_grab != SDL_GRAB_OFF) &&
(SDL_GetAppState() & full_focus) == full_focus) {
if (!mouse_relative) {
X11_EnableDGAMouse(this);
if (!(using_dga & DGA_MOUSE)) {
char *xmouse_accel;
SDL_GetMouseState(&mouse_last.x, &mouse_last.y);
/* Use as raw mouse mickeys as possible */
XGetPointerControl(SDL_Display,
&mouse_accel.numerator,
&mouse_accel.denominator,
&mouse_accel.threshold);
xmouse_accel = SDL_getenv("SDL_VIDEO_X11_MOUSEACCEL");
if (xmouse_accel) {
SetMouseAccel(this, xmouse_accel);
}
}
mouse_relative = 1;
}
} else {
if (mouse_relative) {
if (using_dga & DGA_MOUSE) {
X11_DisableDGAMouse(this);
} else {
XChangePointerControl(SDL_Display, True, True,
mouse_accel.numerator,
mouse_accel.denominator,
mouse_accel.threshold);
}
mouse_relative = 0;
}
}
}
void
X11_CheckMouseMode(_THIS)
{
SDL_Lock_EventThread();
X11_CheckMouseModeNoLock(this);
SDL_Unlock_EventThread();
}
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11mouse_c.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_x11video.h"
/* Functions to be exported */
extern void X11_FreeWMCursor(_THIS, WMcursor * cursor);
extern WMcursor *X11_CreateWMCursor(_THIS,
Uint8 * data, Uint8 * mask, int w, int h,
int hot_x, int hot_y);
extern int X11_ShowWMCursor(_THIS, WMcursor * cursor);
extern void X11_WarpWMCursor(_THIS, Uint16 x, Uint16 y);
extern void X11_CheckMouseModeNoLock(_THIS);
extern void X11_CheckMouseMode(_THIS);
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11sym.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2004 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with this library; if not, write to the Free
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Sam Lantinga
slouken@libsdl.org
*/
SDL_X11_MODULE(BASEXLIB)
SDL_X11_SYM(XClassHint *, XAllocClassHint, (void), (), return)
SDL_X11_SYM(Status, XAllocColor, (Display * a, Colormap b, XColor * c),
(a, b, c), return) SDL_X11_SYM(XSizeHints *, XAllocSizeHints,
(void), (),
return) SDL_X11_SYM(XWMHints *,
XAllocWMHints,
(void), (),
return)
SDL_X11_SYM(int, XChangePointerControl,
(Display * a, Bool b, Bool c, int d, int e, int f), (a, b, c, d,
e, f),
return) SDL_X11_SYM(int, XChangeProperty, (Display * a,
Window b, Atom c,
Atom d, int e, int f,
_Xconst unsigned char
*g, int h), (a, b, c,
d, e, f,
g, h),
return) SDL_X11_SYM(int,
XChangeWindowAttributes,
(Display * a, Window b,
unsigned long c,
XSetWindowAttributes *
d), (a, b, c, d), return)
SDL_X11_SYM(Bool, XCheckTypedEvent, (Display * a, int b, XEvent * c),
(a, b, c), return) SDL_X11_SYM(int, XClearWindow, (Display * a,
Window b),
(a, b), return) SDL_X11_SYM(int,
XCloseDisplay,
(Display
*
a),
(a),
return)
SDL_X11_SYM(Colormap, XCreateColormap,
(Display * a, Window b, Visual * c, int d), (a, b, c, d),
return) SDL_X11_SYM(Cursor, XCreatePixmapCursor, (Display * a,
Pixmap b,
Pixmap c,
XColor * d,
XColor * e,
unsigned int
f,
unsigned int
g), (a, b, c,
d, e, f,
g),
return) SDL_X11_SYM(GC, XCreateGC,
(Display * a,
Drawable b,
unsigned long c,
XGCValues * d), (a, b,
c,
d),
return)
SDL_X11_SYM(XImage *, XCreateImage,
(Display * a, Visual * b, unsigned int c, int d, int e, char *f,
unsigned int g, unsigned int h, int i, int j), (a, b, c, d, e,
f, g, h, i, j),
return) SDL_X11_SYM(Pixmap, XCreatePixmap, (Display * a,
Drawable b,
unsigned int c,
unsigned int d,
unsigned int e), (a,
b,
c,
d,
e),
return) SDL_X11_SYM(Pixmap,
XCreatePixmapFromBitmapData,
(Display * a,
Drawable b, char *c,
unsigned int d,
unsigned int e,
unsigned long f, unsigned long g, unsigned int h), (a, b, c, d, e, f, g, h), return)
SDL_X11_SYM(Window, XCreateSimpleWindow,
(Display * a, Window b, int c, int d, unsigned int e,
unsigned int f, unsigned int g, unsigned long h,
unsigned long i), (a, b, c, d, e, f, g, h, i),
return) SDL_X11_SYM(Window, XCreateWindow, (Display * a,
Window b, int c,
int d,
unsigned int e,
unsigned int f,
unsigned int g,
int h,
unsigned int i,
Visual * j,
unsigned long k,
XSetWindowAttributes
* l), (a, b, c, d,
e, f, g, h,
i, j, k, l),
return) SDL_X11_SYM(int, XDefineCursor, (Display * a, Window b, Cursor c), (a, b, c), return)
SDL_X11_SYM(int, XDeleteProperty, (Display * a, Window b, Atom c), (a, b, c),
return) SDL_X11_SYM(int, XDestroyWindow, (Display * a,
Window b), (a, b),
return) SDL_X11_SYM(char *, XDisplayName,
(_Xconst char *a), (a),
return)
SDL_X11_SYM(int, XEventsQueued, (Display * a, int b), (a, b),
return) SDL_X11_SYM(Bool, XFilterEvent, (XEvent * event,
Window w), (event, w),
return) SDL_X11_SYM(int, XFlush,
(Display * a), (a),
return)
SDL_X11_SYM(int, XFree, (void *a), (a), return) SDL_X11_SYM(int,
XFreeColormap,
(Display *
a,
Colormap
b), (a, b),
return)
SDL_X11_SYM(int, XFreeColors,
(Display * a, Colormap b, unsigned long *c, int d, unsigned long e),
(a, b, c, d, e), return) SDL_X11_SYM(int, XFreeCursor,
(Display * a, Cursor b),
(a, b), return)
SDL_X11_SYM(int, XFreeGC, (Display * a, GC b), (a, b),
return) SDL_X11_SYM(int, XFreeModifiermap,
(XModifierKeymap * a), (a),
return) SDL_X11_SYM(int, XFreePixmap,
(Display * a,
Pixmap b), (a, b),
return)
SDL_X11_SYM(int, XGetErrorDatabaseText,
(Display * a, _Xconst char *b, _Xconst char *c, _Xconst char *d,
char *e, int f), (a, b, c, d, e, f),
return) SDL_X11_SYM(XModifierKeymap *, XGetModifierMapping, (Display * a), (a), return) SDL_X11_SYM(int, XGetPointerControl,
(Display * a, int *b, int *c,
int *d), (a, b, c, d), return)
SDL_X11_SYM(int, XGetScreenSaver,
(Display * a, int *b, int *c, int *d, int *e), (a, b, c, d, e),
return) SDL_X11_SYM(XVisualInfo *, XGetVisualInfo, (Display * a,
long b,
XVisualInfo
* c,
int *d), (a,
b,
c,
d),
return) SDL_X11_SYM(XWMHints *,
XGetWMHints,
(Display * a,
Window b), (a, b),
return)
SDL_X11_SYM(Status, XGetWindowAttributes,
(Display * a, Window b, XWindowAttributes * c), (a, b, c),
return) SDL_X11_SYM(int, XGrabKeyboard, (Display * a, Window b,
Bool c, int d, int e,
Time f), (a, b, c, d,
e, f),
return) SDL_X11_SYM(int, XGrabPointer,
(Display * a, Window b,
Bool c,
unsigned int d, int e,
int f, Window g,
Cursor h, Time i), (a,
b,
c,
d,
e,
f,
g,
h,
i),
return)
SDL_X11_SYM(Status, XIconifyWindow, (Display * a, Window b, int c),
(a, b, c), return) SDL_X11_SYM(int, XInstallColormap,
(Display * a, Colormap b), (a,
b),
return) SDL_X11_SYM(KeyCode,
XKeysymToKeycode,
(Display *
a,
KeySym b),
(a, b), return)
SDL_X11_SYM(Atom, XInternAtom, (Display * a, _Xconst char *b, Bool c),
(a, b, c), return) SDL_X11_SYM(XPixmapFormatValues *,
XListPixmapFormats, (Display * a,
int *b), (a,
b),
return) SDL_X11_SYM(int,
XLookupString,
(XKeyEvent *
a, char *b,
int c,
KeySym * d,
XComposeStatus
* e), (a,
b,
c,
d,
e),
return)
SDL_X11_SYM(int, XMapRaised, (Display * a, Window b), (a, b),
return) SDL_X11_SYM(int, XMapWindow, (Display * a, Window b),
(a, b), return) SDL_X11_SYM(int,
XMaskEvent,
(Display * a,
long b,
XEvent * c),
(a, b, c), return)
SDL_X11_SYM(Status, XMatchVisualInfo,
(Display * a, int b, int c, int d, XVisualInfo * e), (a, b, c, d, e),
return) SDL_X11_SYM(int, XMissingExtension, (Display * a,
_Xconst char *b),
(a, b), return) SDL_X11_SYM(int,
XMoveResizeWindow,
(Display * a,
Window b,
int c, int d,
unsigned int
e,
unsigned int
f), (a, b, c,
d, e, f),
return)
SDL_X11_SYM(int, XMoveWindow, (Display * a, Window b, int c, int d),
(a, b, c, d), return) SDL_X11_SYM(int, XNextEvent, (Display * a,
XEvent * b),
(a, b),
return) SDL_X11_SYM(Display
*,
XOpenDisplay,
(_Xconst
char
*a),
(a), return)
SDL_X11_SYM(int, XPeekEvent, (Display * a, XEvent * b), (a, b),
return) SDL_X11_SYM(int, XPending, (Display * a), (a),
return) SDL_X11_SYM(int, XPutImage,
(Display * a,
Drawable b, GC c,
XImage * d, int e,
int f, int g, int h,
unsigned int i,
unsigned int j), (a,
b,
c,
d,
e,
f,
g,
h,
i,
j),
return)
SDL_X11_SYM(int, XQueryColors, (Display * a, Colormap b, XColor * c, int d),
(a, b, c, d), return) SDL_X11_SYM(int, XQueryKeymap,
(Display * a, char *b), (a,
b),
return) SDL_X11_SYM(Bool,
XQueryPointer,
(Display
* a,
Window
b,
Window *
c,
Window *
d,
int *e,
int *f,
int *g,
int *h,
unsigned
int *i),
(a, b, c,
d, e, f,
g, h,
i), return)
SDL_X11_SYM(int, XRaiseWindow, (Display * a, Window b), (a, b),
return) SDL_X11_SYM(int, XReparentWindow, (Display * a,
Window b, Window c,
int d, int e), (a, b,
c, d,
e),
return) SDL_X11_SYM(int, XResizeWindow,
(Display * a, Window b,
unsigned int c,
unsigned int d), (a,
b,
c,
d),
return)
SDL_X11_SYM(int, XSelectInput, (Display * a, Window b, long c), (a, b, c),
return) SDL_X11_SYM(Status, XSendEvent, (Display * a, Window b,
Bool c, long d,
XEvent * e), (a, b, c,
d, e),
return) SDL_X11_SYM(int, XSetClassHint,
(Display * a, Window b,
XClassHint * c), (a,
b,
c),
return)
SDL_X11_SYM(XErrorHandler, XSetErrorHandler, (XErrorHandler a), (a),
return) SDL_X11_SYM(XIOErrorHandler, XSetIOErrorHandler,
(XIOErrorHandler a), (a),
return) SDL_X11_SYM(int, XSetScreenSaver,
(Display * a, int b,
int c, int d, int e),
(a, b, c, d, e), return)
SDL_X11_SYM(int, XSetTransientForHint, (Display * a, Window b, Window c),
(a, b, c), return) SDL_X11_SYM(int, XSetWMHints, (Display * a,
Window b,
XWMHints * c),
(a, b, c),
return) SDL_X11_SYM(void,
XSetTextProperty,
(Display *
a,
Window b,
XTextProperty
* c,
Atom d),
(a, b, c, d),)
SDL_X11_SYM(void, XSetWMNormalHints, (Display * a, Window b, XSizeHints * c),
(a, b, c),)
SDL_X11_SYM(Status, XSetWMProtocols,
(Display * a, Window b, Atom * c, int d), (a, b, c, d), return)
SDL_X11_SYM(int, XSetWindowBackground,
(Display * a, Window b, unsigned long c), (a, b, c), return)
SDL_X11_SYM(int, XSetWindowBackgroundPixmap,
(Display * a, Window b, Pixmap c), (a, b, c), return)
SDL_X11_SYM(int, XSetWindowColormap, (Display * a, Window b, Colormap c),
(a, b, c), return)
SDL_X11_SYM(int, XStoreColors, (Display * a, Colormap b, XColor * c, int d),
(a, b, c, d), return)
SDL_X11_SYM(Status, XStringListToTextProperty,
(char **a, int b, XTextProperty * c), (a, b, c), return)
SDL_X11_SYM(int, XSync, (Display * a, Bool b), (a, b), return)
SDL_X11_SYM(int, XUngrabKeyboard, (Display * a, Time b), (a, b), return)
SDL_X11_SYM(int, XUngrabPointer, (Display * a, Time b), (a, b), return)
SDL_X11_SYM(int, XUnmapWindow, (Display * a, Window b), (a, b), return)
SDL_X11_SYM(int, XWarpPointer,
(Display * a, Window b, Window c, int d, int e, unsigned int f,
unsigned int g, int h, int i), (a, b, c, d, e, f, g, h, i),
return)
SDL_X11_SYM(VisualID, XVisualIDFromVisual, (Visual * a), (a), return)
SDL_X11_SYM(XExtDisplayInfo *, XextAddDisplay,
(XExtensionInfo * a, Display * b, char *c, XExtensionHooks * d,
int e, XPointer f), (a, b, c, d, e, f), return)
SDL_X11_SYM(XExtensionInfo *, XextCreateExtension, (void), (), return)
SDL_X11_SYM(void, XextDestroyExtension, (XExtensionInfo * a), (a),)
SDL_X11_SYM(XExtDisplayInfo *, XextFindDisplay,
(XExtensionInfo * a, Display * b), (a, b), return)
SDL_X11_SYM(int, XextRemoveDisplay, (XExtensionInfo * a, Display * b),
(a, b), return)
SDL_X11_SYM(Bool, XQueryExtension,
(Display * a, _Xconst char *b, int *c, int *d, int *e), (a, b, c,
d, e),
return)
SDL_X11_SYM(char *, XDisplayString, (Display * a), (a), return)
SDL_X11_SYM(int, XGetErrorText, (Display * a, int b, char *c, int d),
(a, b, c, d), return)
SDL_X11_SYM(void, _XEatData, (Display * a, unsigned long b), (a, b),)
SDL_X11_SYM(void, _XFlush, (Display * a), (a),)
SDL_X11_SYM(void, _XFlushGCCache, (Display * a, GC b), (a, b),)
SDL_X11_SYM(int, _XRead, (Display * a, char *b, long c), (a, b, c), return)
SDL_X11_SYM(void, _XReadPad, (Display * a, char *b, long c), (a, b, c),)
SDL_X11_SYM(void, _XSend, (Display * a, _Xconst char *b, long c), (a, b, c),)
SDL_X11_SYM(Status, _XReply, (Display * a, xReply * b, int c, Bool d),
(a, b, c, d), return)
SDL_X11_SYM(unsigned long, _XSetLastRequestRead,
(Display * a, xGenericReply * b), (a, b), return)
SDL_X11_SYM(SDL_X11_XSynchronizeRetType, XSynchronize, (Display * a, Bool b),
(a, b), return)
SDL_X11_SYM(SDL_X11_XESetWireToEventRetType, XESetWireToEvent,
(Display * a, int b, SDL_X11_XESetWireToEventRetType c), (a, b,
c),
return)
SDL_X11_SYM(SDL_X11_XESetEventToWireRetType, XESetEventToWire,
(Display * a, int b, SDL_X11_XESetEventToWireRetType c), (a, b,
c),
return)
SDL_X11_SYM(XExtensionErrorHandler, XSetExtensionErrorHandler,
(XExtensionErrorHandler a), (a), return)
#if NeedWidePrototypes
SDL_X11_SYM(KeySym, XKeycodeToKeysym, (Display * a, unsigned int b, int c),
(a, b, c), return)
#else
SDL_X11_SYM(KeySym, XKeycodeToKeysym, (Display * a, KeyCode b, int c),
(a, b, c), return)
#endif
#ifdef X_HAVE_UTF8_STRING
SDL_X11_MODULE(UTF8)
SDL_X11_SYM(int, Xutf8TextListToTextProperty,
(Display * a, char **b, int c, XICCEncodingStyle d,
XTextProperty * e), (a, b, c, d, e), return)
SDL_X11_SYM(int, Xutf8LookupString,
(XIC a, XKeyPressedEvent * b, char *c, int d, KeySym * e,
Status * f), (a, b, c, d, e, f), return)
/*SDL_X11_SYM(XIC,XCreateIC,(XIM, ...),return) !!! ARGH! */
SDL_X11_SYM(void, XDestroyIC, (XIC a), (a),)
SDL_X11_SYM(void, XSetICFocus, (XIC a), (a),)
SDL_X11_SYM(void, XUnsetICFocus, (XIC a), (a),)
SDL_X11_SYM(XIM, XOpenIM,
(Display * a, struct _XrmHashBucketRec * b, char *c, char *d),
(a, b, c, d), return)
SDL_X11_SYM(Status, XCloseIM, (XIM a), (a), return)
#endif
#ifndef NO_SHARED_MEMORY
SDL_X11_MODULE(SHM)
SDL_X11_SYM(Status, XShmAttach, (Display * a, XShmSegmentInfo * b), (a, b),
return)
SDL_X11_SYM(Status, XShmDetach, (Display * a, XShmSegmentInfo * b), (a, b),
return)
SDL_X11_SYM(Status, XShmPutImage,
(Display * a, Drawable b, GC c, XImage * d, int e, int f, int g,
int h, unsigned int i, unsigned int j, Bool k), (a, b, c, d, e,
f, g, h, i, j,
k), return)
SDL_X11_SYM(XImage *, XShmCreateImage,
(Display * a, Visual * b, unsigned int c, int d, char *e,
XShmSegmentInfo * f, unsigned int g, unsigned int h), (a, b, c,
d, e, f,
g, h),
return)
SDL_X11_SYM(Bool, XShmQueryExtension, (Display * a), (a), return)
#endif
/*
* Not required...these only exist in code in headers on some 64-bit platforms,
* and are removed via macros elsewhere, so it's safe for them to be missing.
*/
#ifdef LONG64
SDL_X11_MODULE(IO_32BIT)
SDL_X11_SYM(int, _XData32,
(Display * dpy, register long *data, unsigned len), (dpy, data,
len), return)
SDL_X11_SYM(void, _XRead32, (Display * dpy, register long *data, long len),
(dpy, data, len),)
#endif
/*
* These only show up on some variants of Unix.
*/
#if defined(__osf__)
SDL_X11_MODULE(OSF_ENTRY_POINTS)
SDL_X11_SYM(void, _SmtBufferOverflow,
(Display * dpy, register smtDisplayPtr p), (dpy, p),)
SDL_X11_SYM(void, _SmtIpError,
(Display * dpy, register smtDisplayPtr p, int i), (dpy, p, i),)
SDL_X11_SYM(int, ipAllocateData, (ChannelPtr a, IPCard b, IPDataPtr * c),
(a, b, c), return)
SDL_X11_SYM(int, ipUnallocateAndSendData, (ChannelPtr a, IPCard b), (a, b),
return)
#endif
/* Xrandr support. */
#if SDL_VIDEO_DRIVER_X11_XRANDR
SDL_X11_MODULE(XRANDR)
SDL_X11_SYM(Status, XRRQueryVersion,
(Display * dpy, int *major_versionp, int *minor_versionp), (dpy,
major_versionp,
minor_versionp),
return)
SDL_X11_SYM(XRRScreenConfiguration *, XRRGetScreenInfo,
(Display * dpy, Drawable draw), (dpy, draw), return)
SDL_X11_SYM(SizeID, XRRConfigCurrentConfiguration,
(XRRScreenConfiguration * config, Rotation * rotation), (config,
rotation),
return)
SDL_X11_SYM(XRRScreenSize *, XRRConfigSizes,
(XRRScreenConfiguration * config, int *nsizes), (config, nsizes),
return)
SDL_X11_SYM(short *, XRRConfigRates,
(XRRScreenConfiguration * config, int sizeID, int *nrates),
(config, sizeID, nrates), return)
SDL_X11_SYM(Status, XRRSetScreenConfig,
(Display * dpy, XRRScreenConfiguration * config, Drawable draw,
int size_index, Rotation rotation, Time timestamp), (dpy,
config,
draw,
size_index,
rotation,
timestamp),
return)
SDL_X11_SYM(void, XRRFreeScreenConfigInfo, (XRRScreenConfiguration * config),
(config),)
#endif
/* DPMS support */
#if SDL_VIDEO_DRIVER_X11_DPMS
SDL_X11_MODULE(DPMS)
SDL_X11_SYM(Status, DPMSQueryExtension,
(Display * dpy, int *major_versionp, int *minor_versionp), (dpy,
major_versionp,
minor_versionp),
return)
SDL_X11_SYM(Status, DPMSInfo, (Display * dpy, CARD16 * state, BOOL * onoff),
(dpy, state, onoff), return)
SDL_X11_SYM(Status, DPMSEnable, (Display * dpy), (dpy), return)
SDL_X11_SYM(Status, DPMSDisable, (Display * dpy), (dpy), return)
#endif
/* end of SDL_x11sym.h ... */
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11video.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
/* X11 based SDL video driver implementation.
Note: This implementation does not currently need X11 thread locking,
since the event thread uses a separate X connection and any
additional locking necessary is handled internally. However,
if full locking is neccessary, take a look at XInitThreads().
*/
#include <unistd.h>
#include <sys/ioctl.h>
#ifdef MTRR_SUPPORT
#include <asm/mtrr.h>
#include <sys/fcntl.h>
#endif
#include "SDL_endian.h"
#include "SDL_timer.h"
#include "SDL_thread.h"
#include "SDL_video.h"
#include "SDL_mouse.h"
#include "../SDL_sysvideo.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
#include "SDL_x11video.h"
#include "SDL_x11wm_c.h"
#include "SDL_x11mouse_c.h"
#include "SDL_x11events_c.h"
#include "SDL_x11modes_c.h"
#include "SDL_x11image_c.h"
#include "SDL_x11yuv_c.h"
#include "SDL_x11gl_c.h"
#include "SDL_x11gamma_c.h"
#include "../blank_cursor.h"
/* Initialization/Query functions */
static int X11_VideoInit(_THIS);
static SDL_Surface *X11_SetVideoMode(_THIS, SDL_Surface * current,
const SDL_DisplayMode * mode,
Uint32 flags);
static int X11_ToggleFullScreen(_THIS, int on);
static void X11_UpdateMouse(_THIS);
static int X11_SetColors(_THIS, int firstcolor, int ncolors,
SDL_Color * colors);
static int X11_SetGammaRamp(_THIS, Uint16 * ramp);
static void X11_VideoQuit(_THIS);
/* X11 driver bootstrap functions */
static int
X11_Available(void)
{
Display *display = NULL;
if (SDL_X11_LoadSymbols()) {
display = XOpenDisplay(NULL);
if (display != NULL) {
XCloseDisplay(display);
}
SDL_X11_UnloadSymbols();
}
return (display != NULL);
}
static void
X11_DeleteDevice(SDL_VideoDevice * device)
{
if (device) {
if (device->hidden) {
SDL_free(device->hidden);
}
if (device->gl_data) {
SDL_free(device->gl_data);
}
SDL_free(device);
SDL_X11_UnloadSymbols();
}
}
static SDL_VideoDevice *
X11_CreateDevice(int devindex)
{
SDL_VideoDevice *device = NULL;
if (SDL_X11_LoadSymbols()) {
/* Initialize all variables that we clean on shutdown */
device = (SDL_VideoDevice *) SDL_malloc(sizeof(SDL_VideoDevice));
if (device) {
SDL_memset(device, 0, (sizeof *device));
device->hidden = (struct SDL_PrivateVideoData *)
SDL_malloc((sizeof *device->hidden));
device->gl_data = (struct SDL_PrivateGLData *)
SDL_malloc((sizeof *device->gl_data));
}
if ((device == NULL) || (device->hidden == NULL) ||
(device->gl_data == NULL)) {
SDL_OutOfMemory();
X11_DeleteDevice(device); /* calls SDL_X11_UnloadSymbols(). */
return (0);
}
SDL_memset(device->hidden, 0, (sizeof *device->hidden));
SDL_memset(device->gl_data, 0, (sizeof *device->gl_data));
/* Set the driver flags */
device->handles_any_size = 1;
/* Set the function pointers */
device->VideoInit = X11_VideoInit;
device->SetVideoMode = X11_SetVideoMode;
device->ToggleFullScreen = X11_ToggleFullScreen;
device->UpdateMouse = X11_UpdateMouse;
#if SDL_VIDEO_DRIVER_X11_XV
device->CreateYUVOverlay = X11_CreateYUVOverlay;
#endif
device->SetColors = X11_SetColors;
device->UpdateRects = NULL;
device->VideoQuit = X11_VideoQuit;
device->AllocHWSurface = X11_AllocHWSurface;
device->CheckHWBlit = NULL;
device->FillHWRect = NULL;
device->SetHWColorKey = NULL;
device->SetHWAlpha = NULL;
device->LockHWSurface = X11_LockHWSurface;
device->UnlockHWSurface = X11_UnlockHWSurface;
device->FlipHWSurface = X11_FlipHWSurface;
device->FreeHWSurface = X11_FreeHWSurface;
device->SetGamma = X11_SetVidModeGamma;
device->GetGamma = X11_GetVidModeGamma;
device->SetGammaRamp = X11_SetGammaRamp;
device->GetGammaRamp = NULL;
#if SDL_VIDEO_OPENGL_GLX
device->GL_LoadLibrary = X11_GL_LoadLibrary;
device->GL_GetProcAddress = X11_GL_GetProcAddress;
device->GL_GetAttribute = X11_GL_GetAttribute;
device->GL_MakeCurrent = X11_GL_MakeCurrent;
device->GL_SwapBuffers = X11_GL_SwapBuffers;
#endif
device->SetCaption = X11_SetCaption;
device->SetIcon = X11_SetIcon;
device->IconifyWindow = X11_IconifyWindow;
device->GrabInput = X11_GrabInput;
device->GetWMInfo = X11_GetWMInfo;
device->FreeWMCursor = X11_FreeWMCursor;
device->CreateWMCursor = X11_CreateWMCursor;
device->ShowWMCursor = X11_ShowWMCursor;
device->WarpWMCursor = X11_WarpWMCursor;
device->CheckMouseMode = X11_CheckMouseMode;
device->InitOSKeymap = X11_InitOSKeymap;
device->PumpEvents = X11_PumpEvents;
device->free = X11_DeleteDevice;
}
return device;
}
VideoBootStrap X11_bootstrap = {
"x11", "X Window System",
X11_Available, X11_CreateDevice
};
/* Normal X11 error handler routine */
static int (*X_handler) (Display *, XErrorEvent *) = NULL;
static int
x_errhandler(Display * d, XErrorEvent * e)
{
#if SDL_VIDEO_DRIVER_X11_VIDMODE
extern int vm_error;
#endif
#if SDL_VIDEO_DRIVER_X11_DGAMOUSE
extern int dga_error;
#endif
#if SDL_VIDEO_DRIVER_X11_VIDMODE
/* VidMode errors are non-fatal. :) */
/* Are the errors offset by one from the error base?
e.g. the error base is 143, the code is 148, and the
actual error is XF86VidModeExtensionDisabled (4) ?
*/
if ((vm_error >= 0) &&
(((e->error_code == BadRequest) && (e->request_code == vm_error)) ||
((e->error_code > vm_error) &&
(e->error_code <= (vm_error + XF86VidModeNumberErrors))))) {
#ifdef X11_DEBUG
{
char errmsg[1024];
XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));
printf("VidMode error: %s\n", errmsg);
}
#endif
return (0);
}
#endif /* SDL_VIDEO_DRIVER_X11_VIDMODE */
#if SDL_VIDEO_DRIVER_X11_DGAMOUSE
/* DGA errors can be non-fatal. :) */
if ((dga_error >= 0) &&
((e->error_code > dga_error) &&
(e->error_code <= (dga_error + XF86DGANumberErrors)))) {
#ifdef X11_DEBUG
{
char errmsg[1024];
XGetErrorText(d, e->error_code, errmsg, sizeof(errmsg));
printf("DGA error: %s\n", errmsg);
}
#endif
return (0);
}
#endif /* SDL_VIDEO_DRIVER_X11_DGAMOUSE */
return (X_handler(d, e));
}
/* X11 I/O error handler routine */
static int (*XIO_handler) (Display *) = NULL;
static int
xio_errhandler(Display * d)
{
/* Ack! Lost X11 connection! */
/* We will crash if we try to clean up our display */
if (current_video->hidden->Ximage) {
SDL_VideoSurface->pixels = NULL;
}
current_video->hidden->X11_Display = NULL;
/* Continue with the standard X11 error handler */
return (XIO_handler(d));
}
static int (*Xext_handler) (Display *, _Xconst char *, _Xconst char *) = NULL;
static int
xext_errhandler(Display * d, _Xconst char *ext, _Xconst char *reason)
{
#ifdef X11_DEBUG
printf("Xext error inside SDL (may be harmless):\n");
printf(" Extension \"%s\" %s on display \"%s\".\n",
ext, reason, XDisplayString(d));
#endif
if (SDL_strcmp(reason, "missing") == 0) {
/*
* Since the query itself, elsewhere, can handle a missing extension
* and the default behaviour in Xlib is to write to stderr, which
* generates unnecessary bug reports, we just ignore these.
*/
return 0;
}
/* Everything else goes to the default handler... */
return Xext_handler(d, ext, reason);
}
/* Find out what class name we should use */
static char *
get_classname(char *classname, int maxlen)
{
char *spot;
#if defined(__LINUX__) || defined(__FREEBSD__)
char procfile[1024];
char linkfile[1024];
int linksize;
#endif
/* First allow environment variable override */
spot = SDL_getenv("SDL_VIDEO_X11_WMCLASS");
if (spot) {
SDL_strlcpy(classname, spot, maxlen);
return classname;
}
/* Next look at the application's executable name */
#if defined(__LINUX__) || defined(__FREEBSD__)
#if defined(__LINUX__)
SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/exe", getpid());
#elif defined(__FREEBSD__)
SDL_snprintf(procfile, SDL_arraysize(procfile), "/proc/%d/file",
getpid());
#else
#error Where can we find the executable name?
#endif
linksize = readlink(procfile, linkfile, sizeof(linkfile) - 1);
if (linksize > 0) {
linkfile[linksize] = '\0';
spot = SDL_strrchr(linkfile, '/');
if (spot) {
SDL_strlcpy(classname, spot + 1, maxlen);
} else {
SDL_strlcpy(classname, linkfile, maxlen);
}
return classname;
}
#endif /* __LINUX__ */
/* Finally use the default we've used forever */
SDL_strlcpy(classname, "SDL_App", maxlen);
return classname;
}
/* Create auxiliary (toplevel) windows with the current visual */
static void
create_aux_windows(_THIS)
{
int x = 0, y = 0;
char classname[1024];
XSetWindowAttributes xattr;
XWMHints *hints;
int def_vis = (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen));
/* Look up some useful Atoms */
WM_DELETE_WINDOW = XInternAtom(SDL_Display, "WM_DELETE_WINDOW", False);
/* Don't create any extra windows if we are being managed */
if (SDL_windowid) {
FSwindow = 0;
WMwindow = SDL_strtol(SDL_windowid, NULL, 0);
return;
}
if (FSwindow)
XDestroyWindow(SDL_Display, FSwindow);
#if SDL_VIDEO_DRIVER_X11_XINERAMA
if (use_xinerama) {
x = xinerama[this->current_display].x_org;
y = xinerama[this->current_display].y_org;
}
#endif
xattr.override_redirect = True;
xattr.background_pixel =
def_vis ? BlackPixel(SDL_Display, SDL_Screen) : 0;
xattr.border_pixel = 0;
xattr.colormap = SDL_XColorMap;
FSwindow = XCreateWindow(SDL_Display, SDL_Root,
x, y, 32, 32, 0,
this->hidden->depth, InputOutput, SDL_Visual,
CWOverrideRedirect | CWBackPixel | CWBorderPixel
| CWColormap, &xattr);
XSelectInput(SDL_Display, FSwindow, StructureNotifyMask);
/* Tell KDE to keep the fullscreen window on top */
{
XEvent ev;
long mask;
SDL_memset(&ev, 0, sizeof(ev));
ev.xclient.type = ClientMessage;
ev.xclient.window = SDL_Root;
ev.xclient.message_type = XInternAtom(SDL_Display,
"KWM_KEEP_ON_TOP", False);
ev.xclient.format = 32;
ev.xclient.data.l[0] = FSwindow;
ev.xclient.data.l[1] = CurrentTime;
mask = SubstructureRedirectMask;
XSendEvent(SDL_Display, SDL_Root, False, mask, &ev);
}
hints = NULL;
if (WMwindow) {
/* All window attributes must survive the recreation */
hints = XGetWMHints(SDL_Display, WMwindow);
XDestroyWindow(SDL_Display, WMwindow);
}
/* Create the window for windowed management */
/* (reusing the xattr structure above) */
WMwindow = XCreateWindow(SDL_Display, SDL_Root,
x, y, 32, 32, 0,
this->hidden->depth, InputOutput, SDL_Visual,
CWBackPixel | CWBorderPixel | CWColormap,
&xattr);
/* Set the input hints so we get keyboard input */
if (!hints) {
hints = XAllocWMHints();
hints->input = True;
hints->flags = InputHint;
}
XSetWMHints(SDL_Display, WMwindow, hints);
XFree(hints);
X11_SetCaptionNoLock(this, SDL_CurrentWindow.wm_title,
SDL_CurrentWindow.wm_icon);
XSelectInput(SDL_Display, WMwindow,
FocusChangeMask | KeyPressMask | KeyReleaseMask
| PropertyChangeMask | StructureNotifyMask |
KeymapStateMask);
/* Set the class hints so we can get an icon (AfterStep) */
get_classname(classname, sizeof(classname));
{
XClassHint *classhints;
classhints = XAllocClassHint();
if (classhints != NULL) {
classhints->res_name = classname;
classhints->res_class = classname;
XSetClassHint(SDL_Display, WMwindow, classhints);
XFree(classhints);
}
}
/* Setup the communication with the IM server */
SDL_IM = NULL;
SDL_IC = NULL;
#ifdef X_HAVE_UTF8_STRING
if (SDL_X11_HAVE_UTF8) {
SDL_IM = XOpenIM(SDL_Display, NULL, classname, classname);
if (SDL_IM == NULL) {
SDL_SetError("no input method could be opened");
} else {
SDL_IC = pXCreateIC(SDL_IM,
XNClientWindow, WMwindow,
XNFocusWindow, WMwindow,
XNInputStyle,
XIMPreeditNothing | XIMStatusNothing,
XNResourceName, classname,
XNResourceClass, classname, NULL);
if (SDL_IC == NULL) {
SDL_SetError("no input context could be created");
XCloseIM(SDL_IM);
SDL_IM = NULL;
}
}
}
#endif
/* Allow the window to be deleted by the window manager */
XSetWMProtocols(SDL_Display, WMwindow, &WM_DELETE_WINDOW, 1);
}
static int
X11_VideoInit(_THIS)
{
char *display;
int i;
SDL_DisplayMode desktop_mode;
/* Open the X11 display */
display = NULL; /* Get it from DISPLAY environment variable */
if ((SDL_strncmp(XDisplayName(display), ":", 1) == 0) ||
(SDL_strncmp(XDisplayName(display), "unix:", 5) == 0)) {
local_X11 = 1;
} else {
local_X11 = 0;
}
SDL_Display = XOpenDisplay(display);
#if defined(__osf__) && defined(SDL_VIDEO_DRIVER_X11_DYNAMIC)
/* On Tru64 if linking without -lX11, it fails and you get following message.
* Xlib: connection to ":0.0" refused by server
* Xlib: XDM authorization key matches an existing client!
*
* It succeeds if retrying 1 second later
* or if running xhost +localhost on shell.
*
*/
if (SDL_Display == NULL) {
SDL_Delay(1000);
SDL_Display = XOpenDisplay(display);
}
#endif
if (SDL_Display == NULL) {
SDL_SetError("Couldn't open X11 display");
return (-1);
}
#ifdef X11_DEBUG
XSynchronize(SDL_Display, True);
#endif
/* Create an alternate X display for graphics updates -- allows us
to do graphics updates in a separate thread from event handling.
Thread-safe X11 doesn't seem to exist.
*/
GFX_Display = XOpenDisplay(display);
if (GFX_Display == NULL) {
SDL_SetError("Couldn't open X11 display");
return (-1);
}
/* Set the normal X error handler */
X_handler = XSetErrorHandler(x_errhandler);
/* Set the error handler if we lose the X display */
XIO_handler = XSetIOErrorHandler(xio_errhandler);
/* Set the X extension error handler */
Xext_handler = XSetExtensionErrorHandler(xext_errhandler);
/* use default screen (from $DISPLAY) */
SDL_Screen = DefaultScreen(SDL_Display);
#ifndef NO_SHARED_MEMORY
/* Check for MIT shared memory extension */
use_mitshm = 0;
if (local_X11) {
use_mitshm = XShmQueryExtension(SDL_Display);
}
#endif /* NO_SHARED_MEMORY */
/* Get the available visuals */
if (X11_GetVisuals(this) < 0)
return -1;
/* Determine the default screen mode:
Use the default visual (or at least one with the same depth) */
SDL_DisplayColormap = DefaultColormap(SDL_Display, SDL_Screen);
for (i = 0; i < this->hidden->nvisuals; i++)
if (this->hidden->visuals[i].depth == DefaultDepth(SDL_Display,
SDL_Screen))
break;
if (i == this->hidden->nvisuals) {
/* default visual was useless, take the deepest one instead */
i = 0;
}
SDL_Visual = this->hidden->visuals[i].visual;
if (SDL_Visual == DefaultVisual(SDL_Display, SDL_Screen)) {
SDL_XColorMap = SDL_DisplayColormap;
} else {
SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
SDL_Visual, AllocNone);
}
desktop_mode.format =
X11_VisualToFormat(this->hidden->visuals[i].visual,
this->hidden->visuals[i].depth,
this->hidden->visuals[i].bpp);
desktop_mode.w = DisplayWidth(SDL_Display, SDL_Screen);
desktop_mode.h = DisplayHeight(SDL_Display, SDL_Screen);
desktop_mode.refresh_rate = 0;
SDL_AddVideoDisplay(&desktop_mode);
/* Get the available video modes */
if (X11_GetVideoModes(this) < 0)
return -1;
X11_SaveVidModeGamma(this);
/* Save DPMS and screensaver settings */
X11_SaveScreenSaver(SDL_Display, &screensaver_timeout, &dpms_enabled);
X11_DisableScreenSaver(SDL_Display);
/* See if we have been passed a window to use */
SDL_windowid = SDL_getenv("SDL_WINDOWID");
/* Create the fullscreen and managed windows */
create_aux_windows(this);
/* Create the blank cursor */
SDL_BlankCursor = this->CreateWMCursor(this, blank_cdata, blank_cmask,
BLANK_CWIDTH, BLANK_CHEIGHT,
BLANK_CHOTX, BLANK_CHOTY);
/* Fill in some window manager capabilities */
this->info.wm_available = 1;
/* We're done! */
XFlush(SDL_Display);
return (0);
}
static void
X11_DestroyWindow(_THIS, SDL_Surface * screen)
{
/* Clean up OpenGL */
if (screen) {
screen->flags &= ~SDL_INTERNALOPENGL;
}
X11_GL_Shutdown(this);
if (!SDL_windowid) {
/* Hide the managed window */
if (WMwindow) {
XUnmapWindow(SDL_Display, WMwindow);
}
if (screen && (screen->flags & SDL_FULLSCREEN)) {
screen->flags &= ~SDL_FULLSCREEN;
X11_LeaveFullScreen(this);
}
/* Destroy the output window */
if (SDL_Window) {
XDestroyWindow(SDL_Display, SDL_Window);
}
/* Free the colormap entries */
if (SDL_XPixels) {
int numcolors;
unsigned long pixel;
numcolors = SDL_Visual->map_entries;
for (pixel = 0; pixel < numcolors; ++pixel) {
while (SDL_XPixels[pixel] > 0) {
XFreeColors(GFX_Display,
SDL_DisplayColormap, &pixel, 1, 0);
--SDL_XPixels[pixel];
}
}
SDL_free(SDL_XPixels);
SDL_XPixels = NULL;
}
/* Free the graphics context */
if (SDL_GC) {
XFreeGC(SDL_Display, SDL_GC);
SDL_GC = 0;
}
}
}
static SDL_bool
X11_WindowPosition(_THIS, int *x, int *y, int w, int h)
{
const char *window = SDL_getenv("SDL_VIDEO_WINDOW_POS");
const char *center = SDL_getenv("SDL_VIDEO_CENTERED");
if (window) {
if (SDL_sscanf(window, "%d,%d", x, y) == 2) {
return SDL_TRUE;
}
if (SDL_strcmp(window, "center") == 0) {
center = window;
}
}
if (center) {
*x = (DisplayWidth(SDL_Display, SDL_Screen) - w) / 2;
*y = (DisplayHeight(SDL_Display, SDL_Screen) - h) / 2;
return SDL_TRUE;
}
return SDL_FALSE;
}
static void
X11_SetSizeHints(_THIS, int w, int h, Uint32 flags)
{
XSizeHints *hints;
hints = XAllocSizeHints();
if (hints) {
if (flags & SDL_RESIZABLE) {
hints->min_width = 32;
hints->min_height = 32;
hints->max_height = 4096;
hints->max_width = 4096;
} else {
hints->min_width = hints->max_width = w;
hints->min_height = hints->max_height = h;
}
hints->flags = PMaxSize | PMinSize;
if (flags & SDL_FULLSCREEN) {
hints->x = 0;
hints->y = 0;
hints->flags |= USPosition;
} else
/* Center it, if desired */
if (X11_WindowPosition(this, &hints->x, &hints->y, w, h)) {
hints->flags |= USPosition;
XMoveWindow(SDL_Display, WMwindow, hints->x, hints->y);
/* Flush the resize event so we don't catch it later */
XSync(SDL_Display, True);
}
XSetWMNormalHints(SDL_Display, WMwindow, hints);
XFree(hints);
}
/* Respect the window caption style */
if (flags & SDL_NOFRAME) {
SDL_bool set;
Atom WM_HINTS;
/* We haven't modified the window manager hints yet */
set = SDL_FALSE;
/* First try to set MWM hints */
WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True);
if (WM_HINTS != None) {
/* Hints used by Motif compliant window managers */
struct
{
unsigned long flags;
unsigned long functions;
unsigned long decorations;
long input_mode;
unsigned long status;
} MWMHints = {
(1L << 1), 0, 0, 0, 0};
XChangeProperty(SDL_Display, WMwindow,
WM_HINTS, WM_HINTS, 32,
PropModeReplace,
(unsigned char *) &MWMHints,
sizeof(MWMHints) / sizeof(long));
set = SDL_TRUE;
}
/* Now try to set KWM hints */
WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True);
if (WM_HINTS != None) {
long KWMHints = 0;
XChangeProperty(SDL_Display, WMwindow,
WM_HINTS, WM_HINTS, 32,
PropModeReplace,
(unsigned char *) &KWMHints,
sizeof(KWMHints) / sizeof(long));
set = SDL_TRUE;
}
/* Now try to set GNOME hints */
WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True);
if (WM_HINTS != None) {
long GNOMEHints = 0;
XChangeProperty(SDL_Display, WMwindow,
WM_HINTS, WM_HINTS, 32,
PropModeReplace,
(unsigned char *) &GNOMEHints,
sizeof(GNOMEHints) / sizeof(long));
set = SDL_TRUE;
}
/* Finally set the transient hints if necessary */
if (!set) {
XSetTransientForHint(SDL_Display, WMwindow, SDL_Root);
}
} else {
SDL_bool set;
Atom WM_HINTS;
/* We haven't modified the window manager hints yet */
set = SDL_FALSE;
/* First try to unset MWM hints */
WM_HINTS = XInternAtom(SDL_Display, "_MOTIF_WM_HINTS", True);
if (WM_HINTS != None) {
XDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
set = SDL_TRUE;
}
/* Now try to unset KWM hints */
WM_HINTS = XInternAtom(SDL_Display, "KWM_WIN_DECORATION", True);
if (WM_HINTS != None) {
XDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
set = SDL_TRUE;
}
/* Now try to unset GNOME hints */
WM_HINTS = XInternAtom(SDL_Display, "_WIN_HINTS", True);
if (WM_HINTS != None) {
XDeleteProperty(SDL_Display, WMwindow, WM_HINTS);
set = SDL_TRUE;
}
/* Finally unset the transient hints if necessary */
if (!set) {
/* NOTE: Does this work? */
XSetTransientForHint(SDL_Display, WMwindow, None);
}
}
}
static int
X11_CreateWindow(_THIS, SDL_Surface * screen,
const SDL_DisplayMode * mode, Uint32 flags)
{
int i, depth;
Visual *vis;
int vis_change;
int bpp;
Uint32 Rmask, Gmask, Bmask, Amask;
SDL_PixelFormatEnumToMasks(mode->format, &bpp, &Rmask, &Gmask, &Bmask,
&Amask);
/* If a window is already present, destroy it and start fresh */
if (SDL_Window) {
X11_DestroyWindow(this, screen);
switch_waiting = 0; /* Prevent jump back to now-meaningless state. */
}
/* See if we have been given a window id */
if (SDL_windowid) {
SDL_Window = SDL_strtol(SDL_windowid, NULL, 0);
} else {
SDL_Window = 0;
}
/* find out which visual we are going to use */
if (flags & SDL_INTERNALOPENGL) {
XVisualInfo *vi;
vi = X11_GL_GetVisual(this);
if (!vi) {
return -1;
}
vis = vi->visual;
depth = vi->depth;
} else if (SDL_windowid) {
XWindowAttributes a;
XGetWindowAttributes(SDL_Display, SDL_Window, &a);
vis = a.visual;
depth = a.depth;
} else {
for (i = 0; i < this->hidden->nvisuals; i++) {
if (this->hidden->visuals[i].bpp == bpp &&
this->hidden->visuals[i].visual->red_mask == Rmask &&
this->hidden->visuals[i].visual->green_mask == Gmask &&
this->hidden->visuals[i].visual->blue_mask == Bmask)
break;
}
if (i == this->hidden->nvisuals) {
SDL_SetError("No matching visual for requested depth");
return -1; /* should never happen */
}
vis = this->hidden->visuals[i].visual;
depth = this->hidden->visuals[i].depth;
}
#ifdef X11_DEBUG
printf("Choosing %s visual at %d bpp - %d colormap entries\n",
vis->class == PseudoColor ? "PseudoColor" : (vis->class ==
TrueColor ?
"TrueColor" : (vis->
class
==
DirectColor
?
"DirectColor"
:
"Unknown")),
depth, vis->map_entries);
#endif
vis_change = (vis != SDL_Visual);
SDL_Visual = vis;
this->hidden->depth = depth;
/* Allocate the new pixel format for this video mode */
if (!SDL_ReallocFormat(screen, bpp, Rmask, Gmask, Bmask, Amask)) {
return -1;
}
/* Create the appropriate colormap */
if (SDL_XColorMap != SDL_DisplayColormap) {
XFreeColormap(SDL_Display, SDL_XColorMap);
}
if (SDL_Visual->class == PseudoColor) {
int ncolors;
/* Allocate the pixel flags */
ncolors = SDL_Visual->map_entries;
SDL_XPixels = SDL_malloc(ncolors * sizeof(int));
if (SDL_XPixels == NULL) {
SDL_OutOfMemory();
return -1;
}
SDL_memset(SDL_XPixels, 0, ncolors * sizeof(*SDL_XPixels));
/* always allocate a private colormap on non-default visuals */
if (SDL_Visual != DefaultVisual(SDL_Display, SDL_Screen)) {
flags |= SDL_HWPALETTE;
}
if (flags & SDL_HWPALETTE) {
screen->flags |= SDL_HWPALETTE;
SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
SDL_Visual, AllocAll);
} else {
SDL_XColorMap = SDL_DisplayColormap;
}
} else if (SDL_Visual->class == DirectColor) {
/* Create a colormap which we can manipulate for gamma */
SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
SDL_Visual, AllocAll);
XSync(SDL_Display, False);
/* Initialize the colormap to the identity mapping */
SDL_GetGammaRamp(0, 0, 0);
SDL_VideoSurface = screen;
X11_SetGammaRamp(this, SDL_CurrentWindow.gamma);
SDL_VideoSurface = NULL;
} else {
/* Create a read-only colormap for our window */
SDL_XColorMap = XCreateColormap(SDL_Display, SDL_Root,
SDL_Visual, AllocNone);
}
/* Recreate the auxiliary windows, if needed (required for GL) */
if (vis_change)
create_aux_windows(this);
if (screen->flags & SDL_HWPALETTE) {
/* Since the full-screen window might have got a nonzero background
colour (0 is white on some displays), we should reset the
background to 0 here since that is what the user expects
with a private colormap */
XSetWindowBackground(SDL_Display, FSwindow, 0);
XClearWindow(SDL_Display, FSwindow);
}
/* resize the (possibly new) window manager window */
if (!SDL_windowid) {
X11_SetSizeHints(this, mode->w, mode->h, flags);
window_w = mode->w;
window_h = mode->h;
XResizeWindow(SDL_Display, WMwindow, mode->w, mode->h);
}
/* Create (or use) the X11 display window */
if (!SDL_windowid) {
if (flags & SDL_INTERNALOPENGL) {
if (X11_GL_CreateWindow(this, mode->w, mode->h) < 0) {
return (-1);
}
} else {
XSetWindowAttributes swa;
swa.background_pixel = 0;
swa.border_pixel = 0;
swa.colormap = SDL_XColorMap;
SDL_Window = XCreateWindow(SDL_Display, WMwindow,
0, 0, mode->w, mode->h, 0, depth,
InputOutput, SDL_Visual,
CWBackPixel | CWBorderPixel
| CWColormap, &swa);
}
/* Only manage our input if we own the window */
XSelectInput(SDL_Display, SDL_Window,
(EnterWindowMask | LeaveWindowMask
| ButtonPressMask | ButtonReleaseMask
| PointerMotionMask | ExposureMask));
}
/* Create the graphics context here, once we have a window */
if (flags & SDL_INTERNALOPENGL) {
if (X11_GL_CreateContext(this) < 0) {
return (-1);
} else {
screen->flags |= SDL_INTERNALOPENGL;
}
} else {
XGCValues gcv;
gcv.graphics_exposures = False;
SDL_GC = XCreateGC(SDL_Display, SDL_Window,
GCGraphicsExposures, &gcv);
if (!SDL_GC) {
SDL_SetError("Couldn't create graphics context");
return (-1);
}
}
/* Set our colormaps when not setting a GL mode */
if (!(flags & SDL_INTERNALOPENGL)) {
XSetWindowColormap(SDL_Display, SDL_Window, SDL_XColorMap);
if (!SDL_windowid) {
XSetWindowColormap(SDL_Display, FSwindow, SDL_XColorMap);
XSetWindowColormap(SDL_Display, WMwindow, SDL_XColorMap);
}
}
#if 0 /* This is an experiment - are the graphics faster now? - nope. */
if (SDL_getenv("SDL_VIDEO_X11_BACKINGSTORE"))
#endif
/* Cache the window in the server, when possible */
{
Screen *xscreen;
XSetWindowAttributes a;
xscreen = ScreenOfDisplay(SDL_Display, SDL_Screen);
a.backing_store = DoesBackingStore(xscreen);
if (a.backing_store != NotUseful) {
XChangeWindowAttributes(SDL_Display, SDL_Window,
CWBackingStore, &a);
}
}
/* Update the internal keyboard state */
X11_SetKeyboardState(SDL_Display, NULL);
/* When the window is first mapped, ignore non-modifier keys */
{
Uint8 *keys = SDL_GetKeyState(NULL);
for (i = 0; i < SDLK_LAST; ++i) {
switch (i) {
case SDLK_NUMLOCK:
case SDLK_CAPSLOCK:
case SDLK_LCTRL:
case SDLK_RCTRL:
case SDLK_LSHIFT:
case SDLK_RSHIFT:
case SDLK_LALT:
case SDLK_RALT:
case SDLK_LMETA:
case SDLK_RMETA:
case SDLK_MODE:
break;
default:
keys[i] = SDL_RELEASED;
break;
}
}
}
/* Map them both and go fullscreen, if requested */
if (!SDL_windowid) {
XMapWindow(SDL_Display, SDL_Window);
XMapWindow(SDL_Display, WMwindow);
X11_WaitMapped(this, WMwindow);
if (flags & SDL_FULLSCREEN) {
screen->flags |= SDL_FULLSCREEN;
X11_EnterFullScreen(this);
} else {
screen->flags &= ~SDL_FULLSCREEN;
}
}
return (0);
}
static int
X11_ResizeWindow(_THIS, SDL_Surface * screen, int w, int h, Uint32 flags)
{
if (!SDL_windowid) {
/* Resize the window manager window */
X11_SetSizeHints(this, w, h, flags);
window_w = w;
window_h = h;
XResizeWindow(SDL_Display, WMwindow, w, h);
/* Resize the fullscreen and display windows */
if (flags & SDL_FULLSCREEN) {
if (screen->flags & SDL_FULLSCREEN) {
X11_ResizeFullScreen(this);
} else {
screen->flags |= SDL_FULLSCREEN;
X11_EnterFullScreen(this);
}
} else {
if (screen->flags & SDL_FULLSCREEN) {
screen->flags &= ~SDL_FULLSCREEN;
X11_LeaveFullScreen(this);
}
}
XResizeWindow(SDL_Display, SDL_Window, w, h);
}
return (0);
}
SDL_Surface *
X11_SetVideoMode(_THIS, SDL_Surface * current,
const SDL_DisplayMode * mode, Uint32 flags)
{
Uint32 saved_flags;
/* Lock the event thread, in multi-threading environments */
SDL_Lock_EventThread();
/* Check the combination of flags we were passed */
if (flags & SDL_FULLSCREEN) {
/* Clear fullscreen flag if not supported */
if (SDL_windowid) {
flags &= ~SDL_FULLSCREEN;
}
}
/* Flush any delayed updates */
XSync(GFX_Display, False);
/* Set up the X11 window */
saved_flags = current->flags;
if ((SDL_Window)
&& ((saved_flags & SDL_INTERNALOPENGL) ==
(flags & SDL_INTERNALOPENGL))
&& (mode->format == SDL_CurrentDisplay.current_mode.format)
&& ((saved_flags & SDL_NOFRAME) == (flags & SDL_NOFRAME))) {
if (X11_ResizeWindow(this, current, mode->w, mode->h, flags) < 0) {
current = NULL;
goto done;
}
} else {
if (X11_CreateWindow(this, current, mode, flags) < 0) {
current = NULL;
goto done;
}
}
/* Set up the new mode framebuffer */
if (((current->w != mode->w) || (current->h != mode->h)) ||
((saved_flags & SDL_INTERNALOPENGL) != (flags & SDL_INTERNALOPENGL)))
{
current->w = mode->w;
current->h = mode->h;
current->pitch = SDL_CalculatePitch(current);
X11_ResizeImage(this, current, flags);
}
current->flags |= (flags & (SDL_RESIZABLE | SDL_NOFRAME));
done:
/* Release the event thread */
XSync(SDL_Display, False);
SDL_Unlock_EventThread();
/* We're done! */
return (current);
}
static int
X11_ToggleFullScreen(_THIS, int on)
{
Uint32 event_thread;
/* Don't switch if we don't own the window */
if (SDL_windowid) {
return (0);
}
/* Don't lock if we are the event thread */
event_thread = SDL_EventThreadID();
if (event_thread && (SDL_ThreadID() == event_thread)) {
event_thread = 0;
}
if (event_thread) {
SDL_Lock_EventThread();
}
if (on) {
SDL_VideoSurface->flags |= SDL_FULLSCREEN;
X11_EnterFullScreen(this);
} else {
SDL_VideoSurface->flags &= ~SDL_FULLSCREEN;
X11_LeaveFullScreen(this);
}
X11_RefreshDisplay(this);
if (event_thread) {
SDL_Unlock_EventThread();
}
SDL_ResetKeyboard();
return (1);
}
/* Update the current mouse state and position */
static void
X11_UpdateMouse(_THIS)
{
Window u1;
int u2;
Window current_win;
int x, y;
unsigned int mask;
/* Lock the event thread, in multi-threading environments */
SDL_Lock_EventThread();
if (XQueryPointer(SDL_Display, SDL_Window, &u1, &current_win,
&u2, &u2, &x, &y, &mask)) {
if ((x >= 0) && (x < SDL_VideoSurface->w) &&
(y >= 0) && (y < SDL_VideoSurface->h)) {
SDL_PrivateAppActive(1, SDL_APPMOUSEFOCUS);
SDL_PrivateMouseMotion(0, 0, x, y);
} else {
SDL_PrivateAppActive(0, SDL_APPMOUSEFOCUS);
}
}
SDL_Unlock_EventThread();
}
/* simple colour distance metric. Supposed to be better than a plain
Euclidian distance anyway. */
#define COLOUR_FACTOR 3
#define LIGHT_FACTOR 1
#define COLOUR_DIST(r1, g1, b1, r2, g2, b2) \
(COLOUR_FACTOR * (abs(r1 - r2) + abs(g1 - g2) + abs(b1 - b2)) \
+ LIGHT_FACTOR * abs(r1 + g1 + b1 - (r2 + g2 + b2)))
static void
allocate_nearest(_THIS, SDL_Color * colors, SDL_Color * want, int nwant)
{
/*
* There is no way to know which ones to choose from, so we retrieve
* the entire colormap and try the nearest possible, until we find one
* that is shared.
*/
XColor all[256];
int i;
for (i = 0; i < 256; i++)
all[i].pixel = i;
/*
* XQueryColors sets the flags in the XColor struct, so we use
* that to keep track of which colours are available
*/
XQueryColors(GFX_Display, SDL_XColorMap, all, 256);
for (i = 0; i < nwant; i++) {
XColor *c;
int j;
int best = 0;
int mindist = 0x7fffffff;
int ri = want[i].r;
int gi = want[i].g;
int bi = want[i].b;
for (j = 0; j < 256; j++) {
int rj, gj, bj, d2;
if (!all[j].flags)
continue; /* unavailable colour cell */
rj = all[j].red >> 8;
gj = all[j].green >> 8;
bj = all[j].blue >> 8;
d2 = COLOUR_DIST(ri, gi, bi, rj, gj, bj);
if (d2 < mindist) {
mindist = d2;
best = j;
}
}
if (SDL_XPixels[best])
continue; /* already allocated, waste no more time */
c = all + best;
if (XAllocColor(GFX_Display, SDL_XColorMap, c)) {
/* got it */
colors[c->pixel].r = c->red >> 8;
colors[c->pixel].g = c->green >> 8;
colors[c->pixel].b = c->blue >> 8;
++SDL_XPixels[c->pixel];
} else {
/*
* The colour couldn't be allocated, probably being
* owned as a r/w cell by another client. Flag it as
* unavailable and try again. The termination of the
* loop is guaranteed since at least black and white
* are always there.
*/
c->flags = 0;
i--;
}
}
}
int
X11_SetColors(_THIS, int firstcolor, int ncolors, SDL_Color * colors)
{
int nrej = 0;
/* Check to make sure we have a colormap allocated */
if (SDL_XPixels == NULL) {
return (0);
}
if ((SDL_VideoSurface->flags & SDL_HWPALETTE) == SDL_HWPALETTE) {
/* private writable colormap: just set the colours we need */
XColor *xcmap;
int i;
xcmap = SDL_stack_alloc(XColor, ncolors);
if (xcmap == NULL)
return 0;
for (i = 0; i < ncolors; ++i) {
xcmap[i].pixel = i + firstcolor;
xcmap[i].red = (colors[i].r << 8) | colors[i].r;
xcmap[i].green = (colors[i].g << 8) | colors[i].g;
xcmap[i].blue = (colors[i].b << 8) | colors[i].b;
xcmap[i].flags = (DoRed | DoGreen | DoBlue);
}
XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors);
XSync(GFX_Display, False);
SDL_stack_free(xcmap);
} else {
/*
* Shared colormap: We only allocate read-only cells, which
* increases the likelyhood of colour sharing with other
* clients. The pixel values will almost certainly be
* different from the requested ones, so the user has to
* walk the colormap and see which index got what colour.
*
* We can work directly with the logical palette since it
* has already been set when we get here.
*/
SDL_Color *want, *reject;
unsigned long *freelist;
int i;
int nfree = 0;
int nc = SDL_VideoSurface->format->palette->ncolors;
colors = SDL_VideoSurface->format->palette->colors;
freelist = SDL_stack_alloc(unsigned long, nc);
/* make sure multiple allocations of the same cell are freed */
for (i = 0; i < ncolors; i++) {
int pixel = firstcolor + i;
while (SDL_XPixels[pixel]) {
freelist[nfree++] = pixel;
--SDL_XPixels[pixel];
}
}
XFreeColors(GFX_Display, SDL_XColorMap, freelist, nfree, 0);
SDL_stack_free(freelist);
want = SDL_stack_alloc(SDL_Color, ncolors);
reject = SDL_stack_alloc(SDL_Color, ncolors);
SDL_memcpy(want, colors + firstcolor, ncolors * sizeof(SDL_Color));
/* make sure the user isn't fooled by her own wishes
(black is safe, always available in the default colormap) */
SDL_memset(colors + firstcolor, 0, ncolors * sizeof(SDL_Color));
/* now try to allocate the colours */
for (i = 0; i < ncolors; i++) {
XColor col;
col.red = want[i].r << 8;
col.green = want[i].g << 8;
col.blue = want[i].b << 8;
col.flags = DoRed | DoGreen | DoBlue;
if (XAllocColor(GFX_Display, SDL_XColorMap, &col)) {
/* We got the colour, or at least the nearest
the hardware could get. */
colors[col.pixel].r = col.red >> 8;
colors[col.pixel].g = col.green >> 8;
colors[col.pixel].b = col.blue >> 8;
++SDL_XPixels[col.pixel];
} else {
/*
* no more free cells, add it to the list
* of rejected colours
*/
reject[nrej++] = want[i];
}
}
if (nrej)
allocate_nearest(this, colors, reject, nrej);
SDL_stack_free(reject);
SDL_stack_free(want);
}
return nrej == 0;
}
int
X11_SetGammaRamp(_THIS, Uint16 * ramp)
{
int i, ncolors;
XColor xcmap[256];
/* See if actually setting the gamma is supported */
if (SDL_Visual->class != DirectColor) {
SDL_SetError("Gamma correction not supported on this visual");
return (-1);
}
/* Calculate the appropriate palette for the given gamma ramp */
ncolors = SDL_Visual->map_entries;
for (i = 0; i < ncolors; ++i) {
Uint8 c = (256 * i / ncolors);
xcmap[i].pixel = SDL_MapRGB(SDL_VideoSurface->format, c, c, c);
xcmap[i].red = ramp[0 * 256 + c];
xcmap[i].green = ramp[1 * 256 + c];
xcmap[i].blue = ramp[2 * 256 + c];
xcmap[i].flags = (DoRed | DoGreen | DoBlue);
}
XStoreColors(GFX_Display, SDL_XColorMap, xcmap, ncolors);
XSync(GFX_Display, False);
return (0);
}
/* Note: If we are terminated, this could be called in the middle of
another SDL video routine -- notably UpdateRects.
*/
void
X11_VideoQuit(_THIS)
{
/* Shutdown everything that's still up */
/* The event thread should be done, so we can touch SDL_Display */
if (SDL_Display != NULL) {
/* Flush any delayed updates */
XSync(GFX_Display, False);
/* Close the connection with the IM server */
#ifdef X_HAVE_UTF8_STRING
if (SDL_IC != NULL) {
XDestroyIC(SDL_IC);
SDL_IC = NULL;
}
if (SDL_IM != NULL) {
XCloseIM(SDL_IM);
SDL_IM = NULL;
}
#endif
/* Start shutting down the windows */
X11_DestroyImage(this, SDL_VideoSurface);
X11_DestroyWindow(this, SDL_VideoSurface);
X11_FreeVideoModes(this);
if (SDL_XColorMap != SDL_DisplayColormap) {
XFreeColormap(SDL_Display, SDL_XColorMap);
}
if (SDL_iconcolors) {
unsigned long pixel;
Colormap dcmap = DefaultColormap(SDL_Display,
SDL_Screen);
for (pixel = 0; pixel < 256; ++pixel) {
while (SDL_iconcolors[pixel] > 0) {
XFreeColors(GFX_Display, dcmap, &pixel, 1, 0);
--SDL_iconcolors[pixel];
}
}
SDL_free(SDL_iconcolors);
SDL_iconcolors = NULL;
}
if (xinerama) {
XFree(xinerama);
}
/* Restore gamma settings if they've changed */
if (SDL_GetAppState() & SDL_APPACTIVE) {
X11_SwapVidModeGamma(this);
}
/* Restore DPMS and screensaver settings */
X11_RestoreScreenSaver(SDL_Display, screensaver_timeout,
dpms_enabled);
/* Free that blank cursor */
if (SDL_BlankCursor != NULL) {
this->FreeWMCursor(this, SDL_BlankCursor);
SDL_BlankCursor = NULL;
}
/* Close the X11 graphics connection */
if (GFX_Display != NULL) {
XCloseDisplay(GFX_Display);
GFX_Display = NULL;
}
/* Close the X11 display connection */
XCloseDisplay(SDL_Display);
SDL_Display = NULL;
/* Reset the X11 error handlers */
if (XIO_handler) {
XSetIOErrorHandler(XIO_handler);
}
if (X_handler) {
XSetErrorHandler(X_handler);
}
/* Unload GL library after X11 shuts down */
X11_GL_UnloadLibrary(this);
}
if (SDL_VideoSurface && (SDL_VideoSurface->flags & SDL_HWSURFACE)) {
/* Direct screen access, no memory buffer */
SDL_VideoSurface->pixels = NULL;
}
}
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11video.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#ifndef _SDL_x11video_h
#define _SDL_x11video_h
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/Xatom.h>
#include "SDL_mouse.h"
#include "../SDL_sysvideo.h"
#if SDL_VIDEO_DRIVER_X11_DGAMOUSE
#include "../Xext/extensions/xf86dga.h"
#endif
#if SDL_VIDEO_DRIVER_X11_XINERAMA
#include "../Xext/extensions/Xinerama.h"
#endif
#if SDL_VIDEO_DRIVER_X11_XRANDR
#include <X11/extensions/Xrandr.h>
#endif
#if SDL_VIDEO_DRIVER_X11_VIDMODE
#include "../Xext/extensions/xf86vmode.h"
#endif
#if SDL_VIDEO_DRIVER_X11_XME
#include "../Xext/extensions/xme.h"
#endif
#if SDL_VIDEO_DRIVER_X11_DPMS
#include <X11/extensions/dpms.h>
#endif
#include "SDL_x11dyn.h"
/* Hidden "this" pointer for the video functions */
#define _THIS SDL_VideoDevice *this
/* Private display data */
struct SDL_PrivateVideoData
{
int local_X11; /* Flag: true if local display */
Display *X11_Display; /* Used for events and window management */
Display *GFX_Display; /* Used for graphics and colormap stuff */
Visual *SDL_Visual; /* The visual used by our window */
Window WMwindow; /* Input window, managed by window manager */
Window FSwindow; /* Fullscreen window, completely unmanaged */
Window SDL_Window; /* Shared by both displays (no X security?) */
Atom WM_DELETE_WINDOW; /* "close-window" protocol atom */
WMcursor *BlankCursor; /* The invisible cursor */
XIM X11_IM; /* Used to communicate with the input method (IM) server */
XIC X11_IC; /* Used for retaining the state, properties, and semantics of communication with the input method (IM) server */
char *SDL_windowid; /* Flag: true if we have been passed a window */
/* Direct Graphics Access extension information */
int using_dga;
#ifndef NO_SHARED_MEMORY
/* MIT shared memory extension information */
int use_mitshm;
XShmSegmentInfo shminfo;
#endif
/* The variables used for displaying graphics */
XImage *Ximage; /* The X image for our window */
GC gc; /* The graphic context for drawing */
/* The current width and height of the fullscreen mode */
int window_w;
int window_h;
/* Support for internal mouse warping */
struct
{
int x;
int y;
} mouse_last;
struct
{
int numerator;
int denominator;
int threshold;
} mouse_accel;
int mouse_relative;
/* available visuals of interest to us, sorted deepest first */
struct
{
Visual *visual;
int depth; /* number of significant bits/pixel */
int bpp; /* pixel quantum in bits */
} visuals[2 * 5]; /* at most 2 entries for 8, 15, 16, 24, 32 */
int nvisuals;
Visual *vis; /* current visual in use */
int depth; /* current visual depth (not bpp) */
/* Variables used by the X11 video mode code */
#if SDL_VIDEO_DRIVER_X11_XINERAMA
SDL_NAME(XineramaScreenInfo) * xinerama;
#endif
#if SDL_VIDEO_DRIVER_X11_XRANDR
XRRScreenConfiguration *screen_config;
int saved_size_id;
Rotation saved_rotation;
#endif
#if SDL_VIDEO_DRIVER_X11_VIDMODE
SDL_NAME(XF86VidModeModeInfo) saved_mode;
struct
{
int x, y;
} saved_view;
#endif
#if SDL_VIDEO_DRIVER_X11_XME /* XiG XME fullscreen */
XiGMiscResolutionInfo saved_res;
#endif
int use_xinerama;
int use_xrandr;
int use_vidmode;
int use_xme;
int currently_fullscreen;
/* Automatic mode switching support (entering/leaving fullscreen) */
Uint32 switch_waiting;
Uint32 switch_time;
/* Prevent too many XSync() calls */
int blit_queued;
/* Colormap handling */
Colormap DisplayColormap; /* The default display colormap */
Colormap XColorMap; /* The current window colormap */
int *XPixels; /* pixels value allocation counts */
float gamma_saved[3]; /* Saved gamma values for VidMode gamma */
int gamma_changed; /* flag: has VidMode gamma been modified? */
short *iconcolors; /* List of colors used by the icon */
/* Screensaver settings */
int screensaver_timeout;
BOOL dpms_enabled;
};
/* Old variable names */
#define local_X11 (this->hidden->local_X11)
#define SDL_Display (this->hidden->X11_Display)
#define GFX_Display (this->hidden->GFX_Display)
#define SDL_Screen DefaultScreen(this->hidden->X11_Display)
#define SDL_Visual (this->hidden->vis)
#define SDL_Root RootWindow(SDL_Display, SDL_Screen)
#define WMwindow (this->hidden->WMwindow)
#define FSwindow (this->hidden->FSwindow)
#define SDL_Window (this->hidden->SDL_Window)
#define WM_DELETE_WINDOW (this->hidden->WM_DELETE_WINDOW)
#define SDL_BlankCursor (this->hidden->BlankCursor)
#define SDL_IM (this->hidden->X11_IM)
#define SDL_IC (this->hidden->X11_IC)
#define SDL_windowid (this->hidden->SDL_windowid)
#define using_dga (this->hidden->using_dga)
#define use_mitshm (this->hidden->use_mitshm)
#define shminfo (this->hidden->shminfo)
#define SDL_Ximage (this->hidden->Ximage)
#define SDL_GC (this->hidden->gc)
#define window_w (this->hidden->window_w)
#define window_h (this->hidden->window_h)
#define mouse_last (this->hidden->mouse_last)
#define mouse_accel (this->hidden->mouse_accel)
#define mouse_relative (this->hidden->mouse_relative)
#define SDL_modelist (this->hidden->modelist)
#define xinerama (this->hidden->xinerama)
#define saved_mode (this->hidden->saved_mode)
#define saved_view (this->hidden->saved_view)
#define saved_res (this->hidden->saved_res)
#define screen_config (this->hidden->screen_config)
#define saved_size_id (this->hidden->saved_size_id)
#define saved_rotation (this->hidden->saved_rotation)
#define use_xinerama (this->hidden->use_xinerama)
#define use_vidmode (this->hidden->use_vidmode)
#define use_xrandr (this->hidden->use_xrandr)
#define use_xme (this->hidden->use_xme)
#define currently_fullscreen (this->hidden->currently_fullscreen)
#define switch_waiting (this->hidden->switch_waiting)
#define switch_time (this->hidden->switch_time)
#define blit_queued (this->hidden->blit_queued)
#define SDL_DisplayColormap (this->hidden->DisplayColormap)
#define SDL_PrivateColormap (this->hidden->PrivateColormap)
#define SDL_XColorMap (this->hidden->XColorMap)
#define SDL_XPixels (this->hidden->XPixels)
#define gamma_saved (this->hidden->gamma_saved)
#define gamma_changed (this->hidden->gamma_changed)
#define SDL_iconcolors (this->hidden->iconcolors)
#define screensaver_timeout (this->hidden->screensaver_timeout)
#define dpms_enabled (this->hidden->dpms_enabled)
/* Some versions of XFree86 have bugs - detect if this is one of them */
#define BUGGY_XFREE86(condition, buggy_version) \
((SDL_strcmp(ServerVendor(SDL_Display), "The XFree86 Project, Inc") == 0) && \
(VendorRelease(SDL_Display) condition buggy_version))
#endif /* _SDL_x11video_h */
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11wm.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include "SDL_version.h"
#include "SDL_timer.h"
#include "SDL_video.h"
#include "SDL_syswm.h"
#include "../SDL_pixels_c.h"
#include "../../events/SDL_events_c.h"
#include "SDL_x11modes_c.h"
#include "SDL_x11wm_c.h"
static Uint8
reverse_byte(Uint8 x)
{
x = (x & 0xaa) >> 1 | (x & 0x55) << 1;
x = (x & 0xcc) >> 2 | (x & 0x33) << 2;
x = (x & 0xf0) >> 4 | (x & 0x0f) << 4;
return x;
}
void
X11_SetIcon(_THIS, SDL_Surface * icon, Uint8 * mask)
{
SDL_Surface *sicon;
XWMHints *wmhints;
XImage *icon_image;
Pixmap icon_pixmap;
Pixmap mask_pixmap;
Window icon_window = None;
GC gc;
XGCValues GCvalues;
int i, dbpp;
SDL_Rect bounds;
Uint8 *LSBmask;
Visual *dvis;
char *p;
int masksize;
SDL_Lock_EventThread();
/* The icon must use the default visual, depth and colormap of the
screen, so it might need a conversion */
dvis = DefaultVisual(SDL_Display, SDL_Screen);
dbpp = DefaultDepth(SDL_Display, SDL_Screen);
for (i = 0; i < this->hidden->nvisuals; i++) {
if (this->hidden->visuals[i].visual == dvis) {
dbpp = this->hidden->visuals[i].bpp;
break;
}
}
/* The Visual struct is supposed to be opaque but we cheat a little */
sicon = SDL_CreateRGBSurface(SDL_SWSURFACE, icon->w, icon->h,
dbpp,
dvis->red_mask, dvis->green_mask,
dvis->blue_mask, 0);
if (sicon == NULL)
goto done;
if (dbpp == 8) {
/* Default visual is 8bit; we need to allocate colours from
the default colormap */
SDL_Color want[256], got[256];
int nwant;
Colormap dcmap;
int missing;
dcmap = DefaultColormap(SDL_Display, SDL_Screen);
if (icon->format->palette) {
/* The icon has a palette as well - we just have to
find those colours */
nwant = icon->format->palette->ncolors;
SDL_memcpy(want, icon->format->palette->colors,
nwant * sizeof want[0]);
} else {
/* try the standard 6x6x6 cube for lack of better
ideas */
int r, g, b, i;
for (r = i = 0; r < 256; r += 0x33)
for (g = 0; g < 256; g += 0x33)
for (b = 0; b < 256; b += 0x33, i++) {
want[i].r = r;
want[i].g = g;
want[i].b = b;
}
nwant = 216;
}
if (SDL_iconcolors) {
/* free already allocated colours first */
unsigned long freelist[512];
int nfree = 0;
for (i = 0; i < 256; i++) {
while (SDL_iconcolors[i]) {
freelist[nfree++] = i;
SDL_iconcolors[i]--;
}
}
XFreeColors(GFX_Display, dcmap, freelist, nfree, 0);
}
if (!SDL_iconcolors)
SDL_iconcolors = SDL_malloc(256 * sizeof *SDL_iconcolors);
SDL_memset(SDL_iconcolors, 0, 256 * sizeof *SDL_iconcolors);
/* try to allocate the colours */
SDL_memset(got, 0, sizeof got);
missing = 0;
for (i = 0; i < nwant; i++) {
XColor c;
c.red = want[i].r << 8;
c.green = want[i].g << 8;
c.blue = want[i].b << 8;
c.flags = DoRed | DoGreen | DoBlue;
if (XAllocColor(GFX_Display, dcmap, &c)) {
/* got the colour */
SDL_iconcolors[c.pixel]++;
got[c.pixel] = want[i];
} else {
missing = 1;
}
}
if (missing) {
/* Some colours were apparently missing, so we just
allocate all the rest as well */
XColor cols[256];
for (i = 0; i < 256; i++)
cols[i].pixel = i;
XQueryColors(GFX_Display, dcmap, cols, 256);
for (i = 0; i < 256; i++) {
got[i].r = cols[i].red >> 8;
got[i].g = cols[i].green >> 8;
got[i].b = cols[i].blue >> 8;
if (!SDL_iconcolors[i]) {
if (XAllocColor(GFX_Display, dcmap, cols + i)) {
SDL_iconcolors[i] = 1;
} else {
/* index not available */
got[i].r = 0;
got[i].g = 0;
got[i].b = 0;
}
}
}
}
SDL_SetColors(sicon, got, 0, 256);
}
bounds.x = 0;
bounds.y = 0;
bounds.w = icon->w;
bounds.h = icon->h;
if (SDL_LowerBlit(icon, &bounds, sicon, &bounds) < 0)
goto done;
/* We need the mask as given, except in LSBfirst format instead of
MSBfirst. Reverse the bits in each byte. */
masksize = ((sicon->w + 7) >> 3) * sicon->h;
LSBmask = SDL_malloc(masksize);
if (LSBmask == NULL) {
goto done;
}
SDL_memset(LSBmask, 0, masksize);
for (i = 0; i < masksize; i++)
LSBmask[i] = reverse_byte(mask[i]);
mask_pixmap = XCreatePixmapFromBitmapData(SDL_Display, WMwindow,
(char *) LSBmask,
sicon->w, sicon->h, 1L, 0L, 1);
/* Transfer the image to an X11 pixmap */
icon_image = XCreateImage(SDL_Display,
DefaultVisual(SDL_Display, SDL_Screen),
DefaultDepth(SDL_Display, SDL_Screen),
ZPixmap, 0, sicon->pixels,
sicon->w, sicon->h, 32, 0);
icon_image->byte_order = (SDL_BYTEORDER == SDL_BIG_ENDIAN)
? MSBFirst : LSBFirst;
icon_pixmap = XCreatePixmap(SDL_Display, SDL_Root, sicon->w, sicon->h,
DefaultDepth(SDL_Display, SDL_Screen));
gc = XCreateGC(SDL_Display, icon_pixmap, 0, &GCvalues);
XPutImage(SDL_Display, icon_pixmap, gc, icon_image,
0, 0, 0, 0, sicon->w, sicon->h);
XFreeGC(SDL_Display, gc);
XDestroyImage(icon_image);
SDL_free(LSBmask);
sicon->pixels = NULL;
/* Some buggy window managers (some versions of Enlightenment, it
seems) need an icon window *and* icon pixmap to work properly, while
it screws up others. The default is only to use a pixmap. */
p = SDL_getenv("SDL_VIDEO_X11_ICONWIN");
if (p && *p) {
icon_window = XCreateSimpleWindow(SDL_Display, SDL_Root,
0, 0, sicon->w, sicon->h, 0,
CopyFromParent, CopyFromParent);
XSetWindowBackgroundPixmap(SDL_Display, icon_window, icon_pixmap);
XClearWindow(SDL_Display, icon_window);
}
/* Set the window icon to the icon pixmap (and icon window) */
wmhints = XAllocWMHints();
wmhints->flags = (IconPixmapHint | IconMaskHint);
wmhints->icon_pixmap = icon_pixmap;
wmhints->icon_mask = mask_pixmap;
if (icon_window != None) {
wmhints->flags |= IconWindowHint;
wmhints->icon_window = icon_window;
}
XSetWMHints(SDL_Display, WMwindow, wmhints);
XFree(wmhints);
XSync(SDL_Display, False);
done:
SDL_Unlock_EventThread();
SDL_FreeSurface(sicon);
}
void
X11_SetCaptionNoLock(_THIS, const char *title, const char *icon)
{
XTextProperty titleprop, iconprop;
Status status;
#ifdef X_HAVE_UTF8_STRING
Atom _NET_WM_NAME;
Atom _NET_WM_ICON_NAME;
/* Look up some useful Atoms */
if (SDL_X11_HAVE_UTF8) {
_NET_WM_NAME = XInternAtom(SDL_Display, "_NET_WM_NAME", False);
_NET_WM_ICON_NAME =
XInternAtom(SDL_Display, "_NET_WM_ICON_NAME", False);
}
#endif
if (title != NULL) {
char *title_latin1 = SDL_iconv_utf8_latin1((char *) title);
if (!title_latin1) {
SDL_OutOfMemory();
return;
}
status = XStringListToTextProperty(&title_latin1, 1, &titleprop);
SDL_free(title_latin1);
if (status) {
XSetTextProperty(SDL_Display, WMwindow, &titleprop, XA_WM_NAME);
XFree(titleprop.value);
}
#ifdef X_HAVE_UTF8_STRING
if (SDL_X11_HAVE_UTF8) {
status = Xutf8TextListToTextProperty(SDL_Display,
(char **) &title, 1,
XUTF8StringStyle,
&titleprop);
if (status == Success) {
XSetTextProperty(SDL_Display, WMwindow, &titleprop,
_NET_WM_NAME);
XFree(titleprop.value);
}
}
#endif
}
if (icon != NULL) {
char *icon_latin1 = SDL_iconv_utf8_latin1((char *) icon);
if (!icon_latin1) {
SDL_OutOfMemory();
return;
}
status = XStringListToTextProperty(&icon_latin1, 1, &iconprop);
SDL_free(icon_latin1);
if (status) {
XSetTextProperty(SDL_Display, WMwindow, &iconprop,
XA_WM_ICON_NAME);
XFree(iconprop.value);
}
#ifdef X_HAVE_UTF8_STRING
if (SDL_X11_HAVE_UTF8) {
status = Xutf8TextListToTextProperty(SDL_Display,
(char **) &icon, 1,
XUTF8StringStyle, &iconprop);
if (status == Success) {
XSetTextProperty(SDL_Display, WMwindow, &iconprop,
_NET_WM_ICON_NAME);
XFree(iconprop.value);
}
}
#endif
}
XSync(SDL_Display, False);
}
void
X11_SetCaption(_THIS, const char *title, const char *icon)
{
SDL_Lock_EventThread();
X11_SetCaptionNoLock(this, title, icon);
SDL_Unlock_EventThread();
}
/* Iconify the window */
int
X11_IconifyWindow(_THIS)
{
int result;
SDL_Lock_EventThread();
result = XIconifyWindow(SDL_Display, WMwindow, SDL_Screen);
XSync(SDL_Display, False);
SDL_Unlock_EventThread();
return (result);
}
SDL_GrabMode
X11_GrabInputNoLock(_THIS, SDL_GrabMode mode)
{
int result;
if (SDL_VideoSurface == NULL) {
return (SDL_GRAB_OFF);
}
if (!SDL_Window) {
return (mode); /* Will be set later on mode switch */
}
if (mode == SDL_GRAB_OFF) {
XUngrabPointer(SDL_Display, CurrentTime);
XUngrabKeyboard(SDL_Display, CurrentTime);
} else {
if (SDL_VideoSurface->flags & SDL_FULLSCREEN) {
/* Unbind the mouse from the fullscreen window */
XUngrabPointer(SDL_Display, CurrentTime);
}
/* Try to grab the mouse */
#if 0 /* We'll wait here until we actually grab, otherwise behavior undefined */
for (numtries = 0; numtries < 10; ++numtries) {
#else
for (;;) {
#endif
result = XGrabPointer(SDL_Display, SDL_Window, True, 0,
GrabModeAsync, GrabModeAsync,
SDL_Window, None, CurrentTime);
if (result == GrabSuccess) {
break;
}
SDL_Delay(100);
}
if (result != GrabSuccess) {
/* Uh, oh, what do we do here? */ ;
}
/* Now grab the keyboard */
XGrabKeyboard(SDL_Display, WMwindow, True,
GrabModeAsync, GrabModeAsync, CurrentTime);
/* Raise the window if we grab the mouse */
if (!(SDL_VideoSurface->flags & SDL_FULLSCREEN))
XRaiseWindow(SDL_Display, WMwindow);
/* Make sure we register input focus */
SDL_PrivateAppActive(1, SDL_APPINPUTFOCUS);
}
XSync(SDL_Display, False);
return (mode);
}
SDL_GrabMode
X11_GrabInput(_THIS, SDL_GrabMode mode)
{
SDL_Lock_EventThread();
mode = X11_GrabInputNoLock(this, mode);
SDL_Unlock_EventThread();
return (mode);
}
/* If 'info' is the right version, this function fills it and returns 1.
Otherwise, in case of a version mismatch, it returns -1.
*/
static void
lock_display(void)
{
SDL_Lock_EventThread();
}
static void
unlock_display(void)
{
/* Make sure any X11 transactions are completed */
SDL_VideoDevice *this = current_video;
XSync(SDL_Display, False);
SDL_Unlock_EventThread();
}
int
X11_GetWMInfo(_THIS, SDL_SysWMinfo * info)
{
if (info->version.major <= SDL_MAJOR_VERSION) {
info->subsystem = SDL_SYSWM_X11;
info->info.x11.display = SDL_Display;
info->info.x11.window = SDL_Window;
if (SDL_VERSIONNUM(info->version.major,
info->version.minor,
info->version.patch) >= 1002) {
info->info.x11.fswindow = FSwindow;
info->info.x11.wmwindow = WMwindow;
}
info->info.x11.lock_func = lock_display;
info->info.x11.unlock_func = unlock_display;
return (1);
} else {
SDL_SetError("Application not compiled with SDL %d.%d\n",
SDL_MAJOR_VERSION, SDL_MINOR_VERSION);
return (-1);
}
}
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11wm_c.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
#include "SDL_x11video.h"
/* Functions to be exported */
extern void X11_SetCaptionNoLock(_THIS, const char *title, const char *icon);
extern void X11_SetCaption(_THIS, const char *title, const char *icon);
extern void X11_SetIcon(_THIS, SDL_Surface * icon, Uint8 * mask);
extern int X11_IconifyWindow(_THIS);
extern SDL_GrabMode X11_GrabInputNoLock(_THIS, SDL_GrabMode mode);
extern SDL_GrabMode X11_GrabInput(_THIS, SDL_GrabMode mode);
extern int X11_GetWMInfo(_THIS, SDL_SysWMinfo * info);
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11yuv.c deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
/* This is the XFree86 Xv extension implementation of YUV video overlays */
#if SDL_VIDEO_DRIVER_X11_XV
#include <X11/Xlib.h>
#ifndef NO_SHARED_MEMORY
#include <sys/ipc.h>
#include <sys/shm.h>
#include <X11/extensions/XShm.h>
#endif
#include "../Xext/extensions/Xvlib.h"
#include "SDL_x11yuv_c.h"
#include "../SDL_yuvfuncs.h"
#define XFREE86_REFRESH_HACK
#ifdef XFREE86_REFRESH_HACK
#include "SDL_x11image_c.h"
#endif
/* Workaround when pitch != width */
#define PITCH_WORKAROUND
/* Fix for the NVidia GeForce 2 - use the last available adaptor */
#if 0 /* Apparently the NVidia drivers are fixed */
#define USE_LAST_ADAPTOR
#endif
/* The functions used to manipulate software video overlays */
static struct private_yuvhwfuncs x11_yuvfuncs = {
X11_LockYUVOverlay,
X11_UnlockYUVOverlay,
X11_DisplayYUVOverlay,
X11_FreeYUVOverlay
};
struct private_yuvhwdata
{
int port;
#ifndef NO_SHARED_MEMORY
int yuv_use_mitshm;
XShmSegmentInfo yuvshm;
#endif
SDL_NAME(XvImage) * image;
};
static int (*X_handler) (Display *, XErrorEvent *) = NULL;
#ifndef NO_SHARED_MEMORY
/* Shared memory error handler routine */
static int shm_error;
static int
shm_errhandler(Display * d, XErrorEvent * e)
{
if (e->error_code == BadAccess) {
shm_error = True;
return (0);
} else
return (X_handler(d, e));
}
#endif /* !NO_SHARED_MEMORY */
static int xv_error;
static int
xv_errhandler(Display * d, XErrorEvent * e)
{
if (e->error_code == BadMatch) {
xv_error = True;
return (0);
} else
return (X_handler(d, e));
}
SDL_Overlay *
X11_CreateYUVOverlay(_THIS, int width, int height, Uint32 format,
SDL_Surface * display)
{
SDL_Overlay *overlay;
struct private_yuvhwdata *hwdata;
int xv_port;
unsigned int i, j, k;
unsigned int adaptors;
SDL_NAME(XvAdaptorInfo) * ainfo;
int bpp;
#ifndef NO_SHARED_MEMORY
XShmSegmentInfo *yuvshm;
#endif
/* Look for the XVideo extension with a valid port for this format */
xv_port = -1;
if ((Success ==
SDL_NAME(XvQueryExtension) (GFX_Display, &j, &j, &j, &j, &j))
&& (Success ==
SDL_NAME(XvQueryAdaptors) (GFX_Display,
RootWindow(GFX_Display, SDL_Screen),
&adaptors, &ainfo))) {
#ifdef USE_LAST_ADAPTOR
for (i = 0; i < adaptors; ++i)
#else
for (i = 0; (i < adaptors) && (xv_port == -1); ++i)
#endif /* USE_LAST_ADAPTOR */
{
/* Check to see if the visual can be used */
if (BUGGY_XFREE86(<=, 4001)) {
int visual_ok = 0;
for (j = 0; j < ainfo[i].num_formats; ++j) {
if (ainfo[i].formats[j].visual_id == SDL_Visual->visualid) {
visual_ok = 1;
break;
}
}
if (!visual_ok) {
continue;
}
}
if ((ainfo[i].type & XvInputMask) &&
(ainfo[i].type & XvImageMask)) {
int num_formats;
SDL_NAME(XvImageFormatValues) * formats;
formats = SDL_NAME(XvListImageFormats) (GFX_Display,
ainfo[i].
base_id,
&num_formats);
#ifdef USE_LAST_ADAPTOR
for (j = 0; j < num_formats; ++j)
#else
for (j = 0; (j < num_formats) && (xv_port == -1); ++j)
#endif /* USE_LAST_ADAPTOR */
{
if ((Uint32) formats[j].id == format) {
for (k = 0; k < ainfo[i].num_ports; ++k) {
if (Success == SDL_NAME(XvGrabPort)
(GFX_Display,
ainfo[i].base_id + k, CurrentTime)) {
xv_port = ainfo[i].base_id + k;
break;
}
}
}
}
if (formats) {
XFree(formats);
}
}
}
SDL_NAME(XvFreeAdaptorInfo) (ainfo);
}
/* Precalculate the bpp for the pitch workaround below */
switch (format) {
/* Add any other cases we need to support... */
case SDL_YUY2_OVERLAY:
case SDL_UYVY_OVERLAY:
case SDL_YVYU_OVERLAY:
bpp = 2;
break;
default:
bpp = 1;
break;
}
#if 0
/*
* !!! FIXME:
* "Here are some diffs for X11 and yuv. Note that the last part 2nd
* diff should probably be a new call to XvQueryAdaptorFree with ainfo
* and the number of adaptors, instead of the loop through like I did."
*
* ACHTUNG: This is broken! It looks like XvFreeAdaptorInfo does this
* for you, so we end up with a double-free. I need to look at this
* more closely... --ryan.
*/
for (i = 0; i < adaptors; ++i) {
if (ainfo[i].name != NULL)
Xfree(ainfo[i].name);
if (ainfo[i].formats != NULL)
Xfree(ainfo[i].formats);
}
Xfree(ainfo);
#endif
if (xv_port == -1) {
SDL_SetError("No available video ports for requested format");
return (NULL);
}
/* Enable auto-painting of the overlay colorkey */
{
static const char *attr[] =
{ "XV_AUTOPAINT_COLORKEY", "XV_AUTOPAINT_COLOURKEY" };
unsigned int i;
SDL_NAME(XvSelectPortNotify) (GFX_Display, xv_port, True);
X_handler = XSetErrorHandler(xv_errhandler);
for (i = 0; i < sizeof(attr) / (sizeof attr[0]); ++i) {
Atom a;
xv_error = False;
a = XInternAtom(GFX_Display, attr[i], True);
if (a != None) {
SDL_NAME(XvSetPortAttribute) (GFX_Display, xv_port, a, 1);
XSync(GFX_Display, True);
if (!xv_error) {
break;
}
}
}
XSetErrorHandler(X_handler);
SDL_NAME(XvSelectPortNotify) (GFX_Display, xv_port, False);
}
/* Create the overlay structure */
overlay = (SDL_Overlay *) SDL_malloc(sizeof *overlay);
if (overlay == NULL) {
SDL_NAME(XvUngrabPort) (GFX_Display, xv_port, CurrentTime);
SDL_OutOfMemory();
return (NULL);
}
SDL_memset(overlay, 0, (sizeof *overlay));
/* Fill in the basic members */
overlay->format = format;
overlay->w = width;
overlay->h = height;
/* Set up the YUV surface function structure */
overlay->hwfuncs = &x11_yuvfuncs;
overlay->hw_overlay = 1;
/* Create the pixel data and lookup tables */
hwdata = (struct private_yuvhwdata *) SDL_malloc(sizeof *hwdata);
overlay->hwdata = hwdata;
if (hwdata == NULL) {
SDL_NAME(XvUngrabPort) (GFX_Display, xv_port, CurrentTime);
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
return (NULL);
}
hwdata->port = xv_port;
#ifndef NO_SHARED_MEMORY
yuvshm = &hwdata->yuvshm;
SDL_memset(yuvshm, 0, sizeof(*yuvshm));
hwdata->image = SDL_NAME(XvShmCreateImage) (GFX_Display, xv_port, format,
0, width, height, yuvshm);
#ifdef PITCH_WORKAROUND
if (hwdata->image != NULL && hwdata->image->pitches[0] != (width * bpp)) {
/* Ajust overlay width according to pitch */
XFree(hwdata->image);
width = hwdata->image->pitches[0] / bpp;
hwdata->image =
SDL_NAME(XvShmCreateImage) (GFX_Display, xv_port, format, 0,
width, height, yuvshm);
}
#endif /* PITCH_WORKAROUND */
hwdata->yuv_use_mitshm = (hwdata->image != NULL);
if (hwdata->yuv_use_mitshm) {
yuvshm->shmid = shmget(IPC_PRIVATE, hwdata->image->data_size,
IPC_CREAT | 0777);
if (yuvshm->shmid >= 0) {
yuvshm->shmaddr = (char *) shmat(yuvshm->shmid, 0, 0);
yuvshm->readOnly = False;
if (yuvshm->shmaddr != (char *) -1) {
shm_error = False;
X_handler = XSetErrorHandler(shm_errhandler);
XShmAttach(GFX_Display, yuvshm);
XSync(GFX_Display, True);
XSetErrorHandler(X_handler);
if (shm_error)
shmdt(yuvshm->shmaddr);
} else {
shm_error = True;
}
shmctl(yuvshm->shmid, IPC_RMID, NULL);
} else {
shm_error = True;
}
if (shm_error) {
XFree(hwdata->image);
hwdata->yuv_use_mitshm = 0;
} else {
hwdata->image->data = yuvshm->shmaddr;
}
}
if (!hwdata->yuv_use_mitshm)
#endif /* NO_SHARED_MEMORY */
{
hwdata->image =
SDL_NAME(XvCreateImage) (GFX_Display, xv_port, format, 0,
width, height);
#ifdef PITCH_WORKAROUND
if (hwdata->image != NULL
&& hwdata->image->pitches[0] != (width * bpp)) {
/* Ajust overlay width according to pitch */
XFree(hwdata->image);
width = hwdata->image->pitches[0] / bpp;
hwdata->image =
SDL_NAME(XvCreateImage) (GFX_Display, xv_port, format, 0,
width, height);
}
#endif /* PITCH_WORKAROUND */
if (hwdata->image == NULL) {
SDL_SetError("Couldn't create XVideo image");
SDL_FreeYUVOverlay(overlay);
return (NULL);
}
hwdata->image->data = SDL_malloc(hwdata->image->data_size);
if (hwdata->image->data == NULL) {
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
return (NULL);
}
}
/* Find the pitch and offset values for the overlay */
overlay->planes = hwdata->image->num_planes;
overlay->pitches =
(Uint16 *) SDL_malloc(overlay->planes * sizeof(Uint16));
overlay->pixels =
(Uint8 **) SDL_malloc(overlay->planes * sizeof(Uint8 *));
if (!overlay->pitches || !overlay->pixels) {
SDL_OutOfMemory();
SDL_FreeYUVOverlay(overlay);
return (NULL);
}
for (i = 0; i < overlay->planes; ++i) {
overlay->pitches[i] = hwdata->image->pitches[i];
overlay->pixels[i] = (Uint8 *) hwdata->image->data +
hwdata->image->offsets[i];
}
#ifdef XFREE86_REFRESH_HACK
/* Work around an XFree86 X server bug (?)
We can't perform normal updates in windows that have video
being output to them. See SDL_x11image.c for more details.
*/
X11_DisableAutoRefresh(this);
#endif
/* We're all done.. */
return (overlay);
}
int
X11_LockYUVOverlay(_THIS, SDL_Overlay * overlay)
{
return (0);
}
void
X11_UnlockYUVOverlay(_THIS, SDL_Overlay * overlay)
{
return;
}
int
X11_DisplayYUVOverlay(_THIS, SDL_Overlay * overlay, SDL_Rect * src,
SDL_Rect * dst)
{
struct private_yuvhwdata *hwdata;
hwdata = overlay->hwdata;
#ifndef NO_SHARED_MEMORY
if (hwdata->yuv_use_mitshm) {
SDL_NAME(XvShmPutImage) (GFX_Display, hwdata->port, SDL_Window,
SDL_GC, hwdata->image, src->x, src->y,
src->w, src->h, dst->x, dst->y, dst->w,
dst->h, False);
} else
#endif
{
SDL_NAME(XvPutImage) (GFX_Display, hwdata->port, SDL_Window,
SDL_GC, hwdata->image, src->x, src->y,
src->w, src->h, dst->x, dst->y, dst->w, dst->h);
}
XSync(GFX_Display, False);
return (0);
}
void
X11_FreeYUVOverlay(_THIS, SDL_Overlay * overlay)
{
struct private_yuvhwdata *hwdata;
hwdata = overlay->hwdata;
if (hwdata) {
SDL_NAME(XvUngrabPort) (GFX_Display, hwdata->port, CurrentTime);
#ifndef NO_SHARED_MEMORY
if (hwdata->yuv_use_mitshm) {
XShmDetach(GFX_Display, &hwdata->yuvshm);
shmdt(hwdata->yuvshm.shmaddr);
}
#endif
if (hwdata->image) {
XFree(hwdata->image);
}
SDL_free(hwdata);
}
if (overlay->pitches) {
SDL_free(overlay->pitches);
overlay->pitches = NULL;
}
if (overlay->pixels) {
SDL_free(overlay->pixels);
overlay->pixels = NULL;
}
#ifdef XFREE86_REFRESH_HACK
X11_EnableAutoRefresh(this);
#endif
}
#endif /* SDL_VIDEO_DRIVER_X11_XV */
/* vi: set ts=4 sw=4 expandtab: */
src/video/x11/SDL_x11yuv_c.h deleted 100644 → 0
View file @ fe52e82b
/*
SDL - Simple DirectMedia Layer
Copyright (C) 1997-2006 Sam Lantinga
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
Sam Lantinga
slouken@libsdl.org
*/
#include "SDL_config.h"
/* This is the XFree86 Xv extension implementation of YUV video overlays */
#include "SDL_video.h"
#include "SDL_x11video.h"
#if SDL_VIDEO_DRIVER_X11_XV
extern SDL_Overlay *X11_CreateYUVOverlay(_THIS, int width, int height,
Uint32 format,
SDL_Surface * display);
extern int X11_LockYUVOverlay(_THIS, SDL_Overlay * overlay);
extern void X11_UnlockYUVOverlay(_THIS, SDL_Overlay * overlay);
extern int X11_DisplayYUVOverlay(_THIS, SDL_Overlay * overlay,
SDL_Rect * src, SDL_Rect * dst);
extern void X11_FreeYUVOverlay(_THIS, SDL_Overlay * overlay);
#endif /* SDL_VIDEO_DRIVER_X11_XV */
/* vi: set ts=4 sw=4 expandtab: */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment