Presentation-Qt 20 21

Cours Qt
Module IHM
SICOM, S8
2019 - 2020
1 Présentation
2 Programmation évènementielle
3 Structure générale
4 Les modules
5 Application GUI
6 Élément graphique
7 Mécanisme signal/slot
8 Projet Qt
9 Environnement deDéveloppement Intégré (EDI)
10 Positionnement deswidgets
11 Transition Qt4 →− Qt5
12 Documentation
SICOM, S8 Cours Qt 2 / 69
Présentation
Qu’est-ce que Qt ?
Qt est une bibliothèque logicielle orientée objet (API)
développée en C + + par Qt Development Frameworks, filiale de
Digia.
API désigne : Application Programming Interface.
Qt est une plateforme de développement d’interfaces

graphiques GUI (Graphical User Interface) fournie à l’origine par la
société norvégienne Troll Tech, rachetée par Nokia en février 2008
puis cédée intégralement en 2012 à Digia (www.qt.io).
Qt fournit un ensemble de classes décrivant :
des éléments graphiques (widgets) et
des éléments non graphiques : accès aux données (fichier, base

de données), connexions réseaux (socket), gestion du multitâche
(thread ), XML, etc.
SICOM, S8 Cours Qt 3/ 69
Présentation
Qu’est-ce que Qt ?
Le XML, pour Extensible Markup Language, désigne :
Un langage informatique (ou métalangage pour être plus précis) utilisé, entre
autres, dans la conception des sites Web et pour faciliter les échanges
d'informations sur Internet.
Il s'agit, en quelque sorte, d'une version améliorée du langage HTML avec la

création illimitée de nouvelles balises.
Présentation
Qu’offre Qt ?
Qt permet la portabilité des applications par simple recompilation du
code source.
Les environnements supportés sont les Unix (dont Linux), Windows et
Mac OS X.
De grandes entreprises utilisent Qt : Google, Adobe Systems, Asus,

Samsung, Philips, ou encore la NASA et bien évidemment Nokia.
Qt est une bibliothèque sur laquelle repose l’environnement graphique

KDE, l’un des environnements de bureau les plus utilisés dans le monde
Linux.
KDE est un grand projet ayant pour but de:
construire un environnement graphique complet, facile à utiliser et

entièrement libre. Voir aussi les licences Qt : www.qt.io/licensing/
Présentation
Que permet Qt ?
Qt est principalement dédiée au développement d’interfaces

graphiques en fournissant des éléments prédéfinis appelés widgets
(pour windows gadgets).
Les widgets peuvent être utilisés pour créer ses propres fenêtres et
boîtes de dialogue complètement prédéfinies
(ouverture/enregistrement des fichiers, progression d’opération,
etc).
Les interactions avec l’utilisateur sont gérées par un mécanisme

appelé signal/slot. Ce mécanisme est la base de la
programmation événementielle des applications basées sur Qt.
Programmation évènementielle
Qu’est-ce que la programmation évènementielle?
La programmation événementielle est une programmation basée sur

les événements.
Le programme sera principalement défini par ses réactions aux

différents événements qui peuvent se produire,
c’est-à-dire des changements d’état, par exemple

l’incrémentation d’une liste, un mouvement de souris ou un
appui sur une touche de clavier etc.
La programmation événementielle est architecturée autour d’une

boucle principale fournie et divisée en deux sections : la première
section détecte les événements, la seconde les gère.
Quel est le principe ?
Pour chaque évènement à gérer, il faut lui associer une action à

réaliser (le code d’une fonction ou méthode) : c’est le gestionnaire
d’évènement (handler ).
Ensuite, à chaque fois que l’évènement sera détecté par la boucle

d’évènement, le gestionnaire d’évènement sera alors exécuté.
Comment ça marche sous Qt ?

La programmation évènementielle des applications Qt est basée sur un
mécanisme appelé signal / slot :
un signal est émis lorsqu’un événement particulier se produit.
Les classes de Qt possèdent de nombreux signaux prédéfinis mais

vous pouvez aussi hériter de ces classes et leur ajouter vos propres
signaux.
un slot est une fonction qui va être appelée en réponse à un signal
particulier.
De même, les classes de Qt possèdent de nombreux slots prédéfinis,
mais il est très courant d’hériter de ces classes et de créer ses
propres slots afin de gérer les signaux qui vous intéressent.
L’association d’un signal à un slot est réalisée par une connexion

avec l’appel connect().
Comment ça marche sous Qt ?
SICOM, S8 Cours 10 / 69
Structure générale deQt
Quelle est l’organisation des classes Qt ?

L’API Qt est constituée de classes aux noms préfixés par un Q et
dont chaque mot commence par une majuscule (QLineEdit,
QLabel, ...).
L’ensemble des classes est basé sur l’héritage. La classe QObject est
la classe mère de toutes les classes Qt.
En dérivant de QObject, un certain nombre de spécificités Qt sont
hérités, notamment : le mécanisme signal/slot pour la
communication entre objets, une gestion simplifiée de la mémoire,
etc.
Les objets Qt (ceux héritant de QObject) peuvent s’organiser

d’eux-mêmes sous forme d’arbre d’objets.
Ainsi, lorsqu’une classe est instanciée, on peut lui définir un objet

parent.
Comment écrire une classe Qt ?

Pour bénéficier des spécificités de Qt, il faudra hériter de QObject ou
d’une classe fille de QObject :
c l a s s MaClasse : public QObject

{
Q_OBJECT
pu b l i c :
MaClasse( QObject *parent=0 ) : QObject(parent) { }
P ri va t e signals:
void send( int ) ; / / un signal (ne pas définir)
public s l o t s :
void re ce i ve ( int ) ; / / un s l o t ( à définir)
};

Houston ? On a un problème !
Les spécificités Qt nécessitent l’utilisation du moc, un outil fourni par

Qt, pour obtenir du code 100% C + + .

Comment accéder aux propriétés d’une classe Qt ?
Un objet Qt peut avoir des propriétés.
Toutes les propriétés sont des attributs de la classe que l’on peut lire
et éventuellement modifier.
Qt suit cette convention pour le nom des accesseurs : propriete()

pour lire la propriété et setPropriete() pour la modifier.
Pour connaître l’ensemble des classes, méthodes et propriétés, signaux

et slots de Qt, il faut consulter la documentation en ligne :
http://doc.qt.io/.
Pour pouvoir utiliser une classe, il faut inclure sa déclaration :

#include <QLineEdit>
C’est mieux avec un exemple !
/ / Pour l i r e l a chaîne de caractères s a i s i e dans un QLineEdit

QString unTexte = monLineEdit.text();
/ / Pour modifier l a chaîne de caractères d’un QLineEdit

monLineEdit.setText("mon t e x t e " ) ;

Les modules
Qu’est-ce que les modules?

Depuis la version 4, Qt sépare sa bibliothèque en modules.
Un module regroupe un ensemble de classes Qt.
Les principaux modules :

QtCore : pour les fonctionnalités non graphiques utilisées par les
autres modules ;
QtGui : pour les composants graphiques (qt4),
Maintenant QtWidgets (qt5) ;
QtNetwork : pour la programmation réseau;
QtSql : pour l’utilisation de base de données SQL ;
QtXml : pour la manipulation et la génération de fichiers XML
; et de nombreux autres modules, etc.
Il faut activer un module dans un projet Qt pour pouvoir accéder aux

classes qu’il regroupe (cf. la variable QTd’un fichier .pro).
Les modules
• QtOpenGL : pour l'utilisation d'OpenGL ;

• QtSql : pour l'utilisation de base de données SQL ;
• QtXml : pour la manipulation et la génération de fichiers XML ;
•QtDesigner : pour étendre les fonctionnalités de Qt Designer, l'assistant de création
d'interfaces graphiques ;
• QtAssistant : pour l'utilisation de l'aide de Qt ;
• Qt3Support : pour assurer la compatibilité avec Qt 3.
• et de nombreux autres modules, etc.
● Qt utilise Unicode 4.0 pour la représentation de ses chaînes de caractères, pour ces
modules.

Les modules
L'environnement de Qt est aussi constitué de :
● Qt Jambi : les possibilités de Qt pour le langage JAVA.

● Qtopia : une version de Qt destinée aux dispositifs portables (téléphones,
PocketPC, etc..) et aux systèmes embarqués ( ex : Qt/Embedded).
● QSA : Qt Script for Applications, ajout de scripts pour des applications.
● Teambuilder : Architecture de compilation distribuée pour les gros projets

d’entreprise.

Application GUI
La classe QApplication
Pour créer une application Qt graphique (GUI), il faut instancier un

objet de la classe QApplication (et QCoreApplication pour les
applications non graphiques) :
La classe QApplication (qui hérite de QCoreApplication) fournit

une boucle principale d’événements pour les applications Qt : tous
les événements du système seront traités et expédiés.
C’est sa méthode exec() qui exécute la boucle d’attente des
événements jusqu’à la fermeture du dernier objet de
l’application.
La classe QApplication gère également l’initialisation et
la finalisation de l’application, ainsi que ses paramètres.
L’instance de QApplication doit être créée avant tout objet
graphique.
Application GUI
Exemple
main.cpp :
#include <QApplication>
#include "ihm.h"
int main(int a rg c, char **argv)

{
QApplication app(argc, a rg v ); / / un objet QApplication
IHM ihm; / / ma fenêtre

ihm.show(); / / affichage de ma fenêtre
int r e t = app.exec( ) ; / / exécute l a boucle principale d’ évènement
return r e t ;
}

Application GUI
Diagramme de classes partiel
Élément graphique
Le
widget
Avec Qt, les éléments (ou composants) graphiques prédéfinis
sont appelés des widgets (pour windows gadgets).
Les widgets sont les éléments principaux de la création d’interface
graphique utilisateur (GUI) avec Qt.
Les widgets peuvent afficher des données et des informations sur un
état, recevoir des actions de l’utilisateur et agir comme un conteneur
pour d’autres widgets qui doivent être regroupés.

Élément graphique
La classe QWidget
La classe QWidget fournit la capacité de base d’affichage à l’écran et de

gestion des événements. Elle est la classe mère de toutes les classes
servant à réaliser des interfaces graphiques.
Les widgets :
sont crées "cachés" (hide/show )

sont capable de se "peindre" (paint/repaint/update)
sont capable de recevoir les évènements souris, clavier
sont tous rectangulaires (x,y,width,height)
sont initialisés par défaut en coordonnées 0,0
sont ordonnés suivant l’axe z (la profondeur)
peuvent avoir un widget parent et des widgets enfants

Élément graphique
Exemple
#include <QWidget>
int main(int a rg c, char **argv)

{
QApplication app(argc, a rg v );
QWidget w; / / un objet widget qui n’a pas de parent
/ / un widget e st crée caché, i l faut donc l ’ a f f i c h e r

w.show(); / / on obtient une fenêtre "vide"
/ / on exécute l a boucle principale d’ évènements

int r e t = app.exec();
/ / lorsqu’on ferme l a fenêtre, on so r t de l a boucle

/ / e t on quitte l’application
return r e t ;
}

Élément graphique
Une première fenêtre
Un widget qui n’est pas intégré dans un widget parent est appelé une
fenêtre.

Élément graphique
Les widgets
prédéfinis
Qt fournit des widgets prédéfinis permettant de composer ses propres
applications graphiques :

Élément graphique
Les widgets
prédéfinis
Élément graphique
Diagramme de classes partiel (widget):widget de bas

niveau
Élément graphique
Diagramme de classes partiel (fenêtres):Widget de haut niveau
Élément graphique
Création de (widget) et de fenêtre

personnalisées
La création de widgets personnalisés est faite en héritant de QWidget
ou une classe fille :
La création de fenêtres personnalisées est faite en héritant de QWidget,

QDialog ou QMainWindow :

Élément graphique
Création de fenêtre personnalisée

Ensuite, on compose sa fenêtre personnalisée en y intégrant des widgets :
Remarques :
La classe Qt dédiée au fenêtre principale est bien évidemment

QMainWindow.
Généralement, cela est réalisé dans le constructeur de sa classe
“Fenêtre” (ici MyXXX)??

Élément graphique
Création de fenêtre personnalisée : QMainWindow
La classe QMainWindow propose un ”squelette” permettant de réaliser

ce type d’application :

Élément graphique
Création de fenêtre personnalisée : QMainWindow
Création de widgets docks :
Les widgets docks sont implémentés dans la classe QDockWidget.
Un widget dock est une fenêtre qui peut être encastrée (docked) dans
une fenêtre principale.
On peut ajouter des widgets docks à une fenêtre principale
avec addDockWidget().

Élément graphique
MyMainWindow.cpp
#include <QMainWindow>
#include <QLabel>
/ / MA classe fenêtre principale

c l a s s MyMainWindow: public QMainWindow
{
Q_OBJECT
p ubl i c :
MyMainWindow(QWidget *parent=0 ) ;
~MyMainWindow();
p r i va te :
Qlabel * l a b e l ; / / un pointeur sur une instance de QLabel
};

Élément graphique
MyMainWindow.h
#include "MyMainWindow.h"
MyMainWindow::MyMainWindow( QWidget *parent ) : QMainWindow(parent)

{
/ / on instancie un QLabel en indiquant son parent ( t h i s => moi)
l a b e l = new QLabel("Je su i s un QLabel", t h i s ) ;
/ / etc . . .
/ / on f i x e l e widget QLabel au centre de l a fenêtre

setCentralWidget(label);
}
MyMainWindow::~MyMainWindow()
{
}
::. Il va nous servir à accéder à des méthodes et des propriétés surchargées (c’est-à-dire
modifiées par une classe fille).
Élément graphique
Une deuxième fenêtre (main.cpp)
#include "MyMainWindow.h"
i nt main(int a rgc , char **argv) {

QApplication app(argc, a rgv) ; / / monobjet application
MyMainWindoww; / / monobjet fenêtre
w.show(); / / affichage
return app.exec(); / / boucle

}

Mécanisme signal/slot
Signal et Slot
Rappel : les signaux et les slots forment un mécanisme de

communication entre objets sous Qt.
Toutes les classes qui héritent de QObject ou d’une de ses

sous-classes (par exemple, QWidget) peuvent contenir des signaux
et des slots.
Il faut aussi ajouter la macro Q_OBJECT au sein de cette classe.
Les signaux et les slots sont faiblement couplés :
une classe qui émet un signal ne sait pas (et ne se soucie pas de)
quels slots vont recevoir ce signal.
De la même façon, un objet interceptant un signal ne sait pas quel

objet a émis le signal.
Connexion
Une connexion signal / slot doit être réalisée par la

méthode connect() :
Une connexion signal/slot peut être supprimée par la

méthode disconnect().

Une troisième fenêtre
#include <QPushButton>
i nt main(int a rgc , char **argv)

{
QApplication app(argc, a rgv) ;
QPushButton bouton("Quitter");
/ / on connecte l e signal clicked() de l ’ obj e t bouton

/ / au s l o t qui t ( ) de l ’ obj e t app ( i c i l e pointeur qApp)
QObject::connect(&bouton, SIGNAL(clicked()), qApp, SLOT(quit()));
bouton.show();
return app.exec();
}

Les signaux personnalisés
Il est possible de créer ses propres signaux et slots.

Pour déclarer un signal personnalisé, on utilise le mot clé signals dans
la déclaration de la classe et il faut savoir qu’un signal n’a :
pas de valeur de retour (donc void) et

pas de définition de la méthode (donc pas de corps {})
Pour émettre un signal, on utilise emit :

emit nomDuSignal( parametreDuSignal );
Un signal peut être connecté à un autre signal. Dans ce cas, lorsque le
premier signal est émis, il entraîne l’émission du second.
L’émission d’un signal peut être "automatique" par exemple
lorsqu’on appui sur un bouton, le signal existe déjà dans la classe
utilisée (QPushButton).

Les slots personnalisés

Les slots personnalisés se déclarent et se définissent comme des
méthodes private, protected ou public.
Les slots étant des méthodes normales, ils peuvent être appelés
directement comme toute méthode.
Un signal peut être connecté à plusieurs slots. Attention : les slots

seront activés dans un ordre arbitraire.
Plusieurs signaux peuvent être connectés à un seul slot.
Le mécanisme des signaux et slots fournit un contrôle des types : la signature

d’un signal doit correspondre à la signature du slot récepteur (en réalité, un slot
peut avoir une signature plus courte que celle du signal qu’il reçoit car il peut
ignorer les arguments en trop).

Exemple
#include <QObject>
#include <QDebug>
c la s s MaClasse : public QObject

{
Q_OBJECT
p r iv a t e :
int numero;
public:
MaClasse( int numero=0, QObject *parent=0 ) : QObject(parent), numero(numero) { }
void emettre()
{
emit send(numero); / / envoie l e signal send avec l a valeur de l a variable numero
}
signals:
void send( int ) ; / / un signal personnalisé
public s l o t s :
void receive( int valeur ) / / un s l o t personnalisé
{
qDebug() << "sign al recu " << valeur;
}
};

Utilisation
Exemple :
MaClasse monObjet1(1), monObjet2(2); / / instacie 2 objets
/ / l e signal e t l e s l o t doivent êtres compatibles (mêmesignature)

QObject::connect(&monObjet1, SIGNAL(send(int)), &monObjet2, SLOT(receive(int)));
monObjet1.emettre();
/ / l a méthode emettre() de l ’ obj et 1 enverra l e signal send avec l a valeur 1 ,

/ / ce qui déclenchera l’exécution du s l o t receive de l ’ obj e t2 e t
/ / cela affichera "signal recu 1"

Exemple de connexions
Class Convertiseur : public QWidget {
……
signals :
void actualiser();
public slots:
void convertit();
void permuter(int index);
};

Projet Qt
Qu’est-ce qu’un projet Qt ?
Un projet Qt est défini par un fichier d’extension .pro décrivant la

liste des fichiers sources, les dépendances, les paramètres passés au
compilateur, etc...
Le fichier de projet .pro est fait pour être très facilement éditable
par un développeur. Il consiste en une série d’affectations de variables.
Pour contrôler ses propres utilitaires (moc, uic, ...), Qt fournit un
moteur de production spécifique : le programme qmake.
qmake prend en entrée un fichier de projet .pro et génère en sortie
un fichier de fabrication spécifique à la plateforme. Ainsi, sous les
systèmes UNIX/Linux, qmake produira un Makefile.

Projet Qt
Compilation : Ligne de commande

Projet Qt
Qmake :

Projet Qt
Étapes par étapes (1/2)

Exemple
:/ / on crée un répertoire et on se déplace à l’intérieur
$ mkdir exemple ; cd exemple
/ / on édite un simple fichier C++ main.cpp (avec vim par exemple)
$ vim main.cpp
/ / on génère le fichier de projet Qt .pro
$ qmake -project
$ ls
exemple.pro main.cpp
/ / le fichier .pro décrit le contenu du projet en une série d’affectations de variables
$ cat exemple.pro
TEMPLATE = app
TARGET = exemple
DEPENDPATH+= .
INCLUDEPATH += .
# Input
HEADERS+=
SOURCES += main.cpp
/ / on génère le fichier Makefile à partir du fichier .pro
$ qmake
$ ls
exemple.pro main.cpp Makefile

Projet Qt
Étapes par étapes (2/2)

Suite :
/ / on fabrique l’application
$ make
g++ - c -m64 -pipe -O2 -Wall -W-D_REENTRANT-DQT_WEBKIT -DQT_NO_DEBUG-DQT_GUI_LIB -DQT_CORE_LIB -
DQT_SHARED-I/usr/share/qt4/mkspecs/lin ux -g++-64 - I . -I/usr/in clude/qt4/QtCo re - I / u s r / in c lu d e / q t 4 /
QtGui - I / us r / in c lud e / q t 4 - I . - I . -o main.o main.cpp
g++ -m64 -Wl,-O1 -o exemple main.o -L/usr/lib/x86_64 -lin ux-gn u -lQtGui -lQtCore -lpthread
$ ls
exemple exemple.pro main.cpp main.o Makefile
/ / on exécute l’application
$ ./exemple
À chaque fois que l’on modifie le fichier .pro, il faudra exécuter à nouveau la
commande qmake pour que celle-ci mette à jour le fichier Makefile.
D’autre part, le fichier Makefile est toujours spécifique à la plateforme. Si vous
changez de plateforme (Linux −→Windows), il vous suffira d’exécuter à nouveau
la commande qmake pour générer un fichier Makefile adapté à votre système.

Projet Qt
Le fichier de projet .pro
Le principe de fonctionnement du fichier .pro est donc très simple.
La variable permettant d’indiquer les modules Qt à intégrer

pour l’application se nomme QT :
QT+= s q l xml pour a c t iv e r l e s modules SQLe t XML
QT- = gui pour désactiver l e module gui

Environnement deDéveloppement Intégré (EDI)
Qt Creator
Qt Creator est l'environnement de développement intégré dédié

à Qt et facilite la gestion d'un projet Qt.
Qt Creator intègre en son sein les outils Qt Designer et Qt Assistant.
Il intègre aussi un mode débogage :
Remarque : même si Qt Creator est présenté comme l'environnement de

développement de référence pour Qt, il existe des modules Qt pour les
environnements de développement Eclipse et Visual Studio.
Il existe d'autres EDI dédiés à Qt et développés indépendamment de Nokia,

comme QDevelop et Monkey Studio.

Qt Creator

Qt Designer
Qt Designer est un logiciel qui permet de créer des interfaces graphiques Qt dans un
environnement convivial. L’utilisateur, par glisser-déposer, place les composants d’interface
graphique et y règle leurs propriétés facilement. Les fichiers d’interface graphique sont
formatés en X M L et portent l’extension . ui. Lors de la compilation, un fichier d’interface
graphique est converti en classe C++ par l’utilitaire uic, fourni par Qt.

Integrated Development Environment (IDE)

● QDevelop est un environnement de développement intégré libre pour Qt.
Le but de QDevelop est de fournir dans les environnements les plus utilisés,
Linux, Windows et Mac OS X d'un outil permettant de développer en Qt de la
même manière avec un IDE unique.
●KDevelop est un environnement de développement intégré (IDE) pour KDE. Il

intègre également les outils QtDesigner pour la création d'interface graphique.
● Autres bibliothèques généralistes multiplateformes, parmi les plus connus :

➢ GTK+, utilisée par l'environnement graphique GNOME
➢ wxWidgets (anciennement wxWindows)

Assistant nouveau projet
Fichier −→Nouveau fichier ou projet ...
...

Shadow
build
Le shadow build permet de séparer les dossiers contenant les codes sources des fichiers
générés (exécutable, fichiers objets .o, ...) par la fabrication (build ).
Il est important de ne pas les mélanger pour assurer convenablement les tâches courantes
(sauvegarde, gestion de versions, portablité multiplateforme, ...).
Les fichiers issus de la compilation seront donc stockés dans un répertoire séparé et créé
par Qt.

Positionnement deswidgets
Principes (1/2)
Vous pouvez gérer le placement de vos widgets de deux manières :
avec un positionnement absolu (généralement déconseillé car il

pose des problèmes de résolution d’écran, de redimensionnement, ...)
avec un positionnement relatif
Qt fournit un système de disposition (layout) pour l’organisation et le

positionnement automatique des widgets enfants dans un widget. Ce
gestionnaire de placement permet l’agencement facile et le bon usage de
l’espace disponible.

Les classes QLayout

Qt inclut un ensemble de classes QxxxLayout qui sont utilisés pour
décrire la façon dont les widgets sont disposés dans l’interface utilisateur
d’une application.

Les différents layouts

Toutes lesclasseshéritent dela classeabstraiteQLayout.
– QHBoxLayout : boîte horizontale

– QVBoxLayout : boîte verticale
– QGridLayout : grille
– QFormLayout : formulaire

Intérêt
Lorsqu’un layout est défini sur un widget, il prend en charge les tâches
suivantes :
le positionnement des widgets enfants

la gestion des tailles (minimale, préférée, ...)
le redimensionnement, le déplacement
la mise à jour automatique lorsque le contenu change

D’une manière générale, les widgets sont hiérarchiquement inclus les uns
dans les autres.
Le principal avantage est que si le parent est déplacé, les enfants le sont
aussi.
Principe
Les gestionnaires de disposition (les classes QxxxLayout) simplifient

le travail de positionnement :
on peut ajouter des widgets dans un layout :

void QLayout::addWidget(QWidget *widget)
on peut ajouter des layouts dans un layout :

void QLayout::addLayout(QLayout *layout)
on peut associer un layout à un widget qui devient alors le

propriétaire du layout et parent des widgets inclus dans le layout :
void QWidget::setLayout (QLayout *layout)

Exemple
Création des widgets
i nt main(int a rgc , char * a r g v [ ] ) {

QApplication a ( a r g c , a rgv) ;
/ / 1 . création des widgets

/ / l e widget central
QWidget mainWidget;
/ / une image
QLabel * imageLabel = new QLabel;
imageLabel->setPixmap(QPixmap("373058.png"));
/ / une zone de défilement

QScrollArea * imageArea = newQScrollArea;
imageArea->setWidget(imageLabel); / / imageArea parent de imageLabel
/ / une l i s t e déroulante
QComboBox * sizeComboBox = new QComboBox;
sizeComboBox->addItem("100x200");
sizeComboBox->addItem("200x400");

Gestion du positionnement
/ / 2 . gestion du positionnement
/ / un layout ve r t i c a l
QVBoxLayout * layout = new QVBoxLayout;
/ / on ajoute l e s widgets au layout (parent de imageArea e t de sizeComboBox)

layout->addWidget(imageArea);
layout->addWidget(sizeComboBo x ) ;
/ / on applique l e layout au widget central

mainWidget.setLayout(layout); / / parent de layout
/ / on affiche l e widget
mainWidget.show(); / / affichage de mainWidget e t de ses enfants
return a . e x e c ( ) ; / / boucle d’attente d’évènements
/ / destruction de mainWidget e t de ses enfants :

/ / - > destruction de layout
/ / - > destruction de sizeComboBox
/ / - > destruction de imageArea
/ / - > destruction de imageLabel
}
Transition Qt4 →− Qt5
Transition Qt4 →
− Qt5
Qt 5.0 est sorti le 19 décembre 2012. Bien que marquant des

changements majeurs sur bien des points, le passage à Qt5 casse au
minimum la compatibilité au niveau des sources. De cette façon, le
passage est bien plus facile que celui de Qt3 vers Qt4 ( !).
Les principales conséquences sont :
Intégrer QtWidgets qui est un module séparé donc il faudra ajouter
dans le fichier .pro : QT+= widgets
Corriger les erreurs de compilation comme error:

QPushButton: No such file or directory :
#include <QtWidgets/QPushButton> / * pour Qt5 * /
Cours Qt 66/ 69
Transition Qt4 →− Qt5
Compatibilité Qt4/Qt5
Dans le fichier de projet (.pro) :

greaterThan(QT_MAJOR_VERSION, 4 ) : QT+= widgets
Dans les fichiers d’en-têtes (.h) :

# i f QT_VERSION>= 0x050000
#include <QtWidgets> / * tous l e s widgets de Qt5 * /
#else
#include <QtGui> / * tous l e s widgets de Qt4 * /
#endif
Les deux corrections ont été réalisées afin de laisser la compatibilité

Qt4/Qt5. Pour en savoir plus, lire :
http ://wiki.qt.io/Transition_from_Qt_4.x_to_Qt5

Documentation
Qt4
La documentation générale de Qt se trouve à cette adresse :
http ://doc.qt.io/
La documentation de référence Qt4 :

http ://doc.qt.io/qt-4.8/index.html, et plus particulièrement les
concepts de base (http ://doc.qt.io/qt-4.8/qt-basic-concepts.html)
: Signals and Slots, Main Classes, Main Window Architecture,
Internationalization, ...
Une partie de cette documentation est traduite en français :
http ://qt.developpez.com/doc/4.7/index/
Les tutoriels : http ://doc.qt.io/qt-4.8/tutorials.html

La documentation de Qt4 fournit de nombreux exemples (plus de
400), notamment : http ://doc.qt.io/qt-4.8/examples-
widgets.html,
...
Documentation
Qt4/Qt5
La documentation générale de Qt se trouve à cette adresse : http

://doc.qt.io/
Les exemples pour Qt5 sont ici : doc.qt.io/qt-5/

Les tutoriels : http ://doc.qt.io/qt-5/qtexamplesandtutorials.html
Les documentations des outils Qt :

http ://doc.qt.io/qt-4.8/qmake-tutorial.html,
http ://doc.qt.io/qt-5/qmake-manual.html,
http ://doc.qt.io/qt-4.8/designer-manual.html, ...

Documentation
Autres liens
Quelques autres liens :
Qt Wiki : wiki.qt.io
Qt Centre : www.qtcentre.org
Qt Forum (en) : www.qtforum.org
QtFr (fr) : www.qtfr.org
Qt Tutorial (fr) :
www.digitalfanatics.org Qt-Apps.org :
www.qt-apps.org
Qt-Prop.org : www.qt-prop.org
Qt developpez.com (fr) :
qt.developpez.com
SICOM, S8 Cours Qt 70/ 6 9

Presentation-Qt 20 21

Transféré par

Informations du document

Titre original

Copyright

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Presentation-Qt 20 21

Titre original :

Transféré par

Droits d'auteur :

Cours Qt

9 Environnement deDéveloppement Intégré (EDI)

11 Transition Qt4 →− Qt5

Qt est une plateforme de développement d’interfaces

Qt fournit un ensemble de classes décrivant :

des éléments graphiques (widgets) et

des éléments non graphiques : accès aux données (fichier, base

Le XML, pour Extensible Markup Language, désigne :

Il s'agit, en quelque sorte, d'une version améliorée du langage HTML avec la

De grandes entreprises utilisent Qt : Google, Adobe Systems, Asus,

Qt est une bibliothèque sur laquelle repose l’environnement graphique

KDE est un grand projet ayant pour but de:

construire un environnement graphique complet, facile à utiliser et

Qt est principalement dédiée au développement d’interfaces

Les interactions avec l’utilisateur sont gérées par un mécanisme

Qu’est-ce que la programmation évènementielle?

La programmation événementielle est une programmation basée sur

Le programme sera principalement défini par ses réactions aux

c’est-à-dire des changements d’état, par exemple

La programmation événementielle est architecturée autour d’une

Quel est le principe ?

Pour chaque évènement à gérer, il faut lui associer une action à

Ensuite, à chaque fois que l’évènement sera détecté par la boucle

Comment ça marche sous Qt ?

un signal est émis lorsqu’un événement particulier se produit.

Les classes de Qt possèdent de nombreux signaux prédéfinis mais

L’association d’un signal à un slot est réalisée par une connexion

Comment ça marche sous Qt ?

Quelle est l’organisation des classes Qt ?

Les objets Qt (ceux héritant de QObject) peuvent s’organiser

Ainsi, lorsqu’une classe est instanciée, on peut lui définir un objet

Comment écrire une classe Qt ?

c l a s s MaClasse : public QObject

SICOM, S8 Cours Qt 12/ 69

Les spécificités Qt nécessitent l’utilisation du moc, un outil fourni par

SICOM, S8 Cours Qt 13/ 69

Comment accéder aux propriétés d’une classe Qt ?

Un objet Qt peut avoir des propriétés.

Qt suit cette convention pour le nom des accesseurs : propriete()

Pour connaître l’ensemble des classes, méthodes et propriétés, signaux

Pour pouvoir utiliser une classe, il faut inclure sa déclaration :

C’est mieux avec un exemple !

/ / Pour l i r e l a chaîne de caractères s a i s i e dans un QLineEdit

/ / Pour modifier l a chaîne de caractères d’un QLineEdit

SICOM, S8 Cours Qt 15/ 69

Qu’est-ce que les modules?

Les principaux modules :

Il faut activer un module dans un projet Qt pour pouvoir accéder aux

Qu’est-ce que les modules?

• QtOpenGL : pour l'utilisation d'OpenGL ;

SICOM, S8 Cours Qt 17/ 69

Qu’est-ce que les modules?

L'environnement de Qt est aussi constitué de :

● Qt Jambi : les possibilités de Qt pour le langage JAVA.

● QSA : Qt Script for Applications, ajout de scripts pour des applications.

● Teambuilder : Architecture de compilation distribuée pour les gros projets

SICOM, S8 Cours Qt 18/ 69

Pour créer une application Qt graphique (GUI), il faut instancier un

La classe QApplication (qui hérite de QCoreApplication) fournit

int main(int a rg c, char **argv)

IHM ihm; / / ma fenêtre

int r e t = app.exec( ) ; / / exécute l a boucle principale d’ évènement

SICOM, S8 Cours Qt 20/ 69

Diagramme de classes partiel

SICOM, S8 Cours Qt 22/ 69