void
_gdk_monitor_init (void)
{
#ifdef HAVE_MONITOR_INFO
gint i, index;
_gdk_num_monitors = 0;
EnumDisplayMonitors (NULL, NULL, count_monitor, (LPARAM) &_gdk_num_monitors);
_gdk_monitors = g_renew (GdkWin32Monitor, _gdk_monitors, _gdk_num_monitors);
index = 0;
EnumDisplayMonitors (NULL, NULL, enum_monitor, (LPARAM) &index);
_gdk_offset_x = G_MININT;
_gdk_offset_y = G_MININT;
/* Calculate offset */
for (i = 0; i < _gdk_num_monitors; i++)
{
_gdk_offset_x = MAX (_gdk_offset_x, -_gdk_monitors[i].rect.x);
_gdk_offset_y = MAX (_gdk_offset_y, -_gdk_monitors[i].rect.y);
}
GDK_NOTE (MISC, g_print ("Multi-monitor offset: (%d,%d)\n",
_gdk_offset_x, _gdk_offset_y));
/* Translate monitor coords into GDK coordinate space */
for (i = 0; i < _gdk_num_monitors; i++)
{
_gdk_monitors[i].rect.x += _gdk_offset_x;
_gdk_monitors[i].rect.y += _gdk_offset_y;
GDK_NOTE (MISC, g_print ("Monitor %d: %dx%d@%+d%+d\n",
i, _gdk_monitors[i].rect.width,
_gdk_monitors[i].rect.height,
_gdk_monitors[i].rect.x,
_gdk_monitors[i].rect.y));
}
#else
HDC hDC;
_gdk_num_monitors = 1;
_gdk_monitors = g_renew (GdkWin32Monitor, _gdk_monitors, 1);
_gdk_monitors[0].name = g_strdup ("DISPLAY");
hDC = GetDC (NULL);
_gdk_monitors[0].width_mm = GetDeviceCaps (hDC, HORZSIZE);
_gdk_monitors[0].height_mm = GetDeviceCaps (hDC, VERTSIZE);
ReleaseDC (NULL, hDC);
_gdk_monitors[0].rect.x = 0;
_gdk_monitors[0].rect.y = 0;
_gdk_monitors[0].rect.width = GetSystemMetrics (SM_CXSCREEN);
_gdk_monitors[0].rect.height = GetSystemMetrics (SM_CYSCREEN);
_gdk_offset_x = 0;
_gdk_offset_y = 0;
#endif
}
RECT GetDCRect( HDC hdc)
{
RECT rc = {0};
EnumDisplayMonitors(hdc, NULL, MyDCDisplayMonitorsEnumProc, (LPARAM)&rc);
return rc;
}
//---------------------------------------------------------------------------//
// SaveData
//
//---------------------------------------------------------------------------//
void CLauncher::SaveData()
{
m_EnumeratingMonitors = true;
m_Monitor = m_D3D->GetAdapterMonitor(m_Device);
EnumDisplayMonitors(NULL, NULL, MyEnumMonitors, 0);
m_EnumeratingMonitors = false;
IAppOptions::GetInstance()->Set("Device", m_Device);
IAppOptions::GetInstance()->Set("Width", m_Fullscreen ? m_Modes[m_Mode].Width : m_Width);
IAppOptions::GetInstance()->Set("Height", m_Fullscreen ? m_Modes[m_Mode].Height : m_Height);
IAppOptions::GetInstance()->Set("RLeft", m_MonitorRect.left);
IAppOptions::GetInstance()->Set("RTop", m_MonitorRect.top);
IAppOptions::GetInstance()->Set("RWidth", m_Expand ? m_MonitorRect.right - m_MonitorRect.left : m_Width);
IAppOptions::GetInstance()->Set("RHeight", m_Expand ? m_MonitorRect.bottom - m_MonitorRect.top : m_Height);
IAppOptions::GetInstance()->Set("Mode", m_Mode);
IAppOptions::GetInstance()->Set("Fullscreen", m_Fullscreen ? 1 : 0);
IAppOptions::GetInstance()->Set("Expand", m_Expand ? 1 : 0);
IAppOptions::GetInstance()->Set("AutoCustTex", m_AutoCustTex ? 1 : 0);
if (m_AutoCustTex)
{
int w = IAppOptions::GetInstance()->Get("Width", 0);
int h = IAppOptions::GetInstance()->Get("Height", 0);
IAppOptions::GetInstance()->Set("CustTex1W", w>>1);
IAppOptions::GetInstance()->Set("CustTex1H", h>>1);
IAppOptions::GetInstance()->Set("CustTex2W", w>>2);
IAppOptions::GetInstance()->Set("CustTex2H", h>>2);
}
else
{
static int DIB_IsWinVisible(_THIS, int recenter)
{
VisibilityData data;
data.result = 0;
data.first = 1;
GetWindowRect(SDL_Window, &data.wrect);
EnumDisplayMonitors(NULL, NULL, visibility_cb, (LPARAM)&data);
if ( !data.result && recenter ) {
int new_x = 10;
int new_y = 10;
if ( !data.first ) {
int primary_w = data.primary.right - data.primary.left;
int primary_h = data.primary.bottom - data.primary.top;
new_x = data.primary.left + (primary_w - this->screen->w)/2;
new_y = data.primary.top + (primary_h - this->screen->h)/2;
}
DIB_SetWinPos(this, new_x, new_y);
}
return data.result;
}
/***********************************************************************
* MonitorFromRect (USER32.@)
*/
HMONITOR WINAPI MonitorFromRect( LPRECT rect, DWORD flags )
{
struct monitor_enum_info info;
info.rect = *rect;
info.max_area = 0;
info.min_distance = ~0u;
info.primary = 0;
info.nearest = 0;
info.ret = 0;
if (IsRectEmpty(&info.rect))
{
info.rect.right = info.rect.left + 1;
info.rect.bottom = info.rect.top + 1;
}
if (!EnumDisplayMonitors( 0, NULL, monitor_enum, (LPARAM)&info )) return 0;
if (!info.ret)
{
if (flags & MONITOR_DEFAULTTOPRIMARY) info.ret = info.primary;
else if (flags & MONITOR_DEFAULTTONEAREST) info.ret = info.nearest;
}
TRACE( "%s flags %x returning %p\n", wine_dbgstr_rect(rect), flags, info.ret );
return info.ret;
}
BOOL wf_info_peer_register(wfInfo* wfi, wfPeerContext* context)
{
int i;
int peerId;
if (!wfi || !context)
return FALSE;
if (!wf_info_lock(wfi))
return FALSE;
if (wfi->peerCount == WF_INFO_MAXPEERS)
goto fail_peer_count;
context->info = wfi;
if (!(context->updateEvent = CreateEvent(NULL, TRUE, FALSE, NULL)))
goto fail_update_event;
//get the offset of the top left corner of selected screen
EnumDisplayMonitors(NULL, NULL, wf_info_monEnumCB, 0);
_IDcount = 0;
#ifdef WITH_DXGI_1_2
if (wfi->peerCount == 0)
if (wf_dxgi_init(wfi) != 0)
goto fail_driver_init;
#else
if (!wf_mirror_driver_activate(wfi))
goto fail_driver_init;
#endif
//look through the array of peers until an empty slot
for (i = 0; i < WF_INFO_MAXPEERS; ++i)
{
//empty index will be our peer id
if (wfi->peers[i] == NULL)
{
peerId = i;
break;
}
}
wfi->peers[peerId] = ((rdpContext*) context)->peer;
wfi->peers[peerId]->pId = peerId;
wfi->peerCount++;
WLog_INFO(TAG, "Registering Peer: id=%d #=%d", peerId, wfi->peerCount);
wf_info_unlock(wfi);
wfreerdp_server_peer_callback_event(peerId, WF_SRV_CALLBACK_EVENT_CONNECT);
return TRUE;
fail_driver_init:
CloseHandle(context->updateEvent);
context->updateEvent = NULL;
fail_update_event:
fail_peer_count:
context->socketClose = TRUE;
wf_info_unlock(wfi);
return FALSE;
}
static bool gfx_ctx_init(void)
{
if (g_inited)
return false;
g_quit = false;
g_restore_desktop = false;
g_num_mons = 0;
EnumDisplayMonitors(NULL, NULL, monitor_enum_proc, 0);
WNDCLASSEX wndclass = {0};
wndclass.cbSize = sizeof(wndclass);
wndclass.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
wndclass.lpfnWndProc = WndProc;
wndclass.hInstance = GetModuleHandle(NULL);
wndclass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndclass.lpszClassName = "RetroArch";
wndclass.hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON));
wndclass.hIconSm = (HICON)LoadImage(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON), IMAGE_ICON, 16, 16, 0);
if (!RegisterClassEx(&wndclass))
return false;
return true;
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// Fills specified SHELLEXECUTEINFO structure with the information read from registry
VOID CConfigReader::PopulateExecuteInformation ( SHELLEXECUTEINFO* pExecInfo )
{
pExecInfo->cbSize = sizeof ( SHELLEXECUTEINFO ) ;
pExecInfo->fMask =
SEE_MASK_FLAG_DDEWAIT | SEE_MASK_HMONITOR | SEE_MASK_NOASYNC | SEE_MASK_UNICODE ;
pExecInfo->hwnd = NULL ;
pExecInfo->lpVerb = g_szShellExecuteVerb ;
pExecInfo->lpFile = m_lpszPath ;
pExecInfo->lpParameters = m_lpszParams ;
pExecInfo->lpDirectory = NULL ;
pExecInfo->nShow = m_dwWindowState ;
// Set monitor handle. 0 means primary monitor, if index is greater then zero we will enumerate
// through all monitors and find the required one using index.
if ( 0 < m_dwMonitorIndex )
{
FINDMONITOR FindMonitor ;
FindMonitor.dwCurrentIndex = 0 ;
FindMonitor.dwRequiredIndex = m_dwMonitorIndex ;
FindMonitor.hMonitor = NULL ;
EnumDisplayMonitors ( NULL , NULL , EnumMonitorsCallBack , ( LPARAM ) &FindMonitor ) ;
if ( NULL != FindMonitor.hMonitor )
{
pExecInfo->hMonitor = FindMonitor.hMonitor ;
return ;
}
} // If index is invalid or is 0 we will default to primary monitor
else
{
POINT ptZero = { 0 } ;
pExecInfo->hMonitor = MonitorFromPoint ( ptZero , MONITOR_DEFAULTTOPRIMARY ) ;
}
}
// Multi-monitor support.
RECT d3d_monitor_rect(void *data)
{
d3d_video_t *d3d = (d3d_video_t*)data;
Monitor::num_mons = 0;
EnumDisplayMonitors(NULL, NULL, monitor_enum_proc, 0);
if (!Monitor::last_hm)
Monitor::last_hm = MonitorFromWindow(GetDesktopWindow(), MONITOR_DEFAULTTONEAREST);
HMONITOR hm_to_use = Monitor::last_hm;
unsigned fs_monitor = g_settings.video.monitor_index;
if (fs_monitor && fs_monitor <= Monitor::num_mons && Monitor::all_hms[fs_monitor - 1])
{
hm_to_use = Monitor::all_hms[fs_monitor - 1];
d3d->cur_mon_id = fs_monitor - 1;
}
else
{
for (unsigned i = 0; i < Monitor::num_mons; i++)
{
if (Monitor::all_hms[i] == hm_to_use)
{
d3d->cur_mon_id = i;
break;
}
}
}
MONITORINFOEX current_mon;
memset(¤t_mon, 0, sizeof(current_mon));
current_mon.cbSize = sizeof(MONITORINFOEX);
GetMonitorInfo(hm_to_use, (MONITORINFO*)¤t_mon);
return current_mon.rcMonitor;
}
/* static */
int32_t
WinUtils::GetMonitorCount()
{
int32_t monitorCount = 0;
EnumDisplayMonitors(nullptr, nullptr, AddMonitor, (LPARAM)&monitorCount);
return monitorCount;
}
BOOL CScreenCapture::CaptureScreenRect(
std::vector<CRect> arcCapture,
CString sSaveDirName,
int nIdStartFrom,
SCREENSHOT_IMAGE_FORMAT fmt,
int nJpegQuality,
BOOL bGrayscale,
std::vector<MonitorInfo>& monitor_list)
{
// Init output variables
monitor_list.clear();
// Set internal variables
m_nIdStartFrom = nIdStartFrom;
m_sSaveDirName = sSaveDirName;
m_fmt = fmt;
m_nJpegQuality = nJpegQuality;
m_bGrayscale = bGrayscale;
m_arcCapture = arcCapture;
m_monitor_list.clear();
// Get cursor information
GetCursorPos(&m_ptCursorPos);
m_CursorInfo.cbSize = sizeof(CURSORINFO);
GetCursorInfo(&m_CursorInfo);
// Perform actual capture task inside of EnumMonitorsProc
EnumDisplayMonitors(NULL, NULL, EnumMonitorsProc, (LPARAM)this);
// Return
monitor_list = m_monitor_list;
return TRUE;
}
/**
* \brief Update screen information.
*
* This function should be called in libvo's "control" callback
* with parameter VOCTRL_UPDATE_SCREENINFO.
* Note that this also enables the new API where geometry and aspect
* calculations are done in video_out.c:config_video_out
*
* Global libvo variables changed:
* xinerama_x
* xinerama_y
* vo_screenwidth
* vo_screenheight
*/
void w32_update_xinerama_info(struct vo *vo)
{
struct vo_w32_state *w32 = vo->w32;
struct mp_vo_opts *opts = vo->opts;
int screen = opts->fs ? opts->fsscreen_id : opts->screen_id;
vo->xinerama_x = vo->xinerama_y = 0;
if (opts->fs && screen == -2) {
int tmp;
vo->xinerama_x = GetSystemMetrics(SM_XVIRTUALSCREEN);
vo->xinerama_y = GetSystemMetrics(SM_YVIRTUALSCREEN);
tmp = GetSystemMetrics(SM_CXVIRTUALSCREEN);
if (tmp) vo->opts->screenwidth = tmp;
tmp = GetSystemMetrics(SM_CYVIRTUALSCREEN);
if (tmp) vo->opts->screenheight = tmp;
} else if (screen == -1) {
MONITORINFO mi;
HMONITOR m = MonitorFromWindow(w32->window, MONITOR_DEFAULTTOPRIMARY);
mi.cbSize = sizeof(mi);
GetMonitorInfoW(m, &mi);
vo->xinerama_x = mi.rcMonitor.left;
vo->xinerama_y = mi.rcMonitor.top;
vo->opts->screenwidth = mi.rcMonitor.right - mi.rcMonitor.left;
vo->opts->screenheight = mi.rcMonitor.bottom - mi.rcMonitor.top;
} else if (screen >= 0) {
w32->mon_cnt = 0;
w32->mon_id = screen;
EnumDisplayMonitors(NULL, NULL, mon_enum, (LONG_PTR)vo);
}
aspect_save_screenres(vo, vo->opts->screenwidth,
vo->opts->screenheight);
}
void winDisplayDeviceManager::scanDisplays()
{
// TODO mutex for this variable ???
descMap.clear();
EnumDisplayMonitors(0,0,winDisplayDeviceManager::EnumDispProc,(LPARAM)this);
// Add new descriptors
set<DisplayDeviceDescriptor> tempSet, resultSet;
for (descMap_t::iterator it = descMap.begin(); it != descMap.end(); it++)
{
addDevice(it->second);
tempSet.insert(it->second);
}
// We could just copy the new descriptors, however, we need to call callback functions
// for old displays, that's why we do this:
std::set_difference(descriptors.begin(), descriptors.end(), tempSet.begin(), tempSet.end(),
std::inserter(resultSet, resultSet.end()));
set<DisplayDeviceDescriptor>::iterator it = resultSet.begin();
for (; it != resultSet.end(); it++)
{
DisplayDeviceDescriptor desc = *it;
removeDevice(desc);
}
}
void DrawFrame(OpenGLDrawData &oglData)
{
//OutputDebugString("Drawing frame ...\n");
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
EnumDisplayMonitors(oglData.oglDC, NULL, MonitorEnumProc, (LPARAM)&oglData);
#if 0
//glScalef(oglData.width, oglData.height, 1.0f);
glPushMatrix();
glTranslatef(oglData.width / 2.0f, oglData.height / 2.0f, 0.0f);
glScalef(oglData.width, oglData.height, 0.0f);
glBegin(GL_QUADS);
glColor3ub(255, 0, 0);
glVertex2f(-0.5f, -0.5f);
glColor3ub(0, 255, 0);
glVertex2f(-0.5f, 0.5f);
glColor3ub(0, 0, 255);
glVertex2f(0.5f, 0.5f);
glColor3ub(255, 255, 255);
glVertex2f(0.5f, -0.5f);
glEnd();
glPopMatrix();
#endif
#if 1
glEnable(GL_BLEND);
//glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); // non-premultiplied alpha
glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA); // premultiplied alpha
glEnable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, oglData.iconsTexture);
glColor3ub(255, 255, 255);
glScalef(oglData.width, oglData.height, 0.0f);
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f);
glVertex2f(0.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f);
glVertex2f(0.0f, 1.0f);
glTexCoord2f(1.0f, 1.0f);
glVertex2f(1.0f, 1.0f);
glTexCoord2f(1.0f, 0.0f);
glVertex2f(1.0f, 0.0f);
glEnd();
glDisable(GL_TEXTURE_2D);
glDisable(GL_BLEND);
#endif
//OutputDebugString("Drew frame.\n");
}
void enumerate() {
if (initialized) {
return;
}
initialized = true;
EnumDisplayMonitors(NULL, NULL, enumerationCallback, NULL);
}
void Kinc_Windows_InitDisplays() {
HMODULE shcore = LoadLibraryA("Shcore.dll");
if (shcore != NULL) {
MyGetDpiForMonitor = (GetDpiForMonitorType)GetProcAddress(shcore, "GetDpiForMonitor");
}
memset(displays, 0, sizeof(DisplayData) * MAXIMUM_DISPLAYS);
EnumDisplayMonitors(NULL, NULL, EnumerationCallback, 0);
}
system::system()
{
QueryPerformanceFrequency(&freq_);
QueryPerformanceCounter(&start_);
if(!impl::windows::monitors.count())
EnumDisplayMonitors(NULL, NULL, impl::windows::monitor_enum_proc, 0);
}
void Win32WindowManager::buildMonitorsList()
{
// Clear the list
mMonitors.clear();
// Enumerate all monitors
EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, (U32)(void*)&mMonitors);
}
status
ws_init_monitors_display(DisplayObj d)
{ assign(d, monitors, newObject(ClassChain, EAV));
EnumDisplayMonitors(NULL, NULL, next_monitor, (LPARAM)d);
succeed;
}
BOOL LSEnumDisplayMonitors(
HDC hdc,
LPCRECT lprcClip,
MONITORENUMPROC lpfnEnum,
LPARAM dwData)
{
return EnumDisplayMonitors(hdc, lprcClip, lpfnEnum, dwData);
}
unsigned int win32_window_get_screen_count()
{
// http://stackoverflow.com/questions/7767036/how-do-i-get-the-number-of-displays-in-windows
unsigned int screen_count = 0;
EnumDisplayMonitors(0, 0, monitor_enum_proc, (LPARAM)&screen_count);
return screen_count;
} // win32_window_get_screen_count
void win32_monitor_init(void)
{
#ifndef _XBOX
win32_monitor_count = 0;
EnumDisplayMonitors(NULL, NULL, win32_monitor_enum_proc, 0);
#endif
g_quit = false;
}
int Monitor_Setup(void)
{
EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, 0);
if (monitor_count == 0)
return 1;
return 0;
}
ofRectangle ScreenTopology::getScreenRect(int index) {
int numMonitors = GetSystemMetrics (SM_CMONITORS);
printf("we have %d monitors\n", numMonitors);
vector<ofRectangle> monitors;
if(EnumDisplayMonitors(NULL, NULL, monitorEnumFunc, (LPARAM)&monitors)) {
return monitors[index];
}
return ofRectangle();
}
VOID GetHardwareInfo()
{
int i = 0;
int monitorCount;
HANDLE gdi32;
int cores = 0;
//use 64 bits to force allmul() on 32 bit builds
UINT64 physicalPages;
UINT64 pageSize;
InitGpuHardware();
GPU_Initialize(PushSharedMemory->HarwareInformation.DisplayDevice.pciAddress);
PushSharedMemory->HarwareInformation.DisplayDevice.FrameBuffer.Total = GPU_GetTotalMemory();
PushSharedMemory->HarwareInformation.DisplayDevice.EngineClockMax = GPU_GetMaximumEngineClock();
PushSharedMemory->HarwareInformation.DisplayDevice.MemoryClockMax = GPU_GetMaximumMemoryClock();
PushSharedMemory->HarwareInformation.DisplayDevice.VoltageMax = GPU_GetMaximumVoltage();
if (Ini_ReadBoolean(L"Settings", L"GpuUsageD3DKMT", FALSE, L".\\" PUSH_SETTINGS_FILE))
PushGpuLoadD3DKMT = TRUE;
// Get the number of processors in the system
NtQuerySystemInformation(SystemBasicInformation, &HwInfoSystemBasicInformation, sizeof(SYSTEM_BASIC_INFORMATION), 0);
PushSharedMemory->HarwareInformation.Processor.NumberOfThreads = HwInfoSystemBasicInformation.NumberOfProcessors;
physicalPages = HwInfoSystemBasicInformation.NumberOfPhysicalPages;
pageSize = HwInfoSystemBasicInformation.PageSize;
//byte => megabytes
PushSharedMemory->HarwareInformation.Memory.Total = (physicalPages * pageSize) / 1048576;
cores = CPU_Intialize();
PushSharedMemory->HarwareInformation.Processor.NumberOfCores = cores;
PushSharedMemory->HarwareInformation.Processor.TjMax = CPU_GetTemperatureMaximal();
PushSharedMemory->HarwareInformation.Processor.MhzBase = CPU_GetBaseSpeed();
// Monitors
gdi32 = Module_Load(L"gdi32.dll");
GetNumberOfPhysicalMonitors = Module_GetProcedureAddress(gdi32, "GetNumberOfPhysicalMonitors");
GetPhysicalMonitors = Module_GetProcedureAddress(gdi32, "GetPhysicalMonitors");
DDCCIGetTimingReport = Module_GetProcedureAddress(gdi32, "DDCCIGetTimingReport");
DDCCIGetVCPFeature = Module_GetProcedureAddress(gdi32, "DDCCIGetVCPFeature");
DDCCISetVCPFeature = Module_GetProcedureAddress(gdi32, "DDCCISetVCPFeature");
monitorCount = GetSystemMetrics(SM_CMONITORS);
MonitorWidth = GetSystemMetrics(SM_CXSCREEN);
MonitorHeight = GetSystemMetrics(SM_CYSCREEN);
MonitorHandles = Memory_Allocate(sizeof(HANDLE) * monitorCount);
EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, NULL);
}
MonitorManager *monitor_mgr_create()
{
MonitorManager *mgr = malloc(sizeof(MonitorManager*));
mgr->monitor_count = 0;
mgr->monitors = NULL;
EnumDisplayMonitors(0, NULL, callback, (LPARAM)mgr);
return mgr;
}
/*
* FUNCTION FindMonitor
*
* find a specific monitor given by index. Index -1 is the
* primary display.
*
* returns the DC of the selected monitor
*/
HDC FindMonitor(int index)
{
if(index == -1)
return GetDC(NULL); /* return primary display context */
monitorSearchIndex = 0;
monitorDC = 0;
EnumDisplayMonitors(NULL, NULL, MonitorEnumProc, index);
return monitorDC;
}
// Startup monitor ay be specified from command line
// Example: ConEmu.exe -Monitor <1 | x10001 | "\\.\DISPLAY1">
HMONITOR MonitorFromParam(LPCWSTR asMonitor)
{
if (!asMonitor || !*asMonitor)
return NULL;
wchar_t* pszEnd;
HMONITOR hMon = NULL;
MONITORINFO mi = {sizeof(mi)};
if (asMonitor[0] == L'x' || asMonitor[0] == L'X')
hMon = (HMONITOR)(DWORD_PTR)wcstoul(asMonitor+1, &pszEnd, 16);
else if (asMonitor[0] == L'0' && (asMonitor[1] == L'x' || asMonitor[1] == L'X'))
hMon = (HMONITOR)(DWORD_PTR)wcstoul(asMonitor+2, &pszEnd, 16);
// HMONITOR was already specified?
if (GetMonitorInfo(hMon, &mi))
return hMon;
// Monitor name or index?
struct impl {
HMONITOR hMon;
LPCWSTR pszName;
LONG nIndex;
static BOOL CALLBACK FindMonitor(HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMonitor, LPARAM dwData)
{
impl* p = (impl*)dwData;
MONITORINFOEX mi; ZeroStruct(mi); mi.cbSize = sizeof(mi);
if (GetMonitorInfo(hMonitor, &mi))
{
// Get monitor by name?
if (p->pszName && (0 == lstrcmpi(p->pszName, mi.szDevice)))
{
p->hMon = hMonitor;
return FALSE; // Stop
}
// Get monitor by index
if ((--p->nIndex) <= 0)
{
p->hMon = hMonitor;
return FALSE; // Stop
}
}
return TRUE; // Continue enum
};
} Impl = {};
if (isDigit(asMonitor[0]))
Impl.nIndex = wcstoul(asMonitor, &pszEnd, 10);
else
Impl.pszName = asMonitor;
EnumDisplayMonitors(NULL, NULL, impl::FindMonitor, (LPARAM)&Impl);
// Return what found or not
return Impl.hMon;
}
Bool QueryMonitor(int index, struct GetMonitorInfoData *data)
{
/* prepare data */
if (data == NULL)
return FALSE;
memset(data, 0, sizeof(*data));
data->requestedMonitor = index;
/* query information */
return EnumDisplayMonitors(NULL, NULL, getMonitorInfo, (LPARAM) data);
}
// this is the static initialize phase is called via constructor
// Has to occur BEFORE init()
// manages to detect Multimonitorsystems, and ScreensaverMode..
void ScreensaverApp::initialize()
{
iScreensaverMode=InterpreteCommandLine();
BOOL blnCloneMode=CRegistry::MatrixShow[REGISTRY_CLONE];
EnumDisplayMonitors(GetDC(NULL),NULL,(MONITORENUMPROC) MonitorEnum, (long)&blnCloneMode);
SetCursor(NULL);
}
