qquicktableview_p_p.h

Go to the documentation of this file.

// 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