Discussion :

[_Michel]

Bonjour
Quelqu'un saurait comment marche la fonction MessageBox() ?
J'ai un programme qui crée juste une fenètre et dont la fonction callback est :

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
LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
		case WM_KEYDOWN:
			MessageBox (NULL, "a", "a", MB_OK);
		case WM_DESTROY:
			PostQuitMessage (0);
			break;

		default:
			return DefWindowProc (hwnd, message, wParam, lParam);
	}
	return 0;
}

La curiosité est que on peut créer plusieurs boîtes à message, et que le programme ne se termine que si l'on ferme la dernière boîte créee.

J'en déduit que MessageBox contient une boucle de message comme celle présente dans la fonction WinMain. Mais c'est très embètant : ça veut dire que on peut continuer à donner des ordres à un programme qui signale une erreur par exemple.
Quand on spécifie le handle de la fenètre concernée : hwnd lors de l'appel de la fonction MessageBox, on ne peut plus commander la fenêtre principale, mais celle-ci traite encore les messages envoyés par Windows, comme WM_PAINT. J'ai raison ou pas?

[pascal.barbier]

Si tu pass hwnd comme parent de la messageBox au lieu de NULL, elle devient "application modale" ce qui signifie que l'application (dont hwnd est le handle de la fenêtre principale) ne reçoit plus certains messages dans sa pompe à message tant que la messageBox est affichée (les messages provenant de l'utilisateur : clavier et souris).

Ensuite, effectivement, la messageBox a son propre mécanisme de réception des messages Windows, indépendant de la boucle de message de la MainWin.

Donc effectivement, l'application continue à recevoir les messages WM_PAINT pendant l'exécution de MessageBox (réentrance).

[Médinoc]

Attention: Il est très important de toujours spécifier le HWND de la fenêtre quand tu appelles une MessageBox de la fenêtre, car:

• Si tu ne le fais pas, tu as vu que ça te permet entre autres d'afficher plusieurs boîtes de message.
• Si tu ne les fermes pas dans le bon ordre, tu créeras un bordel pas possible en mémoire: http://blogs.msdn.com/oldnewthing/ar...23/378866.aspx

[_Michel]

Tout cela est très interessant, mais à éviter bien sur.

En ce moment j'essaie de faire un partie de programme en multithreading, et je sais pas trop comment m'y prendre.
Mon problème est simple : je crée une thread qui fait beaucoup de calculs et pendant ce temps ma première thread réceptionne les messages. En fait, cette dernière ne doit faire qu'une chose : attendre l'appui d'un bouton qui stoppe l'execution des calculs ou attendre la fin des calculs. J'ai pensé à MsgWaitForMultipleObjects () pour ne pas gaspiller les ressources processeurs mais je ne sais pas comment ne receptionner que les appuis de boutons. J'ai même fait des tests, et je constate que pendant que mon application attend, je ne peut même pas appuyer sur le bouton.
Comment je peut me débrouiller, même si je doit ignorer de temps en temps des "input events" qui n'on rien à voir avec mon fameux bouton?

[Médinoc]

Là, ça devient compliqué.

La fin des calculs, tu peux l'attendre de deux façons:

1. Attendre que le thread se termine, ou attendre un Event signalé par le thread de calcul.
2. Attendre un message posté par le thread de calcul.

La première solution implique l'utilisation de MsgWaitForMultipleObjects() dans une boucle. Là encore il y a plusieurs façons, la plus simple selon moi étant une boucle de messages interne + désactiver_tous_les_autres_boutons.

La seconde solution ne nécessite pas de MsgWaitForMultipleObjects(), mais implique toujours la désactivation de tous les autres boutons (plus le refus de quitter immédiatement si l'on clique sur la croix).

[_Michel]

Donc dans tous les cas, il y aura une boucle de message.
C'est OK, je vais me lancer...

[_Michel]

Pour ma gouverne, comment DispatchMessage () sait quelle callback appeler quand le message en question a été posté via PostThreadMessage (), et donc qu'on ne connaît pas le handle de la fenêtre de destination? En effet, il est toujours possible qu'une même thread poosède deux fenêtre.

[Médinoc]

Après un PostThreadMessage(), DispatchMessage() ne fait rien.
Tu dois traiter toi-même le message dans la boucle après le GetMessage() (le champ hwnd de la structure MSG sera NULL).

...Ou bien, utiliser un PostMessage() normal vers une fenêtre (voire un SendMessage() si ça peut faciliter l'extraction des résultats), ce qui sera plus simple.

[_Michel]

Il n'y aurait pas un moyen de créer une "modal dialog box" soit-même? C-a-d en ayant une bouble de message interne directement contrôlée; parce que si je veut utiliser une "modal dialog box" normale avec DialogBox, je ne pourrait rien recevoir de ma thread de calcul : pas d'event et les messages postée par PostMessageThread ne seront pas transmis.

Donc soit je crée une "modal dialog box" maison, soit je sais vraiment pas quoi faire, parce que si je crée une fenêtre toute simple et que je me débrouille pour lui faire parvenir les messages de ma thread de calcul, elle ne bloquera pas ma fenêtre principale, et c'est pas bon du tout.

Pour l'instant j'ai testé ça :

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
#include <windows.h>
#include <stdio.h>
#include "usuelles.h"


LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam);
BOOL CALLBACK DialogProcNouvelleTread(HWND hWndDlg, UINT uMsg, WPARAM wParam, LPARAM lParam);

HINSTANCE hInstance;
HANDLE hButton;
int i = 0;


int WINAPI WinMain (HINSTANCE hThisInstance, HINSTANCE hPrevInstance, LPSTR lpszArgument, int nFunsterStil)
{
	HWND hWnd;
	MSG messages;
	WNDCLASSEX wincl;
	
	hInstance = hThisInstance;

	// Infos importantes
	wincl.hInstance = hThisInstance;
	wincl.lpszClassName = "Classe principale";
	wincl.lpfnWndProc = WindowProcedure;
	wincl.style = CS_DBLCLKS;
	wincl.cbSize = sizeof (WNDCLASSEX);

	// Icones et curseurs par défaut
	wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
	wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
	wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
	wincl.lpszMenuName = NULL;
	wincl.cbClsExtra = 0;
	wincl.cbWndExtra = 0;
	wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

	DeleteFile ("tracage.txt");

	if (!RegisterClassEx (&wincl)) {
		Message (NULL, "Erreur dans la création de la fenêtre", "Erreur", TRUE);
		return -1;}

	hWnd = CreateWindowEx (
		   0,
		   "Classe principale",
		   "Titre",
		   WS_OVERLAPPEDWINDOW | WS_VISIBLE,
		   CW_USEDEFAULT,
		   CW_USEDEFAULT,
		   544,
		   375,
		   HWND_DESKTOP,	
		   NULL,			
		   hThisInstance,
		   NULL				
		   );

	if (!hWnd) {
		Message (NULL, "Erreur dans la création de la fenêtre", "Erreur", FALSE);
		return -1;}

	while (GetMessage (&messages, NULL, 0, 0))
	{
		TranslateMessage(&messages);
		DispatchMessage(&messages);
	}

	UNREFERENCED_PARAMETER (hPrevInstance);
	UNREFERENCED_PARAMETER (lpszArgument);
	UNREFERENCED_PARAMETER (nFunsterStil);
	return messages.wParam;
}

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message)
	{
		case WM_CREATE:
			if (i==0) {
				hButton = CreateWindow ("BUTTON", "nouvelle fenêtre", WS_CHILD | WS_VISIBLE, 10, 10, 514, 325, hwnd, NULL, hInstance, NULL);
			}
			i += 1;
			break;

		case WM_COMMAND:
			if (lParam == (long)hButton) {
				HWND hWnd2;
				MSG messages;

				hWnd2 = CreateWindowEx (
					   0,
					   "Classe principale",
					   "Titre 2",
					   WS_OVERLAPPEDWINDOW | WS_VISIBLE,
					   10,
					   10,
					   544,
					   375,
					   NULL,
					   NULL,
					   hInstance,
			 		  NULL
					   );

				if (!hWnd2) {
					Message (NULL, "Erreur dans la création de la fenêtre 2", "Erreur", FALSE);
					return -1;}

				while (GetMessage (&messages, NULL, 0, 0))
				{
					if ((messages.hwnd == hWnd2)||(messages.message == WM_PAINT)) {
						TranslateMessage(&messages);
						DispatchMessage(&messages);}
				}
			}
			break;

		case WM_DESTROY:
			PostQuitMessage (0);
			break;

		default:
			return DefWindowProc (hwnd, message, wParam, lParam);
	}

	return 0;
}

Le résultat est pas mal :tant que la seconde fenêtre n'a pas été fermée, la première fenêtre ne peut rien faire, mais les "modal box" de Windows sont plus jolies : quand on clique sur la première fenêtre, celle-ci se met à clignoter.... enfin bon, si c'est pas possible, c'est pas grave, je vend pas encore mes programmes.

[Médinoc]

Si, tu peux faire ta propre boîte de dialogue modale avec boucle de message contrôlée, avec des fonctions comme CreateDialog().

Ou bien, tu peux récupérer des messages de thread, voir ici: http://blogs.msdn.com/oldnewthing/ar...28/412574.aspx
Par contre, tu auras besoin de variables globales (ou de Thread-Local storage, qui nécessite de toute façon une variable globale).

[_Michel]

Juste une petite question : comment oldnewthing s'est procuré le code source de Windows?

[Médinoc]

Sans doute parce c'est son boulot...
(il est membre de l'équipe Microsoft qui bosse sur le shell)

[_Michel]

Si j'ai bien compris, les codes suivants font la même chose, et ne sont pas proscrit par les rêgles de base du bon programmeur Windows :

Code :

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

MessageBox (hwnd, "Texte", "Titre", MB_OK);

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
DialogBox (hInstance, "Dialog", hwnd, DlgProc);

BOOL APIENTRY DlgProc(HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message) {
		case WM_COMMAND:
			EndDialog (hwndDlg, 0);
			break;

		default:
			return FALSE;
	}
	return TRUE;
}

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
CreateDialog (hInstance, "Dialog", hwnd, DlgProc);
EnableWindow (hwnd, FALSE);

BOOL APIENTRY DlgProc(HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message) {
		case WM_COMMAND:
			EndDialog (hwndDlg, 0);
			EnableWindow (hWnd, TRUE);
			break;

		default:
			return FALSE;
	}
	return TRUE;
}

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
CreateDialog (hInstance, "Dialog", hwnd, DlgProc);
EnableWindow (hwnd, FALSE);
while (GetMessage (&messages, NULL, 0, 0))
{
	TranslateMessage (&messages);
	DispatchMessage (&messages);
}

BOOL APIENTRY DlgProc(HWND hwndDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
	switch (message) {
		case WM_COMMAND:
			EndDialog (hwndDlg, 0);
			EnableWindow (hWnd, TRUE);
			PostQuitMessage (0);
			break;

		default:
			return FALSE;
	}
	return TRUE;
}

[Médinoc]

Il ne faut pas prendre ce que je dis pour argent comptant, mais ça y ressemble.

Sauf qu'une vraie boucle avec une boîte de dialogue dedans utiliser aussi IsDialogMessage() sur la boîte de dialogue créée.

[_Michel]

C'est noté (bien que cette fonction ne serve pas à grand chose, selon mon humble avis).

Une toute dernière question : pourquoi tout le monde dit qu'il ne faut pas utiliser de variable globales ? Personnellement, je n'ai jamais eu de problème avec les variables globales que j'utilise à tout bout de champ.

[Médinoc]

Tout simplement parce que ce n'est ni nativement thread-safe, ni nativement réentrant.

Pour un exemple de fonction non-réentrante, tu prends strtok(). Imagine que dans le traitement d'une chaîne, tu aies besoin d'appeler une fonction qui elle-même traite une chaîne avec strtok() --> ERREUR.
Comment se fait-ce ? Parce que strtok() utilise une variable globale. (heureusement, sous Windows, elle a la délicatesse d'utiliser du Thread-Local Storage; elle n'est toujours pas réentrante, mais au moins elle est thread-safe).

Sinon, plus simple, l'utilisation de variables globales avec des fenêtres: Et voilà, tu ne peux plus ouvrir en même temps deux fenêtres de la même WNDCLASS (ou avec la même WNDPROC, ou deux boîtes de dialogue avec la même DLGPROC), car elles utiliseront les mêmes variables globales.


Franchement, il m'arrive d'utiliser des variables globales, dans certains bricolages douteux comme Celui-ci ou celui-là. Tu noteras que dans les deux cas,

• Je préserve la réentrance car les deux sont prévues pour fonctionner avec la pile,
• Et j'utilise du Thread-Local Storage, les seules variables globales sont donc celles liées au TLS et son initialisation.

[_Michel]

A, je vois. Mais alors comment faire quand toutes les fonctions (notamment les callback) doivent utiliser les même objet ? On ne doit quand même pas créer un objet de partage de donnée made in Windows pour un bitmap qui reste unique tout au long du programme ?

[Médinoc]

Typiquement, tu utilises non pas un bitmap pour tout le programme, mais un bitmap par fenêtre de la classe en question.

C'est à ça que servent cbWndExtra, SetWindowLongPtr() (qui compile mal sous Win32)...

[_Michel]

Admettons que l'on puisse passer des informations à une fenêtre créer par CreateWindow, on ne peut toujours pas pour une boite de dialogue qui est crée par CreateDialog par exemple. Alors qu'il est très simple d'avoir des variables globales. De plus, pour une majorité de programmes qui ne font qu'une seule chose à la fois (avec des modal dialog box), la réentrance n'est pas nécessaire. Non?

[Melem]

Admettons que l'on puisse passer des informations à une fenêtre créer par CreateWindow, on ne peut toujours pas pour une boite de dialogue qui est crée par CreateDialog par exemple.

Tu t'es déjà demandé comment sont implémentées DialogBox, CreateDialog et compagnie?