Programmation Qt/La fenêtre principale

Programmation Qt

• Avant-propos
• Introduction
• Développer pour Windows 64 bits
• Un premier programme
• Signaux et slots
• Projet Qt
• Classes et objets Qt
• Extensions du langage C++
• Utilisation de Qt Creator
  • Créer un projet
• Les widgets
• Le positionnement des widgets
• La fenêtre principale
• TP : un éditeur de texte
• Traduire son programme
• Sauvegarder des données avec XML
• Sauvegarder des données avec SQL
• TP : un navigateur web
• Utilisation de Qt Designer
• Utiliser la documentation Qt
• Distribuer son programme
• Ressources

Annexes

• Glossaire

La fenêtre principale permet l'utilisation de nombreux outils. Pour cela, on utilisera la classe QMainWindow.

Utiliser les outils de la fenêtre principale

Connaître les différents outils

Pour connaître les différents outils, quelque chose de simple :

• Les menus : Fichier, Édition, ...
• La barre d'outils : les petites icônes, dans Qt Creator Compiler, Exécuter, Déboguer, etc...
• Les docks : rarement utilisés, ce sont par exemple la liste des fichiers ouverts dans Qt Creator.
• La zone centrale : la partie la plus importante, dans Qt Creator le code source.
• La barre d'état : comme son nom l'indique, l'état de la fenêtre. Par exemple, dans un navigateur web, vous pourrez avoir la durée de chargement.

Les menus

Pour notre chapitre, nous irons de haut en bas, et c'est bien pour cela que nous commençons avec les menus. C'est le plus utilisé (si on ne compte pas la zone centrale), et la grande majorité des programmes en ont. Pour commencer, nous allons étudier un code :

QMenu *menuFichier = menuBar()->addMenu("Fichier", this);

Première ligne de code, premier changement ! Eh bien oui, c'est la méthode addMenu() de menuBar() que nous allons appeler. À noter : nous sommes dans une classe qui dérive de QMainWindow, si vous regardez bien. Si votre code n'est que dans un seul fichier (trèèès mauvais), vous devrez écrire maFenetrePrincipale->menuBar()->addMenu().

Ajouter une action

C'est bien beau, mais, si vous compilez, et que vous cliquez sur votre menu, rien ne s'ouvre ! Qt ne sait absolument pas que le menu Fichier contiendra une action Nouveau, et c'est ce que nous allons faire :

QAction *actionNouveauFichier = new QAction("Nouveau fichier");
menuFichier->addAction(actionNouveauFichier);

Il faudra penser à rajouter des actions. Autre chose, il y a juste marqué Nouveau fichier. C'est banal ! Arrangeons ça !

actionNouveauFichier->setIcon(QIcon("nouveau-fichier.png"));
actionNouveauFichier->setShortcut(QKeySequence("Ctrl+N"));

Et si notre action est Gras, on peut faire ceci :

QAction *actionGras = new QAction("Gras");
actionGras->setIcon(QIcon("gras.png"));
actionGras->setCheckable(true);
menuEdition->addAction(actionGras);

Dans le système d'exploitation Mac OS X, vous ne pouvez pas créer d'action du nom de “Quitter“, car celle-ci est créée automatiquement par l'OS.

Créer des sous-menus

Si la personne a par exemple la liste des fichiers récents, il faut procéder comme ceci :

QMenu *menuFichier = menuBar()->addMenu("Fichier", this);
QMenu *menuFichiersRecents = new QMenu("Fichiers récents");
QAction *actionFichierPro = new QAction("Un certain fichier *.pro");
QAction *actionFichierH = new QAction("Un certain fichier *.h");
QAction *actionFichierCpp = new QAction("Un certain fichier *.cpp");
menuFichiersRecents->addAction(actionFichierPro);
menuFichiersRecents->addAction(actionFichierH);
menuFichiersRecents->addAction(actionFichierCpp);
menuFichier->addMenu(menuFichiersRecents);

Cette fois-ci, on utilise la méthode addMenu().

La barre d'outils

Pour afficher des actions dont l'utilisateur aura le plus besoin, on utilise la barre d'outils qui nous permet de ne pas passer par les menus. Et ce qui est très pratique, c'est que nous pouvons réutiliser toutes les actions du menu !

QToolBar *barreDoutilsFichier = addToolBar("Fichier");
QAction *actionQuitter = new QAction("Fermer la fenêtre");
barreDoutilsFichier->addAction(actionQuitter);

Les docks

Un QDockWidget qui contient un QCalendarWidget.

Le principe des docks est assez simple : la classe QDockWidget contient nos widgets, et on les ajoute à la QMainWindow :

QDockWidget *dock = new QDockWidget(tr("Dock Widget"), this);
QPushButton *button = new QPushButton(tr("Button in a Dock Widget"));
dock->setWidget(button);
addDockWidget(Qt::LeftDockWidgetArea, dock);

On vient donc d'insérer un dock qui sera placé à gauche de la fenêtre. Pour ajouter plusieurs widgets dans un même dock, on peut utiliser un layout puis la méthode setLayout() de la classe QDockWidget. Bien évidemment, l'utilisateur pour en faire une fenêtre à par entière qu'il pourra ensuite remettre autant à gauche qu'à droite.

L'espace principal

Pour l'espace principal, il y a deux choix : un SDI, c'est-à-dire une seule fenêtre dans la fenêtre, ou un MDI, c'est-à-dire plusieurs fenêtres qui vont se glisser dans le cadre principal.

SDI

Pour créer un SDI (Single Document Interface), c'est très simple. Vous créez un widget conteneur (souvent un QWidget), puis vous utilisez la méthode setCentralWidget(), qui accepte votre conteneur.

MDI

Pour l'espace MDI (Multiple Document Interface), c'est un peu différent. Voici un exemple :

QMdiArea *zoneMDI = new QMdiArea();

QPushButton *button = new QPushButton();
QDateEdit *dateEdit = new QDateEdit();

QMdiSubWindow *mdiSubWindow1 = zoneMDI->addSubWindow(button);
QMdiSubWindow *mdiSubWindow2 = zoneMDI->addSubWindow(dateEdit);

setCentralWidget(zoneMDI);

Effectivement, nous utilisons le principe du SDI car on remarque setCentralWidget(). Pour notre MDI, la fenêtre n'a pas ses “propres” outils pour en créer, mais on utilise la classe QMdiArea qui contiendra des QMdiSubWindow, qu'on ajoute avec la méthode addSubWindow() d'une QMdiArea. Ces QMdiSubWindow contiendront les widgets de la sous-fenêtre.

La barre d'état

Aussi appelée barre de statut, la barre d'état est un “bandeau” en bas de la fenêtre qui indique l'état de la fenêtre. Regardez l'exemple ci-dessous :

statusBar()->showMessage(tr("Bienvenue !"), 2000);
QProgressBar *progressBar = new QProgressBar();
progressBar->setValue(75);
statusBar()->addWidget(progressBar, 16);

Ici, nous supposons que nous sommes dans une classe de type QMainWindow, qui intègre directement la classe qui permet de créer une barre d'état : QStatusBar. Nous utilisons le plus souvent ces méthodes : showMessage() et addWidget(). La première méthode permet d'afficher un message, avec deux choix : soit nous indiquons directement le message, qui s'affichera alors jusqu'à ce que l'utilisateur passe dessus avec la souris ou qu'un autre message s'affiche, soit nous indiquons et le message et le temps qu'il doit rester, en millisecondes (vous prenez le nombre de secondes et vous multipliez par 1000). La deuxième méthode permet d'insérer un widget dans la barre d'état, ici une barre de progression, mais cela peut être un bouton, un champ, etc.

Vous êtes maintenant prêt à réaliser un TP qui utilise plus que jamais les éléments de la fenêtre principale. Eh oui, c'est un éditeur de texte que vous allez réaliser dans le prochain chapitre →.

En résumé

• La fenêtre principale est gérée par la classe QMainWindow.
• On peut créer des menus, des barres d'outils, des docks et une barre d'état. On peut aussi gérer l'espace principal avec un SDI ou un MDI.
• Les menus sont créés avec les classes QMenu et QAction. Pour ajouter créer un menu, on utilise menuBar()->addMenu("Nom du menu', this) On ajoute une action avec la méthode addAction().
• La barre d'outils réutilise les actions des menus sous forme d'icône. On les crée avec la méthode addToolBar("Nom de la barre d'outils"). De même, on y ajoute une action avec addAction().
• Les docks sont des gros conteneurs latéraux. La classe QDockWidget permet de les créer, puis on les ajoute avec addDockWidget(Qt::Left/RightDockWidgetArea, monDock).
• Enfin, la barre d'état s'utilise avec l'objet statusBar(), un objet QStatusBar automatiquement créé par la classe QMainWindow. On y affiche un message avec la méthode showMessage("Message", nbMillisecondes) et un widget avec addWidget().