impression d'ecran en dev c++

**Haldres** · 28/07/2005, 10h44

je cherche a faire une capture d'ecran d'une fenetre gaphique active et de l'enregistrer dans un bitmap ou autre format, je suis pas sectaire, pour but de l'imprimer ensuite si quelqu'un a un bout de fonction ou de librairie me permettant de le faire je suis preneur.

j'ai passer deux jours a chercher sur le forum comment faire et je n'ai pas reussi a trouver! si la solution est deja expliquer rediriger moi silvousplait!

**LordBob** · 30/07/2005, 00h57

voila une source qui te permettra de faire une capture d'�cran:

screen_shot.cpp:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
// header
#include "screen_shot.h"
 
// Initialisation des données
Snapshot::Snapshot(void)
{
	m_pBitmapInfoHeader = NULL;
	m_pBitmapInfo = NULL;
	m_pBitmapData = NULL;
 
	m_hDcBitmap = NULL;
	m_hBitmap = NULL;
}
 
// Destructeur de class
Snapshot::~Snapshot(void)
{
	// Effacer les variables dynamiques
	delete[] m_pBitmapInfo;
	delete[] m_pBitmapData;
 
	// Free memory.
	DeleteDC(m_hDcBitmap);
	DeleteObject(m_hBitmap);
}
 
// Prise Capture du bureau
bool Snapshot::TakeDesktopSnapshot(void)
{
	// Récupération du HWND et du HDC du bureau
	HWND hWndWindow = GetDesktopWindow();
	HDC hDcWindow = GetWindowDC(hWndWindow);
 
	// On récupére les dimensions du bureau
	int ScreenX = GetDeviceCaps(hDcWindow, HORZRES);
	int ScreenY = GetDeviceCaps(hDcWindow, VERTRES);
 
	// Création d'un contexte mémoire
	m_hDcBitmap = CreateCompatibleDC(hDcWindow);
	if(!m_hDcBitmap) return 0;
 
	// On crée un bitmap en mémoire ayant les dimensions du bureau
	HBITMAP hBitmap = CreateCompatibleBitmap(hDcWindow, ScreenX, ScreenY);
	if(!hBitmap) return 0;
 
	m_hBitmap = hBitmap;
 
	// On sélectionne ce bitmap dans le contexte mémoire
	if(!SelectObject(m_hDcBitmap, hBitmap)) return 0;
 
	// On effectue une copie du contexte écran vers le contexte mémoire
	if(!BitBlt(m_hDcBitmap, 0, 0, ScreenX, ScreenY, hDcWindow, 0, 0, SRCCOPY)) return 0;
 
	// Maintenant on crée la structure BITMAPINFO
	BITMAP Bitmap;  
    WORD    Couleur; 
 
    // Récupération de la structure BITMAP
    if (!GetObject(hBitmap, sizeof(BITMAP), (LPSTR)&Bitmap)) return 0;
 
    // Convertie le format de couleur 
    Couleur = (WORD)(Bitmap.bmPlanes * Bitmap.bmBitsPixel); 
    if (Couleur == 1) 
        Couleur = 1; 
    else if (Couleur <= 4) 
        Couleur = 4; 
    else if (Couleur <= 8) 
        Couleur = 8; 
    else if (Couleur <= 16) 
        Couleur = 16; 
    else if (Couleur <= 24) 
        Couleur = 24; 
    else Couleur = 32; 
 
	// Alloue de la memoire pour la structure BITMAPINFO (Cette structure 
	// contient une structure BITMAPINFOHEADER et un tableau de RGBQUAD
    if (Couleur != 24) 
		m_pBitmapInfo = (PBITMAPINFO) new BYTE[sizeof(BITMAPINFOHEADER) + sizeof(RGBQUAD) * (1<< Couleur)]; 
 
    // Il n'y a pas de tableau de RGBQUAD pour le format 24 bit
 
    else 
		m_pBitmapInfo = (PBITMAPINFO) new BYTE[sizeof(BITMAPINFOHEADER)];
 
	if(!m_pBitmapInfo) return 0;
 
    // Initialise la structure BITMAPINFO
 
    m_pBitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 
    m_pBitmapInfo->bmiHeader.biWidth = Bitmap.bmWidth; 
    m_pBitmapInfo->bmiHeader.biHeight = Bitmap.bmHeight; 
    m_pBitmapInfo->bmiHeader.biPlanes = Bitmap.bmPlanes; 
    m_pBitmapInfo->bmiHeader.biBitCount = Bitmap.bmBitsPixel; 
	if (Couleur < 24) 
		m_pBitmapInfo->bmiHeader.biClrUsed = (1<<Couleur); 
 
    // If the bitmap is not compressed, set the BI_RGB flag. 
    m_pBitmapInfo->bmiHeader.biCompression = BI_RGB; 
    m_pBitmapInfo->bmiHeader.biSizeImage = ((m_pBitmapInfo->bmiHeader.biWidth * Couleur +31) & ~31) /8 * m_pBitmapInfo->bmiHeader.biHeight; 
 
    // Set biClrImportant to 0, indicating that all of the 
    // device colors are important. 
    m_pBitmapInfo->bmiHeader.biClrImportant = 0;
 
	//initialise le reste des structures... 
 
	m_pBitmapInfoHeader = (PBITMAPINFOHEADER) m_pBitmapInfo; 
 
	m_pBitmapData = new BYTE[m_pBitmapInfoHeader->biSizeImage];
    if (!m_pBitmapData) return 0; 
 
    // Retrieve the color table (RGBQUAD array) and the bits 
    // (array of palette indices) from the DIB. 
    if (!GetDIBits(m_hDcBitmap, hBitmap, 0, (WORD) m_pBitmapInfoHeader->biHeight, m_pBitmapData, m_pBitmapInfo, DIB_RGB_COLORS)) return 0;
 
	m_BitmapFileHeader.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M" 
 
    // Compute the size of the entire file. 
    m_BitmapFileHeader.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + m_pBitmapInfoHeader->biSize + m_pBitmapInfoHeader->biClrUsed * sizeof(RGBQUAD) + m_pBitmapInfoHeader->biSizeImage); 
    m_BitmapFileHeader.bfReserved1 = 0; 
    m_BitmapFileHeader.bfReserved2 = 0; 
 
    // Compute the offset to the array of color indices. 
    m_BitmapFileHeader.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + m_pBitmapInfoHeader->biSize + m_pBitmapInfoHeader->biClrUsed * sizeof (RGBQUAD); 
 
	return 1;
}
 
// Sauvegarde de la capture dans un fichier
bool Snapshot::SaveToFile(const char* Path)
{
	HANDLE hFichier;
    DWORD dwTmp; 
 
    // Create the .BMP file. 
	hFichier = CreateFile(Path, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL); 
    if (hFichier == INVALID_HANDLE_VALUE) return 0;
 
    // Copy the BITMAPFILEHEADER into the .BMP file. 
    if (!WriteFile(hFichier, &m_BitmapFileHeader, sizeof(BITMAPFILEHEADER), &dwTmp,  NULL)) return 0;
 
    // Copy the BITMAPINFOHEADER and RGBQUAD array into the file. 
    if (!WriteFile(hFichier, m_pBitmapInfoHeader, sizeof(BITMAPINFOHEADER) + m_pBitmapInfoHeader->biClrUsed * sizeof (RGBQUAD), &dwTmp, NULL)) return 0; 
 
    // Copy the array of color indices into the .BMP file. 
    if (!WriteFile(hFichier, (LPSTR) m_pBitmapData, (int) m_pBitmapInfoHeader->biSizeImage, &dwTmp, NULL)) return 0; 
 
    // Close the .BMP file. 
    if (!CloseHandle(hFichier)) return 0; 
 
	return 1;
 
}
 
bool Snapshot::SaveToHDC(HDC &hDc)
{
	// Création d'un contexte mémoire
	hDc = CreateCompatibleDC(m_hDcBitmap);
	if(!hDc) return 0;
 
	// On crée un bitmap en mémoire ayant les dimensions du bureau
	HBITMAP hBitmap = CreateCompatibleBitmap(m_hDcBitmap, GetWidth(), GetHeight());
	if(!hBitmap) return 0;
 
	// On sélectionne ce bitmap dans le contexte mémoire
	if(!SelectObject((HDC)hDc, hBitmap)) return 0;
 
	if(!BitBlt((HDC)hDc, 0, 0, GetWidth(), GetHeight(), m_hDcBitmap, 0, 0, SRCCOPY)) return 0;
 
	return 1;
}
 
// longueur capture
int Snapshot::GetWidth()
{
	return m_pBitmapInfo->bmiHeader.biWidth;
}
 
// largeur capture
int Snapshot::GetHeight()
{
	return m_pBitmapInfo->bmiHeader.biHeight;
}

screen_shot.h:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

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
// header
#include <windows.h>
 
#ifndef __CCAPTURE_H_INCLUDED__
#define __CCAPTURE_H_INCLUDED__
 
// définition de la class
class Snapshot
{
	public:
		Snapshot(void);
		~Snapshot(void);
 
		BITMAPFILEHEADER m_BitmapFileHeader;	// Données de la structure BITMAPFILEHEADER du Bitmap
		PBITMAPINFOHEADER m_pBitmapInfoHeader;	// Pointeur sur la structure BITMAPINFOHEADER du Bitmap
		PBITMAPINFO m_pBitmapInfo;	// Pointeur sur la structure BITMAPINFO du Bitmap
		LPBYTE m_pBitmapData;	// Pointeur sur les Data du Bitmap
 
		HDC m_hDcBitmap;	// Handle sur le hDc du Bitmap en memoire
		HBITMAP m_hBitmap;	// Handle sur le Bitmap
 
		bool TakeDesktopSnapshot(void);		// Prend un ScreenShot du bureau, return false si échec
		bool SaveToFile(const char* Path);	// Save le fichier dans un répertoire, return false si échec
		bool SaveToHDC(HDC &hDc);	// Remplie le hDc avec le handle du bitmap, return false si échec
 
		int GetWidth();
		int GetHeight();
};
 
#endif

utilisation:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
g_capture.TakeDesktopSnapshot();
g_capture.SaveToFile("c:\\fichier.bmp");

**Haldres** · 30/07/2005, 14h03

Merci bien pour ce boooooooooooooo code qui je l'esp�re va me permetre de faire avancer mon projet!

**LordBob** · 30/07/2005, 19h52

de rien, si tu as d'autres questions !

**Haldres** · 01/08/2005, 10h33

dit pour recuperer juste la fenetre courante on utilise Getwindow a la place de getDesktopWindow?
parce qu'en fait jai une fenetre qui n'est pas en plein ecran et je cherche juste a recup�rer le contenu de celle la qui est devant une autre!
ON peut?

**LordBob** · 01/08/2005, 10h50

oui tu peux et tu dois effectivement utiliser GetWindow(...) � la place de GetDesktopWindow(...).

**Haldres** · 01/08/2005, 11h14

donc c'est la que j'ai un probl�me car �a continue a me r�cup�rer le bureau en entier!
j'ai :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
HWND hW;
HWND hWnd = GetWindow(hW,GW_HWNDFIRST);
HDC hDcWindow = GetWindowDC(hWnd);

et la suite est la m�me qu'avant!
avec �a j'ai toujours l��cran window au complet!
j'ai du rater quelque chose dans l'API window mais je suis pas habitu� a l'utilis�!

**LordBob** · 01/08/2005, 11h28

le premier argument de GetWindow c'est le handle de la fenetre que tu veux capturer, autrement ce qui identifie la fenetre.
la question qu'il faut se poser est dans:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

HWND hWnd = GetWindow(hW,GW_HWNDFIRST);

est-ce que hW contient bien le handle de la fenetre que tu veux capturer ? visiblement dans ton code, il ne contient rien, �a doit etre pour cela que �a fait une capture globale.

il faut donc que tu recuperes le handle de la fenetre que tu veux, � l'aide de la fonction FindWindox(...) par exemple!

**Haldres** · 01/08/2005, 11h37

tien celle la je ne la connaissais pas cett fonction!
merci je vais essayer tout de suite!

**Haldres** · 01/08/2005, 13h22

Bon alors je vais encore t'embeter :

je n'arrive pas a r�cup�rer le handle de ma fenetre, j'ai beau utiliser la fonction FindWindow ou GetForegroundWindow ou GetActivateWindow en fait il me recup�re toujours l'ecran entier! as tu une id�e d'ou cela pourrais venir?

**LordBob** · 01/08/2005, 13h38

es-tu sur que tu recuperes le handle de la fenetre?
montre le code qui r�cupere le handle.

**Haldres** · 01/08/2005, 13h52

alors j'ai essay� :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
HWND hW = FindWindowW(NULL,"Asphodele 3D");
HWND hWnd = GetWindow(hW,GW_HWNDFIRST);//la quelque soit le truc ça change rien
HDC hDcWindow = GetWindowDC(hWnd);

ou :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
HWND hW = GetForegroundWindow();
HDC hDcWindow = GetWindowDC(hW);

ou encore :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
HWND hW = GetActiveWindow();
HDC hDcWindow = GetWindowDC(hW);

qu'est ce qui cloche chez moi? je pige rien ou c'est autre chose?

**LordBob** · 01/08/2005, 14h19

toutes tes solutions te font une capture de l'�cran entier?

quand tu fais:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
HWND hW = FindWindowW(NULL,"Asphodele 3D"); 
HWND hWnd = GetWindow(hW,GW_HWNDFIRST);//la quelque soit le truc ca change rien 
HDC hDcWindow = GetWindowDC(hWnd);

es-tu sur que FindWindow te retourne bienun handle correct ? sinon je ne sais pas, j'ai pas trop le temps de tester, essai:

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

1
2
3
4
5
6
7
8
HWND hW = FindWindowW(NULL,"Asphodele 3D"); 
if(hW != NULL)
{
    HDC hDcWindow = GetWindowDC(hWnd);
    ... [jusqu'à la fin de la fonction]
}
else
    MessageBox(NULL, "Handle Invalide", "Erreur", MB_OK);

comme �a, tu verifieras bien que le handle est correct et que donc l'erreur est ailleurs !

**Haldres** · 01/08/2005, 14h34

alors oui toute mes solutions font une capture d'ecran en entier et apparemment il ne m'as pas sorti le messged'erreur ce qui fait que tu as raison le probleme vient d'ailleur!
mais alors d'ou je vais mettre un ch'tit moment a trouver je pense!

a moins que ce soit le fait que ma fenetre est une fenetre SDL et qu'elle n'es pas reconnu en fenetre windows?du coup comme il ne la trouve pas il met l'ecran entier par default?

**Laurent Gomila** · 01/08/2005, 14h54

a moins que ce soit le fait que ma fenetre est une fenetre SDL et qu'elle n'es pas reconnu en fenetre windows?

Si tu utilises SDL alors pourquoi ne pas faire �a :

Code :

S�lectionner tout - Visualiser dans une fen�tre � part

SDL_SaveBMP(MonBackBuffer, "Capture.bmp");

:

**Haldres** · 01/08/2005, 14h58

en fait a fait le boulet le compilateur modifiait la version du fichier sur le bureau alors que je voulais modifi� celle qui �tait dans le projet!

merci du temp que tu m'as consacrer ca marche nettement mieux maintenant!

**Haldres** · 01/08/2005, 15h01

je ne le fait parce que je ne vois pas la fenetre tant qu'elle n'est pas cr�er et que cellui qui l'as cod� n'as pas voulus passer la surface en parametre!
du coup j'utilise l'API windows pour palier ce manque de coop�ration!

**LordBob** · 01/08/2005, 15h13

je ne vois pas d'ou vient l'erreur, et pi j'ai pas trop le temps de chercher non plus en ce moment.
mais en tout cas, ca ne vient pas du fait que tu fais une fenetre avec SDL, c'est une fenetre Windows comme n'importe qu'elle autre !

**Laurent Gomila** · 01/08/2005, 16h01

Envoy� par Haldres

je ne le fait parce que je ne vois pas la fenetre tant qu'elle n'est pas cr�er et que cellui qui l'as cod� n'as pas voulus passer la surface en parametre!
du coup j'utilise l'API windows pour palier ce manque de coop�ration!

Tu te donnes bien du mal, tu perds la portabilit� offerte par SDL, et tu rends ton code bien moins fiable et plus gros.
Moi si j'�tais toi, j'irai dire deux mots � ce fameux codeur

Plus s�rieusement (et avec le peu que je sais de ton projet), je pense que le m�canisme de capture d'�cran devrait aller de paire avec le module d'affichage (celui qui manipule SDL donc), et donc utiliser les fonctions qui vont bien comme je te l'ai indiqu�.

Ce n'est que mon avis.

**Haldres** · 01/08/2005, 21h56

En fait la creation de la fenetre SDl son init ainsi que et celle de OpenGl sont fait dans la classe en haut ensuite les classes sont en cascades si on peut dire et moi ma fonction d'impression se trouve quelques classes plus bas o� on ne vois pas les classes du haut enfin d'ailleurs l� c'est bizarre!

au debut j'ai vu SDL j'ai fait chic facile et j'ai voulu l'implementer et l� : bug!
alors je regarde ce qu'il me dit et oh joie je ne vois pas la surface SDL!
Bon pas grave je fait un getter je me dit vu que c'est en cascade et que je suis en dessous je recup�re et ben non ils ont cod� tellement comme des porc que je suis oblig� de faire pareil juste pour faire une impression!
Voila l'esprit du projet dans lequel je viens de revenir!
Super sceance de travail en perspective!

Par contre autre chose et il possible d'initialiser le positionnement d'une fenetre SDL?parce que as chercher j'ai pas trouver et j'ai meme lu certain post disant que c'etait pas possible! dit qu'ils mentent ces gens la!

impression d'ecran en dev c++

Dev-C++

Discussions similaires

Partager

Partager