[C] Print screen finestra attiva

[Spike79]

Torno a rompere le scatole con un'altra domanda sul C (non MFC).
C'è un modo per fare un "print screen" dell'attuale finestra attiva e salvare una bmp o una jpg in un percorso definito ?
Grazie e scusate per l'ennesima domanda.

Ho trovato questo codice:

void CaptureScreen(HWND hwnd)
{
    int nScreenWidth = GetSystemMetrics(SM_CXSCREEN);
    int nScreenHeight = GetSystemMetrics(SM_CYSCREEN);
    //HWND hDesktopWnd = GetDesktopWindow();
    HDC hDC = GetDC(hwnd);
    HDC hCaptureDC = CreateCompatibleDC(hDC);
    HBITMAP hCaptureBitmap =CreateCompatibleBitmap(hDC, 
                            nScreenWidth, nScreenHeight);
    SelectObject(hCaptureDC,hCaptureBitmap); 
    BitBlt(hCaptureDC,0,0,nScreenWidth,nScreenHeight,
           hDC,0,0, SRCCOPY); 
    SaveCapturedBitmap(hCaptureBitmap); //Place holder - Put your code
                                //here to save the captured image to disk
    ReleaseDC(hwnd,hDC);
    DeleteDC(hCaptureDC);
    DeleteObject(hCaptureBitmap);
}

Ma non so cosa mettere al posto di "SaveCapturedBitmap" per far fisicamente scrivere il file...

[Spike79]

Ho risolto!
Se a qualcuno interessa, posso postare il codice.

[cimi88]

posto se riesci..sono curioso in quanto io sono riuscito a salvare l'immagine dell'intero schermo ma non di una singola finestra

[Spike79]

Premettendo che di C non ne conosco molto quindi le mie soluzioni sono un pò "grezze"...ecco come ho risolto:

void CaptureScreen(HWND hwnd)
{

    int nScreenWidth = GetSystemMetrics(SM_CXSCREEN);
    int nScreenHeight = GetSystemMetrics(SM_CYSCREEN);
    HWND hDesktopWnd = GetDesktopWindow();
    HDC hDesktopDC = GetDC(hwnd);
    HDC hCaptureDC = CreateCompatibleDC(hDesktopDC);

    HBITMAP hCaptureBitmap; 

	larghezza = ( r.right - r.left );
	altezza = ( r.bottom - r.top );
		
	hCaptureBitmap = CreateCompatibleBitmap(hDesktopDC, 
                            larghezza, altezza);

    SelectObject(hCaptureDC,hCaptureBitmap); 

	BitBlt(hCaptureDC,0,0,larghezza,altezza,
           hDesktopDC,0,0 ,SRCCOPY); 
    
	//Save the captured image to disk
	WriteBMPFile(hCaptureBitmap,path_salvataggio, hCaptureDC);

    ReleaseDC(hwnd,hDesktopDC);
    DeleteDC(hCaptureDC);
    DeleteObject(hCaptureBitmap);
}

Dove:

RECT r;
int larghezza = 0;
int altezza = 0;

GetWindowRect(GetActiveWindow(), &r);

Altrimenti catturava anche a me una finestra di dimensioni dello schermo (ovviamente , visto i parametri di BitBlt).

[71104]

non è che così ci aiuti molto... praticamente hai solo cambiato nome al placeholder

[Spike79]

Originariamente inviato da 71104

non è che così ci aiuti molto... praticamente hai solo cambiato nome al placeholder

Ah, beh, pensavo che fosse solo un problema di dimensionamento dell'immagine....cmq ecco la funzione di salvataggio....(ocio che una BMP a 1280x1024 viene fuori di 5mb).

void WriteBMPFile(HBITMAP bitmap, LPTSTR filename, HDC hDC)
{
	BITMAP bmp;
	PBITMAPINFO pbmi;
	WORD cClrBits;
	HANDLE hf; // file handle
	BITMAPFILEHEADER hdr; // bitmap file-header
	PBITMAPINFOHEADER pbih; // bitmap info-header
	LPBYTE lpBits; // memory pointer
	DWORD dwTotal; // total count of bytes
	DWORD cb; // incremental count of bytes
	BYTE *hp; // byte pointer
	DWORD dwTmp;

	// create the bitmapinfo header information
	if (!GetObject( bitmap, sizeof(BITMAP), (LPSTR)&bmp) )
	{
		//AfxMessageBox("Could not retrieve bitmap info");
		return;
	}

	// Convert the color format to a count of bits.
	cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel);
	if (cClrBits == 1)
	cClrBits = 1;
	else if (cClrBits <= 4)
	cClrBits = 4;
	else if (cClrBits <= 8)
	cClrBits = 8;
	else if (cClrBits <= 16)
	cClrBits = 16;
	else if (cClrBits <= 24)
	cClrBits = 24;
	else cClrBits = 32;
	// Allocate memory for the BITMAPINFO structure.
	if (cClrBits != 24)
		pbmi = (PBITMAPINFO) LocalAlloc(LPTR,
		sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (1<< cClrBits));
	else
		pbmi = (PBITMAPINFO) LocalAlloc(LPTR, sizeof(BITMAPINFOHEADER));

	// Initialize the fields in the BITMAPINFO structure.
	pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
	pbmi->bmiHeader.biWidth = bmp.bmWidth;
	pbmi->bmiHeader.biHeight = bmp.bmHeight;
	pbmi->bmiHeader.biPlanes = bmp.bmPlanes;
	pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel;

	if (cClrBits < 24)
		pbmi->bmiHeader.biClrUsed = (1<<cClrBits);

	// If the bitmap is not compressed, set the BI_RGB flag.
	pbmi->bmiHeader.biCompression = BI_RGB;

	// Compute the number of bytes in the array of color
	// indices and store the result in biSizeImage.
	pbmi->bmiHeader.biSizeImage = (pbmi->bmiHeader.biWidth + 7) /8 * pbmi->bmiHeader.biHeight * cClrBits;

	// Set biClrImportant to 0, indicating that all of the
	// device colors are important.
	pbmi->bmiHeader.biClrImportant = 0;

	// now open file and save the data
	pbih = (PBITMAPINFOHEADER) pbmi;
	lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);

	if (!lpBits) 
	{
		//AfxMessageBox("writeBMP::Could not allocate memory");
		return;
	}

	// Retrieve the color table (RGBQUAD array) and the bits
	if (!GetDIBits(hDC, bitmap, 0, (WORD) pbih->biHeight, lpBits, pbmi,DIB_RGB_COLORS)) 
	{
		//AfxMessageBox("writeBMP::GetDIB error");
		return;
	}

	// Create the .BMP file.
	hf = CreateFile(filename, GENERIC_READ | GENERIC_WRITE, (DWORD) 0,	NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL,	(HANDLE) NULL);
	
	if (hf == INVALID_HANDLE_VALUE)
	{
		//AfxMessageBox("Could not create file for writing");
		return;
	}

	hdr.bfType = 0x4d42; // 0x42 = "B" 0x4d = "M"
	// Compute the size of the entire file.
	hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) +	pbih->biSize + pbih->biClrUsed	* sizeof(RGBQUAD) + pbih->biSizeImage);
	hdr.bfReserved1 = 0;
	hdr.bfReserved2 = 0;

	// Compute the offset to the array of color indices.
	hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) +	pbih->biSize + pbih->biClrUsed	* sizeof (RGBQUAD);

	// Copy the BITMAPFILEHEADER into the .BMP file.
	if (!WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER),	(LPDWORD) &dwTmp, NULL)) 
	{
		//AfxMessageBox("Could not write in to file");
		return;
	}

	// Copy the BITMAPINFOHEADER and RGBQUAD array into the file.
	if (!WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER)	+ pbih->biClrUsed * sizeof (RGBQUAD),	(LPDWORD) &dwTmp, ( NULL)))
	{
		//AfxMessageBox("Could not write in to file");
		return;
	}

	// Copy the array of color indices into the .BMP file.
	dwTotal = cb = pbih->biSizeImage;
	hp = lpBits;

	if (!WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &dwTmp,NULL))
	{
		//AfxMessageBox("Could not write in to file");
		return;
	}
	// Close the .BMP file.
	if (!CloseHandle(hf))
	{
		//AfxMessageBox("Could not close file");
		return;
	}

	// Free memory.
	GlobalFree((HGLOBAL)lpBits);
}

[71104]

ammazza che bel codice, ci sono almeno una dozzina di return senza GlobalFree ne' CloseHandle

[Spike79]

Originariamente inviato da 71104

ammazza che bel codice, ci sono almeno una dozzina di return senza GlobalFree ne' CloseHandle

Ah guarda, non so neanche di cosa tu stia parlando...l'ho trovato dopo estenuanti ricerche online visto che non sapevo come salvarmi una bmp che la funzione prima s'era allocata.