Cross Compilation Native d'application Qt depuis Linux/Unix Like

| Filipe Azeved (pasnox) | dourouc05 |

Un compilateur croisé (en anglais cross compiler) est un programme capable de traduire un code source en code objet ayant un environnement d'exécution (architecture matérielle, système d'exploitation) différent de celui où la compilation est effectuée. Ces compilateurs sont principalement utilisés en informatique industrielle.

Cet article va détailler la mise en place et l'utilisation d'un environnement de compilation multiplateforme. En effet, tout le monde n'a pas Windows dans sa poche et fournir un exécutable pour une architecture autre que la sienne peut parfois être un vrai calvaire. Aussi, au travers de ce tutoriel, nous allons mettre un place un tel système en utilisant MinGW32 et Qt4.

Version : Qt 4 (supérieure ou égale à Qt 4.0, peut être valable pour n'importe quelle autre bibliothèque)
Test : Kubuntu Feisty 7.04 beta (Qt 4.2.3)

N'hésitez pas à commenter cet article !
Commentez

- Titre : Cross Compilation Native d'application Qt depuis Linux/Unix Like

- Auteurs : Filipe Azeved (pasnox), dourouc05

- Parution : 14 avril 2007

- Mise à jour : 23 octobre 2010

- Licence : Copyright ® 2010 Filipe Azeved. 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.

Sommaire

- I. Prérequis

- II. Installation des paquets (système basé sur Debian)

- III. Installation de Qt 4 Windows

- IV. Configuration de Wine

- V. Création d'un mkspec

- VI. Divers

I - Prérequis

Le but de ce tutoriel est de montrer comment compiler une application Qt 4 pour Windows depuis Linux. Nous aurons donc besoin d'installer les logiciels suivant :

- MinGW32 (disponible normalement dans les paquets de votre distribution, il aura pour effet d'installer en plus les paquets suivant : MinGW32-binutils et MinGW32-runtime) ;

- Wine (pour ensuite tester votre application Windows sous Linux) ;

- une installation correcte de Qt 4 pour Windows, version MinGW32 ;

- une installation correcte de Qt 4 pour Linux.

II - Installation des paquets (système basé sur Debian)

La façon la plus simple d'installer MinGW32 et Wine est d'ouvrir une console (ou bien un gestionnaire de paquets, tel Adept) et d'y inscrire les commandes suivantes :

pasnox@pasnox-desktop:~$ sudo apt-get install mingw32
pasnox@pasnox-desktop:~$ sudo apt-get install wine

Note : les commandes d'installation ci-contre ne sont valables que pour Debian et distributions semblables (Ubuntu, Kubuntu...), veuillez donc vous référer à la documentation de votre distribution le cas échéant.

III - Installation de Qt 4 Windows

Maintenant que nous avons installé Wine, nous pouvons installer la version Windows de Qt 4 qui utilise MinGW32 (par exemple la version 4.2.3). Une fois téléchargée, pour l'installer, veuillez ouvrir une console et taper :

pasnox@pasnox-desktop:~$ wine chemin/de/qt/pour/windows/qt-win-opensource-4.2.3-mingw.exe

Je vous conseille d'installer la bibliothèque Qt dans un dossier dont le chemin ne contient pas d'espace, par exemple : C:\Development\Qt\4.2.3 (ce chemin sera utilisé par la suite).

Attention : il n'est pas nécessaire d'installer MinGW32 depuis l'installateur, même si celui-ci vous dit qu'il ne le trouve pas.

IV - Configuration de Wine

Maintenant que Qt 4 pour Windows est installé, il faut indiquer à Wine où trouver les bibliothèques Qt. Il s'agit en fait de modifier la base de registres, car les variables d'environnement ne sont pas accessibles. Pour ce faire, exécutez le logiciel Wine RegEdit.

pasnox@pasnox-desktop:~$ wine regedit

Rendez-vous dans la clé HKEY_CURRENT_USER. Si la clé Environment n'existe pas, veuillez la créer en faisant un clic droit sur la clé HKEY_CURRENT_USER, puis Nouvelle clé. Dans cette clé (Environment), la valeur nommé PATH devrait s'y trouver. Si celle-ci n'existe pas, créez-là : clic droit sur la clé Environment puis Nouvelle valeur chaine. Nommez-la PATH et donnez-lui la valeur du chemin d'installation des exécutables de Qt, c'est-à-dire C:\Development\Qt\4.2.3\bin.

Parfait, il manque maintenant une DLL, celle-ci se nomme mingwm10.dll et est disponible depuis les paquets installés. Pour ne pas être embêtés, nous allons la copier dans le dossier system32 de Wine, ce qui permettra d'exécuter des applications MinGW32 depuis Wine plus facilement.

Ouvrez une console et tapez :

pasnox@pasnox-desktop:~$ gunzip -c /usr/share/doc/mingw32-runtime/mingwm10.dll.gz > ~/.wine/drive_c/windows/system32/mingwm10.dll

Vous disposez maintenant d'une version de Wine prête pour l'exécution d'application Qt 4.

V - Création d'un mkspec

Pour compiler notre application, il va nous falloir créer un nouveau mkspec basé sur celui de win32-g++. Copiez donc le contenu grâce à la commande suivante (/usr/share/qt4 est le répertoire d'installation par défaut des paquets Qt4 sous une distribution à base de Debian) :

pasnox@pasnox-desktop:~$ sudo cp -r /usr/share/qt4/mkspecs/win32-g++ /usr/share/qt4/mkspecs/win32-x-g++

On a donc maintenant un nouveau mkspec nommé win32-x-g++ basé sur win32-g++. Il faut remplacer quelques variables contenues dans le fichier qmake.conf de ce nouveau mkspec, toujours dans la console tapez :

pasnox@pasnox-desktop:~$ sudo kate /usr/share/qt4/mkspecs/win32-x-g++/qmake.conf

Note : vous pouvez utiliser autre chose que kate comme éditeur de texte.

Les variables à remplacer sont en fait les compilateurs C et C++ (gcc et g++) ainsi que les commandes DOS. Voici les variables à modifier :

QMAKE_CC= i586-mingwmsvc-gcc
QMAKE_CXX= i586-mingwmsvc-g++
QMAKE_INCDIR= /usr/i586-mingwmsvc/include
QMAKE_INCDIR_QT= ~/.wine/drive_c/Development/Qt/4.2.3/include
QMAKE_LIBDIR_QT= ~/.wine/drive_c/Development/Qt/4.2.3/lib
QMAKE_LINK= i586-mingwmsvc-g++
# N'oubliez pas le -mwindows a la fin pour éviter d'avoir une console dans vos applications
QMAKE_LFLAGS= -mthreads -Wl,-enable-stdcall-fixup -Wl,-enable-auto-import -Wl,-enable-runtime-pseudo-reloc -mwindows
# les commandes DOS sont à remplacer par les commandes shell unix
#isEqual(MINGW_IN_SHELL, 1) {
QMAKE_DIR_SEP= /
QMAKE_COPY= cp
QMAKE_COPY_DIR= cp -r
QMAKE_MOVE= mv
QMAKE_DEL_FILE= rm -f
QMAKE_MKDIR= mkdir -p
QMAKE_DEL_DIR= rm -rf
#} else {
# Vous pouvez effacer la partie else qui ne sert a rien, ainsi que le isEqual du dessus
#}
# Enlever les .exe des executables
QMAKE_MOC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}moc
QMAKE_UIC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}uic
QMAKE_IDC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}idc
QMAKE_RCC = $$[QT_INSTALL_BINS]$${DIR_SEPARATOR}rcc
QMAKE_LIB= i586-mingw-ar -ru
QMAKE_RC= i586-mingwmsvc-windres
QMAKE_STRIP = i586-mingwmsvc-strip

Une fois ceci terminé, vous êtes enfin prêt à compiler votre application pour Windows !

Pour ce faire, vous utiliserez le mkspec win32-x-g++ lors de l'appel à qmake :

pasnox@pasnox-desktop:~$ qmake-qt4 -spec win32-x-g++ &amp;&amp; make

Note : il semblerait que, sous Mac OS X, il faille ajouter la plateforme à la ligne de commande qmake : -win32

Une fois compilée, l'application se trouve dans le dossier release en cas de compilation release ou bien dans le dossier debug (vous devrez compiler Qt en debug pour cela). Pour lancer l'application avec Wine :

pasnox@pasnox-desktop:~$ wine release/mon_application.exe

Il est à noter que le binaire aura besoin, tout comme une compilation via MinGW32 sous Windows, des DLL Qt (au minimum de QtCore pour une application console et QtCore/QtGui pour une application graphique simple) ainsi que de mingwm10.dll.

Note : pour supprimer la dépendance aux DLL de Qt, il est nécessaire de compiler Qt4 Windows en version statique mais c'est un problème qui ne sera pas traité ici.

Bonne cross compilation !

VI - Divers

Merci à nicolas581 et à jacques_jean pour leur relecture !