Discussion :

[buzzkaido]

Bonjour,

Je developpe actuellement un petit projet d'interface graphique...

J'ai créé plusieurs composants, notamment un panneau defilant (avec des barres de scrolls)

J'ai remarqué un bug dont je ne comprends pas l'origine :

Lorsque je tourne la molette de la souris à fond les ballons, l'ecran se rafraichit plein de fois (normal) et au bout d'un moment, les bitmaps ne sont plus dessinées.

En cherchant un peu, c'est l'appel à CreateCompatibleDC qui me renvoit un hdcMem à NULL.

Voila le code de ma fonction :

je precise :
- les HBITMAP et les HBRUSH pointés par pSkin sont bien valides, j'ai vérifié
- j'ai essayé de remplacer CreateCompatibleDC(NULL) par CreateCompatibleDC(hdc)
- le hdc transmis à la fonction n'est jamais NULL, lui

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
void cGuiBarreDefilement::dessiner(HDC hdc, RECT updateRect)
{
  RECT rc;
  HDC hdcMem;

  rc = m_surface.intersection(updateRect);
  hdcMem = CreateCompatibleDC(NULL);

  // Dessin du fond
  FillRect(hdc,&rc,pSkin->barreDefilements[m_modele].m_fond);

  // Dessin du curseur
  if ( (m_surfaceCurseur.largeur != 0) && (m_surfaceCurseur.hauteur != 0) )
  {
    rc = m_surfaceCurseur.rectangle();
    if (m_surfaceCurseur.collision(updateRect))
      FillRect(hdc,&rc,pSkin->barreDefilements[m_modele].m_curseur);
  }

  // Dessin des boutons
  if (m_surfaceBoutonMoins.collision(updateRect))
  {
    if (m_orientation & GUI_VERTICAL)
      SelectObject(hdcMem,pSkin->barreDefilements[m_modele].m_boutonHaut.m_bitmap);
    else
      SelectObject(hdcMem,pSkin->barreDefilements[m_modele].m_boutonGauche.m_bitmap);

    BitBlt(hdc,m_surfaceBoutonMoins.x,m_surfaceBoutonMoins.y,m_surfaceBoutonMoins.largeur,m_surfaceBoutonMoins.hauteur,hdcMem,0,0,SRCCOPY);
  }
  if (m_surfaceBoutonPlus.collision(updateRect))
  {
    if (m_orientation & GUI_VERTICAL)
      SelectObject(hdcMem,pSkin->barreDefilements[m_modele].m_boutonBas.m_bitmap);
    else
      SelectObject(hdcMem,pSkin->barreDefilements[m_modele].m_boutonDroit.m_bitmap);

    BitBlt(hdc,m_surfaceBoutonPlus.x,m_surfaceBoutonPlus.y,m_surfaceBoutonPlus.largeur,m_surfaceBoutonPlus.hauteur,hdcMem,0,0,SRCCOPY);
  }

  DeleteDC(hdcMem);
}

J'ai regardé le codes d'erreur renvoyés par CreateCompatibleDC, et j'obtiens ça :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
Erreur : HDCMem=NULL : 6 - Descripteur non valide
Erreur : HDCMem=NULL : 6 - Descripteur non valide
Erreur : HDCMem=NULL : 0 - Opération réussie.
Erreur : HDCMem=NULL : 6 - Descripteur non valide
Erreur : HDCMem=NULL : 6 - Descripteur non valide
Erreur : HDCMem=NULL : 0 - Opération réussie.
etc...

Ce qui m'étonne :
- pourquoi ça plante que au bout d'un moment ?
- pourquoi Erreur : HDCMem=NULL : 0 - Opération réussie ?

Merci de me filer un coup de main, ce truc va me rendre dingue !

[Médinoc]

Quel Windows ?
GetLastError() après CreateCompatibleDC() ne marche que sous les windows NT/2000/XP...

Tu es sûr que tu n'as aucune fuite de ressource ? C'est assez typique du "au bout d'un moment"...

[buzzkaido]

Merci pour la reponse rapide....

Windows XP !

Fuite de ressource ? Comment ça ?

Si tu penses à des bitmaps qui ne sont plus valide, je ne pense vraiment pas, puisque :
- les pointeurs m'ont l'air corrects (en debug, ils ne bougent pas)
- je ne charge les ressources qu'une fois (au tout début, je les chargent toutes d'un coup)
- je n'utilise les ressources qu'en lecture

Et puis j'ai quand meme une erreur sur le createCompatibleDC...

[buzzkaido]

Quelqu'un pourrait m'expliquer ce qu'est une fuite de ressource, comment la detecter, comment la colmater...

Merci !

[Médinoc]

Je pense à des DC ou bitmaps qui sont créés ou acquis sans être détruits ou rendus...

Déjà, tu peux jeter un coup d'oeil à la colonne "Objets GDI" du gestionnaire de tâches : Si ça monte de façon anormale, c'est que tu as une fuite.

[buzzkaido]

Ok, je vais verifier tout ça dès ce soir...

Deux petites precisions :

- faut-il faire un selectObject(NULL) avant de faire le deleteDC(hdcMem) ?
- faut-il mieux faire hdcMem = createCompatibleDC(NULL) ou hdcMem = createCompatibleDC(hdc) ?

[Médinoc]

1. Il faut faire un SelectObject() du handle retourné par le SelectObject() du début. Ne pas le faire peut être la raison de la fuite de ressources.
   Si tu codes en C++, j'ai codé une classe qui fait ça automatiquement (RAII) et je peux te la passer.
2. J'ai l'habitude de faire CreateCompatibleDC(hdc), mais si tu n'es pas en multithread, CreateCompatibleDC(NULL) devrait aussi marcher...

[buzzkaido]

euh, pour le 1. je ne comprends pas réélement l'interet/la raison de cela...

Si j'ai bien compris, il faut faire :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
dessiner(hdc)
{
   hdcMem = createCompatibleDC(hdc);
   handle = selectObject(hdcMem,hbitmap);
   bitblt(....);
   selectObject(hdcMem,handle);
   deleteDC(hdcMem);
}

Mais que faire dans le cas où on selectionne plusieurs objets les uns apres les autres ? (pour dessiner plusieurs bitmaps)

Il faut fait un selectObject(handleDuDebut) entre chaque ?

Ta classe RAII, comment ça fonctionne ? Ca ne m'interresse pas réélement de récupérer un truc tout fait, mais si tu peux m'expliquer le principe rapidement, ce serait cool !

Comme ça j'integrerais le mecanisme dans ma classe cSkin...

----------------------
EDIT :

Apres un lecture de MSDN (faut vraiment que je prenne le reflexe !) :

SelectObject :
"This function returns the previously selected object of the specified type. An application should always replace a new object with the original, default object after it has finished drawing with the new object."

Ceci explique cela... mais pas vraiement, en fait...
Vu que je selectionne les bitmaps sur un hdc en memoire qui est detruit ensuite... pourquoi reselectionner l'objet de depart ?

Merci !

[Médinoc]

Entre autres, pour que l'objet de départ soit lui aussi détruit...

Et quand il est question d'un DC "prêté" et non créé, autant le rendre dans l'état où on l'a trouvé...

Puisque tu ne veux pas l'implémentation de ma classe RAII, je te montre son interface et son utilisation, histoire de comprendre un peu comment on fait proprement de la RAII là-dessus...

Code C++ :

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
class CSaveGdiObj
{
public:
	CSaveGdiObj(
	 HDC hdc,         //[in/hold] Handle to the device context to monitor.
	 DWORD objectType //[in] Object type.
	 );
	CSaveGdiObj(
	 HDC hdc,             //[in/hold] Handle to the device context to monitor.
	 HGDIOBJ hNewObj,     //[in/freed?] Handle to the new object to select (the type is obtained from this object).
	 bool bDeleteSelected //[in] If true, delete hNewObj when restoring the old object or selecting a new one.
	 );
	~CSaveGdiObj();
 
	bool Select(
	 HGDIOBJ hNewObj,     //[in/freed?] Handle to the new object to select (must be of the same type).
	 bool bDeleteSelected //[in] If true, delete hNewObj when restoring the old object or selecting a new one.
	 );
private:
	//Forbidden copy constructor: Not implemented.
	CSaveGdiObj(CSaveGdiObj const &);
	CSaveGdiObj & operator= (CSaveGdiObj const &);
protected:
	void AssertValid();
protected:
	HDC const m_hdc;
	bool m_bDeleteSelected;
	DWORD const m_objectType;
	HGDIOBJ m_hFirstObject;
	HGDIOBJ m_hCurrentObject;
};

(Oui, les commentaires et les variables sont en Anglais).


Et un petit exemple d'utilisation:

Code C++ :

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
case WM_PAINT:
	{
	PAINTSTRUCT ps;
	HDC hdc = BeginPaint(hWnd,&ps);
	//Variables locales: les CCSaveGdiObj doivent être détruits avant le EndPaint.
	{
		CSaveGdiObj saveBrush(hdc, CreateSolidBrush(RGB(0,0,0)), true);
		CSaveGdiObj savePen(hdc, CreatePen(PS_SOLID, 1, RGB(80,80,80)), true);
 
		//Dessiner avec le brush et le pen persos
 
		saveBrush.Select(CreateSolidBrush(RGB(255,0,0)), true);
 
		//Dessiner encore avec un autre brush perso
 
		saveBrush.Select(GetSysColorBrush(COLOR_3DFACE), false);
 
		//Dessiner avec un brush global, cette fois-ci
	}
	EndPaint(hWnd,&ps);
	}
	break;

Dans cet exemple, les brush persos sont créés et détruits dans le traitement du message. Mais on peut très bien utiliser des brush persistants créés et détruits en même temps que la fenêtre. Dans ce cas, le paramètre booléen doit être false pour empêcher leur destruction par le CSaveGdiObj...

[buzzkaido]

Ok !

Je crois que j'ai compris le principe...

Je vais essayer d'implementer un truc du genre dans ma classe cSkin pour eviter toute fuite... (mes bitmaps et mes brosses sont persistentes)

PS : je n'ai rien contre les variables/commentaires en anglais.... et ton aide est vraiment utile !

[Mat.M]

- faut-il faire un selectObject(NULL) avant de faire le deleteDC(hdcMem) ?
- faut-il mieux faire hdcMem = createCompatibleDC(NULL) ou hdcMem = createCompatibleDC(hdc) ?

Pour SelectObject non parce que tu sélectionnes un HGDIOBJ ou objet GDI relié à un HDC ou contexte de dessin de périphérique...

Pour CreateCompatibleDC tu sais qu'il ya quelque chose qui s'appelle le MSDN que c'est écrit en toutes lettres dedans

CreateCompatibleDC
The CreateCompatibleDC function creates a memory device context (DC) compatible with the specified device.

HDC CreateCompatibleDC(
HDC hdc // handle to DC
);
Parameters
hdc
[in] Handle to an existing DC. If this handle is NULL, the function creates a memory DC compatible with the application's current screen.

Merci donc de le consulter

[buzzkaido]

Merci pour les nombreuses réponses... j'avais bien une fuite de ressources... mais pas où je pensais !

En fait, j'utilise des regions de clipping, crées donc avec CreateRgn().

Or une region est aussi un objet GDI, détail qui m'avait échappé !

Du coup j'ai integré une gestion de tout ça dans ma classe de skin, et tout roule !

@Mat.M :

Oui, MSDN est tres bien, des fois je m'y perd un peu mais je regarde (presque) toujours dedans.
Pour ma question sur CreateCompatibleDC, je connaissais bien la difference entre :

CreateCompatibleDC(hdc) et CreateCompatibleDC(NULL)

Ma question était : lequel est le plus adapté, sachant que les deux marchent (dans mon cas) vu que mon hdc est compatible avec l'écran, un nouveau hdc créé avec CreateCompatibleDC(NULL) est a priori compatible avec, mais est-sûr ? y'en-a-t-il un plus rapide que l'autre ? si l'utilisateur change de résolution en cours d'execution ?