TableView QML Type

Bietet eine tabellarische Ansicht von Elementen zur Anzeige von Daten aus einem Modell. Mehr...

Import Statement:	`import QtQuick`
Inherits:	Flickable
Inherited By:	TreeView

Eigenschaften

alternatingRows : bool
animate : bool (since 6.4)
bottomRow : int
columnSpacing : real
columnWidthProvider : var
columns : int
contentHeight : real
contentWidth : real
currentColumn : int
currentRow : int
delegate : Component
editTriggers : enumeration (since 6.5)
keyNavigationEnabled : bool (since 6.4)
leftColumn : int
model : model
pointerNavigationEnabled : bool (since 6.4)
resizableColumns : bool (since 6.5)
resizableRows : bool (since 6.5)
reuseItems : bool
rightColumn : int
rowHeightProvider : var
rowSpacing : real
rows : int
selectionBehavior : enumeration (since 6.4)
selectionMode : enumeration (since 6.6)
selectionModel : ItemSelectionModel (since 6.2)
syncDirection : Qt::Orientations
syncView : TableView
topRow : int

Beigefügte Eigenschaften

editDelegate : Component
view : TableView

Signale

columnMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex) (since 6.8)
layoutChanged() (since 6.5)
rowMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex) (since 6.8)

Angehängte Signale

commit()
pooled()
reused()

Methoden

point cellAtIndex(QModelIndex modelIndex) (since 6.4)
Point cellAtPosition(point position, bool includeSpacing)
Point cellAtPosition(real x, real y, bool includeSpacing)
clearColumnReordering() (since 6.8)
clearColumnWidths()
clearRowHeights()
clearRowReordering() (since 6.8)
closeEditor() (since 6.5)
int columnAtIndex(QModelIndex modelIndex) (since 6.4)
real columnWidth(int column) (since 6.2)
edit(QModelIndex modelIndex) (since 6.5)
qreal explicitColumnWidth(int column)
qreal explicitRowHeight(int row)
forceLayout()
real implicitColumnWidth(int column) (since 6.2)
real implicitRowHeight(int row) (since 6.2)
QModelIndex index(int row, int column) (since 6.4.3)
bool isColumnLoaded(int column) (since 6.2)
bool isRowLoaded(int row) (since 6.2)
Item itemAtCell(point cell)
Item itemAtIndex(QModelIndex index) (since 6.5)
QModelIndex modelIndex(point cell) (since 6.4)
moveColumn(int source, int destination) (since 6.8)
moveRow(int source, int destination) (since 6.8)
positionViewAtCell(point cell, PositionMode mode, point offset, rect subRect)
positionViewAtColumn(int column, PositionMode mode, real offset, rect subRect)
positionViewAtIndex(QModelIndex index, PositionMode mode, point offset, rect subRect) (since 6.5)
positionViewAtRow(int row, PositionMode mode, real offset, rect subRect)
int rowAtIndex(QModelIndex modelIndex) (since 6.4)
real rowHeight(int row) (since 6.2)
setColumnWidth(int column, real size)
setRowHeight(int row, real size)

Detaillierte Beschreibung

Eine TableView hat eine model, die die anzuzeigenden Daten definiert, und eine delegate, die definiert, wie die Daten angezeigt werden sollen.

TableView erbt Flickable. Das bedeutet, dass das Modell zwar eine beliebige Anzahl von Zeilen und Spalten haben kann, aber in der Regel nur ein Teilbereich der Tabelle im Ansichtsfenster sichtbar ist. Sobald Sie die Maus bewegen, treten neue Zeilen und Spalten in das Ansichtsfenster ein, während alte Zeilen und Spalten das Ansichtsfenster verlassen und entfernt werden. Die Zeilen und Spalten, die herausgenommen werden, werden für den Aufbau der Zeilen und Spalten wiederverwendet, die in das Ansichtsfenster gelangen. Daher unterstützt der TableView Modelle jeder Größe, ohne die Leistung zu beeinträchtigen.

Ein TableView zeigt Daten aus Modellen an, die mit eingebauten QML-Typen wie ListModel und XmlListModel erstellt wurden, die nur die erste Spalte in einem TableView ausfüllen. Um Modelle mit mehreren Spalten zu erstellen, verwenden Sie entweder TableModel oder ein C++-Modell, das QAbstractItemModel erbt.

Ein TableView enthält standardmäßig keine Kopfzeilen. Sie können Kopfzeilen hinzufügen, indem Sie die HorizontalHeaderView und VerticalHeaderView von Qt Quick Controls verwenden.

Hinweis: TableView wird nur load so viele Delegate-Elemente wie nötig, um die Ansicht zu füllen. Es gibt keine Garantie, dass Elemente außerhalb des Views geladen werden, obwohl TableView manchmal Elemente aus Optimierungsgründen vorlädt. Daher kann es sein, dass ein TableView mit einer Breite oder Höhe von Null überhaupt keine Delegate Items lädt.

Beispiel Verwendung

C++ Modelle

Das folgende Beispiel zeigt, wie man ein C++-Modell mit mehreren Spalten erstellt:

#include <qqml.h>
#include <QAbstractTableModel>

class TableModel : public QAbstractTableModel
{
    Q_OBJECT
    QML_ELEMENT

public:
    int rowCount(const QModelIndex & = QModelIndex()) const override
    {
        return 200;
    }

    int columnCount(const QModelIndex & = QModelIndex()) const override
    {
        return 200;
    }

    QVariant data(const QModelIndex &index, int role) const override
    {
        switch (role) {
            case Qt::DisplayRole:
                return QString("%1, %2").arg(index.column()).arg(index.row());
            default:
                break;
        }

        return QVariant();
    }

    QHash<int, QByteArray> roleNames() const override
    {
        return { {Qt::DisplayRole, "display"} };
    }
};

Und dann, wie man es in QML verwendet:

import QtQuick
import TableModel

TableView {
    anchors.fill: parent
    columnSpacing: 1
    rowSpacing: 1
    clip: true

    model: TableModel {}

    delegate: Rectangle {
        implicitWidth: 100
        implicitHeight: 50
        Text {
            text: display
        }
    }
}

QML-Modelle

Für das Prototyping und die Anzeige von sehr einfachen Daten (z. B. aus einer Web-API) kann TableModel verwendet werden:

import QtQuick
import Qt.labs.qmlmodels

TableView {
    anchors.fill: parent
    columnSpacing: 1
    rowSpacing: 1
    clip: true

    model: TableModel {
        TableModelColumn { display: "name" }
        TableModelColumn { display: "color" }

        rows: [
            {
                "name": "cat",
                "color": "black"
            },
            {
                "name": "dog",
                "color": "brown"
            },
            {
                "name": "bird",
                "color": "white"
            }
        ]
    }

    delegate: Rectangle {
        implicitWidth: 100
        implicitHeight: 50
        border.width: 1

        Text {
            text: display
            anchors.centerIn: parent
        }
    }
}

Wiederverwendung von Elementen

TableView recycelt standardmäßig Delegate-Items, anstatt von delegate zu instanziieren, wenn neue Zeilen und Spalten in die Ansicht geschoben werden. Dieser Ansatz bringt einen enormen Leistungsschub, abhängig von der Komplexität des Delegaten.

Wenn ein Element herausgeklickt wird, wird es in den Wiederverwendungspool verschoben, der ein interner Cache für unbenutzte Elemente ist. Wenn dies geschieht, wird das Signal TableView::pooled ausgegeben, um das Element darüber zu informieren. Ebenso wird das Signal TableView::reused ausgegeben, wenn das Element aus dem Pool zurückgeschoben wird.

Alle Elementeigenschaften, die aus dem Modell stammen, werden aktualisiert, wenn das Element wiederverwendet wird. Dazu gehören index, row und column, aber auch alle Modellrollen.

Hinweis: Vermeiden Sie es, einen Zustand innerhalb eines Delegaten zu speichern. Wenn Sie dies tun, setzen Sie ihn manuell zurück, wenn Sie das Signal TableView::reused erhalten.

Wenn ein Element über Zeitgeber oder Animationen verfügt, sollten Sie diese beim Empfang des Signals TableView::pooled anhalten. Auf diese Weise vermeiden Sie die Verwendung von CPU-Ressourcen für Elemente, die nicht sichtbar sind. Wenn ein Element über Ressourcen verfügt, die nicht wiederverwendet werden können, können diese ebenfalls freigegeben werden.

Wenn Sie Elemente nicht wiederverwenden wollen oder wenn delegate dies nicht unterstützt, können Sie die Eigenschaft reuseItems auf false setzen.

Hinweis: Während sich ein Element im Pool befindet, kann es noch aktiv sein und auf verbundene Signale und Bindungen reagieren.

Das folgende Beispiel zeigt einen Delegaten, der ein sich drehendes Rechteck animiert. Wenn es gepoolt wird, wird die Animation vorübergehend angehalten:

Component {
    id: tableViewDelegate
    Rectangle {
        implicitWidth: 100
        implicitHeight: 50

        TableView.onPooled: rotationAnimation.pause()
        TableView.onReused: rotationAnimation.resume()

        Rectangle {
            id: rect
            anchors.centerIn: parent
            width: 40
            height: 5
            color: "green"

            RotationAnimation {
                id: rotationAnimation
                target: rect
                duration: (Math.random() * 2000) + 200
                from: 0
                to: 359
                running: true
                loops: Animation.Infinite
            }
        }
    }
}

Zeilenhöhen und Spaltenbreiten

Wenn eine neue Spalte in die Ansicht geschoben wird, bestimmt TableView ihre Breite durch Aufruf der Funktion columnWidthProvider. Wenn diese Funktion gesetzt ist, bestimmt sie allein die Breite der Spalte. Andernfalls wird geprüft, ob eine explizite Breite mit setColumnWidth() festgelegt wurde. Wenn nicht, wird implicitColumnWidth() verwendet. Die implizite Breite einer Spalte entspricht der größten implicit width, die unter den aktuell geladenen Delegaten in dieser Spalte gefunden wurde. Der Versuch, eine explizite width direkt auf einen Delegaten zu setzen, hat keinen Effekt und wird ignoriert und überschrieben. Die gleiche Logik gilt auch für Zeilenhöhen.

Eine Implementierung von columnWidthProvider, die der Standardlogik entspricht, wäre wie folgt:

columnWidthProvider: function(column) {
    let w = explicitColumnWidth(column)
    if (w >= 0)
        return w;
    return implicitColumnWidth(column)
}

Sobald die Spaltenbreite aufgelöst ist, werden alle anderen Elemente in derselben Spalte auf diese Breite angepasst, einschließlich aller Elemente, die zu einem späteren Zeitpunkt in die Ansicht geschoben werden.

Hinweis: Die aufgelöste Breite einer Spalte wird verworfen, wenn die gesamte Spalte aus der Ansicht herausgeklickt wird, und wird neu berechnet, wenn sie wieder hineingeklickt wird. Das bedeutet, dass, wenn die Breite von implicitColumnWidth() abhängt, die Berechnung jedes Mal anders ausfallen kann, je nachdem, in welcher Zeile Sie sich befinden, wenn die Spalte hineingeschoben wird (da implicitColumnWidth() nur die Delegatenelemente berücksichtigt, die gerade loaded sind). Um dies zu vermeiden, sollten Sie eine columnWidthProvider verwenden oder sicherstellen, dass alle delegierten Elemente in derselben Spalte die gleiche implicitWidth haben.

Wenn Sie die Werte ändern, die ein rowHeightProvider oder ein columnWidthProvider für Zeilen und Spalten innerhalb des Ansichtsfensters zurückgeben, müssen Sie forceLayout aufrufen. Dies teilt TableView mit, dass es die Provider-Funktionen erneut verwenden muss, um das Layout neu zu berechnen und zu aktualisieren.

Seit Qt 5.13 können Sie, wenn Sie eine bestimmte Spalte ausblenden wollen, 0 von columnWidthProvider für diese Spalte zurückgeben. Ebenso können Sie 0 aus der rowHeightProvider zurückgeben, um eine Zeile auszublenden. Wenn Sie eine negative Zahl zurückgeben, greift TableView auf die Berechnung der Größe basierend auf den Delegate Items zurück.

Hinweis: Die Größe einer Zeile oder Spalte sollte eine ganze Zahl sein, um eine Sub-Pixel-Ausrichtung der Elemente zu vermeiden.

Das folgende Beispiel zeigt, wie man ein einfaches columnWidthProvider zusammen mit einem Timer, der die von der Funktion zurückgegebenen Werte ändert, einstellt. Wenn das Array geändert wird, wird forceLayout aufgerufen, damit die Änderungen wirksam werden:

TableView {
    id: tableView

    property var columnWidths: [100, 50, 80, 150]
    columnWidthProvider: function (column) { return columnWidths[column] }

    Timer {
        running: true
        interval: 2000
        onTriggered: {
            tableView.columnWidths[2] = 150
            tableView.forceLayout();
        }
    }
}

Bearbeiten von Zellen

Sie können den Benutzer Tabellenzellen bearbeiten lassen, indem Sie einen Bearbeitungsdelegaten bereitstellen. Der Bearbeitungsdelegat wird entsprechend der editTriggers instanziiert, was standardmäßig geschieht, wenn der Benutzer doppelt auf eine Zelle tippt oder z.B. Qt::Key_Enter oder Qt::Key_Return drückt. Der Bearbeitungsdelegat wird mit TableView::editDelegate festgelegt, was eine angehängte Eigenschaft ist, die Sie auf delegate festlegen. Der folgende Ausschnitt zeigt, wie man das macht:

    TableView {
        id: tableView
        anchors.fill: parent
        clip: true

        model: TableModel {
            TableModelColumn { display: "name" }
            rows: [ { "name": "Harry" }, { "name": "Hedwig" } ]
        }

        selectionModel: ItemSelectionModel {}

        delegate: Rectangle {
            implicitWidth: 100
            implicitHeight: 50

            Text {
                anchors.centerIn: parent
                text: display
            }

            TableView.editDelegate: TextField {
                anchors.fill: parent
                text: display
                horizontalAlignment: TextInput.AlignHCenter
                verticalAlignment: TextInput.AlignVCenter
                Component.onCompleted: selectAll()

                TableView.onCommit: {
                    display = text
                    // 'display = text' is short-hand for:
                    // let index = TableView.view.index(row, column)
                    // TableView.view.model.setData(index, "display", text)
                }
            }
        }
    }

Wenn der Benutzer Qt::Key_Enter oder Qt::Key_Return drückt, während der Bearbeitungsdelegat aktiv ist, sendet TableView das Signal TableView::commit an den Bearbeitungsdelegat, so dass er die geänderten Daten in das Modell zurückschreiben kann.

Hinweis: Damit eine Zelle editierbar ist, muss das Modell QAbstractItemModel::flags() überschreiben und Qt::ItemIsEditable zurückgeben. Dieses Flag ist in QAbstractItemModel standardmäßig nicht aktiviert. Die Überschreibung könnte zum Beispiel wie folgt aussehen:

Qt::ItemFlags QAbstractItemModelSubClass::flags(const QModelIndex &index) const override
{
    Q_UNUSED(index)
    return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
}

Wenn die TableView delegate eine Eigenschaft required property bool editing definiert hat, wird sie für den zu bearbeitenden Delegaten auf true gesetzt. Ein Beispiel für die Verwendung dieser Eigenschaft finden Sie in der Dokumentation für editDelegate.

Overlays und Underlays

Alle neuen Elemente, die vom Delegaten instanziiert werden, werden dem contentItem mit dem Wert z übergeordnet, 1. Sie können Ihre eigenen Elemente innerhalb des Tableviews als untergeordnete Elemente des Flickable hinzufügen. Indem Sie ihren z Wert kontrollieren, können Sie sie über oder unter den Tabellenelementen platzieren.

Das folgende Beispiel zeigt, wie man einen Text über der Tabelle hinzufügen kann, der sich mit der Tabelle mitbewegt, wenn man sie anklickt:

TableView {
    id: tableView

    topMargin: header.implicitHeight

    Text {
        id: header
        text: "A table header"
    }
}

Hier ist ein weiteres Beispiel, das zeigt, wie man ein Overlay-Element erstellt, das über einer bestimmten Zelle bleibt. Hierfür ist etwas mehr Code erforderlich, da die Position einer Zelle change wird, wenn der Benutzer z. B. die Größe einer Spalte vor der Zelle ändert.

Rectangle {
    id: overlay
    width: 20
    height: 20
    radius: 10
    color: "blue"

    z: 10
    parent: tableView.contentItem

    Connections {
        target: tableView
        function onLayoutChanged() {
            let item = tableView.itemAtCell(5, 5)
            let insideViewport = item !== null

            overlay.visible = insideViewport
            if (insideViewport) {
                overlay.x = item.x
                overlay.y = item.y
            }
        }
    }
}

Sie könnten das Overlay auch direkt an die Zelle anstelle von contentItem binden. Dies ist jedoch anfällig, da die Zelle entladen oder wiederverwendet wird, wenn sie aus dem Ansichtsfenster herausgeschoben wird.

Auswählen von Elementen

Sie können TableView eine Auswahlunterstützung hinzufügen, indem Sie der Eigenschaft selectionModel ein ItemSelectionModel zuweisen. Dieses Modell wird dann verwendet, um zu steuern, welche Delegatenelemente als ausgewählt angezeigt werden sollen und welches Element als aktuell angezeigt werden soll. Sie können selectionBehavior einstellen, um zu steuern, ob der Benutzer einzelne Zellen, Zeilen oder Spalten auswählen darf.

Um herauszufinden, ob ein Delegat ausgewählt oder aktuell ist, deklarieren Sie die folgenden Eigenschaften:

delegate: Item {
    required property bool selected
    required property bool current
    // ...
}

Hinweis: Die Eigenschaften selected und current müssen als required definiert werden. Dadurch wird TableView mitgeteilt, dass es die Verantwortung für die Aktualisierung ihrer Werte übernehmen soll. Wenn nicht, werden sie einfach ignoriert. Siehe auch Erforderliche Eigenschaften.

Der folgende Ausschnitt zeigt, wie eine Anwendung den Delegaten abhängig von der selected Eigenschaft unterschiedlich darstellen kann:

    TableView {
        id: tableView
        anchors.fill: parent
        clip: true

        model: TableModel {
            TableModelColumn { display: "name" }
            rows: [ { "name": "Harry" }, { "name": "Hedwig" } ]
        }

        selectionModel: ItemSelectionModel {}

        delegate: Rectangle {
            implicitWidth: 100
            implicitHeight: 30
            color: selected ? "blue" : "lightgray"

            required property bool selected

            Text { text: display }
        }
    }

Die Eigenschaften currentRow und currentColumn können auch nützlich sein, wenn Sie einen Delegaten unterschiedlich darstellen müssen, je nachdem, ob er in derselben Zeile oder Spalte wie das aktuelle Element liegt.

Anmerkung: Qt Quick Controls bietet eine SelectionRectangle, die verwendet werden kann, damit der Benutzer Zellen auswählen kann.

Hinweis: Standardmäßig wird eine Zelle zu current, und alle Markierungen werden entfernt, wenn der Benutzer auf sie tippt. Wenn ein solches Standard-Tap-Verhalten nicht erwünscht ist (z. B. wenn Sie benutzerdefinierte Pointer-Handler innerhalb Ihres Delegaten verwenden), können Sie pointerNavigationEnabled auf false setzen.

Um die Tastaturnavigation zu unterstützen, müssen Sie der Eigenschaft selectionModel ein ItemSelectionModel zuweisen. TableView wird dann dieses Modell verwenden, um die currentIndex des Modells zu manipulieren.

Es liegt in der Verantwortung des Delegaten, sich selbst als current darzustellen. Sie können dies tun, indem Sie ihm eine Eigenschaft required property bool current hinzufügen und das Aussehen von seinem Zustand abhängig machen. Der Wert der Eigenschaft current wird von der TableView festgelegt. Sie können auch die Tastaturnavigation vollständig deaktivieren (für den Fall, dass Sie Ihre eigenen Tastenhandler implementieren möchten), indem Sie keyNavigationEnabled auf false setzen.

Das folgende Beispiel zeigt, wie Sie die Tastaturnavigation zusammen mit den Eigenschaften current und selected verwenden können:

ApplicationWindow {
    width: 800
    height: 600
    visible: true
    ScrollView {
        anchors.fill: parent
        TableView {
            id: tableView
            clip: true
            interactive: true
            rowSpacing: 1
            columnSpacing: 1
            model: TableModel {
                TableModelColumn { display: "checked" }
                TableModelColumn { display: "amount" }
                TableModelColumn { display: "fruitType" }
                TableModelColumn { display: "fruitName" }
                TableModelColumn { display: "fruitPrice" }

                rows: [
                    {
                        checked: false,
                        amount: 1,
                        fruitType: "Apple",
                        fruitName: "Granny Smith",
                        fruitPrice: 1.50
                    },
                    {
                        checked: true,
                        amount: 4,
                        fruitType: "Orange",
                        fruitName: "Navel",
                        fruitPrice: 2.50
                    },
                    {
                        checked: false,
                        amount: 1,
                        fruitType: "Banana",
                        fruitName: "Cavendish",
                        fruitPrice: 3.50
                    }
                ]
            }
            selectionModel: ItemSelectionModel {}
            delegate: Rectangle {
                implicitWidth: 100
                implicitHeight: 50
                required property bool selected
                required property bool current
                border.width: current ? 2 : 0
                color: selected ? "lightblue" : palette.base
                Text{
                    text: model.display
                    padding: 12
                }
            }
        }
    }
    SelectionRectangle {
        target: tableView
    }
}

Kopieren und Einfügen

Die Implementierung von Kopier- und Einfügeoperationen für einen TableView beinhaltet in der Regel auch die Verwendung eines QUndoStack (oder eines anderen Undo/Redo Frameworks). Die QUndoStack kann verwendet werden, um die verschiedenen Operationen auf dem Modell zu speichern, wie das Hinzufügen oder Entfernen von Zeilen, oder das Einfügen von Daten aus der Zwischenablage, mit einer Möglichkeit, es später wieder rückgängig zu machen. Allerdings sollte eine begleitende QUndoStack, die die möglichen Operationen und deren Rückgängigmachung beschreibt, entsprechend den Bedürfnissen des Modells und der Anwendung gestaltet werden. Als solches bietet TableView keine eingebaute API für die Handhabung von Kopieren und Einfügen.

Das folgende Snippet kann als Referenz für das Hinzufügen von Kopier- und Einfügeunterstützung zu Ihrem Modell und TableView verwendet werden. Es verwendet die bestehende Mime Data API in QAbstractItemModel, zusammen mit QClipboard. Das Snippet funktioniert so wie es ist, kann aber auch erweitert werden, um eine QUndoStack zu verwenden.

// Inside your C++ QAbstractTableModel subclass:

Q_INVOKABLE void copyToClipboard(const QModelIndexList &indexes) const
{
    QGuiApplication::clipboard()->setMimeData(mimeData(indexes));
}

Q_INVOKABLE bool pasteFromClipboard(const QModelIndex &targetIndex)
{
    const QMimeData *mimeData = QGuiApplication::clipboard()->mimeData();
    // Consider using a QUndoCommand for the following call. It should store
    // the (mime) data for the model items that are about to be overwritten, so
    // that a later call to undo can revert it.
    return dropMimeData(mimeData, Qt::CopyAction, -1, -1, targetIndex);
}

Die beiden Funktionen können z. B. von QML aus wie folgt verwendet werden:

TableView {
    id: tableView
    model: tableModel
    selectionModel: ItemSelectionModel {}

    Shortcut {
       sequence: StandardKey.Copy
       onActivated: {
           let indexes = tableView.selectionModel.selectedIndexes
           tableView.model.copyToClipboard(indexes)
       }
    }

    Shortcut {
       sequence: StandardKey.Paste
       onActivated: {
           let targetIndex = tableView.selectionModel.currentIndex
           tableView.model.pasteFromClipboard(targetIndex)
       }
    }
}

Siehe auch TableView::editDelegate, TableView::commit, editTriggers, edit(), closeEditor(), layoutChanged(), QAbstractItemModel::mimeData(), QAbstractItemModel::dropMimeData(), QUndoStack, QUndoCommand, und QClipboard.

Eigenschaft Dokumentation

alternatingRows : bool

Diese Eigenschaft steuert, ob sich die Hintergrundfarbe der Zeilen abwechseln soll. Der Standardwert ist stilabhängig.

Hinweis: Diese Eigenschaft ist nur ein Hinweis und wird daher möglicherweise von benutzerdefinierten Delegaten nicht beachtet. Es wird empfohlen, dass ein Delegat zwischen palette.base und palette.alternateBase wechselt, wenn dieser Hinweis true lautet, so dass die Farben von außerhalb des Delegaten festgelegt werden können. Zum Beispiel:

background: Rectangle {
    color: control.row === control.tableView.currentRow
           ? control.palette.highlight
           : (control.tableView.alternatingRows && control.row % 2 !== 0
           ? control.palette.alternateBase
           : control.palette.base)
}

animate : bool [since 6.4]

Diese Eigenschaft kann festgelegt werden, um zu steuern, ob TableView die contentItem (contentX und contentY) animieren soll. Sie wird von positionViewAtCell() und beim Navigieren von the current index mit der Tastatur verwendet. Der Standardwert ist true.

Wenn sie auf false gesetzt wird, wird jede laufende Animation sofort gestoppt.

Hinweis: Diese Eigenschaft ist nur ein Hinweis. TableView könnte das Inhaltselement ohne Animation positionieren, wenn z. B. die Zielzelle nicht loaded ist. Wenn sie jedoch auf false gesetzt ist, werden Animationen immer ausgeschaltet sein.

Diese Eigenschaft wurde in Qt 6.4 eingeführt.

Siehe auch positionViewAtCell().

bottomRow : int

Diese Eigenschaft enthält die unterste Zeile, die derzeit in der Ansicht sichtbar ist.

Siehe auch leftColumn, rightColumn, und topRow.

columnSpacing : real

Diese Eigenschaft gibt den Abstand zwischen den Spalten an.

Der Standardwert ist 0.

columnWidthProvider : var

Diese Eigenschaft kann eine Funktion enthalten, die die Spaltenbreite für jede Spalte im Modell zurückgibt. Sie wird immer dann aufgerufen, wenn TableView die Breite einer bestimmten Spalte wissen muss. Die Funktion benötigt ein Argument, column, für das TableView die Breite wissen muss.

Seit Qt 5.13 können Sie, wenn Sie eine bestimmte Spalte ausblenden wollen, 0 width für diese Spalte zurückgeben. Wenn Sie eine negative Zahl zurückgeben, berechnet TableView die Breite auf der Grundlage der Delegatenelemente.

Hinweis: Der columnWidthProvider wird in der Regel zweimal aufgerufen, wenn eine Spalte geladen werden soll (oder wenn ein Layout erstellt wird). Erstens, um zu wissen, ob die Spalte sichtbar ist und geladen werden soll. Und zweitens, um die Breite der Spalte zu bestimmen, nachdem alle Elemente geladen wurden. Wenn Sie die Spaltenbreite auf der Grundlage der Größe der delegierten Elemente berechnen müssen, müssen Sie auf den zweiten Aufruf warten, wenn alle Elemente geladen sind. Sie können dies überprüfen, indem Sie isColumnLoaded(column) aufrufen und einfach -1 zurückgeben, wenn dies noch nicht der Fall ist.

Siehe auch rowHeightProvider, isColumnLoaded(), und Row heights and column widths.

columns : int [read-only]

Diese Eigenschaft enthält die Anzahl der Spalten in der Tabelle.

Hinweis: columns ist normalerweise gleich der Anzahl der Spalten im Modell, kann aber vorübergehend abweichen, bis alle anstehenden Modelländerungen verarbeitet wurden.

Handelt es sich bei dem Modell um eine Liste, so sind die Spalten 1.

Diese Eigenschaft ist nur lesbar.

contentHeight : real

Diese Eigenschaft enthält die Tabellenhöhe, die für die Anzahl der Zeilen im Datenmodell erforderlich ist. Sie entspricht normalerweise nicht der height der view, was bedeutet, dass die Höhe der Tabelle größer oder kleiner als die Höhe des Ansichtsfensters sein kann. Da TableView nicht immer die genaue Höhe der Tabelle kennen kann, ohne alle Zeilen des Modells zu laden, ist contentHeight in der Regel eine Schätzung auf der Grundlage der ursprünglich geladenen Tabelle.

Wenn Sie wissen, wie hoch die Tabelle sein wird, weisen Sie contentHeight einen Wert zu, um unnötige Berechnungen und Aktualisierungen der TableView zu vermeiden.

Siehe auch contentWidth und rowHeightProvider.

contentWidth : real

Diese Eigenschaft enthält die Breite der Tabelle, die erforderlich ist, um die Anzahl der Spalten im Modell unterzubringen. Diese entspricht normalerweise nicht der width der view, was bedeutet, dass die Breite der Tabelle größer oder kleiner als die Breite des Ansichtsfensters sein kann. Da TableView nicht immer die genaue Breite der Tabelle kennen kann, ohne alle Spalten des Modells zu laden, ist contentWidth in der Regel eine Schätzung auf der Grundlage der ursprünglich geladenen Tabelle.

Wenn Sie wissen, wie breit die Tabelle sein wird, weisen Sie contentWidth einen Wert zu, um unnötige Berechnungen und Aktualisierungen der TableView zu vermeiden.

Siehe auch contentHeight und columnWidthProvider.

currentColumn : int [read-only]

Diese schreibgeschützte Eigenschaft enthält die Spalte in der Ansicht, die das Element enthält, das current. ist. Wenn kein Element aktuell ist, wird es -1 sein.

Hinweis: Damit TableView die aktuelle Spalte melden kann, müssen Sie selectionModel eine ItemSelectionModel zuweisen.

Siehe auch currentRow, selectionModel, und Selecting items.

currentRow : int [read-only]

Diese schreibgeschützte Eigenschaft enthält die Zeile in der Ansicht, die das Element enthält, das current. ist. Wenn kein Element aktuell ist, wird es -1 sein.

Hinweis: Damit TableView die aktuelle Zeile melden kann, müssen Sie selectionModel eine ItemSelectionModel zuweisen.

Siehe auch currentColumn, selectionModel, und Selecting items.

delegate : Component

Der Delegat bietet eine Vorlage, die jedes Zellelement definiert, das von der Ansicht instanziiert wird. Der Modellindex wird als eine zugängliche index Eigenschaft dargestellt. Das gleiche gilt für row und column. Eigenschaften des Modells sind auch je nach Art des Datenmodells verfügbar.

Ein Delegat sollte seine Größe mit implicitWidth und implicitHeight angeben. Die TableView legt die Elemente auf der Grundlage dieser Informationen an. Explizite Breiten- oder Höhenangaben werden ignoriert und überschrieben.

Innerhalb des Delegaten können Sie optional eine oder mehrere der folgenden Eigenschaften hinzufügen. TableView ändert die Werte dieser Eigenschaften, um den Delegaten zu informieren, in welchem Zustand er sich befindet. Dies kann vom Delegaten verwendet werden, um sich je nach seinem eigenen Zustand unterschiedlich darzustellen.

erforderliche Eigenschaft bool current - true wenn der Delegat current.
erforderliche Eigenschaft bool selected - true wenn der Delegat selected.
erforderliche Eigenschaft bool editing - true wenn der Delegat edited.
erforderliche Eigenschaft bool containsDrag - true wenn eine Spalte oder Zeile gerade über diesen Delegaten gezogen wird. Diese Eigenschaft wird nur für HorizontalHeaderView und VerticalHeaderView unterstützt (seit Qt 6.8).

Das folgende Beispiel zeigt, wie man diese Eigenschaften verwendet:

delegate: Rectangle {
    required property bool current
    required property bool selected
    border.width: current ? 1 : 0
    color: selected ? palette.highlight : palette.base
}

Hinweis: Delegaten werden nach Bedarf instanziiert und können jederzeit zerstört werden. Sie werden auch wiederverwendet, wenn die Eigenschaft reuseItems auf true gesetzt wird. Sie sollten daher vermeiden, Zustandsinformationen in den Delegaten zu speichern.

Siehe auch Row heights and column widths, Reusing items, und Erforderliche Eigenschaften.

editTriggers : enumeration [default: TableView.DoubleTapped | TableView.EditKeyPressed., since 6.5]

Diese Eigenschaft enthält die verschiedenen Möglichkeiten, wie der Benutzer mit der Bearbeitung einer Zelle beginnen kann. Sie kann eine Kombination der folgenden Werte sein:

Konstante	Beschreibung
`TableView.NoEditTriggers`	- der Benutzer kann die Bearbeitung von Zellen nicht auslösen. Wenn dieser Wert gesetzt ist, wird TableView den Bearbeitungsdelegaten als Reaktion auf eine Benutzerinteraktion weder öffnen noch schließen. Die Anwendung kann jedoch edit() und closeEditor() manuell aufrufen.
`TableView.SingleTapped`	- Der Benutzer kann eine Zelle bearbeiten, indem er sie einfach antippt.
`TableView.DoubleTapped`	- Der Benutzer kann eine Zelle bearbeiten, indem er sie doppelt antippt.
`TableView.SelectedTapped`	- der Benutzer kann eine selected cell durch Antippen bearbeiten.
`TableView.EditKeyPressed`	- Der Benutzer kann current cell durch Drücken einer der Bearbeitungstasten bearbeiten. Die Bearbeitungstasten werden vom Betriebssystem festgelegt, sind aber normalerweise `Qt::Key_Enter` und `Qt::Key_Return`.
`TableView.AnyKeyPressed`	- Der Benutzer kann current cell bearbeiten, indem er eine beliebige Taste drückt, mit Ausnahme der Navigationstasten für die Zellen. Die gedrückte Taste wird auch an das Fokusobjekt innerhalb von edit delegate gesendet.

Damit TableView.SelectedTapped, TableView.EditKeyPressed und TableView.AnyKeyPressed irgendeine Wirkung haben, muss TableView ein selection model zugewiesen werden, da sie davon abhängen, dass ein current index gesetzt ist. Um überhaupt Tastenereignisse empfangen zu können, muss TableView auch QQuickItem::activeFocus zugewiesen sein.

Bei der Bearbeitung einer Zelle kann der Benutzer Qt::Key_Tab oder Qt::Key_Backtab drücken, um die Daten auf commit zu übertragen und die Bearbeitung zur nächsten Zelle zu verschieben. Dieses Verhalten kann deaktiviert werden, indem QQuickItem::activeFocusOnTab auf TableView auf false gesetzt wird.

Hinweis: Damit eine Zelle bearbeitet werden kann, muss an delegate ein edit delegate angehängt sein, und das Modell muss Qt::ItemIsEditable von QAbstractItemModel::flags() zurückgeben (siehe Beispiel unten). Wenn Sie eine Zelle nach Aktivierung eines der angegebenen Auslöser immer noch nicht bearbeiten können, können Sie als Hilfe versuchen, edit() explizit aufzurufen (z.B. von einem Button/TapHandler). In diesem Fall wird eine Warnung ausgegeben, die erklärt, warum die Zelle nicht bearbeitet werden kann.

Qt::ItemFlags QAbstractItemModelSubClass::flags(const QModelIndex &index) const override
{
    Q_UNUSED(index)
    return Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsEditable;
}

Diese Eigenschaft wurde in Qt 6.5 eingeführt.

Siehe auch TableView::editDelegate, TableView::commit, und Editing cells.

keyNavigationEnabled : bool [since 6.4]

Diese Eigenschaft kann gesetzt werden, um zu steuern, ob der Benutzer in der Lage sein soll, the current index über die Tastatur zu ändern. Der Standardwert ist true.

Hinweis: Damit TableView die Tastaturnavigation unterstützt, müssen Sie selectionModel ein ItemSelectionModel zuweisen.

Diese Eigenschaft wurde in Qt 6.4 eingeführt.

Siehe auch Keyboard navigation, selectionModel, selectionBehavior, pointerNavigationEnabled, und interactive.

leftColumn : int

Diese Eigenschaft enthält die Spalte ganz links, die derzeit in der Ansicht sichtbar ist.

Siehe auch rightColumn, topRow und bottomRow.

model : model

Diese Eigenschaft enthält das Modell, das Daten für die Tabelle bereitstellt.

Das Modell stellt den Datensatz bereit, der zur Erstellung der Elemente in der Ansicht verwendet wird. Modelle können direkt in QML mit TableModel, ListModel, ObjectModel erstellt oder durch eine benutzerdefinierte C++-Modellklasse bereitgestellt werden. Das C++-Modell muss eine Unterklasse von QAbstractItemModel oder eine einfache Liste sein.

Siehe auch Datenmodelle.

pointerNavigationEnabled : bool [since 6.4]

Diese Eigenschaft kann gesetzt werden, um zu steuern, ob der Benutzer die Möglichkeit haben soll, the current index mit der Maus oder durch Berührung zu ändern. Der Standardwert ist true.

Diese Eigenschaft wurde in Qt 6.4 eingeführt.

Siehe auch selectionModel, keyNavigationEnabled, und interactive.

resizableColumns : bool [since 6.5]

Diese Eigenschaft legt fest, ob der Benutzer die Größe von Spalten durch Ziehen zwischen den Zellen ändern darf. Der Standardwert ist false.

Diese Eigenschaft wurde in Qt 6.5 eingeführt.

resizableRows : bool [since 6.5]

Diese Eigenschaft legt fest, ob der Benutzer die Größe von Zeilen durch Ziehen zwischen den Zellen ändern kann. Der Standardwert ist false.

Diese Eigenschaft wurde in Qt 6.5 eingeführt.

reuseItems : bool

Diese Eigenschaft legt fest, ob Elemente, die von delegate instanziiert wurden, wiederverwendet werden sollen. Wenn sie auf false gesetzt wird, werden alle derzeit gepoolten Elemente zerstört.

Siehe auch Reusing items, TableView::pooled, und TableView::reused.

rightColumn : int

Diese Eigenschaft enthält die Spalte ganz rechts, die derzeit in der Ansicht sichtbar ist.

Siehe auch leftColumn, topRow, und bottomRow.

rowHeightProvider : var

Diese Eigenschaft kann eine Funktion enthalten, die die Zeilenhöhe für jede Zeile des Modells zurückgibt. Sie wird immer dann aufgerufen, wenn TableView die Höhe einer bestimmten Zeile wissen muss. Die Funktion benötigt ein Argument, row, für das TableView die Höhe wissen muss.

Seit Qt 5.13 können Sie, wenn Sie eine bestimmte Zeile ausblenden wollen, 0 height für diese Zeile zurückgeben. Wenn Sie eine negative Zahl zurückgeben, berechnet TableView die Höhe auf der Grundlage der Delegatenelemente.

Hinweis: Der rowHeightProvider wird in der Regel zweimal aufgerufen, wenn eine Zeile geladen werden soll (oder wenn ein Layout erstellt wird). Erstens, um zu wissen, ob die Zeile sichtbar ist und geladen werden soll. Und zweitens, um die Höhe der Zeile zu bestimmen, nachdem alle Elemente geladen wurden. Wenn Sie die Zeilenhöhe auf der Grundlage der Größe der Delegatenelemente berechnen müssen, müssen Sie auf den zweiten Aufruf warten, wenn alle Elemente geladen sind. Sie können dies überprüfen, indem Sie isRowLoaded(row) aufrufen, und einfach -1 zurückgeben, wenn dies noch nicht der Fall ist.

Siehe auch rowHeightProvider, isRowLoaded(), und Row heights and column widths.

rowSpacing : real

Diese Eigenschaft enthält den Abstand zwischen den Zeilen.

Der Standardwert ist 0.

rows : int [read-only]

Diese Eigenschaft gibt die Anzahl der Zeilen in der Tabelle an.

Hinweis: rows ist in der Regel gleich der Anzahl der Zeilen im Modell, kann aber vorübergehend abweichen, bis alle anstehenden Modelländerungen verarbeitet wurden.

Diese Eigenschaft ist nur lesbar.

selectionBehavior : enumeration [since 6.4]

Diese Eigenschaft gibt an, ob der Benutzer Zellen, Zeilen oder Spalten auswählen kann.

Konstante	Beschreibung
`TableView.SelectionDisabled`	Der Benutzer kann keine Auswahlen vornehmen
`TableView.SelectCells`	(Standardwert) Der Benutzer kann einzelne Zellen markieren
`TableView.SelectRows`	Der Benutzer kann nur Zeilen markieren
`TableView.SelectColumns`	Der Benutzer kann nur Spalten markieren

Diese Eigenschaft wurde in Qt 6.4 eingeführt.

Siehe auch Selecting items, selectionMode, selectionModel, und keyNavigationEnabled.

selectionMode : enumeration [since 6.6]

Wenn selectionBehavior auf TableView.SelectCells gesetzt ist, gibt diese Eigenschaft an, ob der Benutzer eine Zelle oder mehrere Zellen auf einmal auswählen kann. Wenn selectionBehavior auf TableView.SelectRows eingestellt ist, gibt diese Eigenschaft an, ob der Benutzer jeweils eine Zeile oder mehrere Zeilen auswählen kann. Wenn selectionBehavior auf TableView.SelectColumns gesetzt ist, gibt diese Eigenschaft an, ob der Benutzer jeweils eine Spalte oder mehrere Spalten auswählen kann.

Die folgenden Modi sind verfügbar:

Konstant	Beschreibung
`TableView.SingleSelection`	Der Benutzer kann eine einzelne Zelle, Zeile oder Spalte auswählen.
`TableView.ContiguousSelection`	Der Benutzer kann einen einzelnen zusammenhängenden Block von Zellen auswählen. Eine bestehende Auswahl kann durch Gedrückthalten des `Shift` Modifikators während der Auswahl vergrößert oder verkleinert werden.
`TableView.ExtendedSelection`	(Standardwert) Der Benutzer kann mehrere einzelne Blöcke von Zellen auswählen. Eine bestehende Auswahl kann vergrößert oder verkleinert werden, indem der Modifikator `Shift` während der Auswahl gedrückt gehalten wird. Ein neuer Auswahlblock kann gestartet werden, ohne die aktuelle Auswahl zu löschen, indem der `Control` Modifikator während der Auswahl gedrückt gehalten wird.

Diese Eigenschaft wurde in Qt 6.6 eingeführt.

Siehe auch Selecting items, selectionBehavior, selectionModel, und keyNavigationEnabled.

selectionModel : ItemSelectionModel [since 6.2]

Diese Eigenschaft kann gesetzt werden, um zu steuern, welche Delegatenelemente als ausgewählt angezeigt werden sollen und welches Element als aktuell angezeigt werden soll. Wenn der Delegat ein required property bool selected definiert hat, wird TableView es mit dem Auswahlstatus des entsprechenden Modellelements im Auswahlmodell synchronisieren. Wenn der Delegat ein required property bool current definiert hat, wird TableView ihn mit selectionModel.currentIndex synchronisieren.

Diese Eigenschaft wurde in Qt 6.2 eingeführt.

Siehe auch Selecting items, SelectionRectangle, keyNavigationEnabled, und pointerNavigationEnabled.

syncDirection : Qt::Orientations

Wenn syncView auf TableView gesetzt ist, steuert diese Eigenschaft die Synchronisation der Schwenkrichtung(en) für beide Tabellen. Die Voreinstellung ist Qt.Horizontal | Qt.Vertical, was bedeutet, dass, wenn Sie eine der beiden Tabellen in eine der beiden Richtungen bewegen, die andere Tabelle um denselben Betrag in dieselbe Richtung bewegt wird.

Diese Eigenschaft und syncView können verwendet werden, um zwei tableViews zu synchronisieren, unabhängig von den unterschiedlichen Über- und Unterschreitungen, der Geschwindigkeit, der Beschleunigung/Verzögerung, der Rückprallanimation usw.

Ein typischer Anwendungsfall ist es, mehrere Kopfzeilen zusammen mit der Tabelle flackern zu lassen.

Siehe auch syncView.

syncView : TableView

Wenn diese Eigenschaft einer TableView auf eine andere TableView gesetzt wird, synchronisieren sich die beiden Tabellen in Bezug auf Flicking, Spaltenbreiten/Zeilenhöhen und Abstände gemäß syncDirection.

Wenn syncDirection Qt.Horizontal enthält, werden die Spaltenbreiten, der Spaltenabstand und die horizontale Bewegung der tableView mit der syncView synchronisiert.

Wenn syncDirection Qt.Vertical enthält, werden die Zeilenhöhen, der Zeilenabstand und die vertikale Bewegung von tableView mit syncView synchronisiert.

Siehe auch syncDirection.

topRow : int

Diese Eigenschaft enthält die oberste Zeile, die derzeit innerhalb der Ansicht sichtbar ist.

Siehe auch leftColumn, rightColumn, und bottomRow.

Dokumentation der angehängten Eigenschaft

TableView.editDelegate : Component

Diese angehängte Eigenschaft enthält den Bearbeitungsdelegaten. Er wird instanziiert, wenn die Bearbeitung beginnt, und ist dem Delegaten, den er bearbeitet, übergeordnet. Sie unterstützt die gleichen erforderlichen Eigenschaften wie TableView delegate, einschließlich index, row und column. Eigenschaften des Modells, wie display und edit, sind ebenfalls verfügbar (abhängig von der role names, die vom Modell angezeigt wird).

Die Bearbeitung beginnt, wenn die unter editTriggers angegebenen Aktionen erfüllt sind und die aktuelle Zelle bearbeitbar ist.

Hinweis: Damit eine Zelle bearbeitbar ist, muss das Modell QAbstractItemModel::flags() außer Kraft setzen und Qt::ItemIsEditable zurückgeben.

Sie können den Bearbeitungsdelegaten auch manuell öffnen und schließen, indem Sie edit() bzw. closeEditor() aufrufen. Das Qt::ItemIsEditable Flag wird dann ignoriert.

Die Bearbeitung endet, wenn der Benutzer Qt::Key_Enter oder Qt::Key_Return drückt (und auch Qt::Key_Tab oder Qt::Key_Backtab, wenn TableView QQuickItem::activeFocusOnTab gesetzt hat). In diesem Fall wird das Signal TableView::commit ausgegeben, so dass der Bearbeitungsdelegierte reagieren kann, indem er alle geänderten Daten zurück in das Modell schreibt. Wenn die Bearbeitung aus anderen Gründen endet (z.B. wenn der Benutzer Qt::Key_Escape drückt), wird das Signal nicht ausgegeben. In jedem Fall wird am Ende destruction() ausgegeben.

Während das Editierdelegat angezeigt wird, ist die Zelle darunter immer noch sichtbar und scheint daher durch, wenn das Editierdelegat durchsichtig ist oder nicht die ganze Zelle bedeckt. Wenn dies nicht erwünscht ist, können Sie entweder das Wurzelelement des Bearbeitungsdelegaten als einfarbiges Rectangle darstellen lassen oder einige der Elemente innerhalb des TableView delegate. ausblenden. Letzteres kann durch die Definition einer Eigenschaft required property bool editing innerhalb des Delegaten erfolgen, die Sie an die Eigenschaft visible einiger untergeordneter Elemente binden. Das folgende Snippet zeigt, wie man das macht:

        delegate: Rectangle {
            implicitWidth: 100
            implicitHeight: 50

            required property bool editing

            Text {
                id: textField
                anchors.fill: parent
                anchors.margins: 5
                text: display
                visible: !editing
            }

            TableView.editDelegate: TextField {
                x: textField.x
                y: textField.y
                width: textField.width
                height: textField.height
                text: display
                TableView.onCommit: display = text
            }
        }

Wenn der Bearbeitungsdelegat instanziiert wird, ruft TableView QQuickItem::forceActiveFocus () auf ihm auf. Wenn Sie möchten, dass der aktive Fokus stattdessen auf ein Kind des Bearbeitungsdelegaten gesetzt wird, lassen Sie den Bearbeitungsdelegaten ein FocusScope sein.

Siehe auch editTriggers, TableView::commit, edit(), closeEditor(), und Editing cells.

TableView.view : TableView

Diese angehängte Eigenschaft enthält die Ansicht, die die Delegateninstanz verwaltet. Sie ist mit jeder Instanz des Delegaten verbunden.

Signal-Dokumentation

[since 6.8] columnMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex)

Dieses Signal wird ausgesendet, wenn eine Spalte verschoben wird. Der logische Index der Spalte wird durch logicalIndex angegeben, der alte Index durch oldVisualIndex und die neue Indexposition durch newVisualIndex.

Hinweis: Der entsprechende Handler ist onColumnMoved.

Dieses Signal wurde in Qt 6.8 eingeführt.

[since 6.5] layoutChanged()

Dieses Signal wird immer dann ausgegeben, wenn sich das Layout der Zeilen und Spalten von loaded möglicherweise geändert hat. Dies ist insbesondere der Fall, wenn forceLayout() aufgerufen wird, aber auch, wenn z.B. die Größe einer Zeile oder Spalte geändert wird, oder wenn eine Zeile oder Spalte das Ansichtsfenster betreten oder verlassen hat.

Dieses Signal kann z.B. verwendet werden, um die Geometrie von Overlays zu aktualisieren.

Hinweis: Der entsprechende Handler ist onLayoutChanged.

Dieses Signal wurde in Qt 6.5 eingeführt.

Siehe auch forceLayout() und Overlays and underlays.

[since 6.8] rowMoved(int logicalIndex, int oldVisualIndex, int newVisualIndex)

Dieses Signal wird ausgegeben, wenn eine Zeile verschoben wird. Der logische Index der Zeile wird durch logicalIndex angegeben, der alte Index durch oldVisualIndex und die neue Indexposition durch newVisualIndex.

Hinweis: Der entsprechende Handler ist onRowMoved.

Dieses Signal wurde in Qt 6.8 eingeführt.

Dokumentation des angehängten Signals

commit()

Dieses Signal wird von der Funktion edit delegate

Dieses angehängte Signal wird ausgegeben, wenn edit delegate aktiv ist und der Benutzer Qt::Key_Enter oder Qt::Key_Return drückt. Es wird auch ausgegeben, wenn TableView QQuickItem::activeFocusOnTab gesetzt hat und der Benutzer Qt::Key_Tab oder Qt::Key_Backtab drückt.

Dieses Signal wird nicht ausgegeben, wenn die Bearbeitung aus anderen als den genannten Gründen beendet wird. Dazu gehört z. B., wenn der Benutzer Qt::Key_Escape drückt, außerhalb des Delegaten tippt, die bearbeitete Zeile oder Spalte gelöscht wird oder wenn die Anwendung closeEditor() aufruft.

Nach Erhalt des Signals sollte der Bearbeitungsdelegat alle geänderten Daten zurück in das Modell schreiben.

Hinweis: Diese Eigenschaft sollte an die edit delegate und nicht an die delegate angehängt werden.

Hinweis: Der entsprechende Handler ist onCommit.

Siehe auch TableView::editDelegate, editTriggers, und Editing cells.

pooled()

Dieses Signal wird ausgegeben, nachdem ein Element zum Wiederverwendungspool hinzugefügt wurde. Sie können es verwenden, um laufende Timer oder Animationen innerhalb des Objekts anzuhalten oder um Ressourcen freizugeben, die nicht wiederverwendet werden können.

Dieses Signal wird nur ausgegeben, wenn die Eigenschaft reuseItems true lautet.

Hinweis: Der entsprechende Handler ist onPooled.

Siehe auch Reusing items, reuseItems, und reused.

reused()

Dieses Signal wird ausgegeben, nachdem ein Element wiederverwendet wurde. Zu diesem Zeitpunkt wurde das Element aus dem Pool genommen und in der Inhaltsansicht platziert, und die Modelleigenschaften wie Index, Zeile und Spalte wurden aktualisiert.

Andere Eigenschaften, die nicht vom Modell bereitgestellt werden, ändern sich nicht, wenn ein Element wiederverwendet wird. Sie sollten es vermeiden, irgendeinen Zustand innerhalb eines Delegaten zu speichern, aber wenn Sie es doch tun, setzen Sie diesen Zustand beim Empfang dieses Signals manuell zurück.

Dieses Signal wird ausgegeben, wenn das Element wiederverwendet wird, und nicht, wenn das Element zum ersten Mal erstellt wird.

Dieses Signal wird nur ausgegeben, wenn die Eigenschaft reuseItems true lautet.

Hinweis: Der entsprechende Handler ist onReused.

Siehe auch Reusing items, reuseItems, und pooled.

Dokumentation der Methode

[since 6.4] point cellAtIndex(QModelIndex modelIndex)

Gibt die Zelle in der Ansicht zurück, die auf modelIndex im Modell abgebildet ist. Bequemlichkeitsfunktion für das Tun:

Qt.point(columnAtIndex(modelIndex), rowAtIndex(modelIndex))

Eine Zelle ist einfach eine point, die Zeile und Spalte in einem einzigen Typ kombiniert.

Hinweis: point.x wird der Spalte zugeordnet und point.y der Zeile.

Diese Methode wurde in Qt 6.4 eingeführt.

Point cellAtPosition(point position, bool includeSpacing)

Gibt die Zelle an der angegebenen position in der Tabelle zurück. position sollte relativ zu contentItem sein. Wenn sich keine loaded Zelle mit position überschneidet, ist der Rückgabewert point(-1, -1).

Wenn includeSpacing auf true gesetzt ist, wird davon ausgegangen, dass die Bounding Box einer Zelle die Hälfte der angrenzenden rowSpacing und columnSpacing auf jeder Seite umfasst. Der Standardwert ist false.

Hinweis: Ein Input Handler, der an eine TableView angehängt ist, installiert sich selbst auf der contentItem und nicht auf dem View. Daher kann die vom Handler gemeldete Position direkt in einem Aufruf dieser Funktion ohne mapping verwendet werden.

Siehe auch columnSpacing und rowSpacing.

Point cellAtPosition(real x, real y, bool includeSpacing)

Bequemlichkeit für den Aufruf von cellAtPosition(Qt.point(x, y), includeSpacing).

[since 6.8] clearColumnReordering()

Setzt alle zuvor angewendeten Spaltenumstellungen zurück.

Hinweis: Wenn eine syncView gesetzt ist, wird ein Aufruf dieser Funktion an das entsprechende Ansichtselement weitergeleitet und setzt die Spaltenreihenfolge zurück.

Diese Methode wurde in Qt 6.8 eingeführt.

clearColumnWidths()

Löscht alle mit setColumnWidth() gesetzten Spaltenbreiten.

Hinweis: Wenn eine syncView zusammen mit einer Qt.Horizontal syncDirection gesetzt ist, kontrolliert die Sync-Ansicht die Spaltenbreiten. Daher wird in diesem Fall jeder Aufruf dieser Funktion stattdessen an die Sync-Ansicht weitergeleitet.

Siehe auch setColumnWidth(), clearRowHeights(), und Row heights and column widths.

clearRowHeights()

Löscht alle Zeilenhöhen, die mit setRowHeight() gesetzt wurden.

Hinweis: Wenn ein syncView zusammen mit einem Qt.Vertical syncDirection gesetzt wird, steuert die Sync-Ansicht die Zeilenhöhen. Daher wird in diesem Fall jeder Aufruf dieser Funktion stattdessen an die Sync-Ansicht weitergeleitet.

Siehe auch setRowHeight(), clearColumnWidths(), und Row heights and column widths.

[since 6.8] clearRowReordering()

Setzt alle zuvor angewendeten Zeilenumbrüche zurück.

Hinweis: Wenn eine syncView gesetzt ist, wird ein Aufruf dieser Funktion an das entsprechende Ansichtselement weitergeleitet und setzt die Zeilenreihenfolge zurück.

Diese Methode wurde in Qt 6.8 eingeführt.

[since 6.5] closeEditor()

Wenn der Benutzer eine Zelle bearbeitet, wird durch den Aufruf dieser Funktion die Bearbeitung gestoppt und die Instanz des Bearbeitungsdelegaten zerstört.

Diese Methode wurde in Qt 6.5 eingeführt.

Siehe auch edit(), TableView::editDelegate, und Editing cells.

[since 6.4] int columnAtIndex(QModelIndex modelIndex)

Gibt die Spalte in der Ansicht zurück, die auf modelIndex im Modell abgebildet ist.

Diese Methode wurde in Qt 6.4 eingeführt.

Siehe auch rowAtIndex() und index().

[since 6.2] real columnWidth(int column)

Gibt die Breite der angegebenen column zurück. Wenn die Spalte nicht geladen (und daher nicht sichtbar) ist, lautet der Rückgabewert -1.

Diese Methode wurde in Qt 6.2 eingeführt.

Siehe auch setColumnWidth(), columnWidthProvider, implicitColumnWidth(), isColumnLoaded(), und Row heights and column widths.

[since 6.5] edit(QModelIndex modelIndex)

Diese Funktion startet eine Bearbeitungssitzung für die Zelle, die modelIndex darstellt. Wenn der Benutzer bereits eine andere Zelle bearbeitet, wird diese Sitzung beendet.

Normalerweise können Sie die verschiedenen Möglichkeiten zum Starten einer Bearbeitungssitzung angeben, indem Sie stattdessen editTriggers verwenden. Wenn das nicht ausreicht, können Sie diese Funktion verwenden. Um die volle Kontrolle über die Bearbeitung von Zellen zu übernehmen und zu verhindern, dass sich TableView einmischt, setzen Sie editTriggers auf TableView.NoEditTriggers.

Hinweis: Die current index in der selection model wird auch auf modelIndex geändert.

Diese Methode wurde in Qt 6.5 eingeführt.

Siehe auch closeEditor(), editTriggers, TableView::editDelegate, und Editing cells.

qreal explicitColumnWidth(int column)

Gibt die Breite von column zurück, die mit setColumnWidth() gesetzt wurde. Diese Breite kann von der tatsächlichen Breite der Spalte abweichen, wenn eine columnWidthProvider verwendet wird. Um die tatsächliche Breite einer Spalte zu erhalten, verwenden Sie columnWidth().

Ein Rückgabewert gleich 0 bedeutet, dass der Spalte mitgeteilt wurde, dass sie ausgeblendet werden soll. Ein Rückgabewert gleich -1 bedeutet, dass keine explizite Breite für die Spalte festgelegt wurde.

Hinweis: Wenn ein syncView zusammen mit einem Qt.Horizontal syncDirection gesetzt wird, steuert die Sync-Ansicht die Spaltenbreiten. Daher wird in diesem Fall jeder Aufruf dieser Funktion stattdessen an die Sync-Ansicht weitergeleitet.

Siehe auch setColumnWidth(), columnWidth(), und Row heights and column widths.

qreal explicitRowHeight(int row)

Gibt die Höhe des row zurück, die mit setRowHeight() festgelegt wurde. Diese Höhe kann sich von der tatsächlichen Höhe der Spalte unterscheiden, wenn eine rowHeightProvider verwendet wird. Um die tatsächliche Höhe einer Zeile zu erhalten, verwenden Sie rowHeight().

Ein Rückgabewert gleich 0 bedeutet, dass der Zeile mitgeteilt wurde, dass sie ausgeblendet werden soll. Ein Rückgabewert gleich -1 bedeutet, dass keine explizite Höhe für die Zeile festgelegt wurde.

Siehe auch setRowHeight(), rowHeight(), und Row heights and column widths.

forceLayout()

Die Reaktion auf Änderungen im Modell wird gebündelt, so dass sie nur einmal pro Frame behandelt werden. Das bedeutet, dass TableView die Anzeige von Änderungen verzögert, während ein Skript ausgeführt wird. Das Gleiche gilt auch für die Änderung von Eigenschaften, wie rowSpacing oder leftMargin.

Diese Methode zwingt TableView dazu, das Layout sofort zu aktualisieren, so dass alle kürzlich vorgenommenen Änderungen wirksam werden.

Durch den Aufruf dieser Funktion wird die Größe und Position jeder sichtbaren Zeile und Spalte neu bewertet. Dies ist erforderlich, wenn die rowHeightProvider oder columnWidthProvider zugewiesenen Funktionen andere Werte als die bereits zugewiesenen zurückgeben.

[since 6.2] real implicitColumnWidth(int column)

Gibt die implizite Breite der angegebenen column zurück. Dies ist die größte implicitWidth, die unter den aktuell loaded delegierten Elementen innerhalb dieser Spalte gefunden wurde.

Wenn column nicht geladen (und daher nicht sichtbar) ist, lautet der Rückgabewert -1.

Diese Methode wurde in Qt 6.2 eingeführt.

Siehe auch columnWidth(), isRowLoaded(), und Row heights and column widths.

[since 6.2] real implicitRowHeight(int row)

Gibt die implizite Höhe der angegebenen row zurück. Dies ist die größte implicitHeight, die unter den aktuell loaded delegierten Elementen innerhalb dieser Zeile gefunden wurde.

Wenn row nicht geladen (und daher nicht sichtbar) ist, lautet der Rückgabewert -1.

Diese Methode wurde in Qt 6.2 eingeführt.

Siehe auch rowHeight(), isColumnLoaded(), und Row heights and column widths.

[since 6.4.3] QModelIndex index(int row, int column)

Gibt die QModelIndex zurück, die row und column in der Ansicht entspricht.

row und column sollten die Zeile und Spalte in der Ansicht sein (Tabellenzeile und Tabellenspalte) und nicht eine Zeile und Spalte im Modell. Für eine einfache TableView ist dies gleichbedeutend mit dem Aufruf von model.index(row, column).. Aber für eine Unterklasse von TableView, wie TreeView, wo das Datenmodell in ein internes Proxy-Modell verpackt ist, das die Baumstruktur in eine Tabelle umwandelt, müssen Sie diese Funktion verwenden, um den Modellindex aufzulösen.

Diese Methode wurde in Qt 6.4.3 eingeführt.

Siehe auch rowAtIndex() und columnAtIndex().

[since 6.2] bool isColumnLoaded(int column)

Gibt true zurück, wenn die angegebene column geladen ist.

Eine Spalte ist geladen, wenn TableView die Delegatenelemente geladen hat, die benötigt werden, um die Spalte innerhalb der Ansicht anzuzeigen. Dies bedeutet normalerweise auch, dass die Spalte für den Benutzer sichtbar ist, aber nicht immer.

Diese Funktion kann immer dann verwendet werden, wenn Sie über die Delegate Items für eine Spalte iterieren müssen, z.B. von einer columnWidthProvider, um sicher zu sein, dass die Delegate Items für die Iteration verfügbar sind.

Diese Methode wurde in Qt 6.2 eingeführt.

[since 6.2] bool isRowLoaded(int row)

Gibt true zurück, wenn die angegebene row geladen ist.

Eine Zeile ist geladen, wenn TableView die Delegatenelemente geladen hat, die zum Anzeigen der Zeile in der Ansicht erforderlich sind. Dies bedeutet normalerweise auch, dass die Zeile für den Benutzer sichtbar ist, aber nicht immer.

Diese Funktion kann immer dann verwendet werden, wenn Sie über die Delegate Items für eine Zeile iterieren müssen, z.B. von einem rowHeightProvider, um sicher zu sein, dass die Delegate Items für die Iteration verfügbar sind.

Diese Methode wurde in Qt 6.2 eingeführt.

Item itemAtCell(point cell)

Gibt das Delegate Item unter cell zurück, wenn es geladen ist, ansonsten null.

Hinweis: Nur die Elemente, die in der Ansicht sichtbar sind, werden normalerweise geladen. Sobald eine Zelle aus der Ansicht herausgeklickt wird, wird das darin befindliche Element entweder entladen oder in den Recycle-Pool gelegt. Daher sollte der Rückgabewert niemals gespeichert werden.

[since 6.5] Item itemAtIndex(QModelIndex index)

Gibt das instanziierte Delegatenelement für die Zelle zurück, die index darstellt. Wenn das Element nicht loaded ist, lautet der Wert null.

Hinweis: Normalerweise werden nur die Elemente geladen, die in der Ansicht sichtbar sind. Sobald eine Zelle aus der Ansicht herausgeklickt wird, wird das darin befindliche Element entweder entladen oder in den Recycling-Pool gelegt. Daher sollte der Rückgabewert niemals gespeichert werden.

Hinweis: Wenn model kein QAbstractItemModel ist, können Sie auch itemAtCell(Qt.point(Spalte, Zeile)) verwenden. Beachten Sie jedoch, dass sich point.x auf Spalten und point.y auf Zeilen bezieht.

Diese Methode wurde in Qt 6.5 eingeführt.

[since 6.4] QModelIndex modelIndex(point cell)

Bequemlichkeitsfunktion für doing:

index(cell.y, cell.x)

Eine cell ist einfach eine point, die Zeile und Spalte in einem einzigen Typ kombiniert.

Hinweis: point.x wird auf die Spalte abgebildet, und point.y auf die Zeile.

Diese Methode wurde in Qt 6.4 eingeführt.

Siehe auch index().

[since 6.8] moveColumn(int source, int destination)

Verschiebt eine Spalte von der Position source zur Position destination.

Hinweis: Wenn eine syncView gesetzt ist, steuert die Sync-Ansicht die interne Indexzuordnung für die Neuordnung der Spalten. Daher wird in diesem Fall ein Aufruf dieser Funktion stattdessen an die Sync-Ansicht weitergeleitet.

Diese Methode wurde in Qt 6.8 eingeführt.

[since 6.8] moveRow(int source, int destination)

Verschiebt eine Zeile von der Position source zur Position destination.

Hinweis: Wenn eine syncView gesetzt ist, steuert die Sync-Ansicht die interne Indexzuordnung für die Neuordnung der Zeilen. Daher wird in diesem Fall ein Aufruf dieser Funktion stattdessen an die Sync-Ansicht weitergeleitet.

Diese Methode wurde in Qt 6.8 eingeführt.

positionViewAtCell(point cell, PositionMode mode, point offset, rect subRect)

Positioniert contentX und contentY so, dass cell sich an der durch mode angegebenen Position befindet. mode kann eine oder eine der folgenden Kombinationen sein:

Konstante	Beschreibung
`TableView.AlignLeft`	Positioniert die Zelle auf der linken Seite der Ansicht.
`TableView.AlignHCenter`	Positionieren Sie die Zelle in der horizontalen Mitte der Ansicht.
`TableView.AlignRight`	Positionierung der Zelle am rechten Rand der Ansicht.
`TableView.AlignTop`	Positioniert die Zelle am oberen Rand der Ansicht.
`TableView.AlignVCenter`	Positionieren Sie die Zelle in der vertikalen Mitte der Ansicht.
`TableView.AlignBottom`	Positionieren Sie die Zelle am unteren Rand der Ansicht.
`TableView.AlignCenter`	Dasselbe wie (TableView.AlignHCenter \| TableView.AlignVCenter)
`TableView.Visible`	Wenn ein Teil der Zelle sichtbar ist, wird nichts unternommen. Andernfalls verschieben Sie das Inhaltselement so, dass die gesamte Zelle sichtbar wird.
`TableView.Contain`	Wenn die gesamte Zelle sichtbar ist, wird nichts unternommen. Andernfalls verschiebe das Inhaltselement so, dass die gesamte Zelle sichtbar wird. Wenn die Zelle größer ist als die Ansicht, wird der linke obere Teil der Zelle bevorzugt.

Wenn keine vertikale Ausrichtung angegeben ist, wird die vertikale Positionierung ignoriert. Das Gleiche gilt für die horizontale Ausrichtung.

Optional können Sie offset angeben, um contentX und contentY um eine zusätzliche Anzahl von Pixeln über die Zielausrichtung hinaus zu verschieben. Wenn Sie z.B. die Ansicht so positionieren möchten, dass die Zelle [10, 10] in der linken oberen Ecke mit einem Abstand von 5px landet, können Sie das tun:

positionViewAtCell(Qt.point(10, 10), TableView.AlignLeft | TableView.AlignTop, Qt.point(-5, -5))

Ab Qt 6.4 können Sie subRect angeben, um auf einem Rechteck innerhalb der cell zu positionieren, anstatt auf dem Begrenzungsrechteck der gesamten Zelle. Dies kann nützlich sein, wenn die Zelle z.B. größer als die Ansicht ist und Sie sicherstellen wollen, dass ein bestimmter Teil davon sichtbar ist. Die subRect muss valid sein, um berücksichtigt werden zu können.

Hinweis: Es wird nicht empfohlen, contentX oder contentY zu verwenden, um die Ansicht auf eine bestimmte Zelle zu positionieren. Dies ist unzuverlässig, da das Entfernen von Elementen am Anfang der Tabelle nicht dazu führt, dass alle anderen Elemente neu positioniert werden. TableView kann manchmal auch Zeilen und Spalten an ungefähren Positionen platzieren, um die Geschwindigkeit zu optimieren. Die einzige Ausnahme ist, wenn die Zelle bereits in der Ansicht sichtbar ist, was im Vorfeld durch den Aufruf von itemAtCell() überprüft werden kann.

Die Methoden sollten erst aufgerufen werden, wenn die Component abgeschlossen ist. Um die Ansicht beim Starten zu positionieren, sollte diese Methode von Component.onCompleted aufgerufen werden. Zum Beispiel, um die Ansicht am Ende zu positionieren:

Component.onCompleted: positionViewAtCell(Qt.point(columns - 1, rows - 1), TableView.AlignRight | TableView.AlignBottom)

Hinweis: Das zweite Argument für diese Funktion war früher Qt.Alignment. Aus Gründen der Abwärtskompatibilität kann dieses Enum weiterhin verwendet werden. Die Änderung zur Verwendung von PositionMode wurde in Qt 6.4 vorgenommen.

Siehe auch animate.

positionViewAtColumn(int column, PositionMode mode, real offset, rect subRect)

Positioniert {Flickable::}{contentX} so, dass sich column an der durch mode, offset und subRect angegebenen Position befindet.

Komfortable Methode für den Aufruf von

positionViewAtCell(Qt.point(column, 0), mode & Qt.AlignHorizontal_Mask, offset, subRect)

[since 6.5] positionViewAtIndex(QModelIndex index, PositionMode mode, point offset, rect subRect)

Positioniert die Ansicht so, dass sich index an der durch mode, offset und subRect angegebenen Position befindet.

Convenience-Methode für den Aufruf von

positionViewAtRow(rowAtIndex(index), mode & Qt.AlignVertical_Mask, offset.y, subRect)
positionViewAtColumn(columnAtIndex(index), mode & Qt.AlignVertical_Mask, offset.x, subRect)

Diese Methode wurde in Qt 6.5 eingeführt.

positionViewAtRow(int row, PositionMode mode, real offset, rect subRect)

Positioniert {Flickable::}{contentY} so, dass sich row an der durch mode, offset und subRect angegebenen Position befindet.

Komfortable Methode für den Aufruf

positionViewAtCell(Qt.point(0, row), mode & Qt.AlignVertical_Mask, offset, subRect)

[since 6.4] int rowAtIndex(QModelIndex modelIndex)

Gibt die Zeile in der Ansicht zurück, die auf modelIndex im Modell abgebildet ist.

Diese Methode wurde in Qt 6.4 eingeführt.

Siehe auch columnAtIndex() und index().

[since 6.2] real rowHeight(int row)

Gibt die Höhe der angegebenen Zeile row zurück. Wenn die Zeile nicht geladen (und daher nicht sichtbar) ist, lautet der Rückgabewert -1.

Diese Methode wurde in Qt 6.2 eingeführt.

Siehe auch setRowHeight(), rowHeightProvider, implicitRowHeight(), isRowLoaded(), und Row heights and column widths.

setColumnWidth(int column, real size)

Setzt die explizite Spaltenbreite der Spalte column auf size.

Wenn Sie die Werte, die Sie mit dieser Funktion gesetzt haben, zurücklesen wollen, sollten Sie explicitColumnWidth() verwenden. columnWidth() gibt die tatsächliche Größe der Spalte zurück, die unterschiedlich sein kann, wenn ein columnWidthProvider gesetzt ist.

Wenn TableView die Breite von column auflösen muss, wird es zunächst versuchen, columnWidthProvider aufzurufen. Nur wenn kein Provider gesetzt ist, werden standardmäßig die mit dieser Funktion eingestellten Breiten verwendet. Sie können jedoch explicitColumnWidth() aus dem Provider heraus aufrufen und, falls erforderlich, die Werte so anpassen, dass sie z. B. immer innerhalb eines bestimmten Intervalls liegen. Der folgende Ausschnitt zeigt ein Beispiel, wie das geht:

columnWidthProvider: function(column) {
    let w = explicitColumnWidth(column)
    if (w >= 0)
        return Math.max(100, w);
    return implicitColumnWidth(column)
}

Wenn size gleich 0 ist, wird die Spalte ausgeblendet. Wenn size gleich -1 ist, wird die Spalte auf implicitColumnWidth() zurückgesetzt. Sie können Spaltengrößen für Spalten angeben, die außerhalb der Größe des Modells liegen.

Hinweis: Die von Ihnen festgelegten Größen werden nicht gelöscht, wenn Sie model ändern. Um die Größen zu löschen, müssen Sie clearColumnWidths() explizit aufrufen.

Hinweis: Wenn eine syncView zusammen mit einer Qt.Horizontal syncDirection gesetzt wird, steuert die Sync-Ansicht die Spaltenbreiten. Daher wird in diesem Fall jeder Aufruf dieser Funktion stattdessen an die Sync-Ansicht weitergeleitet.

Hinweis: Bei Modellen mit vielen Spalten kann die Verwendung von setColumnWidth(), um die Breiten für alle Spalten beim Start festzulegen, suboptimal sein. Dies verbraucht Startzeit und Speicher (für die Speicherung aller Breiten). Ein skalierbarerer Ansatz besteht darin, stattdessen ein columnWidthProvider zu verwenden oder sich auf die implizite Breite des Delegaten zu verlassen. Ein columnWidthProvider wird nur bei Bedarf aufgerufen und wird nicht von der Größe des Modells beeinflusst.

Siehe auch columnWidth(), explicitColumnWidth(), setRowHeight(), clearColumnWidths(), und Row heights and column widths.

setRowHeight(int row, real size)

Setzt die explizite Zeilenhöhe der Zeile row auf size.

Wenn Sie die Werte, die Sie mit dieser Funktion gesetzt haben, zurücklesen wollen, sollten Sie explicitRowHeight() verwenden. rowHeight() gibt die tatsächliche Höhe der Zeile zurück, die unterschiedlich sein kann, wenn eine rowHeightProvider gesetzt ist.

Wenn TableView die Höhe von row auflösen muss, wird es zuerst versuchen, rowHeightProvider aufzurufen. Nur wenn kein Provider gesetzt ist, werden standardmäßig die mit dieser Funktion eingestellten Höhen verwendet. Sie können jedoch explicitRowHeight() aus dem Provider heraus aufrufen und, falls erforderlich, die Werte so anpassen, dass sie z. B. immer innerhalb eines bestimmten Intervalls liegen. Der folgende Ausschnitt zeigt ein Beispiel, wie das geht:

rowHeightProvider: function(row) {
    let h = explicitRowHeight(row)
    if (h >= 0)
        return Math.max(100, h);
    return implicitRowHeight(row)
}

Wenn size gleich 0 ist, wird die Zeile ausgeblendet. Wenn size gleich -1 ist, wird die Zeile auf implicitRowHeight() zurückgesetzt. Sie können Zeilengrößen für Zeilen angeben, die außerhalb der Größe des Modells liegen.

Hinweis: Die von Ihnen festgelegten Größen werden nicht gelöscht, wenn Sie model ändern. Um die Größen zu löschen, müssen Sie clearRowHeights() explizit aufrufen.

Hinweis: Bei Modellen mit vielen Zeilen kann die Verwendung von setRowHeight(), um die Höhen für alle Zeilen beim Start zu setzen, suboptimal sein. Dies verbraucht Startzeit und Speicher (für die Speicherung aller Höhen). Ein skalierbarerer Ansatz besteht darin, stattdessen ein rowHeightProvider zu verwenden oder sich auf die implizite Höhe des Delegaten zu verlassen. Ein rowHeightProvider wird nur bei Bedarf aufgerufen und wird nicht von der Größe des Modells beeinflusst.

Siehe auch rowHeight(), explicitRowHeight(), setColumnWidth(), und Row heights and column widths.

© 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.