Utiliser Qt avec Visual Studio 2010

Tout d'abord, il faut créer un nouveau projet, mais pas de projet « Console » comme vous en aviez l'habitude. Maintenant, il faut créer un projet « Makefile ». Dans l'assistant de création de projets, cliquez sur « Général » et choisissez « Projet Makefile ».

Entrez un nom pour le projet et cliquez sur OK.

Une nouvelle fenêtre apparaît :

Cliquez sur Suivant.

On arrive dans la partie configuration de la génération « Debug ». C'est la version qui est utilisée par le développeur pour le débogage de l'application.

C'est ici qu'il va falloir renseigner quelques champs, ceux de la partie de gauche pour être exact.

Nous allons renseigner les commandes de compilation que nous devrions taper à la main dans la console.

Pour le premier champ, Ligne de commande « Build », il faut mettre : « qmake & nmake ». Dans « Ligne de commande » « ReBuild », il faut mettre « qmake -project & qmake & nmake ». Ces commandes seront appelées lors de la génération du projet.

Dans le champ « Commandes de nettoyage », ne mettez rien (en tout cas, pour l'instant). En effet, en temps normal, je vous aurais dit de mettre « nmake clean », pour effacer les fichiers générés lors de la compilation et qui sont inutiles pour la suite. Cependant, il y a un bogue connu de Visual Studio 2010 qui fait qu'il n'arrive pas à exécuter la commande. Ça devrait être corrigé dans le prochain service pack.

Enfin, dans « Sortie », mettez avant le nom de l'exécutable « Debug\ ». Si vous ne mettez pas cela et si vous essayez de lancer le débogage, vous aurez ceci :

Donc, si vous avez tout bien suivi, vous avez ceci devant vos yeux :

Bien. Cliquez sur « Suivant ». Ici, c'est pour la version « Release ». C'est la version destinée à la distribution. Comme il n'y a pas d'informations pour le débogage, cette version est un peu moins lourde.

Ici, c'est très simple : ce sont les même paramètres que précédemment, à la différence près que « nmake » devient « nmake release » et que le répertoire pour le fichier de sortie est « Release\ ».

Vous devez donc avoir ceci :

Tout est presque prêt. Il y a juste une manipulation à connaître pour pouvoir compiler. Pour compiler « Build », l'EDI va exécuter la commande « qmake & nmake ». Seulement, lors de la toute première compilation, le fichier .pro n'existe pas encore. C'est la commande « qmake -project » qui génère ce fichier. Avant de lancer la première génération, il faut régénérer (« ReBuild ») le projet.

Mais pourquoi ne pas mettre « qmake -project » dans la commande de génération ?
Eh bien tout simplement parce que le fichier .pro serait écrasé à chaque compilation, ce qui entraînerait la perte des ajouts effectués à la main, comme le chargement de modules (WebKit, par exemple).

Si vous effectué une régénération, pour ajouter les nouveaux fichiers au fichier .pro, il faudra ajouter manuellement les éventuelles modifications déjà effectués, comme le chargement de modules.

Avant de commencer à développer, il faut pouvoir compiler. Pour que Visual Studio y arrive, il faut lui dire où se trouvent les fichiers sources de Qt. Pour faire cela, effectuez un clic droit sur le projet et sélectionnez « Propriétés », comme ceci :

Ensuite, sélectionnez « Propriétés de configuration » puis « Répertoires VC++ ». Dans la liste déroulante « Configuration », sélectionnez « Toutes les configurations ». En pratique, cela sert à avoir une configuration différente si on travaille en mode « Debug » ou « Release ». Pour nous, comme c'est pour réussir la compilation, ce sont les mêmes paramètres.

Vous avez normalement ceci devant vos yeux :

Bien. Maintenant, dans la liste, sélectionnez le premier : « Répertoires d'exécutables » et cliquez sur « <Modifier…> ».

Ici, nous allons ajouter un nouveau chemin, car oui, ce qu'il y figure sont des chemins d'accès pour chercher des fichiers exécutables, comme « qmake ». En fait, ça correspond à la variable PATH que l'on a modifiée tout à l'heure.

Pour ajouter un nouveau chemin, cliquez sur  et tapez « $(QTDIR)\bin ».

Pourquoi « $(QTDIR) » ?
Eh bien, vous vous souvenez, on a défini une nouvelle variable d'environnement. On l'avait appelée « QTDIR ». Ici, « $(QTDIR) » sera remplacée par le contenu de cette variable. Mais si vous mettez par exemple « C:\Qt\4.7.0\bin » ça marchera aussi, à condition que Qt soit installé dans ce répertoire.
C'est là tout l'intérêt des variables d'environnement. Une fois définie, elle est la même chez tout le monde, indépendamment du répertoire d'installation.

Après validation, sélectionnez « Répertoires Include ». Vous l'aurez deviné, on va maintenant dire à Visual Studio où chercher les fichiers d'entête correspondant à Qt.

Pour Qt, ces fichiers sont dans « C:\Qt\4.7.0\include » si vous avez mis les fichiers dans ce répertoire-là.

Eh, mais on ne peut pas utiliser notre variable d'environnement ?
C'est bien ! Bien sûr que l'on peut… et on va même le faire.

Donc, comme avant, créez une nouvelle ligne et rentrez « $(QTDIR)\include ».

Maintenant, il nous faut encore créer une dernière variable : celle pour les bibliothèques (les fameux fichiers .lib).

Dans la liste déroulante, sélectionnez « Répertoires de bibliothèques ». Ceux-ci se trouvent dans « $(QTDIR)\lib ».

Bien, tout est prêt, vous pouvez cliquer sur « Appliquer » puis « OK » et commencer à coder.

Normalement, si vous essayez de compiler ce code et s'il n'y a pas d'erreur, cela voudra dire que les étapes précédentes ont bien fonctionné.

#include <QtGui/qapplication.h>
#include <QtGui/qpushButton.h>
 
int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
 
    QPushButton bouton("Bonjour les Zéros !");
    bouton.show();
 
    QObject::connect(&bouton, SIGNAL(clicked()), &app, SLOT(quit()));
 
    return app.exec();
}

Pourquoi dans les includes, tu mets QtGui/ avant le nom de classe ?

Eh bien, c'est la seule façon de bénéficier de l'IntelliSense de Visual Studio. L'IntelliSense est l'autocomplétion de Visual Studio. Cela permet d'afficher les méthodes disponibles pour un objet en tapant par exemple bouton. juste après sa création. On verra alors à l'écran :

La seule condition pour que ça fonctionne est qu'il faut générer la solution (touche F7) lors de chaque ajout d'include. En fait, QtGui est le module où se trouve le fichier d'include. Pour connaitre le module, il suffit de regarder dans la documentation de la classe.

Vous n'êtes pas sans savoir que, pour utiliser un programme Qt, il faut plusieurs DLL. Deux sont obligatoires : QtGui4.dll et QtCore4.dll, ainsi qu'une DLL de MinGW si vous utilisez ce compilateur-là. Pour le compilateur de Visual Studio, il y en a également deux, mais cela dépend si le projet est généré en mode Debug ou en mode Release.

Si c'est en mode debug, il faut utiliser les DLL qui se terminent par la lettre d (comme debug).

Pour la génération en mode release, ce sont les DLL qui ne se terminent pas par la lettre d.

Elles se trouvent toutes dans le répertoire C:\Qt\4.7.0.

Si vous lancez votre logiciel en mode débogage depuis Visual Studio, vous n'avez pas besoin de ces DLL.