[Plan du site]
Vous êtes ici ---
> Le Site du Zéro
> Les tutoriels
> Officiels
> Programmation
> Apprenez à programmer en C++ ! > [Pratique] Créez vos propres fenêtres avec Qt > Les boîtes de dialogue usuelles
> Lecture du tutoriel
Les boîtes de dialogue usuelles
Après un chapitre sur les signaux et les slots riche en nouveaux concepts, on relâche ici un peu la pression.
Nous allons découvrir les boîtes de dialogue usuelles, aussi appelées "common dialogs" par nos amis anglophones.
Qu'est-ce qu'une boîte de dialogue usuelle ? C'est une fenêtre qui sert à remplir une fonction bien précise. Par exemple, on connaît la boîte de dialogue "message" qui affiche un message et ne vous laisse d'autre choix que de cliquer sur le bouton OK. Ou encore la boîte de dialogue "ouvrir un fichier", "enregistrer un fichier", "sélectionner une couleur", etc.
On ne s'amuse pas à recréer "à la main" ces fenêtres à chaque fois. On profite de fonctions système pour ouvrir des boîtes de dialogue pré-construites.
Qt s'adapte à l'OS pour afficher une boîte de dialogue qui corresponde aux formes habituelles de votre OS.
En clair : attendez-vous à un chapitre simple qui vous donnera de nombreux outils pour pouvoir interagir avec l'utilisateur de votre programme !
Le premier type de boîte de dialogue que nous allons voir est le plus courant : la boîte de dialogue "afficher un message".
Nous allons créer un bouton sur notre fenêtre de type MaFenetre qui appellera un slot personnalisé. Ce slot ouvrira la boîte de dialogue. En clair, un clic sur le bouton doit pouvoir ouvrir la boîte de dialogue.
Les boîtes de dialogue "afficher un message" sont contrôlées par la classe
QMessageBox. Vous pouvez commencer par faire l'include correspondant dans "MaFenetre.h" pour ne pas l'oublier :
#include <QMessageBox>.
Quelques rappels et préparatifs
Pour que l'on soit sûr de travailler ensemble sur le même code, je vous donne le code source des fichiers MaFenetre.h et MaFenetre.cpp sur lesquels je vais travailler. Ils ont été simplifiés au maximum histoire d'éviter le superflu.
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 | // MaFenetre.h
#ifndef DEF_MAFENETRE
#define DEF_MAFENETRE
#include <QApplication>
#include <QWidget>
#include <QPushButton>
#include <QMessageBox>
class MaFenetre : public QWidget
{
Q_OBJECT
public:
MaFenetre();
public slots:
void ouvrirDialogue();
private:
QPushButton *m_boutonDialogue;
};
#endif
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18 | // MaFenetre.cpp
#include "MaFenetre.h"
MaFenetre::MaFenetre() : QWidget()
{
setFixedSize(230, 120);
m_boutonDialogue = new QPushButton("Ouvrir la boîte de dialogue", this);
m_boutonDialogue->move(40, 50);
QObject::connect(m_boutonDialogue, SIGNAL(clicked()), this, SLOT(ouvrirDialogue()));
}
void MaFenetre::ouvrirDialogue()
{
// Vous insérerez le code d'ouverture des boîtes de dialogue ici
}
|
C'est très simple. Nous avons créé un bouton dans la boîte de dialogue qui appelle le slot personnalisé
ouvrirDialogue(). C'est dans ce slot que nous nous chargerons d'ouvrir une boîte de dialogue.
Au cas où certains se poseraient la question, notre main.cpp n'a pas changé. Allez, je vous le redonne. Je suis trop sympa je sais, ne me remerciez pas
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | // main.cpp
#include <QApplication>
#include "MaFenetre.h"
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
MaFenetre fenetre;
fenetre.show();
return app.exec();
}
|
Ouvrir une boîte de dialogue avec une méthode statique
Bien, place à l'action maintenant !
La classe QMessageBox permet de créer des objets de type QMessageBox (comme toute classe qui se respecte
) mais on utilise majoritairement ses méthodes statiques pour des raisons de simplicité. Nous commencerons donc par découvrir les méthodes statiques, qui se comportent je le rappelle comme de simples fonctions. Elles ne nécessiteront pas de créer d'objet.
QMessageBox::information
La méthode statique
information() permet d'ouvrir une boîte de dialogue constituée d'une icône "information".
Son prototype est le suivant :
Code : C++1 | StandardButton information ( QWidget * parent, const QString & title, const QString & text, StandardButtons buttons = Ok, StandardButton defaultButton = NoButton );
|
Seuls les 3 premiers paramètres sont obligatoires, les autres ayant comme vous le voyez une valeur par défaut.
Ces 3 premiers paramètres sont :
- parent : un pointeur vers la fenêtre parente (qui doit être de type QWidget ou hériter de QWidget). Vous pouvez envoyer NULL en paramètre si vous ne voulez pas que votre boîte de dialogue ait une fenêtre parente, mais ce sera plutôt rare.
- title : le titre de la boîte de dialogue (affiché en haut de la fenêtre).
- text : le texte affiché au sein de la boîte de dialogue.
Testons donc un code très simple. Voici le code du slot ouvrirDialogue() :
Code : C++1
2
3
4 | void MaFenetre::ouvrirDialogue()
{
QMessageBox::information(this, "Titre de la fenêtre", "Bonjour et bienvenue à tous les Zéros !");
}
|
L'appel de la méthode statique se fait donc comme celui d'une fonction classique, à la différence près qu'il faut mettre en préfixe le nom de la classe dans laquelle elle est définie (d'où le "
QMessageBox::" avant).
Le résultat est une boîte de dialogue comme vous avez l'habitude d'en voir, constituée d'un bouton OK :
Vous noterez que lorsque la boîte de dialogue est ouverte, on ne peut plus accéder à sa fenêtre parente qui est derrière. On dit que la boîte de dialogue est une fenêtre modale : c'est une fenêtre qui "bloque" temporairement son parent en attente d'une réponse de l'utilisateur.
A l'inverse, on dit qu'une fenêtre est non modale quand on peut toujours accéder à la fenêtre derrière. C'est le cas en général des boîtes de dialogue "Rechercher un texte" dans les éditeurs de texte.
Comble du raffinement (j'aime bien cette expression
), il est même possible de mettre en forme son message à l'aide de balises (X)HTML pour ceux qui connaissent. Si vous ne connaissez pas, il est toujours temps d'
apprendre le HTML, j'ai fait un tuto il faut en profiter
Exemple de boîte de dialogue "enrichie" avec du code HTML :
Code : C++1 | QMessageBox::information(this, "Titre de la fenêtre", "Bonjour et bienvenue à <strong>tous les Zéros !</strong>");
|
QMessageBox::warning
Si la boîte de dialogue "information" sert à informer l'utilisateur par un message, la boîte de dialogue warning le met en garde contre quelque chose. Elle est généralement accompagné d'un "ding" caractéristique.
Elle s'utilise de la même manière que QMessageBox::information, mais cette fois l'icône change :
Code : C++1 | QMessageBox::warning(this, "Titre de la fenêtre", "Attention, vous êtes peut-être un Zéro !");
|
QMessageBox::critical
Quand c'est trop tard et qu'une erreur s'est produite, il ne vous reste plus qu'à utiliser la méthode statique critical() :
Code : C++1 | QMessageBox::critical(this, "Titre de la fenêtre", "Vous n'êtes pas un Zéro, sortez d'ici ou j'appelle la police !");
|
QMessageBox::question
Si vous avez une question à poser à l'utilisateur, c'est la boîte de dialogue qu'il vous faut !
Code : C++1 | QMessageBox::question(this, "Titre de la fenêtre", "Dites voir, je me posais la question comme ça, êtes-vous vraiment un Zéro ?");
|
C'est bien joli mais... comment peut-on répondre à la question avec un simple bouton OK ?
Par défaut, c'est toujours un bouton OK qui s'affiche. Mais dans certains cas, comme lorsqu'on pose une question, il faudra afficher d'autres boutons pour que la boîte de dialogue ait du sens.
Personnaliser les boutons de la boîte de dialogue
Pour personnaliser les boutons de la boîte de dialogue, il faut utiliser le 4ème paramètre de la méthode statique. Ce paramètre accepte une combinaison de valeurs prédéfinies, séparées par un OR (la barre verticale |). On appelle cela des
flags.
Si vous avez déjà travaillé avec la SDL, vous connaissez cela. Sinon, vous vous y habituerez vite vous verrez, c'est juste une façon pratique d'envoyer des options à une fonction.
Pour ceux qui se poseraient la question, le 5ème et dernier paramètre de la fonction permet d'indiquer quel est le bouton par défaut. On change rarement cette valeur car Qt choisit généralement le bouton qui convient le mieux par défaut.
La
liste des flags disponibles est donnée par la documentation. Vous avez du choix comme vous pouvez le voir.
Si on veut placer les boutons "Oui" et "Non", il nous suffit de combiner les valeurs "QMessageBox::Yes" et "QMessageBox::No"
Code : C++1 | QMessageBox::question(this, "Titre de la fenêtre", "Dites voir, je me posais la question comme ça, êtes-vous vraiment un Zéro ?", QMessageBox::Yes | QMessageBox::No);
|
Les boutons apparaissent alors :
Horreur ! Malédiction ! Enfer et damnation !
L'anglais me poursuit, les boutons sont écrits en anglais. Catastrophe qu'est-ce que je vais faire au secouuuuuurs !!!
En effet, les boutons sont écrits en anglais. Mais ce n'est pas grave du tout, les applications Qt peuvent être facilement traduites, je vous en avais parlé en introduction de cette partie.
On ne va pas rentrer dans les détails du fonctionnement de la traduction, on aura l'occasion d'en reparler plus longuement plus tard. Je vais vous donner un code à placer dans le fichier main.cpp, et vous allez l'utiliser gentiment
sans poser de questions.
Attention, j'ai dit : sans poser de question. On n'aime pas trop les gens qui posent des questions ici. Un accident est si vite arrivé...
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23 | // main.cpp
#include <QApplication>
#include <QTranslator>
#include <QLocale>
#include <QLibraryInfo>
#include "MaFenetre.h"
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QString locale = QLocale::system().name();
QTranslator translator;
translator.load(QString("qt_") + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath));
app.installTranslator(&translator);
MaFenetre fenetre;
fenetre.show();
return app.exec();
}
|
Les lignes ajoutées ont été surlignées. Il y a plusieurs includes et quelques lignes de code supplémentaires dans le main.
Normalement, votre application devrait maintenant afficher des boutons en français :
Et voilà le travail !
C'est cool, mais comment je fais pour savoir sur quel bouton l'utilisateur a cliqué ? Hein, hein ?
Quoi ? Encore une question ?
Vous savez, vous réduisez votre espérance de vie avec toutes les questions que vous posez aujourd'hui. Enfin moi j'dis ça comme ça
Bon ok, cette question est pertinente, je peux y répondre. Je dois y répondre même. Alors allons-y !
Récupérer la valeur de retour de la boîte de dialogue
Les méthodes statiques que nous venons de voir retournent un entier (int). On peut tester facilement la signification de ce nombre à l'aide des valeurs prédéfinies par Qt (comme quoi les énumérations c'est pratique !).
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13 | void MaFenetre::ouvrirDialogue()
{
int reponse = QMessageBox::question(this, "Interrogatoire", "Dites voir, je me posais la question comme ça, êtes-vous vraiment un Zéro ?", QMessageBox::Yes | QMessageBox::No);
if (reponse == QMessageBox::Yes)
{
QMessageBox::information(this, "Interrogatoire", "Alors bienvenue chez les Zéros !");
}
else if (reponse == QMessageBox::No)
{
QMessageBox::critical(this, "Interrogatoire", "Tricheur ! Menteur ! Voleur ! Ingrat ! Lâche ! Traître !\nSors d'ici ou j'appelle la police !");
}
}
|
Voici un schéma de ce qui peut se passer :
C'est ma foi clair, non ?
Les boîtes de dialogues précédentes étaient un peu limitées car, à part présenter différents boutons, on ne pouvait pas trop interagir avec l'utilisateur.
Si vous souhaitez que votre utilisateur saisisse une information, ou encore fasse un choix parmi une liste, les boîtes de dialogue de saisie sont idéales. Elles sont gérées par la classe
QInputDialog, que je vous conseille d'inclure dès maintenant dans MaFenetre.h.
Les boîtes de dialogue "saisir une information" peuvent être de 4 types. Nous allons les voir dans l'ordre :
- Saisir un texte
- Saisir un entier
- Saisir un nombre décimal (double)
- Choisir un élément parmi une liste
Chacune de ces fonctionnalités est assurée par une méthode statique différente.
Saisir un texte (QInputDialog::getText)
La méthode statique getText() ouvre une boîte de dialogue qui permet à l'utilisateur de saisir un texte.
Son prototype est :
Code : C++1 | QString QInputDialog::getText ( QWidget * parent, const QString & title, const QString & label, QLineEdit::EchoMode mode = QLineEdit::Normal, const QString & text = QString(), bool * ok = 0, Qt::WindowFlags f = 0 );
|
Vous pouvez tout d'abord constater que la méthode retourne un QString, c'est-à-dire une chaîne de caractères de Qt.
Les paramètres signifient, dans l'ordre :
- parent : pointeur vers la fenêtre parente. Peut être mis à NULL pour ne pas indiquer de fenêtre parente.
- title : titre de la fenêtre affiché en haut.
- label : texte affiché dans la fenêtre.
- mode : mode d'édition du texte. Permet de dire si on veut que les lettres s'affichent quand on tape, ou si elles doivent être remplacées par des astérisques (pour les mots de passe) ou si aucune lettre ne doit s'afficher. Toutes les options sont dans la doc. Par défaut, les lettres s'affichent normalement (QLineEdit::Normal).
- text : le texte par défaut dans la zone de saisie.
- ok : un pointeur vers un booléen pour que Qt puisse vous dire si l'utilisateur a cliqué sur OK ou sur Annuler.
- f = quelques flags (options) permettant d'indiquer si la fenêtre est modale (bloquante) ou pas. Les valeurs possibles sont détaillées par la doc.
Heureusement, comme vous pouvez le constater en lisant le prototype, certains paramètres possèdent des valeurs par défaut ce qui fait qu'ils ne sont pas obligatoires.
Reprenons notre code de tout à l'heure et cette fois, au lieu d'afficher une QMessageBox, nous allons afficher une QInputDialog lorsqu'on clique sur le bouton de la fenêtre.
Code : C++1
2
3
4 | void MaFenetre::ouvrirDialogue()
{
QString pseudo = QInputDialog::getText(this, "Pseudo", "Quel est votre pseudo ?");
}
|
En une ligne, je crée un QString et je lui affecte directement la valeur retournée par la méthode getText(). J'aurais aussi bien pu faire la même chose en deux lignes, mais ç'aurait été plus long et je suis une feignasse
La boîte de dialogue devrait ressembler à cela :
On peut aller plus loin et vérifier si le bouton OK a été actionné, et si c'est le cas on peut alors afficher le pseudo de l'utilisateur dans une QMessageBox.
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13
14 | void MaFenetre::ouvrirDialogue()
{
bool ok = false;
QString pseudo = QInputDialog::getText(this, "Pseudo", "Quel est votre pseudo ?", QLineEdit::Normal, QString(), &ok);
if (ok && !pseudo.isEmpty())
{
QMessageBox::information(this, "Pseudo", "Bonjour " + pseudo + ", ça va ?");
}
else
{
QMessageBox::critical(this, "Pseudo", "Vous n'avez pas voulu donner votre nom... snif.");
}
}
|
Ici, on crée un booléen qui va recevoir l'information "
Le bouton OK a-t-il été cliqué ?".
Pour pouvoir l'utiliser dans la méthode getText, il faut donner tous les paramètres avant qu'on ne souhaite pourtant pas changer ! C'est un des défauts des paramètres par défaut en C++ : si le paramètre que vous voulez renseigner est tout à la fin (à droite), il faudra alors absolument renseigner tous les paramètres qui sont avant !
J'ai donc envoyé des valeurs par défaut aux paramètres qui étaient avant, à savoir
mode et
text.
Comme j'ai donné un pointeur vers mon booléen à la méthode, celle-ci va le remplir pour indiquer si oui ou non le bouton a été cliqué.
Je peux ensuite faire un test, d'où la présence de mon if. Je vérifie 2 choses :
- Si le bouton OK a été cliqué
- Et si le texte n'est pas vide (la méthode isEmpty de QString sert à faire ça, vous ne pouviez pas la connaître, sauf en lisant la doc de QString bien sûr ).
Si un pseudo a été entré et que l'utilisateur a cliqué sur OK, alors une boîte de dialogue lui souhaite la bienvenue. Sinon, une erreur est affichée.
Ce schéma présente ce qui peut se produire :
Exercice : essayez d'afficher le pseudo de l'utilisateur quelque part sur la fenêtre mère, par exemple sur le bouton.
Saisir un entier (QInputDialog::getInteger)
La méthode getInteger devrait vous paraître simple maintenant que vous connaissez getText. Son prototype est :
Code : C++1 | int QInputDialog::getInteger ( QWidget * parent, const QString & title, const QString & label, int value = 0, int minValue = -2147483647, int maxValue = 2147483647, int step = 1, bool * ok = 0, Qt::WindowFlags f = 0 );
|
Elle retourne un int comme prévu.
Vous noterez les paramètres value (valeur par défaut), minValue (valeur minimale autorisée), maxValue (valeur maximale autorisée) et step, le pas d'incrémentation lorsqu'on clique sur les petites flèches (vous allez voir).
Testons ça avec les paramètres obligatoires, ça sera suffisant :
Code : C++1 | int entier = QInputDialog::getInteger(this, "Nombre", "Entrez un nombre entier");
|
Les petites flèches à droite permettent à l'utilisateur d'incrémenter (ou de décrémenter) le nombre affiché. Le rôle du paramètre step est d'indiquer la valeur du pas d'incrémentation. Par défaut il est de 1.
Par exemple si je clique sur la flèche vers le haut alors que le nombre saisi est 12 et que j'ai mis un pas d'incrémentation de 10, le nombre deviendra 22.
Le nombre saisi est retourné par la méthode dans un entier, à vous de le traiter pour faire ce que bon vous semblera avec
Saisir un nombre décimal (QInputDialog::getDouble)
La saisie d'un double est pratiquement identique à celle d'un entier, à la différence près qu'il y a un paramètre qui permet d'indiquer le nombre maximal de chiffres après la virgule autorisés (paramètre
decimals).
Code : C++1 | double QInputDialog::getDouble ( QWidget * parent, const QString & title, const QString & label, double value = 0, double minValue = -2147483647, double maxValue = 2147483647, int decimals = 1, bool * ok = 0, Qt::WindowFlags f = 0 );
|
Petit test :
Code : C++1 | double nombreDecimal = QInputDialog::getDouble(this, "Nombre", "Entrez un nombre décimal");
|
Choix d'un élément parmi une liste (QInputDialog::getItem)
Si l'utilisateur doit faire son choix dans une liste, cette méthode permet d'afficher les choix possibles dans une boîte de dialogue avec un menu déroulant.
Son prototype est :
Code : C++1 | QString QInputDialog::getItem ( QWidget * parent, const QString & title, const QString & label, const QStringList & list, int current = 0, bool editable = true, bool * ok = 0, Qt::WindowFlags f = 0 );
|
Il y a quelques nouveaux paramètres que je dois expliquer :
- list : la liste des choix possibles, envoyée via un objet de type QStringList (liste de chaînes) à construire au préalable.
- current : le numéro du choix qui doit être sélectionné par défaut.
- editable : un booléen qui indique si l'utilisateur a le droit d'entrer sa propre réponse (comme avec getText) ou s'il est obligé de faire un choix parmi la liste.
Toute la "difficulté", vous l'aurez compris, consiste à créer cette liste de choix. La doc nous dit qu'il faut envoyer un objet de type QStringList, allons donc voir la
doc de QStringList !
Hmm...
Hmm hmm...
Intéressant. Bon le constructeur ne permet pas d'envoyer un nombre infini de chaînes à la liste, par contre on peut voir dans la doc que l'opérateur << est surchargé. Cela va nous permettre de "remplir" notre liste de chaînes très facilement !
Code : C++1
2
3
4
5
6 | void MaFenetre::ouvrirDialogue()
{
QStringList pays;
pays << "France" << "Belgique" << "Suisse" << "Canada (québec)" << "Maroc" << "Autre";
QInputDialog::getItem(this, "Votre pays", "De quel pays es-tu, cher Zéro ?", pays);
}
|
Pensez à inclure le header de la classe QStringList avant de vous en servir, sinon le compilateur vous dira que la classe QStringList est indéfinie !
Et voilà, obstacle surmonté avec succès
La boîte de dialogue "Sélectionner une police" est une des boîtes de dialogue standard les plus connues. Nul doute que vous l'avez déjà rencontrée dans l'un de vos programmes favoris.
La boîte de dialogue de sélection de police est gérée par la classe
QFontDialog. Celle-ci propose en gros une seule méthode statique surchargée (il y a plusieurs façons de l'utiliser), comme vous pouvez le constater sur la
doc de QFontDialog.
Prenons le prototype le plus compliqué, juste pour la forme
Code : C++1 | QFont getFont ( bool * ok, const QFont & initial, QWidget * parent, const QString & caption )
|
Les paramètres se comprennent normalement assez facilement.
On retrouve notre pointeur vers un booléen "ok" qui permet de savoir si l'utilisateur a cliqué sur OK ou a annulé.
On peut spécifier une police par défaut (initial), il faudra envoyer un objet de type QFont. Voilà justement que la classe QFont réapparaît
Enfin, la chaîne caption correspond au message qui sera affiché en haut de la fenêtre.
Enfin, et surtout, la méthode retourne un objet de type QFont correspondant à la police qui a été choisie.
Testons ! Histoire d'aller un peu plus loin, je propose que la police que nous aurons sélectionnée soit immédiatement appliquée au texte de notre bouton, par l'intermédiaire de la méthode setFont() que nous avons appris à utiliser il y a quelques chapitres.
Code : C++ 1
2
3
4
5
6
7
8
9
10
11 | void MaFenetre::ouvrirDialogue()
{
bool ok = false;
QFont police = QFontDialog::getFont(&ok, m_boutonDialogue->font(), this, "Choisissez une police");
if (ok)
{
m_boutonDialogue->setFont(police);
}
}
|
La méthode getFont prend comme police par défaut celle qui est utilisée par notre bouton m_boutonDialogue (rappelez-vous, font() est une méthode accesseur qui renvoie un QFont).
On teste si l'utilisateur a bien validé la fenêtre, et si c'est le cas on applique la police qui vient d'être choisie à notre bouton.
C'est l'avantage de travailler avec les classes de Qt : elles sont cohérentes. La méthode getFont renvoie un QFont, et ce QFont nous pouvons l'envoyer à notre tour à notre bouton pour qu'il change d'apparence.
Le résultat ? Le voici :
Attention le bouton ne se redimensionne pas tout seul. Vous pouvez le rendre plus large de base si vous voulez, ou bien le redimensionner après le choix de la police.
Dans la même veine que la sélection de police, on connaît probablement tous la boîte de dialogue "Sélection de couleur".
Utilisez la classe
QColorDialog et sa méthode statique
getColor().
Code : C++1 | QColor QColorDialog::getColor ( const QColor & initial = Qt::white, QWidget * parent = 0 );
|
Elle retourne un objet de type QColor. Vous pouvez préciser une couleur par défaut, en envoyant un objet de type QColor ou en utilisant une des
constantes prédéfinies de couleur. En l'absence de paramètre, c'est la couleur blanche qui sera sélectionnée comme nous l'indique le prototype.
Si on veut tester le résultat en appliquant la nouvelle couleur au bouton, c'est un petit peu compliqué. En effet, il n'existe pas de méthode setColor pour les widgets, mais une méthode setPalette qui sert à indiquer une palette de couleurs. Je vous laisse vous renseigner plus amplement si vous le désirez sur la
classe QPalette qui est intéressante.
Le code que je vous propose ci-dessous ouvre une boîte de dialogue de sélection de couleur, puis crée une palette dont la couleur du texte correspond à la couleur qu'on vient de sélectionner, et applique enfin cette palette au bouton :
Code : C++1
2
3
4
5
6
7
8 | void MaFenetre::ouvrirDialogue()
{
QColor couleur = QColorDialog::getColor(Qt::white, this);
QPalette palette;
palette.setColor(QPalette::ButtonText, couleur);
m_boutonDialogue->setPalette(palette);
}
|
Je ne vous demande pas ici de comprendre comment fonctionne QPalette, qui est d'ailleurs une classe que je ne détaillerai pas plus dans le cours. A vous de vous renseigner sur elle si elle vous intéresse.
Le résultat de l'application est le suivant :
Allez, plus que la sélection de fichiers et de dossiers et on aura fait le tour d'à peu près toutes les boîtes de dialogue usuelles qui existent !
La sélection de fichiers et de dossiers est gérée par la
classe QFileDialog qui propose elle aussi des méthodes statiques faciles à utiliser.
Cette section sera divisée en 3 parties :
- Sélection d'un dossier existant
- Ouverture d'un fichier
- Enregistrement d'un fichier
Sélection d'un dossier existant (QFileDialog::getExistingDirectory)
Bon je ne vous donne plus le prototype, vous devriez être assez grands pour le retrouver dans la doc
On peut utiliser la méthode statique aussi simplement que comme ceci :
Code : C++1 | QString dossier = QFileDialog::getExistingDirectory(this);
|
Elle retourne un QString contenant le chemin complet vers le dossier demandé.
La fenêtre qui s'ouvre devrait ressembler à cela :
Ouverture d'un fichier (QFileDialog::getOpenFileName)
La célèbre boîte de dialogue "Ouverture d'un fichier" est gérée par getOpenFileName().
Sans paramètres particuliers, la boîte de dialogue permet d'ouvrir n'importe quel fichier.
Vous pouvez néanmoins créer un filtre (4ème paramètre) pour afficher par exemple uniquement les images.
Ce code demande d'ouvrir un fichier image. Le chemin vers le fichier est stocké dans un QString, que l'on affiche ensuite via une QMessageBox :
Code : C++1
2
3
4
5 | void MaFenetre::ouvrirDialogue()
{
QString fichier = QFileDialog::getOpenFileName(this, "Ouvrir un fichier", QString(), "Images (*.png *.gif *.jpg *.jpeg)");
QMessageBox::information(this, "Fichier", "Vous avez sélectionné :\n" + fichier);
}
|
Le troisième paramètre de getOpenFileName est le nom du répertoire par défaut dans lequel l'utilisateur est placé. J'ai laissé la valeur par défaut (QString(), ce qui est équivalent à écrire ""), donc la boîte de dialogue affichera par défaut le répertoire dans lequel est situé le programme.
Grâce au 4ème paramètre j'ai choisi de filtrer les fichiers. Seules les images de type PNG, GIF, JPG et JPEG s'afficheront.
Résultat :
La fenêtre bénéficie de toutes les options que propose votre OS, dont l'affichage des images sous forme de miniatures.
Lorsque vous cliquez sur "Ouvrir", le chemin est enregistré dans un QString qui s'affiche ensuite dans une boîte de dialogue :
Le principe de cette boîte de dialogue est de vous donner le chemin complet vers le fichier, mais pas de vous ouvrir ce fichier. C'est à vous ensuite de faire les opérations nécessaires pour ouvrir le fichier et l'afficher dans votre programme.
A noter aussi la fonction getOpenFileNames (notez le "s" à la fin) qui autorise la sélection de plusieurs fichiers. La principale différence est qu'au lieu de retourner un QString, elle retourne un QStringList (liste de chaînes). Tiens, comme on se retrouve !
Enregistrement d'un fichier (QFileDialog::getSaveFileName)
C'est le même principe que la méthode précédente, à la différence près que la personne peut cette fois spécifier un nom de fichier qui n'existe pas pour l'enregistrement. Le bouton "Ouvrir" est remplacé par "Enregistrer".
Code : C++1 | QString fichier = QFileDialog::getSaveFileName(this, "Enregistrer un fichier", QString(), "Images (*.png *.gif *.jpg *.jpeg)");
|
Je vous avais promis un chapitre simple, vous avez eu un chapitre simple !
En effet, les méthodes statiques ne sont rien d'autre que des "fonctions" comme en langage C, elles ne nécessitent donc pas de créer d'objets. Comme quoi, parfois le modèle objet est inadapté et ici c'était clairement le cas. Pour la plupart des classes que nous avons vues, on peut s'en sortir sans créer le moindre objet.
Ces considérations mises à part, le modèle objet reste quoiqu'il en soit très pratique lorsqu'on crée des GUI comme on le fait là. Et je peux vous dire qu'on n'a pas fini de tout découvrir
A titre informatif, il existe quelques autres boîtes de dialogue usuelles un peu plus rares et surtout un peu plus complexes à utiliser. Je pense notamment à :
- QProgressDialog : affiche une boîte de dialogue avec une barre de progression et un bouton "Annuler". Cela permet de faire patienter l'utilisateur le temps qu'une longue opération s'exécute. Cette classe est très intéressante mais il vaut mieux qu'on la voie en pratique si on a l'occasion, car Qt cherche à estimer le temps restant pour savoir s'il doit afficher ou non la fenêtre. C'est plus intéressant de le voir dans un cas très concret donc.
- QWizard : affiche un assistant, avec les boutons "Suivant", "Précédent", "Terminer"... Là encore il vaut mieux avoir un projet concret pour apprendre à utiliser cette classe car elle est assez complexe.
Ceci étant, vous pouvez aussi lire la documentation si vous en avez besoin maintenant, il y a tout ce qu'il faut dessus.
Mais... mais... je sais pas lire une doc moi, je sais pas où chercher l'information dont j'ai besoin, je suis perdu j'y comprends rien
Ah ouais ? C'est ce qu'on va voir !
On vous a pas encore fait de tuto pour vous apprendre à lire une doc à ce que je sache ? Alors c'est le moment d'apprendre !
Tutoriels
Communauté
Mon compte
Recherche
Livre d'or
Publicité
85 Zéros connectés |
8 requêtes |
0.0858s (0.0711s)
