impression d'ecran en dev c++

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!

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

screen_shot.cpp:

Code:

---

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:

---

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:

---

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

---

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

de rien, si tu as d'autres questions !

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?

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

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:

---

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é!

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:

---

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!

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

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?

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

alors j'ai essayé :

Code:

---

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:

---

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

---

ou encore :

Code:

---

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

---

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

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

quand tu fais:

Code:

---

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:

---

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 !

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?

Citation:

---

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:

---

SDL_SaveBMP(MonBackBuffer, "Capture.bmp");

---

:?:

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!

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!

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 !

Citation:

---

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 http://djforum.free.fr/smileysmileys....com.arme3.gif

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.

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!

Citation:

---

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!

---

Aucune idée, à vrai dire je n'ai jamais utilisé la SDL.

Voici une fonction qui capte l'image du presse-papiers et la place dans un fichier .bmp, puis une autre qui place l'image de la fenêtre active (ou l'écran) dans le presse-papiers, puis enfin, un petit programme pour tester le tout. Lancé dans une fenêtre console comme ceci:

Code:

---

window2bmp fichier.bmp

---

il placera l'image de la fenêtre console dans un fichier .bmp nommé fichier.bmp.

Code:

---

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

#include <stdio.h> #include <windows.h>     int ClipboardToBmp(char *nomfich) { HANDLE hret; HANDLE hFile; char *p=0; long len_global, debut_pixels; BITMAPFILEHEADER file_header = { 0 }; BITMAPINFOHEADER *info; int longueur_palette=0; int ret = 0; DWORD bytes_written=0;     // Ça prend un nom de fichier if (!nomfich) return (0);   // Ouvrir le clipboard if (!OpenClipboard(0)) return (0);   // Récupérer l'image hret = GetClipboardData(CF_DIB); if (!hret) { CloseClipboard(); return (0); }   // Récupérer l'adresse du bloc mémoire p = (char *) GlobalLock(hret); if (!p) { CloseClipboard(); return (0); }   // Récupérer la longueur du bloc mémoire len_global = GlobalSize(hret);   // La mémoire contient un BITMAPINFOHEADER // suivi de la palette si elle existe // et ensuite viennent les bits de l'image.   info = (BITMAPINFOHEADER *) p;   // Calculons la longueur de la palette switch (info->biBitCount) { case 1: longueur_palette = 2 * sizeof(RGBQUAD); break; case 4: longueur_palette = 16 * sizeof(RGBQUAD); break; case 8: longueur_palette = 256 * sizeof(RGBQUAD); break; case 16: case 32: if (info->biCompression == BI_BITFIELDS) { // Il y a des masques de bits. // Voir la description de BITMAPINFOHEADER longueur_palette = 3 * sizeof(DWORD); } break; }   // Calculons le début des pixels debut_pixels = sizeof(BITMAPFILEHEADER) + info->biSize + longueur_palette;   // Plaçons les valeurs dans la structure BITMAPFILEHEADER file_header.bfType = 0x4d42; file_header.bfSize = sizeof(BITMAPFILEHEADER) + len_global; file_header.bfOffBits = debut_pixels;   hFile = CreateFile(nomfich, GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0); if (hFile) { ret = WriteFile(hFile, (void *) &file_header, sizeof(BITMAPFILEHEADER), &bytes_written, 0); ret = WriteFile(hFile, (void *) p, len_global, &bytes_written, 0); CloseHandle(hFile); }   GlobalUnlock(hret); CloseClipboard();   return (ret);   }   /* ---------------------------------------------------------------------- */ void CaptureEcran(int fenetre_seulement) {   keybd_event(VK_SNAPSHOT, fenetre_seulement, 0, 0);   }   /* ---------------------------------------------------------------------- */ int main(int argc, char *argv[]) {   if (argc < 2) { printf("Usage: window2bmp nom_de_fichier.bmp\n"); return (1); }   CaptureEcran(1);   Sleep(1000);   if (!ClipboardToBmp(argv[1])) { printf("Une erreur est survenue!\n"); return (1); }   printf("Conversion Ok!\n");   return (0);   }

---

Merci je prend et je garde en reserve mais pour l'instant ce qu'il y avait au dessus marche largement!