多显示器编程

开发平台：
Visual C++

Multimon.h：源码内容
							#if !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500)
//=============================================================================
//// MULTIMON
// stub module that "stubs" multiple monitor APIs on pre-Memphis Win32 OSes//
// By using this header your code will work unchanged on Win95,
// you will get back correct values from GetSystemMetrics() for new metrics
// and the new APIs will act like only one display is present.//
// exactly one source must include this with COMPILE_MULTIMON_STUBS defined//
//=============================================================================
#ifdef __cplusplus
extern "C" {            /* Assume C declarations for C++ */
#endif  /* __cplusplus *///
// if we are building on Win95/NT4 headers we need to declare this stuff 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
DECLARE_HANDLE(HMONITOR);
#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;
#define CCHDEVICENAME 32
#ifdef __cplusplus
typedef struct tagMONITORINFOEX : public tagMONITORINFO
{
  TCHAR       szDevice[CCHDEVICENAME];
} MONITORINFOEX, *LPMONITORINFOEX;
#else
typedef struct{
	MONITORINFO;
	TCHAR       szDevice[CCHDEVICENAME];
} MONITORINFOEX, *LPMONITORINFOEX;
#endif
typedef BOOL (CALLBACK* MONITORENUMPROC)(HMONITOR, HDC, LPRECT, LPARAM);
#endif  // SM_CMONITORS
#ifndef DISPLAY_DEVICE_ATTACHED_TO_DESKTOP
typedef struct {
    DWORD  cb;
    CHAR   DeviceName[32];
    CHAR   DeviceString[128];
    DWORD  StateFlags;
} DISPLAY_DEVICE;
#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
#endif
#define DISPLAY_DEVICE_VGA                 0x00000010
#ifndef ENUM_CURRENT_SETTINGS
#define ENUM_CURRENT_SETTINGS       ((DWORD)-1)
#define ENUM_REGISTRY_SETTINGS      ((DWORD)-2)
#endif
#undef GetMonitorInfo
#undef GetSystemMetrics
#undef MonitorFromWindow
#undef MonitorFromRect
#undef MonitorFromPoint
#undef EnumDisplayMonitors
#undef EnumDisplayDevices
//
// define this to compile the stubs
// otherwise you get the declarations
//
#ifdef COMPILE_MULTIMON_STUBS
    //---------------------------------------------------------------------------
    //
    // Implement the API stubs.
    //
    //---------------------------------------------------------------------------
    int      (WINAPI* g_pfnGetSystemMetrics)(int);
    HMONITOR (WINAPI* g_pfnMonitorFromWindow)(HWND, BOOL);
    HMONITOR (WINAPI* g_pfnMonitorFromRect)(LPCRECT, BOOL);
    HMONITOR (WINAPI* g_pfnMonitorFromPoint)(POINT, BOOL);
    BOOL     (WINAPI* g_pfnGetMonitorInfo)(HMONITOR, LPMONITORINFO);
    BOOL     (WINAPI* g_pfnEnumDisplayMonitors)(HDC, LPCRECT,
              MONITORENUMPROC, LPARAM);
    BOOL     (WINAPI *g_pfnEnumDisplayDevices)(LPVOID, int, 
              DISPLAY_DEVICE *,DWORD);
    
	BOOL InitMultipleMonitorStubs(void)
    {
        HMODULE hUser32;
        static BOOL fInitDone;
        if (fInitDone)
        {
            return g_pfnGetMonitorInfo != NULL;
        }
        
		if ((hUser32 = GetModuleHandle(TEXT("USER32"))) &&
            (*(FARPROC*)&g_pfnGetSystemMetrics    = GetProcAddress(hUser32,"GetSystemMetrics")) &&
            (*(FARPROC*)&g_pfnMonitorFromWindow   = GetProcAddress(hUser32,"MonitorFromWindow")) &&
            (*(FARPROC*)&g_pfnMonitorFromRect     = GetProcAddress(hUser32,"MonitorFromRect")) &&
            (*(FARPROC*)&g_pfnMonitorFromPoint    = GetProcAddress(hUser32,"MonitorFromPoint")) &&
            (*(FARPROC*)&g_pfnEnumDisplayMonitors = GetProcAddress(hUser32,"EnumDisplayMonitors")) &&
    #ifdef UNICODE
            (*(FARPROC*)&g_pfnGetMonitorInfo      = GetProcAddress(hUser32,"GetMonitorInfoW")) &&
            (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesW")) &&
    #else
            (*(FARPROC*)&g_pfnGetMonitorInfo      = GetProcAddress(hUser32,"GetMonitorInfoA")) &&
            (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesA")) &&
    #endif
            (GetSystemMetrics(SM_CXVIRTUALSCREEN) >= GetSystemMetrics(SM_CXSCREEN)) &&
            (GetSystemMetrics(SM_CYVIRTUALSCREEN) >= GetSystemMetrics(SM_CYSCREEN)) )
        {
            fInitDone = 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;
            fInitDone = TRUE;
            return FALSE;
		}
    }
    //---------------------------------------------------------------------------
    //
    // "stubbed" implementations of Monitor APIs that work with the primary         //  display
    //
    //---------------------------------------------------------------------------
    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)0x42)
    
	HMONITOR WINAPI
    xMonitorFromRect(LPCRECT lprcScreenCoords, UINT uFlags)
    {
        if (InitMultipleMonitorStubs())
            return g_pfnMonitorFromRect(lprcScreenCoords, uFlags);
 
		if ((uFlags & (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, UINT uFlags)
    {
        RECT rc;
        
		if (InitMultipleMonitorStubs())
            return g_pfnMonitorFromWindow(hWnd, uFlags);
        if (uFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST))
            return xPRIMARY_MONITOR;
        
		if (GetWindowRect(hWnd, &rc))
            return xMonitorFromRect(&rc, uFlags);
        
		return NULL;
    }
    HMONITOR WINAPI
	xMonitorFromPoint(POINT ptScreenCoords, UINT uFlags)
    {
        if (InitMultipleMonitorStubs())
            return g_pfnMonitorFromPoint(ptScreenCoords, uFlags);
        if ((uFlags & (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;
    }
    BOOL WINAPI
    xGetMonitorInfo(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
    {
        RECT rcWork;
        if (InitMultipleMonitorStubs())
            return g_pfnGetMonitorInfo(hMonitor, lpMonitorInfo);
        if ((hMonitor == xPRIMARY_MONITOR) && lpMonitorInfo &&
            (lpMonitorInfo->cbSize >= sizeof(MONITORINFO)) &&
            SystemParametersInfo(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))
                lstrcpy(((MONITORINFOEX*)lpMonitorInfo)->szDevice,
                TEXT("DISPLAY"));
            
			return TRUE;
        }
        return FALSE;
    }
    
	BOOL WINAPI
	xEnumDisplayMonitors(
        HDC hdc,
        LPCRECT lprcIntersect, 
        MONITORENUMPROC lpfnEnumProc,
        LPARAM lData)
    {
        RECT rcCallback, rcLimit;
        if (InitMultipleMonitorStubs())
            return g_pfnEnumDisplayMonitors(hdc, lprcIntersect, lpfnEnumProc,
                                           lData);
		
		if (!lpfnEnumProc)
            return FALSE;
        
		rcLimit.left   = 0;
        rcLimit.top    = 0;
        rcLimit.right  = GetSystemMetrics(SM_CXSCREEN);
        rcLimit.bottom = GetSystemMetrics(SM_CYSCREEN);
        if (hdc)
        {
            RECT rcClip;
            HWND hWnd;
            if ((hWnd = WindowFromDC(hdc)) == NULL)
                return FALSE;
            switch (GetClipBox(hdc, &rcClip))
            { 
			default:
                MapWindowPoints(NULL, hWnd, (LPPOINT)&rcLimit, 2);
                if (IntersectRect(&rcCallback, &rcClip, &rcLimit))
                    break;
                //fall thru
            case NULLREGION:
				return TRUE;
            case ERROR:
                 return FALSE;
            } 
			
			rcLimit = rcCallback;
        }
        
		if (!lprcIntersect ||
            IntersectRect(&rcCallback, lprcIntersect, &rcLimit))        {
            lpfnEnumProc(xPRIMARY_MONITOR, hdc, &rcCallback, lData);        }
        return TRUE;
    }
    
	BOOL WINAPI
    xEnumDisplayDevices(LPVOID lpReserved, int iDeviceNum, 
DISPLAY_DEVICE * pDisplayDevice, DWORD dwFlags)
    {
        if (InitMultipleMonitorStubs())
            return g_pfnEnumDisplayDevices(lpReserved, iDeviceNum,
                                           pDisplayDevice, dwFlags); 
		
        return FALSE;
    }
    #undef xPRIMARY_MONITOR
    #undef COMPILE_MULTIMON_STUBS
#else    // COMPILE_MULTIMON_STUBS
    extern int    WINAPI xGetSystemMetrics(int);
    extern HMONITOR WINAPI xMonitorFromWindow(HWND, UINT);
    extern HMONITOR WINAPI xMonitorFromRect(LPCRECT, UINT);
    extern HMONITOR WINAPI xMonitorFromPoint(POINT, UINT);
    extern BOOL    WINAPI xGetMonitorInfo(HMONITOR, LPMONITORINFO);
    extern BOOL    WINAPI xEnumDisplayMonitors(HDC, LPCRECT, MONITORENUMPROC,
                                               LPARAM);
    extern BOOL WINAPI xEnumDisplayDevices(LPVOID, int, DISPLAY_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 */
#endif  /* !defined(_WIN32_WINNT) || (_WIN32_WINNT < 0x0500) */

						