int DisplayManagerWin::getCurrentDisplayMode(int display)
{
if (!isValidDisplay(display))
return -1;
// grab current mode
DEVMODEW modeInfo;
ZeroMemory(&modeInfo, sizeof(modeInfo));
modeInfo.dmSize = sizeof(modeInfo);
// grab current mode info
if (!EnumDisplaySettingsW((LPCWSTR)m_displayAdapters[display].utf16(), ENUM_CURRENT_SETTINGS,
&modeInfo))
{
QLOG_ERROR() << "Failed to retrieve current mode";
return -1;
}
// check if current mode info matches on of our modes
for (int modeId = 0; modeId < displays[display]->videoModes.size(); modeId++)
{
if (isModeMatching(modeInfo, displays[display]->videoModes[modeId]))
return modeId;
}
return -1;
}
/***********************************************************************
* EnumDisplaySettingsExW (USER32.@)
*/
BOOL WINAPI EnumDisplaySettingsExW(LPCWSTR lpszDeviceName, DWORD iModeNum,
LPDEVMODEW lpDevMode, DWORD dwFlags)
{
FIXME_(system)("(%s,%lu,%p,%08lx): stub\n",
debugstr_w(lpszDeviceName), iModeNum, lpDevMode, dwFlags);
return EnumDisplaySettingsW(lpszDeviceName, iModeNum, lpDevMode);
}
void _glfwPlatformGetVideoMode(_GLFWmonitor* monitor, GLFWvidmode* mode)
{
DEVMODEW dm;
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
EnumDisplaySettingsW(monitor->win32.adapterName, ENUM_CURRENT_SETTINGS, &dm);
mode->width = dm.dmPelsWidth;
mode->height = dm.dmPelsHeight;
mode->refreshRate = dm.dmDisplayFrequency;
_glfwSplitBPP(dm.dmBitsPerPel,
&mode->redBits,
&mode->greenBits,
&mode->blueBits);
}
RECT CWinSystemWin32::ScreenRect(int screen)
{
const MONITOR_DETAILS* details = GetMonitor(screen);
if (!details)
{
CLog::LogFunction(LOGERROR, __FUNCTION__, "no monitor found for screen %i", screen);
}
DEVMODEW sDevMode;
ZeroMemory(&sDevMode, sizeof(sDevMode));
sDevMode.dmSize = sizeof(sDevMode);
if(!EnumDisplaySettingsW(details->DeviceNameW.c_str(), ENUM_CURRENT_SETTINGS, &sDevMode))
CLog::Log(LOGERROR, "%s : EnumDisplaySettings failed with %d", __FUNCTION__, GetLastError());
RECT rc;
rc.left = sDevMode.dmPosition.x;
rc.right = sDevMode.dmPosition.x + sDevMode.dmPelsWidth;
rc.top = sDevMode.dmPosition.y;
rc.bottom = sDevMode.dmPosition.y + sDevMode.dmPelsHeight;
return rc;
}
int Scope::GetRiftDisplayInfo()
{
#ifndef NO_RIFT
//remove last '\\Monitor#' part from hmdInfo.DisplayDeviceName
CStringW DisplayDeviceName(m_hmdInfo.DisplayDeviceName);
DisplayDeviceName = DisplayDeviceName.Left(DisplayDeviceName.ReverseFind('\\'));
m_RiftDisplayInfo.dmSize = sizeof(DEVMODE);
int result = EnumDisplaySettingsW(DisplayDeviceName, ENUM_CURRENT_SETTINGS, &m_RiftDisplayInfo);
if (!result)
return -1;
else
return result;
#else
m_RiftDisplayInfo.dmPelsWidth = DEFAULT_SCREEN_WIDTH;
m_RiftDisplayInfo.dmPelsHeight = DEFAULT_SCREEN_HEIGHT;
m_RiftDisplayInfo.dmPosition.x = DEFAULT_DESKTOPX;
m_RiftDisplayInfo.dmPosition.y = DEFAULT_DESKTOPY;
return 0;
#endif
}
void CWinSystemWin32::UpdateResolutions()
{
CWinSystemBase::UpdateResolutions();
UpdateResolutionsInternal();
if(m_MonitorsInfo.empty())
return;
float refreshRate = 0;
int w = 0;
int h = 0;
uint32_t dwFlags;
// Primary
m_MonitorsInfo[m_nPrimary].ScreenNumber = 0;
w = m_MonitorsInfo[m_nPrimary].ScreenWidth;
h = m_MonitorsInfo[m_nPrimary].ScreenHeight;
if( (m_MonitorsInfo[m_nPrimary].RefreshRate == 59) || (m_MonitorsInfo[m_nPrimary].RefreshRate == 29) || (m_MonitorsInfo[m_nPrimary].RefreshRate == 23) )
refreshRate = (float)(m_MonitorsInfo[m_nPrimary].RefreshRate + 1) / 1.001f;
else
refreshRate = (float)m_MonitorsInfo[m_nPrimary].RefreshRate;
dwFlags = m_MonitorsInfo[m_nPrimary].Interlaced ? D3DPRESENTFLAG_INTERLACED : 0;
UpdateDesktopResolution(CDisplaySettings::GetInstance().GetResolutionInfo(RES_DESKTOP), 0, w, h, refreshRate, dwFlags);
CLog::Log(LOGNOTICE, "Primary mode: %s", CDisplaySettings::GetInstance().GetResolutionInfo(RES_DESKTOP).strMode.c_str());
// Desktop resolution of the other screens
if(m_MonitorsInfo.size() >= 2)
{
int xbmcmonitor = 1; // The screen number+1 showed in the GUI display settings
for (unsigned int monitor = 0; monitor < m_MonitorsInfo.size(); monitor++)
{
if (monitor != m_nPrimary)
{
m_MonitorsInfo[monitor].ScreenNumber = xbmcmonitor;
w = m_MonitorsInfo[monitor].ScreenWidth;
h = m_MonitorsInfo[monitor].ScreenHeight;
if( (m_MonitorsInfo[monitor].RefreshRate == 59) || (m_MonitorsInfo[monitor].RefreshRate == 29) || (m_MonitorsInfo[monitor].RefreshRate == 23) )
refreshRate = (float)(m_MonitorsInfo[monitor].RefreshRate + 1) / 1.001f;
else
refreshRate = (float)m_MonitorsInfo[monitor].RefreshRate;
dwFlags = m_MonitorsInfo[monitor].Interlaced ? D3DPRESENTFLAG_INTERLACED : 0;
RESOLUTION_INFO res;
UpdateDesktopResolution(res, xbmcmonitor++, w, h, refreshRate, dwFlags);
CDisplaySettings::GetInstance().AddResolutionInfo(res);
CLog::Log(LOGNOTICE, "Secondary mode: %s", res.strMode.c_str());
}
}
}
// The rest of the resolutions. The order is not important.
for (unsigned int monitor = 0; monitor < m_MonitorsInfo.size(); monitor++)
{
for(int mode = 0;; mode++)
{
DEVMODEW devmode;
ZeroMemory(&devmode, sizeof(devmode));
devmode.dmSize = sizeof(devmode);
if(EnumDisplaySettingsW(m_MonitorsInfo[monitor].DeviceNameW.c_str(), mode, &devmode) == 0)
break;
if(devmode.dmBitsPerPel != 32)
continue;
float refreshRate;
if(devmode.dmDisplayFrequency == 59 || devmode.dmDisplayFrequency == 29 || devmode.dmDisplayFrequency == 23)
refreshRate = (float)(devmode.dmDisplayFrequency + 1) / 1.001f;
else
refreshRate = (float)(devmode.dmDisplayFrequency);
dwFlags = (devmode.dmDisplayFlags & DM_INTERLACED) ? D3DPRESENTFLAG_INTERLACED : 0;
RESOLUTION_INFO res;
UpdateDesktopResolution(res, m_MonitorsInfo[monitor].ScreenNumber, devmode.dmPelsWidth, devmode.dmPelsHeight, refreshRate, dwFlags);
AddResolution(res);
CLog::Log(LOGNOTICE, "Additional mode: %s", res.strMode.c_str());
}
}
}
bool CWinSystemWin32::ChangeResolution(const RESOLUTION_INFO& res, bool forceChange /*= false*/)
{
const MONITOR_DETAILS* details = GetMonitor(res.iScreen);
if (!details)
return false;
DEVMODEW sDevMode;
ZeroMemory(&sDevMode, sizeof(sDevMode));
sDevMode.dmSize = sizeof(sDevMode);
// If we can't read the current resolution or any detail of the resolution is different than res
if (!EnumDisplaySettingsW(details->DeviceNameW.c_str(), ENUM_CURRENT_SETTINGS, &sDevMode) ||
sDevMode.dmPelsWidth != res.iWidth || sDevMode.dmPelsHeight != res.iHeight ||
sDevMode.dmDisplayFrequency != (int)res.fRefreshRate ||
((sDevMode.dmDisplayFlags & DM_INTERLACED) && !(res.dwFlags & D3DPRESENTFLAG_INTERLACED)) ||
(!(sDevMode.dmDisplayFlags & DM_INTERLACED) && (res.dwFlags & D3DPRESENTFLAG_INTERLACED))
|| forceChange)
{
ZeroMemory(&sDevMode, sizeof(sDevMode));
sDevMode.dmSize = sizeof(sDevMode);
sDevMode.dmDriverExtra = 0;
sDevMode.dmPelsWidth = res.iWidth;
sDevMode.dmPelsHeight = res.iHeight;
sDevMode.dmDisplayFrequency = (int)res.fRefreshRate;
sDevMode.dmDisplayFlags = (res.dwFlags & D3DPRESENTFLAG_INTERLACED) ? DM_INTERLACED : 0;
sDevMode.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS;
LONG rc = DISP_CHANGE_SUCCESSFUL;
bool bResChanged = false;
// Windows 8 refresh rate workaround for 24.0, 48.0 and 60.0 Hz
if (CSysInfo::IsWindowsVersionAtLeast(CSysInfo::WindowsVersionWin8) && (res.fRefreshRate == 24.0 || res.fRefreshRate == 48.0 || res.fRefreshRate == 60.0))
{
CLog::Log(LOGDEBUG, "%s : Using Windows 8+ workaround for refresh rate %d Hz", __FUNCTION__, (int)res.fRefreshRate);
// Get current resolution stored in registry
DEVMODEW sDevModeRegistry;
ZeroMemory(&sDevModeRegistry, sizeof(sDevModeRegistry));
sDevModeRegistry.dmSize = sizeof(sDevModeRegistry);
if (EnumDisplaySettingsW(details->DeviceNameW.c_str(), ENUM_REGISTRY_SETTINGS, &sDevModeRegistry))
{
// Set requested mode in registry without actually changing resolution
rc = ChangeDisplaySettingsExW(details->DeviceNameW.c_str(), &sDevMode, NULL, CDS_UPDATEREGISTRY | CDS_NORESET, NULL);
if (rc == DISP_CHANGE_SUCCESSFUL)
{
// Change resolution based on registry setting
rc = ChangeDisplaySettingsExW(details->DeviceNameW.c_str(), NULL, NULL, CDS_FULLSCREEN, NULL);
if (rc == DISP_CHANGE_SUCCESSFUL)
bResChanged = true;
else
CLog::Log(LOGERROR, "%s : ChangeDisplaySettingsEx (W8+ change resolution) failed with %d, using fallback", __FUNCTION__, rc);
// Restore registry with original values
sDevModeRegistry.dmSize = sizeof(sDevModeRegistry);
sDevModeRegistry.dmDriverExtra = 0;
sDevModeRegistry.dmFields = DM_PELSWIDTH | DM_PELSHEIGHT | DM_DISPLAYFREQUENCY | DM_DISPLAYFLAGS;
rc = ChangeDisplaySettingsExW(details->DeviceNameW.c_str(), &sDevModeRegistry, NULL, CDS_UPDATEREGISTRY | CDS_NORESET, NULL);
if (rc != DISP_CHANGE_SUCCESSFUL)
CLog::Log(LOGERROR, "%s : ChangeDisplaySettingsEx (W8+ restore registry) failed with %d", __FUNCTION__, rc);
}
else
CLog::Log(LOGERROR, "%s : ChangeDisplaySettingsEx (W8+ set registry) failed with %d, using fallback", __FUNCTION__, rc);
}
else
CLog::Log(LOGERROR, "%s : Unable to retrieve registry settings for Windows 8+ workaround, using fallback", __FUNCTION__);
}
// Standard resolution change/fallback for Windows 8+ workaround
if (!bResChanged)
{
// CDS_FULLSCREEN is for temporary fullscreen mode and prevents icons and windows from moving
// to fit within the new dimensions of the desktop
rc = ChangeDisplaySettingsExW(details->DeviceNameW.c_str(), &sDevMode, NULL, CDS_FULLSCREEN, NULL);
if (rc == DISP_CHANGE_SUCCESSFUL)
bResChanged = true;
else
CLog::Log(LOGERROR, "%s : ChangeDisplaySettingsEx failed with %d", __FUNCTION__, rc);
}
if (bResChanged)
ResolutionChanged();
return bResChanged;
}
// nothing to do, return success
return true;
}
// Create monitor from an adapter and (optionally) a display
//
static _GLFWmonitor* createMonitor(DISPLAY_DEVICEW* adapter,
DISPLAY_DEVICEW* display)
{
_GLFWmonitor* monitor;
int widthMM, heightMM;
char* name;
HDC dc;
DEVMODEW dm;
RECT rect;
if (display)
name = _glfwCreateUTF8FromWideStringWin32(display->DeviceString);
else
name = _glfwCreateUTF8FromWideStringWin32(adapter->DeviceString);
if (!name)
return NULL;
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
EnumDisplaySettingsW(adapter->DeviceName, ENUM_CURRENT_SETTINGS, &dm);
dc = CreateDCW(L"DISPLAY", adapter->DeviceName, NULL, NULL);
if (IsWindows8Point1OrGreater())
{
widthMM = GetDeviceCaps(dc, HORZSIZE);
heightMM = GetDeviceCaps(dc, VERTSIZE);
}
else
{
widthMM = (int) (dm.dmPelsWidth * 25.4f / GetDeviceCaps(dc, LOGPIXELSX));
heightMM = (int) (dm.dmPelsHeight * 25.4f / GetDeviceCaps(dc, LOGPIXELSY));
}
DeleteDC(dc);
monitor = _glfwAllocMonitor(name, widthMM, heightMM);
free(name);
if (adapter->StateFlags & DISPLAY_DEVICE_MODESPRUNED)
monitor->win32.modesPruned = GLFW_TRUE;
wcscpy(monitor->win32.adapterName, adapter->DeviceName);
WideCharToMultiByte(CP_UTF8, 0,
adapter->DeviceName, -1,
monitor->win32.publicAdapterName,
sizeof(monitor->win32.publicAdapterName),
NULL, NULL);
if (display)
{
wcscpy(monitor->win32.displayName, display->DeviceName);
WideCharToMultiByte(CP_UTF8, 0,
display->DeviceName, -1,
monitor->win32.publicDisplayName,
sizeof(monitor->win32.publicDisplayName),
NULL, NULL);
}
rect.left = dm.dmPosition.x;
rect.top = dm.dmPosition.y;
rect.right = dm.dmPosition.x + dm.dmPelsWidth;
rect.bottom = dm.dmPosition.y + dm.dmPelsHeight;
EnumDisplayMonitors(NULL, &rect, monitorCallback, (LPARAM) monitor);
return monitor;
}
GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* count)
{
int modeIndex = 0, size = 0;
GLFWvidmode* result = NULL;
*count = 0;
for (;;)
{
int i;
GLFWvidmode mode;
DEVMODEW dm;
ZeroMemory(&dm, sizeof(dm));
dm.dmSize = sizeof(dm);
if (!EnumDisplaySettingsW(monitor->win32.adapterName, modeIndex, &dm))
break;
modeIndex++;
// Skip modes with less than 15 BPP
if (dm.dmBitsPerPel < 15)
continue;
mode.width = dm.dmPelsWidth;
mode.height = dm.dmPelsHeight;
mode.refreshRate = dm.dmDisplayFrequency;
_glfwSplitBPP(dm.dmBitsPerPel,
&mode.redBits,
&mode.greenBits,
&mode.blueBits);
for (i = 0; i < *count; i++)
{
if (_glfwCompareVideoModes(result + i, &mode) == 0)
break;
}
// Skip duplicate modes
if (i < *count)
continue;
if (monitor->win32.modesPruned)
{
// Skip modes not supported by the connected displays
if (ChangeDisplaySettingsExW(monitor->win32.adapterName,
&dm,
NULL,
CDS_TEST,
NULL) != DISP_CHANGE_SUCCESSFUL)
{
continue;
}
}
if (*count == size)
{
size += 128;
result = (GLFWvidmode*) realloc(result, size * sizeof(GLFWvidmode));
}
(*count)++;
result[*count - 1] = mode;
}
if (!*count)
{
// HACK: Report the current mode if no valid modes were found
result = calloc(1, sizeof(GLFWvidmode));
_glfwPlatformGetVideoMode(monitor, result);
*count = 1;
}
return result;
}
/*!
* \brief get the current settins
* \returns Nothing
*/
void iRandR::reload() {
HWND lDesktopHWND_win32 = GetDesktopWindow();
RECT lDesktopRect_win32;
DISPLAY_DEVICEW lDisplayDevice_win32;
lDisplayDevice_win32.cb = sizeof( DISPLAY_DEVICEW );
GetWindowRect( lDesktopHWND_win32, &lDesktopRect_win32 );
vScreenWidth_uI = lDesktopRect_win32.right - lDesktopRect_win32.left;
vScreenHeight_uI = lDesktopRect_win32.bottom - lDesktopRect_win32.top;
vCurrentConfig_eD.clear();
DEVMODEW lSettings_win32;
lSettings_win32.dmSize = sizeof( DEVMODEW );
for ( DWORD lDeviceNum_win32 = 0;
EnumDisplayDevicesW( NULL, lDeviceNum_win32, &lDisplayDevice_win32, 0 );
++lDeviceNum_win32 ) {
DISPLAY_DEVICEW lDisplayDeviceTemp_win32;
lDisplayDeviceTemp_win32.cb = sizeof( DISPLAY_DEVICEW );
for ( DWORD lDisplayNum_win32 = 0; EnumDisplayDevicesW(
lDisplayDevice_win32.DeviceName, lDisplayNum_win32, &lDisplayDeviceTemp_win32, 0 );
++lDisplayNum_win32 ) {
bool lIsEnabled_B = false;
bool lIsPrimary_B = false;
if ( lDisplayDeviceTemp_win32.StateFlags & DISPLAY_DEVICE_ACTIVE )
lIsEnabled_B = true;
if ( lDisplayDeviceTemp_win32.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE )
lIsPrimary_B = true;
iDisplays lTempDisplay( lDisplayDevice_win32.DeviceName, lIsEnabled_B, lIsPrimary_B );
lTempDisplay.setDisplayDevice( lDisplayDevice_win32 );
EnumDisplaySettingsW(
lDisplayDevice_win32.DeviceName, ENUM_CURRENT_SETTINGS, &lSettings_win32 );
lTempDisplay.setCurrentSettings( lSettings_win32 );
lTempDisplay.setCurrentSizeAndPosition( lSettings_win32.dmPelsWidth,
lSettings_win32.dmPelsHeight,
lSettings_win32.dmPosition.x,
lSettings_win32.dmPosition.y,
lSettings_win32.dmDisplayFrequency );
for ( DWORD lModeNum_win32 = 0; EnumDisplaySettingsW(
lDisplayDevice_win32.DeviceName, lModeNum_win32, &lSettings_win32 );
lModeNum_win32++ )
lTempDisplay.addMode( lSettings_win32 );
vCurrentConfig_eD.push_back( lTempDisplay );
}
}
printRandRStatus();
}
static void collectMonitorInfo()
{
DISPLAY_DEVICEW adapter;
adapter.cb = sizeof(adapter);
int found = 0;
int size = 0;
for (int adapterIndex = 0;; ++adapterIndex)
{
if (!EnumDisplayDevicesW(NULL, adapterIndex, &adapter, 0))
break;
if (!(adapter.StateFlags & DISPLAY_DEVICE_ACTIVE))
continue;
for (int displayIndex = 0; ; displayIndex++)
{
DISPLAY_DEVICEW display;
HDC dc;
display.cb = sizeof(display);
if (!EnumDisplayDevicesW(adapter.DeviceName, displayIndex, &display, 0))
break;
dc = CreateDCW(L"DISPLAY", adapter.DeviceName, NULL, NULL);
MonitorDesc desc;
desc.modesPruned = (adapter.StateFlags & DISPLAY_DEVICE_MODESPRUNED) != 0;
wcsncpy_s(desc.adapterName, adapter.DeviceName, elementsOf(adapter.DeviceName));
wcsncpy_s(desc.publicAdapterName, adapter.DeviceName, elementsOf(adapter.DeviceName));
wcsncpy_s(desc.displayName, display.DeviceName, elementsOf(display.DeviceName));
wcsncpy_s(desc.publicDisplayName, display.DeviceName, elementsOf(display.DeviceName));
gMonitors.push_back(desc);
EnumDisplayMonitors(NULL, NULL, monitorCallback, gMonitors.size() - 1);
DeleteDC(dc);
if ((adapter.StateFlags & DISPLAY_DEVICE_PRIMARY_DEVICE) && displayIndex == 0)
{
MonitorDesc desc = gMonitors[0];
gMonitors[0] = gMonitors[found];
gMonitors[found] = desc;
}
found++;
}
}
for (uint32_t monitor = 0; monitor < (uint32_t)gMonitors.size(); ++monitor)
{
MonitorDesc* pMonitor = &gMonitors[monitor];
DEVMODEW devMode = {};
devMode.dmSize = sizeof(DEVMODEW);
devMode.dmFields = DM_PELSHEIGHT | DM_PELSWIDTH;
EnumDisplaySettingsW(pMonitor->adapterName, ENUM_CURRENT_SETTINGS, &devMode);
pMonitor->defaultResolution.mHeight = devMode.dmPelsHeight;
pMonitor->defaultResolution.mWidth = devMode.dmPelsWidth;
tinystl::vector<Resolution> displays;
DWORD current = 0;
while (EnumDisplaySettingsW(pMonitor->adapterName, current++, &devMode))
{
bool duplicate = false;
for (uint32_t i = 0; i < (uint32_t)displays.size(); ++i)
{
if (displays[i].mWidth == (uint32_t)devMode.dmPelsWidth && displays[i].mHeight == (uint32_t)devMode.dmPelsHeight)
{
duplicate = true;
break;
}
}
if (duplicate)
continue;
Resolution videoMode = {};
videoMode.mHeight = devMode.dmPelsHeight;
videoMode.mWidth = devMode.dmPelsWidth;
displays.emplace_back(videoMode);
}
qsort(displays.data(), displays.size(), sizeof(Resolution), [](const void* lhs, const void* rhs) {
Resolution* pLhs = (Resolution*)lhs;
Resolution* pRhs = (Resolution*)rhs;
if (pLhs->mHeight == pRhs->mHeight)
return (int)(pLhs->mWidth - pRhs->mWidth);
return (int)(pLhs->mHeight - pRhs->mHeight);
});
pMonitor->resolutionCount = (uint32_t)displays.size();
pMonitor->resolutions = (Resolution*)conf_calloc(pMonitor->resolutionCount, sizeof(Resolution));
memcpy(pMonitor->resolutions, displays.data(), pMonitor->resolutionCount * sizeof(Resolution));
}
}
static
BOOL
InitializeDialog(HWND hwndDlg, PDISPLAY_DEVICEW pDispDevice)
{
WCHAR szText[100];
WCHAR szFormat[30];
HKEY hKey;
HWND hDlgCtrls[5];
DWORD dwMemory;
DEVMODEW DevMode;
IDirect3D9 * ppObj = NULL;
D3DADAPTER_IDENTIFIER9 Identifier;
HRESULT hResult;
szText[0] = L'\0';
/* fix wine */
//ppObj = Direct3DCreate9(D3D_SDK_VERSION);
if (ppObj)
{
hResult = IDirect3D9_GetAdapterIdentifier(ppObj, D3DADAPTER_DEFAULT , 2/*D3DENUM_WHQL_LEVEL*/, &Identifier);
if (hResult == D3D_OK)
{
if (Identifier.WHQLLevel)
{
/* adapter is WHQL certified */
LoadStringW(hInst, IDS_OPTION_YES, szText, sizeof(szText)/sizeof(WCHAR));
}
else
{
LoadStringW(hInst, IDS_OPTION_NO, szText, sizeof(szText)/sizeof(WCHAR));
}
}
IDirect3D9_Release(ppObj);
}
else
{
LoadStringW(hInst, IDS_DEVICE_STATUS_UNKNOWN, szText, sizeof(szText)/sizeof(WCHAR));
}
szText[(sizeof(szText)/sizeof(WCHAR))-1] = L'\0';
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_LOGO, WM_SETTEXT, 0, (LPARAM)szText);
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, &pDispDevice->DeviceKey[18], 0, KEY_READ, &hKey) != ERROR_SUCCESS)
return FALSE;
if (GetRegValue(hKey, NULL, L"HardwareInformation.ChipType", REG_BINARY, szText, sizeof(szText)))
{
/* set chip type */
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_CHIP, WM_SETTEXT, 0, (LPARAM)szText);
}
if (GetRegValue(hKey, NULL, L"HardwareInformation.DacType", REG_BINARY, szText, sizeof(szText)))
{
/* set DAC type */
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_DAC, WM_SETTEXT, 0, (LPARAM)szText);
}
if (GetRegValue(hKey, NULL, L"HardwareInformation.MemorySize", REG_BINARY, (LPWSTR)&dwMemory, sizeof(dwMemory)))
{
/* set chip memory size */
if (dwMemory > (1048576))
{
/* buggy ATI driver requires that */
dwMemory /= 1048576;
}
szFormat[0] = L'\0';
if (LoadStringW(hInst, IDS_FORMAT_ADAPTER_MEM, szFormat, sizeof(szFormat)/sizeof(WCHAR)))
szFormat[(sizeof(szFormat)/sizeof(WCHAR))-1] = L'\0';
wsprintfW(szText, szFormat, dwMemory);
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_MEM, WM_SETTEXT, 0, (LPARAM)szText);
}
/* retrieve current display mode */
DevMode.dmSize = sizeof(DEVMODEW);
if (EnumDisplaySettingsW(pDispDevice->DeviceName, ENUM_CURRENT_SETTINGS, &DevMode))
{
szFormat[0] = L'\0';
if (LoadStringW(hInst, IDS_FORMAT_ADAPTER_MODE, szFormat, sizeof(szFormat)/sizeof(WCHAR)))
szFormat[(sizeof(szFormat)/sizeof(WCHAR))-1] = L'\0';
wsprintfW(szText, szFormat, DevMode.dmPelsWidth, DevMode.dmPelsHeight, DevMode.dmBitsPerPel, DevMode.dmDisplayFrequency);
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_MODE, WM_SETTEXT, 0, (LPARAM)szText);
}
/* query attached monitor */
wcscpy(szText, pDispDevice->DeviceName);
ZeroMemory(pDispDevice, sizeof(DISPLAY_DEVICEW));
pDispDevice->cb = sizeof(DISPLAY_DEVICEW);
if (EnumDisplayDevicesW(szText, 0, pDispDevice, 0))
{
/* set monitor name */
SendDlgItemMessageW(hwndDlg, IDC_STATIC_ADAPTER_MONITOR, WM_SETTEXT, 0, (LPARAM)pDispDevice->DeviceString);
}
hDlgCtrls[0] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_ID);
hDlgCtrls[1] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_VENDOR);
hDlgCtrls[2] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_DRIVER);
hDlgCtrls[3] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_VERSION);
hDlgCtrls[4] = GetDlgItem(hwndDlg, IDC_STATIC_ADAPTER_DATE);
SetDeviceDetails(hDlgCtrls, &GUID_DEVCLASS_DISPLAY, NULL);
return TRUE;
}
GLFWvidmode* _glfwPlatformGetVideoModes(_GLFWmonitor* monitor, int* found)
{
int modeIndex = 0, count = 0;
GLFWvidmode* result = NULL;
*found = 0;
for (;;)
{
int i;
GLFWvidmode mode;
DEVMODEW dm;
ZeroMemory(&dm, sizeof(DEVMODEW));
dm.dmSize = sizeof(DEVMODEW);
if (!EnumDisplaySettingsW(monitor->win32.adapterName, modeIndex, &dm))
break;
modeIndex++;
if (dm.dmBitsPerPel < 15)
{
// Skip modes with less than 15 BPP
continue;
}
mode.width = dm.dmPelsWidth;
mode.height = dm.dmPelsHeight;
mode.refreshRate = dm.dmDisplayFrequency;
_glfwSplitBPP(dm.dmBitsPerPel,
&mode.redBits,
&mode.greenBits,
&mode.blueBits);
for (i = 0; i < *found; i++)
{
if (_glfwCompareVideoModes(result + i, &mode) == 0)
break;
}
if (i < *found)
{
// This is a duplicate, so skip it
continue;
}
if (*found == count)
{
if (count)
count *= 2;
else
count = 128;
result = (GLFWvidmode*) realloc(result, count * sizeof(GLFWvidmode));
}
result[*found] = mode;
(*found)++;
}
return result;
}
