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