Menu QML Type

Popup-Menü, das als Kontextmenü oder Popup-Menü verwendet werden kann. Mehr...

• Liste aller Mitglieder, einschließlich geerbter Mitglieder

Eigenschaften

• cascade : bool (since QtQuick.Controls 2.3 (Qt 5.10))
• contentData : list<QtObject>
• contentModel : model
• count : int (since QtQuick.Controls 2.3 (Qt 5.10))
• currentIndex : int (since QtQuick.Controls 2.3 (Qt 5.10))
• delegate : Component (since QtQuick.Controls 2.3 (Qt 5.10))
• focus : bool
• icon (since QtQuick.Controls 6.5)
  • icon.cache : bool (since QtQuick.Controls 6.5)
  • icon.color : color (since QtQuick.Controls 6.5)
  • icon.height : int (since QtQuick.Controls 6.5)
  • icon.name : string (since QtQuick.Controls 6.5)
  • icon.source : url (since QtQuick.Controls 6.5)
  • icon.width : int (since QtQuick.Controls 6.5)
• overlap : real (since QtQuick.Controls 2.3 (Qt 5.10))
• separatorsCollapsible : bool (since QtQuick.Controls 6.12 (Qt 6.12))
• title : string

Methoden

• Action actionAt(int index) (since QtQuick.Controls 2.3 (Qt 5.10))
• void addAction(Action action) (since QtQuick.Controls 2.3 (Qt 5.10))
• void addItem(Item item)
• void addMenu(Menu menu) (since QtQuick.Controls 2.3 (Qt 5.10))
• void dismiss() (since QtQuick.Controls 2.3 (Qt 5.10))
• void insertAction(int index, Action action) (since QtQuick.Controls 2.3 (Qt 5.10))
• void insertItem(int index, Item item)
• void insertMenu(int index, Menu menu) (since QtQuick.Controls 2.3 (Qt 5.10))
• Item itemAt(int index)
• Menu menuAt(int index) (since QtQuick.Controls 2.3 (Qt 5.10))
• void moveItem(int from, int to)
• void popup(MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
• void popup(Item parent, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
• void popup(point pos, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
• void popup(Item parent, point pos, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
• void popup(real x, real y, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
• void popup(Item parent, real x, real y, MenuItem item) (since QtQuick.Controls 2.3 (Qt 5.10))
• void removeAction(Action action) (since QtQuick.Controls 2.3 (Qt 5.10))
• void removeItem(Item item) (since QtQuick.Controls 2.3 (Qt 5.10))
• void removeMenu(Menu menu) (since QtQuick.Controls 2.3 (Qt 5.10))
• Action takeAction(int index) (since QtQuick.Controls 2.3 (Qt 5.10))
• MenuItem takeItem(int index) (since QtQuick.Controls 2.3 (Qt 5.10))
• Menu takeMenu(int index) (since QtQuick.Controls 2.3 (Qt 5.10))

Ausführliche Beschreibung

Das Menü hat zwei Hauptanwendungsfälle:

• Kontextmenüs; zum Beispiel ein Menü, das nach einem Rechtsklick angezeigt wird
• Popup-Menüs; zum Beispiel ein Menü, das nach dem Klicken auf eine Schaltfläche angezeigt wird

Informationen zu Kontextmenüs finden Sie unter Context Menus.

Bei Verwendung als Popup-Menü lässt sich die Position am einfachsten festlegen, indem die gewünschten Koordinaten für „ x “ und „ y “ über die entsprechenden Eigenschaften angegeben werden und die Funktion ` open()` aufgerufen wird, um das Menü zu öffnen.

Button {
    id: fileButton
    text: "File"
    onClicked: menu.open()

    Menu {
        id: menu
        y: fileButton.height

        MenuItem {
            text: "New..."
        }
        MenuItem {
            text: "Open..."
        }
        MenuItem {
            text: "Save"
        }
    }
}

Soll die Schaltfläche beim Klicken das Menü auch schließen, verwenden Sie das Flag „ Popup.CloseOnPressOutsideParent “:

    onClicked: menu.visible = !menu.visible

    Menu {
        id: menu
        // ...
        closePolicy: Popup.CloseOnEscape | Popup.CloseOnPressOutsideParent

Sie können Untermenüs erstellen und Action-Objekte innerhalb von „Menu“ deklarieren:

Menu {
    Action { text: "Cut" }
    Action { text: "Copy" }
    Action { text: "Paste" }

    MenuSeparator { }

    Menu {
        title: "Find/Replace"
        Action { text: "Find Next" }
        Action { text: "Find Previous" }
        Action { text: "Replace" }
    }
}

Untermenüs sind standardmäßig auf Desktop-Plattformen, auf denen ein Mauszeiger verfügbar ist, „ cascading “. Nicht kaskadierende Menüs werden jeweils einzeln angezeigt und über dem übergeordneten Menü zentriert.

In der Regel werden Menüelemente statisch als untergeordnete Elemente des Menüs deklariert, aber „Menu“ bietet auch eine API, um Elemente dynamisch mit „ add “, „ insert “, „ move “ und „ remove “ zu erstellen. Auf die Elemente in einem Menü kann über „ itemAt()“ oder „ contentChildren “ zugegriffen werden.

Obwohl „ MenuItems “ am häufigsten mit „Menu“ verwendet werden, kann es Elemente beliebigen Typs enthalten.

Kontextmenüs

Für Kontextmenüs ist es einfacher, den angehängten Typ „ ContextMenu “ zu verwenden, der bei einem plattformspezifischen Ereignis ein Menü erstellt. Darüber hinaus stellen Textbearbeitungssteuerelemente wie „ TextField “, „ TextArea “, „ SpinBox “ und „ DoubleSpinBox “ standardmäßig ihre eigenen Kontextmenüs bereit.

Wenn Sie ` ContextMenu` nicht verwenden, empfiehlt es sich, das Menü durch Aufruf von ` popup()` zu öffnen. Sofern keine Position explizit angegeben wird, wird das Menü auf Desktop-Plattformen, auf denen ein Mauszeiger verfügbar ist, an der Position des Mauszeigers platziert; andernfalls wird es über dem übergeordneten Element zentriert:

    TapHandler {
        acceptedButtons: Qt.RightButton
        onPressedChanged: {
            if (pressed && Application.styleHints.contextMenuTrigger === Qt.ContextMenuTrigger.Press)
                contextMenu.popup()
        }
        onTapped: {
            if (Application.styleHints.contextMenuTrigger === Qt.ContextMenuTrigger.Release)
                contextMenu.popup()
        }
    }
    TapHandler {
        acceptedDevices: PointerDevice.TouchScreen
        onLongPressed: contextMenu.popup()
    }

    Menu {
        id: contextMenu

        MenuItem {
            text: qsTr("Do stuff")
        }
        MenuItem {
            text: qsTr("Do more stuff")
        }
    }

Beachten Sie, dass Sie bei der Implementierung eines eigenen Kontextmenüs für Textbearbeitungselemente dieses nur auf Desktop-Plattformen anzeigen müssen, da iOS und Android über eigene native Kontextmenüs verfügen:

    TextArea {
        text: qsTr("TextArea")

        // Disable the built-in context menu (since Qt 6.9).
        ContextMenu.menu: null

        TapHandler {
            acceptedButtons: Qt.RightButton
            onPressedChanged: {
                if (pressed === (Application.styleHints.contextMenuTrigger === Qt.ContextMenuTrigger.Press))
                    contextMenu.popup()
            }
        }
    }

    Menu {
        id: contextMenu

        MenuItem {
            text: qsTr("Cut")
            // ...
        }
        MenuItem {
            text: qsTr("Copy")
            // ...
        }
        MenuItem {
            text: qsTr("Paste")
            // ...
        }
    }

Ränder

Da „Menu“ von „Popup“ abgeleitet ist, unterstützt es die Eigenschaft „ margins “. Standardmäßig legen alle integrierten Stile für die Ränder von „Menu“ den Wert „ 0 “ fest, um sicherzustellen, dass das Menü innerhalb der Fenstergrenzen bleibt. Damit ein Menü über den Fensterrand hinausragen kann (beispielsweise, um seine Bewegung in den sichtbaren Bereich zu animieren), setzen Sie die Eigenschaft „margins“ auf „ -1 “.

Dynamisches Erstellen von Menüelementen

Sie können Menüelemente dynamisch mit „ Instantiator “ oder durch dynamische Objekterstellung erstellen.

Verwendung von „Instantiator“

Sie können Menüelemente dynamisch mit „ Instantiator “ generieren. Der folgende Code zeigt, wie Sie ein Untermenü „Zuletzt verwendete Dateien“ implementieren können, dessen Elemente aus einer Liste von Dateien stammen, die in den Einstellungen gespeichert sind:

Menu {
    title: qsTr("File")

    Menu {
        id: recentFilesMenu
        title: qsTr("Recent Files")
        enabled: recentFilesInstantiator.count > 0

        Instantiator {
            id: recentFilesInstantiator
            model: settings.recentFiles
            delegate: MenuItem {
                text: settings.displayableFilePath(modelData)
                onTriggered: loadFile(modelData)
            }

            onObjectAdded: (index, object) => recentFilesMenu.insertItem(index, object)
            onObjectRemoved: (index, object) => recentFilesMenu.removeItem(object)
        }

        MenuSeparator {}

        MenuItem {
            text: qsTr("Clear Recent Files")
            onTriggered: settings.clearRecentFiles()
        }
    }
}

Verwendung der dynamischen Objekterstellung

Sie können eine Komponente auch dynamisch aus einer QML-Datei mit ` Qt.createComponent()` laden. Sobald die Komponente bereit ist, können Sie die Methode ` createObject()` aufrufen, um eine Instanz dieser Komponente zu erstellen.

Row {
    anchors.centerIn: parent

    Component {
        id: menuItemComponent

        MenuItem {}
    }

    Button {
        id: button
        text: "Menu"
        onClicked: menu.open()
        Menu {
            id: menu
        }
    }

    Button {
        text: "Add item"
        onClicked: {
            onClicked: {
                let menuItem = menuItemComponent.createObject(
                    menu.contentItem, { text: qsTr("New item") })
                menu.addItem(menuItem)
            }
        }
    }
}

Menütypen

Seit Qt 6.8 bietet ein Menü je nach Plattform drei verschiedene Implementierungen. Sie können festlegen, welche davon bevorzugt werden soll, indem Sie ` popupType` setzen. Auf diese Weise können Sie steuern, ob ein Menü als separates Fenster, als Element innerhalb des übergeordneten Fensters oder als natives Menü angezeigt werden soll. Weitere Informationen zu diesen Optionen finden Sie unter ` here`.

Der Standardwert für „ popupType “ wird durch den Stil festgelegt. Der macOS-Stil setzt ihn beispielsweise auf „ Popup.Native “, während der Imagine-Stil „ Popup.Window “ verwendet (was der Standardwert ist, wenn der Stil keinen Popup-Typ festlegt). Wenn Sie einem Menü Anpassungen hinzufügen und möchten, dass diese unabhängig vom Stil verwendet werden, sollten Sie den Popup-Typ explizit auf „ Popup.Window “ (oder „ Popup.Item “) setzen. Eine weitere Alternative ist die Einstellung von „ Qt::AA_DontUseNativeMenuWindows “ auf „ application attribute “. Dadurch werden native Kontextmenüs für die gesamte Anwendung deaktiviert, unabhängig vom Stil.

Ob ein Menü den bevorzugten Typ verwenden kann, hängt von der Plattform ab. „ Popup.Item “ wird auf allen Plattformen unterstützt, „ Popup.Window “ hingegen normalerweise nur auf Desktop-Plattformen. Befindet sich das Menü zudem innerhalb eines „ native menubar “, ist es ebenfalls ein natives Menü. Und wenn es sich um ein Untermenü innerhalb eines anderen Menüs handelt, bestimmt das übergeordnete (oder Root-)Menü den Typ.

Einschränkungen bei der Verwendung nativer Menüs

Wenn „ popupType “ auf „ Popup.Native “ gesetzt wird, gibt es einige Einschränkungen und Unterschiede im Vergleich zur Verwendung von „ Popup.Item “ und „ Popup.Window “.

API-Unterschiede

Bei der Verwendung nativer Menüs wird auf allen Plattformen nur ein Teil der Menü-API unterstützt:

• x
• y
• visible
• opened
• title
• count
• contentData
• contentChildren (visuelle untergeordnete Elemente sind nicht sichtbar)
• contentModel
• open()
• popup()
• close()
• opened()
• closed()
• aboutToShow()
• aboutToHide()

Darüber hinaus stellt das Anzeigen eines Popups (beispielsweise mit open() oder popup()) auf einigen Plattformen einen blockierenden Aufruf dar. Das bedeutet, dass der Aufruf erst zurückkehrt, wenn das Menü wieder geschlossen wurde, was sich auf die Logik in Ihrer Anwendung auswirken kann. Dies ist besonders wichtig zu beachten, wenn Ihre Anwendung auf mehrere Plattformen ausgerichtet ist und daher manchmal auf Plattformen läuft, auf denen native Menüs nicht unterstützt werden. In diesem Fall wird der `popupType` beispielsweise auf ` Popup.Item` zurückgesetzt, und Aufrufe von ` open()` sind nicht blockierend.

Elemente wie MenuItem reagieren weiterhin auf Klicks auf den entsprechenden nativen Menüpunkt, indem sie beispielsweise Signale ausgeben, werden jedoch durch ihr natives Gegenstück ersetzt.

Unterschiede bei der Darstellung

Native Menüs werden mithilfe der auf der Plattform verfügbaren nativen Menü-APIs implementiert. Diese Menüs und ihr gesamter Inhalt werden daher von der Plattform und nicht von QML gerendert. Das bedeutet, dass das ` delegate ` nicht für das Rendering verwendet wird. Es wird jedoch immer instanziiert (aber ausgeblendet), sodass Funktionen wie ` onCompleted()` unabhängig von der Plattform ausgeführt werden und ` popupType` funktioniert.

Unterstützte Plattformen

Native Menüs werden derzeit auf den folgenden Plattformen unterstützt:

• Android
• iOS
• Linux (nur als eigenständiges Kontextmenü verfügbar, wenn es mit dem GTK+-Plattform-Design ausgeführt wird)
• macOS
• Windows

Siehe auch „Menü anpassen“, MenuItem, „Menüsteuerelemente“, „Popup-Steuerelemente“, „Dynamische Erstellung von QML-Objekten aus JavaScript“, Popup type, [QML] und popupType.

Dokumentation zu den Eigenschaften

cascade : bool [since QtQuick.Controls 2.3 (Qt 5.10)]

Diese Eigenschaft legt fest, ob das Menü seine Untermenüs kaskadierend anzeigt.

Der Standardwert ist plattformabhängig. Auf Desktop-Plattformen, auf denen ein Mauszeiger verfügbar ist, werden Menüs standardmäßig kaskadiert. Nicht kaskadierte Menüs werden einzeln angezeigt und über dem übergeordneten Menü zentriert.

Diese Eigenschaft wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Siehe auch ` overlap`.

contentData : list<QtObject> [default]

Diese Eigenschaft enthält die Liste der Inhaltsdaten.

Die Liste enthält alle Objekte, die in QML als untergeordnete Elemente des Menüs deklariert wurden, sowie Elemente, die dynamisch mithilfe der Methoden „ addItem()“ bzw. „ insertItem()“ hinzugefügt oder eingefügt wurden.

Siehe auch „ Item::data “ und „ contentChildren “.

contentModel : model [read-only]

Diese Eigenschaft enthält das Modell, das zur Anzeige von Menüelementen verwendet wird.

Das Inhaltsmodell dient zu Visualisierungszwecken. Es kann einem Inhaltselement, das den Inhalt des Menüs darstellt, als Modell zugewiesen werden.

Menu {
    id: menu
    contentItem: ListView {
        model: menu.contentModel
    }
}

Das Modell ermöglicht es, Menüpunkte statisch als untergeordnete Elemente des Menüs zu deklarieren.

count : int [read-only, since QtQuick.Controls 2.3 (Qt 5.10)]

Diese Eigenschaft gibt die Anzahl der Elemente an.

Diese Eigenschaft wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

currentIndex : int [since QtQuick.Controls 2.3 (Qt 5.10)]

Diese Eigenschaft enthält den Index des aktuell markierten Elements.

Menüelemente können durch Bewegen des Mauszeigers oder per Tastaturnavigation markiert werden.

Diese Eigenschaft wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Siehe auch ` MenuItem::highlighted`.

delegate : Component [since QtQuick.Controls 2.3 (Qt 5.10)]

Diese Eigenschaft enthält die Komponente, die zum Erstellen von Elementen zur Darstellung von Aktionen verwendet wird.

Menu {
    Action { text: "Cut" }
    Action { text: "Copy" }
    Action { text: "Paste" }
}

Das Menü übernimmt nicht die Eigentümerschaft des Delegaten.

Diese Eigenschaft wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Siehe auch „ Action “.

focus : bool

Diese Eigenschaft gibt an, ob das Popup den Fokus erhalten soll.

Wenn das Popup tatsächlich den Fokus erhält, wird „ activeFocus “ auf „ true “ gesetzt. Weitere Informationen finden Sie unter „Keyboard Focus“ auf Qt Quick.

Der Standardwert ist „ true “.

Siehe auch „ activeFocus “.

icon group

Diese Eigenschaften wurden in QtQuick.Controls 6.5 eingeführt.

Siehe auch „ AbstractButton::text“ , „ AbstractButton::display “ und „Icons“ unter Qt Quick Controls.

overlap : real [since QtQuick.Controls 2.3 (Qt 5.10)]

Diese Eigenschaft gibt die Anzahl der Pixel an, um die das Menü sein übergeordnetes Menü horizontal überlappt.

Die Eigenschaft wirkt sich nur aus, wenn das Menü als kaskadierendes Untermenü verwendet wird.

Der Standardwert ist stilabhängig.

Diese Eigenschaft wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Siehe auch „ cascade “.

separatorsCollapsible : bool [since QtQuick.Controls 6.12 (Qt 6.12)]

Diese Eigenschaft legt fest, ob aufeinanderfolgende Trennzeichen ausgeblendet werden sollen.

Wenn diese Eigenschaft auf „ true “ gesetzt ist, blendet das Menü automatisch Trennzeichen aus, die am Anfang oder Ende der sichtbaren Elemente erscheinen würden, sowie aufeinanderfolgende Trennzeichen, bei denen alle Elemente dazwischen ausgeblendet sind. Dies entspricht dem Verhalten von „ QMenu::separatorsCollapsible “ unter Qt Widgets.

Der Standardwert ist „ true “.

Dies ist nützlich, wenn Menüelemente dynamisch ein- oder ausgeblendet werden, da so verhindert wird, dass isolierte Trennzeichen angezeigt werden.

Diese Eigenschaft wurde in QtQuick.Controls 6.12 (Qt 6.12) eingeführt.

Siehe auch MenuSeparator.

title : string

Diese Eigenschaft enthält den Titel des Menüs.

Der Titel eines Menüs wird häufig im Text eines Menüelements angezeigt, wenn es sich um ein Untermenü handelt, sowie im Text einer Werkzeugschaltfläche, wenn sich diese in einer Menüleiste befindet.

Methodendokumentation

[since QtQuick.Controls 2.3 (Qt 5.10)] Action actionAt(int index)

Gibt die Aktion unter index zurück oder null, wenn der Index ungültig ist oder unter dem angegebenen Index keine Aktion vorhanden ist.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

[since QtQuick.Controls 2.3 (Qt 5.10)] void addAction(Action action)

Fügt „ action “ am Ende dieses Menüs hinzu. Das Menü übernimmt nicht die Verantwortung für das neu hinzugefügte „ action “.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

void addItem(Item item)

Fügt „ item “ am Ende der Liste der Elemente hinzu. Das Menü übernimmt nicht die Eigentumsrechte an dem neu hinzugefügten Element „ item “.

Siehe auch „ Dynamically Generating Menu Items “.

[since QtQuick.Controls 2.3 (Qt 5.10)] void addMenu(Menu menu)

Fügt „ menu “ als Untermenü am Ende dieses Menüs hinzu. Das Menü übernimmt nicht die Eigentumsrechte an dem neu hinzugefügten „ menu “.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

[since QtQuick.Controls 2.3 (Qt 5.10)] void dismiss()

Schließt alle Menüs in der Hierarchie, zu der dieses Menü gehört.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Siehe auch „ popup “ () und „ Popup::close “ ().

[since QtQuick.Controls 2.3 (Qt 5.10)] void insertAction(int index, Action action)

Fügt action unter index ein. Der Index befindet sich innerhalb aller Menüpunkte. Das Menü übernimmt nicht die Eigentümerschaft an dem neu eingefügten action.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

void insertItem(int index, Item item)

Fügt item unter index ein. Das Menü übernimmt nicht die Eigentumsrechte an dem neu eingefügten item.

Siehe auch Dynamically Generating Menu Items.

[since QtQuick.Controls 2.3 (Qt 5.10)] void insertMenu(int index, Menu menu)

Fügt „ menu “ als Untermenü unter „ index “ ein. Der Index befindet sich innerhalb aller Menüpunkte. Das Menü übernimmt nicht die Eigentümerschaft an dem neu eingefügten „ menu “.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Item itemAt(int index)

Gibt das Element unter index zurück oder null, falls es nicht existiert.

[since QtQuick.Controls 2.3 (Qt 5.10)] Menu menuAt(int index)

Gibt das Untermenü unter index zurück oder null, falls der Index ungültig ist oder unter dem angegebenen Index kein Untermenü vorhanden ist.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

void moveItem(int from, int to)

Verschiebt ein Element from einen Index to einen anderen.

Öffnet das Menü an der Position des Mauszeigers auf Desktop-Plattformen, auf denen ein Mauszeiger verfügbar ist, und zentriert das Menü andernfalls über dem Menüpunkt „ parent “.

Das Menü kann optional an einem bestimmten Menü-„ item “ ausgerichtet werden. Dieses Element wird dann zu „ current. “. Wenn kein „ item “ angegeben ist, wird „ currentIndex “ auf „ -1 “ gesetzt.

Diese Methoden wurden in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Siehe auch ` Popup::open()`.

Öffnet das Menü an der angegebenen Position pos im Koordinatensystem des Popups, d. h. an einer Koordinate relativ zu dessen Element parent.

Das Menü kann optional an einem bestimmten Menü- item ausgerichtet werden. Dieses Element wird dann zu „ current. “. Wenn kein „ item “ angegeben ist, wird „ currentIndex “ auf „ -1 “ gesetzt.

Diese Methoden wurden in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Siehe auch ` Popup::open()`.

Öffnet das Menü an der angegebenen Position x, y im Koordinatensystem des Popups, d. h. an einer Koordinate relativ zu dessen Element parent.

Das Menü kann optional an einem bestimmten Menü item ausgerichtet werden. Dieses Element wird dann zu current.. Wenn kein item angegeben ist, wird currentIndex auf -1 gesetzt.

Diese Methoden wurden in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

Siehe auch „ dismiss()“ und „ Popup::open()“.

[since QtQuick.Controls 2.3 (Qt 5.10)] void removeAction(Action action)

Entfernt und löscht die angegebene „ action “.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

[since QtQuick.Controls 2.3 (Qt 5.10)] void removeItem(Item item)

Entfernt und löscht das angegebene ` item`.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

[since QtQuick.Controls 2.3 (Qt 5.10)] void removeMenu(Menu menu)

Entfernt und löscht das angegebene „ menu “.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

[since QtQuick.Controls 2.3 (Qt 5.10)] Action takeAction(int index)

Entfernt die Aktion unter „ index “ und gibt sie zurück. Der Index bezieht sich auf alle Elemente im Menü.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

[since QtQuick.Controls 2.3 (Qt 5.10)] MenuItem takeItem(int index)

Entfernt das Element unter index und gibt es zurück.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.

[since QtQuick.Controls 2.3 (Qt 5.10)] Menu takeMenu(int index)

Entfernt das Menü unter index und gibt es zurück. Der Index befindet sich innerhalb aller Menüpunkte.

Diese Methode wurde in QtQuick.Controls 2.3 (Qt 5.10) eingeführt.