glfw/src/monitor.c

434 lines
12 KiB
C
Raw Normal View History

//========================================================================
// GLFW - An OpenGL framework
// Platform: Any
// 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 <string.h>
2012-09-12 17:35:52 +00:00
#include <stdlib.h>
#if defined(_MSC_VER)
2012-09-12 19:04:24 +00:00
#include <malloc.h>
2012-09-12 22:05:54 +00:00
#define strdup _strdup
2012-09-12 19:04:24 +00:00
#endif
//========================================================================
// Lexical comparison function for GLFW video modes, used by qsort
//========================================================================
2012-09-12 21:03:07 +00:00
static int compareVideoModes(const void* firstPtr, const void* secondPtr)
2012-09-12 19:04:24 +00:00
{
int firstBPP, secondBPP, firstSize, secondSize;
GLFWvidmode* first = (GLFWvidmode*) firstPtr;
GLFWvidmode* second = (GLFWvidmode*) secondPtr;
// First sort on color bits per pixel
firstBPP = first->redBits +
first->greenBits +
first->blueBits;
secondBPP = second->redBits +
second->greenBits +
second->blueBits;
if (firstBPP != secondBPP)
return firstBPP - secondBPP;
// Then sort on screen area, in pixels
firstSize = first->width * first->height;
secondSize = second->width * second->height;
return firstSize - secondSize;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
2012-09-12 17:35:52 +00:00
// Create a monitor struct from the specified information
//========================================================================
2012-09-12 17:35:52 +00:00
_GLFWmonitor* _glfwCreateMonitor(const char* name,
2012-09-13 15:46:40 +00:00
GLboolean primary,
2012-09-12 17:35:52 +00:00
int physicalWidth, int physicalHeight,
int screenX, int screenY)
{
2012-09-12 17:35:52 +00:00
_GLFWmonitor* monitor = (_GLFWmonitor*) calloc(1, sizeof(_GLFWmonitor));
if (!monitor)
{
_glfwSetError(GLFW_OUT_OF_MEMORY, NULL);
return NULL;
}
monitor->name = strdup(name);
2012-09-13 15:46:40 +00:00
monitor->primary = primary;
2012-09-12 17:35:52 +00:00
monitor->physicalWidth = physicalWidth;
monitor->physicalHeight = physicalHeight;
monitor->screenX = screenX;
monitor->screenY = screenY;
return monitor;
}
//========================================================================
2012-09-12 17:35:52 +00:00
// Destroy the specified monitor
//========================================================================
2012-09-12 17:35:52 +00:00
void _glfwDestroyMonitor(_GLFWmonitor* monitor)
{
2012-09-12 17:35:52 +00:00
if (monitor == NULL)
return;
2012-09-12 17:35:52 +00:00
_glfwPlatformDestroyMonitor(monitor);
2012-09-12 17:35:52 +00:00
free(monitor->modes);
free(monitor->name);
free(monitor);
}
2012-09-12 17:35:52 +00:00
//========================================================================
// Enumerate monitors and notify user of changes
//========================================================================
2012-09-12 17:35:52 +00:00
void _glfwInputMonitorChange(void)
{
int i, j, monitorCount;
_GLFWmonitor** monitors;
2012-09-12 17:35:52 +00:00
monitors = _glfwPlatformGetMonitors(&monitorCount);
2012-09-12 17:35:52 +00:00
for (i = 0; i < monitorCount; i++)
{
for (j = 0; j < _glfwLibrary.monitorCount; j++)
{
2012-09-12 17:35:52 +00:00
if (_glfwLibrary.monitors[j] == NULL)
continue;
if (strcmp(monitors[i]->name, _glfwLibrary.monitors[j]->name) == 0)
{
2012-09-12 17:35:52 +00:00
// This monitor was connected before, so re-use the existing
// monitor object to preserve its address and user pointer
_glfwDestroyMonitor(monitors[i]);
monitors[i] = _glfwLibrary.monitors[j];
_glfwLibrary.monitors[j] = NULL;
break;
}
}
2012-09-12 17:35:52 +00:00
if (j == _glfwLibrary.monitorCount)
{
2012-09-12 17:35:52 +00:00
// This monitor was not connected before
_glfwLibrary.monitorCallback(monitors[i], GLFW_MONITOR_CONNECTED);
}
}
2012-09-12 17:35:52 +00:00
for (i = 0; i < _glfwLibrary.monitorCount; i++)
{
if (_glfwLibrary.monitors[i] == NULL)
continue;
// This monitor is no longer connected
_glfwLibrary.monitorCallback(_glfwLibrary.monitors[i],
GLFW_MONITOR_DISCONNECTED);
}
_glfwDestroyMonitors();
_glfwLibrary.monitors = monitors;
_glfwLibrary.monitorCount = monitorCount;
}
//========================================================================
2012-09-12 17:35:52 +00:00
// Destroy all monitors
//========================================================================
2012-09-12 17:35:52 +00:00
void _glfwDestroyMonitors(void)
{
2012-09-12 17:35:52 +00:00
int i;
for (i = 0; i < _glfwLibrary.monitorCount; i++)
_glfwDestroyMonitor(_glfwLibrary.monitors[i]);
free(_glfwLibrary.monitors);
_glfwLibrary.monitors = NULL;
_glfwLibrary.monitorCount = 0;
}
2012-09-12 19:04:24 +00:00
//========================================================================
// Lexical comparison of GLFW video modes
//========================================================================
int _glfwCompareVideoModes(const GLFWvidmode* first, const GLFWvidmode* second)
{
return compareVideoModes(first, second);
}
//========================================================================
// Convert BPP to RGB bits based on "best guess"
//========================================================================
void _glfwSplitBPP(int bpp, int* red, int* green, int* blue)
{
int delta;
// We assume that by 32 the user really meant 24
if (bpp == 32)
bpp = 24;
// Convert "bits per pixel" to red, green & blue sizes
*red = *green = *blue = bpp / 3;
delta = bpp - (*red * 3);
if (delta >= 1)
*green = *green + 1;
if (delta == 2)
*red = *red + 1;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW public API //////
//////////////////////////////////////////////////////////////////////////
//========================================================================
2012-09-12 17:35:52 +00:00
// Return the currently connected monitors
//========================================================================
2012-09-12 17:35:52 +00:00
GLFWAPI GLFWmonitor* glfwGetMonitors(int* count)
{
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
2012-08-14 14:55:48 +00:00
return NULL;
}
2012-09-12 17:35:52 +00:00
if (count == NULL)
{
_glfwSetError(GLFW_INVALID_VALUE, NULL);
return NULL;
}
*count = _glfwLibrary.monitorCount;
return (GLFWmonitor*) _glfwLibrary.monitors;
}
//========================================================================
// Get the primary monitor
//========================================================================
GLFWAPI GLFWmonitor glfwGetPrimaryMonitor(void)
{
2012-09-13 15:46:40 +00:00
int i;
GLFWmonitor handle = NULL;
2012-09-12 17:35:52 +00:00
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
2012-09-13 15:46:40 +00:00
for (i = 0; i < _glfwLibrary.monitorCount; i++)
{
if (_glfwLibrary.monitors[i]->primary)
{
handle = _glfwLibrary.monitors[i];
break;
}
}
if (!handle)
{
_glfwSetError(GLFW_PLATFORM_ERROR, NULL);
return NULL;
}
return handle;
}
//========================================================================
// Get monitor parameter
//========================================================================
GLFWAPI int glfwGetMonitorParam(GLFWmonitor handle, int param)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return 0;
}
if (monitor == NULL)
{
_glfwSetError(GLFW_INVALID_VALUE,
"glfwGetMonitorParam: Invalid monitor handle");
return 0;
}
switch (param)
{
case GLFW_MONITOR_PHYSICAL_WIDTH:
return monitor->physicalWidth;
case GLFW_MONITOR_PHYSICAL_HEIGHT:
return monitor->physicalHeight;
case GLFW_MONITOR_SCREEN_POS_X:
return monitor->screenX;
case GLFW_MONITOR_SCREEN_POS_Y:
return monitor->screenY;
}
_glfwSetError(GLFW_INVALID_ENUM,
"glfwGetMonitorParam: Invalid enum value for 'param' parameter");
return 0;
}
//========================================================================
// Get monitor string
//========================================================================
GLFWAPI const char* glfwGetMonitorString(GLFWmonitor handle, int param)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
if (monitor == NULL)
{
_glfwSetError(GLFW_INVALID_VALUE,
"glfwGetMonitorString: Invalid monitor handle");
return NULL;
}
switch (param)
{
case GLFW_MONITOR_NAME:
return monitor->name;
}
_glfwSetError(GLFW_INVALID_ENUM,
"glfwGetMonitorString: Invalid enum value for 'param' parameter");
return NULL;
}
2012-07-06 12:36:29 +00:00
//========================================================================
// Set a callback function for monitor events
//========================================================================
GLFWAPI void glfwSetMonitorCallback(GLFWmonitorfun cbfun)
{
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return;
}
_glfwLibrary.monitorCallback= cbfun;
}
2012-09-12 19:04:24 +00:00
//========================================================================
// Get a list of available video modes
//========================================================================
GLFWAPI GLFWvidmode* glfwGetVideoModes(GLFWmonitor handle, int* count)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return NULL;
}
if (monitor == NULL)
{
_glfwSetError(GLFW_INVALID_VALUE,
"glfwGetVideoModes: Invalid monitor handle");
return 0;
}
if (count == NULL)
{
_glfwSetError(GLFW_INVALID_VALUE, NULL);
return NULL;
}
free(monitor->modes);
monitor->modes = _glfwPlatformGetVideoModes(monitor, count);
if (monitor->modes)
qsort(monitor->modes, *count, sizeof(GLFWvidmode), compareVideoModes);
return monitor->modes;
}
//========================================================================
// Get the current video mode for the specified monitor
//========================================================================
GLFWAPI void glfwGetVideoMode(GLFWmonitor handle, GLFWvidmode* mode)
{
_GLFWmonitor* monitor = (_GLFWmonitor*) handle;
if (!_glfwInitialized)
{
_glfwSetError(GLFW_NOT_INITIALIZED, NULL);
return;
}
if (mode == NULL)
{
_glfwSetError(GLFW_INVALID_VALUE, NULL);
return;
}
_glfwPlatformGetVideoMode(monitor, mode);
}