api/include/multimon.h

//=============================================================================
//
// multimon.h -- Stub module that fakes multiple monitor apis on Win32 OSes
//               without them.
//
// By using this header your code will get back default values from
// GetSystemMetrics() for new metrics, and the new multimonitor APIs
// will act like only one display is present on a Win32 OS without
// multimonitor APIs.
//
// Exactly one source must include this with COMPILE_MULTIMON_STUBS defined.
//
// Copyright (c) 1985-1998, Microsoft Corporation
//
//=============================================================================

#ifdef __cplusplus
extern "C" {            // Assume C declarations for C++
#endif // __cplusplus

//
// If we are building with Win95/NT4 headers, we need to declare
// the multimonitor-related metrics and APIs ourselves.
//
#ifndef SM_CMONITORS

#define SM_XVIRTUALSCREEN       76
#define SM_YVIRTUALSCREEN       77
#define SM_CXVIRTUALSCREEN      78
#define SM_CYVIRTUALSCREEN      79
#define SM_CMONITORS            80
#define SM_SAMEDISPLAYFORMAT    81

// HMONITOR is already declared if WINVER >= 0x0500 in windef.h
// This is for components built with an older version number.
//
#if !defined(HMONITOR_DECLARED) && (WINVER < 0x0500)
DECLARE_HANDLE(HMONITOR);
#define HMONITOR_DECLARED
#endif

#define MONITOR_DEFAULTTONULL       0x00000000
#define MONITOR_DEFAULTTOPRIMARY    0x00000001
#define MONITOR_DEFAULTTONEAREST    0x00000002

#define MONITORINFOF_PRIMARY        0x00000001

typedef struct tagMONITORINFO
{
    DWORD   cbSize;
    RECT    rcMonitor;
    RECT    rcWork;
    DWORD   dwFlags;
} MONITORINFO, *LPMONITORINFO;

#ifndef CCHDEVICENAME
#define CCHDEVICENAME 32
#endif

#ifdef __cplusplus
typedef struct tagMONITORINFOEXA : public tagMONITORINFO
{
    CHAR        szDevice[CCHDEVICENAME];
} MONITORINFOEXA, *LPMONITORINFOEXA;
typedef struct tagMONITORINFOEXW : public tagMONITORINFO
{
    WCHAR       szDevice[CCHDEVICENAME];
} MONITORINFOEXW, *LPMONITORINFOEXW;
#ifdef UNICODE
typedef MONITORINFOEXW MONITORINFOEX;
typedef LPMONITORINFOEXW LPMONITORINFOEX;
#else
typedef MONITORINFOEXA MONITORINFOEX;
typedef LPMONITORINFOEXA LPMONITORINFOEX;
#endif // UNICODE
#else // ndef __cplusplus
typedef struct tagMONITORINFOEXA
{
    MONITORINFO;
    CHAR        szDevice[CCHDEVICENAME];
} MONITORINFOEXA, *LPMONITORINFOEXA;
typedef struct tagMONITORINFOEXW
{
    MONITORINFO;
    WCHAR       szDevice[CCHDEVICENAME];
} MONITORINFOEXW, *LPMONITORINFOEXW;
#ifdef UNICODE
typedef MONITORINFOEXW MONITORINFOEX;
typedef LPMONITORINFOEXW LPMONITORINFOEX;
#else
typedef MONITORINFOEXA MONITORINFOEX;
typedef LPMONITORINFOEXA LPMONITORINFOEX;
#endif // UNICODE
#endif

typedef BOOL (CALLBACK* MONITORENUMPROC)(HMONITOR, HDC, LPRECT, LPARAM);

#ifndef DISPLAY_DEVICE_ATTACHED_TO_DESKTOP
typedef struct _DISPLAY_DEVICEA {
    DWORD  cb;
    CHAR   DeviceName[32];
    CHAR   DeviceString[128];
    DWORD  StateFlags;
    CHAR   DeviceID[128];
    CHAR   DeviceKey[128];
} DISPLAY_DEVICEA, *PDISPLAY_DEVICEA, *LPDISPLAY_DEVICEA;
typedef struct _DISPLAY_DEVICEW {
    DWORD  cb;
    WCHAR  DeviceName[32];
    WCHAR  DeviceString[128];
    DWORD  StateFlags;
    WCHAR  DeviceID[128];
    WCHAR  DeviceKey[128];
} DISPLAY_DEVICEW, *PDISPLAY_DEVICEW, *LPDISPLAY_DEVICEW;
#ifdef UNICODE
typedef DISPLAY_DEVICEW DISPLAY_DEVICE;
typedef PDISPLAY_DEVICEW PDISPLAY_DEVICE;
typedef LPDISPLAY_DEVICEW LPDISPLAY_DEVICE;
#else
typedef DISPLAY_DEVICEA DISPLAY_DEVICE;
typedef PDISPLAY_DEVICEA PDISPLAY_DEVICE;
typedef LPDISPLAY_DEVICEA LPDISPLAY_DEVICE;
#endif // UNICODE

#define DISPLAY_DEVICE_ATTACHED_TO_DESKTOP 0x00000001
#define DISPLAY_DEVICE_MULTI_DRIVER        0x00000002
#define DISPLAY_DEVICE_PRIMARY_DEVICE      0x00000004
#define DISPLAY_DEVICE_MIRRORING_DRIVER    0x00000008
#define DISPLAY_DEVICE_VGA_COMPATIBLE      0x00000010
#endif

#endif  // SM_CMONITORS

#undef GetMonitorInfo
#undef GetSystemMetrics
#undef MonitorFromWindow
#undef MonitorFromRect
#undef MonitorFromPoint
#undef EnumDisplayMonitors
#undef EnumDisplayDevices

//
// Define COMPILE_MULTIMON_STUBS to compile the stubs;
// otherwise, you get the declarations.
//
#ifdef COMPILE_MULTIMON_STUBS

//-----------------------------------------------------------------------------
//
// Implement the API stubs.
//
//-----------------------------------------------------------------------------

#ifndef MULTIMON_FNS_DEFINED

int      (WINAPI* g_pfnGetSystemMetrics)(int) = NULL;
HMONITOR (WINAPI* g_pfnMonitorFromWindow)(HWND, DWORD) = NULL;
HMONITOR (WINAPI* g_pfnMonitorFromRect)(LPCRECT, DWORD) = NULL;
HMONITOR (WINAPI* g_pfnMonitorFromPoint)(POINT, DWORD) = NULL;
BOOL     (WINAPI* g_pfnGetMonitorInfo)(HMONITOR, LPMONITORINFO) = NULL;
BOOL     (WINAPI* g_pfnEnumDisplayMonitors)(HDC, LPCRECT, MONITORENUMPROC, LPARAM) = NULL;
BOOL     (WINAPI* g_pfnEnumDisplayDevices)(PVOID, DWORD, PDISPLAY_DEVICE,DWORD) = NULL;
BOOL     g_fMultiMonInitDone = FALSE;
BOOL     g_fMultimonPlatformNT = FALSE;

#endif

BOOL IsPlatformNT()
{ 
    OSVERSIONINFOA osvi = {0};
    osvi.dwOSVersionInfoSize = sizeof(osvi);
    GetVersionExA((OSVERSIONINFOA*)&osvi);
    return (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId);    
}

BOOL InitMultipleMonitorStubs(void)
{
    HMODULE hUser32;
    if (g_fMultiMonInitDone)
    {
        return g_pfnGetMonitorInfo != NULL;
    }

    g_fMultimonPlatformNT = IsPlatformNT();
    hUser32 = GetModuleHandle(TEXT("USER32"));
    if (hUser32 &&
        (*(FARPROC*)&g_pfnGetSystemMetrics    = GetProcAddress(hUser32,"GetSystemMetrics")) != NULL &&
        (*(FARPROC*)&g_pfnMonitorFromWindow   = GetProcAddress(hUser32,"MonitorFromWindow")) != NULL &&
        (*(FARPROC*)&g_pfnMonitorFromRect     = GetProcAddress(hUser32,"MonitorFromRect")) != NULL &&
        (*(FARPROC*)&g_pfnMonitorFromPoint    = GetProcAddress(hUser32,"MonitorFromPoint")) != NULL &&
        (*(FARPROC*)&g_pfnEnumDisplayMonitors = GetProcAddress(hUser32,"EnumDisplayMonitors")) != NULL &&
#ifdef UNICODE
        (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesW")) != NULL &&
        (*(FARPROC*)&g_pfnGetMonitorInfo      = g_fMultimonPlatformNT ? GetProcAddress(hUser32,"GetMonitorInfoW") : 
                                                GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL
#else
        (*(FARPROC*)&g_pfnGetMonitorInfo      = GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL &&
        (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesA")) != NULL
#endif
    ) {
        g_fMultiMonInitDone = TRUE;
        return TRUE;
    }
    else
    {
        g_pfnGetSystemMetrics    = NULL;
        g_pfnMonitorFromWindow   = NULL;
        g_pfnMonitorFromRect     = NULL;
        g_pfnMonitorFromPoint    = NULL;
        g_pfnGetMonitorInfo      = NULL;
        g_pfnEnumDisplayMonitors = NULL;
        g_pfnEnumDisplayDevices  = NULL;

        g_fMultiMonInitDone = TRUE;
        return FALSE;
    }
}

//-----------------------------------------------------------------------------
//
// fake implementations of Monitor APIs that work with the primary display
// no special parameter validation is made since these run in client code
//
//-----------------------------------------------------------------------------

int WINAPI
xGetSystemMetrics(int nIndex)
{
    if (InitMultipleMonitorStubs())
        return g_pfnGetSystemMetrics(nIndex);

    switch (nIndex)
    {
    case SM_CMONITORS:
    case SM_SAMEDISPLAYFORMAT:
        return 1;

    case SM_XVIRTUALSCREEN:
    case SM_YVIRTUALSCREEN:
        return 0;

    case SM_CXVIRTUALSCREEN:
        nIndex = SM_CXSCREEN;
        break;

    case SM_CYVIRTUALSCREEN:
        nIndex = SM_CYSCREEN;
        break;
    }

    return GetSystemMetrics(nIndex);
}

#define xPRIMARY_MONITOR ((HMONITOR)0x12340042)

HMONITOR WINAPI
xMonitorFromPoint(POINT ptScreenCoords, DWORD dwFlags)
{
    if (InitMultipleMonitorStubs())
        return g_pfnMonitorFromPoint(ptScreenCoords, dwFlags);

    if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
        ((ptScreenCoords.x >= 0) &&
        (ptScreenCoords.x < GetSystemMetrics(SM_CXSCREEN)) &&
        (ptScreenCoords.y >= 0) &&
        (ptScreenCoords.y < GetSystemMetrics(SM_CYSCREEN))))
    {
        return xPRIMARY_MONITOR;
    }

    return NULL;
}

HMONITOR WINAPI
xMonitorFromRect(LPCRECT lprcScreenCoords, DWORD dwFlags)
{
    if (InitMultipleMonitorStubs())
        return g_pfnMonitorFromRect(lprcScreenCoords, dwFlags);

    if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
        ((lprcScreenCoords->right > 0) &&
        (lprcScreenCoords->bottom > 0) &&
        (lprcScreenCoords->left < GetSystemMetrics(SM_CXSCREEN)) &&
        (lprcScreenCoords->top < GetSystemMetrics(SM_CYSCREEN))))
    {
        return xPRIMARY_MONITOR;
    }

    return NULL;
}

HMONITOR WINAPI
xMonitorFromWindow(HWND hWnd, DWORD dwFlags)
{
    WINDOWPLACEMENT wp;

    if (InitMultipleMonitorStubs())
        return g_pfnMonitorFromWindow(hWnd, dwFlags);

    if (dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST))
        return xPRIMARY_MONITOR;

    if (IsIconic(hWnd) ?
            GetWindowPlacement(hWnd, &wp) :
            GetWindowRect(hWnd, &wp.rcNormalPosition)) {

        return xMonitorFromRect(&wp.rcNormalPosition, dwFlags);
    }

    return NULL;
}

BOOL WINAPI
xGetMonitorInfo(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
{
    RECT rcWork;

    if (InitMultipleMonitorStubs())
    {
        BOOL f = g_pfnGetMonitorInfo(hMonitor, lpMonitorInfo);
#ifdef UNICODE
        if (f && !g_fMultimonPlatformNT && (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX)))
        { 
            MultiByteToWideChar(CP_ACP, 0,
                (LPSTR)((MONITORINFOEX*)lpMonitorInfo)->szDevice, -1,
                ((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
        }
#endif
        return f;
    }

    if ((hMonitor == xPRIMARY_MONITOR) &&
        lpMonitorInfo &&
        (lpMonitorInfo->cbSize >= sizeof(MONITORINFO)) &&
        SystemParametersInfoA(SPI_GETWORKAREA, 0, &rcWork, 0))
    {
        lpMonitorInfo->rcMonitor.left = 0;
        lpMonitorInfo->rcMonitor.top  = 0;
        lpMonitorInfo->rcMonitor.right  = GetSystemMetrics(SM_CXSCREEN);
        lpMonitorInfo->rcMonitor.bottom = GetSystemMetrics(SM_CYSCREEN);
        lpMonitorInfo->rcWork = rcWork;
        lpMonitorInfo->dwFlags = MONITORINFOF_PRIMARY;

        if (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX))
        {
#ifdef UNICODE
            MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, ((MONITORINFOEX*)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX*)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
#else // UNICODE
            lstrcpy(((MONITORINFOEX*)lpMonitorInfo)->szDevice, TEXT("DISPLAY"));
#endif // UNICODE
        }

        return TRUE;
    }

    return FALSE;
}

BOOL WINAPI
xEnumDisplayMonitors(
        HDC             hdcOptionalForPainting,
        LPCRECT         lprcEnumMonitorsThatIntersect,
        MONITORENUMPROC lpfnEnumProc,
        LPARAM          dwData)
{
    RECT rcLimit;

    if (InitMultipleMonitorStubs()) {
        return g_pfnEnumDisplayMonitors(
                hdcOptionalForPainting,
                lprcEnumMonitorsThatIntersect,
                lpfnEnumProc,
                dwData);
    }

    if (!lpfnEnumProc)
        return FALSE;

    rcLimit.left   = 0;
    rcLimit.top    = 0;
    rcLimit.right  = GetSystemMetrics(SM_CXSCREEN);
    rcLimit.bottom = GetSystemMetrics(SM_CYSCREEN);

    if (hdcOptionalForPainting)
    {
        RECT    rcClip;
        POINT   ptOrg;

        switch (GetClipBox(hdcOptionalForPainting, &rcClip))
        {
        default:
            if (!GetDCOrgEx(hdcOptionalForPainting, &ptOrg))
                return FALSE;

            OffsetRect(&rcLimit, -ptOrg.x, -ptOrg.y);
            if (IntersectRect(&rcLimit, &rcLimit, &rcClip) &&
                (!lprcEnumMonitorsThatIntersect ||
                     IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect))) {

                break;
            }
            //fall thru
        case NULLREGION:
             return TRUE;
        case ERROR:
             return FALSE;
        }
    } else {
        if (    lprcEnumMonitorsThatIntersect &&
                !IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect)) {

            return TRUE;
        }
    }

    return lpfnEnumProc(
            xPRIMARY_MONITOR,
            hdcOptionalForPainting,
            &rcLimit,
            dwData);
}

BOOL WINAPI
xEnumDisplayDevices(
    PVOID Unused,
    DWORD iDevNum,
    PDISPLAY_DEVICE lpDisplayDevice,
    DWORD dwFlags)
{
    if (InitMultipleMonitorStubs())
        return g_pfnEnumDisplayDevices(Unused, iDevNum, lpDisplayDevice, dwFlags);

    if (Unused != NULL)
        return FALSE;

    if (iDevNum != 0)
        return FALSE;

    if (lpDisplayDevice == NULL || lpDisplayDevice->cb < sizeof(DISPLAY_DEVICE))
        return FALSE;

#ifdef UNICODE
    MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceName, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));
    MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceString, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));
#else // UNICODE
    lstrcpy((LPTSTR)lpDisplayDevice->DeviceName,   TEXT("DISPLAY"));
    lstrcpy((LPTSTR)lpDisplayDevice->DeviceString, TEXT("DISPLAY"));
#endif // UNICODE

    lpDisplayDevice->StateFlags = DISPLAY_DEVICE_ATTACHED_TO_DESKTOP | DISPLAY_DEVICE_PRIMARY_DEVICE;

    return TRUE;
}

#undef xPRIMARY_MONITOR
#undef COMPILE_MULTIMON_STUBS

#else   // COMPILE_MULTIMON_STUBS

extern int  WINAPI xGetSystemMetrics(int);
extern HMONITOR WINAPI xMonitorFromWindow(HWND, DWORD);
extern HMONITOR WINAPI xMonitorFromRect(LPCRECT, DWORD);
extern HMONITOR WINAPI xMonitorFromPoint(POINT, DWORD);
extern BOOL WINAPI xGetMonitorInfo(HMONITOR, LPMONITORINFO);
extern BOOL WINAPI xEnumDisplayMonitors(HDC, LPCRECT, MONITORENUMPROC, LPARAM);
extern BOOL WINAPI xEnumDisplayDevices(PVOID, DWORD, PDISPLAY_DEVICE, DWORD);

#endif  // COMPILE_MULTIMON_STUBS

//
// build defines that replace the regular APIs with our versions
//
#define GetSystemMetrics    xGetSystemMetrics
#define MonitorFromWindow   xMonitorFromWindow
#define MonitorFromRect     xMonitorFromRect
#define MonitorFromPoint    xMonitorFromPoint
#define GetMonitorInfo      xGetMonitorInfo
#define EnumDisplayMonitors xEnumDisplayMonitors
#define EnumDisplayDevices  xEnumDisplayDevices

#ifdef __cplusplus
}
#endif  // __cplusplus

1	bearsoft	1.1	//=============================================================================
2			//
3			// multimon.h -- Stub module that fakes multiple monitor apis on Win32 OSes
4			// without them.
5			//
6			// By using this header your code will get back default values from
7			// GetSystemMetrics() for new metrics, and the new multimonitor APIs
8			// will act like only one display is present on a Win32 OS without
9			// multimonitor APIs.
10			//
11			// Exactly one source must include this with COMPILE_MULTIMON_STUBS defined.
12			//
13			// Copyright (c) 1985-1998, Microsoft Corporation
14			//
15			//=============================================================================
16
17			#ifdef __cplusplus
18			extern "C" { // Assume C declarations for C++
19			#endif // __cplusplus
20
21			//
22			// If we are building with Win95/NT4 headers, we need to declare
23			// the multimonitor-related metrics and APIs ourselves.
24			//
25			#ifndef SM_CMONITORS
26
27			#define SM_XVIRTUALSCREEN 76
28			#define SM_YVIRTUALSCREEN 77
29			#define SM_CXVIRTUALSCREEN 78
30			#define SM_CYVIRTUALSCREEN 79
31			#define SM_CMONITORS 80
32			#define SM_SAMEDISPLAYFORMAT 81
33
34			// HMONITOR is already declared if WINVER >= 0x0500 in windef.h
35			// This is for components built with an older version number.
36			//
37			#if !defined(HMONITOR_DECLARED) && (WINVER < 0x0500)
38			DECLARE_HANDLE(HMONITOR);
39			#define HMONITOR_DECLARED
40			#endif
41
42			#define MONITOR_DEFAULTTONULL 0x00000000
43			#define MONITOR_DEFAULTTOPRIMARY 0x00000001
44			#define MONITOR_DEFAULTTONEAREST 0x00000002
45
46			#define MONITORINFOF_PRIMARY 0x00000001
47
48			typedef struct tagMONITORINFO
49			{
50			DWORD cbSize;
51			RECT rcMonitor;
52			RECT rcWork;
53			DWORD dwFlags;
54			} MONITORINFO, *LPMONITORINFO;
55
56			#ifndef CCHDEVICENAME
57			#define CCHDEVICENAME 32
58			#endif
59
60			#ifdef __cplusplus
61			typedef struct tagMONITORINFOEXA : public tagMONITORINFO
62			{
63			CHAR szDevice[CCHDEVICENAME];
64			} MONITORINFOEXA, *LPMONITORINFOEXA;
65			typedef struct tagMONITORINFOEXW : public tagMONITORINFO
66			{
67			WCHAR szDevice[CCHDEVICENAME];
68			} MONITORINFOEXW, *LPMONITORINFOEXW;
69			#ifdef UNICODE
70			typedef MONITORINFOEXW MONITORINFOEX;
71			typedef LPMONITORINFOEXW LPMONITORINFOEX;
72			#else
73			typedef MONITORINFOEXA MONITORINFOEX;
74			typedef LPMONITORINFOEXA LPMONITORINFOEX;
75			#endif // UNICODE
76			#else // ndef __cplusplus
77			typedef struct tagMONITORINFOEXA
78			{
79			MONITORINFO;
80			CHAR szDevice[CCHDEVICENAME];
81			} MONITORINFOEXA, *LPMONITORINFOEXA;
82			typedef struct tagMONITORINFOEXW
83			{
84			MONITORINFO;
85			WCHAR szDevice[CCHDEVICENAME];
86			} MONITORINFOEXW, *LPMONITORINFOEXW;
87			#ifdef UNICODE
88			typedef MONITORINFOEXW MONITORINFOEX;
89			typedef LPMONITORINFOEXW LPMONITORINFOEX;
90			#else
91			typedef MONITORINFOEXA MONITORINFOEX;
92			typedef LPMONITORINFOEXA LPMONITORINFOEX;
93			#endif // UNICODE
94			#endif
95
96			typedef BOOL (CALLBACK* MONITORENUMPROC)(HMONITOR, HDC, LPRECT, LPARAM);
97
98			#ifndef DISPLAY_DEVICE_ATTACHED_TO_DESKTOP
99			typedef struct _DISPLAY_DEVICEA {
100			DWORD cb;
101			CHAR DeviceName[32];
102			CHAR DeviceString[128];
103			DWORD StateFlags;
104			CHAR DeviceID[128];
105			CHAR DeviceKey[128];
106			} DISPLAY_DEVICEA, PDISPLAY_DEVICEA, LPDISPLAY_DEVICEA;
107			typedef struct _DISPLAY_DEVICEW {
108			DWORD cb;
109			WCHAR DeviceName[32];
110			WCHAR DeviceString[128];
111			DWORD StateFlags;
112			WCHAR DeviceID[128];
113			WCHAR DeviceKey[128];
114			} DISPLAY_DEVICEW, PDISPLAY_DEVICEW, LPDISPLAY_DEVICEW;
115			#ifdef UNICODE
116			typedef DISPLAY_DEVICEW DISPLAY_DEVICE;
117			typedef PDISPLAY_DEVICEW PDISPLAY_DEVICE;
118			typedef LPDISPLAY_DEVICEW LPDISPLAY_DEVICE;
119			#else
120			typedef DISPLAY_DEVICEA DISPLAY_DEVICE;
121			typedef PDISPLAY_DEVICEA PDISPLAY_DEVICE;
122			typedef LPDISPLAY_DEVICEA LPDISPLAY_DEVICE;
123			#endif // UNICODE
124
125			#define DISPLAY_DEVICE_ATTACHED_TO_DESKTOP 0x00000001
126			#define DISPLAY_DEVICE_MULTI_DRIVER 0x00000002
127			#define DISPLAY_DEVICE_PRIMARY_DEVICE 0x00000004
128			#define DISPLAY_DEVICE_MIRRORING_DRIVER 0x00000008
129			#define DISPLAY_DEVICE_VGA_COMPATIBLE 0x00000010
130			#endif
131
132			#endif // SM_CMONITORS
133
134			#undef GetMonitorInfo
135			#undef GetSystemMetrics
136			#undef MonitorFromWindow
137			#undef MonitorFromRect
138			#undef MonitorFromPoint
139			#undef EnumDisplayMonitors
140			#undef EnumDisplayDevices
141
142			//
143			// Define COMPILE_MULTIMON_STUBS to compile the stubs;
144			// otherwise, you get the declarations.
145			//
146			#ifdef COMPILE_MULTIMON_STUBS
147
148			//-----------------------------------------------------------------------------
149			//
150			// Implement the API stubs.
151			//
152			//-----------------------------------------------------------------------------
153
154			#ifndef MULTIMON_FNS_DEFINED
155
156			int (WINAPI* g_pfnGetSystemMetrics)(int) = NULL;
157			HMONITOR (WINAPI* g_pfnMonitorFromWindow)(HWND, DWORD) = NULL;
158			HMONITOR (WINAPI* g_pfnMonitorFromRect)(LPCRECT, DWORD) = NULL;
159			HMONITOR (WINAPI* g_pfnMonitorFromPoint)(POINT, DWORD) = NULL;
160			BOOL (WINAPI* g_pfnGetMonitorInfo)(HMONITOR, LPMONITORINFO) = NULL;
161			BOOL (WINAPI* g_pfnEnumDisplayMonitors)(HDC, LPCRECT, MONITORENUMPROC, LPARAM) = NULL;
162			BOOL (WINAPI* g_pfnEnumDisplayDevices)(PVOID, DWORD, PDISPLAY_DEVICE,DWORD) = NULL;
163			BOOL g_fMultiMonInitDone = FALSE;
164			BOOL g_fMultimonPlatformNT = FALSE;
165
166			#endif
167
168			BOOL IsPlatformNT()
169			{
170			OSVERSIONINFOA osvi = {0};
171			osvi.dwOSVersionInfoSize = sizeof(osvi);
172			GetVersionExA((OSVERSIONINFOA*)&osvi);
173			return (VER_PLATFORM_WIN32_NT == osvi.dwPlatformId);
174			}
175
176			BOOL InitMultipleMonitorStubs(void)
177			{
178			HMODULE hUser32;
179			if (g_fMultiMonInitDone)
180			{
181			return g_pfnGetMonitorInfo != NULL;
182			}
183
184			g_fMultimonPlatformNT = IsPlatformNT();
185			hUser32 = GetModuleHandle(TEXT("USER32"));
186			if (hUser32 &&
187			((FARPROC)&g_pfnGetSystemMetrics = GetProcAddress(hUser32,"GetSystemMetrics")) != NULL &&
188			((FARPROC)&g_pfnMonitorFromWindow = GetProcAddress(hUser32,"MonitorFromWindow")) != NULL &&
189			((FARPROC)&g_pfnMonitorFromRect = GetProcAddress(hUser32,"MonitorFromRect")) != NULL &&
190			((FARPROC)&g_pfnMonitorFromPoint = GetProcAddress(hUser32,"MonitorFromPoint")) != NULL &&
191			((FARPROC)&g_pfnEnumDisplayMonitors = GetProcAddress(hUser32,"EnumDisplayMonitors")) != NULL &&
192			#ifdef UNICODE
193			((FARPROC)&g_pfnEnumDisplayDevices = GetProcAddress(hUser32,"EnumDisplayDevicesW")) != NULL &&
194			((FARPROC)&g_pfnGetMonitorInfo = g_fMultimonPlatformNT ? GetProcAddress(hUser32,"GetMonitorInfoW") :
195			GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL
196			#else
197			((FARPROC)&g_pfnGetMonitorInfo = GetProcAddress(hUser32,"GetMonitorInfoA")) != NULL &&
198			((FARPROC)&g_pfnEnumDisplayDevices = GetProcAddress(hUser32,"EnumDisplayDevicesA")) != NULL
199			#endif
200			) {
201			g_fMultiMonInitDone = TRUE;
202			return TRUE;
203			}
204			else
205			{
206			g_pfnGetSystemMetrics = NULL;
207			g_pfnMonitorFromWindow = NULL;
208			g_pfnMonitorFromRect = NULL;
209			g_pfnMonitorFromPoint = NULL;
210			g_pfnGetMonitorInfo = NULL;
211			g_pfnEnumDisplayMonitors = NULL;
212			g_pfnEnumDisplayDevices = NULL;
213
214			g_fMultiMonInitDone = TRUE;
215			return FALSE;
216			}
217			}
218
219			//-----------------------------------------------------------------------------
220			//
221			// fake implementations of Monitor APIs that work with the primary display
222			// no special parameter validation is made since these run in client code
223			//
224			//-----------------------------------------------------------------------------
225
226			int WINAPI
227			xGetSystemMetrics(int nIndex)
228			{
229			if (InitMultipleMonitorStubs())
230			return g_pfnGetSystemMetrics(nIndex);
231
232			switch (nIndex)
233			{
234			case SM_CMONITORS:
235			case SM_SAMEDISPLAYFORMAT:
236			return 1;
237
238			case SM_XVIRTUALSCREEN:
239			case SM_YVIRTUALSCREEN:
240			return 0;
241
242			case SM_CXVIRTUALSCREEN:
243			nIndex = SM_CXSCREEN;
244			break;
245
246			case SM_CYVIRTUALSCREEN:
247			nIndex = SM_CYSCREEN;
248			break;
249			}
250
251			return GetSystemMetrics(nIndex);
252			}
253
254			#define xPRIMARY_MONITOR ((HMONITOR)0x12340042)
255
256			HMONITOR WINAPI
257			xMonitorFromPoint(POINT ptScreenCoords, DWORD dwFlags)
258			{
259			if (InitMultipleMonitorStubs())
260			return g_pfnMonitorFromPoint(ptScreenCoords, dwFlags);
261
262			if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY \| MONITOR_DEFAULTTONEAREST)) \|\|
263			((ptScreenCoords.x >= 0) &&
264			(ptScreenCoords.x < GetSystemMetrics(SM_CXSCREEN)) &&
265			(ptScreenCoords.y >= 0) &&
266			(ptScreenCoords.y < GetSystemMetrics(SM_CYSCREEN))))
267			{
268			return xPRIMARY_MONITOR;
269			}
270
271			return NULL;
272			}
273
274			HMONITOR WINAPI
275			xMonitorFromRect(LPCRECT lprcScreenCoords, DWORD dwFlags)
276			{
277			if (InitMultipleMonitorStubs())
278			return g_pfnMonitorFromRect(lprcScreenCoords, dwFlags);
279
280			if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY \| MONITOR_DEFAULTTONEAREST)) \|\|
281			((lprcScreenCoords->right > 0) &&
282			(lprcScreenCoords->bottom > 0) &&
283			(lprcScreenCoords->left < GetSystemMetrics(SM_CXSCREEN)) &&
284			(lprcScreenCoords->top < GetSystemMetrics(SM_CYSCREEN))))
285			{
286			return xPRIMARY_MONITOR;
287			}
288
289			return NULL;
290			}
291
292			HMONITOR WINAPI
293			xMonitorFromWindow(HWND hWnd, DWORD dwFlags)
294			{
295			WINDOWPLACEMENT wp;
296
297			if (InitMultipleMonitorStubs())
298			return g_pfnMonitorFromWindow(hWnd, dwFlags);
299
300			if (dwFlags & (MONITOR_DEFAULTTOPRIMARY \| MONITOR_DEFAULTTONEAREST))
301			return xPRIMARY_MONITOR;
302
303			if (IsIconic(hWnd) ?
304			GetWindowPlacement(hWnd, &wp) :
305			GetWindowRect(hWnd, &wp.rcNormalPosition)) {
306
307			return xMonitorFromRect(&wp.rcNormalPosition, dwFlags);
308			}
309
310			return NULL;
311			}
312
313			BOOL WINAPI
314			xGetMonitorInfo(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
315			{
316			RECT rcWork;
317
318			if (InitMultipleMonitorStubs())
319			{
320			BOOL f = g_pfnGetMonitorInfo(hMonitor, lpMonitorInfo);
321			#ifdef UNICODE
322			if (f && !g_fMultimonPlatformNT && (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX)))
323			{
324			MultiByteToWideChar(CP_ACP, 0,
325			(LPSTR)((MONITORINFOEX*)lpMonitorInfo)->szDevice, -1,
326			((MONITORINFOEX)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
327			}
328			#endif
329			return f;
330			}
331
332			if ((hMonitor == xPRIMARY_MONITOR) &&
333			lpMonitorInfo &&
334			(lpMonitorInfo->cbSize >= sizeof(MONITORINFO)) &&
335			SystemParametersInfoA(SPI_GETWORKAREA, 0, &rcWork, 0))
336			{
337			lpMonitorInfo->rcMonitor.left = 0;
338			lpMonitorInfo->rcMonitor.top = 0;
339			lpMonitorInfo->rcMonitor.right = GetSystemMetrics(SM_CXSCREEN);
340			lpMonitorInfo->rcMonitor.bottom = GetSystemMetrics(SM_CYSCREEN);
341			lpMonitorInfo->rcWork = rcWork;
342			lpMonitorInfo->dwFlags = MONITORINFOF_PRIMARY;
343
344			if (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX))
345			{
346			#ifdef UNICODE
347			MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, ((MONITORINFOEX)lpMonitorInfo)->szDevice, (sizeof(((MONITORINFOEX)lpMonitorInfo)->szDevice)/sizeof(TCHAR)));
348			#else // UNICODE
349			lstrcpy(((MONITORINFOEX*)lpMonitorInfo)->szDevice, TEXT("DISPLAY"));
350			#endif // UNICODE
351			}
352
353			return TRUE;
354			}
355
356			return FALSE;
357			}
358
359			BOOL WINAPI
360			xEnumDisplayMonitors(
361			HDC hdcOptionalForPainting,
362			LPCRECT lprcEnumMonitorsThatIntersect,
363			MONITORENUMPROC lpfnEnumProc,
364			LPARAM dwData)
365			{
366			RECT rcLimit;
367
368			if (InitMultipleMonitorStubs()) {
369			return g_pfnEnumDisplayMonitors(
370			hdcOptionalForPainting,
371			lprcEnumMonitorsThatIntersect,
372			lpfnEnumProc,
373			dwData);
374			}
375
376			if (!lpfnEnumProc)
377			return FALSE;
378
379			rcLimit.left = 0;
380			rcLimit.top = 0;
381			rcLimit.right = GetSystemMetrics(SM_CXSCREEN);
382			rcLimit.bottom = GetSystemMetrics(SM_CYSCREEN);
383
384			if (hdcOptionalForPainting)
385			{
386			RECT rcClip;
387			POINT ptOrg;
388
389			switch (GetClipBox(hdcOptionalForPainting, &rcClip))
390			{
391			default:
392			if (!GetDCOrgEx(hdcOptionalForPainting, &ptOrg))
393			return FALSE;
394
395			OffsetRect(&rcLimit, -ptOrg.x, -ptOrg.y);
396			if (IntersectRect(&rcLimit, &rcLimit, &rcClip) &&
397			(!lprcEnumMonitorsThatIntersect \|\|
398			IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect))) {
399
400			break;
401			}
402			//fall thru
403			case NULLREGION:
404			return TRUE;
405			case ERROR:
406			return FALSE;
407			}
408			} else {
409			if ( lprcEnumMonitorsThatIntersect &&
410			!IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect)) {
411
412			return TRUE;
413			}
414			}
415
416			return lpfnEnumProc(
417			xPRIMARY_MONITOR,
418			hdcOptionalForPainting,
419			&rcLimit,
420			dwData);
421			}
422
423			BOOL WINAPI
424			xEnumDisplayDevices(
425			PVOID Unused,
426			DWORD iDevNum,
427			PDISPLAY_DEVICE lpDisplayDevice,
428			DWORD dwFlags)
429			{
430			if (InitMultipleMonitorStubs())
431			return g_pfnEnumDisplayDevices(Unused, iDevNum, lpDisplayDevice, dwFlags);
432
433			if (Unused != NULL)
434			return FALSE;
435
436			if (iDevNum != 0)
437			return FALSE;
438
439			if (lpDisplayDevice == NULL \|\| lpDisplayDevice->cb < sizeof(DISPLAY_DEVICE))
440			return FALSE;
441
442			#ifdef UNICODE
443			MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceName, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));
444			MultiByteToWideChar(CP_ACP, 0, "DISPLAY", -1, lpDisplayDevice->DeviceString, (sizeof(lpDisplayDevice->DeviceName)/sizeof(TCHAR)));
445			#else // UNICODE
446			lstrcpy((LPTSTR)lpDisplayDevice->DeviceName, TEXT("DISPLAY"));
447			lstrcpy((LPTSTR)lpDisplayDevice->DeviceString, TEXT("DISPLAY"));
448			#endif // UNICODE
449
450			lpDisplayDevice->StateFlags = DISPLAY_DEVICE_ATTACHED_TO_DESKTOP \| DISPLAY_DEVICE_PRIMARY_DEVICE;
451
452			return TRUE;
453			}
454
455			#undef xPRIMARY_MONITOR
456			#undef COMPILE_MULTIMON_STUBS
457
458			#else // COMPILE_MULTIMON_STUBS
459
460			extern int WINAPI xGetSystemMetrics(int);
461			extern HMONITOR WINAPI xMonitorFromWindow(HWND, DWORD);
462			extern HMONITOR WINAPI xMonitorFromRect(LPCRECT, DWORD);
463			extern HMONITOR WINAPI xMonitorFromPoint(POINT, DWORD);
464			extern BOOL WINAPI xGetMonitorInfo(HMONITOR, LPMONITORINFO);
465			extern BOOL WINAPI xEnumDisplayMonitors(HDC, LPCRECT, MONITORENUMPROC, LPARAM);
466			extern BOOL WINAPI xEnumDisplayDevices(PVOID, DWORD, PDISPLAY_DEVICE, DWORD);
467
468			#endif // COMPILE_MULTIMON_STUBS
469
470			//
471			// build defines that replace the regular APIs with our versions
472			//
473			#define GetSystemMetrics xGetSystemMetrics
474			#define MonitorFromWindow xMonitorFromWindow
475			#define MonitorFromRect xMonitorFromRect
476			#define MonitorFromPoint xMonitorFromPoint
477			#define GetMonitorInfo xGetMonitorInfo
478			#define EnumDisplayMonitors xEnumDisplayMonitors
479			#define EnumDisplayDevices xEnumDisplayDevices
480
481			#ifdef __cplusplus
482			}
483			#endif // __cplusplus
484