initial commit

git-svn-id: http://svn.miranda-ng.org/main/trunk@2 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c

1 files changed, 388 insertions, 0 deletions

diff --git a/plugins/Scriver/multimon.h b/plugins/Scriver/multimon.h
new file mode 100644
index 0000000000..95b81bbe2f
--- /dev/null
+++ b/plugins/Scriver/multimon.h
@@ -0,0 +1,388 @@
+//#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_SAMEDISPLAYFORMAT

+#define SM_SAMEDISPLAYFORMAT    81

+#endif

+

+#ifndef SM_CMONITORS

+#ifndef MONITORINFOF_PRIMARY

+

+#define SM_XVIRTUALSCREEN       76

+#define SM_YVIRTUALSCREEN       77

+#define SM_CXVIRTUALSCREEN      78

+#define SM_CYVIRTUALSCREEN      79

+#define SM_CMONITORS            80

+

+DECLARE_HANDLE(HMONITOR);

+

+typedef struct tagMONITORINFO

+{

+    DWORD   cbSize;

+    RECT    rcMonitor;

+    RECT    rcWork;

+    DWORD   dwFlags;

+} MONITORINFO, *LPMONITORINFO;

+

+#define CCHDEVICENAME 32

+#endif  // SM_CMONITORS

+

+#define MONITORINFOF_PRIMARY        0x00000001

+

+#ifndef MONITOR_DEFAULTTONULL

+#define MONITOR_DEFAULTTONULL       0x00000000

+#endif

+#ifndef MONITOR_DEFAULTTOPRIMARY

+#define MONITOR_DEFAULTTOPRIMARY    0x00000001

+#endif

+#ifndef MONITOR_DEFAULTTONEAREST

+#define MONITOR_DEFAULTTONEAREST    0x00000002

+#endif

+

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

+

+	#ifdef __cplusplus

+		typedef struct tagMONITORINFOEX : public tagMONITORINFO

+		{

+		  TCHAR       szDevice[CCHDEVICENAME];

+		} MONITORINFOEX, *LPMONITORINFOEX;

+	#else

+		typedef struct

+		{

+		  MONITORINFO;

+		  TCHAR       szDevice[CCHDEVICENAME];

+		} MONITORINFOEX, *LPMONITORINFOEX;

+	#endif

+

+

+#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

+#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) */
\ No newline at end of file