Interfaces graphiques en C++ avec wxWidget/Évenements

Un livre de Wikilivres.
Sauter à la navigation Sauter à la recherche
IHM en C++ avec wxWidget
Interfaces graphiques en C++ avec wxWidget
Sommaire
Liens
Modifier ce modèle

Intercepter des événements[modifier | modifier le wikicode]

Notions abordées :[modifier | modifier le wikicode]

  • nouveaux composants graphiques
  • la classe wxPanel
  • la classe wxButton
  • la classe wxStaticText
  • la classe wxTextCtrl
  • la classe wxColour
  • le modèle événementiel
  • la classe wxEventCommand
  • la classe wxString
  • la fonction wxMessageBox


Screenshot[modifier | modifier le wikicode]

Fichier:WxWidgetSomme.jpg

Présentation de l'application[modifier | modifier le wikicode]

L'objectif de cette leçon est d'avoir deux champs texte éditables dans lequels l'utilisateur peut saisir des réels ainsi qu'un bouton « calculer ». Si on clique sur le bouton, on voit apparaître la somme des 2 réels dans un troisième champ texte non éditable.

Présentation de quelques composants graphiques[modifier | modifier le wikicode]

Nous avons vu lors de la première leçon qu'une fenêtre hérite de la classe wxFrame. Nous allons rajouter différents composants graphiques dans notre fenêtre : du texte, des champs texte éditables et des boutons. Pour cela, il faut commencer par positionner un wxPanel à l'intérieur de notre fenêtre. Si panel est un pointeur vers notre wxPanel, on peut tout simplement écrire dans le constructeur de notre fenêtre :

panel = new wxPanel(this);


Maintenant, nous allons mettre différents composants graphiques sur notre panel :

  • du texte : il suffit de rajouter des wxStaticText. Le constructeur de ces wxStaticText ont besoin des informations suivantes :
    • le « père » de notre composant graphique : il s'agira de notre panel.
    • un entier identifiant notre composant : nous n'avons pas besoin d'utiliser un tel identifiant pour nos champs texte, nous mettrons alors la valeur -1.
    • la position de notre champ texte en utilisant la classe wxPoint.
    • la taille de notre champ texte en utilisant le classe wxSize.
    • Pour rajouter un champ texte sur notre wxPanel, nous écrirons par exemple :
textX= new wxStaticText(panel,-1,"Valeur de X : ",wxPoint(10,20),wxSize(100,20));


Il s'affichera alors le texte "Valeur de X :" aux coordonnées 10,20 dans un rectangle de 100x20 pixels.

  • des champs texte éditables :
    • le composant graphique correspondant s'appelle wxTextCtrl. Le constructeur de ce composant a besoin des mêmes paramètres que le constructeur de wxStaticText. Il est possible de rendre le champ texte inéditable en utilisant la méthode SetEditable(false). Il est possible de modifier la couleur de notre champ texte en utilisant la méthode SetBackgroundColour(wxColour(200,200,200)); La classe wxColour permet de représenter une couleur sous la forme rouge-vert-bleu où chaque composante est un entier entre 0 et 255.
    • Pour rajouter un champ texte éditable sur notre wxPanel, nous écrirons par exemple :
editX=new wxTextCtrl(panel,-1,"",wxPoint(120,20),wxSize(100,20));


  • des boutons :
    • nous utiliserons alors la classe wxButton. Le constructeur de ce composant aura besoin des informations suivantes :
    • le « père » de notre composant graphique : il s'agira de notre panel.
    • un entier identifiant notre composant : lorsque nous cliquerons sur notre bouton, nous aurons besoin d'un identifiant pour ce bouton. Nous utiliserons une constante entière générée par exemple par un type énuméré.
    • la position de notre champ texte en utilisant la classe wxPoint.
    • la taille de notre champ texte en utilisant le classe wxSize.
    • Pour rajouter un bouton sur notre wxPanel, nous écrirons par exemple :
buCompute=new wxButton(panel,BUTTONCOMPUTE_ID,"CALCULER",wxPoint(240,50));


Structuration en classes[modifier | modifier le wikicode]

Notre application somme comportera 2 classes : la classe SommeAppli qui représente notre application et qui hérite de wxApp et la classe SommeWin qui héritera de wxframe et qui sera notre principale fenêtre. Pour chacune de ces classes nous allons créer un fichier .h et un fichier .cpp. Nous aurons donc 4 fichiers au total :

  • SommeAppli.h
  • SommeAppli.cpp
  • SommeWin.h
  • SommeWin.cpp

La classe SommeAppli[modifier | modifier le wikicode]

Rien de nouveau par rapport à la leçon numéro 1. Le fichier SommeAppli.h est donc le suivant :

 1 #ifndef SOMMEAPPLI_H
 2 #define SOMMEAPPLI_H
 3 
 4 #include<wx/wx.h>
 5 #include"SommeWin.h"
 6 
 7 class SommeAppli : public wxApp
 8 {
 9 public:
10     bool OnInit();
11 
12 protected:
13     SommeWin * window;
14 };
15 
16 DECLARE_APP(SommeAppli)
17 
18 #endif


Le fichier SommeAppli.cpp est :

 1 #include"SommeAppli.h"
 2 
 3 IMPLEMENT_APP(SommeAppli)
 4 
 5 bool SommeAppli::OnInit()
 6 {
 7   window=new SommeWin();
 8   window->Show(TRUE);
 9   SetTopWindow(window);
10   return true;
11 }


Le modèle événementiel[modifier | modifier le wikicode]

Lorsque l'utilisateur va cliquer sur le bouton, il faudra effectuer une opération particulière : afficher dans un champ texte la somme de 2 réels. Il faut donc dire à l'application que lorsqu'on cliquera sur le bouton ayant un identifiant donné, on actionnera une méthode donnée. Pour cela, nous écrirons dans la classe SommeWin.h la macro :

DECLARE_EVENT_TABLE()

Cela signifie que notre classe va devoir gérer des événements.
Notre bouton portera l'identifiant BUTTONCOMPUTE_ID. Lorsqu'on cliquera sur ce bouton, on appellera la méthode compute. Pour effectuer cette association, on écrira dans le fichier SommeWin.cpp :

BEGIN_EVENT_TABLE(SommeWin,wxFrame)
EVT_BUTTON(BUTTONCOMPUTE_ID,SommeWin::compute)
END_EVENT_TABLE()

La méthode compute sera définie dans la classe SommeWin de la manière suivante :

void compute(wxCommandEvent &event);


Le paramètre event permet d'avoir différentes informations sur l'événement qui vient de se produire : nous n'utiliserons pas ici ces informations.

La méthode compute[modifier | modifier le wikicode]

Dans la méthode compute, il faudra récupérer les chaînes de caractères situées dans les 2 champs texte éditables. Pour cela, il suffit d'appeler la méthode GetValue() de la classe wxTextCtrl pour récupérer la chaîne de caractères qui sera une instance de la classe wxString. Il faudra ensuite transformer cette chaîne en double. Pour cela on utilisera la méthode bool ToDouble(double & x); de la classe wxString. Cette méthode renvoie le booléen true si la chaîne est effectivement un réel. Dans ce cas, la valeur de la chaîne transformée en double est mise dans x. Si l'utilisateur a tapé une chaîne qui n'est pas un réel, alors la méthode ToDouble renverra false.
Lorsqu'on aura récupéré les 2 réels tapés, nous pourrons aisément calculer la somme des 2 double : il faudra alors transformer ce double en une wxString. Pour cela, nous pourrons utiliser la méthode sprintf(...) de wxString qui permet d'écrire ce que l'on veut dans une chaîne de caractères avec la même syntaxe que la commande printf du C. Si jamais l'utilisateur tape des valeurs erronées, nous ouvrirons une boîte de dialogue qui comportera un message d'erreur et un bouton OK et qui bloquera l'application tant que l'utilisateur n'appuiera pas sur le bouton OK : une telle boite de dialogue est dite modale. Il suffit d'appeler la fonction wxMessageBox(...). Par exemple si on appelle wxMessageBox("Données erronées","ERREUR"); , il s'ouvre une boîte de dialogue modale dans laquelle il est écrit « Données erronées » et dans la barre du haut de cette boîte il est écrit « ERREUR ».

La classe SommeWin[modifier | modifier le wikicode]

Le fichier SommeWin.h est le suivant :

 1 #ifndef SOMMEWIN_H
 2 #define SOMMEWIN_H
 3 
 4 #include<wx/wx.h>
 5 
 6 enum
 7 {
 8   BUTTONCOMPUTE_ID
 9 };
10 
11 class SommeWin : public wxFrame
12 {
13 public:
14     SommeWin();
15 
16 protected:
17     wxPanel * panel;
18     wxButton *buCompute;
19     wxStaticText *textX,*textY,*textS;
20     wxTextCtrl *editX,*editY,*editS;
21 
22     void compute(wxCommandEvent &event);
23 
24     DECLARE_EVENT_TABLE()
25 };
26 
27 #endif


Le fichier SommeWin.cpp est le suivant :

 1 #include"SommeWin.h"
 2 #include<wx/colour.h>
 3 
 4 SommeWin::SommeWin()
 5     : wxFrame(NULL,-1,"Distance")
 6 {
 7   panel= new wxPanel(this);
 8 
 9   textX= new wxStaticText(panel,-1,"Valeur de X : ",wxPoint(10,20),wxSize(100,20));
10   textY= new wxStaticText(panel,-1,"Valeur de Y : ",wxPoint(10,50),wxSize(100,20));
11   textS= new wxStaticText(panel,-1,"X+Y vaut : ",wxPoint(10,80),wxSize(100,20));
12 
13   editX=new wxTextCtrl(panel,-1,"",wxPoint(120,20),wxSize(100,20));
14   editY=new wxTextCtrl(panel,-1,"",wxPoint(120,50),wxSize(100,20));
15   editS=new wxTextCtrl(panel,-1,"",wxPoint(120,80),wxSize(100,20));
16   editS->SetEditable(false);
17   editS->SetBackgroundColour(wxColour(200,200,200));
18   buCompute=new wxButton(panel,BUTTONCOMPUTE_ID,"CALCULER",wxPoint(240,50));
19 }
20 
21 void SommeWin::compute(wxCommandEvent &event)
22 {
23   double x,y,s;
24   bool okX,okY;
25   wxString sS, sX, sY;
26 
27   sX=editX->GetValue();
28   okX=sX.ToDouble(&x);
29   sY=editY->GetValue();
30   okY=sY.ToDouble(&y);
31 
32 if(okX && okY)
33   {
34     s=x+y;
35     sS.sprintf("%lf",s);
36     editS->SetValue(sS);
37   }
38 else
39   {
40     editS->SetValue("");
41     wxMessageBox("Données erronnées","ERREUR");
42   }
43 }
44 
45 BEGIN_EVENT_TABLE(SommeWin,wxFrame)
46     EVT_BUTTON(BUTTONCOMPUTE_ID,SommeWin::compute)
47 END_EVENT_TABLE()