Beispiel „Menüs“

Ein Menü-Widget kann entweder ein Pulldown-Menü in einer Menüleiste oder ein eigenständiges Kontextmenü sein. Pulldown-Menüs werden von der Menüleiste angezeigt, wenn der Benutzer auf den entsprechenden Eintrag klickt oder die angegebene Tastenkombination drückt. Kontextmenüs werden in der Regel durch eine spezielle Taste auf der Tastatur oder durch einen Rechtsklick aufgerufen.

Ein Menü besteht aus einer Liste von Aktionselementen. In Anwendungen können viele gängige Befehle über Menüs, Symbolleisten-Schaltflächen sowie Tastenkombinationen aufgerufen werden. Da der Benutzer erwartet, dass die Befehle unabhängig von der verwendeten Benutzeroberfläche auf die gleiche Weise ausgeführt werden, ist es sinnvoll, jeden Befehl als Aktion darzustellen.

Das Beispiel „Menüs“ besteht aus einer einzigen Klasse, „ MainWindow “, die von der Klasse „ QMainWindow “ abgeleitet ist. Wenn in unserer Anwendung einer der Aktionspunkte ausgewählt wird, wird der Pfad des Elements in ihrem zentralen Widget angezeigt.

Definition der Klasse „MainWindow“

QMainWindow stellt ein Hauptanwendungsfenster bereit, das eine Menüleiste, Symbolleisten, Andock-Widgets und eine Statusleiste um ein großes zentrales Widget herum enthält.

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow();

protected:
#ifndef QT_NO_CONTEXTMENU
    void contextMenuEvent(QContextMenuEvent *event) override;
#endif // QT_NO_CONTEXTMENU

In diesem Beispiel werden wir sehen, wie man Pulldown-Menüs sowie ein Kontextmenü implementiert. Um ein benutzerdefiniertes Kontextmenü zu implementieren, müssen wir die Funktion ` contextMenuEvent()` von ` QWidget` neu implementieren, um die Kontextmenü-Ereignisse für unser Hauptfenster zu empfangen.

private slots:
    void newFile();
    void open();
    void save();
    void print();
    void undo();
    void redo();
    void cut();
    void copy();
    void paste();
    void bold();
    void italic();
    void leftAlign();
    void rightAlign();
    void justify();
    void center();
    void setLineSpacing();
    void setParagraphSpacing();
    void about();
    void aboutQt();

Außerdem müssen wir eine Reihe privater Slots implementieren, um auf die Aktivierung eines unserer Menüeinträge durch den Benutzer zu reagieren. Beachten Sie, dass diese Slots in dieser Dokumentation weggelassen werden, da sie trivial sind, d. h., die meisten von ihnen zeigen lediglich den Pfad der Aktion im zentralen Widget des Hauptfensters an.

private:
    void createActions();
    void createMenus();

Wir haben uns dafür entschieden, den Konstruktor zu vereinfachen, indem wir zwei private Hilfsfunktionen implementieren, um die verschiedenen Aktionen zu erstellen, sie den Menüs hinzuzufügen und die Menüs in die Menüleiste unseres Hauptfensters einzufügen.

    QMenu *fileMenu;
    QMenu *editMenu;
    QMenu *formatMenu;
    QMenu *helpMenu;
    QActionGroup *alignmentGroup;
    QAction *newAct;
    QAction *openAct;
    QAction *saveAct;
    QAction *printAct;
    QAction *exitAct;
    QAction *undoAct;
    QAction *redoAct;
    QAction *cutAct;
    QAction *copyAct;
    QAction *pasteAct;
    QAction *boldAct;
    QAction *italicAct;
    QAction *leftAlignAct;
    QAction *rightAlignAct;
    QAction *justifyAct;
    QAction *centerAct;
    QAction *setLineSpacingAct;
    QAction *setParagraphSpacingAct;
    QAction *aboutAct;
    QAction *aboutQtAct;
    QLabel *infoLabel;
};

Schließlich deklarieren wir die verschiedenen Menüs und Aktionen sowie ein einfaches Informationslabel im anwendungsweiten Geltungsbereich.

Die Klasse ` QMenu ` stellt ein Menü-Widget zur Verwendung in Menüleisten, Kontextmenüs und anderen Popup-Menüs bereit, während die Klasse ` QAction ` eine abstrakte Benutzeroberflächen-Aktion bereitstellt, die in Widgets eingefügt werden kann.

In manchen Situationen ist es sinnvoll, Aktionen zu gruppieren, z. B. wenn wir eine „ Left Align “-Aktion, eine „ Right Align “-Aktion, eine „ Justify “-Aktion und eine „ Center “-Aktion haben und möchten, dass jeweils nur eine dieser Aktionen aktiv ist. Eine einfache Möglichkeit, dies zu erreichen, besteht darin, die Aktionen mithilfe der Klasse „ QActionGroup “ in einer Aktionsgruppe zusammenzufassen.

Implementierung der Klasse „MainWindow“

Im Konstruktor erstellen wir zunächst ein reguläres ` QWidget ` und machen es zum zentralen Widget unseres Hauptfensters. Beachten Sie, dass das Hauptfenster die Verantwortung für den Widget-Zeiger übernimmt und diesen zum geeigneten Zeitpunkt löscht.

MainWindow::MainWindow()
{
    QWidget *widget = new QWidget;
    setCentralWidget(widget);

    QWidget *topFiller = new QWidget;
    topFiller->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    infoLabel = new QLabel(tr("<i>Choose a menu option, or right-click to "
                              "invoke a context menu</i>"));
    infoLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Sunken);
    infoLabel->setAlignment(Qt::AlignCenter);

    QWidget *bottomFiller = new QWidget;
    bottomFiller->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);

    QVBoxLayout *layout = new QVBoxLayout;
    layout->setContentsMargins(5, 5, 5, 5);
    layout->addWidget(topFiller);
    layout->addWidget(infoLabel);
    layout->addWidget(bottomFiller);
    widget->setLayout(layout);

Anschließend erstellen wir das Informationslabel sowie einen oberen und unteren Füllbereich, die wir einem Layout hinzufügen, das wir auf dem zentralen Widget installieren. „ QMainWindow “-Objekte verfügen über ein eigenes, angepasstes Layout, und das Festlegen eines Layouts für das eigentliche Hauptfenster oder das Erstellen eines Layouts mit einem Hauptfenster als übergeordnetem Element wird als Fehler gewertet. Stattdessen sollten Sie immer Ihr eigenes Layout auf dem zentralen Widget festlegen.

    createActions();
    createMenus();

    QString message = tr("A context menu is available by right-clicking");
    statusBar()->showMessage(message);

    setWindowTitle(tr("Menus"));
    setMinimumSize(160, 160);
    resize(480, 320);
}

Um die Aktionen und Menüs zu erstellen, rufen wir unsere beiden Hilfsfunktionen auf: ` createActions() ` und ` createMenus()`. Wir werden in Kürze darauf zurückkommen.

QMainWindowDie Funktion ` statusBar()` gibt die Statusleiste für das Hauptfenster zurück (falls die Statusleiste nicht existiert, erstellt diese Funktion eine leere Statusleiste und gibt sie zurück). Wir initialisieren die Statusleiste und den Fenstertitel, passen die Fenstergröße an eine geeignete Größe an und stellen sicher, dass das Hauptfenster nicht auf eine kleinere Größe als die angegebene verkleinert werden kann.

Schauen wir uns nun die Hilfsfunktion ` createActions() ` genauer an, die die verschiedenen Aktionen erstellt:

void MainWindow::createActions()
{
    newAct = new QAction(QIcon::fromTheme(QIcon::ThemeIcon::DocumentNew),
                         tr("&New"), this);
    newAct->setShortcuts(QKeySequence::New);
    newAct->setStatusTip(tr("Create a new file"));
    connect(newAct, &QAction::triggered, this, &MainWindow::newFile);
    ...

Ein „ QAction “-Objekt kann ein Symbol, einen Text, eine Tastenkombination, einen Statushinweis, einen „Was ist das?“-Text und einen Tooltip enthalten. Die meisten dieser Elemente können im Konstruktor festgelegt werden, sie lassen sich aber auch unabhängig voneinander mithilfe der bereitgestellten Hilfsfunktionen festlegen.

In der Funktion ` createActions() ` erstellen wir zunächst eine ` newAct `-Aktion und übergeben dabei den Text sowie ein Symbol unter Verwendung einer der Theme-Symbolkonstanten. Mit der Funktion ` QAction::setShortcut()` legen wir ` Ctrl+N ` als Tastenkürzel fest, und mit der Funktion ` QAction::setStatusTip()` legen wir den Statustipp fest (der Statustipp wird in allen Statusleisten angezeigt, die vom übergeordneten Widget der Aktion bereitgestellt werden). Außerdem verbinden wir das Signal „ triggered()“ mit dem Slot „ newFile() “.

Die übrigen Aktionen werden auf ähnliche Weise erstellt. Einzelheiten entnehmen Sie bitte dem Quellcode.

    alignmentGroup = new QActionGroup(this);
    alignmentGroup->addAction(leftAlignAct);
    alignmentGroup->addAction(rightAlignAct);
    alignmentGroup->addAction(justifyAct);
    alignmentGroup->addAction(centerAct);
    leftAlignAct->setChecked(true);
}

Nachdem wir die Aktionen „ Left Align “, „ Right Align “, „ Justify “ und „ Center “ erstellt haben, können wir auch die zuvor erwähnte Aktionsgruppe erstellen.

Jede Aktion wird der Gruppe mithilfe der Funktion ` addAction()` von ` QActionGroup` hinzugefügt. Beachten Sie, dass eine Aktion auch einer Gruppe hinzugefügt werden kann, indem man sie mit der Gruppe als übergeordneter Aktion erstellt. Da eine Aktionsgruppe standardmäßig exklusiv ist, ist jeweils nur eine der Aktionen in der Gruppe aktiviert (dies kann mithilfe der Funktion ` QActionGroup::setExclusive()` geändert werden).

Wenn alle Aktionen erstellt sind, verwenden wir die Funktion ` createMenus() `, um die Aktionen zu den Menüs hinzuzufügen und die Menüs in die Menüleiste einzufügen:

void MainWindow::createMenus()
{
    fileMenu = menuBar()->addMenu(tr("&File"));
    fileMenu->addAction(newAct);
    fileMenu->addAction(openAct);
    fileMenu->addAction(saveAct);
    fileMenu->addAction(printAct);
    fileMenu->addSeparator();
    fileMenu->addAction(exitAct);

    editMenu = menuBar()->addMenu(tr("&Edit"));
    editMenu->addAction(undoAct);
    editMenu->addAction(redoAct);
    editMenu->addSeparator();
    editMenu->addAction(cutAct);
    editMenu->addAction(copyAct);
    editMenu->addAction(pasteAct);
    editMenu->addSeparator();

    helpMenu = menuBar()->addMenu(tr("&Help"));
    helpMenu->addAction(aboutAct);
    helpMenu->addAction(aboutQtAct);

QMenuBarDie Funktion ` addMenu()` fügt ein neues ` QMenu ` mit dem angegebenen Titel an die Menüleiste an (beachten Sie, dass die Menüleiste die Eigentümerschaft für das Menü übernimmt). Wir verwenden die Funktion ` addAction()` von ` QWidget`, um jede Aktion zum entsprechenden Menü hinzuzufügen.

Alternativ bietet die Klasse ` QMenu ` mehrere Komfortfunktionen wie ` addAction()`, die neue Aktionen aus vorgegebenen Texten und/oder Symbolen erstellen und hinzufügen. Sie können auch ein Element bereitstellen, das automatisch eine Verbindung zum Signal ` triggered()` der neuen Aktion herstellt, sowie eine Verknüpfung, die durch eine Instanz von ` QKeySequence ` dargestellt wird.

Die Funktion ` QMenu::addSeparator()` erstellt eine neue Trennzeichen-Aktion – d. h. eine Aktion, für die ` QAction::isSeparator()` den Wert `true` zurückgibt – und fügt die neue Aktion zur Aktionsliste des Menüs hinzu.

    formatMenu = editMenu->addMenu(tr("&Format"));
    formatMenu->addAction(boldAct);
    formatMenu->addAction(italicAct);
    formatMenu->addSeparator()->setText(tr("Alignment"));
    formatMenu->addAction(leftAlignAct);
    formatMenu->addAction(rightAlignAct);
    formatMenu->addAction(justifyAct);
    formatMenu->addAction(centerAct);
    formatMenu->addSeparator();
    formatMenu->addAction(setLineSpacingAct);
    formatMenu->addAction(setParagraphSpacingAct);
}

Beachten Sie das Menü „ Format “. Zunächst wird es mithilfe der Funktion ` addMenu()` von ` QMenu` als Untermenü zum Menü „ Edit “ hinzugefügt. Sehen Sie sich als Nächstes die Ausrichtungsaktionen an: In der Funktion ` createActions() ` haben wir die Aktionen ` leftAlignAct`, ` rightAlignAct`, ` justifyAct ` und ` centerAct ` zu einer Aktionsgruppe hinzugefügt. Dennoch müssen wir jede Aktion einzeln zum Menü hinzufügen, während die Aktionsgruppe im Hintergrund ihre Arbeit verrichtet.

#ifndef QT_NO_CONTEXTMENU
void MainWindow::contextMenuEvent(QContextMenuEvent *event)
{
    QMenu menu(this);
    menu.addAction(cutAct);
    menu.addAction(copyAct);
    menu.addAction(pasteAct);
    menu.exec(event->globalPos());
}
#endif // QT_NO_CONTEXTMENU

Um ein benutzerdefiniertes Kontextmenü bereitzustellen, müssen wir die Funktion ` contextMenuEvent()` von ` QWidget` neu implementieren, um die Kontextmenü-Ereignisse des Widgets zu empfangen (beachten Sie, dass die Standardimplementierung diese Ereignisse einfach ignoriert).

Immer wenn wir ein solches Ereignis empfangen, erstellen wir ein Menü, das die Aktionen „ Cut “, „ Copy “ und „ Paste “ enthält. Kontextmenüs können entweder asynchron mithilfe der Funktion ` popup()` oder synchron mithilfe der Funktion ` exec()` ausgeführt werden. In diesem Beispiel haben wir uns dafür entschieden, das Menü mithilfe der Funktion ` exec()` anzuzeigen. Indem wir die Position des Ereignisses als Argument übergeben, stellen wir sicher, dass das Kontextmenü an der erwarteten Position erscheint.

Beispielprojekt @ code.qt.io