gtkradiant/libs/multimon.h

#ifndef __MULTIMON_H
#define __MULTIMON_H

#ifdef _WIN32

//=============================================================================
//
// 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 // WIN32

#endif // __MULTIMON_H