glfw/lib/x11/x11_fullscreen.c

557 lines
16 KiB
C
Raw Normal View History

2010-09-07 15:34:51 +00:00
//========================================================================
// GLFW - An OpenGL framework
// Platform: X11/GLX
2010-09-07 15:41:26 +00:00
// API version: 3.0
2010-09-07 15:34:51 +00:00
// WWW: http://www.glfw.org/
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// Copyright (c) 2006-2010 Camilla Berglund <elmindreda@elmindreda.org>
//
// This software is provided 'as-is', without any express or implied
// warranty. In no event will the authors be held liable for any damages
// arising from the use of this software.
//
// Permission is granted to anyone to use this software for any purpose,
// including commercial applications, and to alter it and redistribute it
// freely, subject to the following restrictions:
//
// 1. The origin of this software must not be misrepresented; you must not
// claim that you wrote the original software. If you use this software
// in a product, an acknowledgment in the product documentation would
// be appreciated but is not required.
//
// 2. Altered source versions must be plainly marked as such, and must not
// be misrepresented as being the original software.
//
// 3. This notice may not be removed or altered from any source
// distribution.
//
//========================================================================
#include "internal.h"
#include <limits.h>
//************************************************************************
//**** GLFW internal functions ****
//************************************************************************
//========================================================================
// Convert BPP to RGB bits (based on "best guess")
//========================================================================
2010-09-08 13:58:43 +00:00
static void BPP2RGB(int bpp, int* r, int* g, int* b)
2010-09-07 15:34:51 +00:00
{
int delta;
// Special case: BPP = 32 (I don't think this is necessary for X11??)
2010-09-08 13:51:25 +00:00
if (bpp == 32)
2010-09-07 15:34:51 +00:00
bpp = 24;
// Convert "bits per pixel" to red, green & blue sizes
*r = *g = *b = bpp / 3;
delta = bpp - (*r * 3);
2010-09-08 13:51:25 +00:00
if (delta >= 1)
2010-09-07 15:34:51 +00:00
*g = *g + 1;
2010-09-08 13:51:25 +00:00
if (delta == 2)
2010-09-07 15:34:51 +00:00
*r = *r + 1;
}
//========================================================================
// Finds the video mode closest in size to the specified desired size
//========================================================================
2010-09-08 13:58:43 +00:00
int _glfwGetClosestVideoMode(int screen, int* width, int* height, int* rate)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
#if defined(_GLFW_HAS_XRANDR)
2010-09-07 15:34:51 +00:00
int i, match, bestmatch;
int sizecount, bestsize;
int ratecount, bestrate;
2010-09-08 13:58:43 +00:00
short* ratelist;
XRRScreenConfiguration* sc;
XRRScreenSize* sizelist;
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
if (_glfwLibrary.XRandR.available)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
sc = XRRGetScreenInfo(_glfwLibrary.display,
RootWindow(_glfwLibrary.display, screen));
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
sizelist = XRRConfigSizes(sc, &sizecount);
2010-09-07 15:34:51 +00:00
// Find the best matching mode
bestsize = -1;
bestmatch = INT_MAX;
2010-09-08 13:51:25 +00:00
for (i = 0; i < sizecount; i++)
2010-09-07 15:34:51 +00:00
{
match = (*width - sizelist[i].width) *
(*width - sizelist[i].width) +
(*height - sizelist[i].height) *
(*height - sizelist[i].height);
2010-09-08 13:51:25 +00:00
if (match < bestmatch)
2010-09-07 15:34:51 +00:00
{
bestmatch = match;
bestsize = i;
}
}
2010-09-08 13:51:25 +00:00
if (bestsize != -1)
2010-09-07 15:34:51 +00:00
{
// Report width & height of best matching mode
*width = sizelist[bestsize].width;
*height = sizelist[bestsize].height;
2010-09-08 13:51:25 +00:00
if (*rate > 0)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
ratelist = XRRConfigRates(sc, bestsize, &ratecount);
2010-09-07 15:34:51 +00:00
bestrate = -1;
bestmatch = INT_MAX;
2010-09-08 13:51:25 +00:00
for (i = 0; i < ratecount; i++)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
match = abs(ratelist[i] - *rate);
if (match < bestmatch)
2010-09-07 15:34:51 +00:00
{
bestmatch = match;
bestrate = ratelist[i];
}
}
2010-09-08 13:51:25 +00:00
if (bestrate != -1)
2010-09-07 15:34:51 +00:00
*rate = bestrate;
}
}
// Free modelist
2010-09-08 13:51:25 +00:00
XRRFreeScreenConfigInfo(sc);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
if (bestsize != -1)
2010-09-07 15:34:51 +00:00
return bestsize;
}
2010-09-08 13:51:25 +00:00
#elif defined(_GLFW_HAS_XF86VIDMODE)
2010-09-08 13:58:43 +00:00
XF86VidModeModeInfo** modelist;
2010-09-07 15:34:51 +00:00
int modecount, i, bestmode, bestmatch, match;
// Use the XF86VidMode extension to control video resolution
2010-09-08 13:51:25 +00:00
if (_glfwLibrary.XF86VidMode.available)
2010-09-07 15:34:51 +00:00
{
// Get a list of all available display modes
2010-09-08 13:51:25 +00:00
XF86VidModeGetAllModeLines(_glfwLibrary.display, screen,
&modecount, &modelist);
2010-09-07 15:34:51 +00:00
// Find the best matching mode
bestmode = -1;
bestmatch = INT_MAX;
2010-09-08 13:51:25 +00:00
for (i = 0; i < modecount; i++)
2010-09-07 15:34:51 +00:00
{
match = (*width - modelist[i]->hdisplay) *
(*width - modelist[i]->hdisplay) +
(*height - modelist[i]->vdisplay) *
(*height - modelist[i]->vdisplay);
2010-09-08 13:51:25 +00:00
if (match < bestmatch)
2010-09-07 15:34:51 +00:00
{
bestmatch = match;
bestmode = i;
}
}
2010-09-08 13:51:25 +00:00
if (bestmode != -1)
2010-09-07 15:34:51 +00:00
{
// Report width & height of best matching mode
2010-09-08 13:51:25 +00:00
*width = modelist[bestmode]->hdisplay;
*height = modelist[bestmode]->vdisplay;
2010-09-07 15:34:51 +00:00
}
// Free modelist
2010-09-08 13:51:25 +00:00
XFree(modelist);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
if (bestmode != -1)
2010-09-07 15:34:51 +00:00
return bestmode;
}
#endif
// Default: Simply use the screen resolution
2010-09-08 13:51:25 +00:00
*width = DisplayWidth(_glfwLibrary.display, screen);
*height = DisplayHeight(_glfwLibrary.display, screen);
2010-09-07 15:34:51 +00:00
return 0;
}
//========================================================================
// Change the current video mode
//========================================================================
2010-09-08 13:51:25 +00:00
void _glfwSetVideoModeMODE(int screen, int mode, int rate)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
#if defined(_GLFW_HAS_XRANDR)
2010-09-08 13:58:43 +00:00
XRRScreenConfiguration* sc;
2010-09-07 15:34:51 +00:00
Window root;
2010-09-08 13:51:25 +00:00
if (_glfwLibrary.XRandR.available)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
root = RootWindow(_glfwLibrary.display, screen);
sc = XRRGetScreenInfo(_glfwLibrary.display, root);
2010-09-07 15:34:51 +00:00
// Remember old size and flag that we have changed the mode
2010-09-08 13:51:25 +00:00
if (!_glfwWin.FS.modeChanged)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
_glfwWin.FS.oldSizeID = XRRConfigCurrentConfiguration(sc, &_glfwWin.FS.oldRotation);
_glfwWin.FS.oldWidth = DisplayWidth(_glfwLibrary.display, screen);
_glfwWin.FS.oldHeight = DisplayHeight(_glfwLibrary.display, screen);
2010-09-07 15:34:51 +00:00
_glfwWin.FS.modeChanged = GL_TRUE;
}
2010-09-08 13:51:25 +00:00
if (rate > 0)
2010-09-07 15:34:51 +00:00
{
// Set desired configuration
2010-09-08 13:51:25 +00:00
XRRSetScreenConfigAndRate(_glfwLibrary.display,
sc,
root,
mode,
RR_Rotate_0,
(short) rate,
CurrentTime);
2010-09-07 15:34:51 +00:00
}
else
{
// Set desired configuration
2010-09-08 13:51:25 +00:00
XRRSetScreenConfig(_glfwLibrary.display,
sc,
root,
mode,
RR_Rotate_0,
CurrentTime);
2010-09-07 15:34:51 +00:00
}
2010-09-08 13:51:25 +00:00
XRRFreeScreenConfigInfo(sc);
2010-09-07 15:34:51 +00:00
}
2010-09-08 13:51:25 +00:00
#elif defined(_GLFW_HAS_XF86VIDMODE)
2010-09-07 15:34:51 +00:00
XF86VidModeModeInfo **modelist;
int modecount;
// Use the XF86VidMode extension to control video resolution
2010-09-08 13:51:25 +00:00
if (_glfwLibrary.XF86VidMode.available)
2010-09-07 15:34:51 +00:00
{
// Get a list of all available display modes
2010-09-08 13:51:25 +00:00
XF86VidModeGetAllModeLines(_glfwLibrary.display, screen,
&modecount, &modelist);
2010-09-07 15:34:51 +00:00
// Unlock mode switch if necessary
2010-09-08 13:51:25 +00:00
if (_glfwWin.FS.modeChanged)
XF86VidModeLockModeSwitch(_glfwLibrary.display, screen, 0);
2010-09-07 15:34:51 +00:00
// Change the video mode to the desired mode
2010-09-08 13:51:25 +00:00
XF86VidModeSwitchToMode(_glfwLibrary.display, screen,
modelist[mode]);
2010-09-07 15:34:51 +00:00
// Set viewport to upper left corner (where our window will be)
2010-09-08 13:51:25 +00:00
XF86VidModeSetViewPort(_glfwLibrary.display, screen, 0, 0);
2010-09-07 15:34:51 +00:00
// Lock mode switch
2010-09-08 13:51:25 +00:00
XF86VidModeLockModeSwitch(_glfwLibrary.display, screen, 1);
2010-09-07 15:34:51 +00:00
// Remember old mode and flag that we have changed the mode
2010-09-08 13:51:25 +00:00
if (!_glfwWin.FS.modeChanged)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
_glfwWin.FS.oldMode = *modelist[0];
2010-09-07 15:34:51 +00:00
_glfwWin.FS.modeChanged = GL_TRUE;
}
// Free mode list
2010-09-08 13:51:25 +00:00
XFree(modelist);
2010-09-07 15:34:51 +00:00
}
#endif
}
//========================================================================
// Change the current video mode
//========================================================================
2010-09-08 13:58:43 +00:00
void _glfwSetVideoMode(int screen, int* width, int* height, int* rate)
2010-09-07 15:34:51 +00:00
{
int bestmode;
2010-09-07 15:34:51 +00:00
// Find a best match mode
2010-09-08 13:51:25 +00:00
bestmode = _glfwGetClosestVideoMode(screen, width, height, rate);
2010-09-07 15:34:51 +00:00
// Change mode
2010-09-08 13:51:25 +00:00
_glfwSetVideoModeMODE(screen, bestmode, *rate);
2010-09-07 15:34:51 +00:00
}
//========================================================================
// Restore the previously saved (original) video mode
//========================================================================
2010-09-08 13:51:25 +00:00
void _glfwRestoreVideoMode(void)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
if (_glfwWin.FS.modeChanged)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
#if defined(_GLFW_HAS_XRANDR)
if (_glfwLibrary.XRandR.available)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:58:43 +00:00
XRRScreenConfiguration* sc;
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
if (_glfwLibrary.XRandR.available)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
sc = XRRGetScreenInfo(_glfwLibrary.display, _glfwWin.root);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
XRRSetScreenConfig(_glfwLibrary.display,
sc,
_glfwWin.root,
_glfwWin.FS.oldSizeID,
_glfwWin.FS.oldRotation,
CurrentTime);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
XRRFreeScreenConfigInfo(sc);
2010-09-07 15:34:51 +00:00
}
}
2010-09-08 13:51:25 +00:00
#elif defined(_GLFW_HAS_XF86VIDMODE)
if (_glfwLibrary.XF86VidMode.available)
2010-09-07 15:34:51 +00:00
{
// Unlock mode switch
2010-09-08 13:51:25 +00:00
XF86VidModeLockModeSwitch(_glfwLibrary.display, _glfwWin.screen, 0);
2010-09-07 15:34:51 +00:00
// Change the video mode back to the old mode
2010-09-08 13:51:25 +00:00
XF86VidModeSwitchToMode(_glfwLibrary.display,
2010-09-07 15:34:51 +00:00
_glfwWin.screen,
2010-09-08 13:51:25 +00:00
&_glfwWin.FS.oldMode);
2010-09-07 15:34:51 +00:00
}
#endif
_glfwWin.FS.modeChanged = GL_FALSE;
}
}
//************************************************************************
//**** Platform implementation functions ****
//************************************************************************
struct _glfwResolution
{
int width;
int height;
};
//========================================================================
// List available video modes
//========================================================================
2010-09-08 13:58:43 +00:00
int _glfwPlatformGetVideoModes(GLFWvidmode* list, int maxcount)
2010-09-07 15:34:51 +00:00
{
int count, k, l, r, g, b, rgba, gl;
int depth, screen;
2010-09-08 13:58:43 +00:00
Display* dpy;
XVisualInfo* vislist;
XVisualInfo dummy;
2010-09-07 15:34:51 +00:00
int viscount, rgbcount, rescount;
2010-09-08 13:58:43 +00:00
int* rgbarray;
struct _glfwResolution* resarray;
2010-09-08 13:51:25 +00:00
#if defined(_GLFW_HAS_XRANDR)
2010-09-08 13:58:43 +00:00
XRRScreenConfiguration* sc;
XRRScreenSize* sizelist;
2010-09-07 15:34:51 +00:00
int sizecount;
2010-09-08 13:51:25 +00:00
#elif defined(_GLFW_HAS_XF86VIDMODE)
2010-09-08 13:58:43 +00:00
XF86VidModeModeInfo** modelist;
2010-09-07 15:34:51 +00:00
int modecount, width, height;
#endif
// Get display and screen
dpy = _glfwLibrary.display;
2010-09-08 13:51:25 +00:00
screen = DefaultScreen(dpy);
2010-09-07 15:34:51 +00:00
// Get list of visuals
2010-09-08 13:51:25 +00:00
vislist = XGetVisualInfo(dpy, 0, &dummy, &viscount);
if (vislist == NULL)
2010-09-07 15:34:51 +00:00
return 0;
2010-09-08 13:51:25 +00:00
rgbarray = (int*) malloc(sizeof(int) * viscount);
2010-09-07 15:34:51 +00:00
rgbcount = 0;
// Build RGB array
2010-09-08 13:51:25 +00:00
for (k = 0; k < viscount; k++)
2010-09-07 15:34:51 +00:00
{
// Does the visual support OpenGL & true color?
2010-09-08 13:51:25 +00:00
glXGetConfig(dpy, &vislist[k], GLX_USE_GL, &gl);
glXGetConfig(dpy, &vislist[k], GLX_RGBA, &rgba);
if (gl && rgba)
2010-09-07 15:34:51 +00:00
{
// Get color depth for this visual
depth = vislist[k].depth;
// Convert to RGB
2010-09-08 13:51:25 +00:00
BPP2RGB(depth, &r, &g, &b);
depth = (r << 16) | (g << 8) | b;
2010-09-07 15:34:51 +00:00
// Is this mode unique?
2010-09-08 13:51:25 +00:00
for (l = 0; l < rgbcount; l++)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
if (depth == rgbarray[l])
2010-09-07 15:34:51 +00:00
break;
}
2010-09-08 13:51:25 +00:00
if (l >= rgbcount)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
rgbarray[rgbcount] = depth;
2010-09-07 15:34:51 +00:00
rgbcount++;
}
}
}
rescount = 0;
resarray = NULL;
// Build resolution array
2010-09-08 13:51:25 +00:00
#if defined(_GLFW_HAS_XRANDR)
if (_glfwLibrary.XRandR.available)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
sc = XRRGetScreenInfo(dpy, RootWindow(dpy, screen));
sizelist = XRRConfigSizes(sc, &sizecount);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
resarray = (struct _glfwResolution*) malloc(sizeof(struct _glfwResolution) * sizecount);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
for (k = 0; k < sizecount; k++)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
resarray[rescount].width = sizelist[k].width;
resarray[rescount].height = sizelist[k].height;
2010-09-07 15:34:51 +00:00
rescount++;
}
2010-09-08 13:51:25 +00:00
XRRFreeScreenConfigInfo(sc);
2010-09-07 15:34:51 +00:00
}
2010-09-08 13:51:25 +00:00
#elif defined(_GLFW_HAS_XF86VIDMODE)
if (_glfwLibrary.XF86VidMode.available)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
XF86VidModeGetAllModeLines(dpy, screen, &modecount, &modelist);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
resarray = (struct _glfwResolution*) malloc(sizeof(struct _glfwResolution) * modecount);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
for (k = 0; k < modecount; k++)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
width = modelist[k]->hdisplay;
height = modelist[k]->vdisplay;
2010-09-07 15:34:51 +00:00
// Is this mode unique?
2010-09-08 13:51:25 +00:00
for (l = 0; l < rescount; l++)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
if (width == resarray[l].width && height == resarray[l].height)
2010-09-07 15:34:51 +00:00
break;
}
2010-09-08 13:51:25 +00:00
if (l >= rescount)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
resarray[rescount].width = width;
resarray[rescount].height = height;
2010-09-07 15:34:51 +00:00
rescount++;
}
}
2010-09-08 13:51:25 +00:00
XFree(modelist);
2010-09-07 15:34:51 +00:00
}
#endif
2010-09-08 13:51:25 +00:00
if (!resarray)
2010-09-07 15:34:51 +00:00
{
rescount = 1;
2010-09-08 13:51:25 +00:00
resarray = (struct _glfwResolution*) malloc(sizeof(struct _glfwResolution) * rescount);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
resarray[ 0 ].width = DisplayWidth(dpy, screen);
resarray[ 0 ].height = DisplayHeight(dpy, screen);
2010-09-07 15:34:51 +00:00
}
// Build permutations of colors and resolutions
count = 0;
2010-09-08 13:51:25 +00:00
for (k = 0; k < rgbcount && count < maxcount; k++)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
for (l = 0; l < rescount && count < maxcount; l++)
2010-09-07 15:34:51 +00:00
{
2010-09-08 14:50:50 +00:00
list[count].width = resarray[l].width;
list[count].height = resarray[l].height;
list[count].redBits = (rgbarray[k] >> 16) & 255;
list[count].greenBits = (rgbarray[k] >> 8) & 255;
list[count].blueBits = rgbarray[k] & 255;
2010-09-07 15:34:51 +00:00
count++;
}
}
// Free visuals list
2010-09-08 13:51:25 +00:00
XFree(vislist);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
free(resarray);
free(rgbarray);
2010-09-07 15:34:51 +00:00
return count;
}
//========================================================================
// Get the desktop video mode
//========================================================================
2010-09-08 13:58:43 +00:00
void _glfwPlatformGetDesktopMode(GLFWvidmode* mode)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:58:43 +00:00
Display* dpy;
2010-09-08 13:51:25 +00:00
int bpp, screen;
#if defined(_GLFW_HAS_XF86VIDMODE)
2010-09-08 13:58:43 +00:00
XF86VidModeModeInfo** modelist;
2010-09-08 13:51:25 +00:00
int modecount;
2010-09-07 15:34:51 +00:00
#endif
// Get display and screen
dpy = _glfwLibrary.display;
2010-09-08 13:51:25 +00:00
screen = DefaultScreen(dpy);
2010-09-07 15:34:51 +00:00
// Get display depth
2010-09-08 13:51:25 +00:00
bpp = DefaultDepth(dpy, screen);
2010-09-07 15:34:51 +00:00
// Convert BPP to RGB bits
2010-09-08 14:50:50 +00:00
BPP2RGB(bpp, &mode->redBits, &mode->greenBits, &mode->blueBits);
2010-09-07 15:34:51 +00:00
2010-09-08 13:51:25 +00:00
#if defined(_GLFW_HAS_XRANDR)
if (_glfwLibrary.XRandR.available)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
if (_glfwWin.FS.modeChanged)
2010-09-07 15:34:51 +00:00
{
2010-09-08 14:50:50 +00:00
mode->width = _glfwWin.FS.oldWidth;
mode->height = _glfwWin.FS.oldHeight;
2010-09-07 15:34:51 +00:00
return;
}
}
2010-09-08 13:51:25 +00:00
#elif defined(_GLFW_HAS_XF86VIDMODE)
if (_glfwLibrary.XF86VidMode.available)
2010-09-07 15:34:51 +00:00
{
2010-09-08 13:51:25 +00:00
if (_glfwWin.FS.modeChanged)
2010-09-07 15:34:51 +00:00
{
// The old (desktop) mode is stored in _glfwWin.FS.oldMode
2010-09-08 14:50:50 +00:00
mode->width = _glfwWin.FS.oldMode.hdisplay;
mode->height = _glfwWin.FS.oldMode.vdisplay;
2010-09-07 15:34:51 +00:00
}
else
{
// Use the XF86VidMode extension to get list of video modes
2010-09-08 13:51:25 +00:00
XF86VidModeGetAllModeLines(dpy, screen, &modecount, &modelist);
2010-09-07 15:34:51 +00:00
// The first mode in the list is the current (desktio) mode
2010-09-08 14:50:50 +00:00
mode->width = modelist[0]->hdisplay;
mode->height = modelist[0]->vdisplay;
2010-09-07 15:34:51 +00:00
// Free list
2010-09-08 13:51:25 +00:00
XFree(modelist);
2010-09-07 15:34:51 +00:00
}
return;
}
#endif
// Get current display width and height
2010-09-08 14:50:50 +00:00
mode->width = DisplayWidth(dpy, screen);
mode->height = DisplayHeight(dpy, screen);
2010-09-07 15:34:51 +00:00
}