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