warsow-openbox/warsowopenboxfs.patch

   1 diff -ru a/unix/unix_glw.c b/unix/unix_glw.c
   2 --- a/unix/unix_glw.c   2011-04-29 14:42:24.000000000 +0200
   3 +++ b/unix/unix_glw.c   2011-10-03 22:11:02.000000000 +0200
   4 @@ -1,941 +1,1070 @@
   5 -/*
   6 -   Copyright (C) 1997-2001 Id Software, Inc.
   7 -
   8 -   This program is free software; you can redistribute it and/or
   9 -   modify it under the terms of the GNU General Public License
  10 -   as published by the Free Software Foundation; either version 2
  11 -   of the License, or (at your option) any later version.
  12 -
  13 -   This program is distributed in the hope that it will be useful,
  14 -   but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 -   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  16 -
  17 -   See the GNU General Public License for more details.
  18 -
  19 -   You should have received a copy of the GNU General Public License
  20 -   along with this program; if not, write to the Free Software
  21 -   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  22 -
  23 - */
  24 -/*
  25 -** GLW_IMP.C
  26 -**
  27 -** This file contains ALL Linux specific stuff having to do with the
  28 -** OpenGL refresh.  When a port is being made the following functions
  29 -** must be implemented by the port:
  30 -**
  31 -** GLimp_EndFrame
  32 -** GLimp_Init
  33 -** GLimp_Shutdown
  34 -** GLimp_SwitchFullscreen
  35 -**
  36 -*/
  37 -
  38 -#include <termios.h>
  39 -#include <sys/ioctl.h>
  40 -#include <sys/stat.h>
  41 -#include <stdarg.h>
  42 -#include <stdio.h>
  43 -#include <unistd.h>
  44 -#include <signal.h>
  45 -#include <dlfcn.h>
  46 -
  47 -#include "../ref_gl/r_local.h"
  48 -#include "../client/keys.h"
  49 -
  50 -#include "x11.h"
  51 -
  52 -#include "unix_glw.h"
  53 -
  54 -#define DISPLAY_MASK ( VisibilityChangeMask | StructureNotifyMask | ExposureMask | PropertyChangeMask )
  55 -#define INIT_MASK ( KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask | DISPLAY_MASK )
  56 -
  57 -x11display_t x11display;
  58 -
  59 -glwstate_t glw_state;
  60 -
  61 -static qboolean _xf86_vidmodes_supported = qfalse;
  62 -static int default_dotclock, default_viewport[2];
  63 -static XF86VidModeModeLine default_modeline;
  64 -static XF86VidModeModeInfo **_xf86_vidmodes;
  65 -static int _xf86_vidmodes_num;
  66 -static qboolean _xf86_vidmodes_active = qfalse;
  67 -static qboolean _xf86_xinerama_supported = qfalse;
  68 -
  69 -static void _xf86_VidmodesInit( void )
  70 -{
  71 -       int MajorVersion = 0, MinorVersion = 0;
  72 -
  73 -       // Get video mode list
  74 -       if( XF86VidModeQueryVersion( x11display.dpy, &MajorVersion, &MinorVersion ) )
  75 -       {
  76 -               Com_Printf( "..XFree86-VidMode Extension Version %d.%d\n", MajorVersion, MinorVersion );
  77 -               XF86VidModeGetViewPort( x11display.dpy, x11display.scr, &default_viewport[0], &default_viewport[1] );
  78 -               XF86VidModeGetModeLine( x11display.dpy, x11display.scr, &default_dotclock, &default_modeline );
  79 -               XF86VidModeGetAllModeLines( x11display.dpy, x11display.scr, &_xf86_vidmodes_num, &_xf86_vidmodes );
  80 -               _xf86_vidmodes_supported = qtrue;
  81 -       }
  82 -       else
  83 -       {
  84 -               Com_Printf( "..XFree86-VidMode Extension not available\n" );
  85 -               _xf86_vidmodes_supported = qfalse;
  86 -       }
  87 -}
  88 -
  89 -static void _xf86_VidmodesFree( void )
  90 -{
  91 -       if( _xf86_vidmodes_supported ) XFree( _xf86_vidmodes );
  92 -
  93 -       _xf86_vidmodes_supported = qfalse;
  94 -}
  95 -
  96 -static void _xf86_XineramaInit( void )
  97 -{
  98 -       int MajorVersion = 0, MinorVersion = 0;
  99 -
 100 -       if( ( XineramaQueryVersion( x11display.dpy, &MajorVersion, &MinorVersion ) ) && ( XineramaIsActive( x11display.dpy ) ) )
 101 -       {
 102 -               Com_Printf( "..XFree86-Xinerama Extension Version %d.%d\n", MajorVersion, MinorVersion );
 103 -               _xf86_xinerama_supported = qtrue;
 104 -       }
 105 -       else
 106 -       {
 107 -               Com_Printf( "..XFree86-Xinerama Extension not available\n" );
 108 -               _xf86_xinerama_supported = qfalse;
 109 -       }
 110 -}
 111 -
 112 -static void _xf86_XineramaFree( void )
 113 -{
 114 -       _xf86_xinerama_supported = qfalse;
 115 -}
 116 -
 117 -static qboolean _xf86_XineramaFindBest( int *x, int *y, int *width, int *height, qboolean silent )
 118 -{
 119 -       int i, screens, head;
 120 -       int best_dist, dist;
 121 -       XineramaScreenInfo *xinerama;
 122 -
 123 -       assert( _xf86_xinerama_supported );
 124 -
 125 -       if( vid_multiscreen_head->integer == 0 )
 126 -               return qfalse;
 127 -
 128 -       xinerama = XineramaQueryScreens( x11display.dpy, &screens );
 129 -       if( screens <= 1 )
 130 -               return qfalse;
 131 -
 132 -       head = -1;
 133 -       if( vid_multiscreen_head->integer > 0 )
 134 -       {
 135 -               for( i = 0; i < screens; i++ )
 136 -               {
 137 -                       if( xinerama[i].screen_number == vid_multiscreen_head->integer - 1 )
 138 -                       {
 139 -                               head = i;
 140 -                               break;
 141 -                       }
 142 -               }
 143 -               if( head == -1 && !silent )
 144 -                       Com_Printf( "Xinerama: Head %i not found, using best fit\n", vid_multiscreen_head->integer );
 145 -               if( *width > xinerama[head].width || *height > xinerama[head].height )
 146 -               {
 147 -                       head = -1;
 148 -                       if( !silent )
 149 -                               Com_Printf( "Xinerama: Window doesn't fit into head %i, using best fit\n", vid_multiscreen_head->integer );
 150 -               }
 151 -       }
 152 -
 153 -       if( head == -1 ) // find best fit
 154 -       {
 155 -               best_dist = 999999999;
 156 -               for( i = 0; i < screens; i++ )
 157 -               {
 158 -                       if( *width <= xinerama[i].width && *height <= xinerama[i].height )
 159 -                       {
 160 -                               if( xinerama[i].width - *width > xinerama[i].height - *height )
 161 -                               {
 162 -                                       dist = xinerama[i].height - *height;
 163 -                               }
 164 -                               else
 165 -                               {
 166 -                                       dist = xinerama[i].width - *width;
 167 -                               }
 168 -
 169 -                               if( dist < 0 )
 170 -                                       dist = -dist; // Only positive number please
 171 -
 172 -                               if( dist < best_dist )
 173 -                               {
 174 -                                       best_dist = dist;
 175 -                                       head = i;
 176 -                               }
 177 -                       }
 178 -               }
 179 -               if( head < -1 )
 180 -               {
 181 -                       if( !silent )
 182 -                               Com_Printf( "Xinerama: No fitting head found" );
 183 -                       return qfalse;
 184 -               }
 185 -       }
 186 -
 187 -       *x = xinerama[head].x_org;
 188 -       *y = xinerama[head].y_org;
 189 -       *width = xinerama[head].width;
 190 -       *height = xinerama[head].height;
 191 -
 192 -       if( !silent )
 193 -               Com_Printf( "Xinerama: Using screen %d: %dx%d+%d+%d\n", xinerama[head].screen_number, xinerama[head].width, xinerama[head].height, xinerama[head].x_org, xinerama[head].y_org );
 194 -
 195 -       return qtrue;
 196 -}
 197 -
 198 -static void _xf86_VidmodesSwitch( int mode )
 199 -{
 200 -       if( _xf86_vidmodes_supported )
 201 -       {
 202 -               XF86VidModeSwitchToMode( x11display.dpy, x11display.scr, _xf86_vidmodes[mode] );
 203 -               XF86VidModeSetViewPort( x11display.dpy, x11display.scr, 0, 0 );
 204 -       }
 205 -
 206 -       _xf86_vidmodes_active = qtrue;
 207 -}
 208 -
 209 -static void _xf86_VidmodesSwitchBack( void )
 210 -{
 211 -       if( _xf86_vidmodes_supported && _xf86_vidmodes_active )
 212 -       {
 213 -               XF86VidModeModeInfo modeinfo;
 214 -
 215 -               modeinfo.dotclock = default_dotclock;
 216 -               modeinfo.hdisplay = default_modeline.hdisplay;
 217 -               modeinfo.hsyncstart = default_modeline.hsyncstart;
 218 -               modeinfo.hsyncend = default_modeline.hsyncend;
 219 -               modeinfo.htotal = default_modeline.htotal;
 220 -               modeinfo.vdisplay = default_modeline.vdisplay;
 221 -               modeinfo.vsyncstart = default_modeline.vsyncstart;
 222 -               modeinfo.vsyncend = default_modeline.vsyncend;
 223 -               modeinfo.vtotal = default_modeline.vtotal;
 224 -               modeinfo.flags = default_modeline.flags;
 225 -               modeinfo.privsize = default_modeline.privsize;
 226 -               modeinfo.private = default_modeline.private;
 227 -
 228 -               XF86VidModeSwitchToMode( x11display.dpy, x11display.scr, &modeinfo );
 229 -               XF86VidModeSetViewPort( x11display.dpy, x11display.scr, default_viewport[0], default_viewport[1] );
 230 -       }
 231 -
 232 -       _xf86_vidmodes_active = qfalse;
 233 -}
 234 -
 235 -static void _xf86_VidmodesFindBest( int *mode, int *pwidth, int *pheight, qboolean silent )
 236 -{
 237 -       int i, best_fit, best_dist, dist, x, y;
 238 -
 239 -       best_fit = -1;
 240 -       best_dist = 999999999;
 241 -
 242 -       if( _xf86_vidmodes_supported )
 243 -       {
 244 -               for( i = 0; i < _xf86_vidmodes_num; i++ )
 245 -               {
 246 -                       if( _xf86_vidmodes[i]->hdisplay < *pwidth || _xf86_vidmodes[i]->vdisplay < *pheight )
 247 -                               continue;
 248 -
 249 -                       x = _xf86_vidmodes[i]->hdisplay - *pwidth;
 250 -                       y = _xf86_vidmodes[i]->vdisplay - *pheight;
 251 -
 252 -                       if( x > y ) dist = y;
 253 -                       else dist = x;
 254 -
 255 -                       if( dist < 0 ) dist = -dist; // Only positive number please
 256 -
 257 -                       if( dist < best_dist )
 258 -                       {
 259 -                               best_dist = dist;
 260 -                               best_fit = i;
 261 -                       }
 262 -
 263 -                       if( !silent )
 264 -                               Com_Printf( "%ix%i -> %ix%i: %i\n", *pwidth, *pheight, _xf86_vidmodes[i]->hdisplay, _xf86_vidmodes[i]->vdisplay, dist );
 265 -               }
 266 -
 267 -               if( best_fit >= 0 )
 268 -               {
 269 -                       if( !silent )
 270 -                               Com_Printf( "%ix%i selected\n", _xf86_vidmodes[best_fit]->hdisplay, _xf86_vidmodes[best_fit]->vdisplay );
 271 -
 272 -                       *pwidth = _xf86_vidmodes[best_fit]->hdisplay;
 273 -                       *pheight = _xf86_vidmodes[best_fit]->vdisplay;
 274 -               }
 275 -       }
 276 -
 277 -       *mode = best_fit;
 278 -}
 279 -
 280 -static void _x11_SetNoResize( Window w, int width, int height )
 281 -{
 282 -       XSizeHints *hints;
 283 -
 284 -       if( x11display.dpy )
 285 -       {
 286 -               hints = XAllocSizeHints();
 287 -
 288 -               if( hints )
 289 -               {
 290 -                       hints->min_width = hints->max_width = width;
 291 -                       hints->min_height = hints->max_height = height;
 292 -
 293 -                       hints->flags = PMaxSize | PMinSize;
 294 -
 295 -                       XSetWMNormalHints( x11display.dpy, w, hints );
 296 -                       XFree( hints );
 297 -               }
 298 -       }
 299 -}
 300 -
 301 -/*****************************************************************************/
 302 -
 303 -/*
 304 -   =================
 305 -   Sys_GetClipboardData
 306 -
 307 -   Orginally from EzQuake
 308 -   There should be a smarter place to put this
 309 -   =================
 310 - */
 311 -char *Sys_GetClipboardData( qboolean primary )
 312 -{
 313 -       Window win;
 314 -       Atom type;
 315 -       int format, ret;
 316 -       unsigned long nitems, bytes_after, bytes_left;
 317 -       unsigned char *data;
 318 -       char *buffer;
 319 -       Atom atom;
 320 -
 321 -       if( !x11display.dpy )
 322 -               return NULL;
 323 -
 324 -       if( primary )
 325 -       {
 326 -               atom = XInternAtom( x11display.dpy, "PRIMARY", True );
 327 -       }
 328 -       else
 329 -       {
 330 -               atom = XInternAtom( x11display.dpy, "CLIPBOARD", True );
 331 -       }
 332 -       if( atom == None )
 333 -               return NULL;
 334 -
 335 -       win = XGetSelectionOwner( x11display.dpy, atom );
 336 -       if( win == None )
 337 -               return NULL;
 338 -
 339 -       XConvertSelection( x11display.dpy, atom, XA_STRING, atom, win, CurrentTime );
 340 -       XFlush( x11display.dpy );
 341 -
 342 -       XGetWindowProperty( x11display.dpy, win, atom, 0, 0, False, AnyPropertyType, &type, &format, &nitems, &bytes_left,
 343 -                           &data );
 344 -       if( bytes_left <= 0 )
 345 -               return NULL;
 346 -
 347 -       ret = XGetWindowProperty( x11display.dpy, win, atom, 0, bytes_left, False, AnyPropertyType, &type,
 348 -                                 &format, &nitems, &bytes_after, &data );
 349 -       if( ret == Success )
 350 -       {
 351 -               buffer = Q_malloc( bytes_left + 1 );
 352 -               Q_strncpyz( buffer, (char *)data, bytes_left + 1 );
 353 -       }
 354 -       else
 355 -       {
 356 -               buffer = NULL;
 357 -       }
 358 -
 359 -       XFree( data );
 360 -
 361 -       return buffer;
 362 -}
 363 -
 364 -
 365 -/*
 366 -* Sys_SetClipboardData
 367 -*/
 368 -qboolean Sys_SetClipboardData( char *data )
 369 -{
 370 -       return qfalse;
 371 -}
 372 -
 373 -/*
 374 -   =================
 375 -   Sys_FreeClipboardData
 376 -   =================
 377 - */
 378 -void Sys_FreeClipboardData( char *data )
 379 -{
 380 -       Q_free( data );
 381 -}
 382 -
 383 -/*
 384 -* _NET_WM_CHECK_SUPPORTED
 385 -*/
 386 -static qboolean _NET_WM_CHECK_SUPPORTED( Atom NET_ATOM )
 387 -{
 388 -       qboolean issupported = qfalse;
 389 -       unsigned char *atomdata;
 390 -       Atom *atoms;
 391 -       int status, real_format;
 392 -       Atom real_type;
 393 -       unsigned long items_read, items_left, i;
 394 -       int result = 1;
 395 -       Atom _NET_SUPPORTED;
 396 -
 397 -       _NET_SUPPORTED = XInternAtom( x11display.dpy, "_NET_SUPPORTED", 0 );
 398 -
 399 -       status = XGetWindowProperty( x11display.dpy, x11display.root, _NET_SUPPORTED,
 400 -               0L, 8192L, False, XA_ATOM, &real_type, &real_format,
 401 -               &items_read, &items_left, &atomdata );
 402 -
 403 -       if( status != Success )
 404 -               return qfalse;
 405 -
 406 -       atoms = (Atom *)atomdata;
 407 -       for( i = 0; result && i < items_read; i++ )
 408 -       {
 409 -               if( atoms[i] == NET_ATOM )
 410 -               {
 411 -                       issupported = qtrue;
 412 -                       break;
 413 -               }
 414 -       }
 415 -
 416 -       XFree( atomdata );
 417 -       return issupported;
 418 -}
 419 -
 420 -/*
 421 -* _NET_WM_STATE_FULLSCREEN_SUPPORTED
 422 -*/
 423 -static qboolean _NET_WM_STATE_FULLSCREEN_SUPPORTED( void )
 424 -{
 425 -       Atom _NET_WM_STATE_FULLSCREEN = XInternAtom( x11display.dpy, "_NET_WM_STATE_FULLSCREEN", 0 );
 426 -       return _NET_WM_CHECK_SUPPORTED( _NET_WM_STATE_FULLSCREEN );
 427 -
 428 -}
 429 -
 430 -/*
 431 -* _NETWM_CHECK_FULLSCREEN
 432 -*/
 433 -qboolean _NETWM_CHECK_FULLSCREEN( void )
 434 -{
 435 -       qboolean isfullscreen = qfalse;
 436 -       unsigned char *atomdata;
 437 -       Atom *atoms;
 438 -       int status, real_format;
 439 -       Atom real_type;
 440 -       unsigned long items_read, items_left, i;
 441 -       int result = 1;
 442 -       Atom _NET_WM_STATE;
 443 -       Atom _NET_WM_STATE_FULLSCREEN;
 444 -
 445 -       if( !x11display.features.wmStateFullscreen )
 446 -               return qfalse;
 447 -
 448 -       _NET_WM_STATE = XInternAtom( x11display.dpy, "_NET_WM_STATE", 0 );
 449 -       _NET_WM_STATE_FULLSCREEN = XInternAtom( x11display.dpy, "_NET_WM_STATE_FULLSCREEN", 0 );
 450 -
 451 -       status = XGetWindowProperty( x11display.dpy, x11display.win, _NET_WM_STATE,
 452 -               0L, 8192L, False, XA_ATOM, &real_type, &real_format,
 453 -               &items_read, &items_left, &atomdata );
 454 -
 455 -       if( status != Success )
 456 -               return qfalse;
 457 -
 458 -       atoms = (Atom *)atomdata;
 459 -       for( i = 0; result && i < items_read; i++ )
 460 -       {
 461 -               if( atoms[i] == _NET_WM_STATE_FULLSCREEN )
 462 -               {
 463 -                       isfullscreen = qtrue;
 464 -                       break;
 465 -               }
 466 -       }
 467 -
 468 -       if( isfullscreen )
 469 -       {
 470 -               Cvar_SetValue( "vid_fullscreen", 1 );
 471 -               vid_fullscreen->modified = qfalse;
 472 -       }
 473 -       else
 474 -       {
 475 -               Cvar_SetValue( "vid_fullscreen", 0 );
 476 -               vid_fullscreen->modified = qfalse;
 477 -       }
 478 -
 479 -       XFree( atomdata );
 480 -       return isfullscreen;
 481 -}
 482 -
 483 -/*
 484 -* _NETWM_SET_FULLSCREEN
 485 -*
 486 -* Tell Window-Manager to toggle fullscreen
 487 -*/
 488 -void _NETWM_SET_FULLSCREEN( qboolean fullscreen )
 489 -{
 490 -       XEvent xev;
 491 -       Atom wm_state;
 492 -       Atom wm_fullscreen;
 493 -
 494 -       if( !x11display.features.wmStateFullscreen )
 495 -               return;
 496 -
 497 -       wm_state = XInternAtom( x11display.dpy, "_NET_WM_STATE", False );
 498 -       wm_fullscreen = XInternAtom( x11display.dpy, "_NET_WM_STATE_FULLSCREEN", False );
 499 -
 500 -       memset(&xev, 0, sizeof(xev));
 501 -       xev.type = ClientMessage;
 502 -       xev.xclient.window = x11display.win;
 503 -       xev.xclient.message_type = wm_state;
 504 -       xev.xclient.format = 32;
 505 -       xev.xclient.data.l[0] = fullscreen ? 1 : 0;
 506 -       xev.xclient.data.l[1] = wm_fullscreen;
 507 -       xev.xclient.data.l[2] = 0;
 508 -
 509 -       XSendEvent( x11display.dpy, DefaultRootWindow( x11display.dpy ), False,
 510 -               SubstructureNotifyMask, &xev );
 511 -}
 512 -
 513 -/*****************************************************************************/
 514 -
 515 -static void GLimp_SetXPMIcon( const int *xpm_icon )
 516 -{
 517 -       int width, height;
 518 -       size_t i, cardinalSize;
 519 -       long *cardinalData;
 520 -       Atom NET_WM_ICON;
 521 -       Atom CARDINAL;
 522 -
 523 -       // allocate memory for icon data: width + height + width * height pixels
 524 -        // note: sizeof(long) shall be used according to XChangeProperty() man page
 525 -       width = xpm_icon[0];
 526 -       height = xpm_icon[1];
 527 -       cardinalSize = width * height + 2;
 528 -       cardinalData = Q_malloc( cardinalSize * sizeof( *cardinalData ) );
 529 -       for( i = 0; i < cardinalSize; i++ )
 530 -               cardinalData[i] = xpm_icon[i];
 531 -
 532 -       NET_WM_ICON = XInternAtom( x11display.dpy, "_NET_WM_ICON", False );
 533 -       CARDINAL = XInternAtom( x11display.dpy, "CARDINAL", False );
 534 -
 535 -       XChangeProperty( x11display.dpy, x11display.win, NET_WM_ICON, CARDINAL, 32,
 536 -               PropModeReplace, (unsigned char *)cardinalData, cardinalSize );
 537 -
 538 -       Q_free( cardinalData );
 539 -}
 540 -
 541 -int *parse_xpm_icon ( int num_xpm_elements, char *xpm_data[] );
 542 -
 543 -static void GLimp_SetApplicationIcon( void )
 544 -{
 545 -       #include "warsow128x128.xpm"
 546 -
 547 -       const int *xpm_icon;
 548 -
 549 -       xpm_icon = parse_xpm_icon( sizeof( warsow128x128_xpm ) / sizeof( warsow128x128_xpm[0] ), warsow128x128_xpm );
 550 -       if( xpm_icon )
 551 -       {
 552 -               GLimp_SetXPMIcon( xpm_icon );
 553 -               free( ( void * )xpm_icon );
 554 -       }
 555 -}
 556 -
 557 -/*****************************************************************************/
 558 -
 559 -/*
 560 -** GLimp_SetMode_Real
 561 -* Hack to get rid of the prints when toggling fullscreen
 562 -*/
 563 -int GLimp_SetMode_Real( int mode, qboolean fullscreen, qboolean silent )
 564 -{
 565 -       int width, height, screen_x, screen_y, screen_width, screen_height, screen_mode;
 566 -       float ratio;
 567 -       XSetWindowAttributes wa;
 568 -       unsigned long mask;
 569 -       qboolean wideScreen;
 570 -
 571 -       if( !VID_GetModeInfo( &width, &height, &wideScreen, mode ) )
 572 -       {
 573 -               if( !silent )
 574 -                       Com_Printf( " invalid mode\n" );
 575 -               return rserr_invalid_mode;
 576 -       }
 577 -
 578 -       screen_mode = -1;
 579 -       screen_x = screen_y = 0;
 580 -       screen_width = width;
 581 -       screen_height = height;
 582 -
 583 -       x11display.old_win = x11display.win;
 584 -
 585 -       if( fullscreen )
 586 -       {
 587 -               if( !_xf86_xinerama_supported ||
 588 -                  !_xf86_XineramaFindBest( &screen_x, &screen_y, &screen_width, &screen_height, silent ) )
 589 -               {
 590 -                       _xf86_VidmodesFindBest( &screen_mode, &screen_width, &screen_height, silent );
 591 -                       if( screen_mode < 0 )
 592 -                       {
 593 -                               if( !silent )
 594 -                                       Com_Printf( " no mode found\n" );
 595 -                               return rserr_invalid_mode;
 596 -                       }
 597 -               }
 598 -
 599 -               if( screen_width < width || screen_height < height )
 600 -               {
 601 -                       if( width > height )
 602 -                       {
 603 -                               ratio = width / height;
 604 -                               height = height * ratio;
 605 -                               width = screen_width;
 606 -                       }
 607 -                       else
 608 -                       {
 609 -                               ratio = height / width;
 610 -                               width = width * ratio;
 611 -                               height = screen_height;
 612 -                       }
 613 -               }
 614 -
 615 -               if( !silent )
 616 -                       Com_Printf( "...setting fullscreen mode %d:\n", mode );
 617 -
 618 -               /* Create fulscreen window */
 619 -               wa.background_pixel = 0;
 620 -               wa.border_pixel = 0;
 621 -               wa.event_mask = INIT_MASK;
 622 -               wa.backing_store = NotUseful;
 623 -               wa.save_under = False;
 624 -
 625 -               if( x11display.features.wmStateFullscreen )
 626 -               {
 627 -                       wa.override_redirect = False;
 628 -                       mask = CWBackPixel | CWBorderPixel | CWEventMask | CWSaveUnder | CWBackingStore;
 629 -               }
 630 -               else
 631 -               {
 632 -                       wa.override_redirect = True;
 633 -                       mask = CWBackPixel | CWBorderPixel | CWEventMask | CWSaveUnder | CWBackingStore | CWOverrideRedirect;
 634 -               }
 635 -
 636 -               x11display.win = XCreateWindow( x11display.dpy, x11display.root, screen_x, screen_y, screen_width, screen_height,
 637 -                                               0, CopyFromParent, InputOutput, CopyFromParent, mask, &wa );
 638 -
 639 -               XResizeWindow( x11display.dpy, x11display.gl_win, width, height );
 640 -               XReparentWindow( x11display.dpy, x11display.gl_win, x11display.win, ( screen_width/2 )-( width/2 ),
 641 -                               ( screen_height/2 )-( height/2 ) );
 642 -
 643 -               x11display.modeset = qtrue;
 644 -
 645 -               XMapWindow( x11display.dpy, x11display.gl_win );
 646 -               XMapWindow( x11display.dpy, x11display.win );
 647 -
 648 -               if ( !x11display.features.wmStateFullscreen )
 649 -                       _x11_SetNoResize( x11display.win, width, height );
 650 -               else
 651 -                       _NETWM_SET_FULLSCREEN( qtrue );
 652 -
 653 -               if( screen_mode != -1 )
 654 -                       _xf86_VidmodesSwitch( screen_mode );
 655 -       }
 656 -       else
 657 -       {
 658 -               if( !silent )
 659 -                       Com_Printf( "...setting mode %d:\n", mode );
 660 -
 661 -               /* Create managed window */
 662 -               wa.background_pixel = 0;
 663 -               wa.border_pixel = 0;
 664 -               wa.event_mask = INIT_MASK;
 665 -               mask = CWBackPixel | CWBorderPixel | CWEventMask;
 666 -
 667 -               x11display.win = XCreateWindow( x11display.dpy, x11display.root, 0, 0, screen_width, screen_height,
 668 -                                               0, CopyFromParent, InputOutput, CopyFromParent, mask, &wa );
 669 -               x11display.wmDeleteWindow = XInternAtom( x11display.dpy, "WM_DELETE_WINDOW", False );
 670 -               XSetWMProtocols( x11display.dpy, x11display.win, &x11display.wmDeleteWindow, 1 );
 671 -
 672 -               XResizeWindow( x11display.dpy, x11display.gl_win, width, height );
 673 -               XReparentWindow( x11display.dpy, x11display.gl_win, x11display.win, 0, 0 );
 674 -
 675 -               x11display.modeset = qtrue;
 676 -
 677 -               XMapWindow( x11display.dpy, x11display.gl_win );
 678 -               XMapWindow( x11display.dpy, x11display.win );
 679 -
 680 -               if( !x11display.features.wmStateFullscreen )
 681 -                       _x11_SetNoResize( x11display.win, width, height );
 682 -
 683 -               _xf86_VidmodesSwitchBack();
 684 -       }
 685 -
 686 -       XSetStandardProperties( x11display.dpy, x11display.win, APPLICATION, None, None, NULL, 0, NULL );
 687 -
 688 -       GLimp_SetApplicationIcon();
 689 -
 690 -       XSetIconName( x11display.dpy, x11display.win, APPLICATION );
 691 -       XStoreName( x11display.dpy, x11display.win, APPLICATION );
 692 -
 693 -       // save the parent window size for mouse use. this is not the gl context window
 694 -       x11display.win_width = width;
 695 -       x11display.win_height = height;
 696 -
 697 -       if( x11display.old_win )
 698 -       {
 699 -               XDestroyWindow( x11display.dpy, x11display.old_win );
 700 -               x11display.old_win = 0;
 701 -       }
 702 -
 703 -       XFlush( x11display.dpy );
 704 -
 705 -       glState.width = width;
 706 -       glState.height = height;
 707 -       glState.fullScreen = fullscreen;
 708 -       glState.wideScreen = wideScreen;
 709 -
 710 -       // let the sound and input subsystems know about the new window
 711 -       VID_NewWindow( width, height );
 712 -
 713 -       return rserr_ok;
 714 -}
 715 -
 716 -/*
 717 -** GLimp_SetMode
 718 -*/
 719 -int GLimp_SetMode( int mode, qboolean fullscreen )
 720 -{
 721 -       return GLimp_SetMode_Real( mode, fullscreen, qfalse );
 722 -}
 723 -
 724 -/*
 725 -** GLimp_GetCurrentMode
 726 -*/
 727 -int GLimp_GetCurrentMode( void )
 728 -{
 729 -       if( x11display.dpy )
 730 -       {
 731 -               int width, height;
 732 -
 733 -               width = DisplayWidth( x11display.dpy, x11display.scr );
 734 -               height = DisplayHeight( x11display.dpy, x11display.scr );
 735 -               return VID_GetModeNum( width, height );
 736 -       }
 737 -
 738 -       return -1;
 739 -}
 740 -
 741 -/*
 742 -** GLimp_Shutdown
 743 -*/
 744 -void GLimp_Shutdown( void )
 745 -{
 746 -       if( x11display.dpy )
 747 -       {
 748 -               _xf86_VidmodesSwitchBack();
 749 -               _xf86_VidmodesFree();
 750 -               _xf86_XineramaFree();
 751 -
 752 -               if( x11display.cmap ) XFreeColormap( x11display.dpy, x11display.cmap );
 753 -               if( x11display.ctx ) qglXDestroyContext( x11display.dpy, x11display.ctx );
 754 -               if( x11display.gl_win ) XDestroyWindow( x11display.dpy, x11display.gl_win );
 755 -               if( x11display.win ) XDestroyWindow( x11display.dpy, x11display.win );
 756 -
 757 -               XCloseDisplay( x11display.dpy );
 758 -       }
 759 -
 760 -       memset(&x11display.features, 0, sizeof(x11display.features));
 761 -       x11display.modeset = qfalse;
 762 -       x11display.visinfo = NULL;
 763 -       x11display.cmap = 0;
 764 -       x11display.ctx = NULL;
 765 -       x11display.gl_win = 0;
 766 -       x11display.win = 0;
 767 -       x11display.dpy = NULL;
 768 -}
 769 -
 770 -static qboolean gotstencil = qfalse; // evil hack!
 771 -static qboolean ChooseVisual( int colorbits, int stencilbits )
 772 -{
 773 -       int colorsize;
 774 -       int depthbits = colorbits;
 775 -
 776 -       if( colorbits == 24 ) colorsize = 8;
 777 -       else colorsize = 4;
 778 -
 779 -       {
 780 -               int attributes[] = {
 781 -                       GLX_RGBA,
 782 -                       GLX_DOUBLEBUFFER,
 783 -                       GLX_RED_SIZE, colorsize,
 784 -                       GLX_GREEN_SIZE, colorsize,
 785 -                       GLX_BLUE_SIZE, colorsize,
 786 -                       GLX_DEPTH_SIZE, depthbits,
 787 -                       GLX_STENCIL_SIZE, stencilbits,
 788 -                       None
 789 -               };
 790 -
 791 -               x11display.visinfo = qglXChooseVisual( x11display.dpy, x11display.scr, attributes );
 792 -               if( !x11display.visinfo )
 793 -               {
 794 -                       Com_Printf( "..Failed to get colorbits %i, depthbits %i, stencilbits %i\n", colorbits, depthbits, stencilbits );
 795 -                       return qfalse;
 796 -               }
 797 -               else
 798 -               {
 799 -                       Com_Printf( "..Got colorbits %i, depthbits %i, stencilbits %i\n", colorbits, depthbits, stencilbits );
 800 -                       if( stencilbits > 0 ) gotstencil = qtrue;
 801 -                       return qtrue;
 802 -               }
 803 -       }
 804 -}
 805 -
 806 -/*
 807 -** GLimp_Init
 808 -*/
 809 -int GLimp_Init( void *hinstance, void *wndproc, void *parenthWnd )
 810 -{
 811 -       int colorbits, stencilbits;
 812 -       XSetWindowAttributes attr;
 813 -       unsigned long mask;
 814 -
 815 -       hinstance = NULL;
 816 -       wndproc = NULL;
 817 -
 818 -       // on unix we can change to fullscreen on fly
 819 -       vid_fullscreen->flags &= ~( CVAR_LATCH_VIDEO );
 820 -
 821 -       if( x11display.dpy )
 822 -               GLimp_Shutdown();
 823 -
 824 -       Com_Printf( "Display initialization\n" );
 825 -
 826 -       x11display.dpy = XOpenDisplay( NULL );
 827 -       if( !x11display.dpy )
 828 -       {
 829 -               Com_Printf( "..Error couldn't open the X display\n" );
 830 -               return 0;
 831 -       }
 832 -
 833 -       x11display.scr = DefaultScreen( x11display.dpy );
 834 -       if( parenthWnd )
 835 -               x11display.root = (Window )parenthWnd;
 836 -       else
 837 -               x11display.root = RootWindow( x11display.dpy, x11display.scr );
 838 -
 839 -       x11display.wmState = XInternAtom( x11display.dpy, "WM_STATE", False );
 840 -       x11display.features.wmStateFullscreen = _NET_WM_STATE_FULLSCREEN_SUPPORTED();
 841 -
 842 -       _xf86_VidmodesInit();
 843 -       _xf86_XineramaInit();
 844 -
 845 -       if( r_colorbits->integer == 16 || r_colorbits->integer == 24 ) colorbits = r_colorbits->integer;
 846 -       else colorbits = 0;
 847 -
 848 -       if( r_stencilbits->integer == 8 || r_stencilbits->integer == 16 ) stencilbits = r_stencilbits->integer;
 849 -       else stencilbits = 0;
 850 -
 851 -       gotstencil = qfalse;
 852 -       if( colorbits > 0 )
 853 -       {
 854 -               ChooseVisual( colorbits, stencilbits );
 855 -               if( !x11display.visinfo && stencilbits > 8 ) ChooseVisual( colorbits, 8 );
 856 -               if( !x11display.visinfo && stencilbits > 0 ) ChooseVisual( colorbits, 0 );
 857 -               if( !x11display.visinfo && colorbits > 16 ) ChooseVisual( 16, 0 );
 858 -       }
 859 -       else
 860 -       {
 861 -               ChooseVisual( 24, stencilbits );
 862 -               if( !x11display.visinfo ) ChooseVisual( 16, stencilbits );
 863 -               if( !x11display.visinfo && stencilbits > 8 ) ChooseVisual( 24, 8 );
 864 -               if( !x11display.visinfo && stencilbits > 8 ) ChooseVisual( 16, 8 );
 865 -               if( !x11display.visinfo && stencilbits > 0 ) ChooseVisual( 24, 0 );
 866 -               if( !x11display.visinfo && stencilbits > 0 ) ChooseVisual( 16, 0 );
 867 -       }
 868 -
 869 -       if( !x11display.visinfo )
 870 -       {
 871 -               GLimp_Shutdown(); // hope this doesn't do anything evil when we don't have window etc.
 872 -               Com_Printf( "..Error couldn't set GLX visual\n" );
 873 -               return 0;
 874 -       }
 875 -
 876 -       glState.stencilEnabled = gotstencil;
 877 -
 878 -       x11display.ctx = qglXCreateContext( x11display.dpy, x11display.visinfo, NULL, True );
 879 -       x11display.cmap = XCreateColormap( x11display.dpy, x11display.root, x11display.visinfo->visual, AllocNone );
 880 -
 881 -       attr.colormap = x11display.cmap;
 882 -       attr.border_pixel = 0;
 883 -       attr.event_mask = DISPLAY_MASK;
 884 -       attr.override_redirect = False;
 885 -       mask = CWBorderPixel | CWColormap | ExposureMask;
 886 -
 887 -       x11display.gl_win = XCreateWindow( x11display.dpy, x11display.root, 0, 0, 1, 1, 0,
 888 -                                          x11display.visinfo->depth, InputOutput, x11display.visinfo->visual, mask, &attr );
 889 -       qglXMakeCurrent( x11display.dpy, x11display.gl_win, x11display.ctx );
 890 -
 891 -       XSync( x11display.dpy, False );
 892 -
 893 -       return 1;
 894 -}
 895 -
 896 -/*
 897 -** GLimp_BeginFrame
 898 -*/
 899 -void GLimp_BeginFrame( void )
 900 -{
 901 -}
 902 -
 903 -/*
 904 -** GLimp_EndFrame
 905 -**
 906 -** Responsible for doing a swapbuffers and possibly for other stuff
 907 -** as yet to be determined.  Probably better not to make this a GLimp
 908 -** function and instead do a call to GLimp_SwapBuffers.
 909 -*/
 910 -void GLimp_EndFrame( void )
 911 -{
 912 -       qglXSwapBuffers( x11display.dpy, x11display.gl_win );
 913 -
 914 -       if( vid_fullscreen->modified || ( vid_fullscreen->integer && vid_multiscreen_head->modified ) )
 915 -       {
 916 -               GLimp_SetMode_Real( r_mode->integer, vid_fullscreen->integer, qtrue );
 917 -               vid_fullscreen->modified = qfalse;
 918 -               vid_multiscreen_head->modified = qfalse;
 919 -       }
 920 -}
 921 -
 922 -/*
 923 -** GLimp_GetGammaRamp
 924 -*/
 925 -qboolean GLimp_GetGammaRamp( size_t stride, unsigned short *ramp )
 926 -{
 927 -       if( XF86VidModeGetGammaRamp( x11display.dpy, x11display.scr, stride, ramp, ramp + stride, ramp + ( stride << 1 ) ) != 0 )
 928 -               return qtrue;
 929 -       return qfalse;
 930 -}
 931 -
 932 -/*
 933 -** GLimp_SetGammaRamp
 934 -*/
 935 -void GLimp_SetGammaRamp( size_t stride, unsigned short *ramp )
 936 -{
 937 -       XF86VidModeSetGammaRamp( x11display.dpy, x11display.scr, stride, ramp, ramp + stride, ramp + ( stride << 1 ) );
 938 -}
 939 -
 940 -/*
 941 -** GLimp_AppActivate
 942 -*/
 943 -void GLimp_AppActivate( qboolean active, qboolean destroy )
 944 -{
 945 -}
 946 +/*
 947 +Copyright (C) 1997-2001 Id Software, Inc.
 948 +
 949 +This program is free software; you can redistribute it and/or
 950 +modify it under the terms of the GNU General Public License
 951 +as published by the Free Software Foundation; either version 2
 952 +of the License, or (at your option) any later version.
 953 +
 954 +This program is distributed in the hope that it will be useful,
 955 +but WITHOUT ANY WARRANTY; without even the implied warranty of
 956 +MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 957 +
 958 +See the GNU General Public License for more details.
 959 +
 960 +You should have received a copy of the GNU General Public License
 961 +along with this program; if not, write to the Free Software
 962 +Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 963 +
 964 +*/
 965 +/*
 966 +** GLW_IMP.C
 967 +**
 968 +** This file contains ALL Linux specific stuff having to do with the
 969 +** OpenGL refresh.  When a port is being made the following functions
 970 +** must be implemented by the port:
 971 +**
 972 +** GLimp_EndFrame
 973 +** GLimp_Init
 974 +** GLimp_Shutdown
 975 +** GLimp_SwitchFullscreen
 976 +**
 977 +*/
 978 +
 979 +#include <termios.h>
 980 +#include <sys/ioctl.h>
 981 +#include <sys/stat.h>
 982 +#include <stdarg.h>
 983 +#include <stdio.h>
 984 +#include <unistd.h>
 985 +#include <signal.h>
 986 +#include <dlfcn.h>
 987 +
 988 +#include "../ref_gl/r_local.h"
 989 +#include "../client/keys.h"
 990 +
 991 +#include "x11.h"
 992 +
 993 +#include "unix_glw.h"
 994 +
 995 +#define DISPLAY_MASK ( VisibilityChangeMask | StructureNotifyMask | ExposureMask | PropertyChangeMask )
 996 +#define INIT_MASK ( KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask | PointerMotionMask | FocusChangeMask | DISPLAY_MASK )
 997 +
 998 +
 999 +x11display_t x11display;
1000 +
1001 +glwstate_t glw_state;
1002 +
1003 +static qboolean _xf86_vidmodes_supported = qfalse;
1004 +static int default_dotclock, default_viewport[2];
1005 +static XF86VidModeModeLine default_modeline;
1006 +static XF86VidModeModeInfo **_xf86_vidmodes;
1007 +static int _xf86_vidmodes_num;
1008 +static qboolean _xf86_vidmodes_active = qfalse;
1009 +static qboolean _xf86_xinerama_supported = qfalse;
1010 +
1011 +static void _xf86_VidmodesInit( void )
1012 +{
1013 +       int MajorVersion = 0, MinorVersion = 0;
1014 +
1015 +       // Get video mode list
1016 +       if( XF86VidModeQueryVersion( x11display.dpy, &MajorVersion, &MinorVersion ) )
1017 +       {
1018 +               Com_Printf( "..XFree86-VidMode Extension Version %d.%d\n", MajorVersion, MinorVersion );
1019 +               XF86VidModeGetViewPort( x11display.dpy, x11display.scr, &default_viewport[0], &default_viewport[1] );
1020 +               XF86VidModeGetModeLine( x11display.dpy, x11display.scr, &default_dotclock, &default_modeline );
1021 +               XF86VidModeGetAllModeLines( x11display.dpy, x11display.scr, &_xf86_vidmodes_num, &_xf86_vidmodes );
1022 +               _xf86_vidmodes_supported = qtrue;
1023 +       }
1024 +       else
1025 +       {
1026 +               Com_Printf( "..XFree86-VidMode Extension not available\n" );
1027 +               _xf86_vidmodes_supported = qfalse;
1028 +       }
1029 +}
1030 +
1031 +static void _xf86_VidmodesFree( void )
1032 +{
1033 +       if( _xf86_vidmodes_supported ) XFree( _xf86_vidmodes );
1034 +
1035 +       _xf86_vidmodes_supported = qfalse;
1036 +}
1037 +
1038 +static void _xf86_XineramaInit( void )
1039 +{
1040 +       int MajorVersion = 0, MinorVersion = 0;
1041 +
1042 +       if( ( XineramaQueryVersion( x11display.dpy, &MajorVersion, &MinorVersion ) ) && ( XineramaIsActive( x11display.dpy ) ) )
1043 +       {
1044 +               Com_Printf( "..XFree86-Xinerama Extension Version %d.%d\n", MajorVersion, MinorVersion );
1045 +               _xf86_xinerama_supported = qtrue;
1046 +       }
1047 +       else
1048 +       {
1049 +               Com_Printf( "..XFree86-Xinerama Extension not available\n" );
1050 +               _xf86_xinerama_supported = qfalse;
1051 +       }
1052 +}
1053 +
1054 +static void _xf86_XineramaFree( void )
1055 +{
1056 +       _xf86_xinerama_supported = qfalse;
1057 +}
1058 +
1059 +static qboolean _xf86_XineramaFindBest( int *x, int *y, int *width, int *height, qboolean silent )
1060 +{
1061 +       int i, screens, head;
1062 +       int best_dist, dist;
1063 +       XineramaScreenInfo *xinerama;
1064 +
1065 +       assert( _xf86_xinerama_supported );
1066 +
1067 +       if( vid_multiscreen_head->integer == 0 )
1068 +               return qfalse;
1069 +
1070 +       xinerama = XineramaQueryScreens( x11display.dpy, &screens );
1071 +       if( screens <= 1 )
1072 +               return qfalse;
1073 +
1074 +       head = -1;
1075 +       if( vid_multiscreen_head->integer > 0 )
1076 +       {
1077 +               for( i = 0; i < screens; i++ )
1078 +               {
1079 +                       if( xinerama[i].screen_number == vid_multiscreen_head->integer - 1 )
1080 +                       {
1081 +                               head = i;
1082 +                               break;
1083 +                       }
1084 +               }
1085 +               if( head == -1 && !silent )
1086 +                       Com_Printf( "Xinerama: Head %i not found, using best fit\n", vid_multiscreen_head->integer );
1087 +               if( *width > xinerama[head].width || *height > xinerama[head].height )
1088 +               {
1089 +                       head = -1;
1090 +                       if( !silent )
1091 +                               Com_Printf( "Xinerama: Window doesn't fit into head %i, using best fit\n", vid_multiscreen_head->integer );
1092 +               }
1093 +       }
1094 +
1095 +       if( head == -1 ) // find best fit
1096 +       {
1097 +               best_dist = 999999999;
1098 +               for( i = 0; i < screens; i++ )
1099 +               {
1100 +                       if( *width <= xinerama[i].width && *height <= xinerama[i].height )
1101 +                       {
1102 +                               if( xinerama[i].width - *width > xinerama[i].height - *height )
1103 +                               {
1104 +                                       dist = xinerama[i].height - *height;
1105 +                               }
1106 +                               else
1107 +                               {
1108 +                                       dist = xinerama[i].width - *width;
1109 +                               }
1110 +
1111 +                               if( dist < 0 )
1112 +                                       dist = -dist; // Only positive number please
1113 +
1114 +                               if( dist < best_dist )
1115 +                               {
1116 +                                       best_dist = dist;
1117 +                                       head = i;
1118 +                               }
1119 +                       }
1120 +               }
1121 +               if( head < -1 )
1122 +               {
1123 +                       if( !silent )
1124 +                               Com_Printf( "Xinerama: No fitting head found" );
1125 +                       return qfalse;
1126 +               }
1127 +       }
1128 +
1129 +       *x = xinerama[head].x_org;
1130 +       *y = xinerama[head].y_org;
1131 +       *width = xinerama[head].width;
1132 +       *height = xinerama[head].height;
1133 +
1134 +       if( !silent )
1135 +               Com_Printf( "Xinerama: Using screen %d: %dx%d+%d+%d\n", xinerama[head].screen_number, xinerama[head].width, xinerama[head].height, xinerama[head].x_org, xinerama[head].y_org );
1136 +
1137 +       return qtrue;
1138 +}
1139 +
1140 +static void _xf86_VidmodesSwitch( int mode )
1141 +{
1142 +       if( _xf86_vidmodes_supported )
1143 +       {
1144 +               XF86VidModeSwitchToMode( x11display.dpy, x11display.scr, _xf86_vidmodes[mode] );
1145 +               XF86VidModeSetViewPort( x11display.dpy, x11display.scr, 0, 0 );
1146 +       }
1147 +
1148 +       _xf86_vidmodes_active = qtrue;
1149 +}
1150 +
1151 +static void _xf86_VidmodesSwitchBack( void )
1152 +{
1153 +       if( _xf86_vidmodes_supported && _xf86_vidmodes_active )
1154 +       {
1155 +               XF86VidModeModeInfo modeinfo;
1156 +
1157 +               modeinfo.dotclock = default_dotclock;
1158 +               modeinfo.hdisplay = default_modeline.hdisplay;
1159 +               modeinfo.hsyncstart = default_modeline.hsyncstart;
1160 +               modeinfo.hsyncend = default_modeline.hsyncend;
1161 +               modeinfo.htotal = default_modeline.htotal;
1162 +               modeinfo.vdisplay = default_modeline.vdisplay;
1163 +               modeinfo.vsyncstart = default_modeline.vsyncstart;
1164 +               modeinfo.vsyncend = default_modeline.vsyncend;
1165 +               modeinfo.vtotal = default_modeline.vtotal;
1166 +               modeinfo.flags = default_modeline.flags;
1167 +               modeinfo.privsize = default_modeline.privsize;
1168 +               modeinfo.private = default_modeline.private;
1169 +
1170 +               XF86VidModeSwitchToMode( x11display.dpy, x11display.scr, &modeinfo );
1171 +               XF86VidModeSetViewPort( x11display.dpy, x11display.scr, default_viewport[0], default_viewport[1] );
1172 +       }
1173 +
1174 +       _xf86_vidmodes_active = qfalse;
1175 +}
1176 +
1177 +static void _xf86_VidmodesFindBest( int *mode, int *pwidth, int *pheight, qboolean silent )
1178 +{
1179 +       int i, best_fit, best_dist, dist, x, y;
1180 +
1181 +       best_fit = -1;
1182 +       best_dist = 999999999;
1183 +
1184 +       if( _xf86_vidmodes_supported )
1185 +       {
1186 +               for( i = 0; i < _xf86_vidmodes_num; i++ )
1187 +               {
1188 +                       if( _xf86_vidmodes[i]->hdisplay < *pwidth || _xf86_vidmodes[i]->vdisplay < *pheight )
1189 +                               continue;
1190 +
1191 +                       x = _xf86_vidmodes[i]->hdisplay - *pwidth;
1192 +                       y = _xf86_vidmodes[i]->vdisplay - *pheight;
1193 +
1194 +                       if( x > y ) dist = y;
1195 +                       else dist = x;
1196 +
1197 +                       if( dist < 0 ) dist = -dist; // Only positive number please
1198 +
1199 +                       if( dist < best_dist )
1200 +                       {
1201 +                               best_dist = dist;
1202 +                               best_fit = i;
1203 +                       }
1204 +
1205 +                       if( !silent )
1206 +                               Com_Printf( "%ix%i -> %ix%i: %i\n", *pwidth, *pheight, _xf86_vidmodes[i]->hdisplay, _xf86_vidmodes[i]->vdisplay, dist );
1207 +               }
1208 +
1209 +               if( best_fit >= 0 )
1210 +               {
1211 +                       if( !silent )
1212 +                               Com_Printf( "%ix%i selected\n", _xf86_vidmodes[best_fit]->hdisplay, _xf86_vidmodes[best_fit]->vdisplay );
1213 +
1214 +                       *pwidth = _xf86_vidmodes[best_fit]->hdisplay;
1215 +                       *pheight = _xf86_vidmodes[best_fit]->vdisplay;
1216 +               }
1217 +       }
1218 +
1219 +       *mode = best_fit;
1220 +}
1221 +
1222 +static void _x11_SetNoResize( Window w, int width, int height )
1223 +{
1224 +       XSizeHints *hints;
1225 +
1226 +       if( x11display.dpy )
1227 +       {
1228 +               hints = XAllocSizeHints();
1229 +
1230 +               if( hints )
1231 +               {
1232 +                       hints->min_width = hints->max_width = width;
1233 +                       hints->min_height = hints->max_height = height;
1234 +
1235 +                       hints->flags = PMaxSize | PMinSize;
1236 +
1237 +                       XSetWMNormalHints( x11display.dpy, w, hints );
1238 +                       XFree( hints );
1239 +               }
1240 +       }
1241 +}
1242 +
1243 +/*****************************************************************************/
1244 +
1245 +/*
1246 +* Sys_GetClipboardData
1247 +*
1248 +* Orginally from EzQuake
1249 +* There should be a smarter place to put this
1250 +*/
1251 +char *Sys_GetClipboardData( qboolean primary )
1252 +{
1253 +       Window win;
1254 +       Atom type;
1255 +       int format, ret;
1256 +       unsigned long nitems, bytes_after, bytes_left;
1257 +       unsigned char *data;
1258 +       char *buffer;
1259 +       Atom atom;
1260 +
1261 +       if( !x11display.dpy )
1262 +               return NULL;
1263 +
1264 +       if( primary )
1265 +       {
1266 +               atom = XInternAtom( x11display.dpy, "PRIMARY", True );
1267 +       }
1268 +       else
1269 +       {
1270 +               atom = XInternAtom( x11display.dpy, "CLIPBOARD", True );
1271 +       }
1272 +       if( atom == None )
1273 +               return NULL;
1274 +
1275 +       win = XGetSelectionOwner( x11display.dpy, atom );
1276 +       if( win == None )
1277 +               return NULL;
1278 +
1279 +       XConvertSelection( x11display.dpy, atom, XA_STRING, atom, win, CurrentTime );
1280 +       XFlush( x11display.dpy );
1281 +
1282 +       XGetWindowProperty( x11display.dpy, win, atom, 0, 0, False, AnyPropertyType, &type, &format, &nitems, &bytes_left,
1283 +               &data );
1284 +       if( bytes_left <= 0 )
1285 +               return NULL;
1286 +
1287 +       ret = XGetWindowProperty( x11display.dpy, win, atom, 0, bytes_left, False, AnyPropertyType, &type,
1288 +               &format, &nitems, &bytes_after, &data );
1289 +       if( ret == Success )
1290 +       {
1291 +               buffer = Q_malloc( bytes_left + 1 );
1292 +               Q_strncpyz( buffer, (char *)data, bytes_left + 1 );
1293 +       }
1294 +       else
1295 +       {
1296 +               buffer = NULL;
1297 +       }
1298 +
1299 +       XFree( data );
1300 +
1301 +       return buffer;
1302 +}
1303 +
1304 +
1305 +/*
1306 +* Sys_SetClipboardData
1307 +*/
1308 +qboolean Sys_SetClipboardData( char *data )
1309 +{
1310 +       return qfalse;
1311 +}
1312 +
1313 +/*
1314 +* Sys_FreeClipboardData
1315 +*/
1316 +void Sys_FreeClipboardData( char *data )
1317 +{
1318 +       Q_free( data );
1319 +}
1320 +
1321 +/*
1322 +* _NET_WM_CHECK_SUPPORTED
1323 +*/
1324 +static qboolean _NET_WM_CHECK_SUPPORTED( Atom NET_ATOM )
1325 +{
1326 +       qboolean issupported = qfalse;
1327 +       unsigned char *atomdata;
1328 +       Atom *atoms;
1329 +       int status, real_format;
1330 +       Atom real_type;
1331 +       unsigned long items_read, items_left, i;
1332 +       int result = 1;
1333 +       Atom _NET_SUPPORTED;
1334 +
1335 +       _NET_SUPPORTED = XInternAtom( x11display.dpy, "_NET_SUPPORTED", 0 );
1336 +
1337 +       status = XGetWindowProperty( x11display.dpy, x11display.root, _NET_SUPPORTED,
1338 +               0L, 8192L, False, XA_ATOM, &real_type, &real_format,
1339 +               &items_read, &items_left, &atomdata );
1340 +
1341 +       if( status != Success )
1342 +               return qfalse;
1343 +
1344 +       atoms = (Atom *)atomdata;
1345 +       for( i = 0; result && i < items_read; i++ )
1346 +       {
1347 +               if( atoms[i] == NET_ATOM )
1348 +               {
1349 +                       issupported = qtrue;
1350 +                       break;
1351 +               }
1352 +       }
1353 +
1354 +       XFree( atomdata );
1355 +       return issupported;
1356 +}
1357 +
1358 +/*
1359 +* _NET_WM_STATE_FULLSCREEN_SUPPORTED
1360 +*/
1361 +static qboolean _NET_WM_STATE_FULLSCREEN_SUPPORTED( void )
1362 +{
1363 +       Atom _NET_WM_STATE_FULLSCREEN = XInternAtom( x11display.dpy, "_NET_WM_STATE_FULLSCREEN", 0 );
1364 +       return _NET_WM_CHECK_SUPPORTED( _NET_WM_STATE_FULLSCREEN );
1365 +
1366 +}
1367 +
1368 +/*
1369 +* _NETWM_CHECK_FULLSCREEN
1370 +*/
1371 +qboolean _NETWM_CHECK_FULLSCREEN( void )
1372 +{
1373 +       qboolean isfullscreen = qfalse;
1374 +       unsigned char *atomdata;
1375 +       Atom *atoms;
1376 +       int status, real_format;
1377 +       Atom real_type;
1378 +       unsigned long items_read, items_left, i;
1379 +       int result = 1;
1380 +       Atom _NET_WM_STATE;
1381 +       Atom _NET_WM_STATE_FULLSCREEN;
1382 +
1383 +       if( !x11display.features.wmStateFullscreen )
1384 +               return qfalse;
1385 +
1386 +       _NET_WM_STATE = XInternAtom( x11display.dpy, "_NET_WM_STATE", 0 );
1387 +       _NET_WM_STATE_FULLSCREEN = XInternAtom( x11display.dpy, "_NET_WM_STATE_FULLSCREEN", 0 );
1388 +
1389 +       status = XGetWindowProperty( x11display.dpy, x11display.win, _NET_WM_STATE,
1390 +               0L, 8192L, False, XA_ATOM, &real_type, &real_format,
1391 +               &items_read, &items_left, &atomdata );
1392 +
1393 +       if( status != Success )
1394 +               return qfalse;
1395 +
1396 +       atoms = (Atom *)atomdata;
1397 +       for( i = 0; result && i < items_read; i++ )
1398 +       {
1399 +               if( atoms[i] == _NET_WM_STATE_FULLSCREEN )
1400 +               {
1401 +                       isfullscreen = qtrue;
1402 +                       break;
1403 +               }
1404 +       }
1405 +
1406 +       if( isfullscreen )
1407 +       {
1408 +               Cvar_SetValue( "vid_fullscreen", 1 );
1409 +               vid_fullscreen->modified = qfalse;
1410 +       }
1411 +       else
1412 +       {
1413 +               Cvar_SetValue( "vid_fullscreen", 0 );
1414 +               vid_fullscreen->modified = qfalse;
1415 +       }
1416 +
1417 +       XFree( atomdata );
1418 +       return isfullscreen;
1419 +}
1420 +
1421 +/*
1422 +* _NETWM_SET_FULLSCREEN
1423 +*
1424 +* Tell Window-Manager to toggle fullscreen
1425 +*/
1426 +void _NETWM_SET_FULLSCREEN( qboolean fullscreen )
1427 +{
1428 +       XEvent xev;
1429 +       Atom wm_state;
1430 +       Atom wm_fullscreen;
1431 +
1432 +       if( !x11display.features.wmStateFullscreen )
1433 +               return;
1434 +
1435 +       wm_state = XInternAtom( x11display.dpy, "_NET_WM_STATE", False );
1436 +       wm_fullscreen = XInternAtom( x11display.dpy, "_NET_WM_STATE_FULLSCREEN", False );
1437 +
1438 +       memset(&xev, 0, sizeof(xev));
1439 +       xev.type = ClientMessage;
1440 +    xev.xany.type = ClientMessage;
1441 +       xev.xclient.window = x11display.win;
1442 +       xev.xclient.message_type = wm_state;
1443 +       xev.xclient.format = 32;
1444 +       xev.xclient.data.l[0] = fullscreen ? 1 : 0;
1445 +       xev.xclient.data.l[1] = wm_fullscreen;
1446 +       xev.xclient.data.l[2] = 0l;
1447 +
1448 +       XSendEvent( x11display.dpy, DefaultRootWindow( x11display.dpy ), False,
1449 +               SubstructureNotifyMask | SubstructureRedirectMask, &xev );
1450 +}
1451 +
1452 +/*
1453 +* _NETWM_CHECK_PING
1454 +*
1455 +* Checks if the _NET_WM_PING Atom is already present in WM_PROTOCOLS
1456 +*/
1457 +qboolean _NETWM_CHECK_PING( void )
1458 +{
1459 +    Status status;
1460 +       qboolean present = qfalse;
1461 +       Atom *atoms;
1462 +       int num_atoms, i;
1463 +
1464 +       status = XGetWMProtocols( x11display.dpy, x11display.win, &atoms, &num_atoms );
1465 +
1466 +       if( status == 0 )
1467 +               return qfalse;
1468 +
1469 +       for( i = 0; i < num_atoms; i++ )
1470 +       {
1471 +               if( atoms[i] == x11display.ping )
1472 +               {
1473 +                       present = qtrue;
1474 +                       break;
1475 +               }
1476 +       }
1477 +    XFree( atoms );
1478 +    return present;
1479 +}
1480 +
1481 +/*
1482 +* _NETWM_SET_HINTS
1483 +*
1484 +* Sets informative hints defined in the ICCCM2/EWMH spec
1485 +*/
1486 +void _NETWM_SET_HINTS( void )
1487 +{
1488 +       Status status;
1489 +       XTextProperty titleprop, iconprop, clientmachineprop;
1490 +       char *title = "Warsow"; //FIXME: Shouldn't be hardcoded
1491 +       char *icon_name = "warsow128x128.xpm"; //FIXME: Shouldn't be hardcoded
1492 +    pid_t warsowpid; //FIXME: Does Warsow already know it's pid? Can it be retrieved from there?
1493 +       char hostname[256]; //FIXME: Is it possible to get the hostname of the client from qcommon/net.c or somewhere else?
1494 +    char* hostnamepointer = &hostname[0];
1495 +
1496 +    Atom CARDINAL;
1497 +       Atom UTF8_STRING;
1498 +
1499 +    Atom NET_WM_PID;
1500 +       Atom NET_WM_NAME;
1501 +       Atom NET_WM_ICON_NAME;
1502 +       Atom NET_WM_WINDOW_TYPE;
1503 +       Atom NET_WM_WINDOW_TYPE_NORMAL;
1504 +
1505 +    Atom WM_PROTOCOLS;
1506 +    Atom WM_CLIENT_MACHINE;
1507 +
1508 +    x11display.ping = XInternAtom( x11display.dpy, "_NET_WM_PING", False );
1509 +
1510 +       CARDINAL = XInternAtom( x11display.dpy, "CARDINAL", False );
1511 +       UTF8_STRING = XInternAtom( x11display.dpy, "_UTF8_STRING", False );
1512 +
1513 +    NET_WM_PID = XInternAtom( x11display.dpy, "_NET_WM_PID", False );
1514 +       NET_WM_NAME = XInternAtom( x11display.dpy, "_NET_WM_NAME", False );
1515 +       NET_WM_ICON_NAME = XInternAtom( x11display.dpy, "_NET_WM_ICON_NAME", False );
1516 +       NET_WM_WINDOW_TYPE = XInternAtom( x11display.dpy, "_NET_WM_WINDOW_TYPE", False );
1517 +       NET_WM_WINDOW_TYPE_NORMAL = XInternAtom( x11display.dpy, "_NET_WM_WINDOW_TYPE_NORMAL", False );
1518 +
1519 +    WM_PROTOCOLS = XInternAtom( x11display.dpy, "WM_PROTOCOLS", False );
1520 +    WM_CLIENT_MACHINE = XInternAtom( x11display.dpy, "WM_CLIENT_MACHINE", False );
1521 +
1522 +    warsowpid = getpid();
1523 +
1524 +    XChangeProperty( x11display.dpy, x11display.win, NET_WM_PID, CARDINAL, 32,
1525 +        PropModeReplace,
1526 +        (unsigned char *)&warsowpid, 1 );
1527 +
1528 +       status = XStringListToTextProperty( &title, 1, &titleprop );
1529 +
1530 +       if( status )
1531 +               XSetTextProperty( x11display.dpy, x11display.win, &titleprop, NET_WM_NAME );
1532 +
1533 +       status = XStringListToTextProperty( &icon_name, 1, &iconprop );
1534 +
1535 +       if( status )
1536 +               XSetTextProperty( x11display.dpy, x11display.win, &iconprop, NET_WM_ICON_NAME );
1537 +
1538 +       XChangeProperty( x11display.dpy, x11display.win, NET_WM_WINDOW_TYPE, XA_ATOM, 32,
1539 +               PropModeReplace,
1540 +               (unsigned char *)&NET_WM_WINDOW_TYPE_NORMAL, 1 );
1541 +
1542 +       if( gethostname( hostname, 256 ) == SOCKET_ERROR )
1543 +        return;
1544 +
1545 +    status = XStringListToTextProperty( &hostnamepointer, 1, &clientmachineprop );
1546 +
1547 +    if( status )
1548 +        XSetWMClientMachine( x11display.dpy, x11display.win, &clientmachineprop );
1549 +    else
1550 +        return;
1551 +
1552 +    if( !_NETWM_CHECK_PING() ) {
1553 +        XChangeProperty( x11display.dpy, x11display.win, WM_PROTOCOLS, XA_ATOM, 32,
1554 +            PropModeAppend,
1555 +            (unsigned char *)&x11display.ping, 1 );
1556 +    }
1557 +}
1558 +
1559 +/*****************************************************************************/
1560 +
1561 +static void GLimp_SetXPMIcon( const int *xpm_icon )
1562 +{
1563 +       int width, height;
1564 +       size_t i, cardinalSize;
1565 +       long *cardinalData;
1566 +       Atom NET_WM_ICON;
1567 +       Atom CARDINAL;
1568 +
1569 +       // allocate memory for icon data: width + height + width * height pixels
1570 +       // note: sizeof(long) shall be used according to XChangeProperty() man page
1571 +       width = xpm_icon[0];
1572 +       height = xpm_icon[1];
1573 +       cardinalSize = width * height + 2;
1574 +       cardinalData = Q_malloc( cardinalSize * sizeof( *cardinalData ) );
1575 +       for( i = 0; i < cardinalSize; i++ )
1576 +               cardinalData[i] = xpm_icon[i];
1577 +
1578 +       NET_WM_ICON = XInternAtom( x11display.dpy, "_NET_WM_ICON", False );
1579 +       CARDINAL = XInternAtom( x11display.dpy, "CARDINAL", False );
1580 +
1581 +       XChangeProperty( x11display.dpy, x11display.win, NET_WM_ICON, CARDINAL, 32,
1582 +               PropModeReplace, (unsigned char *)cardinalData, cardinalSize );
1583 +
1584 +       Q_free( cardinalData );
1585 +}
1586 +
1587 +int *parse_xpm_icon ( int num_xpm_elements, char *xpm_data[] );
1588 +
1589 +static void GLimp_SetApplicationIcon( void )
1590 +{
1591 +#include "warsow128x128.xpm"
1592 +
1593 +       const int *xpm_icon;
1594 +
1595 +       xpm_icon = parse_xpm_icon( sizeof( warsow128x128_xpm ) / sizeof( warsow128x128_xpm[0] ), warsow128x128_xpm );
1596 +       if( xpm_icon )
1597 +       {
1598 +               GLimp_SetXPMIcon( xpm_icon );
1599 +               free( ( void * )xpm_icon );
1600 +       }
1601 +}
1602 +
1603 +/*****************************************************************************/
1604 +
1605 +/*
1606 +** GLimp_SetMode_Real
1607 +* Hack to get rid of the prints when toggling fullscreen
1608 +*/
1609 +int GLimp_SetMode_Real( int mode, qboolean fullscreen, qboolean silent )
1610 +{
1611 +       int width, height, screen_x, screen_y, screen_width, screen_height, screen_mode;
1612 +       float ratio;
1613 +       XSetWindowAttributes wa;
1614 +       unsigned long mask;
1615 +       qboolean wideScreen;
1616 +
1617 +       if( !VID_GetModeInfo( &width, &height, &wideScreen, mode ) )
1618 +       {
1619 +               if( !silent )
1620 +                       Com_Printf( " invalid mode\n" );
1621 +               return rserr_invalid_mode;
1622 +       }
1623 +
1624 +       screen_mode = -1;
1625 +       screen_x = screen_y = 0;
1626 +       screen_width = width;
1627 +       screen_height = height;
1628 +
1629 +       x11display.old_win = x11display.win;
1630 +
1631 +       if( fullscreen )
1632 +       {
1633 +               if( !_xf86_xinerama_supported ||
1634 +                       !_xf86_XineramaFindBest( &screen_x, &screen_y, &screen_width, &screen_height, silent ) )
1635 +               {
1636 +                       _xf86_VidmodesFindBest( &screen_mode, &screen_width, &screen_height, silent );
1637 +                       if( screen_mode < 0 )
1638 +                       {
1639 +                               if( !silent )
1640 +                                       Com_Printf( " no mode found\n" );
1641 +                               return rserr_invalid_mode;
1642 +                       }
1643 +               }
1644 +
1645 +               if( screen_width < width || screen_height < height )
1646 +               {
1647 +                       if( width > height )
1648 +                       {
1649 +                               ratio = width / height;
1650 +                               height = height * ratio;
1651 +                               width = screen_width;
1652 +                       }
1653 +                       else
1654 +                       {
1655 +                               ratio = height / width;
1656 +                               width = width * ratio;
1657 +                               height = screen_height;
1658 +                       }
1659 +               }
1660 +
1661 +               if( !silent )
1662 +                       Com_Printf( "...setting fullscreen mode %d:\n", mode );
1663 +
1664 +               /* Create fulscreen window */
1665 +               wa.background_pixel = 0;
1666 +               wa.border_pixel = 0;
1667 +               wa.event_mask = INIT_MASK;
1668 +               wa.backing_store = NotUseful;
1669 +               wa.save_under = False;
1670 +
1671 +               if( x11display.features.wmStateFullscreen )
1672 +               {
1673 +                       wa.override_redirect = False;
1674 +                       mask = CWBackPixel | CWBorderPixel | CWEventMask | CWSaveUnder | CWBackingStore;
1675 +               }
1676 +               else
1677 +               {
1678 +                       wa.override_redirect = True;
1679 +                       mask = CWBackPixel | CWBorderPixel | CWEventMask | CWSaveUnder | CWBackingStore | CWOverrideRedirect;
1680 +               }
1681 +
1682 +               if( ( !x11display.win ) || !x11display.features.wmStateFullscreen ) {
1683 +                   x11display.win = XCreateWindow( x11display.dpy, x11display.root, screen_x, screen_y, screen_width, screen_height,
1684 +                       0, CopyFromParent, InputOutput, CopyFromParent, mask, &wa );
1685 +                   x11display.wmDeleteWindow = XInternAtom( x11display.dpy, "WM_DELETE_WINDOW", False );
1686 +                   XSetWMProtocols( x11display.dpy, x11display.win, &x11display.wmDeleteWindow, 1 );
1687 +           _NETWM_SET_HINTS();
1688 +        }
1689 +
1690 +               XResizeWindow( x11display.dpy, x11display.gl_win, width, height );
1691 +               XReparentWindow( x11display.dpy, x11display.gl_win, x11display.win, ( screen_width/2 )-( width/2 ),
1692 +                       ( screen_height/2 )-( height/2 ) );
1693 +
1694 +               x11display.modeset = qtrue;
1695 +
1696 +               XMapWindow( x11display.dpy, x11display.gl_win );
1697 +               XMapWindow( x11display.dpy, x11display.win );
1698 +
1699 +               if ( !x11display.features.wmStateFullscreen )
1700 +                       _x11_SetNoResize( x11display.win, width, height );
1701 +               else
1702 +                       _NETWM_SET_FULLSCREEN( qtrue );
1703 +
1704 +               if( screen_mode != -1 )
1705 +               {
1706 +                       _xf86_VidmodesSwitch( screen_mode );
1707 +               }
1708 +       }
1709 +       else
1710 +       {
1711 +               if( !silent )
1712 +                       Com_Printf( "...setting mode %d:\n", mode );
1713 +
1714 +               /* Create managed window */
1715 +               wa.background_pixel = 0;
1716 +               wa.border_pixel = 0;
1717 +               wa.event_mask = INIT_MASK;
1718 +               mask = CWBackPixel | CWBorderPixel | CWEventMask;
1719 +
1720 +               if( ( !x11display.win ) || !x11display.features.wmStateFullscreen ) {
1721 +                   x11display.win = XCreateWindow( x11display.dpy, x11display.root, 0, 0, screen_width, screen_height,
1722 +                       0, CopyFromParent, InputOutput, CopyFromParent, mask, &wa );
1723 +                   x11display.wmDeleteWindow = XInternAtom( x11display.dpy, "WM_DELETE_WINDOW", False );
1724 +                   XSetWMProtocols( x11display.dpy, x11display.win, &x11display.wmDeleteWindow, 1 );
1725 +           _NETWM_SET_HINTS();
1726 +        }
1727 +
1728 +               XResizeWindow( x11display.dpy, x11display.gl_win, width, height );
1729 +               XReparentWindow( x11display.dpy, x11display.gl_win, x11display.win, 0, 0 );
1730 +
1731 +               x11display.modeset = qtrue;
1732 +
1733 +               XMapWindow( x11display.dpy, x11display.gl_win );
1734 +               XMapWindow( x11display.dpy, x11display.win );
1735 +
1736 +               if( !x11display.features.wmStateFullscreen )
1737 +                       _x11_SetNoResize( x11display.win, width, height );
1738 +        else
1739 +            _NETWM_SET_FULLSCREEN( qfalse );
1740 +
1741 +               _xf86_VidmodesSwitchBack();
1742 +       }
1743 +
1744 +       XSetStandardProperties( x11display.dpy, x11display.win, APPLICATION, None, None, NULL, 0, NULL );
1745 +
1746 +       GLimp_SetApplicationIcon();
1747 +
1748 +       XSetIconName( x11display.dpy, x11display.win, APPLICATION );
1749 +       XStoreName( x11display.dpy, x11display.win, APPLICATION );
1750 +
1751 +       // save the parent window size for mouse use. this is not the gl context window
1752 +       x11display.win_width = width;
1753 +       x11display.win_height = height;
1754 +
1755 +       if( x11display.old_win && !x11display.features.wmStateFullscreen )
1756 +       {
1757 +               XDestroyWindow( x11display.dpy, x11display.old_win );
1758 +               x11display.old_win = 0;
1759 +       }
1760 +
1761 +       XFlush( x11display.dpy );
1762 +
1763 +       glState.width = width;
1764 +       glState.height = height;
1765 +       glState.fullScreen = fullscreen;
1766 +       glState.wideScreen = wideScreen;
1767 +
1768 +       // let the sound and input subsystems know about the new window
1769 +       VID_NewWindow( width, height );
1770 +
1771 +       return rserr_ok;
1772 +}
1773 +
1774 +/*
1775 +** GLimp_SetMode
1776 +*/
1777 +int GLimp_SetMode( int mode, qboolean fullscreen )
1778 +{
1779 +       return GLimp_SetMode_Real( mode, fullscreen, qfalse );
1780 +}
1781 +
1782 +/*
1783 +** GLimp_GetCurrentMode
1784 +*/
1785 +int GLimp_GetCurrentMode( void )
1786 +{
1787 +       if( x11display.dpy )
1788 +       {
1789 +               int width, height;
1790 +
1791 +               width = DisplayWidth( x11display.dpy, x11display.scr );
1792 +               height = DisplayHeight( x11display.dpy, x11display.scr );
1793 +               return VID_GetModeNum( width, height );
1794 +       }
1795 +
1796 +       return -1;
1797 +}
1798 +
1799 +/*
1800 +** GLimp_Shutdown
1801 +*/
1802 +void GLimp_Shutdown( void )
1803 +{
1804 +       if( x11display.dpy )
1805 +       {
1806 +               _xf86_VidmodesSwitchBack();
1807 +               _xf86_VidmodesFree();
1808 +               _xf86_XineramaFree();
1809 +
1810 +               if( x11display.cmap ) XFreeColormap( x11display.dpy, x11display.cmap );
1811 +               if( x11display.ctx ) qglXDestroyContext( x11display.dpy, x11display.ctx );
1812 +               if( x11display.gl_win ) XDestroyWindow( x11display.dpy, x11display.gl_win );
1813 +               if( x11display.win ) XDestroyWindow( x11display.dpy, x11display.win );
1814 +
1815 +               XCloseDisplay( x11display.dpy );
1816 +       }
1817 +
1818 +       memset(&x11display.features, 0, sizeof(x11display.features));
1819 +       x11display.modeset = qfalse;
1820 +       x11display.visinfo = NULL;
1821 +       x11display.cmap = 0;
1822 +       x11display.ctx = NULL;
1823 +       x11display.gl_win = 0;
1824 +       x11display.win = 0;
1825 +       x11display.dpy = NULL;
1826 +}
1827 +
1828 +static qboolean gotstencil = qfalse; // evil hack!
1829 +static qboolean ChooseVisual( int colorbits, int stencilbits )
1830 +{
1831 +       int colorsize;
1832 +       int depthbits = colorbits;
1833 +
1834 +       if( colorbits == 24 ) colorsize = 8;
1835 +       else colorsize = 4;
1836 +
1837 +       {
1838 +               int attributes[] = {
1839 +                       GLX_RGBA,
1840 +                       GLX_DOUBLEBUFFER,
1841 +                       GLX_RED_SIZE, colorsize,
1842 +                       GLX_GREEN_SIZE, colorsize,
1843 +                       GLX_BLUE_SIZE, colorsize,
1844 +                       GLX_DEPTH_SIZE, depthbits,
1845 +                       GLX_STENCIL_SIZE, stencilbits,
1846 +                       None
1847 +               };
1848 +
1849 +               x11display.visinfo = qglXChooseVisual( x11display.dpy, x11display.scr, attributes );
1850 +               if( !x11display.visinfo )
1851 +               {
1852 +                       Com_Printf( "..Failed to get colorbits %i, depthbits %i, stencilbits %i\n", colorbits, depthbits, stencilbits );
1853 +                       return qfalse;
1854 +               }
1855 +               else
1856 +               {
1857 +                       Com_Printf( "..Got colorbits %i, depthbits %i, stencilbits %i\n", colorbits, depthbits, stencilbits );
1858 +                       if( stencilbits > 0 ) gotstencil = qtrue;
1859 +                       return qtrue;
1860 +               }
1861 +       }
1862 +}
1863 +
1864 +static int _my_x11_error( Display *dpy, XErrorEvent *ev )
1865 +{
1866 +       printf("_my_x11_error:\n\ttype: %d\n\terror-code: %d\n\tminor-code: %d\n\trequest-code: %d\n",
1867 +                       ev->type, ev->error_code, ev->minor_code, ev->request_code );
1868 +
1869 +//     assert( 0 );
1870 +
1871 +       return 0;
1872 +}
1873 +
1874 +/*
1875 +** GLimp_Init
1876 +*/
1877 +int GLimp_Init( void *hinstance, void *wndproc, void *parenthWnd )
1878 +{
1879 +       int colorbits, stencilbits;
1880 +       XSetWindowAttributes attr;
1881 +       unsigned long mask;
1882 +
1883 +       hinstance = NULL;
1884 +       wndproc = NULL;
1885 +
1886 +       // on unix we can change to fullscreen on fly
1887 +       vid_fullscreen->flags &= ~( CVAR_LATCH_VIDEO );
1888 +
1889 +       if( x11display.dpy )
1890 +               GLimp_Shutdown();
1891 +
1892 +       Com_Printf( "Display initialization\n" );
1893 +
1894 +       x11display.dpy = XOpenDisplay( NULL );
1895 +       if( !x11display.dpy )
1896 +       {
1897 +               Com_Printf( "..Error couldn't open the X display\n" );
1898 +               return 0;
1899 +       }
1900 +
1901 +       x11display.scr = DefaultScreen( x11display.dpy );
1902 +       if( parenthWnd )
1903 +               x11display.root = (Window )parenthWnd;
1904 +       else
1905 +               x11display.root = RootWindow( x11display.dpy, x11display.scr );
1906 +
1907 +       x11display.wmState = XInternAtom( x11display.dpy, "WM_STATE", False );
1908 +       x11display.features.wmStateFullscreen = _NET_WM_STATE_FULLSCREEN_SUPPORTED();
1909 +
1910 +       _xf86_VidmodesInit();
1911 +
1912 +       if( r_colorbits->integer == 16 || r_colorbits->integer == 24 ) colorbits = r_colorbits->integer;
1913 +       else colorbits = 0;
1914 +
1915 +       if( r_stencilbits->integer == 8 || r_stencilbits->integer == 16 ) stencilbits = r_stencilbits->integer;
1916 +       else stencilbits = 0;
1917 +
1918 +       gotstencil = qfalse;
1919 +       if( colorbits > 0 )
1920 +       {
1921 +               ChooseVisual( colorbits, stencilbits );
1922 +               if( !x11display.visinfo && stencilbits > 8 ) ChooseVisual( colorbits, 8 );
1923 +               if( !x11display.visinfo && stencilbits > 0 ) ChooseVisual( colorbits, 0 );
1924 +               if( !x11display.visinfo && colorbits > 16 ) ChooseVisual( 16, 0 );
1925 +       }
1926 +       else
1927 +       {
1928 +               ChooseVisual( 24, stencilbits );
1929 +               if( !x11display.visinfo ) ChooseVisual( 16, stencilbits );
1930 +               if( !x11display.visinfo && stencilbits > 8 ) ChooseVisual( 24, 8 );
1931 +               if( !x11display.visinfo && stencilbits > 8 ) ChooseVisual( 16, 8 );
1932 +               if( !x11display.visinfo && stencilbits > 0 ) ChooseVisual( 24, 0 );
1933 +               if( !x11display.visinfo && stencilbits > 0 ) ChooseVisual( 16, 0 );
1934 +       }
1935 +
1936 +       if( !x11display.visinfo )
1937 +       {
1938 +               GLimp_Shutdown(); // hope this doesn't do anything evil when we don't have window etc.
1939 +               Com_Printf( "..Error couldn't set GLX visual\n" );
1940 +               return 0;
1941 +       }
1942 +
1943 +       glState.stencilEnabled = gotstencil;
1944 +
1945 +       x11display.ctx = qglXCreateContext( x11display.dpy, x11display.visinfo, NULL, True );
1946 +       x11display.cmap = XCreateColormap( x11display.dpy, x11display.root, x11display.visinfo->visual, AllocNone );
1947 +
1948 +       attr.colormap = x11display.cmap;
1949 +       attr.border_pixel = 0;
1950 +       attr.event_mask = DISPLAY_MASK;
1951 +       attr.override_redirect = False;
1952 +       mask = CWBorderPixel | CWColormap | ExposureMask;
1953 +
1954 +       x11display.gl_win = XCreateWindow( x11display.dpy, x11display.root, 0, 0, 1, 1, 0,
1955 +               x11display.visinfo->depth, InputOutput, x11display.visinfo->visual, mask, &attr );
1956 +       qglXMakeCurrent( x11display.dpy, x11display.gl_win, x11display.ctx );
1957 +
1958 +       XSync( x11display.dpy, False );
1959 +
1960 +       XSetErrorHandler( _my_x11_error );
1961 +
1962 +       return 1;
1963 +}
1964 +
1965 +/*
1966 +** GLimp_BeginFrame
1967 +*/
1968 +void GLimp_BeginFrame( void )
1969 +{
1970 +}
1971 +
1972 +/*
1973 +** GLimp_EndFrame
1974 +**
1975 +** Responsible for doing a swapbuffers and possibly for other stuff
1976 +** as yet to be determined.  Probably better not to make this a GLimp
1977 +** function and instead do a call to GLimp_SwapBuffers.
1978 +*/
1979 +void GLimp_EndFrame( void )
1980 +{
1981 +       qglXSwapBuffers( x11display.dpy, x11display.gl_win );
1982 +
1983 +       if( vid_fullscreen->modified || ( vid_fullscreen->integer && vid_multiscreen_head->modified ) )
1984 +       {
1985 +               GLimp_SetMode_Real( r_mode->integer, vid_fullscreen->integer, qtrue );
1986 +               vid_fullscreen->modified = qfalse;
1987 +               vid_multiscreen_head->modified = qfalse;
1988 +       }
1989 +}
1990 +
1991 +/*
1992 +** GLimp_GetGammaRamp
1993 +*/
1994 +qboolean GLimp_GetGammaRamp( size_t stride, unsigned short *ramp )
1995 +{
1996 +       if( XF86VidModeGetGammaRamp( x11display.dpy, x11display.scr, stride, ramp, ramp + stride, ramp + ( stride << 1 ) ) != 0 )
1997 +               return qtrue;
1998 +       return qfalse;
1999 +}
2000 +
2001 +/*
2002 +** GLimp_SetGammaRamp
2003 +*/
2004 +void GLimp_SetGammaRamp( size_t stride, unsigned short *ramp )
2005 +{
2006 +       XF86VidModeSetGammaRamp( x11display.dpy, x11display.scr, stride, ramp, ramp + stride, ramp + ( stride << 1 ) );
2007 +}
2008 +
2009 +/*
2010 +** GLimp_AppActivate
2011 +*/
2012 +void GLimp_AppActivate( qboolean active, qboolean destroy )
2013 +{
2014 +}
2015 +
2016 diff -ru a/unix/unix_input.c b/unix/unix_input.c
2017 --- a/unix/unix_input.c 2011-04-29 14:42:24.000000000 +0200
2018 +++ b/unix/unix_input.c 2011-10-03 22:13:53.000000000 +0200
2019 @@ -748,6 +748,13 @@
2020                 case ClientMessage:
2021                         if( event.xclient.data.l[0] == x11display.wmDeleteWindow )
2022                                 Cbuf_ExecuteText( EXEC_NOW, "quit" );
2023 +
2024 +            if( event.xclient.data.l[0] == x11display.ping )
2025 +            {
2026 +                event.xclient.window = x11display.root;
2027 +                       XSendEvent( x11display.dpy, x11display.root, False,
2028 +                           (SubstructureNotifyMask|SubstructureRedirectMask), &event );
2029 +            }
2030                         break;
2031
2032                 case MapNotify:
2033 diff -ru a/unix/x11.h b/unix/x11.h
2034 --- a/unix/x11.h        2011-04-29 14:42:24.000000000 +0200
2035 +++ b/unix/x11.h        2011-10-03 22:11:30.000000000 +0200
2036 @@ -18,6 +18,7 @@
2037         GLXContext ctx;
2038         XVisualInfo *visinfo;
2039         Atom wmDeleteWindow;
2040 +    Atom ping;
2041
2042         Atom wmState;
2043         struct featureset_s {