Tutoriel sur les widgets

Introduction

Les widgets constituent les éléments de base des applications d’interface utilisateur graphique (GUI) développées avec Qt. Chaque composant GUI (par exemple, les boutons, les étiquettes, les éditeurs de texte) est un « widget » placé à un emplacement donné dans une fenêtre d’interface utilisateur, ou affiché sous la forme d’une fenêtre indépendante. Chaque type de widget est fourni par une sous-classe de ` QWidget`, qui est elle-même une sous-classe de ` QObject`.

QWidget n’est pas une classe abstraite. Elle peut servir de conteneur pour d’autres widgets et peut être sous-classée très facilement pour créer de nouveaux widgets personnalisés. La classe ` QWidget ` est souvent utilisée pour créer une fenêtre à l’intérieur de laquelle d’autres objets ` QWidget` sont placés.

Comme pour les ` QObject`, les ` QWidget` peuvent être créés avec des objets parents pour indiquer la propriété, ce qui garantit que les objets sont supprimés lorsqu’ils ne sont plus utilisés. Avec les widgets, ces relations parent-enfant ont une signification supplémentaire : chaque widget enfant s’affiche dans la zone d’écran occupée par son widget parent. Cela signifie que lorsque vous supprimez un widget fenêtre, tous les widgets enfants qu’il contient sont également supprimés.

Écriture d’une fonction Main

La plupart des exemples d’interface graphique fournis avec Qt suivent le modèle consistant à disposer d’un fichier ` main.cpp `, qui contient le code standard permettant d’initialiser l’application, ainsi qu’un nombre variable d’autres fichiers source/en-tête contenant la logique de l’application et les composants personnalisés de l’interface graphique.

Une fonction ` main() ` typique dans ` main.cpp ` se présente comme suit :

#include <QtWidgets>

// Include header files for application components.
// ...

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    // Set up and show widgets.
    // ...

    return app.exec();
}

Tout d’abord, un objet ` QApplication ` est instancié ; celui-ci peut être configuré à l’aide d’arguments transmis depuis la ligne de commande. Une fois les widgets créés et affichés, la fonction ` QApplication::exec()` est appelée pour lancer la boucle d’événements de Qt. Le contrôle est alors transféré à Qt jusqu’à ce que cette fonction renvoie une valeur. Enfin, la fonction ` main() ` renvoie la valeur retournée par ` QApplication::exec()`.

Exemples de widgets simples

Chacun de ces exemples de widgets simples est entièrement écrit au sein de la fonction ` main() `.

• Création d’une fenêtre
• Création de widgets enfants
• Utilisation des mises en page
• Dispositions imbriquées

Exemples concrets de widgets

Dans ces exemples plus avancés, le code qui crée les widgets et les mises en page est stocké dans d'autres fichiers. Par exemple, l'interface graphique d'une fenêtre principale peut être créée dans le constructeur d'une sous-classe de ` QMainWindow `.

Compilation des exemples

Si vous avez installé un paquet binaire pour obtenir Qt, ou si vous avez compilé Qt vous-même, les exemples décrits dans ce tutoriel devraient déjà être compilés et prêts à être exécutés. Si vous souhaitez les modifier et les recompiler, procédez comme suit :

1. Dans une invite de commande, accédez au répertoire contenant l’exemple que vous avez modifié.
2. Tapez ` qmake ` et appuyez sur ` Return`. Si cela ne fonctionne pas, assurez-vous que l'exécutable se trouve dans votre chemin d'accès, ou indiquez son emplacement complet.
3. Sous Linux/Unix et macOS, tapez « make » puis appuyez sur « Return » ; sous Windows avec Visual Studio, tapez « nmake » puis appuyez sur « Return ».

Un fichier exécutable est créé dans le répertoire courant. Sous Windows, ce fichier peut se trouver dans un sous-répertoire nommé « debug » ou « release ». Vous pouvez exécuter ce fichier exécutable pour voir le code d'exemple en action.