/* * MACDRV display settings * * Copyright 2003 Alexander James Pasadyn * Copyright 2011, 2012, 2013 Ken Thomases for CodeWeavers Inc. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the Free Software * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA */ #if 0 #pragma makedep unix #endif #include "config.h" #include "macdrv.h" #include "winuser.h" #include "winreg.h" #include "ddrawi.h" #define WIN32_NO_STATUS #include "winternl.h" WINE_DEFAULT_DEBUG_CHANNEL(display); #define NEXT_DEVMODEW(mode) ((DEVMODEW *)((char *)((mode) + 1) + (mode)->dmDriverExtra)) struct display_mode_descriptor { DWORD width; DWORD height; DWORD pixel_width; DWORD pixel_height; DWORD io_flags; double refresh; CFStringRef pixel_encoding; }; static const WCHAR initial_mode_keyW[] = {'I','n','i','t','i','a','l',' ','D','i','s','p','l','a','y', ' ','M','o','d','e'}; static const WCHAR pixelencodingW[] = {'P','i','x','e','l','E','n','c','o','d','i','n','g',0}; static BOOL inited_original_display_mode; static int display_mode_bits_per_pixel(CGDisplayModeRef display_mode) { CFStringRef pixel_encoding; int bits_per_pixel = 0; pixel_encoding = CGDisplayModeCopyPixelEncoding(display_mode); if (pixel_encoding) { if (CFEqual(pixel_encoding, CFSTR(kIO32BitFloatPixels))) bits_per_pixel = 128; else if (CFEqual(pixel_encoding, CFSTR(kIO16BitFloatPixels))) bits_per_pixel = 64; else if (CFEqual(pixel_encoding, CFSTR(kIO64BitDirectPixels))) bits_per_pixel = 64; else if (CFEqual(pixel_encoding, CFSTR(kIO30BitDirectPixels))) bits_per_pixel = 30; else if (CFEqual(pixel_encoding, CFSTR(IO32BitDirectPixels))) bits_per_pixel = 32; else if (CFEqual(pixel_encoding, CFSTR(IO16BitDirectPixels))) bits_per_pixel = 16; else if (CFEqual(pixel_encoding, CFSTR(IO8BitIndexedPixels))) bits_per_pixel = 8; else if (CFEqual(pixel_encoding, CFSTR(IO4BitIndexedPixels))) bits_per_pixel = 4; else if (CFEqual(pixel_encoding, CFSTR(IO2BitIndexedPixels))) bits_per_pixel = 2; else if (CFEqual(pixel_encoding, CFSTR(IO1BitIndexedPixels))) bits_per_pixel = 1; CFRelease(pixel_encoding); } return bits_per_pixel; } static BOOL display_mode_is_supported(CGDisplayModeRef display_mode) { uint32_t io_flags = CGDisplayModeGetIOFlags(display_mode); return (io_flags & kDisplayModeValidFlag) && (io_flags & kDisplayModeSafeFlag); } static void display_mode_to_devmode(CGDirectDisplayID display_id, CGDisplayModeRef display_mode, DEVMODEW *devmode) { uint32_t io_flags; double rotation; rotation = CGDisplayRotation(display_id); devmode->dmDisplayOrientation = ((int)((rotation / 90) + 0.5)) % 4; devmode->dmFields |= DM_DISPLAYORIENTATION; io_flags = CGDisplayModeGetIOFlags(display_mode); if (io_flags & kDisplayModeStretchedFlag) devmode->dmDisplayFixedOutput = DMDFO_STRETCH; else devmode->dmDisplayFixedOutput = DMDFO_CENTER; devmode->dmFields |= DM_DISPLAYFIXEDOUTPUT; devmode->dmBitsPerPel = display_mode_bits_per_pixel(display_mode); if (devmode->dmBitsPerPel) devmode->dmFields |= DM_BITSPERPEL; devmode->dmPelsWidth = CGDisplayModeGetWidth(display_mode); devmode->dmPelsHeight = CGDisplayModeGetHeight(display_mode); devmode->dmFields |= DM_PELSWIDTH | DM_PELSHEIGHT; devmode->dmDisplayFlags = 0; if (io_flags & kDisplayModeInterlacedFlag) devmode->dmDisplayFlags |= DM_INTERLACED; if (!display_mode_is_supported(display_mode)) devmode->dmDisplayFlags |= WINE_DM_UNSUPPORTED; devmode->dmFields |= DM_DISPLAYFLAGS; devmode->dmDisplayFrequency = CGDisplayModeGetRefreshRate(display_mode); if (!devmode->dmDisplayFrequency) devmode->dmDisplayFrequency = 60; devmode->dmFields |= DM_DISPLAYFREQUENCY; } static BOOL set_setting_value(HKEY hkey, const char *name, DWORD val) { WCHAR nameW[128]; UNICODE_STRING str = { asciiz_to_unicode(nameW, name) - sizeof(WCHAR), sizeof(nameW), nameW }; return !NtSetValueKey(hkey, &str, 0, REG_DWORD, &val, sizeof(val)); } static BOOL write_display_settings(HKEY parent_hkey, CGDirectDisplayID displayID) { BOOL ret = FALSE; char display_key_name[19]; HKEY display_hkey; CGDisplayModeRef display_mode; UNICODE_STRING str = RTL_CONSTANT_STRING(pixelencodingW); DWORD val; CFStringRef pixel_encoding; size_t len; WCHAR* buf = NULL; snprintf(display_key_name, sizeof(display_key_name), "Display 0x%08x", CGDisplayUnitNumber(displayID)); /* @@ Wine registry key: HKLM\Software\Wine\Mac Driver\Initial Display Mode\Display 0xnnnnnnnn */ if (!(display_hkey = reg_create_ascii_key(parent_hkey, display_key_name, REG_OPTION_VOLATILE, NULL))) return FALSE; display_mode = CGDisplayCopyDisplayMode(displayID); if (!display_mode) goto fail; val = CGDisplayModeGetWidth(display_mode); if (!set_setting_value(display_hkey, "Width", val)) goto fail; val = CGDisplayModeGetHeight(display_mode); if (!set_setting_value(display_hkey, "Height", val)) goto fail; val = CGDisplayModeGetRefreshRate(display_mode) * 100; if (!set_setting_value(display_hkey, "RefreshRateTimes100", val)) goto fail; val = CGDisplayModeGetIOFlags(display_mode); if (!set_setting_value(display_hkey, "IOFlags", val)) goto fail; val = CGDisplayModeGetPixelWidth(display_mode); if (!set_setting_value(display_hkey, "PixelWidth", val)) goto fail; val = CGDisplayModeGetPixelHeight(display_mode); if (!set_setting_value(display_hkey, "PixelHeight", val)) goto fail; pixel_encoding = CGDisplayModeCopyPixelEncoding(display_mode); len = CFStringGetLength(pixel_encoding); buf = malloc((len + 1) * sizeof(WCHAR)); CFStringGetCharacters(pixel_encoding, CFRangeMake(0, len), (UniChar*)buf); buf[len] = 0; CFRelease(pixel_encoding); if (NtSetValueKey(display_hkey, &str, 0, REG_SZ, (const BYTE*)buf, (len + 1) * sizeof(WCHAR))) goto fail; ret = TRUE; fail: free(buf); if (display_mode) CGDisplayModeRelease(display_mode); NtClose(display_hkey); if (!ret) { WCHAR nameW[64]; reg_delete_tree(parent_hkey, nameW, asciiz_to_unicode(nameW, display_key_name) - sizeof(WCHAR)); } return ret; } static void init_original_display_mode(void) { BOOL success = FALSE; HKEY mac_driver_hkey, parent_hkey; DWORD disposition; struct macdrv_display *displays = NULL; int num_displays, i; if (inited_original_display_mode) return; /* @@ Wine registry key: HKLM\Software\Wine\Mac Driver */ mac_driver_hkey = reg_create_ascii_key(NULL, "\\Registry\\Machine\\Software\\Wine\\Mac Driver", 0, NULL); if (!mac_driver_hkey) return; /* @@ Wine registry key: HKLM\Software\Wine\Mac Driver\Initial Display Mode */ if (!(parent_hkey = reg_create_key(mac_driver_hkey, initial_mode_keyW, sizeof(initial_mode_keyW), REG_OPTION_VOLATILE, &disposition))) { parent_hkey = NULL; goto fail; } /* If we didn't create a new key, then it already existed. Something already stored the initial display mode since Wine was started. We don't want to overwrite it. */ if (disposition != REG_CREATED_NEW_KEY) goto done; if (macdrv_get_displays(&displays, &num_displays)) goto fail; for (i = 0; i < num_displays; i++) { if (!write_display_settings(parent_hkey, displays[i].displayID)) goto fail; } done: success = TRUE; fail: macdrv_free_displays(displays); NtClose(parent_hkey); if (!success && parent_hkey) reg_delete_tree(mac_driver_hkey, initial_mode_keyW, sizeof(initial_mode_keyW)); NtClose(mac_driver_hkey); if (success) inited_original_display_mode = TRUE; } static BOOL read_dword(HKEY hkey, const char* name, DWORD* val) { char buffer[offsetof(KEY_VALUE_PARTIAL_INFORMATION, Data[sizeof(*val)])]; KEY_VALUE_PARTIAL_INFORMATION *value = (void *)buffer; WCHAR nameW[64]; asciiz_to_unicode(nameW, name); if (query_reg_value(hkey, nameW, value, sizeof(buffer)) != sizeof(*val) || value->Type != REG_DWORD) return FALSE; *val = *(DWORD *)value->Data; return TRUE; } static void free_display_mode_descriptor(struct display_mode_descriptor* desc) { if (desc) { if (desc->pixel_encoding) CFRelease(desc->pixel_encoding); free(desc); } } static struct display_mode_descriptor* create_original_display_mode_descriptor(CGDirectDisplayID displayID) { static const char display_key_format[] = "\\Registry\\Machine\\Software\\Wine\\Mac Driver\\Initial Display Mode\\Display 0x%08x"; struct display_mode_descriptor* ret = NULL; struct display_mode_descriptor* desc; char display_key[sizeof(display_key_format) + 10]; WCHAR nameW[ARRAYSIZE(display_key)]; char buffer[4096]; KEY_VALUE_PARTIAL_INFORMATION *value = (void *)buffer; HKEY hkey; DWORD refresh100; init_original_display_mode(); snprintf(display_key, sizeof(display_key), display_key_format, CGDisplayUnitNumber(displayID)); /* @@ Wine registry key: HKLM\Software\Wine\Mac Driver\Initial Display Mode\Display 0xnnnnnnnn */ if (!(hkey = reg_open_key(NULL, nameW, asciiz_to_unicode(nameW, display_key) - sizeof(WCHAR)))) return NULL; desc = malloc(sizeof(*desc)); desc->pixel_encoding = NULL; if (!read_dword(hkey, "Width", &desc->width) || !read_dword(hkey, "Height", &desc->height) || !read_dword(hkey, "RefreshRateTimes100", &refresh100) || !read_dword(hkey, "IOFlags", &desc->io_flags)) goto done; if (refresh100) desc->refresh = refresh100 / 100.0; else desc->refresh = 60; if (!read_dword(hkey, "PixelWidth", &desc->pixel_width) || !read_dword(hkey, "PixelHeight", &desc->pixel_height)) { desc->pixel_width = desc->width; desc->pixel_height = desc->height; } if (!query_reg_value(hkey, pixelencodingW, value, sizeof(buffer)) || value->Type != REG_SZ) goto done; desc->pixel_encoding = CFStringCreateWithCharacters(NULL, (const UniChar*)value->Data, lstrlenW((const WCHAR *)value->Data)); ret = desc; done: if (!ret) free_display_mode_descriptor(desc); NtClose(hkey); return ret; } static BOOL display_mode_matches_descriptor(CGDisplayModeRef mode, const struct display_mode_descriptor* desc) { DWORD mode_io_flags; double mode_refresh; CFStringRef mode_pixel_encoding; if (!desc) return FALSE; if (CGDisplayModeGetWidth(mode) != desc->width || CGDisplayModeGetHeight(mode) != desc->height) return FALSE; mode_io_flags = CGDisplayModeGetIOFlags(mode); if ((desc->io_flags ^ mode_io_flags) & (kDisplayModeValidFlag | kDisplayModeSafeFlag | kDisplayModeStretchedFlag | kDisplayModeInterlacedFlag | kDisplayModeTelevisionFlag)) return FALSE; mode_refresh = CGDisplayModeGetRefreshRate(mode); if (!mode_refresh) mode_refresh = 60; if (fabs(desc->refresh - mode_refresh) > 0.1) return FALSE; if (CGDisplayModeGetPixelWidth(mode) != desc->pixel_width || CGDisplayModeGetPixelHeight(mode) != desc->pixel_height) return FALSE; mode_pixel_encoding = CGDisplayModeCopyPixelEncoding(mode); if (!CFEqual(mode_pixel_encoding, desc->pixel_encoding)) { CFRelease(mode_pixel_encoding); return FALSE; } CFRelease(mode_pixel_encoding); return TRUE; } static int get_default_bpp(void) { static int cached; int ret; if (!cached) { CGDisplayModeRef mode = CGDisplayCopyDisplayMode(kCGDirectMainDisplay); if (mode) { cached = display_mode_bits_per_pixel(mode); CFRelease(mode); } if (!cached) cached = 32; } ret = cached; TRACE(" -> %d\n", ret); return ret; } static CFDictionaryRef create_mode_dict(CGDisplayModeRef display_mode, BOOL is_original) { CFDictionaryRef ret; SInt32 io_flags = CGDisplayModeGetIOFlags(display_mode); SInt64 width = CGDisplayModeGetWidth(display_mode); SInt64 height = CGDisplayModeGetHeight(display_mode); double refresh_rate = CGDisplayModeGetRefreshRate(display_mode); CFStringRef pixel_encoding = CGDisplayModeCopyPixelEncoding(display_mode); CFNumberRef cf_io_flags, cf_width, cf_height, cf_refresh; if (retina_enabled && is_original) { width *= 2; height *= 2; } io_flags &= kDisplayModeValidFlag | kDisplayModeSafeFlag | kDisplayModeInterlacedFlag | kDisplayModeStretchedFlag | kDisplayModeTelevisionFlag; cf_io_flags = CFNumberCreate(NULL, kCFNumberSInt32Type, &io_flags); cf_width = CFNumberCreate(NULL, kCFNumberSInt64Type, &width); cf_height = CFNumberCreate(NULL, kCFNumberSInt64Type, &height); cf_refresh = CFNumberCreate(NULL, kCFNumberDoubleType, &refresh_rate); { static const CFStringRef keys[] = { CFSTR("io_flags"), CFSTR("width"), CFSTR("height"), CFSTR("pixel_encoding"), CFSTR("refresh_rate"), }; const void* values[ARRAY_SIZE(keys)] = { cf_io_flags, cf_width, cf_height, pixel_encoding, cf_refresh, }; ret = CFDictionaryCreate(NULL, (const void**)keys, (const void**)values, ARRAY_SIZE(keys), &kCFCopyStringDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); } CFRelease(pixel_encoding); CFRelease(cf_io_flags); CFRelease(cf_width); CFRelease(cf_height); CFRelease(cf_refresh); return ret; } static BOOL mode_is_preferred(CGDisplayModeRef new_mode, CGDisplayModeRef old_mode, struct display_mode_descriptor *original_mode_desc, BOOL include_unsupported) { BOOL new_is_supported; CFStringRef pixel_encoding; size_t width_points, height_points; size_t old_width_pixels, old_height_pixels, new_width_pixels, new_height_pixels; BOOL old_size_same, new_size_same; /* If a given mode is the user's default, then always list it in preference to any similar modes that may exist. */ if (display_mode_matches_descriptor(new_mode, original_mode_desc)) return TRUE; /* Skip unsupported modes unless told to do otherwise. */ new_is_supported = display_mode_is_supported(new_mode); if (!new_is_supported && !include_unsupported) return FALSE; pixel_encoding = CGDisplayModeCopyPixelEncoding(new_mode); if (pixel_encoding) { BOOL bpp30 = CFEqual(pixel_encoding, CFSTR(kIO30BitDirectPixels)); CFRelease(pixel_encoding); if (bpp30) { /* This is an odd pixel encoding. It seems it's only returned when using kCGDisplayShowDuplicateLowResolutionModes. It's 32bpp in terms of the actual raster layout, but it's 10 bits per component. I think that no Windows program is likely to need it and they will probably be confused by it. Skip it. */ return FALSE; } } if (!old_mode) return TRUE; /* Prefer the original mode over any similar mode. */ if (display_mode_matches_descriptor(old_mode, original_mode_desc)) return FALSE; /* Prefer supported modes over similar unsupported ones. */ if (!new_is_supported && display_mode_is_supported(old_mode)) return FALSE; /* Otherwise, prefer a mode whose pixel size equals its point size over one which is scaled. */ width_points = CGDisplayModeGetWidth(new_mode); height_points = CGDisplayModeGetHeight(new_mode); new_width_pixels = CGDisplayModeGetPixelWidth(new_mode); new_height_pixels = CGDisplayModeGetPixelHeight(new_mode); old_width_pixels = CGDisplayModeGetPixelWidth(old_mode); old_height_pixels = CGDisplayModeGetPixelHeight(old_mode); new_size_same = (new_width_pixels == width_points && new_height_pixels == height_points); old_size_same = (old_width_pixels == width_points && old_height_pixels == height_points); if (new_size_same && !old_size_same) return TRUE; if (!new_size_same && old_size_same) return FALSE; /* Otherwise, prefer the mode with the smaller pixel size. */ return new_width_pixels < old_width_pixels && new_height_pixels < old_height_pixels; } static CFComparisonResult mode_compare(const void *p1, const void *p2, void *context) { CGDisplayModeRef a = (CGDisplayModeRef)p1, b = (CGDisplayModeRef)p2; size_t a_val, b_val; double a_refresh_rate, b_refresh_rate; /* Sort by bpp descending, */ a_val = display_mode_bits_per_pixel(a); b_val = display_mode_bits_per_pixel(b); if (a_val < b_val) return kCFCompareGreaterThan; else if (a_val > b_val) return kCFCompareLessThan; /* then width ascending, */ a_val = CGDisplayModeGetWidth(a); b_val = CGDisplayModeGetWidth(b); if (a_val < b_val) return kCFCompareLessThan; else if (a_val > b_val) return kCFCompareGreaterThan; /* then height ascending, */ a_val = CGDisplayModeGetHeight(a); b_val = CGDisplayModeGetHeight(b); if (a_val < b_val) return kCFCompareLessThan; else if (a_val > b_val) return kCFCompareGreaterThan; /* then refresh rate descending. */ a_refresh_rate = CGDisplayModeGetRefreshRate(a); b_refresh_rate = CGDisplayModeGetRefreshRate(b); if (a_refresh_rate < b_refresh_rate) return kCFCompareGreaterThan; else if (a_refresh_rate > b_refresh_rate) return kCFCompareLessThan; return kCFCompareEqualTo; } /*********************************************************************** * copy_display_modes * * Wrapper around CGDisplayCopyAllDisplayModes() to include additional * modes on Retina-capable systems, but filter those which would confuse * Windows apps (basically duplicates at different DPIs). * * For example, some Retina Macs support a 1920x1200 mode, but it's not * returned from CGDisplayCopyAllDisplayModes() without special options. * This is especially bad if that's the user's default mode, since then * no "available" mode matches the initial settings. * * If include_unsupported is FALSE, display modes with IO flags that * indicate that they are invalid or unsafe are filtered. */ static CFArrayRef copy_display_modes(CGDirectDisplayID display, BOOL include_unsupported) { CFArrayRef modes = NULL; CFDictionaryRef options; struct display_mode_descriptor* desc; CFMutableDictionaryRef modes_by_size; CFIndex i, count; CGDisplayModeRef* mode_array; options = CFDictionaryCreate(NULL, (const void**)&kCGDisplayShowDuplicateLowResolutionModes, (const void**)&kCFBooleanTrue, 1, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); modes = CGDisplayCopyAllDisplayModes(display, options); if (options) CFRelease(options); if (!modes) return NULL; desc = create_original_display_mode_descriptor(display); modes_by_size = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); count = CFArrayGetCount(modes); for (i = 0; i < count; i++) { CGDisplayModeRef new_mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(modes, i); BOOL new_is_original = display_mode_matches_descriptor(new_mode, desc); CFDictionaryRef key = create_mode_dict(new_mode, new_is_original); CGDisplayModeRef old_mode = (CGDisplayModeRef)CFDictionaryGetValue(modes_by_size, key); if (mode_is_preferred(new_mode, old_mode, desc, include_unsupported)) CFDictionarySetValue(modes_by_size, key, new_mode); CFRelease(key); } free_display_mode_descriptor(desc); CFRelease(modes); count = CFDictionaryGetCount(modes_by_size); mode_array = malloc(count * sizeof(mode_array[0])); CFDictionaryGetKeysAndValues(modes_by_size, NULL, (const void **)mode_array); modes = CFArrayCreate(NULL, (const void **)mode_array, count, &kCFTypeArrayCallBacks); free(mode_array); CFRelease(modes_by_size); if (modes) { CFIndex count = CFArrayGetCount(modes); CFMutableArrayRef sorted_modes = CFArrayCreateMutableCopy(NULL, count, modes); CFRelease(modes); CFArraySortValues(sorted_modes, CFRangeMake(0, count), mode_compare, NULL); return sorted_modes; } return NULL; } void check_retina_status(void) { if (retina_enabled) { struct display_mode_descriptor* desc = create_original_display_mode_descriptor(kCGDirectMainDisplay); CGDisplayModeRef mode = CGDisplayCopyDisplayMode(kCGDirectMainDisplay); BOOL new_value = display_mode_matches_descriptor(mode, desc); CGDisplayModeRelease(mode); free_display_mode_descriptor(desc); if (new_value != retina_on) macdrv_set_cocoa_retina_mode(new_value); } } static BOOL is_detached_mode(const DEVMODEW *mode) { return mode->dmFields & DM_POSITION && mode->dmFields & DM_PELSWIDTH && mode->dmFields & DM_PELSHEIGHT && mode->dmPelsWidth == 0 && mode->dmPelsHeight == 0; } static CGDisplayModeRef find_best_display_mode(DEVMODEW *devmode, CFArrayRef display_modes, int bpp, struct display_mode_descriptor *desc) { CFIndex count, i, best; CGDisplayModeRef best_display_mode; best_display_mode = NULL; count = CFArrayGetCount(display_modes); for (i = 0; i < count; i++) { CGDisplayModeRef display_mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(display_modes, i); BOOL is_original = display_mode_matches_descriptor(display_mode, desc); uint32_t io_flags = CGDisplayModeGetIOFlags(display_mode); int mode_bpp = display_mode_bits_per_pixel(display_mode); size_t width = CGDisplayModeGetWidth(display_mode); size_t height = CGDisplayModeGetHeight(display_mode); double refresh_rate = CGDisplayModeGetRefreshRate(display_mode); if (!refresh_rate) refresh_rate = 60; if (is_original && retina_enabled) { width *= 2; height *= 2; } if (bpp != mode_bpp) continue; if (devmode->dmPelsWidth != width) continue; if (devmode->dmPelsHeight != height) continue; if (devmode->dmDisplayFrequency != (DWORD)refresh_rate) continue; if (!(devmode->dmDisplayFlags & DM_INTERLACED) != !(io_flags & kDisplayModeInterlacedFlag)) continue; if (!(devmode->dmDisplayFixedOutput == DMDFO_STRETCH) != !(io_flags & kDisplayModeStretchedFlag)) continue; if (best_display_mode) continue; best_display_mode = display_mode; best = i; } if (best_display_mode) TRACE("Requested display settings match mode %ld\n", best); return best_display_mode; } /*********************************************************************** * ChangeDisplaySettings (MACDRV.@) * */ LONG macdrv_ChangeDisplaySettings(LPDEVMODEW displays, LPCWSTR primary_name, HWND hwnd, DWORD flags, LPVOID lpvoid) { LONG ret = DISP_CHANGE_SUCCESSFUL; DEVMODEW *mode; int bpp; struct macdrv_display *macdrv_displays; int num_displays; CFArrayRef display_modes; struct display_mode_descriptor *desc; CGDisplayModeRef best_display_mode; TRACE("%p %s %p 0x%08x %p\n", displays, debugstr_w(primary_name), hwnd, (unsigned int)flags, lpvoid); init_original_display_mode(); if (macdrv_get_displays(&macdrv_displays, &num_displays)) return DISP_CHANGE_FAILED; display_modes = copy_display_modes(macdrv_displays[0].displayID, FALSE); if (!display_modes) { macdrv_free_displays(macdrv_displays); return DISP_CHANGE_FAILED; } bpp = get_default_bpp(); desc = create_original_display_mode_descriptor(macdrv_displays[0].displayID); for (mode = displays; mode->dmSize && !ret; mode = NEXT_DEVMODEW(mode)) { if (wcsicmp(primary_name, mode->dmDeviceName)) { FIXME("Changing non-primary adapter settings is currently unsupported.\n"); continue; } if (is_detached_mode(mode)) { FIXME("Detaching adapters is currently unsupported.\n"); continue; } if (mode->dmBitsPerPel != bpp) TRACE("using default %d bpp instead of caller's request %d bpp\n", bpp, (int)mode->dmBitsPerPel); TRACE("looking for %dx%dx%dbpp @%d Hz", (int)mode->dmPelsWidth, (int)mode->dmPelsHeight, bpp, (int)mode->dmDisplayFrequency); TRACE(" %sstretched", mode->dmDisplayFixedOutput == DMDFO_STRETCH ? "" : "un"); TRACE(" %sinterlaced", mode->dmDisplayFlags & DM_INTERLACED ? "" : "non-"); TRACE("\n"); if (!(best_display_mode = find_best_display_mode(mode, display_modes, bpp, desc))) { ERR("No matching mode found %ux%ux%d @%u!\n", (unsigned int)mode->dmPelsWidth, (unsigned int)mode->dmPelsHeight, bpp, (unsigned int)mode->dmDisplayFrequency); ret = DISP_CHANGE_BADMODE; } else if (!macdrv_set_display_mode(&macdrv_displays[0], best_display_mode)) { WARN("Failed to set display mode\n"); ret = DISP_CHANGE_FAILED; } } free_display_mode_descriptor(desc); CFRelease(display_modes); macdrv_free_displays(macdrv_displays); return ret; } static DEVMODEW *display_get_modes(CGDirectDisplayID display_id, int *modes_count) { int default_bpp = get_default_bpp(), synth_count = 0, count, i; BOOL modes_has_8bpp = FALSE, modes_has_16bpp = FALSE; struct display_mode_descriptor *desc; DEVMODEW *devmodes; CFArrayRef modes; modes = copy_display_modes(display_id, TRUE); if (!modes) return NULL; count = CFArrayGetCount(modes); for (i = 0; i < count && !(modes_has_8bpp && modes_has_16bpp); i++) { CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(modes, i); int bpp = display_mode_bits_per_pixel(mode); if (bpp == 8) modes_has_8bpp = TRUE; else if (bpp == 16) modes_has_16bpp = TRUE; } if (!(devmodes = calloc(count * 3, sizeof(DEVMODEW)))) { CFRelease(modes); return NULL; } desc = create_original_display_mode_descriptor(display_id); for (i = 0; i < count; i++) { CGDisplayModeRef mode = (CGDisplayModeRef)CFArrayGetValueAtIndex(modes, i); display_mode_to_devmode(display_id, mode, devmodes + i); if (retina_enabled && display_mode_matches_descriptor(mode, desc)) { devmodes[i].dmPelsWidth *= 2; devmodes[i].dmPelsHeight *= 2; } } free_display_mode_descriptor(desc); for (i = 0; !modes_has_16bpp && i < count; i++) { /* We only synthesize modes from those having the default bpp. */ if (devmodes[i].dmBitsPerPel != default_bpp) continue; devmodes[count + synth_count] = devmodes[i]; devmodes[count + synth_count].dmBitsPerPel = 16; synth_count++; } for (i = 0; !modes_has_8bpp && i < count; i++) { /* We only synthesize modes from those having the default bpp. */ if (devmodes[i].dmBitsPerPel != default_bpp) continue; devmodes[count + synth_count] = devmodes[i]; devmodes[count + synth_count].dmBitsPerPel = 8; synth_count++; } CFRelease(modes); *modes_count = count + synth_count; return devmodes; } static void display_get_current_mode(struct macdrv_display *display, DEVMODEW *devmode) { CGDisplayModeRef display_mode; CGDirectDisplayID display_id; display_id = display->displayID; display_mode = CGDisplayCopyDisplayMode(display_id); devmode->dmPosition.x = CGRectGetMinX(display->frame); devmode->dmPosition.y = CGRectGetMinY(display->frame); devmode->dmFields |= DM_POSITION; display_mode_to_devmode(display_id, display_mode, devmode); if (retina_enabled) { struct display_mode_descriptor *desc = create_original_display_mode_descriptor(display_id); if (display_mode_matches_descriptor(display_mode, desc)) { devmode->dmPelsWidth *= 2; devmode->dmPelsHeight *= 2; } free_display_mode_descriptor(desc); } CFRelease(display_mode); } /*********************************************************************** * GetCurrentDisplaySettings (MACDRV.@) * */ BOOL macdrv_GetCurrentDisplaySettings(LPCWSTR devname, BOOL is_primary, LPDEVMODEW devmode) { struct macdrv_display *displays = NULL; int num_displays, display_idx; WCHAR *end; TRACE("%s, %u, %p + %hu\n", debugstr_w(devname), is_primary, devmode, devmode->dmSize); init_original_display_mode(); if (macdrv_get_displays(&displays, &num_displays)) return FALSE; display_idx = wcstol(devname + 11, &end, 10) - 1; if (display_idx >= num_displays) { macdrv_free_displays(displays); return FALSE; } display_get_current_mode(&displays[display_idx], devmode); macdrv_free_displays(displays); TRACE("current mode -- %dx%d-%dx%dx%dbpp @%d Hz", (int)devmode->dmPosition.x, (int)devmode->dmPosition.y, (int)devmode->dmPelsWidth, (int)devmode->dmPelsHeight, (int)devmode->dmBitsPerPel, (int)devmode->dmDisplayFrequency); if (devmode->dmDisplayOrientation) TRACE(" rotated %u degrees", (unsigned int)devmode->dmDisplayOrientation * 90); if (devmode->dmDisplayFixedOutput == DMDFO_STRETCH) TRACE(" stretched"); if (devmode->dmDisplayFlags & DM_INTERLACED) TRACE(" interlaced"); TRACE("\n"); return TRUE; } /*********************************************************************** * GetDisplayDepth (MACDRV.@) * */ INT macdrv_GetDisplayDepth(LPCWSTR name, BOOL is_primary) { return get_default_bpp(); } /*********************************************************************** * GetDeviceGammaRamp (MACDRV.@) */ BOOL macdrv_GetDeviceGammaRamp(PHYSDEV dev, LPVOID ramp) { BOOL ret = FALSE; DDGAMMARAMP *r = ramp; struct macdrv_display *displays; int num_displays; uint32_t mac_entries; int win_entries = ARRAY_SIZE(r->red); CGGammaValue *red, *green, *blue; CGError err; int win_entry; TRACE("dev %p ramp %p\n", dev, ramp); if (macdrv_get_displays(&displays, &num_displays)) { WARN("failed to get Mac displays\n"); return FALSE; } mac_entries = CGDisplayGammaTableCapacity(displays[0].displayID); red = malloc(mac_entries * sizeof(red[0]) * 3); if (!red) goto done; green = red + mac_entries; blue = green + mac_entries; err = CGGetDisplayTransferByTable(displays[0].displayID, mac_entries, red, green, blue, &mac_entries); if (err != kCGErrorSuccess) { WARN("failed to get Mac gamma table: %d\n", err); goto done; } if (mac_entries == win_entries) { for (win_entry = 0; win_entry < win_entries; win_entry++) { r->red[win_entry] = red[win_entry] * 65535 + 0.5; r->green[win_entry] = green[win_entry] * 65535 + 0.5; r->blue[win_entry] = blue[win_entry] * 65535 + 0.5; } } else { for (win_entry = 0; win_entry < win_entries; win_entry++) { double mac_pos = win_entry * (mac_entries - 1) / (double)(win_entries - 1); int mac_entry = mac_pos; double red_value, green_value, blue_value; if (mac_entry == mac_entries - 1) { red_value = red[mac_entry]; green_value = green[mac_entry]; blue_value = blue[mac_entry]; } else { double distance = mac_pos - mac_entry; red_value = red[mac_entry] * (1 - distance) + red[mac_entry + 1] * distance; green_value = green[mac_entry] * (1 - distance) + green[mac_entry + 1] * distance; blue_value = blue[mac_entry] * (1 - distance) + blue[mac_entry + 1] * distance; } r->red[win_entry] = red_value * 65535 + 0.5; r->green[win_entry] = green_value * 65535 + 0.5; r->blue[win_entry] = blue_value * 65535 + 0.5; } } ret = TRUE; done: free(red); macdrv_free_displays(displays); return ret; } /*********************************************************************** * SetDeviceGammaRamp (MACDRV.@) */ BOOL macdrv_SetDeviceGammaRamp(PHYSDEV dev, LPVOID ramp) { DDGAMMARAMP *r = ramp; struct macdrv_display *displays; int num_displays; int win_entries = ARRAY_SIZE(r->red); CGGammaValue *red, *green, *blue; int i; CGError err = kCGErrorFailure; TRACE("dev %p ramp %p\n", dev, ramp); if (!allow_set_gamma) { TRACE("disallowed by registry setting\n"); return FALSE; } if (macdrv_get_displays(&displays, &num_displays)) { WARN("failed to get Mac displays\n"); return FALSE; } red = malloc(win_entries * sizeof(red[0]) * 3); if (!red) goto done; green = red + win_entries; blue = green + win_entries; for (i = 0; i < win_entries; i++) { red[i] = r->red[i] / 65535.0; green[i] = r->green[i] / 65535.0; blue[i] = r->blue[i] / 65535.0; } err = CGSetDisplayTransferByTable(displays[0].displayID, win_entries, red, green, blue); if (err != kCGErrorSuccess) WARN("failed to set display gamma table: %d\n", err); done: free(red); macdrv_free_displays(displays); return (err == kCGErrorSuccess); } /*********************************************************************** * macdrv_displays_changed * * Handler for DISPLAYS_CHANGED events. */ void macdrv_displays_changed(const macdrv_event *event) { HWND hwnd = NtUserGetDesktopWindow(); /* A system display change will get delivered to all GUI-attached threads, so the desktop-window-owning thread will get it and all others should ignore it. A synthesized display change event due to activation will only get delivered to the activated process. So, it needs to process it (by sending it to the desktop window). */ if (event->displays_changed.activating || NtUserGetWindowThread(hwnd, NULL) == GetCurrentThreadId()) { macdrv_init_display_devices(TRUE); macdrv_resize_desktop(); } } static BOOL force_display_devices_refresh; static BOOL is_same_devmode(const DEVMODEW *a, const DEVMODEW *b) { return a->dmDisplayOrientation == b->dmDisplayOrientation && a->dmDisplayFixedOutput == b->dmDisplayFixedOutput && a->dmBitsPerPel == b->dmBitsPerPel && a->dmPelsWidth == b->dmPelsWidth && a->dmPelsHeight == b->dmPelsHeight && a->dmDisplayFlags == b->dmDisplayFlags && a->dmDisplayFrequency == b->dmDisplayFrequency; } static const char *debugstr_devmodew(const DEVMODEW *devmode) { char position[32] = {0}; if (devmode->dmFields & DM_POSITION) { snprintf(position, sizeof(position), " at (%d,%d)", (int)devmode->dmPosition.x, (int)devmode->dmPosition.y); } return wine_dbg_sprintf("%ux%u %ubits %uHz rotated %u degrees %sstretched %sinterlaced%s", (unsigned int)devmode->dmPelsWidth, (unsigned int)devmode->dmPelsHeight, (unsigned int)devmode->dmBitsPerPel, (unsigned int)devmode->dmDisplayFrequency, (unsigned int)devmode->dmDisplayOrientation * 90, devmode->dmDisplayFixedOutput == DMDFO_STRETCH ? "" : "un", devmode->dmDisplayFlags & DM_INTERLACED ? "" : "non-", position); } BOOL macdrv_UpdateDisplayDevices( const struct gdi_device_manager *device_manager, BOOL force, void *param ) { struct macdrv_adapter *adapters, *adapter; struct macdrv_monitor *monitors, *monitor; struct macdrv_gpu *gpus, *gpu; struct macdrv_display *displays, *display; INT gpu_count, adapter_count, monitor_count, mode_count, display_count; DEVMODEW *mode, *modes; DWORD len; if (!force && !force_display_devices_refresh) return TRUE; force_display_devices_refresh = FALSE; if (macdrv_get_displays(&displays, &display_count)) { displays = NULL; display_count = 0; } /* Initialize GPUs */ if (macdrv_get_gpus(&gpus, &gpu_count)) { ERR("could not get GPUs\n"); return FALSE; } TRACE("GPU count: %d\n", gpu_count); for (gpu = gpus; gpu < gpus + gpu_count; gpu++) { struct gdi_gpu gdi_gpu = { .id = gpu->id, .vendor_id = gpu->vendor_id, .device_id = gpu->device_id, .subsys_id = gpu->subsys_id, .revision_id = gpu->revision_id, }; RtlUTF8ToUnicodeN(gdi_gpu.name, sizeof(gdi_gpu.name), &len, gpu->name, strlen(gpu->name)); device_manager->add_gpu(&gdi_gpu, param); /* Initialize adapters */ if (macdrv_get_adapters(gpu->id, &adapters, &adapter_count)) break; TRACE("GPU: %llx %s, adapter count: %d\n", gpu->id, debugstr_a(gpu->name), adapter_count); for (adapter = adapters; adapter < adapters + adapter_count; adapter++) { DEVMODEW current_mode = { .dmSize = sizeof(current_mode) }; struct gdi_adapter gdi_adapter = { .id = adapter->id, .state_flags = adapter->state_flags, }; device_manager->add_adapter( &gdi_adapter, param ); if (macdrv_get_monitors(adapter->id, &monitors, &monitor_count)) break; TRACE("adapter: %#x, monitor count: %d\n", adapter->id, monitor_count); /* Initialize monitors */ for (monitor = monitors; monitor < monitors + monitor_count; monitor++) { struct gdi_monitor gdi_monitor = { .rc_monitor = rect_from_cgrect(monitor->rc_monitor), .rc_work = rect_from_cgrect(monitor->rc_work), .state_flags = monitor->state_flags, }; device_manager->add_monitor( &gdi_monitor, param ); } /* Get the current mode */ if (displays) { for (display = displays; display < displays + display_count; display++) { if (display->displayID == adapter->id) { display_get_current_mode(display, ¤t_mode); break; } } } if (!(modes = display_get_modes(adapter->id, &mode_count))) break; TRACE("adapter: %#x, mode count: %d\n", adapter->id, mode_count); /* Initialize modes */ for (mode = modes; mode < modes + mode_count; mode++) { if (is_same_devmode(mode, ¤t_mode)) { TRACE("current mode: %s\n", debugstr_devmodew(¤t_mode)); device_manager->add_mode( ¤t_mode, TRUE, param ); } else { TRACE("mode: %s\n", debugstr_devmodew(mode)); device_manager->add_mode( mode, FALSE, param ); } } free(modes); macdrv_free_monitors(monitors); } macdrv_free_adapters(adapters); } macdrv_free_gpus(gpus); macdrv_free_displays(displays); return TRUE; } /*********************************************************************** * macdrv_init_display_devices * * Initialize display device registry data. */ void macdrv_init_display_devices(BOOL force) { UINT32 num_path, num_mode; if (force) force_display_devices_refresh = TRUE; /* trigger refresh in win32u */ NtUserGetDisplayConfigBufferSizes( QDC_ONLY_ACTIVE_PATHS, &num_path, &num_mode ); }