glfw/src/x11_monitor.c

357 lines
10 KiB
C
Raw Normal View History

//========================================================================
// GLFW - An OpenGL library
// Platform: X11 (Unix)
// API version: 3.0
// 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"
2012-09-12 19:04:24 +00:00
#include <limits.h>
#include <stdlib.h>
#include <string.h>
2012-09-12 19:04:24 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
// Set the current video mode for the specified monitor
2013-02-04 12:22:10 +00:00
//
void _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* mode)
2012-09-12 19:04:24 +00:00
{
if (_glfw.x11.randr.available)
2012-09-12 19:04:24 +00:00
{
int i, j, k;
XRRScreenResources* sr;
XRRCrtcInfo* ci;
RRMode bestMode = 0;
unsigned int leastSizeDiff = UINT_MAX;
2012-09-12 19:04:24 +00:00
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
2012-09-12 19:04:24 +00:00
for (i = 0; i < sr->nmode; i++)
2012-09-12 19:04:24 +00:00
{
GLboolean usable = GL_TRUE;
XRRModeInfo* mi = sr->modes + i;
2012-09-12 19:04:24 +00:00
for (j = 0; j < ci->noutput; j++)
{
XRROutputInfo* oi = XRRGetOutputInfo(_glfw.x11.display,
sr, ci->outputs[j]);
2012-09-12 19:04:24 +00:00
for (k = 0; k < oi->nmode; k++)
{
if (oi->modes[k] == mi->id)
break;
}
2012-09-12 19:04:24 +00:00
if (k == oi->nmode)
usable = GL_FALSE;
2012-09-12 19:04:24 +00:00
XRRFreeOutputInfo(oi);
}
2012-09-12 19:04:24 +00:00
if (!usable)
continue;
2012-09-12 19:04:24 +00:00
if (mi->modeFlags & RR_Interlace)
continue;
2012-09-12 19:04:24 +00:00
unsigned int sizeDiff = (mi->width - mode->width) *
(mi->width - mode->width) +
(mi->height - mode->height) *
(mi->height - mode->height);
2012-09-12 19:04:24 +00:00
if (sizeDiff < leastSizeDiff)
{
bestMode = mi->id;
leastSizeDiff = sizeDiff;
}
2012-09-12 19:04:24 +00:00
}
monitor->x11.oldMode = ci->mode;
2012-09-12 19:04:24 +00:00
XRRSetCrtcConfig(_glfw.x11.display,
sr, monitor->x11.crtc,
CurrentTime,
ci->x, ci->y,
bestMode,
ci->rotation,
ci->outputs,
ci->noutput);
2012-09-12 19:04:24 +00:00
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
}
2012-09-12 19:04:24 +00:00
}
// Restore the saved (original) video mode for the specified monitor
2013-02-04 12:22:10 +00:00
//
void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
2012-09-12 19:04:24 +00:00
{
if (_glfw.x11.randr.available)
2012-09-12 19:04:24 +00:00
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
2012-09-12 19:04:24 +00:00
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
2012-09-12 19:04:24 +00:00
XRRSetCrtcConfig(_glfw.x11.display,
sr, monitor->x11.crtc,
CurrentTime,
ci->x, ci->y,
monitor->x11.oldMode,
ci->rotation,
ci->outputs,
ci->noutput);
2012-09-12 19:04:24 +00:00
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
2012-09-12 19:04:24 +00:00
}
}
2012-08-16 17:11:31 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
2013-01-12 17:10:18 +00:00
_GLFWmonitor** _glfwPlatformGetMonitors(int* found)
{
2012-09-12 17:35:52 +00:00
_GLFWmonitor** monitors = NULL;
2011-10-03 16:48:59 +00:00
2013-01-12 17:10:18 +00:00
*found = 0;
if (_glfw.x11.randr.available)
{
2012-09-12 17:35:52 +00:00
int i;
2012-12-22 22:35:45 +00:00
RROutput primary;
2012-09-12 17:35:52 +00:00
XRRScreenResources* sr;
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
primary = XRRGetOutputPrimary(_glfw.x11.display, _glfw.x11.root);
2012-12-22 22:35:45 +00:00
2012-09-12 17:35:52 +00:00
monitors = (_GLFWmonitor**) calloc(sr->noutput, sizeof(_GLFWmonitor*));
if (!monitors)
{
2012-10-21 21:55:41 +00:00
XRRFreeScreenResources(sr);
_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
2012-09-12 17:35:52 +00:00
return NULL;
}
for (i = 0; i < sr->ncrtc; i++)
{
int j;
2012-09-12 17:35:52 +00:00
XRROutputInfo* oi;
XRRCrtcInfo* ci;
RROutput output;
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, sr->crtcs[i]);
2013-02-17 12:57:25 +00:00
output = ci->outputs[0];
for (j = 0; j < ci->noutput; j++)
{
2013-02-17 12:57:25 +00:00
if (ci->outputs[j] == primary)
{
output = primary;
break;
}
}
oi = XRRGetOutputInfo(_glfw.x11.display, sr, output);
2012-09-12 17:35:52 +00:00
if (oi->connection != RR_Connected)
{
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
2012-09-12 17:35:52 +00:00
continue;
}
2013-01-12 17:10:18 +00:00
monitors[*found] = _glfwCreateMonitor(oi->name,
output == primary,
2013-01-12 17:10:18 +00:00
oi->mm_width, oi->mm_height,
ci->x, ci->y);
2012-09-12 17:35:52 +00:00
monitors[*found]->x11.output = output;
monitors[*found]->x11.crtc = oi->crtc;
2012-09-12 17:35:52 +00:00
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
2012-09-12 17:35:52 +00:00
2013-01-12 17:10:18 +00:00
(*found)++;
}
XRRFreeScreenResources(sr);
}
2013-01-12 17:10:18 +00:00
else
{
int widthMM, heightMM;
monitors = (_GLFWmonitor**) calloc(1, sizeof(_GLFWmonitor*));
if (!monitors)
{
_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
return NULL;
}
widthMM = DisplayWidthMM(_glfw.x11.display, _glfw.x11.screen);
heightMM = DisplayHeightMM(_glfw.x11.display, _glfw.x11.screen);
monitors[0] = _glfwCreateMonitor("Display",
GL_TRUE,
widthMM, heightMM,
0, 0);
*found = 1;
}
2012-09-12 17:35:52 +00:00
return monitors;
}
void _glfwPlatformDestroyMonitor(_GLFWmonitor* monitor)
{
}
2012-09-12 19:04:24 +00:00
GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
{
GLFWvidmode* result;
2012-12-27 20:13:04 +00:00
int depth, r, g, b;
2012-09-12 19:04:24 +00:00
depth = DefaultDepth(_glfw.x11.display, _glfw.x11.screen);
2012-12-27 20:13:04 +00:00
_glfwSplitBPP(depth, &r, &g, &b);
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
*found = 0;
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
// Build array of available resolutions
2012-09-12 19:04:24 +00:00
if (_glfw.x11.randr.available)
2012-12-27 20:13:04 +00:00
{
int i, j;
2012-12-27 20:13:04 +00:00
XRRScreenResources* sr;
XRROutputInfo* oi;
2012-09-12 19:04:24 +00:00
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
2012-09-12 19:04:24 +00:00
result = (GLFWvidmode*) malloc(sizeof(GLFWvidmode) * oi->nmode);
if (!result)
{
_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
return NULL;
}
2012-09-12 19:04:24 +00:00
for (i = 0; i < oi->nmode; i++)
2012-09-12 19:04:24 +00:00
{
2012-12-27 20:13:04 +00:00
GLFWvidmode mode;
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
for (j = 0; j < sr->nmode; j++)
{
if (sr->modes[j].id == oi->modes[i])
2012-12-27 20:13:04 +00:00
break;
}
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
if (j == sr->nmode)
continue;
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
mode.width = sr->modes[j].width;
mode.height = sr->modes[j].height;
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
for (j = 0; j < *found; j++)
{
if (result[j].width == mode.width &&
result[j].height == mode.height)
{
break;
}
}
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
if (j < *found)
{
// This is a duplicate, so skip it
continue;
}
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
mode.redBits = r;
mode.greenBits = g;
mode.blueBits = b;
2012-09-12 19:04:24 +00:00
2012-12-27 20:13:04 +00:00
result[*found] = mode;
2012-09-12 19:04:24 +00:00
(*found)++;
}
2012-12-27 20:13:04 +00:00
XRRFreeOutputInfo(oi);
2012-12-27 20:13:04 +00:00
XRRFreeScreenResources(sr);
2012-09-12 19:04:24 +00:00
}
2013-01-12 17:10:18 +00:00
else
2012-12-27 20:13:04 +00:00
{
*found = 1;
2012-12-27 20:13:04 +00:00
result = (GLFWvidmode*) malloc(sizeof(GLFWvidmode));
if (!result)
{
_glfwInputError(GLFW_OUT_OF_MEMORY, NULL);
return NULL;
}
2012-12-27 20:13:04 +00:00
result[0].width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
result[0].height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
2012-12-27 20:13:04 +00:00
result[0].redBits = r;
result[0].greenBits = g;
result[0].blueBits = b;
}
2012-09-12 19:04:24 +00:00
return result;
}
void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
{
if (_glfw.x11.randr.available)
{
XRRScreenResources* sr;
XRRCrtcInfo* ci;
sr = XRRGetScreenResources(_glfw.x11.display, _glfw.x11.root);
ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
mode->width = ci->width;
mode->height = ci->height;
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
}
else
{
mode->width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
mode->height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
}
_glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
2012-09-12 19:04:24 +00:00
&mode->redBits, &mode->greenBits, &mode->blueBits);
}