glfw/src/win32_monitor.c

393 lines
11 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"
#include <stdlib.h>
#include <string.h>
2012-09-12 19:04:24 +00:00
#include <limits.h>
#include <malloc.h>
2012-09-12 18:46:54 +00:00
// These constants are missing on MinGW
#ifndef EDS_ROTATEDMODE
2012-09-12 18:46:54 +00:00
#define EDS_ROTATEDMODE 0x00000004
#endif
2012-01-31 22:47:01 +00:00
#ifndef DISPLAY_DEVICE_ACTIVE
2012-09-12 18:46:54 +00:00
#define DISPLAY_DEVICE_ACTIVE 0x00000001
2012-01-31 22:47:01 +00:00
#endif
2012-09-12 19:04:24 +00:00
//========================================================================
// Return closest video mode by dimensions, refresh rate and bits per pixel
//========================================================================
static GLboolean getClosestVideoMode(int* width, int* height,
int* bpp, int* refreshRate,
GLboolean exactBPP)
{
int mode, bestWidth, bestHeight, bestBPP, bestRate;
unsigned int sizeDiff, rateDiff, leastSizeDiff, leastRateDiff;
GLboolean foundMode = GL_FALSE;
DEVMODE dm;
leastSizeDiff = leastRateDiff = UINT_MAX;
for (mode = 0; ; mode++)
{
dm.dmSize = sizeof(DEVMODE);
if (!EnumDisplaySettings(NULL, mode, &dm))
break;
if (exactBPP && dm.dmBitsPerPel != *bpp)
continue;
sizeDiff = (abs(dm.dmBitsPerPel - *bpp) << 25) |
((dm.dmPelsWidth - *width) *
(dm.dmPelsWidth - *width) +
(dm.dmPelsHeight - *height) *
(dm.dmPelsHeight - *height));
if (*refreshRate > 0)
{
rateDiff = (dm.dmDisplayFrequency - *refreshRate) *
(dm.dmDisplayFrequency - *refreshRate);
}
else
{
// If no refresh rate was specified, then they're all the same
rateDiff = 0;
}
// We match first BPP, then screen area and last refresh rate
if ((sizeDiff < leastSizeDiff) ||
(sizeDiff == leastSizeDiff && (rateDiff < leastRateDiff)))
{
bestWidth = dm.dmPelsWidth;
bestHeight = dm.dmPelsHeight;
bestBPP = dm.dmBitsPerPel;
bestRate = dm.dmDisplayFrequency;
leastSizeDiff = sizeDiff;
leastRateDiff = rateDiff;
foundMode = GL_TRUE;
}
}
if (!foundMode)
return GL_FALSE;
*width = bestWidth;
*height = bestHeight;
*bpp = bestBPP;
// Only save the found refresh rate if the client requested a specific
// rate; otherwise keep it at zero to let Windows select the best rate
if (*refreshRate > 0)
*refreshRate = bestRate;
return GL_TRUE;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
// Change the current video mode
//========================================================================
void _glfwSetVideoMode(int* width, int* height,
int* bpp, int* refreshRate,
GLboolean exactBPP)
{
DEVMODE dm;
int closestWidth, closestHeight, closestBPP, closestRate;
closestWidth = *width;
closestHeight = *height;
closestBPP = *bpp;
closestRate = *refreshRate;
if (getClosestVideoMode(&closestWidth, &closestHeight,
&closestBPP, &closestRate, GL_FALSE))
{
dm.dmSize = sizeof(DEVMODE);
dm.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_BITSPERPEL;
dm.dmPelsWidth = closestWidth;
dm.dmPelsHeight = closestHeight;
dm.dmBitsPerPel = closestBPP;
if (*refreshRate > 0)
{
dm.dmFields |= DM_DISPLAYFREQUENCY;
dm.dmDisplayFrequency = closestRate;
}
if (ChangeDisplaySettings(&dm, CDS_FULLSCREEN) == DISP_CHANGE_SUCCESSFUL)
{
*width = closestWidth;
*height = closestHeight;
*bpp = closestBPP;
*refreshRate = closestRate;
}
}
else
{
dm.dmSize = sizeof(DEVMODE);
EnumDisplaySettings(NULL, ENUM_REGISTRY_SETTINGS, &dm);
*width = dm.dmPelsWidth;
*height = dm.dmPelsHeight;
*bpp = dm.dmBitsPerPel;
*refreshRate = dm.dmDisplayFrequency;
}
}
//========================================================================
// Restore the previously saved (original) video mode
//========================================================================
void _glfwRestoreVideoMode(void)
{
ChangeDisplaySettings(NULL, CDS_FULLSCREEN);
}
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
2012-07-06 12:36:29 +00:00
//========================================================================
2012-09-12 17:35:52 +00:00
// Return a list of available monitors
2012-07-06 12:36:29 +00:00
//========================================================================
2012-09-12 17:35:52 +00:00
_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
{
2012-09-12 17:35:52 +00:00
int size = 0, found = 0;
_GLFWmonitor** monitors = NULL;
DWORD adapterIndex = 0;
2012-09-12 17:35:52 +00:00
for (;;)
{
2012-09-12 18:54:12 +00:00
// Enumerate display adapters
2012-09-12 20:51:55 +00:00
DISPLAY_DEVICE adapter, monitor;
DEVMODE settings;
const char* name;
HDC dc;
2012-09-12 17:35:52 +00:00
ZeroMemory(&adapter, sizeof(DISPLAY_DEVICE));
adapter.cb = sizeof(DISPLAY_DEVICE);
2012-09-12 17:35:52 +00:00
if (!EnumDisplayDevices(NULL, adapterIndex, &adapter, 0))
break;
2012-09-12 17:35:52 +00:00
adapterIndex++;
2012-09-12 17:35:52 +00:00
if ((adapter.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) ||
!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
{
continue;
}
2012-09-12 20:51:55 +00:00
ZeroMemory(&settings, sizeof(DEVMODE));
settings.dmSize = sizeof(DEVMODE);
2012-09-12 17:35:52 +00:00
2012-09-12 20:51:55 +00:00
EnumDisplaySettingsEx(adapter.DeviceName,
ENUM_CURRENT_SETTINGS,
&settings,
EDS_ROTATEDMODE);
2012-09-12 17:35:52 +00:00
2012-09-12 20:51:55 +00:00
name = _glfwCreateUTF8FromWideString(adapter.DeviceName);
if (!name)
{
// TODO: wat
return NULL;
}
2012-09-12 17:35:52 +00:00
2012-09-12 20:51:55 +00:00
if (found == size)
{
if (size)
size *= 2;
else
size = 4;
2012-09-12 17:35:52 +00:00
2012-09-12 20:51:55 +00:00
monitors = (_GLFWmonitor**) realloc(monitors, sizeof(_GLFWmonitor*) * size);
if (!monitors)
2012-09-12 17:35:52 +00:00
{
// TODO: wat
return NULL;
}
2012-09-12 20:51:55 +00:00
}
2012-09-12 17:35:52 +00:00
2012-09-12 20:51:55 +00:00
ZeroMemory(&monitor, sizeof(DISPLAY_DEVICE));
monitor.cb = sizeof(DISPLAY_DEVICE);
2012-09-12 17:35:52 +00:00
2012-09-12 20:51:55 +00:00
EnumDisplayDevices(adapter.DeviceName, 0, &monitor, 0);
dc = CreateDC(L"DISPLAY", monitor.DeviceString, NULL, NULL);
2012-09-12 17:35:52 +00:00
2012-09-12 20:51:55 +00:00
monitors[found] = _glfwCreateMonitor(name,
GetDeviceCaps(dc, HORZSIZE),
GetDeviceCaps(dc, VERTSIZE),
settings.dmPosition.x,
settings.dmPosition.y);
2012-09-12 17:35:52 +00:00
2012-09-12 20:51:55 +00:00
DeleteDC(dc);
2012-09-12 17:35:52 +00:00
2012-09-12 20:51:55 +00:00
if (!monitors[found])
{
// TODO: wat
return NULL;
2012-09-12 17:35:52 +00:00
}
2012-09-12 20:51:55 +00:00
2012-09-12 22:05:54 +00:00
monitors[found]->Win32.name = _wcsdup(adapter.DeviceName);
2012-09-12 20:51:55 +00:00
found++;
2012-09-12 17:35:52 +00:00
}
2012-07-06 11:55:54 +00:00
2012-09-12 17:35:52 +00:00
*count = found;
return monitors;
}
2012-07-06 12:36:29 +00:00
//========================================================================
// Destroy a monitor struct
//========================================================================
2012-09-12 17:35:52 +00:00
void _glfwPlatformDestroyMonitor(_GLFWmonitor* monitor)
{
2012-07-06 11:55:54 +00:00
free(monitor->Win32.name);
}
2012-09-12 19:04:24 +00:00
//========================================================================
// Get a list of available video modes
//========================================================================
GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
{
int modeIndex = 0, count = 0;
GLFWvidmode* result = NULL;
*found = 0;
for (;;)
{
int i;
GLFWvidmode mode;
DEVMODE dm;
ZeroMemory(&dm, sizeof(DEVMODE));
dm.dmSize = sizeof(DEVMODE);
if (!EnumDisplaySettings(monitor->Win32.name, modeIndex, &dm))
break;
modeIndex++;
if (dm.dmBitsPerPel < 15)
{
// Skip modes with less than 15 BPP
continue;
}
mode.width = dm.dmPelsWidth;
mode.height = dm.dmPelsHeight;
_glfwSplitBPP(dm.dmBitsPerPel,
2012-09-12 21:03:15 +00:00
&mode.redBits,
&mode.greenBits,
&mode.blueBits);
2012-09-12 19:04:24 +00:00
for (i = 0; i < *found; i++)
{
if (_glfwCompareVideoModes(result + i, &mode) == 0)
break;
}
if (i < *found)
{
// This is a duplicate, so skip it
continue;
}
if (*found == count)
{
void* larger;
if (count)
count *= 2;
else
count = 128;
larger = realloc(result, count * sizeof(GLFWvidmode));
if (!larger)
{
free(result);
_glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
return NULL;
}
result = (GLFWvidmode*) larger;
}
result[*found] = mode;
(*found)++;
}
return result;
}
//========================================================================
// Get the current video mode for the specified monitor
//========================================================================
void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
{
DEVMODE dm;
ZeroMemory(&dm, sizeof(DEVMODE));
dm.dmSize = sizeof(DEVMODE);
EnumDisplaySettings(monitor->Win32.name, ENUM_REGISTRY_SETTINGS, &dm);
mode->width = dm.dmPelsWidth;
mode->height = dm.dmPelsHeight;
_glfwSplitBPP(dm.dmBitsPerPel,
&mode->redBits,
&mode->greenBits,
&mode->blueBits);
}