Combo Widget Mapper Beispiel

Wir erstellen eine Klasse Window mit einer fast identischen Benutzeroberfläche, mit der Ausnahme, dass wir anstelle eines Drehfelds, in das das Alter jeder Person eingegeben werden kann, ein Kombinationsfeld bereitstellen, mit dem die Adressen als "Privat", "Arbeit" oder "Sonstiges" klassifiziert werden können.

Definition der Personenklasse

Wir definieren eine Struktur Person, die Name, Adresse und Adresstyp enthält, um die Modelldaten darzustellen:

struct Person
{
private:
    Q_GADGET
    Q_PROPERTY(QString name MEMBER name)
    Q_PROPERTY(QString address MEMBER address)
    Q_PROPERTY(QString type MEMBER type)
public:

    QString name;
    QString address;
    QString type;
};

Sie wird als Q_GADGET deklariert, wobei die Mitglieder gleichnamige Eigenschaften sein sollen, um eine QRangeModel bequem ausfüllen zu können.

Definition der Fensterklasse

Die Klasse bietet einen Konstruktor und einen Slot, um die Schaltflächen auf dem neuesten Stand zu halten:

class Window : public QWidget
{
    Q_OBJECT

public:
    Window(QWidget *parent = nullptr);

private slots:
    void updateButtons(int row);

private:
    QLineEdit *nameEdit;
    QTextEdit *addressEdit;
    QComboBox *typeComboBox;
    QPushButton *nextButton;
    QPushButton *previousButton;
    QList<Person> data;
    QRangeModel *model;
    QDataWidgetMapper *mapper;
};

Neben dem Objekt QDataWidgetMapper und den Steuerelementen, die für die Benutzeroberfläche verwendet werden, verwenden wir ein QList<Person>, um unsere Daten zu speichern, und ein QRangeModel, das auf diese Daten zugreift.

Implementierung der Fensterklasse

Der Konstruktor der Klasse Window kann in mehreren Teilen erklärt werden. Im ersten Teil richten wir die Widgets ein, die für die Benutzeroberfläche verwendet werden:

Window::Window(QWidget *parent)
    : QWidget(parent),
      nameEdit(new QLineEdit),
      addressEdit(new QTextEdit),
      typeComboBox(new QComboBox),
      nextButton(new QPushButton(tr("&Next"))),
      previousButton(new QPushButton(tr("&Previous"))),

Die Personenliste wird mit Hilfe einer Initalizer-Liste gefüllt, die dann an die QRangeModel übergeben wird:

      data{Person{u"Alice"_s,  u"<qt>123 Main Street<br/>Market Town</qt>"_s,                      u"0"_s},
           Person{u"Bob"_s,    u"<qt>PO Box 32<br/>Mail Handling Service<br/>Service City</qt>"_s, u"1"_s},
           Person{u"Carol"_s,  u"<qt>The Lighthouse<br/>Remote Island</qt>"_s,                     u"2"_s},
           Person{u"Donald"_s, u"<qt>47338 Park Avenue<br/>Big City</qt>"_s,                       u"0"_s},
           Person{u"Emma"_s,   u"<qt>Research Station<br/>Base Camp<br/>Big Mountain</qt>"_s,      u"2"_s}},
      model(new QRangeModel(data, this)),
      mapper(new QDataWidgetMapper(this))

Beachten Sie, dass wir die Zuordnung des Kombinationsfeldes auf dieselbe Weise einrichten wie bei den anderen Widgets, dass wir aber ein eigenes Modell mit Informationen über die Adresstypen darauf anwenden, so dass es die Zeichenkette des Adresstyps anstelle der Daten aus dem Modell anzeigt, das Daten über jede Person enthält:

    typeComboBox->setModel(new QStringListModel({ tr("Home"), tr("Work"), tr("Other") }, this));

Als Nächstes richten wir den Widget-Mapper ein, der jedes Eingabe-Widget mit einer Spalte in dem durch den Aufruf von setModel() angegebenen Modell verknüpft:

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

Für das Kombinationsfeld übergeben wir ein zusätzliches Argument, um dem Widget-Mapper mitzuteilen, welche Eigenschaft mit Werten aus dem Modell verknüpft werden soll. Als Ergebnis kann der Benutzer ein Element aus der Combobox auswählen, und der entsprechende Wert, der in der Eigenschaft currentIndex des Widgets gespeichert ist, wird im Modell gespeichert.

Der Rest des Konstruktors richtet Verbindungen und Layouts ein:

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

    auto *formLayout = new QFormLayout;
    formLayout->addRow(tr("Na&me:"), nameEdit);
    formLayout->addRow(tr("&Address:"), addressEdit);
    formLayout->addRow(tr("&Type:"), typeComboBox);

    auto *buttonLayout = new QVBoxLayout;
    buttonLayout->addWidget(previousButton);
    buttonLayout->addWidget(nextButton);
    buttonLayout->addStretch();

    auto *mainLayout = new QHBoxLayout(this);
    mainLayout->addLayout(formLayout);
    mainLayout->addLayout(buttonLayout);

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

Der Vollständigkeit halber zeigen wir die Implementierung des updateButtons() Slots:

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

Zusammenfassung und weiterführende Literatur

Die Verwendung eines separaten Modells für das Kombinationsfeld bietet ein Menü mit Auswahlmöglichkeiten, die von den im Hauptmodell gespeicherten Daten getrennt sind. Die Verwendung eines benannten Mappings, das die Eigenschaft currentIndex des Kombinationsfeldes mit einer Spalte im Modell verknüpft, ermöglicht es uns, einen Nachschlagewert im Modell zu speichern.

Wenn wir jedoch das Modell außerhalb des Kontexts des Widget-Mappers lesen, müssen wir über typeModel Bescheid wissen, um diese Nachschlagewerte verstehen zu können. Es wäre nützlich, sowohl die Daten als auch die Auswahlmöglichkeiten von typeModel an einem Ort zu speichern. Dies wird durch das SQL Widget Mapper Beispiel abgedeckt.

Beispielprojekt @ code.qt.io