static void initialize_display_settings( HWND desktop )
{
static const WCHAR display_device_guid_propW[] = {
'_','_','w','i','n','e','_','d','i','s','p','l','a','y','_',
'd','e','v','i','c','e','_','g','u','i','d',0 };
GUID guid;
RPC_CSTR guid_str;
ATOM guid_atom;
DEVMODEW dmW;
UuidCreate( &guid );
UuidToStringA( &guid, &guid_str );
WINE_TRACE( "display guid %s\n", guid_str );
guid_atom = GlobalAddAtomA( (LPCSTR)guid_str );
SetPropW( desktop, display_device_guid_propW, ULongToHandle(guid_atom) );
RpcStringFreeA( &guid_str );
/* Store current display mode in the registry */
if (EnumDisplaySettingsExW( NULL, ENUM_CURRENT_SETTINGS, &dmW, 0 ))
{
WINE_TRACE( "Current display mode %ux%u %u bpp %u Hz\n", dmW.dmPelsWidth,
dmW.dmPelsHeight, dmW.dmBitsPerPel, dmW.dmDisplayFrequency );
ChangeDisplaySettingsExW( NULL, &dmW, 0,
CDS_GLOBAL | CDS_NORESET | CDS_UPDATEREGISTRY,
NULL );
}
}
bool DisplayManagerWin::getModeInfo(int display, int mode, DEVMODEW& info)
{
if (m_displayAdapters.contains(display))
{
ZeroMemory(&info, sizeof(info));
info.dmSize = sizeof(info);
return EnumDisplaySettingsExW((LPCWSTR)m_displayAdapters[display].utf16(), mode, &info, 0);
}
return false;
}
static void initialize_display_settings(void)
{
DEVMODEW dmW;
/* Store current display mode in the registry */
if (EnumDisplaySettingsExW( NULL, ENUM_CURRENT_SETTINGS, &dmW, 0 ))
{
WINE_TRACE( "Current display mode %ux%u %u bpp %u Hz\n", dmW.dmPelsWidth,
dmW.dmPelsHeight, dmW.dmBitsPerPel, dmW.dmDisplayFrequency );
ChangeDisplaySettingsExW( NULL, &dmW, 0,
CDS_GLOBAL | CDS_NORESET | CDS_UPDATEREGISTRY,
NULL );
}
}
void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
DEVMODEW dm;
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
EnumDisplaySettingsExW(monitor->win32.adapterName,
ENUM_CURRENT_SETTINGS,
&dm,
EDS_ROTATEDMODE);
if (xpos)
*xpos = dm.dmPosition.x;
if (ypos)
*ypos = dm.dmPosition.y;
}
void _glfwPlatformGetMonitorPos(_GLFWmonitor* monitor, int* xpos, int* ypos)
{
DEVMODEW settings;
ZeroMemory(&settings, sizeof(DEVMODEW));
settings.dmSize = sizeof(DEVMODEW);
EnumDisplaySettingsExW(monitor->win32.name,
ENUM_CURRENT_SETTINGS,
&settings,
EDS_ROTATEDMODE);
if (xpos)
*xpos = settings.dmPosition.x;
if (ypos)
*ypos = settings.dmPosition.y;
}
static PSETTINGS_ENTRY
GetPossibleSettings(IN LPCWSTR lpDeviceName,
OUT DWORD* pSettingsCount,
OUT PSETTINGS_ENTRY* CurrentSettings)
{
DEVMODEW devmode;
DWORD NbSettings = 0;
DWORD iMode = 0;
DWORD dwFlags = 0;
PSETTINGS_ENTRY Settings = NULL;
HDC hDC;
PSETTINGS_ENTRY Current;
DWORD bpp, xres, yres, checkbpp;
/* Get current settings */
*CurrentSettings = NULL;
hDC = CreateICW(NULL, lpDeviceName, NULL, NULL);
bpp = GetDeviceCaps(hDC, PLANES);
bpp *= GetDeviceCaps(hDC, BITSPIXEL);
xres = GetDeviceCaps(hDC, HORZRES);
yres = GetDeviceCaps(hDC, VERTRES);
DeleteDC(hDC);
/* List all settings */
devmode.dmSize = (WORD)sizeof(DEVMODE);
devmode.dmDriverExtra = 0;
if (!EnumDisplaySettingsExW(lpDeviceName, ENUM_CURRENT_SETTINGS, &devmode, dwFlags))
return NULL;
while (EnumDisplaySettingsExW(lpDeviceName, iMode, &devmode, dwFlags))
{
if (devmode.dmBitsPerPel==8 ||
devmode.dmBitsPerPel==16 ||
devmode.dmBitsPerPel==24 ||
devmode.dmBitsPerPel==32)
{
checkbpp=1;
}
else
checkbpp=0;
if (devmode.dmPelsWidth < 640 ||
devmode.dmPelsHeight < 480 || checkbpp == 0)
{
iMode++;
continue;
}
Current = HeapAlloc(GetProcessHeap(), 0, sizeof(SETTINGS_ENTRY));
if (Current != NULL)
{
/* Sort resolutions by increasing height, and BPP */
PSETTINGS_ENTRY Previous = NULL;
PSETTINGS_ENTRY Next = Settings;
Current->dmPelsWidth = devmode.dmPelsWidth;
Current->dmPelsHeight = devmode.dmPelsHeight;
Current->dmBitsPerPel = devmode.dmBitsPerPel;
while (Next != NULL &&
(Next->dmPelsWidth < Current->dmPelsWidth ||
(Next->dmPelsWidth == Current->dmPelsWidth && Next->dmPelsHeight < Current->dmPelsHeight) ||
(Next->dmPelsHeight == Current->dmPelsHeight &&
Next->dmPelsWidth == Current->dmPelsWidth &&
Next->dmBitsPerPel < Current->dmBitsPerPel )))
{
Previous = Next;
Next = Next->Flink;
}
Current->Blink = Previous;
Current->Flink = Next;
if (Previous == NULL)
Settings = Current;
else
Previous->Flink = Current;
if (Next != NULL)
Next->Blink = Current;
if (devmode.dmPelsWidth == xres && devmode.dmPelsHeight == yres && devmode.dmBitsPerPel == bpp)
{
*CurrentSettings = Current;
}
NbSettings++;
}
iMode++;
}
*pSettingsCount = NbSettings;
return Settings;
}
bool CWinSystemWin32::UpdateResolutionsInternal()
{
DISPLAY_DEVICEW ddAdapter;
ZeroMemory(&ddAdapter, sizeof(ddAdapter));
ddAdapter.cb = sizeof(ddAdapter);
DWORD adapter = 0;
while (EnumDisplayDevicesW(NULL, adapter, &ddAdapter, 0))
{
// Exclude displays that are not part of the windows desktop. Using them is too different: no windows,
// direct access with GDI CreateDC() or DirectDraw for example. So it may be possible to play video, but GUI?
if (!(ddAdapter.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER) && (ddAdapter.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP))
{
DISPLAY_DEVICEW ddMon;
ZeroMemory(&ddMon, sizeof(ddMon));
ddMon.cb = sizeof(ddMon);
bool foundScreen = false;
DWORD screen = 0;
// Just look for the first active output, we're actually only interested in the information at the adapter level.
while (EnumDisplayDevicesW(ddAdapter.DeviceName, screen, &ddMon, 0))
{
if (ddMon.StateFlags & (DISPLAY_DEVICE_ACTIVE | DISPLAY_DEVICE_ATTACHED))
{
foundScreen = true;
break;
}
ZeroMemory(&ddMon, sizeof(ddMon));
ddMon.cb = sizeof(ddMon);
screen++;
}
// Remoting returns no screens. Handle with a dummy screen.
if (!foundScreen && screen == 0)
{
lstrcpyW(ddMon.DeviceString, L"Dummy Monitor"); // safe: large static array
foundScreen = true;
}
if (foundScreen)
{
std::string monitorStr, adapterStr;
g_charsetConverter.wToUTF8(ddMon.DeviceString, monitorStr);
g_charsetConverter.wToUTF8(ddAdapter.DeviceString, adapterStr);
CLog::Log(LOGNOTICE, "Found screen: %s on %s, adapter %d.", monitorStr.c_str(), adapterStr.c_str(), adapter);
// get information about the display's current position and display mode
//! @todo for Windows 7/Server 2008 and up, Microsoft recommends QueryDisplayConfig() instead, the API used by the control panel.
DEVMODEW dm;
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
if (EnumDisplaySettingsExW(ddAdapter.DeviceName, ENUM_CURRENT_SETTINGS, &dm, 0) == FALSE)
EnumDisplaySettingsExW(ddAdapter.DeviceName, ENUM_REGISTRY_SETTINGS, &dm, 0);
// get the monitor handle and workspace
HMONITOR hm = 0;
POINT pt = { dm.dmPosition.x, dm.dmPosition.y };
hm = MonitorFromPoint(pt, MONITOR_DEFAULTTONULL);
MONITOR_DETAILS md = {};
md.MonitorNameW = ddMon.DeviceString;
md.CardNameW = ddAdapter.DeviceString;
md.DeviceNameW = ddAdapter.DeviceName;
// width x height @ x,y - bpp - refresh rate
// note that refresh rate information is not available on Win9x
md.ScreenWidth = dm.dmPelsWidth;
md.ScreenHeight = dm.dmPelsHeight;
md.hMonitor = hm;
md.RefreshRate = dm.dmDisplayFrequency;
md.Bpp = dm.dmBitsPerPel;
md.Interlaced = (dm.dmDisplayFlags & DM_INTERLACED) ? true : false;
m_MonitorsInfo.push_back(md);
// Careful, some adapters don't end up in the vector (mirroring, no active output, etc.)
if (ddAdapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE)
m_nPrimary = m_MonitorsInfo.size() -1;
}
}
ZeroMemory(&ddAdapter, sizeof(ddAdapter));
ddAdapter.cb = sizeof(ddAdapter);
adapter++;
}
return 0;
}
static HRESULT
fill_groups( struct d3dadapter9 *This )
{
DISPLAY_DEVICEW dd;
DEVMODEW dm;
POINT pt;
HDC hdc;
HRESULT hr;
int i, j, k;
WCHAR wdisp[] = {'D','I','S','P','L','A','Y',0};
ZeroMemory(&dd, sizeof(dd));
ZeroMemory(&dm, sizeof(dm));
dd.cb = sizeof(dd);
dm.dmSize = sizeof(dm);
for (i = 0; EnumDisplayDevicesW(NULL, i, &dd, 0); ++i) {
struct adapter_group *group = add_group(This);
if (!group) {
ERR("Out of memory.\n");
return E_OUTOFMEMORY;
}
hdc = CreateDCW(wdisp, dd.DeviceName, NULL, NULL);
if (!hdc) {
remove_group(This);
WARN("Unable to create DC for display %d.\n", i);
goto end_group;
}
hr = present_create_adapter9(This->gdi_display, hdc, &group->adapter);
DeleteDC(hdc);
if (FAILED(hr)) {
remove_group(This);
goto end_group;
}
CopyMemory(group->devname, dd.DeviceName, sizeof(group->devname));
for (j = 0; EnumDisplayDevicesW(group->devname, j, &dd, 0); ++j) {
struct output *out = add_output(This);
boolean orient = FALSE, monit = FALSE;
if (!out) {
ERR("Out of memory.\n");
return E_OUTOFMEMORY;
}
for (k = 0; EnumDisplaySettingsExW(dd.DeviceName, k, &dm, 0); ++k) {
D3DDISPLAYMODEEX *mode = add_mode(This);
if (!out) {
ERR("Out of memory.\n");
return E_OUTOFMEMORY;
}
mode->Size = sizeof(D3DDISPLAYMODEEX);
mode->Width = dm.dmPelsWidth;
mode->Height = dm.dmPelsHeight;
mode->RefreshRate = dm.dmDisplayFrequency;
mode->ScanLineOrdering =
(dm.dmDisplayFlags & DM_INTERLACED) ?
D3DSCANLINEORDERING_INTERLACED :
D3DSCANLINEORDERING_PROGRESSIVE;
switch (dm.dmBitsPerPel) {
case 32: mode->Format = D3DFMT_X8R8G8B8; break;
case 24: mode->Format = D3DFMT_R8G8B8; break;
case 16: mode->Format = D3DFMT_R5G6B5; break;
case 8:
remove_mode(This);
goto end_mode;
default:
remove_mode(This);
WARN("Unknown format (%u bpp) in display %d, monitor "
"%d, mode %d.\n", dm.dmBitsPerPel, i, j, k);
goto end_mode;
}
if (!orient) {
switch (dm.dmDisplayOrientation) {
case DMDO_DEFAULT:
out->rotation = D3DDISPLAYROTATION_IDENTITY;
break;
case DMDO_90:
out->rotation = D3DDISPLAYROTATION_90;
break;
case DMDO_180:
out->rotation = D3DDISPLAYROTATION_180;
break;
case DMDO_270:
out->rotation = D3DDISPLAYROTATION_270;
break;
default:
remove_output(This);
WARN("Unknown display rotation in display %d, "
"monitor %d\n", i, j);
goto end_output;
}
orient = TRUE;
}
if (!monit) {
pt.x = dm.dmPosition.x;
pt.y = dm.dmPosition.y;
out->monitor = MonitorFromPoint(pt, 0);
if (!out->monitor) {
remove_output(This);
WARN("Unable to get monitor handle for display %d, "
"monitor %d.\n", i, j);
goto end_output;
}
monit = TRUE;
}
end_mode:
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
}
end_output:
ZeroMemory(&dd, sizeof(dd));
dd.cb = sizeof(dd);
}
end_group:
ZeroMemory(&dd, sizeof(dd));
dd.cb = sizeof(dd);
}
return D3D_OK;
}
