home *** CD-ROM | disk | FTP | other *** search
/ Chip: 2001 Haziran / CHIP Haziran2001.iso / prog / share / 17 / dings_e.exe / Compiler / Include / DX7 / multimon.h < prev    next >
Encoding:
C/C++ Source or Header  |  1999-04-24  |  13.0 KB  |  443 lines
  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 tagMONITORINFOEX : public tagMONITORINFO
  62. {
  63.     TCHAR       szDevice[CCHDEVICENAME];
  64. } MONITORINFOEX, *LPMONITORINFOEX;
  65. #else
  66. typedef struct
  67. {
  68.     MONITORINFO;
  69.     TCHAR       szDevice[CCHDEVICENAME];
  70. } MONITORINFOEX, *LPMONITORINFOEX;
  71. #endif
  72.  
  73. typedef BOOL (CALLBACK* MONITORENUMPROC)(HMONITOR, HDC, LPRECT, LPARAM);
  74.  
  75. #ifndef DISPLAY_DEVICE_ATTACHED_TO_DESKTOP
  76. typedef struct _DISPLAY_DEVICEA {
  77.     DWORD  cb;
  78.     CHAR   DeviceName[32];
  79.     CHAR   DeviceString[128];
  80.     DWORD  StateFlags;
  81.     CHAR   DeviceID[128];
  82.     CHAR   DeviceKey[128];
  83. } DISPLAY_DEVICEA, *PDISPLAY_DEVICEA, *LPDISPLAY_DEVICEA;
  84. typedef struct _DISPLAY_DEVICEW {
  85.     DWORD  cb;
  86.     WCHAR  DeviceName[32];
  87.     WCHAR  DeviceString[128];
  88.     DWORD  StateFlags;
  89.     WCHAR  DeviceID[128];
  90.     WCHAR  DeviceKey[128];
  91. } DISPLAY_DEVICEW, *PDISPLAY_DEVICEW, *LPDISPLAY_DEVICEW;
  92. #ifdef UNICODE
  93. typedef DISPLAY_DEVICEW DISPLAY_DEVICE;
  94. typedef PDISPLAY_DEVICEW PDISPLAY_DEVICE;
  95. typedef LPDISPLAY_DEVICEW LPDISPLAY_DEVICE;
  96. #else
  97. typedef DISPLAY_DEVICEA DISPLAY_DEVICE;
  98. typedef PDISPLAY_DEVICEA PDISPLAY_DEVICE;
  99. typedef LPDISPLAY_DEVICEA LPDISPLAY_DEVICE;
  100. #endif // UNICODE
  101.  
  102. #define DISPLAY_DEVICE_ATTACHED_TO_DESKTOP 0x00000001
  103. #define DISPLAY_DEVICE_MULTI_DRIVER        0x00000002
  104. #define DISPLAY_DEVICE_PRIMARY_DEVICE      0x00000004
  105. #define DISPLAY_DEVICE_MIRRORING_DRIVER    0x00000008
  106. #define DISPLAY_DEVICE_VGA_COMPATIBLE      0x00000010
  107. #endif
  108.  
  109. #endif  // SM_CMONITORS
  110.  
  111. #undef GetMonitorInfo
  112. #undef GetSystemMetrics
  113. #undef MonitorFromWindow
  114. #undef MonitorFromRect
  115. #undef MonitorFromPoint
  116. #undef EnumDisplayMonitors
  117. #undef EnumDisplayDevices
  118.  
  119. //
  120. // Define COMPILE_MULTIMON_STUBS to compile the stubs;
  121. // otherwise, you get the declarations.
  122. //
  123. #ifdef COMPILE_MULTIMON_STUBS
  124.  
  125. //-----------------------------------------------------------------------------
  126. //
  127. // Implement the API stubs.
  128. //
  129. //-----------------------------------------------------------------------------
  130.  
  131. #ifndef MULTIMON_FNS_DEFINED
  132.  
  133. int      (WINAPI* g_pfnGetSystemMetrics)(int) = NULL;
  134. HMONITOR (WINAPI* g_pfnMonitorFromWindow)(HWND, DWORD) = NULL;
  135. HMONITOR (WINAPI* g_pfnMonitorFromRect)(LPCRECT, DWORD) = NULL;
  136. HMONITOR (WINAPI* g_pfnMonitorFromPoint)(POINT, DWORD) = NULL;
  137. BOOL     (WINAPI* g_pfnGetMonitorInfoA)(HMONITOR, LPMONITORINFO) = NULL;
  138. BOOL     (WINAPI* g_pfnEnumDisplayMonitors)(HDC, LPCRECT, MONITORENUMPROC, LPARAM) = NULL;
  139. BOOL     (WINAPI* g_pfnEnumDisplayDevices)(PVOID, DWORD, PDISPLAY_DEVICE,DWORD) = NULL;
  140. BOOL     g_fMultiMonInitDone = FALSE;
  141.  
  142. #endif
  143.  
  144. BOOL InitMultipleMonitorStubs(void)
  145. {
  146.     HMODULE hUser32;
  147.  
  148.     if (g_fMultiMonInitDone)
  149.     {
  150.         return g_pfnGetMonitorInfoA != NULL;
  151.     }
  152.  
  153.     if ((hUser32 = GetModuleHandle(TEXT("USER32"))) &&
  154.         (*(FARPROC*)&g_pfnGetSystemMetrics    = GetProcAddress(hUser32,"GetSystemMetrics")) &&
  155.         (*(FARPROC*)&g_pfnMonitorFromWindow   = GetProcAddress(hUser32,"MonitorFromWindow")) &&
  156.         (*(FARPROC*)&g_pfnMonitorFromRect     = GetProcAddress(hUser32,"MonitorFromRect")) &&
  157.         (*(FARPROC*)&g_pfnMonitorFromPoint    = GetProcAddress(hUser32,"MonitorFromPoint")) &&
  158.         (*(FARPROC*)&g_pfnEnumDisplayMonitors = GetProcAddress(hUser32,"EnumDisplayMonitors")) &&
  159.         (*(FARPROC*)&g_pfnGetMonitorInfoA     = GetProcAddress(hUser32,"GetMonitorInfoA")) &&
  160. #ifdef UNICODE
  161.         (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesW")) )
  162. #else
  163.         (*(FARPROC*)&g_pfnEnumDisplayDevices  = GetProcAddress(hUser32,"EnumDisplayDevicesA")) )
  164. #endif
  165.     {
  166.         g_fMultiMonInitDone = TRUE;
  167.         return TRUE;
  168.     }
  169.     else
  170.     {
  171.         g_pfnGetSystemMetrics    = NULL;
  172.         g_pfnMonitorFromWindow   = NULL;
  173.         g_pfnMonitorFromRect     = NULL;
  174.         g_pfnMonitorFromPoint    = NULL;
  175.         g_pfnGetMonitorInfoA     = NULL;
  176.         g_pfnEnumDisplayMonitors = NULL;
  177.         g_pfnEnumDisplayDevices  = NULL;
  178.  
  179.         g_fMultiMonInitDone = TRUE;
  180.         return FALSE;
  181.     }
  182. }
  183.  
  184. //-----------------------------------------------------------------------------
  185. //
  186. // fake implementations of Monitor APIs that work with the primary display
  187. // no special parameter validation is made since these run in client code
  188. //
  189. //-----------------------------------------------------------------------------
  190.  
  191. int WINAPI
  192. xGetSystemMetrics(int nIndex)
  193. {
  194.     if (InitMultipleMonitorStubs())
  195.         return g_pfnGetSystemMetrics(nIndex);
  196.  
  197.     switch (nIndex)
  198.     {
  199.     case SM_CMONITORS:
  200.     case SM_SAMEDISPLAYFORMAT:
  201.         return 1;
  202.  
  203.     case SM_XVIRTUALSCREEN:
  204.     case SM_YVIRTUALSCREEN:
  205.         return 0;
  206.  
  207.     case SM_CXVIRTUALSCREEN:
  208.         nIndex = SM_CXSCREEN;
  209.         break;
  210.  
  211.     case SM_CYVIRTUALSCREEN:
  212.         nIndex = SM_CYSCREEN;
  213.         break;
  214.     }
  215.  
  216.     return GetSystemMetrics(nIndex);
  217. }
  218.  
  219. #define xPRIMARY_MONITOR ((HMONITOR)0x12340042)
  220.  
  221. HMONITOR WINAPI
  222. xMonitorFromPoint(POINT ptScreenCoords, DWORD dwFlags)
  223. {
  224.     if (InitMultipleMonitorStubs())
  225.         return g_pfnMonitorFromPoint(ptScreenCoords, dwFlags);
  226.  
  227.     if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
  228.         ((ptScreenCoords.x >= 0) &&
  229.         (ptScreenCoords.x < GetSystemMetrics(SM_CXSCREEN)) &&
  230.         (ptScreenCoords.y >= 0) &&
  231.         (ptScreenCoords.y < GetSystemMetrics(SM_CYSCREEN))))
  232.     {
  233.         return xPRIMARY_MONITOR;
  234.     }
  235.  
  236.     return NULL;
  237. }
  238.  
  239. HMONITOR WINAPI
  240. xMonitorFromRect(LPCRECT lprcScreenCoords, DWORD dwFlags)
  241. {
  242.     if (InitMultipleMonitorStubs())
  243.         return g_pfnMonitorFromRect(lprcScreenCoords, dwFlags);
  244.  
  245.     if ((dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST)) ||
  246.         ((lprcScreenCoords->right > 0) &&
  247.         (lprcScreenCoords->bottom > 0) &&
  248.         (lprcScreenCoords->left < GetSystemMetrics(SM_CXSCREEN)) &&
  249.         (lprcScreenCoords->top < GetSystemMetrics(SM_CYSCREEN))))
  250.     {
  251.         return xPRIMARY_MONITOR;
  252.     }
  253.  
  254.     return NULL;
  255. }
  256.  
  257. HMONITOR WINAPI
  258. xMonitorFromWindow(HWND hWnd, DWORD dwFlags)
  259. {
  260.     WINDOWPLACEMENT wp;
  261.  
  262.     if (InitMultipleMonitorStubs())
  263.         return g_pfnMonitorFromWindow(hWnd, dwFlags);
  264.  
  265.     if (dwFlags & (MONITOR_DEFAULTTOPRIMARY | MONITOR_DEFAULTTONEAREST))
  266.         return xPRIMARY_MONITOR;
  267.  
  268.     if (IsIconic(hWnd) ?
  269.             GetWindowPlacement(hWnd, &wp) :
  270.             GetWindowRect(hWnd, &wp.rcNormalPosition)) {
  271.  
  272.         return xMonitorFromRect(&wp.rcNormalPosition, dwFlags);
  273.     }
  274.  
  275.     return NULL;
  276. }
  277.  
  278. BOOL WINAPI
  279. xGetMonitorInfo(HMONITOR hMonitor, LPMONITORINFO lpMonitorInfo)
  280. {
  281.     RECT rcWork;
  282.  
  283.     if (InitMultipleMonitorStubs())
  284.     {
  285.         BOOL f = g_pfnGetMonitorInfoA(hMonitor, lpMonitorInfo);
  286.  
  287. #ifdef UNICODE
  288.         if (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX))
  289.         {
  290.             WCHAR szDeviceW[CCHDEVICENAME];
  291.  
  292.             MultiByteToWideChar(CP_ACP, 0,
  293.                 (LPSTR)((MONITORINFOEX*)lpMonitorInfo)->szDevice, -1,
  294.                 szDeviceW, CCHDEVICENAME);
  295.  
  296.             lstrcpy(((MONITORINFOEX*)lpMonitorInfo)->szDevice, szDeviceW);
  297.         }
  298. #endif
  299.         return f;
  300.     }
  301.  
  302.     if ((hMonitor == xPRIMARY_MONITOR) &&
  303.         lpMonitorInfo &&
  304.         (lpMonitorInfo->cbSize >= sizeof(MONITORINFO)) &&
  305.         SystemParametersInfoA(SPI_GETWORKAREA, 0, &rcWork, 0))
  306.     {
  307.         lpMonitorInfo->rcMonitor.left = 0;
  308.         lpMonitorInfo->rcMonitor.top  = 0;
  309.         lpMonitorInfo->rcMonitor.right  = GetSystemMetrics(SM_CXSCREEN);
  310.         lpMonitorInfo->rcMonitor.bottom = GetSystemMetrics(SM_CYSCREEN);
  311.         lpMonitorInfo->rcWork = rcWork;
  312.         lpMonitorInfo->dwFlags = MONITORINFOF_PRIMARY;
  313.  
  314.         if (lpMonitorInfo->cbSize >= sizeof(MONITORINFOEX))
  315.             lstrcpy(((MONITORINFOEX*)lpMonitorInfo)->szDevice, TEXT("DISPLAY"));
  316.  
  317.         return TRUE;
  318.     }
  319.  
  320.     return FALSE;
  321. }
  322.  
  323. BOOL WINAPI
  324. xEnumDisplayMonitors(
  325.         HDC             hdcOptionalForPainting,
  326.         LPCRECT         lprcEnumMonitorsThatIntersect,
  327.         MONITORENUMPROC lpfnEnumProc,
  328.         LPARAM          dwData)
  329. {
  330.     RECT rcLimit;
  331.  
  332.     if (InitMultipleMonitorStubs()) {
  333.         return g_pfnEnumDisplayMonitors(
  334.                 hdcOptionalForPainting,
  335.                 lprcEnumMonitorsThatIntersect,
  336.                 lpfnEnumProc,
  337.                 dwData);
  338.     }
  339.  
  340.     if (!lpfnEnumProc)
  341.         return FALSE;
  342.  
  343.     rcLimit.left   = 0;
  344.     rcLimit.top    = 0;
  345.     rcLimit.right  = GetSystemMetrics(SM_CXSCREEN);
  346.     rcLimit.bottom = GetSystemMetrics(SM_CYSCREEN);
  347.  
  348.     if (hdcOptionalForPainting)
  349.     {
  350.         RECT    rcClip;
  351.         POINT   ptOrg;
  352.  
  353.         switch (GetClipBox(hdcOptionalForPainting, &rcClip))
  354.         {
  355.         default:
  356.             if (!GetDCOrgEx(hdcOptionalForPainting, &ptOrg))
  357.                 return FALSE;
  358.  
  359.             OffsetRect(&rcLimit, -ptOrg.x, -ptOrg.y);
  360.             if (IntersectRect(&rcLimit, &rcLimit, &rcClip) &&
  361.                 (!lprcEnumMonitorsThatIntersect ||
  362.                      IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect))) {
  363.  
  364.                 break;
  365.             }
  366.             //fall thru
  367.         case NULLREGION:
  368.              return TRUE;
  369.         case ERROR:
  370.              return FALSE;
  371.         }
  372.     } else {
  373.         if (    lprcEnumMonitorsThatIntersect &&
  374.                 !IntersectRect(&rcLimit, &rcLimit, lprcEnumMonitorsThatIntersect)) {
  375.  
  376.             return TRUE;
  377.         }
  378.     }
  379.  
  380.     return lpfnEnumProc(
  381.             xPRIMARY_MONITOR,
  382.             hdcOptionalForPainting,
  383.             &rcLimit,
  384.             dwData);
  385. }
  386.  
  387. BOOL WINAPI
  388. xEnumDisplayDevices(
  389.     PVOID Unused,
  390.     DWORD iDevNum,
  391.     PDISPLAY_DEVICE lpDisplayDevice,
  392.     DWORD dwFlags)
  393. {
  394.     if (InitMultipleMonitorStubs())
  395.         return g_pfnEnumDisplayDevices(Unused, iDevNum, lpDisplayDevice, dwFlags);
  396.  
  397.     if (Unused != NULL)
  398.         return FALSE;
  399.  
  400.     if (iDevNum != 0)
  401.         return FALSE;
  402.  
  403.     if (lpDisplayDevice == NULL || lpDisplayDevice->cb < sizeof(DISPLAY_DEVICE))
  404.         return FALSE;
  405.  
  406.     lstrcpy((TCHAR *)lpDisplayDevice->DeviceName,   TEXT("DISPLAY"));
  407.     lstrcpy((TCHAR *)lpDisplayDevice->DeviceString, TEXT("DISPLAY"));
  408.     lpDisplayDevice->StateFlags = DISPLAY_DEVICE_ATTACHED_TO_DESKTOP | DISPLAY_DEVICE_PRIMARY_DEVICE;
  409.  
  410.     return TRUE;
  411. }
  412.  
  413. #undef xPRIMARY_MONITOR
  414. #undef COMPILE_MULTIMON_STUBS
  415.  
  416. #else   // COMPILE_MULTIMON_STUBS
  417.  
  418. extern int  WINAPI xGetSystemMetrics(int);
  419. extern HMONITOR WINAPI xMonitorFromWindow(HWND, DWORD);
  420. extern HMONITOR WINAPI xMonitorFromRect(LPCRECT, DWORD);
  421. extern HMONITOR WINAPI xMonitorFromPoint(POINT, DWORD);
  422. extern BOOL WINAPI xGetMonitorInfo(HMONITOR, LPMONITORINFO);
  423. extern BOOL WINAPI xEnumDisplayMonitors(HDC, LPCRECT, MONITORENUMPROC, LPARAM);
  424. extern BOOL WINAPI xEnumDisplayDevices(PVOID, DWORD, PDISPLAY_DEVICE, DWORD);
  425.  
  426. #endif  // COMPILE_MULTIMON_STUBS
  427.  
  428. //
  429. // build defines that replace the regular APIs with our versions
  430. //
  431. #define GetSystemMetrics    xGetSystemMetrics
  432. #define MonitorFromWindow   xMonitorFromWindow
  433. #define MonitorFromRect     xMonitorFromRect
  434. #define MonitorFromPoint    xMonitorFromPoint
  435. #define GetMonitorInfo      xGetMonitorInfo
  436. #define EnumDisplayMonitors xEnumDisplayMonitors
  437. #define EnumDisplayDevices  xEnumDisplayDevices
  438.  
  439. #ifdef __cplusplus
  440. }
  441. #endif  // __cplusplus
  442.  
  443.