Le modèle objet de QT

Le modèle objet de QT
●
Communication basée sur les concepts de
« Signaux » et « Slots »
●
Gestion des évenements
●
Gestion des « Timers »
●
Composition d'objets
●
Pointeurs protégés
Signaux/Slots
●
●
●
Tout objet QT (descendant de QObject) peut
émettre des signaux dans l'environnement pour
indiquer (en général) un changement d'état
pouvant être intéressant pour d'autres objets
Tout objet QT peut réagir à des signaux émis
en exécutant des méthodes particulières
appelées « SLOTS »
Ce mécanisme favorise la réutilisabilité des
composants
●
●
●
●
●
Signal --> notification d'un évènement
Slot --> méthode pouvant être déclenchée par
un signal
Plusieurs signaux peuvent être connectés à un
même slot et un même signal peut être
connecté à plusieurs slots
Les param du signal sont transmis au slot
auquel il est connecté
Un slot peut avoir moins de param que le signal
associé
Pour connecter un signal à un slot :
connect (objS, SIGNAL(nomSignal(...)),
objD, SLOT(nomSlot(...)) )
Pour émettre un signal :
emit nomSignal(...)
objD
NomSlot(...)
{
...
}
emit nomSignal(...)
objS
obj...
class Pile : public QObject
{
Q_OBJECT
// macro pour utiliser le modèle QT
private:
int Tab[100];
int nbElem;
...
public slots:
// méthodes de type Slots (aussi private ou protected)
void Empiler( int val );
...
signals:
// déclaration des signaux
void newElem( int val );
// pas d'implémentation
void risqueDebordement( );
};
...
void Pile::Empiler( int val)
{
if (nbElem < 100) {
Tab[nbElem++] = val;
emit newElem( val );
if (nbElem > 90)
emit risqueDebordement( );
}
}
...
Organisation du source pour un
projet
●
Un prog principal : main.cpp
●
Pour chaque classe (composant) : 2 fichiers
●
–
nomClasse.h : définition de la classe
–
nomClasse.cpp : implémentation des méthodes
L'utilitaire moc permet de traduire le modèle QT
(signaux/slots...) en du C++ standard
–
Préprocesseur
moc nomClasse.h -o moc_nomClasse.cpp
●
L'utilitaire qmake génère un Makefile prêt à
l'emploi
Exemple de main.cpp :
#include <QApplication>
#include <QPushButton>
int main( int argc, char *argv[ ] )
{
QApplication app( argc, argv );
QPushButton hello( "Hello world!" ); // pas de parent donc Toplevel (une fenêtre)
hello.resize(100, 30);
hello.show();
return app.exec( );
// boucle principale : traitement des évènements
}
Pour la construction de l'exécutable (build) :
qmake -project // génère un fichier projet (.pro)
qmake
// génère un Makefile à partir du fichier projet
make
// utilise le Makefile pour générer l'exécutable (compilation+édition de liens)
Les Makefiles
●
Automatiser la construction d'exécutables
●
Formés par des règles de la forme:
cibles : dépendances ...
commandes ...
●
Contiennent des définitions de variables
VAR1 = .....
# initialisation de variables
$(VAR1)
# utilisation de variables
Règles
●
Explicites
main.o : main.cpp init.h
g++ -c main.cpp
prog: main.o composant1.o
g++ -o prog composant1.o main.o -lqt
●
Implicite
%.o : %.c
Variables prédéfinies
A chaque exécution d'une règle, un ensemble de
variables (automatiques) est géré
$@
le nom de la cible
$<
le nom de la 1ere dépendance
$^
toutes les dépendances
$*
le radical associé à une règle implicite
si la cible est 'fich.o' et le motif dans la règle est %.o alors
$* vaut 'fich'
Exemples:
CFLAGS = -I /usr/lib/qt4/include -I .
CC = gcc
%.o : %.c
$(CC) -c -o $@ $(CFLAGS) $<
un fichier.c est transformé (compilé) en un fichier.o
par le compilateur indiqué dans $(CC) en utilisant
les options spécifiées dans $(CFLAGS)
moc_%.cpp : %.h
moc $< -o $@
règle automatisant l'utilisation de moc pour les
headers des classes QT