Comme tous les éléments d'une fenêtre, on dit que le bouton est un widget.
Avec Qt, on crée un bouton à l'aide de la classe QPushButton.
Comme vous le savez, une classe est constituée de 2 éléments :
- Des attributs : ce sont les "variables" internes de la classe.
- Des méthodes : ce sont les "fonctions" internes de la classe.
La règle d'encapsulation dit que les utilisateurs de la classe ne doivent pas pouvoir modifier les attributs : ceux-ci doivent donc tous être privés.
Or, je ne sais pas si vous avez remarqué, mais nous sommes justement des
utilisateurs des classes de Qt. Ce qui veut dire... que nous n'avons pas accès aux attributs puisque ceux-ci sont privés !
Hé, mais tu avais parlé d'un truc à un moment je crois... Les accesseurs, c'est pas ça ?
Ah... J'aime les gens qui ont de la mémoire
Effectivement oui, j'avais dit que le créateur d'une classe devait rendre ses attributs privés, mais du coup proposer des méthodes
accesseurs, c'est-à-dire des méthodes permettant de lire et de modifier les attributs de manière sécurisée (get et set ça vous dit rien ?).
Les accesseurs avec Qt
Justement, les gens qui ont créé Qt chez Trolltech sont des braves gars : ils ont codé proprement en respectant ces règles. Et il valait mieux qu'ils fassent bien les choses s'ils ne voulaient pas que leur bibliothèque devienne un véritable foutoir !
Du coup, pour chaque propriété d'un widget, on a :
- Un attribut : il est privé on ne peut pas le lire ni le modifier directement.
Exemple : text
- Un accesseur pour le lire : cet accesseur est une méthode constante qui porte le même nom que l'attribut (personnellement j'aurais plutôt mis un "get" devant pour ne pas confondre avec l'attribut, mais bon). Je vous rappelle qu'une méthode constante est une méthode qui s'interdit de modifier les attributs de la classe. Ainsi, vous êtes assuré que la méthode ne fait que lire l'attribut et qu'elle ne le modifie pas.
Exemple : text()
- Un accesseur pour le modifier : c'est une méthode qui se présente sous la forme setAttribut(). Elle modifie la valeur de l'attribut.
Exemple : setText()
Cette technique, même si elle paraît un peu lourde parce qu'il faut créer 2 méthodes pour chaque attribut, a l'avantage d'être parfaitement sûre. Grâce à ça, Qt peut vérifier que la valeur que vous essayez de donner est valide.
Cela permet d'éviter par exemple que vous ne donniez à une barre de progression la valeur "150%", alors que la valeur d'une barre de progression doit être comprise entre 0 et 100%.
Voyons voir sans plus tarder quelques propriétés des boutons que nous pouvons nous amuser à modifier à l'aide des accesseurs
Quelques exemples de propriétés des boutons
Il existe un grand nombre de propriétés éditables pour chaque widget, y compris le bouton. Nous n'allons pas toutes les voir ici, ni même plus tard d'ailleurs, je vous apprendrai à lire la doc pour toutes les découvrir
Cependant, je tiens à vous montrer les plus intéressantes d'entre elles pour que vous puissiez commencer à vous faire la main, et surtout pour que vous preniez l'habitude d'utiliser les accesseurs de Qt.
text : le texte
Cette propriété est probablement la plus importante : elle permet de modifier le texte présent sur le bouton.
En général, on définit le texte du bouton au moment de sa création car le constructeur accepte que l'on donne le texte du bouton dès sa création.
Toutefois, pour une raison ou une autre, vous pourriez être amené à modifier le texte présent sur le bouton au cours de l'exécution du programme. C'est là qu'il devient pratique d'avoir accès à l'attribut "text" du bouton
via ses accesseurs.
Pour chaque attribut, la documentation de Qt nous dit à quoi il sert et quels sont ses accesseurs. Voyez par exemple
ce que ça donne pour l'attribut text des boutons.
On vous indique de quel type est l'attribut. Ici, text est de type QString, comme tous les attributs qui stockent du texte avec Qt. En effet, Qt n'utilise pas la classe "string" standard du C++ mais sa propre version de la gestion des chaînes de caractères. En gros,
QString c'est un
string amélioré.
Puis, on vous explique en quelques mots à quoi sert cet attribut (
in english of course, il n'est jamais trop tard pour reprendre des cours d'anglais quel que soit votre âge
).
Enfin, on vous indique les accesseurs qui permettent de lire et de modifier l'attribut. Dans le cas présent, il s'agit de :
- QString text () const : c'est l'accesseur qui permet de lire l'attribut. Il retourne un QString, ce qui est logique puisque l'attribut est de type QString. Vous noterez la présence du mot-clé "const" qui indique que c'est une méthode constante qui ne modifie aucun attribut.
- void setText ( const QString & text ) : c'est l'accesseur qui permet de modifier l'attribut. Il prend un paramètre : le texte que vous voulez mettre sur le bouton.
A la longue, vous ne devriez pas avoir besoin de la doc pour savoir quels sont les accesseurs d'un attribut. Ca suit toujours le même schéma :
attribut() : permet de lire l'attribut.
setAttribut() : permet de modifier l'attribut.
Essayons donc de modifier le texte du bouton après sa création :
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | #include <QApplication>
#include <QPushButton>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QPushButton bouton("Salut les Zéros, la forme ?");
bouton.setText("Pimp mon bouton !");
bouton.show();
return app.exec();
}
|
Vous aurez noté que la méthode setText attend un QString et qu'on lui envoie une bête chaîne de caractères entre guillemets. En fait, ça fonctionne comme la classe string : les chaînes de caractères entre guillemets sont automatiquement converties en QString. Heureusement d'ailleurs, sinon ça serait lourd de devoir créer un objet de type QString juste pour ça !
Résultat :
Le résultat n'est peut-être pas très impressionnant, mais ça montre bien ce qui se passe :
- On crée le bouton et on lui donne le texte "Salut les Zéros, la forme ?" à l'aide du constructeur.
- On modifie le texte présent sur le bouton pour afficher "Pimp mon bouton !".
Au final, c'est "Pimp mon bouton !" qui s'affiche.
Pourquoi ? Parce que le nouveau texte a "écrasé" l'ancien. C'est exactement comme si on faisait :
Code : C++ | int x = 1;
x = 2;
cout << x;
|
... Lorsqu'on affiche x, il vaut 2.
C'est pareil pour le bouton. Au final, c'est le tout dernier texte qui sera affiché.
Bien entendu, ce qu'on vient de faire est complètement inutile : autant donner le bon texte directement au bouton lors de l'appel du constructeur. Toutefois, setText() se révèlera utile plus tard lorsque vous voudrez modifier le contenu du bouton au cours de l'exécution. Par exemple, lorsque l'utilisateur aura donné son nom, le bouton pourra changer de texte pour dire "Bonjour M. Dupont !".
toolTip : l'infobulle
Il est courant d'afficher une petite aide sous la forme d'une infobulle qui apparaît lorsqu'on pointe sur un élément avec la souris.
L'infobulle peut afficher un court texte d'aide. On la définit à l'aide de la propriété toolTip.
Pour modifier l'infobulle, la méthode à appeler est donc... setToolTip ! Bah vous voyez, c'est facile quand on a compris comment Qt était organisé
Code : C++ 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15 | #include <QApplication>
#include <QPushButton>
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
QPushButton bouton("Pimp mon bouton !");
bouton.setToolTip("Texte d'aide");
bouton.show();
return app.exec();
}
|
Une infobullefont : la police
Avec la propriété font, les choses se compliquent. En effet, jusqu'ici on avait juste eu à envoyer une chaîne de caractères en paramètres, qui était en fait convertie en objet de type QString.
La propriété font est un peu plus complexe car elle contient 3 informations :
- Le nom de la police de caractères utilisée (Times New Roman, Arial, Comic Sans MS...)
- La taille du texte en pixels (12, 16, 18...)
- Le style du texte (gras, italique...)
La signature de la méthode setFont est :
void setFont ( const QFont & )
Cela veut dire que setFont attend un objet de type QFont !
Bon, comment on fait pour lui donner un objet de type QFont nous ?
Eh bien c'est simple : il... suffit de créer un objet de type QFont !
La doc nous indique
tout ce que nous avons besoin de savoir sur QFont, en particulier les informations qu'il faut donner à son constructeur. Je n'attends pas de vous encore que vous soyez capable de lire la doc de manière autonome, je vais donc vous mâcher le travail (mais profitez-en parce que ça ne durera pas éternellement
).
Pour faire simple, le constructeur de QFont attend 4 paramètres. Voici son prototype :
QFont ( const QString & family, int pointSize = -1, int weight = -1, bool italic = false )
En fait, avec Qt il y a rarement un seul constructeur par classe. Les développeurs de Qt profitent des fonctionnalités du C++ et ont donc tendance à beaucoup surcharger les constructeurs. Certaines classes possèdent même plusieurs dizaines de constructeurs différents !
Pour QFont, celui que je vous montre là est néanmoins le principal et le plus utilisé. Et le plus simple aussi, tant qu'à faire.
Seul le premier argument est obligatoire : il s'agit du nom de la police à utiliser. Les autres, comme vous pouvez le voir, possèdent des valeurs par défaut donc nous ne sommes pas obligés de les indiquer.
Dans l'ordre, les paramètres signifient :
- family : le nom de la police de caractères à utiliser.
- pointSize : la taille des caractères en pixels.
- weight : le niveau d'épaisseur du trait (gras). Cette valeur peut être comprise entre 0 et 99 (du plus fin au plus gras). Vous pouvez aussi utiliser la constante QFont::Bold qui correspond à une épaisseur de 75.
- italic : un booléen pour dire si le texte doit être affiché en italique ou non.
On va faire quelques tests. Tout d'abord, il va falloir créer un objet de type QFont :
Code : C++ | QFont maPolice("Courier");
|
J'ai appelé cet objet maPolice.
Maintenant, je dois envoyer l'objet maPolice de type QFont à la méthode setFont de mon bouton (suivez, suivez !) :
Code : C++ | bouton.setFont(maPolice);
|
En résumé, j'ai donc dû écrire 2 lignes pour changer la police :
Code : C++ | QFont maPolice("Courier");
bouton.setFont(maPolice);
|
C'est un peu fastidieux. Il existe une solution plus maligne, si on ne compte pas se resservir de la police plus tard, c'est de définir l'objet de type QFont au moment de l'appel à la méthode setFont. Ca nous évite d'avoir à donner un nom bidon à l'objet comme on l'a fait ici (maPolice), c'est plus court, ça va plus vite, bref c'est mieux en général
Code : C++ | bouton.setFont(QFont("Courier"));
|
Voilà, en imbriquant comme ça ça marche très bien. La méthode setFont veut un objet de type QFont ? Qu'à cela ne tienne, on lui en crée un à la volée !
Voici le résultat :
Maintenant, on peut exploiter un peu plus le constructeur de QFont en utilisant une autre police plus fantaisiste et en augmentant la taille des caractères :
Code : C++ | bouton.setFont(QFont("Comic Sans MS", 20));
|
Et voilà le même avec du gras et de l'italique !
Code : C++ | bouton.setFont(QFont("Comic Sans MS", 20, QFont::Bold, true));
|
Bref, si vous avez compris le
principe des paramètres par défaut (et j'espère que vous avez compris depuis le temps !
), ça ne devrait vous poser aucun problème.
cursor : le curseur de la souris
Avec la propriété cursor, vous pouvez déterminer quel curseur de la souris doit s'afficher lorsqu'on pointe sur le bouton.
Le plus simple est d'utiliser une des
constantes de curseurs prédéfinis parmi la liste qui s'offre à vous.
Ce qui peut donner par exemple, si on veut qu'une main s'affiche :
Code : C++ | bouton.setCursor(Qt::PointingHandCursor);
|
icon : l'icône du bouton
Après tout ce qu'on vient de voir, rajouter une icône au bouton va vous paraître très simple : la méthode setIcon attend juste un objet de type QIcon.
Un QIcon peut se construire très facilement en donnant le nom du fichier image à charger.
Prenons par exemple ce petit smiley souriant :
Il s'agit d'une image au format PNG que sait lire Qt.
Code : C++ | bouton.setIcon(QIcon("smile.png"));
|
Attention, sous Windows pour que cela fonctionne, votre icône smile.png doit se trouver dans le même dossier que l'exécutable (ou dans un sous-dossier si vous écrivez "dossier/smile.png").
Sous Linux, il faut que votre icône soit dans votre répertoire HOME. Si vous voulez utiliser le chemin de votre application, comme cela se fait sous Windows par défaut, écrivez :
Code : C++ | QIcon(QCoreApplication::applicationDirPath() + "/smile.png");
|
Cela aura pour effet d'afficher l'icône à condition que celle-ci se trouve dans le même répertoire que l'exécutable.
Si vous avez fait ce qu'il fallait, l'icône devrait alors apparaître comme ceci :
Personnaliser les widgets
". Faites-moi confiance c'est tout 
blox
tùm
Trouvez une formation
Suggestions
Flux RSS News
Twitter
Facebook
Google+