qquicktableview_p_p.h

// Copyright (C) 2018 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:significant reason:default

#ifndef QQUICKTABLEVIEW_P_P_H

#define QQUICKTABLEVIEW_P_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists purely as an

// implementation detail.  This header file may change from version to

// version without notice, or even be removed.

//

// We mean it.

//

#include "qquicktableview_p.h"

#include <QtCore/qtimer.h>

#include <QtCore/qitemselectionmodel.h>

#include <QtQmlModels/private/qqmltableinstancemodel_p.h>

#include <QtQml/private/qqmlincubator_p.h>

#include <QtQmlModels/private/qqmlchangeset_p.h>

#include <QtQml/qqmlinfo.h>

#include <QtQuick/private/qquickflickable_p_p.h>

#include <QtQuick/private/qquickitemviewfxitem_p_p.h>

#include <QtQuick/private/qquickanimation_p.h>

#include <QtQuick/private/qquickselectable_p.h>

#include <QtQuick/private/qquicksinglepointhandler_p.h>

#include <QtQuick/private/qquickhoverhandler_p.h>

#include <QtQuick/private/qquicktaphandler_p.h>

#include <QtCore/private/qminimalflatset_p.h>

#if QT_CONFIG(quick_draganddrop)

#include <QtGui/qdrag.h>

#include <QtQuick/private/qquickdroparea_p.h>

#endif

#include <vector>

QT_BEGIN_NAMESPACE

Q_DECLARE_LOGGING_CATEGORY(lcTableViewDelegateLifecycle)

static const qreal kDefaultRowHeight = 50;

static const qreal kDefaultColumnWidth = 50;

static const int kEdgeIndexNotSet = -2;

static const int kEdgeIndexAtEnd = -3;

class FxTableItem;

class QQuickTableSectionSizeProviderPrivate;

class QTypeRevision;

/*! \internal

 *  TableView uses QQuickTableViewHoverHandler to track where the pointer is

 *  on top of the table, and change the cursor at the places where a drag

 *  would start a resize of a row or a column.

*/

class QQuickTableViewHoverHandler : public QQuickHoverHandler

    Q_OBJECT

public:

    QQuickTableViewHoverHandler(QQuickTableView *view);

    inline bool isHoveringGrid() const { return m_row != -1 || m_column != -1; };

    int m_row = -1;

    int m_column = -1;

    friend class QQuickTableViewPrivate;

protected:

    void handleEventPoint(QPointerEvent *event, QEventPoint &point) override;

};

class QQuickTableViewPointerHandler : public QQuickSinglePointHandler

    Q_OBJECT

public:

    enum State {

        Listening, // the pointer is not being pressed between the cells

        Tracking, // the pointer is being pressed between the cells

        DraggingStarted, // dragging started

        Dragging, // a drag is ongoing

        DraggingFinished // dragging was finished

};

    QQuickTableViewPointerHandler(QQuickTableView *view);

    State m_state = Listening;

    State state() { return m_state; }

protected:

    bool wantsEventPoint(const QPointerEvent *event, const QEventPoint &point) override;

};

/*! \internal

 *  TableView uses QQuickTableViewResizeHandler to enable the user to resize

 *  rows and columns. By using a custom pointer handler, we can get away with

 *  using a single pointer handler for the whole content item, rather than

 *  e.g having to split it up into multiple items with drag handlers placed

 *  between the cells.

*/

class QQuickTableViewResizeHandler : public QQuickTableViewPointerHandler

    Q_OBJECT

public:

    QQuickTableViewResizeHandler(QQuickTableView *view);

    int m_row = -1;

    qreal m_rowStartY = -1;

    qreal m_rowStartHeight = -1;

    int m_column = -1;

    qreal m_columnStartX = -1;

    qreal m_columnStartWidth = -1;

    void updateState(QEventPoint &point);

    void updateDrag(QPointerEvent *event, QEventPoint &point);

    friend class QQuickTableViewPrivate;

protected:

    void handleEventPoint(QPointerEvent *event, QEventPoint &point) override;

    void onGrabChanged(QQuickPointerHandler *grabber, QPointingDevice::GrabTransition transition,

                       QPointerEvent *ev, QEventPoint &point) override;

};

#if QT_CONFIG(quick_draganddrop)

class QQuickTableViewSectionDragHandler : public QQuickTableViewPointerHandler

    Q_OBJECT

public:

    QQuickTableViewSectionDragHandler(QQuickTableView *view);

    ~QQuickTableViewSectionDragHandler();

    void grabSection();

    void handleDrag(QQuickDragEvent *event);

    void handleDrop(QQuickDragEvent *event);

    void handleDragDropAction(Qt::DropAction action);

    void setSectionOrientation(Qt::Orientation orientation) { m_sectionOrientation = orientation; }

    friend class QQuickTableViewPrivate;

protected:

    void handleEventPoint(QPointerEvent *event, QEventPoint &point) override;

private:

    void resetDragData();

    void resetSectionOverlay();

    QSharedPointer<QQuickItemGrabResult> m_grabResult;

    QPointer<QDrag> m_drag;

    int m_source = -1;

    int m_destination = -1;

    QPointer<QQuickDropArea> m_dropArea;

    Qt::Orientation m_sectionOrientation;

    QPointF m_dragPoint;

    QSizeF m_step = QSizeF(1, 1);

    QTimer m_scrollTimer;

};

#endif // quick_draganddrop

/*! \internal

 *  QQuickTableViewTapHandler used to handle tap events explicitly for table view

*/

class QQuickTableViewTapHandler : public QQuickTapHandler

    Q_OBJECT

public:

    explicit QQuickTableViewTapHandler(QQuickTableView *view);

    bool wantsEventPoint(const QPointerEvent *event, const QEventPoint &point) override;

    friend class QQuickTableViewPrivate;

};

class Q_QUICK_EXPORT QQuickTableViewPrivate : public QQuickFlickablePrivate, public QQuickSelectable

public:

    Q_DECLARE_PUBLIC(QQuickTableView)

    class TableEdgeLoadRequest

        // Whenever we need to load new rows or columns in the

        // table, we fill out a TableEdgeLoadRequest.

        // TableEdgeLoadRequest is just a struct that keeps track

        // of which cells that needs to be loaded, and which cell

        // the table is currently loading. The loading itself is

        // done by QQuickTableView.

    public:

        void begin(const QPoint &cell, const QPointF &pos, QQmlIncubator::IncubationMode incubationMode)

            Q_ASSERT(!m_active);

            m_active = true;

            m_edge = Qt::Edge(0);

            m_mode = incubationMode;

            m_edgeIndex = cell.x();

            m_visibleCellsInEdge.clear();

            m_visibleCellsInEdge.append(cell.y());

            m_currentIndex = 0;

            m_startPos = pos;

            qCDebug(lcTableViewDelegateLifecycle()) << "begin top-left:" << toString();

        void begin(Qt::Edge edgeToLoad, int edgeIndex, const QList<int> visibleCellsInEdge, QQmlIncubator::IncubationMode incubationMode)

            Q_ASSERT(!m_active);

            m_active = true;

            m_edge = edgeToLoad;

            m_edgeIndex = edgeIndex;

            m_visibleCellsInEdge = visibleCellsInEdge;

            m_mode = incubationMode;

            m_currentIndex = 0;

            qCDebug(lcTableViewDelegateLifecycle()) << "begin:" << toString();

        inline void markAsDone() { m_active = false; }

        inline bool isActive() const { return m_active; }

        inline QPoint currentCell() const { return cellAt(m_currentIndex); }

        inline bool hasCurrentCell() const { return m_currentIndex < m_visibleCellsInEdge.size(); }

        inline void moveToNextCell() { ++m_currentIndex; }

        inline Qt::Edge edge() const { return m_edge; }

        inline int row() const { return cellAt(0).y(); }

        inline int column() const { return cellAt(0).x(); }

        inline QQmlIncubator::IncubationMode incubationMode() const { return m_mode; }

        inline QPointF startPosition() const { return m_startPos; }

        QString toString() const

            QString str;

            QDebug dbg(&str);

            dbg.nospace() << "TableSectionLoadRequest(" << "edge:"

                << m_edge << ", edgeIndex:" << m_edgeIndex << ", incubation:";

            switch (m_mode) {

            case QQmlIncubator::Asynchronous:

                dbg << "Asynchronous";

                break;

            case QQmlIncubator::AsynchronousIfNested:

                dbg << "AsynchronousIfNested";

                break;

            case QQmlIncubator::Synchronous:

                dbg << "Synchronous";

                break;

            return str;

    private:

        Qt::Edge m_edge = Qt::Edge(0);

        QList<int> m_visibleCellsInEdge;

        int m_edgeIndex = 0;

        int m_currentIndex = 0;

        bool m_active = false;

        QQmlIncubator::IncubationMode m_mode = QQmlIncubator::AsynchronousIfNested;

        QPointF m_startPos;

        inline QPoint cellAt(int index) const {

            return !m_edge || (m_edge & (Qt::LeftEdge | Qt::RightEdge))

                    ? QPoint(m_edgeIndex, m_visibleCellsInEdge[index])

                    : QPoint(m_visibleCellsInEdge[index], m_edgeIndex);

};

    class EdgeRange {

    public:

        EdgeRange();

        bool containsIndex(Qt::Edge edge, int index);

        int startIndex;

        int endIndex;

        qreal size;

};

    enum class RebuildState {

        Begin = 0,

        LoadInitalTable,

        VerifyTable,

        LayoutTable,

        CancelOvershoot,

        UpdateContentSize,

        PreloadColumns,

        PreloadRows,

        MovePreloadedItemsToPool,

        Done

};

    enum class SectionState {

        Idle = 0,

        Moving

};

    enum class RebuildOption {

        None = 0,

        All = 0x1,

        LayoutOnly = 0x2,

        ViewportOnly = 0x4,

        CalculateNewTopLeftRow = 0x8,

        CalculateNewTopLeftColumn = 0x10,

        CalculateNewContentWidth = 0x20,

        CalculateNewContentHeight = 0x40,

        PositionViewAtRow = 0x80,

        PositionViewAtColumn = 0x100,

};

    Q_DECLARE_FLAGS(RebuildOptions, RebuildOption)

public:

    QQuickTableViewPrivate();

    ~QQuickTableViewPrivate() override;

    static inline QQuickTableViewPrivate *get(QQuickTableView *q) { return q->d_func(); }

    void updatePolish() override;

    void fixup(AxisData &data, qreal minExtent, qreal maxExtent) override;

public:

    QHash<int, FxTableItem *> loadedItems;

    // model, tableModel and modelVariant all point to the same model. modelVariant

    // is the model assigned by the user. And tableModel is the wrapper model we create

    // around it. But if the model is an instance model directly, we cannot wrap it, so

    // we need a pointer for that case as well.

    QQmlInstanceModel* model = nullptr;

    QPointer<QQmlTableInstanceModel> tableModel = nullptr;

    // When the applications assignes a new model or delegate to the view, we keep them

    // around until we're ready to take them into use (syncWithPendingChanges).

    QVariant assignedModel = QVariant(int(0));

    QQmlGuard<QQmlComponent> assignedDelegate;

    // loadedRows/Columns describes the rows and columns that are currently loaded (from top left

    // row/column to bottom right row/column). loadedTableOuterRect describes the actual

    // pixels that all the loaded delegate items cover, and is matched agains the viewport to determine when

    // we need to fill up with more rows/columns. loadedTableInnerRect describes the pixels

    // that the loaded table covers if you remove one row/column on each side of the table, and

    // is used to determine rows/columns that are no longer visible and can be unloaded.

    QMinimalFlatSet<int> loadedColumns;

    QMinimalFlatSet<int> loadedRows;

    QRectF loadedTableOuterRect;

    QRectF loadedTableInnerRect;

    QPointF origin = QPointF(0, 0);

    QSizeF endExtent = QSizeF(0, 0);

    QRectF viewportRect = QRectF(0, 0, -1, -1);

    QSize tableSize;

    RebuildState rebuildState = RebuildState::Done;

    RebuildOptions rebuildOptions = RebuildOption::All;

    RebuildOptions scheduledRebuildOptions = RebuildOption::All;

    TableEdgeLoadRequest loadRequest;

    QSizeF cellSpacing = QSizeF(0, 0);

    QQmlTableInstanceModel::ReusableFlag reusableFlag = QQmlTableInstanceModel::Reusable;

    bool blockItemCreatedCallback = false;

    mutable bool layoutWarningIssued = false;

    bool polishing = false;

    bool syncVertically = false;

    bool syncHorizontally = false;

    bool inSetLocalViewportPos = false;

    bool inSyncViewportPosRecursive = false;

    bool inUpdateContentSize = false;

    bool animate = true;

    bool keyNavigationEnabled = true;

    bool pointerNavigationEnabled = true;

    bool alternatingRows = true;

    bool resizableColumns = false;

    bool resizableRows = false;

#if QT_CONFIG(cursor)

    bool m_cursorSet = false;

#endif

    // isTransposed is currently only used by HeaderView.

    // Consider making it public.

    bool isTransposed = false;

    bool warnNoSelectionModel = true;

    QQmlDelegateModel::DelegateModelAccess assignedDelegateModelAccess

            = QQmlDelegateModel::Qt5ReadWrite;

    bool componentFinalized = false;

    // sorting

    void requestSort(int logicalColumn, bool clearable);

    void sortByColumn(int column, Qt::SortOrder order);

    void updateSortState(int column, Qt::SortOrder order);

    bool sortingEnabled = false;

    int sortColumn = -1;

    Qt::SortOrder sortOrder = Qt::AscendingOrder;

    QJSValue rowHeightProvider;

    QJSValue columnWidthProvider;

    mutable EdgeRange cachedNextVisibleEdgeIndex[4];

    mutable EdgeRange cachedColumnWidth;

    mutable EdgeRange cachedRowHeight;

    // TableView uses contentWidth/height to report the size of the table (this

    // will e.g make scrollbars written for Flickable work out of the box). This

    // value is continuously calculated, and will change/improve as more columns

    // are loaded into view. At the same time, we want to open up for the

    // possibility that the application can set the content width explicitly, in

    // case it knows what the exact width should be from the start. We therefore

    // override the contentWidth/height properties from QQuickFlickable, to be able

    // to implement this combined behavior. This also lets us lazy build the table

    // if the application needs to know the content size early on.

    QQmlNullableValue<qreal> explicitContentWidth;

    QQmlNullableValue<qreal> explicitContentHeight;

    QSizeF averageEdgeSize;

    QPointer<QQuickTableView> assignedSyncView;

    QPointer<QQuickTableView> syncView;

    QList<QPointer<QQuickTableView> > syncChildren;

    Qt::Orientations assignedSyncDirection = Qt::Horizontal | Qt::Vertical;

    QPointer<QItemSelectionModel> selectionModel;

    QQuickTableView::SelectionBehavior selectionBehavior = QQuickTableView::SelectCells;

    QQuickTableView::SelectionMode selectionMode = QQuickTableView::ExtendedSelection;

    QItemSelectionModel::SelectionFlag selectionFlag = QItemSelectionModel::NoUpdate;

    std::function<void(CallBackFlag)> selectableCallbackFunction;

    bool inSelectionModelUpdate = false;

    bool needsModelSynchronization = false;

    int assignedPositionViewAtRowAfterRebuild = 0;

    int assignedPositionViewAtColumnAfterRebuild = 0;

    int positionViewAtRowAfterRebuild = 0;

    int positionViewAtColumnAfterRebuild = 0;

    qreal positionViewAtRowOffset = 0;

    qreal positionViewAtColumnOffset = 0;

    QRectF positionViewAtRowSubRect;

    QRectF positionViewAtColumnSubRect;

    Qt::Alignment positionViewAtRowAlignment = Qt::AlignTop;

    Qt::Alignment positionViewAtColumnAlignment = Qt::AlignLeft;

    QQuickPropertyAnimation positionXAnimation;

    QQuickPropertyAnimation positionYAnimation;

    QPoint selectionStartCell = {-1, -1};

    QPoint selectionEndCell = {-1, -1};

    QItemSelection existingSelection;

    QMargins edgesBeforeRebuild;

    QSize tableSizeBeforeRebuild;

    int currentRow = -1;

    int currentColumn = -1;

#if QT_CONFIG(accessibility)

    QPointer<QQuickItem> accessibleFocusItem;

#endif

    QHash<int, qreal> explicitColumnWidths;

    QHash<int, qreal> explicitRowHeights;

    QQuickTableViewHoverHandler *hoverHandler = nullptr;

    QQuickTableViewResizeHandler *resizeHandler = nullptr;

#if QT_CONFIG(quick_draganddrop)

    QQuickTableViewSectionDragHandler *sectionDragHandler = nullptr;

#endif

    QQuickTableViewPointerHandler *activePtrHandler = nullptr;

    QQmlTableInstanceModel *editModel = nullptr;

    QQuickItem *editItem = nullptr;

    QPersistentModelIndex editIndex;

    QQuickTableView::EditTriggers editTriggers = QQuickTableView::DoubleTapped | QQuickTableView::EditKeyPressed;

#ifdef QT_DEBUG

    QString forcedIncubationMode = qEnvironmentVariable("QT_TABLEVIEW_INCUBATION_MODE");

#endif

    struct SectionData {

        int index = -1;

        int prevIndex = -1;

};

    std::vector<SectionData> horizontalVisualIndices;

    std::vector<SectionData> verticalVisualIndices;

    std::vector<SectionData> horizontalLogicalIndices;

    std::vector<SectionData> verticalLogicalIndices;

    std::vector<SectionData> &visualIndicesForOrientation(Qt::Orientation orientation)

        return orientation == Qt::Horizontal ? horizontalVisualIndices : verticalVisualIndices;

    std::vector<SectionData> &logicalIndicesForOrientation(Qt::Orientation orientation)

        return orientation == Qt::Horizontal ? horizontalLogicalIndices : verticalLogicalIndices;

    SectionState m_sectionState = SectionState::Idle;

public:

    void init();

    QQuickTableViewAttached *getAttachedObject(const QObject *object) const;

    int modelIndexAtCell(const QPoint &cell) const;

    QPoint cellAtModelIndex(int modelIndex) const;

    int modelIndexToCellIndex(const QModelIndex &modelIndex, bool visualIndex = true) const;

    inline bool cellIsValid(const QPoint &cell) const { return cell.x() != -1 && cell.y() != -1; }

    qreal sizeHintForColumn(int column) const;

    qreal sizeHintForRow(int row) const;

    QSize calculateTableSize();

    void updateTableSize();

    inline bool isColumnHidden(int column) const;

    inline bool isRowHidden(int row) const;

    qreal getColumnLayoutWidth(int column);

    qreal getRowLayoutHeight(int row);

    qreal getColumnWidth(int column) const;

    qreal getRowHeight(int row) const;

    qreal getEffectiveRowY(int row) const;

    qreal getEffectiveRowHeight(int row) const;

    qreal getEffectiveColumnX(int column) const;

    qreal getEffectiveColumnWidth(int column) const;

    qreal getAlignmentContentX(int column, Qt::Alignment alignment, const qreal offset, const QRectF &subRect);

    qreal getAlignmentContentY(int row, Qt::Alignment alignment, const qreal offset, const QRectF &subRect);

    int topRow() const { return *loadedRows.cbegin(); }

    int bottomRow() const { return *loadedRows.crbegin(); }

    int leftColumn() const { return *loadedColumns.cbegin(); }

    int rightColumn() const { return *loadedColumns.crbegin(); }

    QQuickTableView *rootSyncView() const;

    bool updateTableRecursive();

    bool updateTable();

    void relayoutTableItems();

    void layoutVerticalEdge(Qt::Edge tableEdge);

    void layoutHorizontalEdge(Qt::Edge tableEdge);

    void layoutTopLeftItem();

    void layoutTableEdgeFromLoadRequest();

    void updateContentWidth();

    void updateContentHeight();

    void updateAverageColumnWidth();

    void updateAverageRowHeight();

    RebuildOptions checkForVisibilityChanges();

    void forceLayout(bool immediate);

    void updateExtents();

    void syncLoadedTableRectFromLoadedTable();

    void syncLoadedTableFromLoadRequest();

    int nextVisibleEdgeIndex(Qt::Edge edge, int startIndex) const;

    int nextVisibleEdgeIndexAroundLoadedTable(Qt::Edge edge) const;

    inline bool atTableEnd(Qt::Edge edge) const { return nextVisibleEdgeIndexAroundLoadedTable(edge) == kEdgeIndexAtEnd; }

    inline bool atTableEnd(Qt::Edge edge, int startIndex) const { return nextVisibleEdgeIndex(edge, startIndex) == kEdgeIndexAtEnd; }

    inline int edgeToArrayIndex(Qt::Edge edge) const;

    void clearEdgeSizeCache();

    bool canLoadTableEdge(Qt::Edge tableEdge, const QRectF fillRect) const;

    bool canUnloadTableEdge(Qt::Edge tableEdge, const QRectF fillRect) const;

    Qt::Edge nextEdgeToLoad(const QRectF rect);

    Qt::Edge nextEdgeToUnload(const QRectF rect);

    qreal cellWidth(const QPoint &cell) const;

    qreal cellHeight(const QPoint &cell) const;

    FxTableItem *loadedTableItem(const QPoint &cell) const;

    FxTableItem *createFxTableItem(const QPoint &cell, QQmlIncubator::IncubationMode incubationMode);

    FxTableItem *loadFxTableItem(const QPoint &cell, QQmlIncubator::IncubationMode incubationMode);

    void releaseItem(FxTableItem *fxTableItem, QQmlTableInstanceModel::ReusableFlag reusableFlag);

    void releaseLoadedItems(QQmlTableInstanceModel::ReusableFlag reusableFlag);

    void unloadItem(const QPoint &cell);

    void loadEdge(Qt::Edge edge, QQmlIncubator::IncubationMode incubationMode);

    void unloadEdge(Qt::Edge edge);

    void loadAndUnloadVisibleEdges(QQmlIncubator::IncubationMode incubationMode = QQmlIncubator::AsynchronousIfNested);

    void drainReusePoolAfterLoadRequest();

    void processLoadRequest();

    void processRebuildTable();

    bool moveToNextRebuildState();

    void calculateTopLeft(QPoint &topLeft, QPointF &topLeftPos);

    void loadInitialTable();

    void layoutAfterLoadingInitialTable();

    void adjustViewportXAccordingToAlignment();

    void adjustViewportYAccordingToAlignment();

    void cancelOvershootAfterLayout();

    void scheduleRebuildTable(QQuickTableViewPrivate::RebuildOptions options);

#if QT_CONFIG(cursor)

    void updateCursor();

#endif

    void updateEditItem();

    void updateContentSize();

    QTypeRevision resolveImportVersion();

    void createWrapperModel();

    QAbstractItemModel *qaim(QVariant modelAsVariant) const;

    virtual void initItemCallback(int modelIndex, QObject *item);

    virtual void itemCreatedCallback(int modelIndex, QObject *object);

    virtual void itemPooledCallback(int modelIndex, QObject *object);

    virtual void itemReusedCallback(int modelIndex, QObject *object);

    virtual void modelUpdated(const QQmlChangeSet &changeSet, bool reset);

    virtual void updateItemProperties(int flatIndex, QObject *object, bool init);

    virtual void syncWithPendingChanges();

    virtual void syncDelegate();

    virtual void syncDelegateModelAccess();

    virtual QVariant modelImpl() const;

    virtual void setModelImpl(const QVariant &newModel);

    virtual void syncModel();

    virtual void syncSyncView();

    virtual void syncPositionView();

    virtual QAbstractItemModel *selectionSourceModel();

    inline void syncRebuildOptions();

    void connectToModel();

    void disconnectFromModel();

    void rowsMovedCallback(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int row);

    void columnsMovedCallback(const QModelIndex &parent, int start, int end, const QModelIndex &destination, int column);

    void rowsInsertedCallback(const QModelIndex &parent, int begin, int end);

    void rowsRemovedCallback(const QModelIndex &parent, int begin, int end);

    void columnsInsertedCallback(const QModelIndex &parent, int begin, int end);

    void columnsRemovedCallback(const QModelIndex &parent, int begin, int end);

    void layoutChangedCallback(const QList<QPersistentModelIndex> &parents, QAbstractItemModel::LayoutChangeHint hint);

    void modelResetCallback();

    void dataChangedCallback(const QModelIndex &topLeft, const QModelIndex &bottomRight, const QList<int> &roles);

    bool compareModel(const QVariant& model1, const QVariant& model2) const;

    void positionViewAtRow(int row, Qt::Alignment alignment, qreal offset, const QRectF subRect = QRectF());

    void positionViewAtColumn(int column, Qt::Alignment alignment, qreal offset, const QRectF subRect = QRectF());

    bool scrollToRow(int row, Qt::Alignment alignment, qreal offset, const QRectF subRect = QRectF());

    bool scrollToColumn(int column, Qt::Alignment alignment, qreal offset, const QRectF subRect = QRectF());

    void scheduleRebuildIfFastFlick();

    void setLocalViewportX(qreal contentX);

    void setLocalViewportY(qreal contentY);

    void syncViewportRect();

    void syncViewportPosRecursive();

    bool selectedInSelectionModel(const QPoint &cell) const;

    void selectionChangedInSelectionModel(const QItemSelection &selected, const QItemSelection &deselected);

    void updateSelectedOnAllDelegateItems();

    void setSelectedOnDelegateItem(const QModelIndex &modelIndex, bool select);

    bool currentInSelectionModel(const QPoint &cell) const;

    void currentChangedInSelectionModel(const QModelIndex &current, const QModelIndex &previous);

    void setCurrentOnDelegateItem(const QModelIndex &index, bool isCurrent);

    void updateCurrentRowAndColumn();

#if QT_CONFIG(accessibility)

    void updateAccessibleFocus();

#endif

    void fetchMoreData();

    void _q_componentFinalized();

    void registerCallbackWhenBindingsAreEvaluated();

    inline QString tableLayoutToString() const;

    void dumpTable() const;

    void setRequiredProperty(const char *property,

                             const QVariant &value,

                             int serializedModelIndex,

                             QObject *object, bool init);

    void handleTap(const QQuickHandlerPoint &point);

    virtual void executeTap(const QQuickHandlerPoint &point);

    void setCurrentIndexFromTap(const QPointF &pos);

    void setCurrentIndex(const QPoint &cell);

    bool setCurrentIndexFromKeyEvent(QKeyEvent *e);

    bool canEdit(const QModelIndex tappedIndex, bool warn);

    bool editFromKeyEvent(QKeyEvent *e);

    void closeEditorAndCommit();

    QObject *installEventFilterOnFocusObjectInsideEditItem();

    // QQuickSelectable

    QQuickItem *selectionPointerHandlerTarget() const override;

    bool hasSelection() const override;

    bool startSelection(const QPointF &pos, Qt::KeyboardModifiers modifiers) override;

    void setSelectionStartPos(const QPointF &pos) override;

    void setSelectionEndPos(const QPointF &pos) override;

    void clearSelection() override;

    void normalizeSelection() override;

    QRectF selectionRectangle() const override;

    QSizeF scrollTowardsPoint(const QPointF &pos, const QSizeF &step) override;

    void setCallback(std::function<void(CallBackFlag)> func) override;

    void cancelSelectionTracking();

    QPoint clampedCellAtPos(const QPointF &pos) const;

    virtual void updateSelection(const QRect &oldSelection, const QRect &newSelection);

    QRect selection() const;

    // ----------------

    // Section drag handler

#if QT_CONFIG(quick_draganddrop)

    void initSectionDragHandler(Qt::Orientation orientation);

    void destroySectionDragHandler();

#endif

    inline void setActivePointerHandler(QQuickTableViewPointerHandler *handler) { activePtrHandler = handler; }

    inline QQuickTableViewPointerHandler* activePointerHandler() const { return activePtrHandler; }

    // Row/Column reordering

    void moveSection(int source , int destination, Qt::Orientation orientation);

    void initializeIndexMapping();

    void clearIndexMapping();

    void clearSection(Qt::Orientation orientation);

    virtual int logicalRowIndex(const int visualIndex) const;

    virtual int logicalColumnIndex(const int visualIndex) const;

    virtual int visualRowIndex(const int logicalIndex) const;

    virtual int visualColumnIndex(const int logicalIndex) const;

    void setContainsDragOnDelegateItem(const QModelIndex &modelIndex, bool overlay);

    int getEditCellIndex(const QModelIndex &index) const;

};

class FxTableItem : public QQuickItemViewFxItem

public:

    FxTableItem(QQuickItem *item, QQuickTableView *table, bool own)

        : QQuickItemViewFxItem(item, own, QQuickTableViewPrivate::get(table))

    qreal position() const override { return 0; }

    qreal endPosition() const override { return 0; }

    qreal size() const override { return 0; }

    qreal sectionSize() const override { return 0; }

    bool contains(qreal, qreal) const override { return false; }

    QPoint cell;

};

Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickTableViewPrivate::RebuildOptions)

QT_END_NAMESPACE

#endif

Revision control

Copy as Markdown