C/c++ sous windows tutorial 3 : creation et affichage de contrôles

Commenter

Contenu du snippet

Dans ce code, on va voir le système générique de création de contrôles. Pour agrémenter ce tuto d'un exemple, le control Button a été choisi. Ainsi, nous verrons d'une façon générale comment on crée et on gère un contrôle dans une appli Windows et plus spécifiquement le contrôle Button.

Source / Exemple : 


C/C++ SOUS WINDOWS TUTORIAL 3 : Système de création et d'utilisation des contrôles

INTRODUCTION
Nous avons vu dans les tutoriaux précédents comment créer une fenêtre Windows, et comment écrire du texte dedans avec la gestion de l'évènement WM_PAINT.
Dans ce ouveau tutorial, nous allons voir comment créer des contrôles les afficher, et les utilise. Ce tutorial va être à la fois généraliste les contrôles se créant et se gérant tous d'une façon similaire, mais aussi spécialisé pour l'exmple dans la création et la gestion du contrôle button. Nous verrons au fil du temps que la création de contrôles et la gestion de leurs évènements présentent des divergences tant au point de vue paramètres utilisés qu'au point de vue de ce qu'il peuvent faire.

I) CREATION D'UN CONTROLE
Un contrôle s'identifie par son Handle (HWND) et se crée de la même façon qu'une feuille à savoir au moyen de la fonction CreateWindow. Ici, pas de déclaration de structure au préalable ce que nous avions fait pour la feuille au moyen de WNDCLASS. Pas besoin non plus de la fonction RegisterClass. l'API connait déjà nos contrôles et comment ils doivent apparaitre dans leur forme basique.
Ainsi, pour créer par exemple un controle Button nous allons avoir comme premier paramètre de CreateWindow la chaine "button". "button" est connu de l'API. 
Notre contrôle Button, nous voulons qu'il contienne en texte (Caption) le mot Annuler par exemple. Notre deuxième paramètre de CreateWindow va donc être "Annuler".
Le troisième paramètre nous l'avions vu dans le premier tutorial correspond à la hérarchie de l'élément que nous créons. Une feuille est au premier rang donc a pour paramètre WS_OVERLAPPED_WINDOW par exemple. Un contrôle lui est rattaché à une feuille, donc est hiérarchiquement inférieur à elle. Notre troisième paramètre va donc être WS_CHILD. Ensuite, comme pour la feuille, arrivent les quatres paramètres de coordonées (position à gauche, position en haut, longueur, hauteur). 
Puisque notre contrôle est hiérarchiquement inférieur à une feuille qui le contient, le huitième paramètre de CreateWindow va donc être le Handle de cette feuille. Donc hFenetre pour reprendre le nom du Handle de la fenêtre du tutorial 1. Ensuite, les paramètres restent pour notre exemple 0, hInstance et 0.
Voici donc notre fonction de création de bouton : 
HWND hBouton;
hBouton = CreateWindow("button", "Annuler", WS_CHILD, 30, 30, 100, 30, hFenetre, 0, hInstance, 0);

Pour que le contrôle soit effectivement visible, comme pour l'affichage de la feuille, on conclut par : 
ShowWindow (hBouton, nShowCmd);

Voilà, en rajoutant la déclaration de hBouton, en tête du programme et les deux lignes précédentes de création et d'affichage du bouton sur la feuille à la suite de la création de cette feuille, votre programme une fois lancé doit faire apparaitre en haut à gauche aux coordonnées 30,30 de votre feuille un bouton de commande Annuler.

Nota : Ce bouton de commande comme tous les contrôle qui sont crés sous Windows ne nécessitent pas de proczdure particulière pour être redessinés lors de l'invalidation de la feuille. Ils se redessinent avec leur contenu de façon automatique. Pas besoin de coder pour eux WM_PAINT.

2) GESTION DES EVENEMENTS D'UN CONTROLE
C'est dans la boucle WinProc que nous allons gérer les évènements des contrôles créés.
Les évènements vont être divers et variés, utile et inutiles suivant les contrôles. Qu'est ce qu'on demande à un bouton de comande par exemple ? Qu'il conduise le programme sur une certaine voie lorsqu'on click dessus. Qu'est ce qu'on demanderait à un contrpole edit ? Par exemple que quelque chose se produise lorsque son texte change ou que l'on clique dedans. Je cite ces exemples volontairement, pour comprendre, qe le changement du texte d'un contrôle button n'est pas un évènement principal de ce contrôle. Ce serait normalement programmable, mais le bouton de commande est à la base créé pour réagir à un click sur lui.

Ce bouton de commande pour l'utiliser pour l'exemple dans sont rôle principal est géré par l'évènement WM_COMMAND. Ainsi, lorsque un click est effectué sur ce bouton, un message WM_COMMAND est envoyé à WinProc. Et ce message va contenir non pas dans son paramètre hWnd mais dans son paramètre lParam des informations sur le bouton qui vient de recevoir le message. Immaginons que notre feuille contienne plusieurs contrôles button, on ne pourrait pas savoir lors de l'envoie du message WM_COMMAND lequel a été cliqué. Cette information se trouve à l'intérieur du paramètre lParam. Et comme nous le savons, lParam n'est pas de type HWND et ne nous permet donc pas directement de le comparer avec les handles des boutons créés. Il va alors falloir le caster
Ainsi notre code d'évènement du click d'un bouton va apparaître ainsi:

case WM_COMMAND:
{
      if((HWND) lParam == hBouton)
      {
            //Procédure à effectuer en cas d'appuie sur hBouton
      }
      return 0;
}

WM_COMMAND est l'évènement principal d'un Bouton. Il y en a d'autres tels que ceux qui sont communs à tous les contrôles. Citons par exemple les évènements qui renvoient l'état d'un controle (visible, invisible, valide, invalide...) Nous verrons ultérieurement la gestions de ces messages.

3) COMPLEMENT
A noter autre chose qui concerne la création du contrôle Bouton et qui se retrouve dans la création d'autres contrôles mais de façon parfois différentes.
Un contrôle dispose d'options d'apparence. Un contrôle quel qu'il soit peut être à sa création valide ou non, disposer d'une bordure ou non, dans le cas du bouton être un bouton simple, un bouton d'option ou un bouton de case à cocher...
Toutes ces options nous le verrons au fil du temps sont à rajouter au paramètre d'apparence du contrôle. Par exemple pour un bouton d'option, on écrira WS_CHILD | BS_RADIOBUTTON.
Si on veut une bordure autour de ce bouton d'option, il faudra rajouter | WS_BORDER. 
Toutes ces options sont décrites dans le SDK de la programmation Windows. A savoir : 
Les options générales attribuables aux fenêtres et contrôles commencent par WS_
Les options d'apparence propres aux boutons commencent par BS_
Les options d'apparence propres aux zones d'édition commencent par ES_
... etc...

Voici ci dessous le programme complet d'affichage d'un bouton Annuler. Le Programme se termine lorsqu'on clique sur ce bouton.

#include <windows.h>

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd);

LRESULT CALLBACK WinProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
bool stop = false; 

HWND hFenetre; //Attention, on place cette déclaration ici et non dans WinMain pour la portée de la variable hFenetre lors du WM_PAINT
HWND hBouton;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd)
{

MSG MessagesAEnvoyer;

WNDCLASS Fenetre; 
Fenetre.lpszMenuName =NULL;
Fenetre.cbClsExtra  =0;
Fenetre.cbWndExtra =0;
Fenetre.hInstance = hInstance; 
Fenetre.lpfnWndProc = WinProc;
Fenetre.lpszClassName = "FENETRE DE TYPE A MOI";
Fenetre.style =  CS_VREDRAW | CS_HREDRAW; 
Fenetre.hbrBackground = (HBRUSH) GetStockObject(WHITE_BRUSH);
Fenetre.hIcon =(HICON)  LoadIcon(hInstance, IDI_APPLICATION);
Fenetre.hCursor =(HCURSOR)  LoadCursor(hInstance, IDC_ARROW);

RegisterClass(&Fenetre);

hFenetre = CreateWindow("FENETRE DE TYPE A MOI", "Voici la fenêtre", WS_OVERLAPPEDWINDOW, 200, 200, 300, 250, NULL, NULL, hInstance, NULL);
ShowWindow(hFenetre,nShowCmd);

hBouton = CreateWindow("button", "Annuler", WS_CHILD | WS_BORDER, 30, 30, 100, 30, hFenetre, 0, hInstance, 0);
ShowWindow(hBouton, nShowCmd);

InvalidateRect(hFenetre, 0, FALSE);

while (GetMessage(&MessagesAEnvoyer, hFenetre, 0, 0))
{ 
	TranslateMessage (&MessagesAEnvoyer); 
	DispatchMessage (&MessagesAEnvoyer);
}

return 0; 
}

LRESULT CALLBACK WinProc (HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	switch (uMsg)
	{
		case WM_DESTROY:
		{
			stop = true ;
			PostQuitMessage(0);
			return 0;
		}
		case WM_PAINT:
		{
			HDC hDC;
			hDC = GetWindowDC(hWnd);
			PAINTSTRUCT Ps;
			hDC = BeginPaint(hWnd, &Ps);
			TextOut (hDC, 10, 10, "Voici notre Phrase", strlen("Voici notre Phrase"));
			EndPaint(hWnd, &Ps);
			return 0;
		}
		case WM_COMMAND:
		{
			if((HWND) lParam == hBouton)
			{
				DestroyWindow(hFenetre);
				return 0;
			}
		return 0;
		}

	}
	return DefWindowProc(hWnd, uMsg, wParam, lParam); 
}

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (cs_LaPatoshe)