Exemple de mappeur de widgets Combo

L'exemple Combo Widget Mapper montre comment utiliser un délégué personnalisé pour faire correspondre les informations d'un modèle à des widgets spécifiques sur un formulaire.

Nous créons une classe Window avec une interface utilisateur presque identique, à ceci près qu'au lieu de fournir une boîte tournante permettant de saisir l'âge de chaque personne, nous fournissons une boîte combinée permettant de classer leurs adresses dans les catégories "Domicile", "Travail" ou "Autre".

Définition de la classe de fenêtre

La classe fournit un constructeur, un slot pour maintenir les boutons à jour et une fonction privée pour configurer le modèle :

class Window : public QWidget
{
    Q_OBJECT

public:
    Window(QWidget *parent = nullptr);

private slots:
    void updateButtons(int row);

private:
    void setupModel();

    QLabel *nameLabel;
    QLabel *addressLabel;
    QLabel *typeLabel;
    QLineEdit *nameEdit;
    QTextEdit *addressEdit;
    QComboBox *typeComboBox;
    QPushButton *nextButton;
    QPushButton *previousButton;

    QStandardItemModel *model;
    QStringListModel *typeModel;
    QDataWidgetMapper *mapper;
};

Outre l'objet QDataWidgetMapper et les contrôles utilisés pour composer l'interface utilisateur, nous utilisons un objet QStandardItemModel pour contenir nos données et un objet QStringListModel pour contenir des informations sur les types d'adresses qui peuvent être appliqués aux données de chaque personne.

Mise en œuvre de la classe Window

Le constructeur de la classe Window peut être expliqué en trois parties. Dans la première partie, nous configurons les widgets utilisés pour l'interface utilisateur :

Window::Window(QWidget *parent)
    : QWidget(parent)
{
    setupModel();

    nameLabel = new QLabel(tr("Na&me:"));
    nameEdit = new QLineEdit();
    addressLabel = new QLabel(tr("&Address:"));
    addressEdit = new QTextEdit();
    typeLabel = new QLabel(tr("&Type:"));
    typeComboBox = new QComboBox();
    nextButton = new QPushButton(tr("&Next"));
    previousButton = new QPushButton(tr("&Previous"));

    nameLabel->setBuddy(nameEdit);
    addressLabel->setBuddy(addressEdit);
    typeLabel->setBuddy(typeComboBox);

    typeComboBox->setModel(typeModel);

Notez que nous configurons le mappage de la boîte combo de la même manière que pour les autres widgets, mais que nous lui appliquons son propre modèle afin qu'elle affiche les données de son propre modèle, le typeModel, plutôt que celles du modèle contenant les données de chaque personne.

Ensuite, nous configurons le mappeur de widgets, en reliant chaque widget d'entrée à une colonne du modèle spécifié par l'appel à setModel() :

    mapper = new QDataWidgetMapper(this);
    mapper->setModel(model);
    mapper->addMapping(nameEdit, 0);
    mapper->addMapping(addressEdit, 1);
    mapper->addMapping(typeComboBox, 2, "currentIndex");

Pour la liste déroulante, nous passons un argument supplémentaire pour indiquer au cartographe de widgets quelle propriété doit être reliée aux valeurs du modèle. Ainsi, l'utilisateur peut sélectionner un élément dans la liste déroulante et la valeur correspondante stockée dans la propriété currentIndex du widget sera stockée dans le modèle.

Le reste du constructeur établit les connexions et les mises en page :

    connect(previousButton, &QAbstractButton::clicked,
            mapper, &QDataWidgetMapper::toPrevious);
    connect(nextButton, &QAbstractButton::clicked,
            mapper, &QDataWidgetMapper::toNext);
    connect(mapper, &QDataWidgetMapper::currentIndexChanged,
            this, &Window::updateButtons);

    QGridLayout *layout = new QGridLayout();
    layout->addWidget(nameLabel, 0, 0, 1, 1);
    layout->addWidget(nameEdit, 0, 1, 1, 1);
    layout->addWidget(previousButton, 0, 2, 1, 1);
    layout->addWidget(addressLabel, 1, 0, 1, 1);
    layout->addWidget(addressEdit, 1, 1, 2, 1);
    layout->addWidget(nextButton, 1, 2, 1, 1);
    layout->addWidget(typeLabel, 3, 0, 1, 1);
    layout->addWidget(typeComboBox, 3, 1, 1, 1);
    setLayout(layout);

    setWindowTitle(tr("Delegate Widget Mapper"));
    mapper->toFirst();
}

Le modèle est initialisé dans la fonction setupModel() de la fenêtre. Ici, nous créons un modèle standard avec 5 lignes et 3 colonnes. Dans chaque ligne, nous insérons un nom, une adresse et une valeur qui indique le type d'adresse. Les types d'adresse sont stockés dans un modèle de liste de chaînes.

void Window::setupModel()
{
    QStringList items;
    items << tr("Home") << tr("Work") << tr("Other");
    typeModel = new QStringListModel(items, this);

    model = new QStandardItemModel(5, 3, this);
    QStringList names;
    names << "Alice" << "Bob" << "Carol" << "Donald" << "Emma";
    QStringList addresses;
    addresses << "<qt>123 Main Street<br/>Market Town</qt>"
              << "<qt>PO Box 32<br/>Mail Handling Service"
                 "<br/>Service City</qt>"
              << "<qt>The Lighthouse<br/>Remote Island</qt>"
              << "<qt>47338 Park Avenue<br/>Big City</qt>"
              << "<qt>Research Station<br/>Base Camp<br/>Big Mountain</qt>";

    QStringList types;
    types << "0" << "1" << "2" << "0" << "2";

    for (int row = 0; row < 5; ++row) {
      QStandardItem *item = new QStandardItem(names[row]);
      model->setItem(row, 0, item);
      item = new QStandardItem(addresses[row]);
      model->setItem(row, 1, item);
      item = new QStandardItem(types[row]);
      model->setItem(row, 2, item);
    }
}

Lorsque nous insérons chaque ligne dans le modèle, comme un enregistrement dans une base de données, nous stockons des valeurs qui correspondent aux éléments de typeModel pour le type d'adresse de chaque personne. Lorsque le mappeur de widgets lit ces valeurs dans la dernière colonne de chaque ligne, il doit les utiliser comme références aux valeurs de typeModel, comme le montre le diagramme suivant. C'est là que le délégué est utilisé.

Nous montrons l'implémentation du slot updateButtons() par souci d'exhaustivité :

void Window::updateButtons(int row)
{
    previousButton->setEnabled(row > 0);
    nextButton->setEnabled(row < model->rowCount() - 1);
}

Résumé et lectures complémentaires

L'utilisation d'un modèle distinct pour la liste déroulante permet d'obtenir un menu de choix distinct des données stockées dans le modèle principal. L'utilisation d'un mappage nommé qui relie la propriété currentIndex de la liste déroulante à une colonne du modèle nous permet de stocker une valeur de consultation dans le modèle.

Cependant, lorsque nous lisons le modèle en dehors du contexte du mappeur de widgets, nous avons besoin de connaître le site typeModel pour donner un sens à ces valeurs de consultation. Il serait utile de pouvoir stocker à la fois les données et les choix détenus par typeModel en un seul endroit. Ceci est couvert par l'exemple SQL Widget Mapper.

Exemple de projet @ code.qt.io

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.