Générateur de calculatrices

Nous utilisons le formulaire créé dans l’exemple « Calculator Form » pour montrer que la même interface utilisateur peut être générée lors de l’exécution de l’application ou définie lors de sa compilation.

Préparation

L’exemple « Calculator Form » définit une interface utilisateur que nous pouvons utiliser telle quelle. Dans cet exemple, nous utilisons un fichier de ressources pour contenir le fichier « calculatorform.ui » créé dans l’exemple précédent, mais celui-ci pourrait également être stocké sur le disque.

Pour générer un formulaire au moment de l’exécution, nous devons lier l’exemple à la bibliothèque de modules « QtUiTools ». Le fichier de projet que nous utilisons contient toutes les informations nécessaires à cette fin :

target_link_libraries(calculatorbuilder PRIVATE
    Qt6::UiTools
    Qt6::Widgets
)

Le fichier d’interface utilisateur est chargé à partir d’une ressource :

qt_add_resources(calculatorbuilder "calculatorbuilder"
    PREFIX
        "/forms"
    FILES
        "calculatorform.ui"
)

Pour qmake:

RESOURCES   = calculatorbuilder.qrc
SOURCES     = main.cpp
QT += widgets uitools

Tous les autres fichiers nécessaires sont déclarés comme d'habitude.

Chargement du formulaire « Calculator »

Nous allons devoir utiliser la classe ` QUiLoader ` fournie par la bibliothèque ` libQtUiTools ` ; nous devons donc d’abord nous assurer d’inclure le fichier d’en-tête correspondant à cette classe :

#include <QUiLoader>

Nous créons une fonction d’aide statique qui crée un widget de niveau supérieur et charge l’interface utilisateur que nous récupérons, via un objet ` QFile `, à partir des ressources de l’exemple :

static QWidget *loadCalculatorForm(QWidget *parent = nullptr)
{
    QFile file(u":/forms/calculatorform.ui"_s);
    if (!file.open(QFile::ReadOnly))
        return nullptr;

    QWidget *formWidget = QUiLoader().load(&file, parent);
    if (!formWidget)
        return nullptr;

En incluant l’interface utilisateur dans les ressources de l’exemple, nous nous assurons qu’elle sera présente lors de l’exécution de l’exemple. La fonction ` QUiLoader::load()` récupère la description de l’interface utilisateur contenue dans le fichier et construit le widget de formulaire en tant que widget enfant de ` CalculatorForm`.

Trois widgets de l’interface utilisateur générée nous intéressent : deux zones de saisie et une étiquette. Par souci de commodité, nous récupérons les pointeurs vers ces widgets à partir du widget construit par la fonction FormBuilder, et nous les enregistrons pour une utilisation ultérieure. La fonction modèle findChild() nous permet d’interroger les widgets afin de trouver des widgets enfants nommés.

    auto *inputSpinBox1 = formWidget->findChild<QSpinBox*>(u"inputSpinBox1"_s);
    auto *inputSpinBox2 = formWidget->findChild<QSpinBox*>(u"inputSpinBox2"_s);
    auto *outputWidget = formWidget->findChild<QLabel*>(u"outputWidget"_s);

Le slot qui modifie le widget de sortie fourni par le formulaire est défini de manière similaire à celui de l’exemple « Calculator Form », à l’exception du fait que nous utilisons un lambda, capturant les widgets trouvés :

    auto updateResult = [inputSpinBox1, inputSpinBox2, outputWidget]()
    {
        const int sum = inputSpinBox1->value() + inputSpinBox2->value();
        outputWidget->setText(QString::number(sum));
    };
    QObject::connect(inputSpinBox1, &QSpinBox::valueChanged, formWidget, updateResult);
    QObject::connect(inputSpinBox2, &QSpinBox::valueChanged, formWidget, updateResult);

Le widget de formulaire est ajouté à une disposition, et le titre de la fenêtre est défini :

auto *layout = new QVBoxLayout(&w);
layout->addWidget(formWidget);
w.setWindowTitle(QCoreApplication::translate("CalculatorForm",
                                             "Calculator Builder"));

L’avantage de cette approche est que nous pouvons remplacer le formulaire lors de l’exécution de l’application, tout en conservant la possibilité de manipuler les widgets qu’il contient, à condition qu’ils portent des noms appropriés.

Cependant, le chargement d’un formulaire à l’exécution entraîne un coût d’exécution par rapport à sa conversion en code C++ à l’aide de l’outil «User Interface Compiler » (uic).

Exemple de projet sur code.qt.io