mirror of
https://github.com/glfw/glfw.git
synced 2024-11-14 14:33:52 +00:00
372 lines
11 KiB
Objective-C
372 lines
11 KiB
Objective-C
//========================================================================
|
|
// GLFW - An OpenGL library
|
|
// Platform: Cocoa
|
|
// 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 <limits.h>
|
|
|
|
#include <IOKit/graphics/IOGraphicsLib.h>
|
|
|
|
|
|
// Get the name of the specified display
|
|
//
|
|
static const char* getDisplayName(CGDirectDisplayID displayID)
|
|
{
|
|
char* name;
|
|
CFDictionaryRef info, names;
|
|
CFStringRef value;
|
|
CFIndex size;
|
|
|
|
info = IODisplayCreateInfoDictionary(CGDisplayIOServicePort(displayID),
|
|
kIODisplayOnlyPreferredName);
|
|
names = CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
|
|
|
|
if (!CFDictionaryGetValueIfPresent(names, CFSTR("en_US"),
|
|
(const void**) &value))
|
|
{
|
|
CFRelease(info);
|
|
return strdup("Unknown");
|
|
}
|
|
|
|
size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(value),
|
|
kCFStringEncodingUTF8);
|
|
name = (char*) malloc(size + 1);
|
|
CFStringGetCString(value, name, size, kCFStringEncodingUTF8);
|
|
|
|
CFRelease(info);
|
|
|
|
return name;
|
|
}
|
|
|
|
// Check whether the display mode should be included in enumeration
|
|
//
|
|
static GLboolean modeIsGood(CGDisplayModeRef mode)
|
|
{
|
|
uint32_t flags = CGDisplayModeGetIOFlags(mode);
|
|
if (!(flags & kDisplayModeValidFlag) || !(flags & kDisplayModeSafeFlag))
|
|
return GL_FALSE;
|
|
|
|
if (flags & kDisplayModeInterlacedFlag)
|
|
return GL_FALSE;
|
|
|
|
if (flags & kDisplayModeTelevisionFlag)
|
|
return GL_FALSE;
|
|
|
|
if (flags & kDisplayModeStretchedFlag)
|
|
return GL_FALSE;
|
|
|
|
CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
|
|
if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) &&
|
|
CFStringCompare(format, CFSTR(IO32BitDirectPixels), 0))
|
|
{
|
|
CFRelease(format);
|
|
return GL_FALSE;
|
|
}
|
|
|
|
CFRelease(format);
|
|
return GL_TRUE;
|
|
}
|
|
|
|
// Convert Core Graphics display mode to GLFW video mode
|
|
//
|
|
static GLFWvidmode vidmodeFromCGDisplayMode(CGDisplayModeRef mode)
|
|
{
|
|
GLFWvidmode result;
|
|
result.width = CGDisplayModeGetWidth(mode);
|
|
result.height = CGDisplayModeGetHeight(mode);
|
|
result.refreshRate = (int) CGDisplayModeGetRefreshRate(mode);
|
|
|
|
CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
|
|
|
|
if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
|
|
{
|
|
result.redBits = 5;
|
|
result.greenBits = 5;
|
|
result.blueBits = 5;
|
|
}
|
|
else
|
|
{
|
|
result.redBits = 8;
|
|
result.greenBits = 8;
|
|
result.blueBits = 8;
|
|
}
|
|
|
|
CFRelease(format);
|
|
return result;
|
|
}
|
|
|
|
// Starts reservation for display fading
|
|
//
|
|
static CGDisplayFadeReservationToken beginFadeReservation(void)
|
|
{
|
|
CGDisplayFadeReservationToken token = kCGDisplayFadeReservationInvalidToken;
|
|
|
|
if (CGAcquireDisplayFadeReservation(5, &token) == kCGErrorSuccess)
|
|
CGDisplayFade(token, 0.3, kCGDisplayBlendNormal, kCGDisplayBlendSolidColor, 0.0, 0.0, 0.0, TRUE);
|
|
|
|
return token;
|
|
}
|
|
|
|
// Ends reservation for display fading
|
|
//
|
|
static void endFadeReservation(CGDisplayFadeReservationToken token)
|
|
{
|
|
if (token != kCGDisplayFadeReservationInvalidToken)
|
|
{
|
|
CGDisplayFade(token, 0.5, kCGDisplayBlendSolidColor, kCGDisplayBlendNormal, 0.0, 0.0, 0.0, FALSE);
|
|
CGReleaseDisplayFadeReservation(token);
|
|
}
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
////// GLFW internal API //////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// Change the current video mode
|
|
//
|
|
GLboolean _glfwSetVideoMode(_GLFWmonitor* monitor, const GLFWvidmode* desired)
|
|
{
|
|
CGDisplayModeRef bestMode = NULL;
|
|
CFArrayRef modes;
|
|
CFIndex count, i;
|
|
unsigned int sizeDiff, leastSizeDiff = UINT_MAX;
|
|
unsigned int rateDiff, leastRateDiff = UINT_MAX;
|
|
const int bpp = desired->redBits - desired->greenBits - desired->blueBits;
|
|
|
|
modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
|
|
count = CFArrayGetCount(modes);
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
CGDisplayModeRef mode = (CGDisplayModeRef) CFArrayGetValueAtIndex(modes, i);
|
|
if (!modeIsGood(mode))
|
|
continue;
|
|
|
|
int modeBPP;
|
|
|
|
// Identify display mode pixel encoding
|
|
{
|
|
CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
|
|
|
|
if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0)
|
|
modeBPP = 16;
|
|
else
|
|
modeBPP = 32;
|
|
|
|
CFRelease(format);
|
|
}
|
|
|
|
const int modeWidth = (int) CGDisplayModeGetWidth(mode);
|
|
const int modeHeight = (int) CGDisplayModeGetHeight(mode);
|
|
const int modeRate = (int) CGDisplayModeGetRefreshRate(mode);
|
|
|
|
sizeDiff = (abs(modeBPP - bpp) << 25) |
|
|
((modeWidth - desired->width) * (modeWidth - desired->width) +
|
|
(modeHeight - desired->height) * (modeHeight - desired->height));
|
|
|
|
if (desired->refreshRate)
|
|
rateDiff = abs(modeRate - desired->refreshRate);
|
|
else
|
|
rateDiff = UINT_MAX - modeRate;
|
|
|
|
if ((sizeDiff < leastSizeDiff) ||
|
|
(sizeDiff == leastSizeDiff && rateDiff < leastRateDiff))
|
|
{
|
|
bestMode = mode;
|
|
leastSizeDiff = sizeDiff;
|
|
leastRateDiff = rateDiff;
|
|
}
|
|
}
|
|
|
|
if (!bestMode)
|
|
{
|
|
CFRelease(modes);
|
|
return GL_FALSE;
|
|
}
|
|
|
|
monitor->ns.previousMode = CGDisplayCopyDisplayMode(monitor->ns.displayID);
|
|
|
|
CGDisplayFadeReservationToken token = beginFadeReservation();
|
|
|
|
CGDisplayCapture(monitor->ns.displayID);
|
|
CGDisplaySetDisplayMode(monitor->ns.displayID, bestMode, NULL);
|
|
|
|
endFadeReservation(token);
|
|
|
|
CFRelease(modes);
|
|
return GL_TRUE;
|
|
}
|
|
|
|
// Restore the previously saved (original) video mode
|
|
//
|
|
void _glfwRestoreVideoMode(_GLFWmonitor* monitor)
|
|
{
|
|
CGDisplayFadeReservationToken token = beginFadeReservation();
|
|
|
|
CGDisplaySetDisplayMode(monitor->ns.displayID, monitor->ns.previousMode, NULL);
|
|
CGDisplayRelease(monitor->ns.displayID);
|
|
|
|
endFadeReservation(token);
|
|
}
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
////// GLFW platform API //////
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
_GLFWmonitor** _glfwPlatformGetMonitors(int* count)
|
|
{
|
|
uint32_t i, found = 0, monitorCount;
|
|
_GLFWmonitor** monitors;
|
|
CGDirectDisplayID* displays;
|
|
|
|
*count = 0;
|
|
|
|
CGGetActiveDisplayList(0, NULL, &monitorCount);
|
|
|
|
displays = (CGDirectDisplayID*) calloc(monitorCount, sizeof(CGDirectDisplayID));
|
|
monitors = (_GLFWmonitor**) calloc(monitorCount, sizeof(_GLFWmonitor*));
|
|
|
|
CGGetActiveDisplayList(monitorCount, displays, &monitorCount);
|
|
|
|
for (i = 0; i < monitorCount; i++)
|
|
{
|
|
const CGSize size = CGDisplayScreenSize(displays[i]);
|
|
|
|
monitors[found] = _glfwCreateMonitor(getDisplayName(displays[i]),
|
|
size.width, size.height);
|
|
|
|
monitors[found]->ns.displayID = displays[i];
|
|
found++;
|
|
}
|
|
|
|
free(displays);
|
|
|
|
for (i = 0; i < monitorCount; i++)
|
|
{
|
|
if (CGDisplayIsMain(monitors[i]->ns.displayID))
|
|
{
|
|
_GLFWmonitor* temp = monitors[0];
|
|
monitors[0] = monitors[i];
|
|
monitors[i] = temp;
|
|
break;
|
|
}
|
|
}
|
|
|
|
NSArray* screens = [NSScreen screens];
|
|
|
|
for (i = 0; i < monitorCount; i++)
|
|
{
|
|
int j;
|
|
|
|
for (j = 0; j < [screens count]; j++)
|
|
{
|
|
NSScreen* screen = [screens objectAtIndex:j];
|
|
NSDictionary* dictionary = [screen deviceDescription];
|
|
NSNumber* number = [dictionary objectForKey:@"NSScreenNumber"];
|
|
|
|
if (monitors[i]->ns.displayID == [number unsignedIntegerValue])
|
|
{
|
|
monitors[i]->ns.screen = screen;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (monitors[i]->ns.screen == nil)
|
|
{
|
|
_glfwDestroyMonitors(monitors, monitorCount);
|
|
_glfwInputError(GLFW_PLATFORM_ERROR,
|
|
"Cocoa: Failed to find NSScreen for CGDisplay %s",
|
|
monitors[i]->name);
|
|
|
|
free(monitors);
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
*count = monitorCount;
|
|
return monitors;
|
|
}
|
|
|
|
GLboolean _glfwPlatformIsSameMonitor(_GLFWmonitor* first, _GLFWmonitor* second)
|
|
{
|
|
return first->ns.displayID == second->ns.displayID;
|
|
}
|
|
|
|
void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
|
|
{
|
|
const CGRect bounds = CGDisplayBounds(monitor->ns.displayID);
|
|
|
|
if (xpos)
|
|
*xpos = (int) bounds.origin.x;
|
|
if (ypos)
|
|
*ypos = (int) bounds.origin.y;
|
|
}
|
|
|
|
GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
|
|
{
|
|
CFArrayRef modes;
|
|
CFIndex count, i;
|
|
GLFWvidmode* result;
|
|
|
|
modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
|
|
count = CFArrayGetCount(modes);
|
|
|
|
result = (GLFWvidmode*) malloc(sizeof(GLFWvidmode) * count);
|
|
*found = 0;
|
|
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
CGDisplayModeRef mode;
|
|
|
|
mode = (CGDisplayModeRef) CFArrayGetValueAtIndex(modes, i);
|
|
if (modeIsGood(mode))
|
|
{
|
|
result[*found] = vidmodeFromCGDisplayMode(mode);
|
|
(*found)++;
|
|
}
|
|
}
|
|
|
|
CFRelease(modes);
|
|
return result;
|
|
}
|
|
|
|
void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode *mode)
|
|
{
|
|
CGDisplayModeRef displayMode;
|
|
|
|
displayMode = CGDisplayCopyDisplayMode(monitor->ns.displayID);
|
|
*mode = vidmodeFromCGDisplayMode(displayMode);
|
|
CGDisplayModeRelease(displayMode);
|
|
}
|
|
|