Partie I : Programmer ma première application avec wxWidgets

Dans la première partie de cette série de tutoriels, vous allez apprendre à créer une première application basique avec la bibliothèque wxWidgets.

Un espace de dialogue vous est proposé sur le forum. N'hésitez pas à apporter vos commentaires sur le lien ci-dessous, si vous avez des remarques concernant ce tutoriel.

Commentez Donner une note à l'article (5)

Article lu   fois.

L'auteur

Profil ProSite personnel

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

I. Introduction :

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.

Image non disponible

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

II. Code source :

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

II-A. wxwin1.h :

 
Sélectionnez
#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 :

 
Sélectionnez
#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");
}
//------------------------------------------------------------------------------

III. Explication :

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.

 
Sélectionnez
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.

 
Sélectionnez
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 :

 
Sélectionnez
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éfini : IMPLEMENT_APP(TMyApp).

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

 
Sélectionnez
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 click des boutons et une macro : DECLARE_EVENT_TABLE(). Cette macro déclare la présence d'une table d'événement :

 
Sélectionnez
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 click des boutons par l'intermédiaire de constantes symboliques:

 
Sélectionnez
#define ID_APP_QUIT 1
#define ID_CHG_TITRE 2

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

 
Sélectionnez
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.

Fichier resource.rc:
Sélectionnez
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 click :

 
Sélectionnez
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.

IV. Remarques sur ce document :

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.

A bientôt,

CGi

Avec la contribution d'Alacazam pour la relecture.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Copyright © 2016 CGi. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.