do not generate vertexposition/vertexmesh arrays in
[divverent/darkplaces.git] / vid_glx.c
index 4a95aa1..342e52d 100644 (file)
--- a/vid_glx.c
+++ b/vid_glx.c
@@ -17,34 +17,41 @@ along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
 
-//#include <termios.h>
-//#include <sys/ioctl.h>
-//#include <sys/stat.h>
-//#include <sys/vt.h>
-//#include <stdarg.h>
-//#include <stdio.h>
 #include <signal.h>
 
 #include <dlfcn.h>
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
+#include <X11/Xatom.h>
+#include <X11/XKBlib.h> // TODO possibly ifdef this out on non-supporting systems... Solaris (as always)?
 #include <GL/glx.h>
 
+#include "quakedef.h"
+
 #include <X11/keysym.h>
 #include <X11/cursorfont.h>
+#include <X11/xpm.h>
 
 #include <X11/extensions/XShm.h>
-#if !defined(__APPLE__) && !defined(__MACH__)
+#if !defined(__APPLE__) && !defined(__MACH__) && !defined(SUNOS)
 #include <X11/extensions/xf86dga.h>
 #endif
 #include <X11/extensions/xf86vmode.h>
 
-#include "quakedef.h"
+// get the Uchar type
+#include "utf8lib.h"
+#include "image.h"
+
+#include "nexuiz.xpm"
+#include "darkplaces.xpm"
 
 // Tell startup code that we have a client
 int cl_available = true;
 
+// note: if we used the XRandR extension we could support refresh rates
+qboolean vid_supportrefreshrate = false;
+
 //GLX prototypes
 XVisualInfo *(GLAPIENTRY *qglXChooseVisual)(Display *dpy, int screen, int *attribList);
 GLXContext (GLAPIENTRY *qglXCreateContext)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct);
@@ -62,23 +69,26 @@ static dllfunction_t getprocaddressfuncs[] =
        {NULL, NULL}
 };
 
-//GLX_SGI_video_sync
-GLint (GLAPIENTRY *qglXGetVideoSyncSGI)(GLuint *count);
-GLint (GLAPIENTRY *qglXWaitVideoSyncSGI)(GLint divisor, GLint remainder, GLuint *count);
+//GLX_SGI_swap_control
+GLint (GLAPIENTRY *qglXSwapIntervalSGI)(GLint interval);
 
-static dllfunction_t videosyncfuncs[] =
+static dllfunction_t swapcontrolfuncs[] =
 {
-       {"glXGetVideoSyncSGI", (void **) &qglXGetVideoSyncSGI},
-       {"glXWaitVideoSyncSGI", (void **) &qglXWaitVideoSyncSGI},
+       {"glXSwapIntervalSGI", (void **) &qglXSwapIntervalSGI},
        {NULL, NULL}
 };
 
 static Display *vidx11_display = NULL;
 static int vidx11_screen;
-static Window win;
+static Window win, root;
 static GLXContext ctx = NULL;
 
 Atom wm_delete_window_atom;
+Atom net_wm_state_atom;
+Atom net_wm_state_hidden_atom;
+Atom net_wm_state_fullscreen_atom;
+Atom net_wm_icon;
+Atom cardinal;
 
 #define KEY_MASK (KeyPressMask | KeyReleaseMask)
 #define MOUSE_MASK (ButtonPressMask | ButtonReleaseMask | \
@@ -88,40 +98,87 @@ Atom wm_delete_window_atom;
                LeaveWindowMask)
 
 
-static qboolean                mouse_avail = true;
-static qboolean                mouse_active = false, usingmouse = false;
-static float   mouse_x, mouse_y;
-static int p_mouse_x, p_mouse_y;
+static qboolean mouse_avail = true;
+static qboolean vid_usingmousegrab = false;
+static qboolean vid_usingmouse = false;
+static qboolean vid_usinghidecursor = false;
+static qboolean vid_usingvsync = false;
+static qboolean vid_usevsync = false;
+static qboolean vid_x11_hardwaregammasupported = false;
+static qboolean vid_x11_dgasupported = false;
+static int vid_x11_gammarampsize = 0;
 
-#ifndef __APPLE__
-cvar_t vid_dga = {CVAR_SAVE, "vid_dga", "1"};
-cvar_t vid_dga_mouseaccel = {0, "vid_dga_mouseaccel", "1"};
+#if !defined(__APPLE__) && !defined(SUNOS)
+cvar_t vid_dgamouse = {CVAR_SAVE, "vid_dgamouse", "0", "make use of DGA mouse input"};
+static qboolean vid_usingdgamouse = false;
 #endif
+cvar_t vid_netwmfullscreen = {CVAR_SAVE, "vid_netwmfullscreen", "0", "make use _NET_WM_STATE_FULLSCREEN; turn this off if fullscreen does not work for you"};
 
 qboolean vidmode_ext = false;
 
 static int win_x, win_y;
 
-static int scr_width, scr_height;
-
-static XF86VidModeModeInfo **vidmodes;
-static int num_vidmodes;
-static qboolean vidmode_active = false;
+static XF86VidModeModeInfo init_vidmode, game_vidmode;
+static qboolean vid_isfullscreen = false;
+static qboolean vid_isvidmodefullscreen = false;
+static qboolean vid_isnetwmfullscreen = false;
+static qboolean vid_isoverrideredirect = false;
 
 static Visual *vidx11_visual;
 static Colormap vidx11_colormap;
 
 /*-----------------------------------------------------------------------*/
+//
+
+long keysym2ucs(KeySym keysym);
+void DP_Xutf8LookupString(XKeyEvent * ev,
+                        Uchar *uch,
+                        KeySym * keysym_return,
+                        Status * status_return)
+{
+       int rc;
+       KeySym keysym;
+       int codepoint;
+       char buffer[64];
+       int nbytes = sizeof(buffer);
+
+       rc = XLookupString(ev, buffer, nbytes, &keysym, NULL);
+
+       if (rc > 0) {
+               codepoint = buffer[0] & 0xFF;
+       } else {
+               codepoint = keysym2ucs(keysym);
+       }
 
-static int XLateKey(XKeyEvent *ev, char *ascii)
+       if (codepoint < 0) {
+               if (keysym == None) {
+                       *status_return = XLookupNone;
+               } else {
+                       *status_return = XLookupKeySym;
+                       *keysym_return = keysym;
+               }
+               *uch = 0;
+               return;
+       }
+
+       *uch = codepoint;
+
+       if (keysym != None) {
+               *keysym_return = keysym;
+               *status_return = XLookupBoth;
+       } else {
+               *status_return = XLookupChars;
+       }
+}
+static int XLateKey(XKeyEvent *ev, Uchar *ascii)
 {
        int key = 0;
-       char buf[64];
+       //char buf[64];
        KeySym keysym, shifted;
+       Status status;
 
        keysym = XLookupKeysym (ev, 0);
-       XLookupString(ev, buf, sizeof buf, &shifted, 0);
-       *ascii = buf[0];
+       DP_Xutf8LookupString(ev, ascii, &shifted, &status);
 
        switch(keysym)
        {
@@ -196,6 +253,7 @@ static int XLateKey(XKeyEvent *ev, char *ascii)
 
                case XK_Alt_L:
                case XK_Meta_L:
+               case XK_ISO_Level3_Shift:
                case XK_Alt_R:
                case XK_Meta_R: key = K_ALT;                    break;
 
@@ -204,13 +262,15 @@ static int XLateKey(XKeyEvent *ev, char *ascii)
                case XK_Insert:key = K_INS; break;
                case XK_KP_Insert: key = K_KP_INS; break;
 
-               case XK_KP_Multiply: key = '*'; break;
+               case XK_KP_Multiply: key = K_KP_MULTIPLY; break;
                case XK_KP_Add:  key = K_KP_PLUS; break;
                case XK_KP_Subtract: key = K_KP_MINUS; break;
                case XK_KP_Divide: key = K_KP_SLASH; break;
 
+               case XK_section:        key = '~'; break;
+
                default:
-                       if (keysym < 32 && keysym > 126)
+                       if (keysym < 32)
                                break;
 
                        if (keysym >= 'A' && keysym <= 'Z')
@@ -245,72 +305,147 @@ static Cursor CreateNullCursor(Display *display, Window root)
        return cursor;
 }
 
-static void install_grabs(void)
+void VID_SetMouse(qboolean fullscreengrab, qboolean relative, qboolean hidecursor)
 {
-       XWindowAttributes attribs_1;
-       XSetWindowAttributes attribs_2;
+       static int originalmouseparms_num;
+       static int originalmouseparms_denom;
+       static int originalmouseparms_threshold;
+       static qboolean restore_spi;
 
-       XGetWindowAttributes(vidx11_display, win, &attribs_1);
-       attribs_2.event_mask = attribs_1.your_event_mask | KEY_MASK | MOUSE_MASK;
-       XChangeWindowAttributes(vidx11_display, win, CWEventMask, &attribs_2);
+#if !defined(__APPLE__) && !defined(SUNOS)
+       qboolean usedgamouse;
+#endif
 
-// inviso cursor
-       XDefineCursor(vidx11_display, win, CreateNullCursor(vidx11_display, win));
+       if (!vidx11_display || !win)
+               return;
 
-       XGrabPointer(vidx11_display, win,  True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime);
+       if (relative)
+               fullscreengrab = true;
 
-#ifndef __APPLE__
-       if (vid_dga.integer)
-       {
-               int MajorVersion, MinorVersion;
+       if (!mouse_avail)
+               fullscreengrab = relative = hidecursor = false;
+
+#if !defined(__APPLE__) && !defined(SUNOS)
+       usedgamouse = relative && vid_dgamouse.integer;
+       if (!vid_x11_dgasupported)
+               usedgamouse = false;
+       if (fullscreengrab && vid_usingmouse && (vid_usingdgamouse != usedgamouse))
+               VID_SetMouse(false, false, false); // ungrab first!
+#endif
 
-               if (!XF86DGAQueryVersion(vidx11_display, &MajorVersion, &MinorVersion))
+       if (vid_usingmousegrab != fullscreengrab)
+       {
+               vid_usingmousegrab = fullscreengrab;
+               cl_ignoremousemoves = 2;
+               if (fullscreengrab)
                {
-                       // unable to query, probalby not supported
-                       Con_Print( "Failed to detect XF86DGA Mouse\n" );
-                       vid_dga.integer = 0;
+                       XGrabPointer(vidx11_display, win,  True, 0, GrabModeAsync, GrabModeAsync, win, None, CurrentTime);
+                       if (vid_grabkeyboard.integer || vid_isoverrideredirect)
+                               XGrabKeyboard(vidx11_display, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
                }
                else
                {
-                       vid_dga.integer = 1;
-                       XF86DGADirectVideo(vidx11_display, DefaultScreen(vidx11_display), XF86DGADirectMouse);
-                       XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, 0, 0);
+                       XUngrabPointer(vidx11_display, CurrentTime);
+                       XUngrabKeyboard(vidx11_display, CurrentTime);
                }
        }
-       else
-#endif
-               XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, scr_width / 2, scr_height / 2);
 
-       XGrabKeyboard(vidx11_display, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
+       if (relative)
+       {
+               if (!vid_usingmouse)
+               {
+                       XWindowAttributes attribs_1;
+                       XSetWindowAttributes attribs_2;
 
-       mouse_active = true;
-       mouse_x = mouse_y = 0;
-}
+                       XGetWindowAttributes(vidx11_display, win, &attribs_1);
+                       attribs_2.event_mask = attribs_1.your_event_mask | KEY_MASK | MOUSE_MASK;
+                       XChangeWindowAttributes(vidx11_display, win, CWEventMask, &attribs_2);
 
-static void uninstall_grabs(void)
-{
-       if (!vidx11_display || !win)
-               return;
+#if !defined(__APPLE__) && !defined(SUNOS)
+                       vid_usingdgamouse = usedgamouse;
+                       if (usedgamouse)
+                       {
+                               XF86DGADirectVideo(vidx11_display, DefaultScreen(vidx11_display), XF86DGADirectMouse);
+                               XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, 0, 0);
+                       }
+                       else
+#endif
+                               XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
 
-#ifndef __APPLE__
-       if (vid_dga.integer == 1)
-               XF86DGADirectVideo(vidx11_display, DefaultScreen(vidx11_display), 0);
+// COMMANDLINEOPTION: X11 Input: -noforcemparms disables setting of mouse parameters (not used with DGA, windows only)
+#if !defined(__APPLE__) && !defined(SUNOS)
+                       if (!COM_CheckParm ("-noforcemparms") && !usedgamouse)
+#else
+                       if (!COM_CheckParm ("-noforcemparms"))
 #endif
+                       {
+                               XGetPointerControl(vidx11_display, &originalmouseparms_num, &originalmouseparms_denom, &originalmouseparms_threshold);
+                               XChangePointerControl (vidx11_display, true, false, 1, 1, -1); // TODO maybe change threshold here, or remove this comment
+                               restore_spi = true;
+                       }
+                       else
+                               restore_spi = false;
 
-       XUngrabPointer(vidx11_display, CurrentTime);
-       XUngrabKeyboard(vidx11_display, CurrentTime);
+                       cl_ignoremousemoves = 2;
+                       vid_usingmouse = true;
+               }
+       }
+       else
+       {
+               if (vid_usingmouse)
+               {
+#if !defined(__APPLE__) && !defined(SUNOS)
+                       if (vid_usingdgamouse)
+                               XF86DGADirectVideo(vidx11_display, DefaultScreen(vidx11_display), 0);
+                       vid_usingdgamouse = false;
+#endif
+                       cl_ignoremousemoves = 2;
 
-// inviso cursor
-       XUndefineCursor(vidx11_display, win);
+                       if (restore_spi)
+                               XChangePointerControl (vidx11_display, true, true, originalmouseparms_num, originalmouseparms_denom, originalmouseparms_threshold);
+                       restore_spi = false;
+
+                       vid_usingmouse = false;
+               }
+       }
 
-       mouse_active = false;
+       if (vid_usinghidecursor != hidecursor)
+       {
+               vid_usinghidecursor = hidecursor;
+               if (hidecursor)
+                       XDefineCursor(vidx11_display, win, CreateNullCursor(vidx11_display, win));
+               else
+                       XUndefineCursor(vidx11_display, win);
+       }
 }
 
+static keynum_t buttonremap[18] =
+{
+       K_MOUSE1,
+       K_MOUSE3,
+       K_MOUSE2,
+       K_MWHEELUP,
+       K_MWHEELDOWN,
+       K_MOUSE4,
+       K_MOUSE5,
+       K_MOUSE6,
+       K_MOUSE7,
+       K_MOUSE8,
+       K_MOUSE9,
+       K_MOUSE10,
+       K_MOUSE11,
+       K_MOUSE12,
+       K_MOUSE13,
+       K_MOUSE14,
+       K_MOUSE15,
+       K_MOUSE16,
+};
+
 static void HandleEvents(void)
 {
        XEvent event;
        int key;
-       char ascii;
+       Uchar unicode;
        qboolean dowarp = false;
 
        if (!vidx11_display)
@@ -324,135 +459,57 @@ static void HandleEvents(void)
                {
                case KeyPress:
                        // key pressed
-                       key = XLateKey (&event.xkey, &ascii);
-                       Key_Event(key, ascii, true);
+                       key = XLateKey (&event.xkey, &unicode);
+                       Key_Event(key, unicode, true);
                        break;
 
                case KeyRelease:
                        // key released
-                       key = XLateKey (&event.xkey, &ascii);
-                       Key_Event(key, ascii, false);
+                       key = XLateKey (&event.xkey, &unicode);
+                       Key_Event(key, unicode, false);
                        break;
 
                case MotionNotify:
                        // mouse moved
-                       if (usingmouse)
+                       if (vid_usingmouse)
                        {
-#ifndef __APPLE__
-                               if (vid_dga.integer == 1)
+#if !defined(__APPLE__) && !defined(SUNOS)
+                               if (vid_usingdgamouse)
                                {
-                                       mouse_x += event.xmotion.x_root * vid_dga_mouseaccel.value;
-                                       mouse_y += event.xmotion.y_root * vid_dga_mouseaccel.value;
+                                       in_mouse_x += event.xmotion.x_root;
+                                       in_mouse_y += event.xmotion.y_root;
                                }
                                else
 #endif
                                {
-
                                        if (!event.xmotion.send_event)
                                        {
-                                               mouse_x += event.xmotion.x - p_mouse_x;
-                                               mouse_y += event.xmotion.y - p_mouse_y;
-                                               if (abs(scr_width/2 - event.xmotion.x) > scr_width / 4 || abs(scr_height/2 - event.xmotion.y) > scr_height / 4)
+                                               in_mouse_x += event.xmotion.x - in_windowmouse_x;
+                                               in_mouse_y += event.xmotion.y - in_windowmouse_y;
+                                               //if (abs(vid.width/2 - event.xmotion.x) + abs(vid.height/2 - event.xmotion.y))
+                                               if (vid_stick_mouse.integer || abs(vid.width/2 - event.xmotion.x) > vid.width / 4 || abs(vid.height/2 - event.xmotion.y) > vid.height / 4)
                                                        dowarp = true;
                                        }
-                                       p_mouse_x = event.xmotion.x;
-                                       p_mouse_y = event.xmotion.y;
                                }
                        }
-                       //else
-                       //      ui_mouseupdate(event.xmotion.x, event.xmotion.y);
+                       in_windowmouse_x = event.xmotion.x;
+                       in_windowmouse_y = event.xmotion.y;
                        break;
 
                case ButtonPress:
                        // mouse button pressed
-                       switch(event.xbutton.button)
-                       {
-                       case 1:
-                               Key_Event(K_MOUSE1, 0, true);
-                               break;
-                       case 2:
-                               Key_Event(K_MOUSE3, 0, true);
-                               break;
-                       case 3:
-                               Key_Event(K_MOUSE2, 0, true);
-                               break;
-                       case 4:
-                               Key_Event(K_MWHEELUP, 0, true);
-                               break;
-                       case 5:
-                               Key_Event(K_MWHEELDOWN, 0, true);
-                               break;
-                       case 6:
-                               Key_Event(K_MOUSE4, 0, true);
-                               break;
-                       case 7:
-                               Key_Event(K_MOUSE5, 0, true);
-                               break;
-                       case 8:
-                               Key_Event(K_MOUSE6, 0, true);
-                               break;
-                       case 9:
-                               Key_Event(K_MOUSE7, 0, true);
-                               break;
-                       case 10:
-                               Key_Event(K_MOUSE8, 0, true);
-                               break;
-                       case 11:
-                               Key_Event(K_MOUSE9, 0, true);
-                               break;
-                       case 12:
-                               Key_Event(K_MOUSE10, 0, true);
-                               break;
-                       default:
-                               Con_Printf("HandleEvents: ButtonPress gave value %d, 1-12 expected\n", event.xbutton.button);
-                               break;
-                       }
+                       if (event.xbutton.button <= 18)
+                               Key_Event(buttonremap[event.xbutton.button - 1], 0, true);
+                       else
+                               Con_Printf("HandleEvents: ButtonPress gave value %d, 1-18 expected\n", event.xbutton.button);
                        break;
 
                case ButtonRelease:
                        // mouse button released
-                       switch(event.xbutton.button)
-                       {
-                       case 1:
-                               Key_Event(K_MOUSE1, 0, false);
-                               break;
-                       case 2:
-                               Key_Event(K_MOUSE3, 0, false);
-                               break;
-                       case 3:
-                               Key_Event(K_MOUSE2, 0, false);
-                               break;
-                       case 4:
-                               Key_Event(K_MWHEELUP, 0, false);
-                               break;
-                       case 5:
-                               Key_Event(K_MWHEELDOWN, 0, false);
-                               break;
-                       case 6:
-                               Key_Event(K_MOUSE4, 0, false);
-                               break;
-                       case 7:
-                               Key_Event(K_MOUSE5, 0, false);
-                               break;
-                       case 8:
-                               Key_Event(K_MOUSE6, 0, false);
-                               break;
-                       case 9:
-                               Key_Event(K_MOUSE7, 0, false);
-                               break;
-                       case 10:
-                               Key_Event(K_MOUSE8, 0, false);
-                               break;
-                       case 11:
-                               Key_Event(K_MOUSE9, 0, false);
-                               break;
-                       case 12:
-                               Key_Event(K_MOUSE10, 0, false);
-                               break;
-                       default:
-                               Con_Printf("HandleEvents: ButtonRelease gave value %d, 1-12 expected\n", event.xbutton.button);
-                               break;
-                       }
+                       if (event.xbutton.button <= 18)
+                               Key_Event(buttonremap[event.xbutton.button - 1], 0, false);
+                       else
+                               Con_Printf("HandleEvents: ButtonRelease gave value %d, 1-18 expected\n", event.xbutton.button);
                        break;
 
                case CreateNotify:
@@ -465,36 +522,106 @@ static void HandleEvents(void)
                        // window changed size/location
                        win_x = event.xconfigure.x;
                        win_y = event.xconfigure.y;
+                       if(vid_resizable.integer < 2 || vid_isnetwmfullscreen)
+                       {
+                               vid.width = event.xconfigure.width;
+                               vid.height = event.xconfigure.height;
+                               if(vid_isnetwmfullscreen)
+                                       Con_Printf("NetWM fullscreen: actually using resolution %dx%d\n", vid.width, vid.height);
+                               else
+                                       Con_DPrintf("Updating to ConfigureNotify resolution %dx%d\n", vid.width, vid.height);
+                       }
                        break;
                case DestroyNotify:
                        // window has been destroyed
-                       Sys_Quit();
+                       Sys_Quit(0);
                        break;
                case ClientMessage:
                        // window manager messages
                        if ((event.xclient.format == 32) && ((unsigned int)event.xclient.data.l[0] == wm_delete_window_atom))
-                               Sys_Quit();
+                               Sys_Quit(0);
                        break;
                case MapNotify:
+                       if (vid_isoverrideredirect)
+                               break;
                        // window restored
                        vid_hidden = false;
-                       vid_activewindow = false;
                        VID_RestoreSystemGamma();
+
+                       if(vid_isvidmodefullscreen)
+                       {
+                               // set our video mode
+                               XF86VidModeSwitchToMode(vidx11_display, vidx11_screen, &game_vidmode);
+
+                               // Move the viewport to top left
+                               XF86VidModeSetViewPort(vidx11_display, vidx11_screen, 0, 0);
+                       }
+
+                       if(vid_isnetwmfullscreen)
+                       {
+                               // make sure it's fullscreen
+                               XEvent event;
+                               event.type = ClientMessage;
+                               event.xclient.serial = 0;
+                               event.xclient.send_event = True;
+                               event.xclient.message_type = net_wm_state_atom;
+                               event.xclient.window = win;
+                               event.xclient.format = 32;
+                               event.xclient.data.l[0] = 1;
+                               event.xclient.data.l[1] = net_wm_state_fullscreen_atom;
+                               event.xclient.data.l[2] = 0;
+                               event.xclient.data.l[3] = 1;
+                               event.xclient.data.l[4] = 0;
+                               XSendEvent(vidx11_display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &event);
+                       }
+
+                       dowarp = true;
+
                        break;
                case UnmapNotify:
+                       if (vid_isoverrideredirect)
+                               break;
                        // window iconified/rolledup/whatever
                        vid_hidden = true;
-                       vid_activewindow = false;
                        VID_RestoreSystemGamma();
+
+                       if(vid_isvidmodefullscreen)
+                               XF86VidModeSwitchToMode(vidx11_display, vidx11_screen, &init_vidmode);
+
                        break;
                case FocusIn:
+                       if (vid_isoverrideredirect)
+                               break;
                        // window is now the input focus
                        vid_activewindow = true;
                        break;
                case FocusOut:
+                       if (vid_isoverrideredirect)
+                               break;
+
+                       if(vid_isnetwmfullscreen && event.xfocus.mode == NotifyNormal)
+                       {
+                               // iconify netwm fullscreen window when it loses focus
+                               // when the user selects it in the taskbar, the window manager will map it again and send MapNotify
+                               XEvent event;
+                               event.type = ClientMessage;
+                               event.xclient.serial = 0;
+                               event.xclient.send_event = True;
+                               event.xclient.message_type = net_wm_state_atom;
+                               event.xclient.window = win;
+                               event.xclient.format = 32;
+                               event.xclient.data.l[0] = 1;
+                               event.xclient.data.l[1] = net_wm_state_hidden_atom;
+                               event.xclient.data.l[2] = 0;
+                               event.xclient.data.l[3] = 1;
+                               event.xclient.data.l[4] = 0;
+                               XSendEvent(vidx11_display, root, False, SubstructureRedirectMask | SubstructureNotifyMask, &event);
+                       }
+
                        // window is no longer the input focus
                        vid_activewindow = false;
                        VID_RestoreSystemGamma();
+
                        break;
                case EnterNotify:
                        // mouse entered window
@@ -508,36 +635,54 @@ static void HandleEvents(void)
        if (dowarp)
        {
                /* move the mouse to the window center again */
-               p_mouse_x = scr_width / 2;
-               p_mouse_y = scr_height / 2;
-               XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, p_mouse_x, p_mouse_y);
+               // we'll catch the warp motion by its send_event flag, updating the
+               // stored mouse position without adding any delta motion
+               XEvent event;
+               event.type = MotionNotify;
+               event.xmotion.display = vidx11_display;
+               event.xmotion.window = win;
+               event.xmotion.x = vid.width / 2;
+               event.xmotion.y = vid.height / 2;
+               XSendEvent(vidx11_display, win, False, PointerMotionMask, &event);
+               XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, vid.width / 2, vid.height / 2);
        }
-
 }
 
-static void IN_DeactivateMouse( void )
+static void *prjobj = NULL;
+
+static void GL_CloseLibrary(void)
 {
-       if (!mouse_avail || !vidx11_display || !win)
-               return;
+       if (prjobj)
+               dlclose(prjobj);
+       prjobj = NULL;
+       gl_driver[0] = 0;
+       qglXGetProcAddressARB = NULL;
+       gl_extensions = "";
+       gl_platform = "";
+       gl_platformextensions = "";
+}
 
-       if (mouse_active)
+static int GL_OpenLibrary(const char *name)
+{
+       Con_Printf("Loading OpenGL driver %s\n", name);
+       GL_CloseLibrary();
+       if (!(prjobj = dlopen(name, RTLD_LAZY | RTLD_GLOBAL)))
        {
-               uninstall_grabs();
-               mouse_active = false;
+               Con_Printf("Unable to open symbol list for %s\n", name);
+               return false;
        }
+       strlcpy(gl_driver, name, sizeof(gl_driver));
+       return true;
 }
 
-static void IN_ActivateMouse( void )
+void *GL_GetProcAddress(const char *name)
 {
-       if (!mouse_avail || !vidx11_display || !win)
-               return;
-
-       if (!mouse_active)
-       {
-               mouse_x = mouse_y = 0; // don't spazz
-               install_grabs();
-               mouse_active = true;
-       }
+       void *p = NULL;
+       if (qglXGetProcAddressARB != NULL)
+               p = (void *) qglXGetProcAddressARB((GLubyte *)name);
+       if (p == NULL)
+               p = (void *) dlsym(prjobj, name);
+       return p;
 }
 
 void VID_Shutdown(void)
@@ -545,21 +690,21 @@ void VID_Shutdown(void)
        if (!ctx || !vidx11_display)
                return;
 
-       vid_hidden = true;
-       usingmouse = false;
-       if (vidx11_display)
-       {
-               VID_RestoreSystemGamma();
-               uninstall_grabs();
+       VID_SetMouse(false, false, false);
+       VID_RestoreSystemGamma();
 
-               // FIXME: glXDestroyContext here?
-               if (vidmode_active)
-                       XF86VidModeSwitchToMode(vidx11_display, vidx11_screen, vidmodes[0]);
-               if (win)
-                       XDestroyWindow(vidx11_display, win);
-               XCloseDisplay(vidx11_display);
-       }
-       vidmode_active = false;
+       // FIXME: glXDestroyContext here?
+       if (vid_isvidmodefullscreen)
+               XF86VidModeSwitchToMode(vidx11_display, vidx11_screen, &init_vidmode);
+       if (win)
+               XDestroyWindow(vidx11_display, win);
+       XCloseDisplay(vidx11_display);
+
+       vid_hidden = true;
+       vid_isfullscreen = false;
+       vid_isnetwmfullscreen = false;
+       vid_isvidmodefullscreen = false;
+       vid_isoverrideredirect = false;
        vidx11_display = NULL;
        win = 0;
        ctx = NULL;
@@ -570,10 +715,9 @@ void VID_Shutdown(void)
 
 void signal_handler(int sig)
 {
-       printf("Received signal %d, exiting...\n", sig);
+       Con_Printf("Received signal %d, exiting...\n", sig);
        VID_RestoreSystemGamma();
-       Sys_Quit();
-       exit(0);
+       Sys_Quit(1);
 }
 
 void InitSig(void)
@@ -590,108 +734,107 @@ void InitSig(void)
        signal(SIGTERM, signal_handler);
 }
 
-/*
-=================
-VID_GetWindowSize
-=================
-*/
-void VID_GetWindowSize (int *x, int *y, int *width, int *height)
-{
-       *x = *y = 0;
-       *width = scr_width;
-       *height = scr_height;
-}
-
 void VID_Finish (void)
 {
-       int usemouse;
-       if (r_render.integer)
-       {
-               if (r_speeds.integer || gl_finish.integer)
-                       qglFinish();
-               qglXSwapBuffers(vidx11_display, win);
-       }
-
-// handle the mouse state when windowed if that's changed
-       usemouse = false;
-       if (vid_mouse.integer && !key_consoleactive)
-               usemouse = true;
-       if (vidmode_active)
-               usemouse = true;
-       if (usemouse)
+       vid_usevsync = vid_vsync.integer && !cls.timedemo && qglXSwapIntervalSGI;
+       if (vid_usingvsync != vid_usevsync)
        {
-               if (!usingmouse)
-               {
-                       usingmouse = true;
-                       IN_ActivateMouse ();
-               }
+               vid_usingvsync = vid_usevsync;
+               if (qglXSwapIntervalSGI (vid_usevsync))
+                       Con_Print("glXSwapIntervalSGI didn't accept the vid_vsync change, it will take effect on next vid_restart (GLX_SGI_swap_control does not allow turning off vsync)\n");
        }
-       else
+
+       if (!vid_hidden)
        {
-               if (usingmouse)
+               CHECKGLERROR
+               if (r_speeds.integer == 2 || gl_finish.integer)
                {
-                       usingmouse = false;
-                       IN_DeactivateMouse ();
+                       qglFinish();CHECKGLERROR
                }
+               qglXSwapBuffers(vidx11_display, win);CHECKGLERROR
        }
+
+       if (vid_x11_hardwaregammasupported)
+               VID_UpdateGamma(false, vid_x11_gammarampsize);
 }
 
-int VID_SetGamma(unsigned short *ramps)
+int VID_SetGamma(unsigned short *ramps, int rampsize)
 {
-       return XF86VidModeSetGammaRamp(vidx11_display, vidx11_screen, 256, ramps, ramps + 256, ramps + 512);
+       return XF86VidModeSetGammaRamp(vidx11_display, vidx11_screen, rampsize, ramps, ramps + rampsize, ramps + rampsize*2);
 }
 
-int VID_GetGamma(unsigned short *ramps)
+int VID_GetGamma(unsigned short *ramps, int rampsize)
 {
-       return XF86VidModeGetGammaRamp(vidx11_display, vidx11_screen, 256, ramps, ramps + 256, ramps + 512);
+       return XF86VidModeGetGammaRamp(vidx11_display, vidx11_screen, rampsize, ramps, ramps + rampsize, ramps + rampsize*2);
 }
 
 void VID_Init(void)
 {
-#ifndef __APPLE__
-       Cvar_RegisterVariable (&vid_dga);
-       Cvar_RegisterVariable (&vid_dga_mouseaccel);
+#if !defined(__APPLE__) && !defined(SUNOS)
+       Cvar_RegisterVariable (&vid_dgamouse);
 #endif
+       Cvar_RegisterVariable (&vid_netwmfullscreen);
        InitSig(); // trap evil signals
-// COMMANDLINEOPTION: -nomouse disables mouse support (see also vid_mouse cvar)
-       if (COM_CheckParm ("-nomouse") || COM_CheckParm("-safe"))
+// COMMANDLINEOPTION: Input: -nomouse disables mouse support (see also vid_mouse cvar)
+       if (COM_CheckParm ("-nomouse"))
                mouse_avail = false;
 }
 
-void VID_BuildGLXAttrib(int *attrib, int stencil)
+void VID_BuildGLXAttrib(int *attrib, qboolean stencil, qboolean stereobuffer, int samples)
 {
        *attrib++ = GLX_RGBA;
-       *attrib++ = GLX_RED_SIZE;*attrib++ = 1;
-       *attrib++ = GLX_GREEN_SIZE;*attrib++ = 1;
-       *attrib++ = GLX_BLUE_SIZE;*attrib++ = 1;
+       *attrib++ = GLX_RED_SIZE;*attrib++ = stencil ? 8 : 5;
+       *attrib++ = GLX_GREEN_SIZE;*attrib++ = stencil ? 8 : 5;
+       *attrib++ = GLX_BLUE_SIZE;*attrib++ = stencil ? 8 : 5;
        *attrib++ = GLX_DOUBLEBUFFER;
-       *attrib++ = GLX_DEPTH_SIZE;*attrib++ = 1;
+       *attrib++ = GLX_DEPTH_SIZE;*attrib++ = stencil ? 24 : 16;
        // if stencil is enabled, ask for alpha too
        if (stencil)
        {
                *attrib++ = GLX_STENCIL_SIZE;*attrib++ = 8;
-               *attrib++ = GLX_ALPHA_SIZE;*attrib++ = 1;
+               *attrib++ = GLX_ALPHA_SIZE;*attrib++ = 8;
+       }
+       if (stereobuffer)
+               *attrib++ = GLX_STEREO;
+       if (samples > 1)
+       {
+               *attrib++ = GLX_SAMPLE_BUFFERS_ARB;
+               *attrib++ = 1;
+               *attrib++ = GLX_SAMPLES_ARB;
+               *attrib++ = samples;
        }
        *attrib++ = None;
 }
 
-int VID_InitMode(int fullscreen, int width, int height, int bpp)
+qboolean VID_InitMode(viddef_mode_t *mode)
 {
-       int i;
+       int i, j;
        int attrib[32];
        XSetWindowAttributes attr;
+       XClassHint *clshints;
+       XWMHints *wmhints;
+       XSizeHints *szhints;
        unsigned long mask;
-       Window root;
        XVisualInfo *visinfo;
        int MajorVersion, MinorVersion;
        const char *drivername;
+       char *xpm;
+       char **idata;
+       unsigned char *data;
+
+       vid_isfullscreen = false;
+       vid_isnetwmfullscreen = false;
+       vid_isvidmodefullscreen = false;
+       vid_isoverrideredirect = false;
 
 #if defined(__APPLE__) && defined(__MACH__)
        drivername = "/usr/X11R6/lib/libGL.1.dylib";
 #else
        drivername = "libGL.so.1";
 #endif
-// COMMANDLINEOPTION: -gl_driver <drivername> selects a GL driver library, default is libGL.so.1 (Linux/BSD) or opengl32.dll (windows) or /usr/X11R6/lib/libGL.1.dylib (MacOSX), if you don't know what this is for, you don't need it
+// COMMANDLINEOPTION: Linux GLX: -gl_driver <drivername> selects a GL driver library, default is libGL.so.1, useful only for using fxmesa or similar, if you don't know what this is for, you don't need it
+// COMMANDLINEOPTION: BSD GLX: -gl_driver <drivername> selects a GL driver library, default is libGL.so.1, useful only for using fxmesa or similar, if you don't know what this is for, you don't need it
+// LordHavoc: although this works on MacOSX, it's useless there (as there is only one system libGL)
        i = COM_CheckParm("-gl_driver");
        if (i && i < com_argc - 1)
                drivername = com_argv[i + 1];
@@ -707,6 +850,18 @@ int VID_InitMode(int fullscreen, int width, int height, int bpp)
                return false;
        }
 
+       // LordHavoc: making the close button on a window do the right thing
+       // seems to involve this mess, sigh...
+       wm_delete_window_atom = XInternAtom(vidx11_display, "WM_DELETE_WINDOW", false);
+       net_wm_state_atom = XInternAtom(vidx11_display, "_NET_WM_STATE", false);
+       net_wm_state_fullscreen_atom = XInternAtom(vidx11_display, "_NET_WM_STATE_FULLSCREEN", false);
+       net_wm_state_hidden_atom = XInternAtom(vidx11_display, "_NET_WM_STATE_HIDDEN", false);
+       net_wm_icon = XInternAtom(vidx11_display, "_NET_WM_ICON", false);
+       cardinal = XInternAtom(vidx11_display, "CARDINAL", false);
+
+       // make autorepeat send keypress/keypress/.../keyrelease instead of intervening keyrelease
+       XkbSetDetectableAutoRepeat(vidx11_display, true, NULL);
+
        vidx11_screen = DefaultScreen(vidx11_display);
        root = RootWindow(vidx11_display, vidx11_screen);
 
@@ -720,17 +875,18 @@ int VID_InitMode(int fullscreen, int width, int height, int bpp)
                vidmode_ext = true;
        }
 
-       if ((qglXChooseVisual = GL_GetProcAddress("glXChooseVisual")) == NULL
-        || (qglXCreateContext = GL_GetProcAddress("glXCreateContext")) == NULL
-        || (qglXMakeCurrent = GL_GetProcAddress("glXMakeCurrent")) == NULL
-        || (qglXSwapBuffers = GL_GetProcAddress("glXSwapBuffers")) == NULL
-        || (qglXQueryExtensionsString = GL_GetProcAddress("glXQueryExtensionsString")) == NULL)
+       if ((qglXChooseVisual = (XVisualInfo *(GLAPIENTRY *)(Display *dpy, int screen, int *attribList))GL_GetProcAddress("glXChooseVisual")) == NULL
+        || (qglXCreateContext = (GLXContext (GLAPIENTRY *)(Display *dpy, XVisualInfo *vis, GLXContext shareList, Bool direct))GL_GetProcAddress("glXCreateContext")) == NULL
+        || (qglXDestroyContext = (void (GLAPIENTRY *)(Display *dpy, GLXContext ctx))GL_GetProcAddress("glXDestroyContext")) == NULL
+        || (qglXMakeCurrent = (Bool (GLAPIENTRY *)(Display *dpy, GLXDrawable drawable, GLXContext ctx))GL_GetProcAddress("glXMakeCurrent")) == NULL
+        || (qglXSwapBuffers = (void (GLAPIENTRY *)(Display *dpy, GLXDrawable drawable))GL_GetProcAddress("glXSwapBuffers")) == NULL
+        || (qglXQueryExtensionsString = (const char *(GLAPIENTRY *)(Display *dpy, int screen))GL_GetProcAddress("glXQueryExtensionsString")) == NULL)
        {
                Con_Printf("glX functions not found in %s\n", gl_driver);
                return false;
        }
 
-       VID_BuildGLXAttrib(attrib, bpp == 32);
+       VID_BuildGLXAttrib(attrib, mode->bitsperpixel == 32, mode->stereobuffer, mode->samples);
        visinfo = qglXChooseVisual(vidx11_display, vidx11_screen, attrib);
        if (!visinfo)
        {
@@ -738,26 +894,43 @@ int VID_InitMode(int fullscreen, int width, int height, int bpp)
                return false;
        }
 
-       if (vidmode_ext)
+       if (mode->fullscreen)
        {
-               int best_fit, best_dist, dist, x, y;
+               if(vid_netwmfullscreen.integer)
+               {
+                       // TODO detect WM support
+                       vid_isnetwmfullscreen = true;
+                       vid_isfullscreen = true;
+                       // width and height will be filled in later
+                       Con_DPrintf("Using NetWM fullscreen mode\n");
+               }
 
-               // Are we going fullscreen?  If so, let's change video mode
-               if (fullscreen)
+               if(!vid_isfullscreen && vidmode_ext)
                {
+                       int best_fit, best_dist, dist, x, y;
+
+                       // Are we going fullscreen?  If so, let's change video mode
+                       XF86VidModeModeLine *current_vidmode;
+                       XF86VidModeModeInfo **vidmodes;
+                       int num_vidmodes;
+
+                       // This nice hack comes from the SDL source code
+                       current_vidmode = (XF86VidModeModeLine*)((char*)&init_vidmode + sizeof(init_vidmode.dotclock));
+                       XF86VidModeGetModeLine(vidx11_display, vidx11_screen, (int*)&init_vidmode.dotclock, current_vidmode);
+
                        XF86VidModeGetAllModeLines(vidx11_display, vidx11_screen, &num_vidmodes, &vidmodes);
-                       best_dist = 9999999;
+                       best_dist = 0;
                        best_fit = -1;
 
                        for (i = 0; i < num_vidmodes; i++)
                        {
-                               if (width > vidmodes[i]->hdisplay || height > vidmodes[i]->vdisplay)
+                               if (mode->width > vidmodes[i]->hdisplay || mode->height > vidmodes[i]->vdisplay)
                                        continue;
 
-                               x = width - vidmodes[i]->hdisplay;
-                               y = height - vidmodes[i]->vdisplay;
+                               x = mode->width - vidmodes[i]->hdisplay;
+                               y = mode->height - vidmodes[i]->vdisplay;
                                dist = (x * x) + (y * y);
-                               if (dist < best_dist)
+                               if (best_fit == -1 || dist < best_dist)
                                {
                                        best_dist = dist;
                                        best_fit = i;
@@ -769,18 +942,32 @@ int VID_InitMode(int fullscreen, int width, int height, int bpp)
                                // LordHavoc: changed from ActualWidth/ActualHeight =,
                                // to width/height =, so the window will take the full area of
                                // the mode chosen
-                               width = vidmodes[best_fit]->hdisplay;
-                               height = vidmodes[best_fit]->vdisplay;
+                               mode->width = vidmodes[best_fit]->hdisplay;
+                               mode->height = vidmodes[best_fit]->vdisplay;
 
                                // change to the mode
                                XF86VidModeSwitchToMode(vidx11_display, vidx11_screen, vidmodes[best_fit]);
-                               vidmode_active = true;
+                               memcpy(&game_vidmode, vidmodes[best_fit], sizeof(game_vidmode));
+                               vid_isvidmodefullscreen = true;
+                               vid_isfullscreen = true;
 
                                // Move the viewport to top left
                                XF86VidModeSetViewPort(vidx11_display, vidx11_screen, 0, 0);
+                               Con_DPrintf("Using XVidMode fullscreen mode at %dx%d\n", mode->width, mode->height);
                        }
-                       else
-                               fullscreen = 0;
+
+                       free(vidmodes);
+               }
+
+               if(!vid_isfullscreen)
+               {
+                       // sorry, no FS available
+                       // use the full desktop resolution
+                       vid_isfullscreen = true;
+                       // width and height will be filled in later
+                       mode->width = DisplayWidth(vidx11_display, vidx11_screen);
+                       mode->height = DisplayHeight(vidx11_display, vidx11_screen);
+                       Con_DPrintf("Using X11 fullscreen mode at %dx%d\n", mode->width, mode->height);
                }
        }
 
@@ -793,31 +980,112 @@ int VID_InitMode(int fullscreen, int width, int height, int bpp)
        // LordHavoc: save the colormap for later, too
        vidx11_colormap = attr.colormap = XCreateColormap(vidx11_display, root, visinfo->visual, AllocNone);
        attr.event_mask = X_MASK;
-       if (vidmode_active)
+
+       if (mode->fullscreen)
        {
-               mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | CWEventMask | CWOverrideRedirect;
-               attr.override_redirect = True;
-               attr.backing_store = NotUseful;
-               attr.save_under = False;
+               if(vid_isnetwmfullscreen)
+               {
+                       mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | CWEventMask;
+                       attr.backing_store = NotUseful;
+                       attr.save_under = False;
+               }
+               else
+               {
+                       mask = CWBackPixel | CWColormap | CWSaveUnder | CWBackingStore | CWEventMask | CWOverrideRedirect;
+                       attr.override_redirect = True;
+                       attr.backing_store = NotUseful;
+                       attr.save_under = False;
+                       vid_isoverrideredirect = true; // so it knows to grab
+               }
        }
        else
+       {
                mask = CWBackPixel | CWBorderPixel | CWColormap | CWEventMask;
+       }
+
+       win = XCreateWindow(vidx11_display, root, 0, 0, mode->width, mode->height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr);
 
-       win = XCreateWindow(vidx11_display, root, 0, 0, width, height, 0, visinfo->depth, InputOutput, visinfo->visual, mask, &attr);
-       XStoreName(vidx11_display, win, gamename);
+       data = loadimagepixelsbgra("darkplaces-icon", false, false, false, NULL);
+       if(data)
+       {
+               // use _NET_WM_ICON too
+               static long netwm_icon[MAX_NETWM_ICON];
+               int pos = 0;
+               int i = 1;
+
+               while(data)
+               {
+                       if(pos + 2 * image_width * image_height < MAX_NETWM_ICON)
+                       {
+                               netwm_icon[pos++] = image_width;
+                               netwm_icon[pos++] = image_height;
+                               for(i = 0; i < image_height; ++i)
+                                       for(j = 0; j < image_width; ++j)
+                                               netwm_icon[pos++] = BuffLittleLong(&data[(i*image_width+j)*4]);
+                       }
+                       else
+                       {
+                               Con_Printf("Skipping NETWM icon #%d because there is no space left\n", i);
+                       }
+                       ++i;
+                       Mem_Free(data);
+                       data = loadimagepixelsbgra(va("darkplaces-icon%d", i), false, false, false, NULL);
+               }
+               XChangeProperty(vidx11_display, win, net_wm_icon, cardinal, 32, PropModeReplace, (const unsigned char *) netwm_icon, pos);
+       }
+
+       // fallthrough for old window managers
+       xpm = (char *) FS_LoadFile("darkplaces-icon.xpm", tempmempool, false, NULL);
+       idata = NULL;
+       if(xpm)
+               idata = XPM_DecodeString(xpm);
+       if(!idata)
+               idata = ENGINE_ICON;
+
+       wmhints = XAllocWMHints();
+       if(XpmCreatePixmapFromData(vidx11_display, win,
+               idata,
+               &wmhints->icon_pixmap, &wmhints->icon_mask, NULL) == XpmSuccess)
+               wmhints->flags |= IconPixmapHint | IconMaskHint;
+
+       if(xpm)
+               Mem_Free(xpm);
+
+       clshints = XAllocClassHint();
+       clshints->res_name = strdup(gamename);
+       clshints->res_class = strdup("DarkPlaces");
+
+       szhints = XAllocSizeHints();
+       if(vid_resizable.integer == 0 && !vid_isnetwmfullscreen)
+       {
+               szhints->min_width = szhints->max_width = mode->width;
+               szhints->min_height = szhints->max_height = mode->height;
+               szhints->flags |= PMinSize | PMaxSize;
+       }
+
+       XmbSetWMProperties(vidx11_display, win, gamename, gamename, (char **) com_argv, com_argc, szhints, wmhints, clshints);
+       // strdup() allocates using malloc(), should be freed with free()
+       free(clshints->res_name);
+       free(clshints->res_class);
+       XFree(clshints);
+       XFree(wmhints);
+       XFree(szhints);
+
+       //XStoreName(vidx11_display, win, gamename);
        XMapWindow(vidx11_display, win);
 
-       // LordHavoc: making the close button on a window do the right thing
-       // seems to involve this mess, sigh...
-       wm_delete_window_atom = XInternAtom(vidx11_display, "WM_DELETE_WINDOW", false);
        XSetWMProtocols(vidx11_display, win, &wm_delete_window_atom, 1);
 
-       if (vidmode_active)
+       if (vid_isoverrideredirect)
        {
                XMoveWindow(vidx11_display, win, 0, 0);
                XRaiseWindow(vidx11_display, win);
                XWarpPointer(vidx11_display, None, win, 0, 0, 0, 0, 0, 0);
                XFlush(vidx11_display);
+       }
+
+       if(vid_isvidmodefullscreen)
+       {
                // Move the viewport to top left
                XF86VidModeSetViewPort(vidx11_display, vidx11_screen, 0, 0);
        }
@@ -825,97 +1093,121 @@ int VID_InitMode(int fullscreen, int width, int height, int bpp)
        //XSync(vidx11_display, False);
 
        ctx = qglXCreateContext(vidx11_display, visinfo, NULL, True);
+       XFree(visinfo); // glXChooseVisual man page says to use XFree to free visinfo
        if (!ctx)
-               Sys_Error ("glXCreateContext failed\n");
+       {
+               Con_Printf ("glXCreateContext failed\n");
+               return false;
+       }
 
        if (!qglXMakeCurrent(vidx11_display, win, ctx))
-               Sys_Error ("glXMakeCurrent failed\n");
+       {
+               Con_Printf ("glXMakeCurrent failed\n");
+               return false;
+       }
 
        XSync(vidx11_display, False);
 
-       scr_width = width;
-       scr_height = height;
-
-       if ((qglGetString = GL_GetProcAddress("glGetString")) == NULL)
-               Sys_Error("glGetString not found in %s", gl_driver);
+       if ((qglGetString = (const GLubyte* (GLAPIENTRY *)(GLenum name))GL_GetProcAddress("glGetString")) == NULL)
+       {
+               Con_Printf ("glGetString not found in %s\n", gl_driver);
+               return false;
+       }
 
-       gl_renderer = qglGetString(GL_RENDERER);
-       gl_vendor = qglGetString(GL_VENDOR);
-       gl_version = qglGetString(GL_VERSION);
-       gl_extensions = qglGetString(GL_EXTENSIONS);
+       gl_extensions = (const char *)qglGetString(GL_EXTENSIONS);
        gl_platform = "GLX";
        gl_platformextensions = qglXQueryExtensionsString(vidx11_display, vidx11_screen);
 
-       gl_videosyncavailable = false;
-
-// COMMANDLINEOPTION: -nogetprocaddress disables GLX_ARB_get_proc_address (not required, more formal method of getting extension functions)
+// COMMANDLINEOPTION: Linux GLX: -nogetprocaddress disables GLX_ARB_get_proc_address (not required, more formal method of getting extension functions)
+// COMMANDLINEOPTION: BSD GLX: -nogetprocaddress disables GLX_ARB_get_proc_address (not required, more formal method of getting extension functions)
+// COMMANDLINEOPTION: MacOSX GLX: -nogetprocaddress disables GLX_ARB_get_proc_address (not required, more formal method of getting extension functions)
        GL_CheckExtension("GLX_ARB_get_proc_address", getprocaddressfuncs, "-nogetprocaddress", false);
-// COMMANDLINEOPTION: -novideosync disables GLX_SGI_video_sync (required for video sync control on GLX)
-       gl_videosyncavailable = GL_CheckExtension("GLX_SGI_video_sync", videosyncfuncs, "-novideosync", false);
-
-       usingmouse = false;
+// COMMANDLINEOPTION: Linux GLX: -novideosync disables GLX_SGI_swap_control
+// COMMANDLINEOPTION: BSD GLX: -novideosync disables GLX_SGI_swap_control
+// COMMANDLINEOPTION: MacOSX GLX: -novideosync disables GLX_SGI_swap_control
+       GL_CheckExtension("GLX_SGI_swap_control", swapcontrolfuncs, "-novideosync", false);
+
+       vid_usingmousegrab = false;
+       vid_usingmouse = false;
+       vid_usinghidecursor = false;
+       vid_usingvsync = false;
        vid_hidden = false;
        vid_activewindow = true;
+       vid_x11_hardwaregammasupported = XF86VidModeGetGammaRampSize(vidx11_display, vidx11_screen, &vid_x11_gammarampsize) != 0;
+#if !defined(__APPLE__) && !defined(SUNOS)
+       vid_x11_dgasupported = XF86DGAQueryVersion(vidx11_display, &MajorVersion, &MinorVersion);
+       if (!vid_x11_dgasupported)
+               Con_Print( "Failed to detect XF86DGA Mouse extension\n" );
+#endif
+
        GL_Init();
        return true;
 }
 
 void Sys_SendKeyEvents(void)
 {
-       HandleEvents();
-}
+       static qboolean sound_active = true;
 
-/*
-===========
-IN_Commands
-===========
-*/
-void IN_Commands (void)
-{
-}
-
-void IN_Move (usercmd_t *cmd)
-{
-       if (mouse_avail)
-               IN_Mouse(cmd, mouse_x, mouse_y);
-       mouse_x = 0;
-       mouse_y = 0;
-}
-
-static void *prjobj = NULL;
-
-int GL_OpenLibrary(const char *name)
-{
-       Con_Printf("Loading OpenGL driver %s\n", name);
-       GL_CloseLibrary();
-       if (!(prjobj = dlopen(name, RTLD_LAZY)))
+       // enable/disable sound on focus gain/loss
+       if ((!vid_hidden && vid_activewindow) || !snd_mutewhenidle.integer)
        {
-               Con_Printf("Unable to open symbol list for %s\n", name);
-               return false;
+               if (!sound_active)
+               {
+                       S_UnblockSound ();
+                       sound_active = true;
+               }
        }
-       strcpy(gl_driver, name);
-       return true;
+       else
+       {
+               if (sound_active)
+               {
+                       S_BlockSound ();
+                       sound_active = false;
+               }
+       }
+
+       HandleEvents();
 }
 
-void GL_CloseLibrary(void)
+void IN_Move (void)
 {
-       if (prjobj)
-               dlclose(prjobj);
-       prjobj = NULL;
-       gl_driver[0] = 0;
-       qglXGetProcAddressARB = NULL;
-       gl_extensions = "";
-       gl_platform = "";
-       gl_platformextensions = "";
 }
 
-void *GL_GetProcAddress(const char *name)
+size_t VID_ListModes(vid_mode_t *modes, size_t maxcount)
 {
-       void *p = NULL;
-       if (qglXGetProcAddressARB != NULL)
-               p = (void *) qglXGetProcAddressARB(name);
-       if (p == NULL)
-               p = (void *) dlsym(prjobj, name);
-       return p;
+       if(vidmode_ext)
+       {
+               int i, bpp;
+               size_t k;
+               XF86VidModeModeInfo **vidmodes;
+               int num_vidmodes;
+
+               XF86VidModeGetAllModeLines(vidx11_display, vidx11_screen, &num_vidmodes, &vidmodes);
+               k = 0;
+               for (i = 0; i < num_vidmodes; i++)
+               {
+                       if(k >= maxcount)
+                               break;
+                       // we don't get bpp info, so let's just assume all of 8, 15, 16, 24, 32 work
+                       for(bpp = 8; bpp <= 32; bpp = ((bpp == 8) ? 15 : (bpp & 0xF8) + 8))
+                       {
+                               if(k >= maxcount)
+                                       break;
+                               modes[k].width = vidmodes[i]->hdisplay;
+                               modes[k].height = vidmodes[i]->vdisplay;
+                               modes[k].bpp = 8;
+                               if(vidmodes[i]->dotclock && vidmodes[i]->htotal && vidmodes[i]->vtotal)
+                                       modes[k].refreshrate = vidmodes[i]->dotclock / vidmodes[i]->htotal / vidmodes[i]->vtotal;
+                               else
+                                       modes[k].refreshrate = 60;
+                               modes[k].pixelheight_num = 1;
+                               modes[k].pixelheight_denom = 1; // xvidmode does not provide this
+                               ++k;
+                       }
+               }
+               // manpage of XF86VidModeGetAllModeLines says it should be freed by the caller
+               XFree(vidmodes);
+               return k;
+       }
+       return 0; // FIXME implement this
 }
-