glfw/src/x11_monitor.c

647 lines
20 KiB
C
Raw Normal View History

//========================================================================
2024-02-29 14:28:46 +00:00
// GLFW 3.5 X11 - www.glfw.org
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
2019-04-15 18:50:00 +00:00
// Copyright (c) 2006-2019 Camilla Löwy <elmindreda@glfw.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"
#if defined(_GLFW_X11)
2012-09-12 19:04:24 +00:00
#include <limits.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <assert.h>
2014-02-13 13:25:26 +00:00
// Check whether the display mode should be included in enumeration
//
2015-08-23 17:30:04 +00:00
static GLFWbool modeIsGood(const XRRModeInfo* mi)
2014-02-13 13:25:26 +00:00
{
return (mi->modeFlags & RR_Interlace) == 0;
}
// Calculates the refresh rate, in Hz, from the specified RandR mode info
//
2013-05-30 13:52:42 +00:00
static int calculateRefreshRate(const XRRModeInfo* mi)
{
2014-02-13 13:25:26 +00:00
if (mi->hTotal && mi->vTotal)
return (int) round((double) mi->dotClock / ((double) mi->hTotal * (double) mi->vTotal));
2014-02-13 13:25:26 +00:00
else
2013-05-30 13:52:42 +00:00
return 0;
}
2014-02-13 13:25:26 +00:00
// Returns the mode info for a RandR mode XID
//
2013-05-30 13:52:42 +00:00
static const XRRModeInfo* getModeInfo(const XRRScreenResources* sr, RRMode id)
{
2019-06-04 14:51:31 +00:00
for (int i = 0; i < sr->nmode; i++)
2013-05-30 13:52:42 +00:00
{
if (sr->modes[i].id == id)
return sr->modes + i;
}
return NULL;
}
2014-02-13 13:25:26 +00:00
// Convert RandR mode info to GLFW video mode
//
static GLFWvidmode vidmodeFromModeInfo(const XRRModeInfo* mi,
const XRRCrtcInfo* ci)
2014-02-13 13:25:26 +00:00
{
GLFWvidmode mode;
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
mode.width = mi->height;
mode.height = mi->width;
}
else
{
mode.width = mi->width;
mode.height = mi->height;
}
2014-02-13 13:25:26 +00:00
mode.refreshRate = calculateRefreshRate(mi);
_glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
&mode.redBits, &mode.greenBits, &mode.blueBits);
return mode;
}
2013-05-30 13:52:42 +00:00
2012-09-12 19:04:24 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
// Poll for changes in the set of connected monitors
//
void _glfwPollMonitorsX11(void)
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
2019-06-04 14:51:31 +00:00
int disconnectedCount, screenCount = 0;
2017-02-16 04:23:10 +00:00
_GLFWmonitor** disconnected = NULL;
XineramaScreenInfo* screens = NULL;
XRRScreenResources* sr = XRRGetScreenResourcesCurrent(_glfw.x11.display,
_glfw.x11.root);
RROutput primary = XRRGetOutputPrimary(_glfw.x11.display,
_glfw.x11.root);
if (_glfw.x11.xinerama.available)
screens = XineramaQueryScreens(_glfw.x11.display, &screenCount);
disconnectedCount = _glfw.monitorCount;
2017-02-16 04:23:10 +00:00
if (disconnectedCount)
{
disconnected = _glfw_calloc(_glfw.monitorCount, sizeof(_GLFWmonitor*));
2017-02-16 04:23:10 +00:00
memcpy(disconnected,
_glfw.monitors,
_glfw.monitorCount * sizeof(_GLFWmonitor*));
}
2019-06-04 14:51:31 +00:00
for (int i = 0; i < sr->noutput; i++)
{
2019-06-04 14:51:31 +00:00
int j, type, widthMM, heightMM;
2019-06-04 14:51:31 +00:00
XRROutputInfo* oi = XRRGetOutputInfo(_glfw.x11.display, sr, sr->outputs[i]);
if (oi->connection != RR_Connected || oi->crtc == None)
{
XRRFreeOutputInfo(oi);
continue;
}
for (j = 0; j < disconnectedCount; j++)
{
if (disconnected[j] &&
disconnected[j]->x11.output == sr->outputs[i])
{
disconnected[j] = NULL;
break;
}
}
if (j < disconnectedCount)
{
XRRFreeOutputInfo(oi);
continue;
}
2019-06-04 14:51:31 +00:00
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, oi->crtc);
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
widthMM = oi->mm_height;
heightMM = oi->mm_width;
}
else
{
widthMM = oi->mm_width;
heightMM = oi->mm_height;
}
if (widthMM <= 0 || heightMM <= 0)
{
// HACK: If RandR does not provide a physical size, assume the
2020-06-23 14:20:27 +00:00
// X11 default 96 DPI and calculate from the CRTC viewport
// NOTE: These members are affected by rotation, unlike the mode
// info and output info members
widthMM = (int) (ci->width * 25.4f / 96.f);
heightMM = (int) (ci->height * 25.4f / 96.f);
}
2019-06-04 14:51:31 +00:00
_GLFWmonitor* monitor = _glfwAllocMonitor(oi->name, widthMM, heightMM);
monitor->x11.output = sr->outputs[i];
monitor->x11.crtc = oi->crtc;
for (j = 0; j < screenCount; j++)
{
if (screens[j].x_org == ci->x &&
screens[j].y_org == ci->y &&
screens[j].width == ci->width &&
screens[j].height == ci->height)
{
monitor->x11.index = j;
break;
}
}
if (monitor->x11.output == primary)
type = _GLFW_INSERT_FIRST;
else
type = _GLFW_INSERT_LAST;
_glfwInputMonitor(monitor, GLFW_CONNECTED, type);
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
}
XRRFreeScreenResources(sr);
if (screens)
XFree(screens);
2019-06-04 14:51:31 +00:00
for (int i = 0; i < disconnectedCount; i++)
{
if (disconnected[i])
_glfwInputMonitor(disconnected[i], GLFW_DISCONNECTED, 0);
}
_glfw_free(disconnected);
}
else
{
const int widthMM = DisplayWidthMM(_glfw.x11.display, _glfw.x11.screen);
const int heightMM = DisplayHeightMM(_glfw.x11.display, _glfw.x11.screen);
_glfwInputMonitor(_glfwAllocMonitor("Display", widthMM, heightMM),
GLFW_CONNECTED,
_GLFW_INSERT_FIRST);
}
}
// Set the current video mode for the specified monitor
2013-02-04 12:22:10 +00:00
//
void _glfwSetVideoModeX11(_GLFWmonitor* monitor, const GLFWvidmode* desired)
2012-09-12 19:04:24 +00:00
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
2012-09-12 19:04:24 +00:00
{
2014-02-13 13:25:26 +00:00
GLFWvidmode current;
RRMode native = None;
2019-06-04 14:51:31 +00:00
const GLFWvidmode* best = _glfwChooseVideoMode(monitor, desired);
_glfwGetVideoModeX11(monitor, &current);
2014-02-13 13:25:26 +00:00
if (_glfwCompareVideoModes(&current, best) == 0)
return;
2012-09-12 19:04:24 +00:00
2019-06-04 14:51:31 +00:00
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
XRROutputInfo* oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
2012-09-12 19:04:24 +00:00
2019-06-04 14:51:31 +00:00
for (int i = 0; i < oi->nmode; i++)
2012-09-12 19:04:24 +00:00
{
2014-02-13 13:25:26 +00:00
const XRRModeInfo* mi = getModeInfo(sr, oi->modes[i]);
if (!modeIsGood(mi))
2013-05-30 18:42:50 +00:00
continue;
const GLFWvidmode mode = vidmodeFromModeInfo(mi, ci);
2014-02-13 13:25:26 +00:00
if (_glfwCompareVideoModes(best, &mode) == 0)
{
2014-02-13 13:25:26 +00:00
native = mi->id;
break;
}
2012-09-12 19:04:24 +00:00
}
2014-02-13 13:25:26 +00:00
if (native)
{
if (monitor->x11.oldMode == None)
monitor->x11.oldMode = ci->mode;
XRRSetCrtcConfig(_glfw.x11.display,
sr, monitor->x11.crtc,
CurrentTime,
ci->x, ci->y,
native,
ci->rotation,
ci->outputs,
ci->noutput);
}
2012-09-12 19:04:24 +00:00
2013-05-30 18:42:50 +00:00
XRRFreeOutputInfo(oi);
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 _glfwRestoreVideoModeX11(_GLFWmonitor* monitor)
2012-09-12 19:04:24 +00:00
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
2012-09-12 19:04:24 +00:00
{
if (monitor->x11.oldMode == None)
return;
2019-06-04 14:51:31 +00:00
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* 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);
monitor->x11.oldMode = None;
2012-09-12 19:04:24 +00:00
}
}
2012-08-16 17:11:31 +00:00
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
void _glfwFreeMonitorX11(_GLFWmonitor* monitor)
{
}
void _glfwGetMonitorPosX11(_GLFWmonitor* monitor, int* xpos, int* ypos)
2013-02-20 15:00:53 +00:00
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
2013-02-20 15:00:53 +00:00
{
2019-06-04 14:51:31 +00:00
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
2013-02-20 15:00:53 +00:00
if (ci)
{
if (xpos)
*xpos = ci->x;
if (ypos)
*ypos = ci->y;
XRRFreeCrtcInfo(ci);
}
2013-02-20 15:00:53 +00:00
XRRFreeScreenResources(sr);
}
}
void _glfwGetMonitorContentScaleX11(_GLFWmonitor* monitor,
float* xscale, float* yscale)
{
if (xscale)
*xscale = _glfw.x11.contentScaleX;
if (yscale)
*yscale = _glfw.x11.contentScaleY;
}
void _glfwGetMonitorWorkareaX11(_GLFWmonitor* monitor,
int* xpos, int* ypos,
int* width, int* height)
{
int areaX = 0, areaY = 0, areaWidth = 0, areaHeight = 0;
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
2019-06-04 14:51:31 +00:00
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
areaX = ci->x;
areaY = ci->y;
const XRRModeInfo* mi = getModeInfo(sr, ci->mode);
if (ci->rotation == RR_Rotate_90 || ci->rotation == RR_Rotate_270)
{
areaWidth = mi->height;
areaHeight = mi->width;
}
else
{
areaWidth = mi->width;
areaHeight = mi->height;
}
XRRFreeCrtcInfo(ci);
XRRFreeScreenResources(sr);
}
else
{
areaWidth = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
areaHeight = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
}
if (_glfw.x11.NET_WORKAREA && _glfw.x11.NET_CURRENT_DESKTOP)
{
Atom* extents = NULL;
Atom* desktop = NULL;
const unsigned long extentCount =
_glfwGetWindowPropertyX11(_glfw.x11.root,
_glfw.x11.NET_WORKAREA,
XA_CARDINAL,
(unsigned char**) &extents);
if (_glfwGetWindowPropertyX11(_glfw.x11.root,
_glfw.x11.NET_CURRENT_DESKTOP,
XA_CARDINAL,
(unsigned char**) &desktop) > 0)
{
if (extentCount >= 4 && *desktop < extentCount / 4)
{
const int globalX = extents[*desktop * 4 + 0];
const int globalY = extents[*desktop * 4 + 1];
const int globalWidth = extents[*desktop * 4 + 2];
const int globalHeight = extents[*desktop * 4 + 3];
if (areaX < globalX)
{
areaWidth -= globalX - areaX;
areaX = globalX;
}
if (areaY < globalY)
{
areaHeight -= globalY - areaY;
areaY = globalY;
}
if (areaX + areaWidth > globalX + globalWidth)
areaWidth = globalX - areaX + globalWidth;
if (areaY + areaHeight > globalY + globalHeight)
areaHeight = globalY - areaY + globalHeight;
}
}
if (extents)
XFree(extents);
if (desktop)
XFree(desktop);
}
if (xpos)
*xpos = areaX;
if (ypos)
*ypos = areaY;
if (width)
*width = areaWidth;
if (height)
*height = areaHeight;
}
GLFWvidmode* _glfwGetVideoModesX11(_GLFWmonitor* monitor, int* count)
2012-09-12 19:04:24 +00:00
{
GLFWvidmode* result;
*count = 0;
2012-09-12 19:04:24 +00:00
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
2012-12-27 20:13:04 +00:00
{
2019-06-04 14:51:31 +00:00
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
XRROutputInfo* oi = XRRGetOutputInfo(_glfw.x11.display, sr, monitor->x11.output);
2012-09-12 19:04:24 +00:00
result = _glfw_calloc(oi->nmode, sizeof(GLFWvidmode));
2012-09-12 19:04:24 +00:00
2019-06-04 14:51:31 +00:00
for (int i = 0; i < oi->nmode; i++)
2012-09-12 19:04:24 +00:00
{
2013-05-30 13:52:42 +00:00
const XRRModeInfo* mi = getModeInfo(sr, oi->modes[i]);
2014-02-13 13:25:26 +00:00
if (!modeIsGood(mi))
continue;
2012-09-12 19:04:24 +00:00
const GLFWvidmode mode = vidmodeFromModeInfo(mi, ci);
2019-06-04 14:51:31 +00:00
int j;
2012-09-12 19:04:24 +00:00
for (j = 0; j < *count; j++)
2012-12-27 20:13:04 +00:00
{
2014-09-22 17:25:05 +00:00
if (_glfwCompareVideoModes(result + j, &mode) == 0)
2012-12-27 20:13:04 +00:00
break;
}
2012-09-12 19:04:24 +00:00
// Skip duplicate modes
if (j < *count)
2012-12-27 20:13:04 +00:00
continue;
2012-09-12 19:04:24 +00:00
(*count)++;
result[*count - 1] = mode;
2012-09-12 19:04:24 +00:00
}
2012-12-27 20:13:04 +00:00
XRRFreeOutputInfo(oi);
XRRFreeCrtcInfo(ci);
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
{
*count = 1;
result = _glfw_calloc(1, sizeof(GLFWvidmode));
_glfwGetVideoModeX11(monitor, result);
2012-12-27 20:13:04 +00:00
}
2012-09-12 19:04:24 +00:00
return result;
}
GLFWbool _glfwGetVideoModeX11(_GLFWmonitor* monitor, GLFWvidmode* mode)
2012-09-12 19:04:24 +00:00
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.monitorBroken)
{
2019-06-04 14:51:31 +00:00
XRRScreenResources* sr =
XRRGetScreenResourcesCurrent(_glfw.x11.display, _glfw.x11.root);
const XRRModeInfo* mi = NULL;
XRRCrtcInfo* ci = XRRGetCrtcInfo(_glfw.x11.display, sr, monitor->x11.crtc);
if (ci)
{
mi = getModeInfo(sr, ci->mode);
if (mi)
*mode = vidmodeFromModeInfo(mi, ci);
XRRFreeCrtcInfo(ci);
}
2013-05-30 13:52:42 +00:00
XRRFreeScreenResources(sr);
if (!mi)
{
_glfwInputError(GLFW_PLATFORM_ERROR, "X11: Failed to query video mode");
return GLFW_FALSE;
}
}
else
{
mode->width = DisplayWidth(_glfw.x11.display, _glfw.x11.screen);
mode->height = DisplayHeight(_glfw.x11.display, _glfw.x11.screen);
2013-05-30 13:52:42 +00:00
mode->refreshRate = 0;
2014-02-13 13:25:26 +00:00
_glfwSplitBPP(DefaultDepth(_glfw.x11.display, _glfw.x11.screen),
&mode->redBits, &mode->greenBits, &mode->blueBits);
}
return GLFW_TRUE;
2012-09-12 19:04:24 +00:00
}
GLFWbool _glfwGetGammaRampX11(_GLFWmonitor* monitor, GLFWgammaramp* ramp)
2014-08-18 10:31:48 +00:00
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
const size_t size = XRRGetCrtcGammaSize(_glfw.x11.display,
monitor->x11.crtc);
XRRCrtcGamma* gamma = XRRGetCrtcGamma(_glfw.x11.display,
monitor->x11.crtc);
_glfwAllocGammaArrays(ramp, size);
2017-03-19 21:25:11 +00:00
memcpy(ramp->red, gamma->red, size * sizeof(unsigned short));
2014-08-18 10:31:48 +00:00
memcpy(ramp->green, gamma->green, size * sizeof(unsigned short));
2017-03-19 21:25:11 +00:00
memcpy(ramp->blue, gamma->blue, size * sizeof(unsigned short));
2014-08-18 10:31:48 +00:00
XRRFreeGamma(gamma);
return GLFW_TRUE;
2014-08-18 10:31:48 +00:00
}
else if (_glfw.x11.vidmode.available)
{
int size;
XF86VidModeGetGammaRampSize(_glfw.x11.display, _glfw.x11.screen, &size);
_glfwAllocGammaArrays(ramp, size);
XF86VidModeGetGammaRamp(_glfw.x11.display,
_glfw.x11.screen,
ramp->size, ramp->red, ramp->green, ramp->blue);
return GLFW_TRUE;
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Gamma ramp access not supported by server");
return GLFW_FALSE;
2014-08-18 10:31:48 +00:00
}
}
void _glfwSetGammaRampX11(_GLFWmonitor* monitor, const GLFWgammaramp* ramp)
2014-08-18 10:31:48 +00:00
{
if (_glfw.x11.randr.available && !_glfw.x11.randr.gammaBroken)
{
if (XRRGetCrtcGammaSize(_glfw.x11.display, monitor->x11.crtc) != ramp->size)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Gamma ramp size must match current ramp size");
return;
}
2014-08-18 10:31:48 +00:00
XRRCrtcGamma* gamma = XRRAllocGamma(ramp->size);
2017-03-19 21:25:11 +00:00
memcpy(gamma->red, ramp->red, ramp->size * sizeof(unsigned short));
2014-08-18 10:31:48 +00:00
memcpy(gamma->green, ramp->green, ramp->size * sizeof(unsigned short));
2017-03-19 21:25:11 +00:00
memcpy(gamma->blue, ramp->blue, ramp->size * sizeof(unsigned short));
2014-08-18 10:31:48 +00:00
XRRSetCrtcGamma(_glfw.x11.display, monitor->x11.crtc, gamma);
XRRFreeGamma(gamma);
}
else if (_glfw.x11.vidmode.available)
{
XF86VidModeSetGammaRamp(_glfw.x11.display,
_glfw.x11.screen,
ramp->size,
(unsigned short*) ramp->red,
(unsigned short*) ramp->green,
(unsigned short*) ramp->blue);
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"X11: Gamma ramp access not supported by server");
}
2014-08-18 10:31:48 +00:00
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
2014-10-28 14:35:03 +00:00
GLFWAPI RRCrtc glfwGetX11Adapter(GLFWmonitor* handle)
{
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
{
_glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "X11: Platform not initialized");
return None;
}
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
2014-10-28 14:35:03 +00:00
return monitor->x11.crtc;
}
GLFWAPI RROutput glfwGetX11Monitor(GLFWmonitor* handle)
{
_GLFW_REQUIRE_INIT_OR_RETURN(None);
if (_glfw.platform.platformID != GLFW_PLATFORM_X11)
{
_glfwInputError(GLFW_PLATFORM_UNAVAILABLE, "X11: Platform not initialized");
return None;
}
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
assert(monitor != NULL);
return monitor->x11.output;
}
#endif // _GLFW_X11