Documentation Qtfr - Installation

Environnement de développement pour Greenphone

Nicolas — Fri, 27 Apr 2007 22:34:00 +0200

Comment développer une application pour Greenphone ?
Comment installer l'environnement de développement pour Greenphone ?
Comment se lancer dans la programmation pour Greenphone ?

Cet article va nous permettre d'installer un environnement de programmation afin d'écrire des programmes pour le Greenphone. Il faut savoir qu'il est tout à fait possible de développer une application sans avoir un Greenphone.

L'installation et l'utilisation de cette environnement va vous permettre de tester vos applications pour Greenphone sans avoir à les transférer sur un Greenphone, et même de pouvoir tester l'envoie de SMS et de MMS.

Version : Qtopia4 (SDK pour Greenphone)
Auteur : Nicolas Arnaud-Cormos (nikikko)

Installation

L'installation en elle-même est relativement simple, tout l'environnement de développement est disponible sur une image vmware : l'environnement est exécuté dans une machine virtuelle.

Il est par contre nécessaire d'installer le logiciel VMWare player, qui est gratuit est disponible sur le site de VMware ou sur certaines distributions Linux.

ISO de la SDK

L'image vmware n'est pas disponible directement en téléchargement, il faut récupérer une image ISO et la graver pour pouvoir effectuer l'installation.

télécharger l'image ISO sur le site de Qtopia : page de téléchargement, choisissez la dernière disponible (actuellement : Greenphone Community SDK 4.2.1),
graver l'image sur un CD.

Note : la documentation est disponible sur le CD, sous le forme de fichier PDF (notamment greenphone_quickstart.pdf).

Installation de l'image vmware

L'image vmware est installable à partir du CD que vous venez de graver.

Sous Windows

Normalement, le programme d'installation se lance automatiquement. Si ce n'est pas le cas, allez sur le CD et lancer l'exécutable autorun.exe.

suivre les indications de l'installeur... normalement, pas de problème à cette étape.

Sous Linux

aller sur le cdrom : cd /mnt/cdrom ou cd /media/cdrom
lancer l'installation de l'image : sh install.sh, et suiver les instructions de l'installeur
lancer l'image vmware en allant de le répertoire d'installation avec la commande suivante :

 vmware greenphone.vmx

Environnement de développement

Ca y est, vous avez installer l'environnement de développement ! Bravo ! Une fois lancé, vous avez un bureau KDE/Linux en 1024x768 (pour la petite histoire, c'est une Debian Etch personnalisée) :

Je vais maintenant détailler quelques personnalisation qui me semblent être indispensable pour développer correctement.

Utilisateurs

Deux utilisateurs sont prédéfinis :

user (mot de passe user) : l'utilisateur sous lequel vous êtes connecté
root (mot de passe root) : l'administrateur

Configuration du clavier

Première chose à faire, changer la configuration du clavier pour ceux qui ont un clavier azerty (vous l'avez peut-être remarqué, mais c'est configuré pour un clavier qwerty) :

aller dans le menu K (en bas à gauche) > Settings > Control Center
aller dans Regional & Accessibility > Keyboard Layout
modifier comme indiqué dans la capture d'écran suivante :

Modification de la résolution

Je ne sais pas vous, mais moi j'ai la chance de ne pas avoir un écran 1024x768... il est donc nécessaire de modifier la résolution :

ouvrir une console (icône Konsole) et taper les commandes suivantes (la deuxième commande va demander le mot de passe de l'utilisateur root) :

cd /etc/X11
sudo nano xorg.conf

modifier dans la section "Screen" la taille :

    Subsection "Display"
        Depth       24
        Modes       "1024x768"
        ViewPort    0 0
    EndSubsection

redémarrer l'image vmware pour prendre les modifications en compte

Installation de Subversion

Personnellement, je vois mal un environnement de développement sans un gestionnaire de versions, j'ai donc installer Subversion. Pour cela, ouvrez une console et tapez les lignes suivantes :

sudo apt-get update
sudo apt-get install subversion

La première ligne entraîne des erreurs chez moi, mais ce n'est pas grave, l'installation se passe bien au final.

Exécution du programme d'exemple

Afin de vérifier le bon fonctionnement, nous allons compiler et exécuter un programme d'exemple (qui est fourni dans le SDK) :

ouvrir une console (cliquez sur l'icône de la console)
rentrer les commandes suivantes :

source /opt/Qtopia/SDK/scripts/devel-x86.sh
cd ~/projects/application
qtopiamake
make clean
make
make install
gph -rescan

Note : lors de l'exécution de la dernière ligne, j'ai chez moi plusieurs erreurs (QWSSocket::connectToLocalFile could not connect:: Connection refuse), mais ça ne semble pas gêner l'exécution du programme)

cliquer sur l'icône runqpe pour lancer Qtopia dans Qvfb avec le skin Greenphone
naviguer dans le menu (Applications->Example) ou taper ./example dans la console pour lancer l'exemple

Amusez-vous bien avec le Greenphone !

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

P@sNox — Sat, 14 Apr 2007 10:01:00 +0200

Qu'est ce que la cross compilation ?
Comment créer un executable pour une architecture différente ?
Comment créer un exécutable Windows sous Linux ?

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 detailler la mise en place et l'utilisation d'un environnement de compilation multi plateforme. En effet, tout le monde n'a pas Windows dans sa poche ( et heureusement :D ), et fournir un executable pour une architecture autre que la sienne peut parfois etre un vrai calvaire.
Aussi à travers de ce tutoriel, nous allons mettre un place un tel systeme en utilisant mingw32 et Qt4.

Version : Qt4 (supérieur ou égal à Qt 4.0, peut etre valable pour n'importe quelle autre librairie)
Auteur : Filipe Azevedo (pasnox)
Test : Kubuntu Feisty 7.04 beta (Qt 4.2.3)

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 mingw
Une installation correcte de Qt 4 pour Linux

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 paquet, tel Adept) et d'y inscrire les commandes suivante :

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

Note : les commandes d'installation de paquet ci contre ne sont valables que pour debian/ubuntu/kubuntu, ou tout systeme basé sur debian, veuillez vous réferrer à la documentation de votre distribution linux le cas échéant.

Installation de Qt 4 Windows

Maintenant que nous avons installé Wine, nous pouvons installer la version Windows de Qt 4 qui utilise mingw (par exemple la version 4.2.3) Une fois téléchargé, 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 librairie Qt dans un dossier dont le chemin ne contient pas d'espace, par exemple : C:\Development\Qt\4.2.3 (chemin qui sera utilisé par la suite).

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

Configuration de Wine

Maintenant que Qt 4 pour Windows est installé, il faut indiquer à Wine où trouver les librairies 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écuter 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 clique 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à : clique 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é, nous allons la copier dans le dossier system32 de Wine, ce qui permettra d'executer des applications mingw 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.

Création d'un mkspec

Pour pouvoir 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 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 a modifier :

QMAKE_CC		= i586-mingw32msvc-gcc
QMAKE_CXX		= i586-mingw32msvc-g++
QMAKE_INCDIR		= /usr/i586-mingw32msvc/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-mingw32msvc-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 commande 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-mingw32-ar -ru
QMAKE_RC                = i586-mingw32msvc-windres
QMAKE_STRIP             = i586-mingw32msvc-strip

Une fois terminée, vous êtes enfin prêt à compiler votre application pour windows :)

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

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

Note : Il semblerait que sous mac, il faille ajouter la platforme à 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 aurez besoin de compiler Qt en debug pour cela )

Pour lancer l'application grace à 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 dlls de Qt, il est nécessaire de compiler Qt4 Windows en version statique, mais c'est un problème qui n'est pas traité ici... peut-être plus tard.

Bonne cross compilation !

Autres sources

Vous trouverez ici d'autres informations sur la cross-compilation ici :

Cross-compilation C++/QT4 sur le forum, par Amalsek,
Cross-compilation vers un environnement Win32,
Cross compiling Qt/Win Apps on Linux.

Compiler Qt 4 avec Visual C++ 2005

Visiteur — Mon, 26 Mar 2007 21:14:00 +0200

Installation de Qt4 avec Visual C++ 2005

La version Open-Source de Qt4 n'est compatible officiellement sous Windows qu'avec le compilateur mingw. Il est toutefois possible d'utiliser Visual C++.

Sachez toutefois que cette installation n'est pas supporté officiellement.

Auteur : Aurélien Regat-Barrel
Version : Qt4 Windows
Test : Qt 4.1.1

L'article est disponible sur le site de developpez.com : http://arb.developpez.com/qt4/vc++/...

Cet article a pour but de faciliter la compilation Qt/Windows Open Source Edition avec Microsoft Visual C++ 2005. Il présente aussi de manière détaillée le processus de compilation et le principe de configuration de cette bibliothèque.

Vous trouverez également un article sur notre forum : http://forum.qtfr.org/viewtopic.php...