Capture a Window even a window is over

HBITMAP CopyScreenToBitmap(LPRECT lpRect, BYTE *pData, BITMAPINFO *pHeader)
{
    HDC         hScrDC, hMemDC;         // screen DC and memory DC
    HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
    int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
    int         nWidth, nHeight;        // DIB width and height
    int         xScrn, yScrn;           // screen resolution
 
    // check for an empty rectangle
	if (IsRectEmpty(lpRect))       
		return NULL;      
 
	//hScrDC = CreateDC("DISPLAY", NULL, NULL, NULL);     
	
	HWND hwnd = FindWindow("SciCalc", "Calculator");
	GetWindowRect(hwnd , lpRect);
	hScrDC = GetDC(hwnd);
	hMemDC = CreateCompatibleDC(hScrDC);      // get points of rectangle to grab  
 
    // get points of rectangle to grab
    nX  = lpRect->left;
    nY  = lpRect->top;
    nX2 = lpRect->right;
    nY2 = lpRect->bottom;
	
    // get screen resolution
    xScrn = GetDeviceCaps(hScrDC, HORZRES);
    yScrn = GetDeviceCaps(hScrDC, VERTRES);
 
    //make sure bitmap rectangle is visible
    if (nX < 0)
        nX = 0;
    if (nY < 0)
        nY = 0;
    if (nX2 > xScrn)
        nX2 = xScrn;
    if (nY2 > yScrn)
        nY2 = yScrn;
 
	nWidth = nX2 - nX;
	nHeight = nY2 - nY;
 
    // create a bitmap compatible with the screen DC
    hBitmap = CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
 
    // select new bitmap into memory DC
    hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
    // bitblt screen DC to memory DC
    BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, SRCCOPY);
 
    // select old bitmap back into memory DC and get handle to
    // bitmap of the screen  
    hBitmap = (HBITMAP)  SelectObject(hMemDC, hOldBitmap);
 
    // Copy the bitmap data into the provided BYTE buffer
    GetDIBits(hScrDC, hBitmap, 0, nHeight, pData, pHeader, DIB_RGB_COLORS);
 
    // clean up
    DeleteDC(hScrDC);
    DeleteDC(hMemDC);
 
    // return handle to the bitmap
    return hBitmap;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:

    HDC         hScrDC, hMemDC;         // screen DC and memory DC
    HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
    int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
    int         nWidth, nHeight;        // DIB width and height
    int         xScrn, yScrn;           // screen resolution
 
	
	RECT lpRect;
 
	Sleep(3000);
	HWND hwnd = FindWindow("SciCalc", "Calculator");
	GetWindowRect(hwnd , &lpRect);
	hScrDC = GetDC(hwnd);
	hMemDC = CreateCompatibleDC(hScrDC);
 
 
    nX  = lpRect.left;
    nY  = lpRect.top;
    nX2 = lpRect.right;
    nY2 = lpRect.bottom;
	
    // get screen resolution
    xScrn = GetDeviceCaps(hScrDC, HORZRES);
    yScrn = GetDeviceCaps(hScrDC, VERTRES);
 
    //make sure bitmap rectangle is visible
    if (nX < 0)
        nX = 0;
    if (nY < 0)
        nY = 0;
    if (nX2 > xScrn)
        nX2 = xScrn;
    if (nY2 > yScrn)
        nY2 = yScrn;
 
	nWidth = nX2 - nX;
	nHeight = nY2 - nY;
 
    // create a bitmap compatible with the screen DC
    hBitmap = CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
 
    // select new bitmap into memory DC
    hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
    // bitblt screen DC to memory DC
    //BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, SRCCOPY);
	BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, 0, 0, SRCCOPY);
 
    // select old bitmap back into memory DC and get handle to
    // bitmap of the screen  
    hBitmap = (HBITMAP)  SelectObject(hMemDC, hOldBitmap);
 
 
	Capture(hScrDC, &lpRect, "C:\\res.bmp");

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:

#include <Windows.h>
 
BOOL Capture(HDC, LPRECT, LPCWSTR);
 
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					  LPWSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;
	HDC hDC;
	RECT rect;
 
	hWnd = FindWindow(NULL, L"Calculator");
	if (hWnd != NULL)
	{
		SetForegroundWindow(hWnd);
		GetWindowRect(hWnd , &rect);
		hDC = GetDC(GetDesktopWindow());
 
		if (hDC != NULL)
			Capture(hDC, &rect, L"capture.bmp");
	}
	return 0;
}
 
BOOL Capture(HDC hDC, LPRECT lpRect, LPCWSTR lpszFile)
{
	BITMAPINFO bmi = { 0 };
 
	LPBYTE pBits = NULL;
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = lpRect->right - lpRect->left;
	bmi.bmiHeader.biHeight = lpRect->bottom - lpRect->top;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 32;
	bmi.bmiHeader.biCompression = BI_RGB;
	HBITMAP hBitmap = CreateDIBSection(hDC, &bmi, 
		DIB_RGB_COLORS, (LPVOID*)&pBits, NULL, 0);
 
	HDC hMemDC = CreateCompatibleDC(hDC);
	HGDIOBJ hOld = SelectObject(hMemDC, hBitmap);
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hDC, lpRect->left, lpRect->top, SRCCOPY);
	SelectObject(hMemDC, hOld);
	DeleteDC(hMemDC);
 
	DWORD nImageSize = ((((bmi.bmiHeader.biWidth * 
		bmi.bmiHeader.biBitCount) 
		+ 31) & ~31) >> 3) 
		* bmi.bmiHeader.biHeight;
 
	BITMAPFILEHEADER header = { 0 };
	header.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + 
		(DWORD)sizeof(BITMAPINFOHEADER); 
	header.bfSize = nImageSize + sizeof(BITMAPFILEHEADER) + 
		sizeof(BITMAPINFOHEADER);
	header.bfType = 0x4D42;
 
	HANDLE hFile = CreateFile(lpszFile, GENERIC_WRITE,
		0, NULL, CREATE_ALWAYS, 
		FILE_ATTRIBUTE_NORMAL, NULL);   
 
	if (hFile != INVALID_HANDLE_VALUE) 
	{
		DWORD nWritten = 0;;
		WriteFile(hFile, (LPVOID)&header, 
			sizeof(BITMAPFILEHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)&bmi, 
			sizeof(BITMAPINFOHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)pBits, nImageSize, 
			&nWritten, NULL);
		CloseHandle(hFile);
	}
 
	return TRUE;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:

#include <Windows.h>
 
BOOL Capture(HDC, LPRECT, LPCWSTR);
 
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					  LPWSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;
	HDC hDC;
	RECT rect;
 
	hWnd = FindWindow(NULL, L"Calculator");
	if (hWnd != NULL)
	{
		ShowWindow(hWnd, SW_HIDE);
		ShowWindow(hWnd, SW_SHOW);
		Sleep(100);
		GetWindowRect(hWnd , &rect);
		hDC = GetDC(GetDesktopWindow());
 
		if (hDC != NULL)
			Capture(hDC, &rect, L"capture.bmp");
	}
	return 0;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:

HBITMAP TakeScreen(HDC hDC, LPRECT lpRect)
{
	BITMAPINFO bmi = { 0 };
 
	LPBYTE pBits = NULL;
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = lpRect->right - lpRect->left;
	bmi.bmiHeader.biHeight = lpRect->bottom - lpRect->top;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 32;
	bmi.bmiHeader.biCompression = BI_RGB;
	HBITMAP hBitmap = CreateDIBSection(hDC, &bmi, 
		DIB_RGB_COLORS, (LPVOID*)&pBits, NULL, 0);
 
	HDC hMemDC = CreateCompatibleDC(hDC);
	HGDIOBJ hOld = SelectObject(hMemDC, hBitmap);
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hDC, lpRect->left, lpRect->top, SRCCOPY);
	SelectObject(hMemDC, hOld);
	DeleteDC(hMemDC);
	return hBitmap;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

#include <Windows.h>
 
HBITMAP TakeScreen(HDC hDC, LPRECT lpRect);
 
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					  LPWSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;
	HDC hDC;
	RECT rect;
 
	hWnd = FindWindow(NULL, L"Calculator");
	if (hWnd != NULL)
	{
		SetForegroundWindow(hWnd);
		ShowWindow(hWnd, SW_HIDE);
		ShowWindow(hWnd, SW_SHOWNORMAL);
		Sleep(100);
		GetWindowRect(hWnd , &rect);
		hDC = GetDC(GetDesktopWindow());
		HBITMAP hBmp = TakeScreen(hDC, &rect);
		if (hBmp != NULL) //Delete this HBITMAP only when you don't need it
			::DeleteObject(hBmp);
	}
	return 0;
}
 
HBITMAP TakeScreen(HDC hDC, LPRECT lpRect)
{
	BITMAPINFO bmi = { 0 };
 
	LPBYTE pBits = NULL;
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = lpRect->right - lpRect->left;
	bmi.bmiHeader.biHeight = lpRect->bottom - lpRect->top;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 32;
	bmi.bmiHeader.biCompression = BI_RGB;
	HBITMAP hBitmap = CreateDIBSection(hDC, &bmi, 
		DIB_RGB_COLORS, (LPVOID*)&pBits, NULL, 0);
 
	HDC hMemDC = CreateCompatibleDC(hDC);
	HGDIOBJ hOld = SelectObject(hMemDC, hBitmap);
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hDC, lpRect->left, lpRect->top, SRCCOPY);
	SelectObject(hMemDC, hOld);
	DeleteDC(hMemDC);
	return hBitmap;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:

#include <Windows.h>
 
BOOL TakeScreen(HDC hDC, LPRECT lpRect, HBITMAP& hBitmap, LPBYTE& pByte, DWORD& nImageSize);
 
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					  LPWSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;
	HDC hDC;
	RECT rect;
 
	hWnd = FindWindow(NULL, L"Calculator");
	if (hWnd != NULL)
	{
		SetForegroundWindow(hWnd);
		ShowWindow(hWnd, SW_HIDE);
		ShowWindow(hWnd, SW_SHOWNORMAL);
		Sleep(100);
		GetWindowRect(hWnd , &rect);
		hDC = GetDC(GetDesktopWindow());
		HBITMAP hBmp = NULL;
		LPBYTE pBits = NULL;
		DWORD nSize = 0;
		if (TakeScreen(hDC, &rect, hBmp, pBits, nSize))
		{
			//here is your code that will work with the image
			::DeleteObject(hBmp);
		}
	}
	return 0;
}
 
BOOL TakeScreen(HDC hDC, LPRECT lpRect, HBITMAP& hBitmap, LPBYTE& pBits, DWORD& nImageSize)
{
	BITMAPINFO bmi = { 0 };
 
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = lpRect->right - lpRect->left;
	bmi.bmiHeader.biHeight = lpRect->bottom - lpRect->top;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 32;
	bmi.bmiHeader.biCompression = BI_RGB;
	hBitmap = CreateDIBSection(hDC, &bmi, 
		DIB_RGB_COLORS, (LPVOID*)&pBits, NULL, 0);
 
	if (hBitmap == NULL)
		return FALSE;
 
	HDC hMemDC = CreateCompatibleDC(hDC);
	HGDIOBJ hOld = SelectObject(hMemDC, hBitmap);
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hDC, lpRect->left, lpRect->top, SRCCOPY);
	SelectObject(hMemDC, hOld);
	DeleteDC(hMemDC);
 
	nImageSize = ((((bmi.bmiHeader.biWidth * 
		bmi.bmiHeader.biBitCount) 
		+ 31) & ~31) >> 3) 
		* bmi.bmiHeader.biHeight;
 
	return TRUE;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:

HBITMAP TakeScreen(HDC hDC, LPRECT lpRect, BYTE *pBits, BITMAPINFO *pHeader)
{
	BITMAPINFO bmi = { 0 };
 
	bmi.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	bmi.bmiHeader.biWidth = lpRect->right - lpRect->left;
	bmi.bmiHeader.biHeight = lpRect->bottom - lpRect->top;
	bmi.bmiHeader.biPlanes = 1;
	bmi.bmiHeader.biBitCount = 32;
	bmi.bmiHeader.biCompression = BI_RGB;
	HBITMAP hBitmap = CreateDIBSection(hDC, &bmi, 
		DIB_RGB_COLORS, (LPVOID*)&pBits, NULL, 0);
 
	HDC hMemDC = CreateCompatibleDC(hDC);
	HGDIOBJ hOld = SelectObject(hMemDC, hBitmap);
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hDC, lpRect->left, lpRect->top, SRCCOPY);
	SelectObject(hMemDC, hOld);
 
		DWORD nImageSize = ((((bmi.bmiHeader.biWidth * 
		bmi.bmiHeader.biBitCount) 
		+ 31) & ~31) >> 3) 
		* bmi.bmiHeader.biHeight;
	BITMAPFILEHEADER header = { 0 };
	header.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + 
		(DWORD)sizeof(BITMAPINFOHEADER); 
	header.bfSize = nImageSize + sizeof(BITMAPFILEHEADER) + 
		sizeof(BITMAPINFOHEADER);
	header.bfType = 0x4D42;
 
	GetDIBits(hDC, hBitmap, 0, bmi.bmiHeader.biHeight, pBits, &bmi, DIB_RGB_COLORS);
	DeleteDC(hMemDC);
	return hBitmap;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:

HBITMAP CopyScreenToBitmap(LPRECT lpRect, BYTE *pData, BITMAPINFO *pHeader)
{
    HDC         hScrDC, hMemDC;         // screen DC and memory DC
    HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
    int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
    int         nWidth, nHeight;        // DIB width and height
    int         xScrn, yScrn;           // screen resolution
 
 
 
	HWND hwnd;
	hwnd = FindWindow(NULL, "Calculator");
	GetWindowRect(hwnd , lpRect);
	hScrDC = GetDC(GetDesktopWindow());
	hMemDC = CreateCompatibleDC(hScrDC);
 
	nWidth = lpRect->right - lpRect->left;
	nHeight = lpRect->bottom - lpRect->top;
 
	char tmp[200];
	sprintf(tmp, "Width: %d\r\nHeight: %d\r\n", nWidth, nHeight);
	FILE *f;
	f = fopen("C:\\Res.txt", "a+");
	fwrite(tmp, strlen(tmp), 1, f);
	fclose(f);
 
    // create a bitmap compatible with the screen DC
    hBitmap = CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
 
    // select new bitmap into memory DC
    hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
    // bitblt screen DC to memory DC
    //BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, SRCCOPY);
	BitBlt(hMemDC, 0, 0, lpRect->right - lpRect->left,	lpRect->bottom - lpRect->top, hScrDC, lpRect->left, lpRect->top, SRCCOPY);
 
    // select old bitmap back into memory DC and get handle to
    // bitmap of the screen  
    hBitmap = (HBITMAP)  SelectObject(hMemDC, hOldBitmap);
 
    // Copy the bitmap data into the provided BYTE buffer
    GetDIBits(hScrDC, hBitmap, 0, nHeight, pData, pHeader, DIB_RGB_COLORS);
 
    // clean up
    DeleteDC(hScrDC);
    DeleteDC(hMemDC);
 
    // return handle to the bitmap
    return hBitmap;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:

HBITMAP CopyScreenToBitmap(LPRECT lpRect, BYTE *pData, BITMAPINFO *pHeader)
{
    HDC         hScrDC, hMemDC;         // screen DC and memory DC
    HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
    int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
    int         nWidth, nHeight;        // DIB width and height
    int         xScrn, yScrn;           // screen resolution
 
 
 
	HWND hwnd;
	hwnd = FindWindow(NULL, "Calculator");
	GetWindowRect(hwnd , lpRect);
	hScrDC = GetDC(GetDesktopWindow());
	hMemDC = CreateCompatibleDC(hScrDC);
 
	nWidth = lpRect->right - lpRect->left;
	nHeight = lpRect->bottom - lpRect->top;
 
    // create a bitmap compatible with the screen DC
    hBitmap = CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
 
    // select new bitmap into memory DC
    hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
    // bitblt screen DC to memory DC
    //BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, SRCCOPY);
	BitBlt(hMemDC, 0, 0, lpRect->right - lpRect->left,	lpRect->bottom - lpRect->top, hScrDC, lpRect->left, lpRect->top, SRCCOPY);
	SelectObject(hMemDC, hOldBitmap);
 
    // Copy the bitmap data into the provided BYTE buffer
    GetDIBits(hScrDC, hBitmap, 0, nHeight, pData, pHeader, DIB_RGB_COLORS);
 
    // clean up
    DeleteDC(hScrDC);
    DeleteDC(hMemDC);
 
    // return handle to the bitmap
    return hBitmap;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:

HBITMAP CopyScreenToBitmap(LPRECT lpRect, BYTE *pData, BITMAPINFO *pHeader)
{
    HDC         hScrDC, hMemDC;         // screen DC and memory DC
    HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
    int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
    int         nWidth, nHeight;        // DIB width and height
    int         xScrn, yScrn;           // screen resolution
 
	
	HWND hwnd = FindWindow("SciCalc", "Calculator");
	GetWindowRect(hwnd , lpRect);
	hScrDC = GetDC(GetDesktopWindow());
	hMemDC = CreateCompatibleDC(hScrDC);
 
	nWidth = lpRect->right - lpRect->left;
	nHeight = lpRect->bottom - lpRect->top;
 
    // create a bitmap compatible with the screen DC
    hBitmap = CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
 
    // select new bitmap into memory DC
    hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
    // bitblt screen DC to memory DC
    //BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, SRCCOPY);
	BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, 0, 0, SRCCOPY);
 
    // select old bitmap back into memory DC and get handle to
    // bitmap of the screen  
    hBitmap = (HBITMAP)  SelectObject(hMemDC, hOldBitmap);
 
    // Copy the bitmap data into the provided BYTE buffer
    GetDIBits(hScrDC, hBitmap, 0, nHeight, pData, pHeader, DIB_RGB_COLORS);
 
    // clean up
    DeleteDC(hScrDC);
    DeleteDC(hMemDC);
 
    // return handle to the bitmap
    return hBitmap;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:

HBITMAP CopyScreenToBitmap(LPRECT lpRect, BYTE *pData, BITMAPINFO *pHeader)
{
    HDC         hScrDC, hMemDC;         // screen DC and memory DC
    HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
    int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
    int         nWidth, nHeight;        // DIB width and height
    int         xScrn, yScrn;           // screen resolution
 
	
	HWND hwnd = FindWindow("SciCalc", "Calculator");
	GetWindowRect(hwnd , lpRect);
	hScrDC = GetDC(GetDesktopWindow());
	hMemDC = CreateCompatibleDC(hScrDC);
 
	nWidth = lpRect->right - lpRect->left;
	nHeight = lpRect->bottom - lpRect->top;
	
    // create a bitmap compatible with the screen DC
    hBitmap = CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
 
    // select new bitmap into memory DC
	hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
    // bitblt screen DC to memory DC
    //BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, nX, nY, SRCCOPY);
	//BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, 0, 0, SRCCOPY);
	BitBlt(hMemDC, lpRect->left, lpRect->top, nWidth, nHeight, hScrDC, 0, 0, SRCCOPY);
 
    // select old bitmap back into memory DC and get handle to
    // bitmap of the screen  
    SelectObject(hMemDC, hOldBitmap);
 
    // Copy the bitmap data into the provided BYTE buffer
    GetDIBits(hScrDC, hBitmap, 0, nHeight, pData, pHeader, DIB_RGB_COLORS);
 
    // clean up
    DeleteDC(hScrDC);
    DeleteDC(hMemDC);
 
    // return handle to the bitmap
    return hBitmap;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:

#include <Windows.h>
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect, BYTE*& pData, BITMAPINFO* pHeader);
BOOL Save(LPCWSTR lpszFile, LPBYTE pBits, LPBITMAPINFO pHeader);
 
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					  LPWSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;
	RECT rect;
 
	LPBYTE pData = NULL;
	BITMAPINFO header = { 0 };
	HBITMAP hBitmap = CopyScreenToBitmap(&rect, pData, &header);
	if (hBitmap)
	{
	//	Save(L"cap_screen.bmp", pData, &header);
		::DeleteObject(hBitmap);
	}
	return 0;
}
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect, BYTE*& pData, LPBITMAPINFO pHeader)
{
	HDC         hScrDC, hMemDC;         // screen DC and memory DC
	HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
	int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
	int         nWidth, nHeight;        // DIB width and height
	int         xScrn, yScrn;           // screen resolution
 
 
	HWND hwnd = FindWindow(L"SciCalc", L"Calculator");
	SetForegroundWindow(hwnd);
	ShowWindow(hwnd, SW_HIDE);
	ShowWindow(hwnd, SW_SHOWNORMAL);
	Sleep(100);
	GetWindowRect(hwnd , lpRect);
 
	hScrDC = GetDC(GetDesktopWindow());
	hMemDC = CreateCompatibleDC(hScrDC);
 
	nWidth = lpRect->right - lpRect->left;
	nHeight = lpRect->bottom - lpRect->top;
 
	pHeader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	pHeader->bmiHeader.biWidth = nWidth;
	pHeader->bmiHeader.biHeight = nHeight;
	pHeader->bmiHeader.biPlanes = 1;
	pHeader->bmiHeader.biBitCount = 32;
	pHeader->bmiHeader.biCompression = BI_RGB;
	hBitmap = CreateDIBSection(hScrDC, pHeader, 
		DIB_RGB_COLORS, (LPVOID*)&pData, NULL, 0);
 
	// select new bitmap into memory DC
	hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hScrDC, lpRect->left, lpRect->top, SRCCOPY);
 
	// select old bitmap back into memory DC and get handle to
	// bitmap of the screen  
	SelectObject(hMemDC, hOldBitmap);
 
	// clean up
	DeleteDC(hMemDC);
	ReleaseDC(GetDesktopWindow(), hScrDC);
 
	// return handle to the bitmap
	return hBitmap;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:

#include <Windows.h>
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect, LPBYTE& pData, LPBITMAPINFO pHeader);
BOOL Save(LPCWSTR lpszFile, LPBYTE pBits, LPBITMAPINFO pHeader);
 
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					  LPWSTR lpCmdLine, int nCmdShow)
{
	HWND hWnd;
	RECT rect;
 
	LPBYTE pData = NULL;
	BITMAPINFO header = { 0 };
	HBITMAP hBitmap = CopyScreenToBitmap(&rect, pData, &header);
	if (hBitmap)
	{
		Save(L"cap_screen.bmp", pData, &header);
		::DeleteObject(hBitmap);
	}
	return 0;
}
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect, LPBYTE& pData, LPBITMAPINFO pHeader)
{
	HDC         hScrDC, hMemDC;         // screen DC and memory DC
	HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
	int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
	int         nWidth, nHeight;        // DIB width and height
	int         xScrn, yScrn;           // screen resolution
 
 
	HWND hwnd = FindWindow(L"SciCalc", L"Calculator");
	SetForegroundWindow(hwnd);
	ShowWindow(hwnd, SW_HIDE);
	ShowWindow(hwnd, SW_SHOWNORMAL);
	Sleep(100);
	GetWindowRect(hwnd , lpRect);
 
	hScrDC = GetDC(GetDesktopWindow());
	hMemDC = CreateCompatibleDC(hScrDC);
 
	nWidth = lpRect->right - lpRect->left;
	nHeight = lpRect->bottom - lpRect->top;
 
	pHeader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	pHeader->bmiHeader.biWidth = nWidth;
	pHeader->bmiHeader.biHeight = nHeight;
	pHeader->bmiHeader.biPlanes = 1;
	pHeader->bmiHeader.biBitCount = 32;
	pHeader->bmiHeader.biCompression = BI_RGB;
	hBitmap = CreateDIBSection(hScrDC, pHeader, 
		DIB_RGB_COLORS, (LPVOID*)&pData, NULL, 0);
 
	// select new bitmap into memory DC
	hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hScrDC, lpRect->left, lpRect->top, SRCCOPY);
 
 
	// select old bitmap back into memory DC and get handle to
	// bitmap of the screen  
	SelectObject(hMemDC, hOldBitmap);
	// clean up
	DeleteDC(hMemDC);
 
	ReleaseDC(GetDesktopWindow(), hScrDC);
	// return handle to the bitmap
	return hBitmap;
}
 
BOOL Save(LPCWSTR lpszFile, LPBYTE pBits, LPBITMAPINFO pHeader)
{
	DWORD nImageSize = ((((pHeader->bmiHeader.biWidth * 
		pHeader->bmiHeader.biBitCount) 
		+ 31) & ~31) >> 3) 
		* pHeader->bmiHeader.biHeight;
 
	BITMAPFILEHEADER header = { 0 };
	header.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + 
		(DWORD)sizeof(BITMAPINFOHEADER); 
	header.bfSize = nImageSize + sizeof(BITMAPFILEHEADER) + 
		sizeof(BITMAPINFOHEADER);
	header.bfType = 0x4D42;
 
	HANDLE hFile = CreateFile(lpszFile, GENERIC_WRITE,
		0, NULL, CREATE_ALWAYS, 
		FILE_ATTRIBUTE_NORMAL, NULL);   
 
	if (hFile != INVALID_HANDLE_VALUE) 
	{
		DWORD nWritten = 0;;
		WriteFile(hFile, (LPVOID)&header, 
			sizeof(BITMAPFILEHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)pHeader, 
			sizeof(BITMAPINFOHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)pBits, nImageSize, 
			&nWritten, NULL);
		CloseHandle(hFile);
	}
 
	return TRUE;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:

HBITMAP CopyScreenToBitmap(LPRECT lpRect, BYTE*& pData, LPBITMAPINFO pHeader)
{
	HDC         hScrDC, hMemDC;         // screen DC and memory DC
    HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
    int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
    int         nWidth, nHeight;        // DIB width and height
    int         xScrn, yScrn;           // screen resolution
 
	HWND hwnd = FindWindow("SciCalc", "Calculator");
	GetWindowRect(hwnd , lpRect);
	hScrDC = GetDC(hwnd);
	hMemDC = CreateCompatibleDC(hScrDC);      // get points of re
	
 
    // get points of rectangle to grab
    nX  = lpRect->left;
    nY  = lpRect->top;
    nX2 = lpRect->right;
    nY2 = lpRect->bottom;
	
    // get screen resolution
    xScrn = GetDeviceCaps(hScrDC, HORZRES);
    yScrn = GetDeviceCaps(hScrDC, VERTRES);
 
    //make sure bitmap rectangle is visible
    if (nX < 0)
        nX = 0;
    if (nY < 0)
        nY = 0;
    if (nX2 > xScrn)
        nX2 = xScrn;
    if (nY2 > yScrn)
        nY2 = yScrn;
 
	nWidth = nX2 - nX;
	nHeight = nY2 - nY;
 
    // create a bitmap compatible with the screen DC
    hBitmap = CreateCompatibleBitmap(hScrDC, nWidth, nHeight);
 
    // select new bitmap into memory DC
    hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
    // bitblt screen DC to memory DC
    BitBlt(hMemDC, 0, 0, nWidth, nHeight, hScrDC, 0, 0, SRCCOPY);
 
    // select old bitmap back into memory DC and get handle to
    // bitmap of the screen  
    hBitmap = (HBITMAP)  SelectObject(hMemDC, hOldBitmap);
 
    // Copy the bitmap data into the provided BYTE buffer
    GetDIBits(hScrDC, hBitmap, 0, nHeight, pData, pHeader, DIB_RGB_COLORS);
 
    // clean up
    DeleteDC(hScrDC);
    DeleteDC(hMemDC);
 
    // return handle to the bitmap
    return hBitmap;
 
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:

BOOL SaveMemDCToBitmapNoPalete(LPCSTR lpszFileName, HDC hMemDC,HBITMAP hBitmap)
{
	int   wBitCount = 32;
 
	BITMAP   Bitmap;  
	BITMAPFILEHEADER   bmfHdr;    
	BITMAPINFOHEADER   bi;
 
	GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&Bitmap); 
 
	bi.biSize = sizeof(BITMAPINFOHEADER);    
	bi.biWidth = Bitmap.bmWidth;    
	bi.biHeight = Bitmap.bmHeight;  
	bi.biPlanes = 1;    
	bi.biBitCount = wBitCount;    
	bi.biCompression = BI_RGB;    
	bi.biSizeImage = 0;  
	bi.biXPelsPerMeter = 0;    
	bi.biYPelsPerMeter = 0;    
	bi.biClrUsed = 0;    
	bi.biClrImportant = 0; 
 
	DWORD dwBmBitsSize = ((Bitmap.bmWidth * wBitCount + 31) / 32) * 4 * Bitmap.bmHeight; 
 
	HANDLE hDib = GlobalAlloc(GHND,dwBmBitsSize+sizeof(BITMAPINFOHEADER)); 
	LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDib);    
	*lpbi = bi;
 
	GetDIBits(hMemDC, hBitmap, 0, (UINT)Bitmap.bmHeight,  
		(LPSTR)lpbi + sizeof(BITMAPINFOHEADER), (BITMAPINFO *)lpbi, DIB_RGB_COLORS);    
 
	HANDLE fh = CreateFile(lpszFileName,GENERIC_WRITE,0,NULL,CREATE_ALWAYS,
		FILE_ATTRIBUTE_NORMAL|FILE_FLAG_SEQUENTIAL_SCAN,NULL);   
	ASSERT(fh != INVALID_HANDLE_VALUE);
 
	DWORD dwDIBSize   =   sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dwBmBitsSize;
 
	bmfHdr.bfType = 0x4D42;    
	bmfHdr.bfSize = dwDIBSize;  
	bmfHdr.bfReserved1 = 0;    
	bmfHdr.bfReserved2 = 0;    
	bmfHdr.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + (DWORD)sizeof(BITMAPINFOHEADER);    
 
	DWORD dwWritten;
 
	WriteFile(fh,   (LPSTR)&bmfHdr,   sizeof(BITMAPFILEHEADER),   &dwWritten,   NULL);    
	WriteFile(fh, (LPSTR)lpbi, dwDIBSize, &dwWritten, NULL);    
	GlobalUnlock(hDib);    
	GlobalFree(hDib);    
	CloseHandle(fh);
 
	return TRUE;
 
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:

   // get points of rectangle to grab
    nX  = lpRect->left;
    nY  = lpRect->top;
    nX2 = lpRect->right;
    nY2 = lpRect->bottom;
 
    // get screen resolution
    xScrn = GetDeviceCaps(hScrDC, HORZRES);
    yScrn = GetDeviceCaps(hScrDC, VERTRES);
 
    //make sure bitmap rectangle is visible
    if (nX < 0)
        nX = 0;
    if (nY < 0)
        nY = 0;
    if (nX2 > xScrn)
        nX2 = xScrn;
    if (nY2 > yScrn)
        nY2 = yScrn;

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:

	HWND hwnd = FindWindow(L"SciCalc", L"Calculator");
	SetForegroundWindow(hwnd);
	ShowWindow(hwnd, SW_HIDE);
	ShowWindow(hwnd, SW_SHOWNORMAL);
	SetFocus(hwnd);
	GetWindowRect(hwnd , lpRect);
                                              

1:
2:
3:
4:
5:
6:

#include <Windows.h>
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect, LPBYTE& pData, LPBITMAPINFO pHeader);
BOOL Save(LPCWSTR lpszFile, LPBYTE pBits, LPBITMAPINFO pHeader);
 
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					  LPWSTR lpCmdLine, int nCmdShow)
{
	RECT rect;
 
	LPBYTE pData = NULL;
	BITMAPINFO header = { 0 };
	HBITMAP hBitmap = CopyScreenToBitmap(&rect, pData, &header);
 
	if (hBitmap)
	{
 
		DWORD nImageSize = ((((header.bmiHeader.biWidth * 
			header.bmiHeader.biBitCount) 
			+ 31) & ~31) >> 3) 
			* header.bmiHeader.biHeight;
 
		LPBYTE p = (LPBYTE)malloc(nImageSize);
		memcpy(p, pData, nImageSize);
 
		Save(L"cap_screen.bmp", p, &header);
		::DeleteObject(hBitmap);
 
		free(p);
	}
	return 0;
}
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect, LPBYTE& pData, LPBITMAPINFO pHeader)
{
	HDC         hScrDC, hMemDC;         // screen DC and memory DC
	HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
	int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
	int         nWidth, nHeight;        // DIB width and height
	int         xScrn, yScrn;           // screen resolution
 
 
	HWND hwnd = FindWindow(L"SciCalc", L"Calculator");
	SetForegroundWindow(hwnd);
	GetWindowRect(hwnd , lpRect);
	Sleep(10);
 
	hScrDC = GetDC(GetDesktopWindow());
	hMemDC = CreateCompatibleDC(hScrDC);
 
	nWidth = lpRect->right - lpRect->left;
	nHeight = lpRect->bottom - lpRect->top;
 
	pHeader->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	pHeader->bmiHeader.biWidth = nWidth;
	pHeader->bmiHeader.biHeight = nHeight;
	pHeader->bmiHeader.biPlanes = 1;
	pHeader->bmiHeader.biBitCount = 32;
	pHeader->bmiHeader.biCompression = BI_RGB;
	hBitmap = CreateDIBSection(hScrDC, pHeader, 
		DIB_RGB_COLORS, (LPVOID*)&pData, NULL, 0);
 
	// select new bitmap into memory DC
	hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hScrDC, lpRect->left, lpRect->top, SRCCOPY);
 
 
	// select old bitmap back into memory DC and get handle to
	// bitmap of the screen  
	SelectObject(hMemDC, hOldBitmap);
	// clean up
	DeleteDC(hMemDC);
 
	ReleaseDC(GetDesktopWindow(), hScrDC);
	// return handle to the bitmap
	return hBitmap;
}
 
 
BOOL Save(LPCWSTR lpszFile, LPBYTE pBits, LPBITMAPINFO pHeader)
{
	DWORD nImageSize = ((((pHeader->bmiHeader.biWidth * 
		pHeader->bmiHeader.biBitCount) 
		+ 31) & ~31) >> 3) 
		* pHeader->bmiHeader.biHeight;
 
	BITMAPFILEHEADER header = { 0 };
	header.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + 
		(DWORD)sizeof(BITMAPINFOHEADER); 
	header.bfSize = nImageSize + sizeof(BITMAPFILEHEADER) + 
		sizeof(BITMAPINFOHEADER);
	header.bfType = 0x4D42;
 
	HANDLE hFile = CreateFile(lpszFile, GENERIC_WRITE,
		0, NULL, CREATE_ALWAYS, 
		FILE_ATTRIBUTE_NORMAL, NULL);   
 
	if (hFile != INVALID_HANDLE_VALUE) 
	{
		DWORD nWritten = 0;;
		WriteFile(hFile, (LPVOID)&header, 
			sizeof(BITMAPFILEHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)pHeader, 
			sizeof(BITMAPINFOHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)pBits, nImageSize, 
			&nWritten, NULL);
		CloseHandle(hFile);
	}
 
	return TRUE;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:

#include <Windows.h>
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect);
BOOL Save(LPCWSTR lpszFile, LPBYTE pBits, LPBITMAPINFO pHeader);
 
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					  LPWSTR lpCmdLine, int nCmdShow)
{
	RECT rect;
 
	HBITMAP hBitmap = CopyScreenToBitmap(&rect);
 
	if (hBitmap)
	{
 
		BITMAP bitmap = { 0 };
		GetObject(hBitmap, sizeof(BITMAP), &bitmap);
		DWORD nImageSize = bitmap.bmWidthBytes * bitmap.bmHeight;
		HDC hDC = GetDC(GetDesktopWindow());
 
		DWORD dwBmBitsSize = ((bitmap.bmWidth * 32 + 31) / 32) * 4 * bitmap.bmHeight; 
 
		HANDLE hDib = GlobalAlloc(GHND,dwBmBitsSize+sizeof(BITMAPINFOHEADER)); 
		LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDib);    
		BITMAPINFOHEADER header = { 0 };
		header.biSize = sizeof(BITMAPINFOHEADER);
		header.biWidth = bitmap.bmWidth;
		header.biHeight = bitmap.bmHeight;
		header.biPlanes = 1;
		header.biBitCount = 32;
		header.biCompression = BI_RGB;
		*lpbi = header;
 
		GetDIBits(hDC, hBitmap, 0, (UINT)bitmap.bmHeight,  
			(LPSTR)lpbi + sizeof(BITMAPINFOHEADER), (BITMAPINFO *)lpbi, 
			DIB_RGB_COLORS);    
 
		ReleaseDC(GetDesktopWindow(), hDC);
		Save(L"cap_screen.bmp", (LPBYTE)lpbi + sizeof(BITMAPINFOHEADER), (BITMAPINFO *)lpbi);
		GlobalUnlock(hDib);    
		GlobalFree(hDib);    
		::DeleteObject(hBitmap);
	}
	return 0;
}
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect)
{
	HDC         hScrDC, hMemDC;         // screen DC and memory DC
	HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
	int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
	int         nWidth, nHeight;        // DIB width and height
	int         xScrn, yScrn;           // screen resolution
 
 
	HWND hwnd = FindWindow(L"SciCalc", L"Calculator");
	SetForegroundWindow(hwnd);
	GetWindowRect(hwnd , lpRect);
	Sleep(10);
 
	hScrDC = GetDC(GetDesktopWindow());
	hMemDC = CreateCompatibleDC(hScrDC);
 
	nWidth = lpRect->right - lpRect->left;
	nHeight = lpRect->bottom - lpRect->top;
 
	BITMAPINFO header = { 0 };
	LPVOID pData = NULL;
	header.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	header.bmiHeader.biWidth = nWidth;
	header.bmiHeader.biHeight = nHeight;
	header.bmiHeader.biPlanes = 1;
	header.bmiHeader.biBitCount = 32;
	header.bmiHeader.biCompression = BI_RGB;
	hBitmap = CreateDIBSection(hScrDC, &header, 
		DIB_RGB_COLORS, (LPVOID*)&pData, NULL, 0);
 
	// select new bitmap into memory DC
	hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hScrDC, lpRect->left, lpRect->top, SRCCOPY);
 
 
	// select old bitmap back into memory DC and get handle to
	// bitmap of the screen  
	SelectObject(hMemDC, hOldBitmap);
	// clean up
	DeleteDC(hMemDC);
 
	ReleaseDC(GetDesktopWindow(), hScrDC);
	// return handle to the bitmap
	return hBitmap;
}
 
 
BOOL Save(LPCWSTR lpszFile, LPBYTE pBits, LPBITMAPINFO pHeader)
{
	DWORD nImageSize = ((((pHeader->bmiHeader.biWidth * 
		pHeader->bmiHeader.biBitCount) 
		+ 31) & ~31) >> 3) 
		* pHeader->bmiHeader.biHeight;
 
	BITMAPFILEHEADER header = { 0 };
	header.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + 
		(DWORD)sizeof(BITMAPINFOHEADER); 
	header.bfSize = nImageSize + sizeof(BITMAPFILEHEADER) + 
		sizeof(BITMAPINFOHEADER);
	header.bfType = 0x4D42;
 
	HANDLE hFile = CreateFile(lpszFile, GENERIC_WRITE,
		0, NULL, CREATE_ALWAYS, 
		FILE_ATTRIBUTE_NORMAL, NULL);   
 
	if (hFile != INVALID_HANDLE_VALUE) 
	{
		DWORD nWritten = 0;;
		WriteFile(hFile, (LPVOID)&header, 
			sizeof(BITMAPFILEHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)pHeader, 
			sizeof(BITMAPINFOHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)pBits, nImageSize, 
			&nWritten, NULL);
		CloseHandle(hFile);
	}
 
	return TRUE;
}
                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:

HBITMAP Stretch(HBITMAP hBitmap, LPRECT lpRect)
{
	HDC hDC = GetDC(NULL);
	HDC hMemDC1 = CreateCompatibleDC(hDC);
	HBITMAP hBitmap1 = CreateCompatibleBitmap(hDC,
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top);
	HGDIOBJ hOld1 = SelectObject(hMemDC1, hBitmap1);
 
	HDC hMemDC2 = CreateCompatibleDC(hDC);
	HGDIOBJ hOld2 = SelectObject(hMemDC2, hBitmap);
 
	BITMAP bitmap = { 0 };
	GetObject(hBitmap, sizeof(BITMAP), &bitmap);
	StretchBlt(hMemDC1, 0, 0, lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top, hMemDC2, 0, 0, 
		bitmap.bmWidth, bitmap.bmHeight, SRCCOPY);
 
	SelectObject(hMemDC1, hOld1);
	SelectObject(hMemDC2, hOld2);
	DeleteDC(hMemDC1);
	DeleteDC(hMemDC2);
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:

HBITMAP Stretch(HBITMAP hBitmap, LPRECT lpRect)
{
	HDC hDC = GetDC(NULL);
	HDC hMemDC1 = CreateCompatibleDC(hDC);
	HBITMAP hBitmap1 = CreateCompatibleBitmap(hDC,
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top);
	HGDIOBJ hOld1 = SelectObject(hMemDC1, hBitmap1);
 
	HDC hMemDC2 = CreateCompatibleDC(hDC);
	HGDIOBJ hOld2 = SelectObject(hMemDC2, hBitmap);
 
	BITMAP bitmap = { 0 };
	GetObject(hBitmap, sizeof(BITMAP), &bitmap);
	StretchBlt(hMemDC1, 0, 0, lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top, hMemDC2, 0, 0, 
		bitmap.bmWidth, bitmap.bmHeight, SRCCOPY);
 
	SelectObject(hMemDC1, hOld1);
	SelectObject(hMemDC2, hOld2);
	DeleteDC(hMemDC1);
	DeleteDC(hMemDC2);
	return hBitmap1;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:

#include <Windows.h>
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect);
BOOL Save(LPCWSTR lpszFile, LPBYTE pBits, LPBITMAPINFO pHeader);
HBITMAP Stretch(HBITMAP hBitmap, LPRECT lpRect);
 
int APIENTRY wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, 
					  LPWSTR lpCmdLine, int nCmdShow)
{
	RECT rect;
 
	HBITMAP hBitmap = CopyScreenToBitmap(&rect);
 
	if (hBitmap)
	{
		RECT rect = { 0, 0, 320, 240 };
		HBITMAP hb1 = Stretch(hBitmap, &rect);
		DeleteObject(hBitmap);
		hBitmap = hb1;
 
		BITMAP bitmap = { 0 };
		GetObject(hBitmap, sizeof(BITMAP), &bitmap);
		DWORD nImageSize = bitmap.bmWidthBytes * bitmap.bmHeight;
		HDC hDC = GetDC(GetDesktopWindow());
 
		DWORD dwBmBitsSize = ((bitmap.bmWidth * 32 + 31) / 32) * 4 * bitmap.bmHeight; 
 
		HANDLE hDib = GlobalAlloc(GHND,dwBmBitsSize+sizeof(BITMAPINFOHEADER)); 
		LPBITMAPINFOHEADER lpbi = (LPBITMAPINFOHEADER)GlobalLock(hDib);    
		BITMAPINFOHEADER header = { 0 };
		header.biSize = sizeof(BITMAPINFOHEADER);
		header.biWidth = bitmap.bmWidth;
		header.biHeight = bitmap.bmHeight;
		header.biPlanes = 1;
		header.biBitCount = 32;
		header.biCompression = BI_RGB;
		*lpbi = header;
 
		GetDIBits(hDC, hBitmap, 0, (UINT)bitmap.bmHeight,  
			(LPSTR)lpbi + sizeof(BITMAPINFOHEADER), (BITMAPINFO *)lpbi, 
			DIB_RGB_COLORS);    
 
		ReleaseDC(GetDesktopWindow(), hDC);
		Save(L"cap_screen.bmp", (LPBYTE)lpbi + sizeof(BITMAPINFOHEADER), (BITMAPINFO *)lpbi);
		GlobalUnlock(hDib);    
		GlobalFree(hDib);    
		::DeleteObject(hBitmap);
	}
	return 0;
}
 
HBITMAP CopyScreenToBitmap(LPRECT lpRect)
{
	HDC         hScrDC, hMemDC;         // screen DC and memory DC
	HBITMAP     hBitmap, hOldBitmap;    // handles to deice-dependent bitmaps
	int         nX, nY, nX2, nY2;       // coordinates of rectangle to grab
	int         nWidth, nHeight;        // DIB width and height
	int         xScrn, yScrn;           // screen resolution
 
 
	HWND hwnd = FindWindow(L"SciCalc", L"Calculator");
	SetForegroundWindow(hwnd);
	GetWindowRect(hwnd , lpRect);
	Sleep(10);
 
	hScrDC = GetDC(GetDesktopWindow());
	hMemDC = CreateCompatibleDC(hScrDC);
 
	nWidth = lpRect->right - lpRect->left;
	nHeight = lpRect->bottom - lpRect->top;
 
	BITMAPINFO header = { 0 };
	LPVOID pData = NULL;
	header.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	header.bmiHeader.biWidth = nWidth;
	header.bmiHeader.biHeight = nHeight;
	header.bmiHeader.biPlanes = 1;
	header.bmiHeader.biBitCount = 32;
	header.bmiHeader.biCompression = BI_RGB;
	hBitmap = CreateDIBSection(hScrDC, &header, 
		DIB_RGB_COLORS, (LPVOID*)&pData, NULL, 0);
 
	// select new bitmap into memory DC
	hOldBitmap = (HBITMAP) SelectObject(hMemDC, hBitmap);
 
	BitBlt(hMemDC, 0, 0, 
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top,
		hScrDC, lpRect->left, lpRect->top, SRCCOPY);
 
 
	// select old bitmap back into memory DC and get handle to
	// bitmap of the screen  
	SelectObject(hMemDC, hOldBitmap);
	// clean up
	DeleteDC(hMemDC);
 
	ReleaseDC(GetDesktopWindow(), hScrDC);
	// return handle to the bitmap
	return hBitmap;
}
 
 
BOOL Save(LPCWSTR lpszFile, LPBYTE pBits, LPBITMAPINFO pHeader)
{
	DWORD nImageSize = ((((pHeader->bmiHeader.biWidth * 
		pHeader->bmiHeader.biBitCount) 
		+ 31) & ~31) >> 3) 
		* pHeader->bmiHeader.biHeight;
 
	BITMAPFILEHEADER header = { 0 };
	header.bfOffBits = (DWORD)sizeof(BITMAPFILEHEADER) + 
		(DWORD)sizeof(BITMAPINFOHEADER); 
	header.bfSize = nImageSize + sizeof(BITMAPFILEHEADER) + 
		sizeof(BITMAPINFOHEADER);
	header.bfType = 0x4D42;
 
	HANDLE hFile = CreateFile(lpszFile, GENERIC_WRITE,
		0, NULL, CREATE_ALWAYS, 
		FILE_ATTRIBUTE_NORMAL, NULL);   
 
	if (hFile != INVALID_HANDLE_VALUE) 
	{
		DWORD nWritten = 0;;
		WriteFile(hFile, (LPVOID)&header, 
			sizeof(BITMAPFILEHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)pHeader, 
			sizeof(BITMAPINFOHEADER), 
			&nWritten, NULL);
		WriteFile(hFile, (LPVOID)pBits, nImageSize, 
			&nWritten, NULL);
		CloseHandle(hFile);
	}
 
	return TRUE;
}
 
HBITMAP Stretch(HBITMAP hBitmap, LPRECT lpRect)
{
	HDC hDC = GetDC(NULL);
	HDC hMemDC1 = CreateCompatibleDC(hDC);
	HBITMAP hBitmap1 = CreateCompatibleBitmap(hDC,
		lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top);
	HGDIOBJ hOld1 = SelectObject(hMemDC1, hBitmap1);
 
	HDC hMemDC2 = CreateCompatibleDC(hDC);
	HGDIOBJ hOld2 = SelectObject(hMemDC2, hBitmap);
 
	BITMAP bitmap = { 0 };
	GetObject(hBitmap, sizeof(BITMAP), &bitmap);
	StretchBlt(hMemDC1, 0, 0, lpRect->right - lpRect->left,
		lpRect->bottom - lpRect->top, hMemDC2, 0, 0, 
		bitmap.bmWidth, bitmap.bmHeight, SRCCOPY);
 
	SelectObject(hMemDC1, hOld1);
	SelectObject(hMemDC2, hOld2);
	DeleteDC(hMemDC1);
	DeleteDC(hMemDC2);
	return hBitmap1;
}

                                              

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:

	HWND hwnd = FindWindow("SciCalc", "Calculator");
	SetForegroundWindow(hwnd);
	GetWindowRect(hwnd , lpRect);
	Sleep(10);
                                              

1:
2:
3:
4: