kitty/glfw/cocoa_monitor.m
Kovid Goyal 0adc6745c8
macOS: Require macOS 14 and drop code for older versions
Increase the minimum supported macOS version from 12 to 14. Remove the
CVDisplayLink fallback, using only CADisplayLink. Since CADisplayLink fires
on the main thread, the display link locking and cross thread dispatch are no
longer needed. Also remove other code paths that were only used on macOS
versions older than 14.
2026-11-19 19:57:34 +05:30

516 lines
18 KiB
Objective-C

//========================================================================
// GLFW 3.4 macOS - www.glfw.org
//------------------------------------------------------------------------
// Copyright (c) 2002-2006 Marcus Geelnard
// 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.
//
//========================================================================
// It is fine to use C99 in this file because it will not be built with VS
//========================================================================
#include "internal.h"
#include <stdlib.h>
#include <limits.h>
#include <math.h>
#include <assert.h>
#include <IOKit/graphics/IOGraphicsLib.h>
#include <ApplicationServices/ApplicationServices.h>
// Get the name of the specified display, or NULL
//
static char *
getDisplayName(CGDirectDisplayID displayID, NSScreen *screen) {
// IOKit doesn't work on Apple Silicon anymore, so use
// -[NSScreen localizedName] and fall back to IOKit if there is no screen.
if (screen) {
NSString *name = screen.localizedName;
if (name) { return _glfw_strdup([name UTF8String]); }
}
io_iterator_t it;
io_service_t service;
CFDictionaryRef info;
if (IOServiceGetMatchingServices(0, IOServiceMatching("IODisplayConnect"), &it) != 0) {
// This may happen if a desktop Mac is running headless
return NULL;
}
while ((service = IOIteratorNext(it)) != 0) {
info = IODisplayCreateInfoDictionary(service, kIODisplayOnlyPreferredName);
CFNumberRef vendorIDRef = CFDictionaryGetValue(info, CFSTR(kDisplayVendorID));
CFNumberRef productIDRef = CFDictionaryGetValue(info, CFSTR(kDisplayProductID));
if (!vendorIDRef || !productIDRef) {
CFRelease(info);
continue;
}
unsigned int vendorID, productID;
CFNumberGetValue(vendorIDRef, kCFNumberIntType, &vendorID);
CFNumberGetValue(productIDRef, kCFNumberIntType, &productID);
if (CGDisplayVendorNumber(displayID) == vendorID && CGDisplayModelNumber(displayID) == productID) {
// Info dictionary is used and freed below
break;
}
CFRelease(info);
}
IOObjectRelease(it);
if (!service) {
_glfwInputError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to find service port for display");
return NULL;
}
CFDictionaryRef names = CFDictionaryGetValue(info, CFSTR(kDisplayProductName));
CFStringRef nameRef;
if (!names || !CFDictionaryGetValueIfPresent(names, CFSTR("en_US"), (const void **)&nameRef)) {
// This may happen if a desktop Mac is running headless
CFRelease(info);
return NULL;
}
const CFIndex size = CFStringGetMaximumSizeForEncoding(CFStringGetLength(nameRef), kCFStringEncodingUTF8);
char *name = calloc(size + 1, 1);
CFStringGetCString(nameRef, name, size, kCFStringEncodingUTF8);
CFRelease(info);
return name;
}
// Check whether the display mode should be included in enumeration
//
static bool
modeIsGood(CGDisplayModeRef mode) {
uint32_t flags = CGDisplayModeGetIOFlags(mode);
if (!(flags & kDisplayModeValidFlag) || !(flags & kDisplayModeSafeFlag)) return false;
if (flags & kDisplayModeInterlacedFlag) return false;
if (flags & kDisplayModeStretchedFlag) return false;
#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) && CFStringCompare(format, CFSTR(IO32BitDirectPixels), 0)) {
CFRelease(format);
return false;
}
CFRelease(format);
#endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
return true;
}
// Convert Core Graphics display mode to GLFW video mode
//
static GLFWvidmode
vidmodeFromCGDisplayMode(CGDisplayModeRef mode, double fallbackRefreshRate) {
GLFWvidmode result;
result.width = (int)CGDisplayModeGetWidth(mode);
result.height = (int)CGDisplayModeGetHeight(mode);
result.refreshRate = (int)round(CGDisplayModeGetRefreshRate(mode));
if (result.refreshRate == 0) result.refreshRate = (int)round(fallbackRefreshRate);
#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
CFStringRef format = CGDisplayModeCopyPixelEncoding(mode);
if (CFStringCompare(format, CFSTR(IO16BitDirectPixels), 0) == 0) {
result.redBits = 5;
result.greenBits = 5;
result.blueBits = 5;
} else
#endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
{
result.redBits = 8;
result.greenBits = 8;
result.blueBits = 8;
}
#if MAC_OS_X_VERSION_MAX_ALLOWED <= 101100
CFRelease(format);
#endif /* MAC_OS_X_VERSION_MAX_ALLOWED */
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);
}
}
// Finds and caches the NSScreen corresponding to the specified monitor
//
static bool
refreshMonitorScreen(_GLFWmonitor *monitor) {
if (monitor->ns.screen) return true;
for (NSScreen *screen in [NSScreen screens]) {
NSNumber *displayID = [screen deviceDescription][@"NSScreenNumber"];
// HACK: Compare unit numbers instead of display IDs to work around
// display replacement on machines with automatic graphics
// switching
if (monitor->ns.unitNumber == CGDisplayUnitNumber([displayID unsignedIntValue])) {
monitor->ns.screen = screen;
return true;
}
}
_glfwInputError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to find a screen for monitor");
return false;
}
// Returns the display refresh rate queried from the I/O registry
//
static double
getFallbackRefreshRate(CGDirectDisplayID displayID) {
double refreshRate = 60.0;
io_iterator_t it;
io_service_t service;
if (IOServiceGetMatchingServices(0, IOServiceMatching("IOFramebuffer"), &it) != 0) { return refreshRate; }
while ((service = IOIteratorNext(it)) != 0) {
const CFNumberRef indexRef = IORegistryEntryCreateCFProperty(service, CFSTR("IOFramebufferOpenGLIndex"), kCFAllocatorDefault, kNilOptions);
if (!indexRef) continue;
uint32_t index = 0;
CFNumberGetValue(indexRef, kCFNumberIntType, &index);
CFRelease(indexRef);
if (CGOpenGLDisplayMaskToDisplayID(1 << index) != displayID) continue;
const CFNumberRef clockRef = IORegistryEntryCreateCFProperty(service, CFSTR("IOFBCurrentPixelClock"), kCFAllocatorDefault, kNilOptions);
const CFNumberRef countRef = IORegistryEntryCreateCFProperty(service, CFSTR("IOFBCurrentPixelCount"), kCFAllocatorDefault, kNilOptions);
uint32_t clock = 0, count = 0;
if (clockRef) {
CFNumberGetValue(clockRef, kCFNumberIntType, &clock);
CFRelease(clockRef);
}
if (countRef) {
CFNumberGetValue(countRef, kCFNumberIntType, &count);
CFRelease(countRef);
}
if (clock > 0 && count > 0) refreshRate = clock / (double)count;
break;
}
IOObjectRelease(it);
return refreshRate;
}
//////////////////////////////////////////////////////////////////////////
////// GLFW internal API //////
//////////////////////////////////////////////////////////////////////////
// Poll for changes in the set of connected monitors
void
_glfwPollMonitorsNS(void) {
uint32_t displayCount;
CGGetOnlineDisplayList(0, NULL, &displayCount);
CGDirectDisplayID *displays = calloc(displayCount, sizeof(CGDirectDisplayID));
CGGetOnlineDisplayList(displayCount, displays, &displayCount);
_glfwClearDisplayLinks();
if (_glfw.hints.init.debugRendering) { fprintf(stderr, "Polling for monitors: %u found\n", displayCount); }
for (int i = 0; i < _glfw.monitorCount; i++) _glfw.monitors[i]->ns.screen = nil;
_GLFWmonitor **disconnected = NULL;
uint32_t disconnectedCount = _glfw.monitorCount;
if (disconnectedCount) {
disconnected = calloc(_glfw.monitorCount, sizeof(_GLFWmonitor *));
memcpy(disconnected, _glfw.monitors, _glfw.monitorCount * sizeof(_GLFWmonitor *));
}
for (uint32_t i = 0; i < displayCount; i++) {
if (CGDisplayIsAsleep(displays[i])) {
if (_glfw.hints.init.debugRendering) fprintf(stderr, "Ignoring sleeping display: %u", displays[i]);
continue;
}
const uint32_t unitNumber = CGDisplayUnitNumber(displays[i]);
NSScreen *screen = nil;
for (screen in [NSScreen screens]) {
NSNumber *screenNumber = [screen deviceDescription][@"NSScreenNumber"];
// HACK: Compare unit numbers instead of display IDs to work around
// display replacement on machines with automatic graphics
// switching
if (CGDisplayUnitNumber([screenNumber unsignedIntValue]) == unitNumber) break;
}
// HACK: Compare unit numbers instead of display IDs to work around
// display replacement on machines with automatic graphics
// switching
uint32_t j;
for (j = 0; j < disconnectedCount; j++) {
if (disconnected[j] && disconnected[j]->ns.unitNumber == unitNumber) {
disconnected[j]->ns.displayID = displays[i];
disconnected[j]->ns.screen = screen;
_glfwCreateDisplayLink(displays[i]);
disconnected[j] = NULL;
break;
}
}
if (j < disconnectedCount) continue;
const CGSize size = CGDisplayScreenSize(displays[i]);
char *name = getDisplayName(displays[i], screen);
if (!name) {
_glfwInputError(GLFW_PLATFORM_ERROR, "Failed to get name for display, using generic name");
name = _glfw_strdup("Display with no name");
}
_GLFWmonitor *monitor = _glfwAllocMonitor(name, (int)size.width, (int)size.height);
monitor->ns.displayID = displays[i];
monitor->ns.unitNumber = unitNumber;
monitor->ns.screen = screen;
_glfwCreateDisplayLink(monitor->ns.displayID);
free(name);
CGDisplayModeRef mode = CGDisplayCopyDisplayMode(displays[i]);
if (CGDisplayModeGetRefreshRate(mode) == 0.0) monitor->ns.fallbackRefreshRate = getFallbackRefreshRate(displays[i]);
CGDisplayModeRelease(mode);
_glfwInputMonitor(monitor, GLFW_CONNECTED, _GLFW_INSERT_LAST);
}
for (uint32_t i = 0; i < disconnectedCount; i++) {
if (disconnected[i]) _glfwInputMonitor(disconnected[i], GLFW_DISCONNECTED, 0);
}
free(disconnected);
free(displays);
_glfwRestartDisplayLinks();
}
// Change the current video mode
//
void
_glfwSetVideoModeNS(_GLFWmonitor *monitor, const GLFWvidmode *desired) {
GLFWvidmode current;
_glfwPlatformGetVideoMode(monitor, &current);
const GLFWvidmode *best = _glfwChooseVideoMode(monitor, desired);
if (_glfwCompareVideoModes(&current, best) == 0) return;
CFArrayRef modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
const CFIndex count = CFArrayGetCount(modes);
CGDisplayModeRef native = NULL;
for (CFIndex i = 0; i < count; i++) {
CGDisplayModeRef dm = (CGDisplayModeRef)CFArrayGetValueAtIndex(modes, i);
if (!modeIsGood(dm)) continue;
const GLFWvidmode mode = vidmodeFromCGDisplayMode(dm, monitor->ns.fallbackRefreshRate);
if (_glfwCompareVideoModes(best, &mode) == 0) {
native = dm;
break;
}
}
if (native) {
if (monitor->ns.previousMode == NULL) monitor->ns.previousMode = CGDisplayCopyDisplayMode(monitor->ns.displayID);
CGDisplayFadeReservationToken token = beginFadeReservation();
CGDisplaySetDisplayMode(monitor->ns.displayID, native, NULL);
endFadeReservation(token);
}
CFRelease(modes);
}
// Restore the previously saved (original) video mode
//
void
_glfwRestoreVideoModeNS(_GLFWmonitor *monitor) {
if (monitor->ns.previousMode) {
CGDisplayFadeReservationToken token = beginFadeReservation();
CGDisplaySetDisplayMode(monitor->ns.displayID, monitor->ns.previousMode, NULL);
endFadeReservation(token);
CGDisplayModeRelease(monitor->ns.previousMode);
monitor->ns.previousMode = NULL;
}
}
//////////////////////////////////////////////////////////////////////////
////// GLFW platform API //////
//////////////////////////////////////////////////////////////////////////
void
_glfwPlatformFreeMonitor(_GLFWmonitor *monitor UNUSED) {}
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;
}
void
_glfwPlatformGetMonitorContentScale(_GLFWmonitor *monitor, float *xscale, float *yscale) {
if (!refreshMonitorScreen(monitor)) return;
const NSRect points = [monitor->ns.screen frame];
const NSRect pixels = [monitor->ns.screen convertRectToBacking:points];
if (xscale) *xscale = (float)(pixels.size.width / points.size.width);
if (yscale) *yscale = (float)(pixels.size.height / points.size.height);
}
void
_glfwPlatformGetMonitorWorkarea(_GLFWmonitor *monitor, int *xpos, int *ypos, int *width, int *height) {
if (!refreshMonitorScreen(monitor)) return;
const NSRect frameRect = [monitor->ns.screen visibleFrame];
if (xpos) *xpos = (int)frameRect.origin.x;
if (ypos) *ypos = (int)_glfwTransformYNS(frameRect.origin.y + frameRect.size.height - 1);
if (width) *width = (int)frameRect.size.width;
if (height) *height = (int)frameRect.size.height;
}
GLFWvidmode *
_glfwPlatformGetVideoModes(_GLFWmonitor *monitor, int *count) {
*count = 0;
CFArrayRef modes = CGDisplayCopyAllDisplayModes(monitor->ns.displayID, NULL);
const CFIndex found = CFArrayGetCount(modes);
GLFWvidmode *result = calloc(found, sizeof(GLFWvidmode));
for (CFIndex i = 0; i < found; i++) {
CGDisplayModeRef dm = (CGDisplayModeRef)CFArrayGetValueAtIndex(modes, i);
if (!modeIsGood(dm)) continue;
const GLFWvidmode mode = vidmodeFromCGDisplayMode(dm, monitor->ns.fallbackRefreshRate);
CFIndex j;
for (j = 0; j < *count; j++) {
if (_glfwCompareVideoModes(result + j, &mode) == 0) break;
}
// Skip duplicate modes
if (j < *count) continue;
(*count)++;
result[*count - 1] = mode;
}
CFRelease(modes);
return result;
}
bool
_glfwPlatformGetVideoMode(_GLFWmonitor *monitor, GLFWvidmode *mode) {
CGDisplayModeRef native = CGDisplayCopyDisplayMode(monitor->ns.displayID);
if (!native) {
_glfwInputError(GLFW_PLATFORM_ERROR, "Cocoa: Failed to query display mode");
return false;
}
*mode = vidmodeFromCGDisplayMode(native, monitor->ns.fallbackRefreshRate);
CGDisplayModeRelease(native);
return true;
}
bool
_glfwPlatformGetGammaRamp(_GLFWmonitor *monitor, GLFWgammaramp *ramp) {
uint32_t size = CGDisplayGammaTableCapacity(monitor->ns.displayID);
CGGammaValue *values = calloc(size * 3, sizeof(CGGammaValue));
CGGetDisplayTransferByTable(monitor->ns.displayID, size, values, values + size, values + size * 2, &size);
_glfwAllocGammaArrays(ramp, size);
for (uint32_t i = 0; i < size; i++) {
ramp->red[i] = (unsigned short)(values[i] * 65535);
ramp->green[i] = (unsigned short)(values[i + size] * 65535);
ramp->blue[i] = (unsigned short)(values[i + size * 2] * 65535);
}
free(values);
return true;
}
void
_glfwPlatformSetGammaRamp(_GLFWmonitor *monitor, const GLFWgammaramp *ramp) {
CGGammaValue *values = calloc(ramp->size * 3, sizeof(CGGammaValue));
for (unsigned int i = 0; i < ramp->size; i++) {
values[i] = ramp->red[i] / 65535.f;
values[i + ramp->size] = ramp->green[i] / 65535.f;
values[i + ramp->size * 2] = ramp->blue[i] / 65535.f;
}
CGSetDisplayTransferByTable(monitor->ns.displayID, ramp->size, values, values + ramp->size, values + ramp->size * 2);
free(values);
}
//////////////////////////////////////////////////////////////////////////
////// GLFW native API //////
//////////////////////////////////////////////////////////////////////////
GLFWAPI CGDirectDisplayID
glfwGetCocoaMonitor(GLFWmonitor *handle) {
_GLFWmonitor *monitor = (_GLFWmonitor *)handle;
assert(monitor != NULL);
_GLFW_REQUIRE_INIT_OR_RETURN(kCGNullDirectDisplay);
return monitor->ns.displayID;
}