获取一个窗口的截图

loverinmydream

我想要通过窗口句柄获取一个窗口的截图，这个窗口是一个外部程序的，只知道进程号，然后回显到当前正在运行的程序窗口上。
这些代码是我从https://learn.microsoft.com/en-us/windows/win32/gdi/capturing-an-image复制下来的，在147行GetDC(NULL)获取桌面窗口句柄，这样可以成功显示。
但是当我把GetDC()参数换成上面这种通过进程ID获取的窗口句柄时，显示都是黑屏的。我不知道是什么原因，求大佬解答

1. BOOL CALLBACK EnumWindowsProc(HWND hwnd, LPARAM lParam)
   
2. {
   
3.         EnumWindowsArg* pArg = (EnumWindowsArg*)lParam;
   
4.         DWORD  dwProcessID = 0;
   
5.         // 通过窗口句柄取得进程ID
   
6.         ::GetWindowThreadProcessId(hwnd, &dwProcessID);
   
7.         if (dwProcessID == pArg->dwProcessID)
   
8.         {
   
9.                 pArg->hwndWindow = hwnd;
   
10.                 // 找到了返回FALSE
    
11.                 return FALSE;
    
12.         }
    
13.         // 没找到，继续找，返回TRUE
    
14.         return TRUE;
    
15. }
    
16. 
    
17. ///< 通过进程ID获取窗口句柄
    
18. HWND GetWindowHwndByPID(DWORD dwProcessID)
    
19. {
    
20.         HWND hwndRet = NULL;
    
21.         EnumWindowsArg ewa;
    
22.         ewa.dwProcessID = dwProcessID;
    
23.         ewa.hwndWindow = NULL;
    
24.         EnumWindows(EnumWindowsProc, (LPARAM)&ewa);
    
25.         if (ewa.hwndWindow)
    
26.         {
    
27.                 hwndRet = ewa.hwndWindow;
    
28.         }
    
29.         return hwndRet;
    
30. }

复制代码

1. // GDI_CapturingAnImage.cpp : Defines the entry point for the application.
   
2. //
   
3. 
   
4. #include "framework.h"
   
5. #include "GDI_CapturingAnImage.h"
   
6. #include "GetHWND.h"
   
7. 
   
8. #define MAX_LOADSTRING 100
   
9. 
   
10. // Global Variables:
    
11. HINSTANCE hInst;                                // current instance
    
12. WCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
    
13. WCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
    
14. 
    
15. // Forward declarations of functions included in this code module:
    
16. ATOM                MyRegisterClass(HINSTANCE hInstance);
    
17. BOOL                InitInstance(HINSTANCE, int);
    
18. LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
    
19. INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
    
20. 
    
21. int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
    
22.   _In_opt_ HINSTANCE hPrevInstance,
    
23.   _In_ LPWSTR    lpCmdLine,
    
24.   _In_ int       nCmdShow)
    
25. {
    
26.   UNREFERENCED_PARAMETER(hPrevInstance);
    
27.   UNREFERENCED_PARAMETER(lpCmdLine);
    
28. 
    
29.   // TODO: Place code here.
    
30. 
    
31.   // Initialize global strings
    
32.   LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    
33.   LoadStringW(hInstance, IDC_GDICAPTURINGANIMAGE, szWindowClass, MAX_LOADSTRING);
    
34.   MyRegisterClass(hInstance);
    
35. 
    
36.   // Perform application initialization:
    
37.   if (!InitInstance(hInstance, nCmdShow))
    
38.   {
    
39.     return FALSE;
    
40.   }
    
41. 
    
42.   HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_GDICAPTURINGANIMAGE));
    
43. 
    
44.   MSG msg;
    
45. 
    
46.   // Main message loop:
    
47.   while (GetMessage(&msg, nullptr, 0, 0))
    
48.   {
    
49.     if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
    
50.     {
    
51.       TranslateMessage(&msg);
    
52.       DispatchMessage(&msg);
    
53.     }
    
54.   }
    
55. 
    
56.   return (int)msg.wParam;
    
57. }
    
58. 
    
59. //
    
60. //  FUNCTION: MyRegisterClass()
    
61. //
    
62. //  PURPOSE: Registers the window class.
    
63. //
    
64. ATOM MyRegisterClass(HINSTANCE hInstance)
    
65. {
    
66.   WNDCLASSEXW wcex;
    
67. 
    
68.   wcex.cbSize = sizeof(WNDCLASSEX);
    
69. 
    
70.   wcex.style = CS_HREDRAW | CS_VREDRAW;
    
71.   wcex.lpfnWndProc = WndProc;
    
72.   wcex.cbClsExtra = 0;
    
73.   wcex.cbWndExtra = 0;
    
74.   wcex.hInstance = hInstance;
    
75.   wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_GDICAPTURINGANIMAGE));
    
76.   wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);
    
77.   wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);
    
78.   wcex.lpszMenuName = MAKEINTRESOURCEW(IDC_GDICAPTURINGANIMAGE);
    
79.   wcex.lpszClassName = szWindowClass;
    
80.   wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
    
81. 
    
82.   return RegisterClassExW(&wcex);
    
83. }
    
84. 
    
85. //
    
86. //   FUNCTION: InitInstance(HINSTANCE, int)
    
87. //
    
88. //   PURPOSE: Saves instance handle and creates main window
    
89. //
    
90. //   COMMENTS:
    
91. //
    
92. //        In this function, we save the instance handle in a global variable and
    
93. //        create and display the main program window.
    
94. //
    
95. BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
    
96. {
    
97.   hInst = hInstance; // Store instance handle in our global variable
    
98. 
    
99.   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
    
100.     CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);
     
101. 
     
102.   if (!hWnd)
     
103.   {
     
104.     return FALSE;
     
105.   }
     
106. 
     
107.   ShowWindow(hWnd, nCmdShow);
     
108.   UpdateWindow(hWnd);
     
109. 
     
110.   return TRUE;
     
111. }
     
112. 
     
113. // THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
     
114. // ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
     
115. // THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
     
116. // PARTICULAR PURPOSE.
     
117. //
     
118. // Copyright (c) Microsoft Corporation. All rights reserved
     
119. 
     
120. //
     
121. //   FUNCTION: CaptureAnImage(HWND hWnd)
     
122. //
     
123. //   PURPOSE: Captures a screenshot into a window ,and then saves it in a .bmp file.
     
124. //
     
125. //   COMMENTS:
     
126. //
     
127. //      Note: This function attempts to create a file called captureqwsx.bmp
     
128. //        
     
129. 
     
130. int CaptureAnImage(HWND hWnd)
     
131. {
     
132.   HDC hdcScreen;
     
133.   HDC hdcWindow;
     
134.   HDC hdcMemDC = NULL;
     
135.   HBITMAP hbmScreen = NULL;
     
136.   BITMAP bmpScreen;
     
137.   DWORD dwBytesWritten = 0;
     
138.   DWORD dwSizeofDIB = 0;
     
139.   HANDLE hFile = NULL;
     
140.   char* lpbitmap = NULL;
     
141.   HANDLE hDIB = NULL;
     
142.   DWORD dwBmpSize = 0;
     
143. 
     
144.   // Retrieve the handle to a display device context for the client
     
145.   // area of the window.
     
146.   // HWND nhdcScreen = GetWindowHwndByPID(27380);
     
147.   hdcScreen = GetDC(NULL); // source
     
148. 
     
149.   hdcWindow = GetDC(hWnd);  // destination
     
150. 
     
151.   // Create a compatible DC, which is used in a BitBlt from the window DC.
     
152.   hdcMemDC = CreateCompatibleDC(hdcWindow);
     
153. 
     
154.   if (!hdcMemDC)
     
155.   {
     
156.     MessageBox(hWnd, L"CreateCompatibleDC has failed", L"Failed", MB_OK);
     
157.     goto done;
     
158.   }
     
159. 
     
160.   // Get the client area for size calculation.
     
161.   RECT rcClient;
     
162.   GetClientRect(hWnd, &rcClient);
     
163. 
     
164.   // This is the best stretch mode.
     
165.   SetStretchBltMode(hdcWindow, HALFTONE);
     
166. 
     
167.   // The source DC is the entire screen, and the destination DC is the current window (HWND).
     
168.   if (!StretchBlt(hdcWindow,
     
169.     0, 0,
     
170.     rcClient.right, rcClient.bottom,
     
171.     hdcScreen,
     
172.     0, 0,
     
173.     GetSystemMetrics(SM_CXSCREEN),
     
174.     GetSystemMetrics(SM_CYSCREEN),
     
175.     SRCCOPY))
     
176.   {
     
177.     MessageBox(hWnd, L"StretchBlt has failed", L"Failed", MB_OK);
     
178.     goto done;
     
179.   }
     
180. 
     
181.   // Create a compatible bitmap from the Window DC.
     
182.   hbmScreen = CreateCompatibleBitmap(hdcWindow, rcClient.right - rcClient.left, rcClient.bottom - rcClient.top);
     
183. 
     
184.   if (!hbmScreen)
     
185.   {
     
186.     MessageBox(hWnd, L"CreateCompatibleBitmap Failed", L"Failed", MB_OK);
     
187.     goto done;
     
188.   }
     
189. 
     
190.   // Select the compatible bitmap into the compatible memory DC.
     
191.   SelectObject(hdcMemDC, hbmScreen);
     
192. 
     
193.   // Bit block transfer into our compatible memory DC.
     
194.   if (!BitBlt(hdcMemDC,
     
195.     0, 0,
     
196.     rcClient.right - rcClient.left, rcClient.bottom - rcClient.top,
     
197.     hdcWindow,
     
198.     0, 0,
     
199.     SRCCOPY))
     
200.   {
     
201.     MessageBox(hWnd, L"BitBlt has failed", L"Failed", MB_OK);
     
202.     goto done;
     
203.   }
     
204. 
     
205.   // Get the BITMAP from the HBITMAP.
     
206.   GetObject(hbmScreen, sizeof(BITMAP), &bmpScreen);
     
207. 
     
208.   BITMAPFILEHEADER   bmfHeader;
     
209.   BITMAPINFOHEADER   bi;
     
210. 
     
211.   bi.biSize = sizeof(BITMAPINFOHEADER);
     
212.   bi.biWidth = bmpScreen.bmWidth;
     
213.   bi.biHeight = bmpScreen.bmHeight;
     
214.   bi.biPlanes = 1;
     
215.   bi.biBitCount = 32;
     
216.   bi.biCompression = BI_RGB;
     
217.   bi.biSizeImage = 0;
     
218.   bi.biXPelsPerMeter = 0;
     
219.   bi.biYPelsPerMeter = 0;
     
220.   bi.biClrUsed = 0;
     
221.   bi.biClrImportant = 0;
     
222. 
     
223.   dwBmpSize = ((bmpScreen.bmWidth * bi.biBitCount + 31) / 32) * 4 * bmpScreen.bmHeight;
     
224. 
     
225.   // Starting with 32-bit Windows, GlobalAlloc and LocalAlloc are implemented as wrapper functions that
     
226.   // call HeapAlloc using a handle to the process's default heap. Therefore, GlobalAlloc and LocalAlloc
     
227.   // have greater overhead than HeapAlloc.
     
228.   hDIB = GlobalAlloc(GHND, dwBmpSize);
     
229.   lpbitmap = (char*)GlobalLock(hDIB);
     
230. 
     
231.   // Gets the "bits" from the bitmap, and copies them into a buffer
     
232.   // that's pointed to by lpbitmap.
     
233.   GetDIBits(hdcWindow, hbmScreen, 0,
     
234.     (UINT)bmpScreen.bmHeight,
     
235.     lpbitmap,
     
236.     (BITMAPINFO*)&bi, DIB_RGB_COLORS);
     
237. 
     
238.   // A file is created, this is where we will save the screen capture.
     
239.   hFile = CreateFile(L"captureqwsx.bmp",
     
240.     GENERIC_WRITE,
     
241.     0,
     
242.     NULL,
     
243.     CREATE_ALWAYS,
     
244.     FILE_ATTRIBUTE_NORMAL, NULL);
     
245. 
     
246.   // Add the size of the headers to the size of the bitmap to get the total file size.
     
247.   dwSizeofDIB = dwBmpSize + sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
     
248. 
     
249.   // Offset to where the actual bitmap bits start.
     
250.   bmfHeader.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER);
     
251. 
     
252.   // Size of the file.
     
253.   bmfHeader.bfSize = dwSizeofDIB;
     
254. 
     
255.   // bfType must always be BM for Bitmaps.
     
256.   bmfHeader.bfType = 0x4D42; // BM.
     
257. 
     
258.   WriteFile(hFile, (LPSTR)&bmfHeader, sizeof(BITMAPFILEHEADER), &dwBytesWritten, NULL);
     
259.   WriteFile(hFile, (LPSTR)&bi, sizeof(BITMAPINFOHEADER), &dwBytesWritten, NULL);
     
260.   WriteFile(hFile, (LPSTR)lpbitmap, dwBmpSize, &dwBytesWritten, NULL);
     
261. 
     
262.   // Unlock and Free the DIB from the heap.
     
263.   GlobalUnlock(hDIB);
     
264.   GlobalFree(hDIB);
     
265. 
     
266.   // Close the handle for the file that was created.
     
267.   CloseHandle(hFile);
     
268. 
     
269.   // Clean up.
     
270. done:
     
271.   DeleteObject(hbmScreen);
     
272.   DeleteObject(hdcMemDC);
     
273.   ReleaseDC(NULL, hdcScreen);
     
274.   ReleaseDC(hWnd, hdcWindow);
     
275. 
     
276.   return 0;
     
277. }
     
278. 
     
279. //
     
280. //  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
     
281. //
     
282. //  PURPOSE: Processes messages for the main window.
     
283. //
     
284. //  WM_COMMAND  - process the application menu
     
285. //  WM_PAINT    - Paint the main window
     
286. //  WM_DESTROY  - post a quit message and return
     
287. //
     
288. //
     
289. LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
     
290. {
     
291.   switch (message)
     
292.   {
     
293.   case WM_COMMAND:
     
294.   {
     
295.     int wmId = LOWORD(wParam);
     
296.     // Parse the menu selections:
     
297.     switch (wmId)
     
298.     {
     
299.     case IDM_ABOUT:
     
300.       DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
     
301.       break;
     
302.     case IDM_EXIT:
     
303.       DestroyWindow(hWnd);
     
304.       break;
     
305.     default:
     
306.       return DefWindowProc(hWnd, message, wParam, lParam);
     
307.     }
     
308.   }
     
309.   break;
     
310.   case WM_PAINT:
     
311.   {
     
312.     PAINTSTRUCT ps;
     
313.     HDC hdc = BeginPaint(hWnd, &ps);
     
314.     CaptureAnImage(hWnd);
     
315.     EndPaint(hWnd, &ps);
     
316.   }
     
317.   break;
     
318.   case WM_DESTROY:
     
319.     PostQuitMessage(0);
     
320.     break;
     
321.   default:
     
322.     return DefWindowProc(hWnd, message, wParam, lParam);
     
323.   }
     
324.   return 0;
     
325. }
     
326. 
     
327. // Message handler for about box.
     
328. INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
     
329. {
     
330.   UNREFERENCED_PARAMETER(lParam);
     
331.   switch (message)
     
332.   {
     
333.   case WM_INITDIALOG:
     
334.     return (INT_PTR)TRUE;
     
335. 
     
336.   case WM_COMMAND:
     
337.     if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
     
338.     {
     
339.       EndDialog(hDlg, LOWORD(wParam));
     
340.       return (INT_PTR)TRUE;
     
341.     }
     
342.     break;
     
343.   }
     
344.   return (INT_PTR)FALSE;
     
345. }

复制代码