Partie I : Programmer ma première application avec wxWidgets

Dans un précédent article nous avons vu : l'installation de wxWidgets dans l'EDI de C++ Builder 6, pour ne pas rester sur notre faim, et comprendre un peu le fonctionnement de cette bibliothèque, nous allons, à l'aide d'un exemple, matérialisé par une application, composée d'une fenêtre munie de deux boutons.

Dans cet article nous aborderons la structure d'un programme élaboré avec la bibliothèque wxWidgets et le traitement des événements.

Je vous propose de regarder tout de suite le code de l'exemple.

II-A. wxwin1.h▲

#ifndef wxWin1H
#define wxWin1H
#define ID_APP_QUIT 1
#define ID_CHG_TITRE 2
//------------------------------------------------------------------------------
class TMyApp : public wxApp
{
public:
    virtual bool OnInit();
};
//------------------------------------------------------------------------------
class TMyFrame : public wxFrame
{
public:
    TMyFrame(const wxString& title, const wxPoint& pos, const wxSize& size,
                                           long style = wxDEFAULT_FRAME_STYLE);
    void OnQuit(wxCommandEvent& event);
    void OnChgTitre(wxCommandEvent& event);
private:
    wxButton *MonBouton;
    wxButton *MonBouton2;

DECLARE_EVENT_TABLE()
};
//------------------------------------------------------------------------------
#endif //wxWin1H

II-B. wxwin1.cpp▲

#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif
//------------------------------------------------------------------------------

#include "wxWin1.h"

BEGIN_EVENT_TABLE(TMyFrame, wxFrame)
    EVT_BUTTON(ID_APP_QUIT,  TMyFrame::OnQuit)
    EVT_BUTTON(ID_CHG_TITRE,  TMyFrame::OnChgTitre)
END_EVENT_TABLE()

IMPLEMENT_APP(TMyApp)
//------------------------------------------------------------------------------
bool TMyApp::OnInit()
{
    TMyFrame *frame = new TMyFrame("Ma première application",
                                           wxPoint(150, 150), wxSize(480, 360));
    frame->Show(true);
    return true;
}
//------------------------------------------------------------------------------
TMyFrame::TMyFrame(const wxString& title, const wxPoint& pos, const wxSize& size,
                        long style) : wxFrame(NULL, -1, title, pos, size, style)
{
  SetIcon(wxICON(monicone));
  SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
  MonBouton = new wxButton(this,ID_CHG_TITRE,"Chgt Titre", wxPoint(20,20),
                                                                 wxDefaultSize);
  MonBouton2 = new wxButton(this,ID_APP_QUIT,"Quitter", wxPoint(20,60),
                                                                 wxDefaultSize);
}
//------------------------------------------------------------------------------
void TMyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    Close(true);
}
//------------------------------------------------------------------------------
void TMyFrame::OnChgTitre(wxCommandEvent& WXUNUSED(event))
{
    SetTitle("Nouveau Titre");
}
//------------------------------------------------------------------------------

Pour créer une application fenêtrée, nous utiliserons une classe nommée dans l'exemple TMyFrame descendant de la classe wxFrame. Elle nous servira de modèle pour la fenêtre principale de l'application.

class TMyFrame : public wxFrame
{
public:
    TMyFrame(const wxString& title, const wxPoint& pos, const wxSize& size,
                                           long style = wxDEFAULT_FRAME_STYLE);
//...
};

Pour créer cette fenêtre, nous aurons besoin d'un objet encapsulant l'application. Ce sera l'affaire de la classe TMyApp classe dérivant de wxApp. Nous y redéfinirons sa fonction membre OnInit.

class TMyApp : public wxApp
{
public:
    virtual bool OnInit();
};

Cette méthode est appelée automatiquement à la création de l'application et nous servira à créer notre fenêtre principale :

bool TMyApp::OnInit()
{
    TMyFrame *frame = new TMyFrame("Ma première application",
                                           wxPoint(150, 150), wxSize(480, 360));
    frame->Show(true);
    return true;
}

Nous y créons une instance de la fenêtre principale de l'application à l'aide de l'opérateur new, avec comme paramètres dans le constructeur : le titre de la fenêtre, sa position, sa taille. Son prototype avait un paramètre supplémentaire : style comme son nom l'indique il sert à modifier le style de la fenêtre. (Voir la liste dans le fichier d'aide: classe->wxFrame)

Puis nous la rendons visible à l'aide de sa méthode Show.

Enfin la méthode OnInit doit retourner la valeur true, sinon l'application se ferme.

Vous cherchez peut-être l'instanciation de la classe TMyApp, ne cherchez pas, ceci est fait dans une macro prédéfinie : IMPLEMENT_APP(TMyApp).

Nous allons maintenant ajouter nos deux boutons à la fenêtre principale et traiter les événements déclenchés par le clic de ces boutons.

class TMyFrame : public wxFrame
{
public:
    TMyFrame(const wxString& title, const wxPoint& pos, const wxSize& size,
                                           long style = wxDEFAULT_FRAME_STYLE);
    void OnQuit(wxCommandEvent& event);
    void OnChgTitre(wxCommandEvent& event);
private:
    wxButton *MonBouton;
    wxButton *MonBouton2;

DECLARE_EVENT_TABLE()
};

Dans le prototype de la classe on déclare deux pointeurs sur des objets de type wxButton : MonBouton et MonBouton2, deux méthodes : OnQuit et OnChgTitre qui seront appelées par les événements clic des boutons et une macro : DECLARE_EVENT_TABLE(). Cette macro déclare la présence d'une table d'événement :

BEGIN_EVENT_TABLE(TMyFrame, wxFrame)
    EVT_BUTTON(ID_APP_QUIT,  TMyFrame::OnQuit)
    EVT_BUTTON(ID_CHG_TITRE,  TMyFrame::OnChgTitre)
END_EVENT_TABLE()

C'est dans cette table que les méthodes OnQuit et OnChgTitre sont liées aux événements clic des boutons par l'intermédiaire de constantes symboliques:

#define ID_APP_QUIT 1
#define ID_CHG_TITRE 2

Voyons maintenant l'implémentation du constructeur de TMyFrame :

TMyFrame::TMyFrame(const wxString& title, const wxPoint& pos, const wxSize& size,
                        long style) : wxFrame(NULL, -1, title, pos, size, style)
{
  SetIcon(wxICON(monicone));
  SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE));
  MonBouton = new wxButton(this,ID_CHG_TITRE,"Chgt Titre", wxPoint(20,20),
                                                                 wxDefaultSize);
  MonBouton2 = new wxButton(this,ID_APP_QUIT,"Quitter", wxPoint(20,60),
                                                                 wxDefaultSize);
}

C'est ici que l'on crée nos boutons avec l'opérateur new. Sous wxWidgets tous les objets fenêtrés doivent être instanciés de cette façon. Chaque constructeur des boutons recevra comme paramètres : sa fenêtre parent, sa constante d'événement vue précédemment, sa position, sa taille.

SetBackgroundColour sert à changer la couleur du fond, ici obtenue à l'aide de la méthode static wxSystemSettings::GetColour renvoyant une couleur système ici c'est la couleur des boutons.

Nous affectons une icône personnalisée à la fenêtre à l'aide de la méthode SetIcon qui reçoit en paramètre une macro destinée à charger l'icône nommée dans l'exemple 'monicone' depuis les ressources de l'application. Sous Windows cette icône doit être dans un fichier ressources à ajouter au projet.

monicone ICON "mondrian.ico"

L'icône à ajouter aux ressources étant ici dans le fichier « mondrian.ico ».

Pour terminer notre première application wxWidgets et ne pas laisser nos deux boutons sans rien faire nous allons implémenter les deux méthodes de TMyFrame OnQuit et OnChgTitre gérant leurs événements clic :

void TMyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    Close(true);
}
//------------------------------------------------------------------------------
void TMyFrame::OnChgTitre(wxCommandEvent& WXUNUSED(event))
{
    SetTitle("Nouveau Titre");
}

Dans la méthode OnQuit on ferme l'application par l'appel de la méthode Close. La méthode OnChgTitre appelle SetTitle pour changer le titre de la fenêtre principale.

Maintenant vous allez me dire : Où est la destruction des objets créés ? Et bien vous n'avez pas à vous en préoccuper, ni pour les boutons ni pour la fenêtre. C'est le cas pour tous les objets fenêtrés créés avec la bibliothèque. C'est l'application qui s'en occupe. Les objets fenêtrés reçoivent dans le premier paramètre de leur constructeur un parent : this dans le cas de nos boutons, la destruction de leur parent entraine donc leur propre destruction.

Ce document relate la réalisation d'une application simple. J'ai réalisé les compilations dans l'EDI de C++ Builder, wxWidgets étant installé comme vu dans l'article : « Installation de wxWidgets dans l'EDI de C++ Builder ».

Pour les autres compilateurs, veuillez vous référer à leur documentation respective ainsi qu'à la documentation de wxWindows.

À bientôt,

CGi

Avec la contribution d'Alacazam pour la relecture.