Installation de wxWidgets sur Windows

Pour MinGW, le fichier de configuration est « \wxWidgets-2.8.10\build\msw\config.gcc » et le makefile est « \wxWidgets-2.8.10\build\msw\makefile.gcc ». Inutile de modifier le second. Seul le premier - « \wxWidgets-2.8.10\build\msw\config.gcc » - a pour objectif d'être paramétré. Les premières lignes de ce fichier concernent les différents paramètres de compilation sur lesquels nous n'intervenons pas. Nous allons commencer à nous intéresser aux directives de préprocessing commençant avec SHARED ?= 0. Toutes celles qui suivent ont la même forme. Le tableau suivant les récapitule en précisant leur objectif, la valeur par défaut et la valeur que nous allons choisir :

Une fois le fichier « \wxWidgets-2.8.10\build\msw\config.gcc » modifié, nous devons également intervenir sur le fichier « \wxWidgets-2.8.10\include\wx\msw\setup.h ». La différence ? « \wxWidgets-2.8.10\build\msw\config.gcc » gouverne la compilation des bibliothèques wxWidgets. « \wxWidgets-2.8.10\include\wx\msw\setup.h » est l'en-tête reprenant cette configuration dans vos projets. Il faut donc ajuster quelques définitions de directives pour maintenir la cohérence.
En l'occurrence, nous allons modifier les directives suivantes :

• #define wxUSE_UNICODE 1 : car nous voulons compiler avec UNICODE ;
• #define wxUSE_GLCANVAS 1 : car nous voulons compiler avec USE_OPENGL ;
• #define wxUSE_ODBC 1 : car nous voulons compiler avec USE_ODBC.

À cela, nous modifions les directives suivantes :

• #define wxUSE_STL 1 : wxWidgets définit ses propres classes pour les listes (wxList) et les tableaux (wxArray). En positionnant cette directive à 1, ces deux classes vont dériver de std::list et std::vector tirant ainsi profit de la STL ;
• #define wxUSE_STD_IOSTREAM 1 : grâce à cette directive, nous indiquons que nous souhaitons utiliser les flux de la bibliothèque standard quand cela est possible à la place des flux définis dans wxWidgets.

Pour compiler, nous supposons que la variable d'environnement PATH contient le chemin vers MinGW/bin. C'est dans ce répertoire que se trouvent le compilateur, l'éditeur de lien, le make, etc.
La compilation de wxWidgets en mode DEBUG s'écrit simplement :

mingw32-make -f makefile.gcc BUILD=debug

La compilation peut provoquer quelques avertissements. Il ne faut pas en tenir compte.
Les fichiers intermédiaires de la compilation (les .o) sont générés dans « wxWidgets-2.8.10\build\msw\gcc_mswud ». Le nom du répertoire intermédiaire est composé à partir de :

• le compilateur : 'gcc' ;
• la plateforme : 'msw' ;
• le mode DEBUG/RELEASE : 'd' pour debug, rien pour release ;
• le mode UNICODE : 'u' pour UNICODE.

Si nous avions choisi le mode non UNICODE, le répertoire aurait eu la forme « gcc_mswd ». Et comme nous allons le voir, la compilation en mode RELEASE crée le répertoire « gcc_mswu ».

La compilation ajoute un autre répertoire : « \wxWidgets-2.8.10\lib\gcc_lib ». Le schéma suivi pour le nom du répertoire ne prend en compte que le nom du compilateur utilisé. Toutes les versions des bibliothèques compilées avec un même compilateur (DEBUG, RELEASE, UNICODE, ANSI) sont mises dans ce même répertoire ce qui facilite le paramétrage de l'I.D.E. (ou du makefile si vous préférez mettre les mains dans le cambouis). Ce répertoire contient à sa base l'ensemble des bibliothèques générées :

• libwxbase28ud.a ;
• libwxbase28ud_net.a ;
• libwxbase28ud_odbc.a ;
• libwxbase28ud_xml.a ;
• libwxexpatd.a ;
• libwxjpegd.a ;
• libwxmsw28ud_adv.a ;
• libwxmsw28ud_aui.a ;
• libwxmsw28ud_core.a ;
• libwxmsw28ud_dbgrid.a ;
• libwxmsw28ud_gl.a ;
• libwxmsw28ud_html.a ;
• libwxmsw28ud_media.a ;
• libwxmsw28ud_qa.a ;
• libwxmsw28ud_richtext.a ;
• libwxmsw28ud_xrc.a ;
• libwxpngd.a ;
• libwxregexud.a ;
• libwxtiffd.a ;
• libwxzlibd.a.

Chaque bibliothèque porte un nom suivant le schéma :

lib[nom]ud.a

Certaines n'ont pas le suffixe 'u' dès lors qu'elles ne dépendent pas du critère UNICODE.
Toujours dans « \wxWidgets-2.8.10\lib\gcc_lib » un répertoire a été inséré avec les bibliothèques : « \wxWidgets-2.8.10\lib\gcc_lib\mswud ». Celui-ci contient un premier fichier : « build.cfg ». Ce fichier récapitule les options positionnées dans config.gcc. Cela permet de se souvenir quelle a été la configuration utilisée pour générer la version. À côté de ce fichier, un dernier répertoire « \wxWidgets-2.8.10\lib\gcc_lib\mswud\wx » contient un fichier « setup.h ». Il s'agit du fichier d'en-tête correspondant à la compilation. Nous verrons plus loin qu'il est important de bien configurer son I.D.E. de façon à ce que chaque ligne #include <wx/setup.h> corresponde à l'inclusion de ce fichier d'en-tête et non pas à celui dans « \wxWidgets-2.8.10\include\wx\msw\setup.h ».

De façon identique, la compilation en RELEASE s'écrit :

mingw32-make -f makefile.gcc BUILD=release

Les fichiers intermédiaires sont créés dans le répertoire « wxWidgets-2.8.10\build\msw\gcc_mswu ».
Les bibliothèques générées dans « \wxWidgets-2.8.10\lib\gcc_lib » sont les mêmes que précédemment, mais sans le suffixe 'd' pour DEBUG :

• libwxbase28u.a ;
• libwxbase28u_net.a ;
• libwxbase28u_odbc.a ;
• libwxbase28u_xml.a ;
• libwxexpat.a ;
• libwxjpeg.a ;
• libwxmsw28u_adv.a ;
• libwxmsw28u_aui.a ;
• libwxmsw28u_core.a ;
• libwxmsw28u_dbgrid.a ;
• libwxmsw28u_gl.a ;
• libwxmsw28u_html.a ;
• libwxmsw28u_media.a ;
• libwxmsw28u_qa.a ;
• libwxmsw28u_richtext.a ;
• libwxmsw28u_xrc.a ;
• libwxpng.a ;
• libwxregexu.a ;
• libwxtiff.a ;
• libwxzlib.a.

Le répertoire « \wxWidgets-2.8.10\lib\gcc_lib\mswu » contient le fichier « build.cfg » et le répertoire « wx » avec son fichier « setup.h ».

Pour MinGW nous proposons la configuration de Code::Block.

II-C-1. À partir d'un projet existant▲

Pour montrer la configuration pour un projet existant, nous allons commencer par créer ce projet. Sous Code::Block, nous choisissons le menu 'File/New/Project' :

Nous choisissons un projet vide :

Apparaît alors un assistant pour la création du projet :

Nous choisissons suivant et obtenons la page de saisie du titre du projet et du répertoire de création, le nom du projet et le fichier correspondant sont automatiquement construits avec ces deux informations :

La page suivante nous propose de choisir le compilateur : GNU GCC Compiler pour la compilation avec MinGW (nous supposons que vous avez correctement paramétré Code::Block pour aller chercher le compilateur MinGW correspondant).
Nous gardons cochées les cases pour la configuration Debug et Release :

Nous voilà maintenant avec notre projet vide. Nous allons le configurer pour l'utilisation de wxWidgets.
Dans le menu contextuel de notre nouveau projet, nous choisissons l'item 'Build Options…'

Nous commençons par positionner les paramètres pour toutes les configurations de génération. Il faut donc choisir le nom du projet en haut de l'arbre de gauche :

Nous choisissons l'onglet 'Search directories' et le sous- onglet 'Compiler'. Nous ajoutons « \wxWidgets-2.8.10\include ». Code::Block demande si le chemin doit être ajouté en relatif. Pour une bibliothèque, je préconise de choisir Non pour conserver le chemin en absolu :

Le même paramétrage doit être fait pour le chemin d'accès aux bibliothèques .lib précédemment générées. Cela se fait dans le sous-onglet Linker :

Maintenant, nous configurons le mode debug. Dans l'onglet de gauche, nous sélectionnons 'Debug' et dans la page de droite nous sélectionnons l'onglet 'Search directories' et le sous-onglet 'Compiler'. Nous ajoutons « \wxWidgets-2.8.10\lib\gcc_lib\mswud » et dans la boîte déroulante nous choisissons 'Prepend target options to project options'. De cette façon les fichiers (et setup.h) sont d'abord cherchés dans ce répertoire puis dans le répertoire précisé pour tout le projet :

L'opération est renouvelée pour la configuration Release avec le répertoire « \wxWidgets-2.8.10\lib\gcc_lib\mswu »

Nous positionnons l'option de compilation __WXDEBUG__ pour la version debug dans l'onglet 'Compiler settings' et le sous-onglet '#define' :

Et comme nous avons créé un projet vide, nous devons aussi spécifier les bibliothèques standards de Windows dans l'onglet 'Linker settings' pour l'ensemble des générations :

L'ordre d'inclusion est important. Il faut conserver celui proposé sans quoi des erreurs à l'édition de lien peuvent apparaître.

Nous en avons provisoirement fini pour les options. Il nous reste un dernier réglage sur le projet. Nous choisissons donc l'item 'Properties' du menu contextuel de notre projet :

Dans l'onglet 'Build targets', dans la boîte déroulante 'Type', nous choisissions 'GUI application'. Sans quoi, notre application est lancée à partir d'une console. Et, bien sûr, la même option est positionnée pour la version release :

Nous créons un fichier vide « main.cpp » pour une application minimale et nous ajoutons le code suivant :

 

Sélectionnez

#include "wx/wx.h"
    
    // Classe application :
    class MyApp : public wxApp
    {
    public:
       // Méthode virtuelle de démarrage de l'application :
        virtual bool OnInit();
    };
    
    // Notre fenêtre minimale :
    class MyFrame : public wxFrame
    {
    public:
        // Constructeur :
        MyFrame(const wxString& title);
    
        // 2 handler d'évènements
        void OnQuit(wxCommandEvent& event);
        void OnAbout(wxCommandEvent& event);
    
    private:
        // la table des évènements
        DECLARE_EVENT_TABLE()
    };
    
    IMPLEMENT_APP(MyApp)
    
    
    // Notre 'main' :
    bool MyApp::OnInit()
    {
        if ( !wxApp::OnInit() )
            return false;
    
        MyFrame *frame = new MyFrame(_T("Minimal wxWidgets App"));
        frame->Show(true);
    
        return true;
    }
    
    // IDs pour nos menus et contrôles :
    enum
    {
        Minimal_Quit = wxID_EXIT,
        Minimal_About = wxID_ABOUT
    };
    
    // La table des évènements de notre fenêtre :
    BEGIN_EVENT_TABLE(MyFrame, wxFrame)
        EVT_MENU(Minimal_Quit,  MyFrame::OnQuit)
        EVT_MENU(Minimal_About, MyFrame::OnAbout)
    END_EVENT_TABLE()
    
    
    // Le constructeur de notre classe de fenêtre :
    MyFrame::MyFrame(const wxString& title)
           : wxFrame(NULL, wxID_ANY, title)
    {
        // Ajoutons nos menus :
        wxMenu *fileMenu = new wxMenu;
        fileMenu->Append(Minimal_Quit, _T("&Quitter\tAlt-Q"), _T("Sortir du programme"));
        wxMenu *helpMenu = new wxMenu;
        helpMenu->Append(Minimal_About, _T("&A propos...\tF1"), _T("Affiche la boîte à propos"));
        // dans une barre de menu :
        wxMenuBar *menuBar = new wxMenuBar();
        menuBar->Append(fileMenu, _T("&Fichier"));
        menuBar->Append(helpMenu, _T("&Aide"));
        SetMenuBar(menuBar);
    
        // Une barre de statut :
        CreateStatusBar(2);
        SetStatusText(_T("Bienvenu sur notre premier projet wxWidgets avec MinGW !"));
    }
    
    
    // La gestion des évènements :
    
    void MyFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
    {
        Close(true);
    }
    
    void MyFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
    {
        wxMessageBox(wxString::Format(
                        _T("Bienvenu avec %s!\n")
                        _T("\n")
                        _T("Ceci est notre application minimale\n")
                        _T("s'exécutant sous %s."),
                        wxVERSION_STRING,
                        wxGetOsDescription().c_str()
                     ),
                     _T("A propos..."),
                     wxOK | wxICON_INFORMATION,
                     this);
    }

Pour cette application minimale, nous nous sommes contentés de reprendre l'exemple proposé par wxWidgets : « \wxWidgets-2.8.10\samples\minimal\minimal.cpp » que nous avons un peu simplifié pour le rendre plus lisible.

Avant de compiler, il nous reste deux réglages. Commençons par indiquer les bibliothèques wxWidgets nécessaires à la bonne compilation de notre projet. Ici, nous n'avons besoin que de core (libwxmsw28ud_core.a) et base (libwxbase28ud.a). Nous retournons donc dans la boîte de dialogue 'Project Build options', dans l'onglet 'Linker settings', pour la cible debug :

La configuration pour release est identique si ce n'est qu'il faut choisir les versions release de bibliothèques (libwxmsw28u_core.a et libwxbase28u.a).

Si nous compilons en l'état notre projet, MinGW génère une erreur :

 

Sélectionnez

error: converting to execution character set: Illegal byte sequence

Cette erreur vient des caractères accentués, tréma, accent circonflexe, c cédille et autres joyeusetés de la langue française. Pour corriger cela, nous devons indiquer que notre fichier source est écrit dans notre langue maternelle et que nous souhaitons que la correspondance adéquate soit faite pour la compilation. Il faut rajouter l'option de compilation '-finput-charset=iso-8859-15'. Je vous invite à consulter la documentation de GCC pour des informations plus précises à ce sujet. Cette option s'ajoute dans le sous-onglet 'Other options' de l'onglet 'Compiler settings' pour l'ensemble des cibles de compilation :

Voilà ! Nous pouvons enfin compiler notre application, demander à l'exécuter et contempler le premier fruit de notre labeur :

Vous pouvez trouver les sources de ce projet dans l'archive suivante : ProjetProjet

II-C-2. À partir d'un nouveau projet▲

Code::Block propose dans les projets un canevas pour la création de projets wxWidgets prenant ainsi en charge une partie de la configuration. Nous allons montrer comment procéder pour créer un tel projet et le configurer correctement.
Créons notre projet ! Sous Code::Block, nous choisissons le menu 'File/New/Project' :

Parmi les différents types de projets, nous optons pour 'wxWidgets project' :

L'assistant démarre :

Nous choisissons wxWidgets 2.8.x puisque c'est la version que nous venons d'installer :

Nous saisissons un nom à notre projet et un répertoire d'accueil :

Ces trois informations sont uniquement destinées aux commentaires insérés dans les fichiers sources générés par le canevas :

wxSmith et wxFormBuilder sont deux assistants pour la création des I.H.M. wxWidgets. Pour cet exemple, nous n'en choisissons aucun.
Nous créons un projet basé sur une boîte de dialogue :

Il faut maintenant indiquer à Code::Block où se trouvent nos fichiers wxWidgets. Code::Block attend le répertoire racine, il en déduit les répertoires d'inclusions des en-têtes et des bibliothèques à partir de cela :

Le panneau suivant nous permet de préciser que nous souhaitons une cible debug et release et que nous allons utiliser le compilateur GCC (nous supposons que vous avez correctement paramétré Code::Block pour aller chercher le compilateur MinGW correspondant) :

La première case est à cocher lorsque vous avez généré une version DLL de wxWidgets. La seconde si vous avez opté pour une version monolithique et la troisième pour UNICODE. Nos versions sont statiques, en plusieurs unités et en UNICODE : seule la troisième case reste cochée.
Nous ne souhaitons pas créer un projet vide et pour cet exemple nous nous passons des en-têtes précompilés.
N'oubliez pas de cocher la dernière case pour avoir accès aux options avancées :

Nous souhaitons pouvoir utiliser la version debug des bibliothèques en mode debug car nous sommes curieux de ce qu'il se passe : donc nous cochons la case relative à __WXDEBUG__. Notre application est une application IHM en release et en debug :

Enfin, cette dernière étape nous permet de préciser quelles sont les bibliothèques avec lesquelles nous souhaitons lier notre application. Par défaut, core (libwxmsw28u[d]_core.a) et base (libwxbase28u[d].a) sont rajoutées. C'est pour ça qu'elles n'apparaissent pas dans la liste. Pour notre exemple simple, nous n'avons pas besoin de bibliothèques supplémentaires :

Notre projet est généré. Code::Block a constuit cinq fichiers :

• wxProjetApp.h : fichier de déclaration de notre classe wxProjetApp dérivant de wxApp ;
• wxProjetApp.cpp : fichier de définition de la classe wxProjetApp ;
• wxProjetMain.h : fichier de déclaration de notre classe wxProjetDialog dérivant de wxDialog ;
• wxProjetMain.cpp : fichier de définition de la classe wxProjetDialog ;
• resource.rc : ficher de ressources (icônes).

Avant de lancer la compilation, nous devons positionner l'option '-finput-charset=iso-8859-15'. Je vous invite à consulter la documentation de GCC pour des informations plus précises à ce sujet. Cette option s'ajoute dans le sous-onglet 'Other options' de l'onglet 'Compiler settings' pour l'ensemble des cibles de compilation :

Nous pouvons maintenant lancer la compilation et exécuter notre programme :

Vous pouvez trouver les sources de ce projet dans l'archive suivante : ProjetProjet

Le répertoire « \wxWidgets-2.8.10\samples\ » regroupe des projets d'exemples illustrant différentes classes de wxWidgets. Chaque répertoire suit le même principe. Il contient le ou les fichiers sources ainsi que le makefile nécessaire à la compilation pour chaque compilateur. Générer des exemples devient chose facile.
Placez-vous dans le répertoire \wxWidgets-2.8.10\samples\access et tapez simplement la commande suivante :

mingw32-make -f makefile.gcc BUILD=debug

Cette commande ressemble en tout point à celle utilisée pour construire les bibliothèques.
La compilation d'un fichier exemple entraîne la création d'un répertoire gcc_mswud contenant l'exécutable généré.
Il est possible de générer tous les exemples en une seule fois. Il suffit de se positionner sur le répertoire « \wxWidgets-2.8.10\samples ». Celui-ci contient un makefile.gcc pilotant la construction de tous les exemples. Il ne nous reste donc qu'à demander cette compilation :

mingw32-make -f makefile.gcc BUILD=debug

1. Télécharger wxWidgetsTéléchargement de wxWidgets
2. Désarchiver wxWidgets (répertoire destination sans espace)

3. Modifier la configuration : \wxWidgets-2.8.10\build\msw\config.gcc :

    

   Sélectionnez

   UNICODE ?= 1
   USE_OPENGL ?= 1
   USE_ODBC ?= 1

4. Modifier le setup : \wxWidgets-2.8.10\include\wx\msw\setup.h :

    

   Sélectionnez

   #define wxUSE_UNICODE 1
   #define wxUSE_GLCANVAS       1
   #define wxUSE_ODBC          1
   #define wxUSE_STL 1
   #define wxUSE_STD_IOSTREAM  1

5. Compiler
   

    

   Sélectionnez

   cd \wxWidgets-2.8.10\build\msw\
   mingw32-make -f makefile.gcc BUILD=debug

6. Paramétrer Code::Block

   1. 'Project'/'Build Options…' - Item 'Projet' (racine arbre de gauche) - Onglet 'Search directories' - Sous-onglet 'Compiler' - Ajout de « \wxWidgets-2.8.10\include »
   2. 'Project'/'Build Options…' - Item 'Projet' (racine arbre de gauche) - Onglet 'Search directories' - Sous-onglet 'Linker' - Ajout de « \wxWidgets-2.8.10\lib\gcc_lib »
   3. 'Project'/'Build Options…' - Item 'Debug' (arbre de gauche) - Onglet 'Search directories' - Sous-onglet 'Compiler' - Ajout de « \wxWidgets-2.8.10\lib\gcc_lib\mswud » et modification de Policy vers 'Prepend target options to project options'
   4. 'Project'/'Build Options…' - Item 'Debug' (arbre de gauche) - Onglet 'Search directories' - Sous-onglet 'Compiler' - Ajout de « \wxWidgets-2.8.10\lib\gcc_lib\mswu » et modification de Policy vers 'Prepend target options to project options'