diff options
Diffstat (limited to 'src/quick/items/qquicktableview_p_p.h')
| -rw-r--r-- | src/quick/items/qquicktableview_p_p.h | 591 |
1 files changed, 455 insertions, 136 deletions
diff --git a/src/quick/items/qquicktableview_p_p.h b/src/quick/items/qquicktableview_p_p.h index 8a02d23694..ea49a3309b 100644 --- a/src/quick/items/qquicktableview_p_p.h +++ b/src/quick/items/qquicktableview_p_p.h @@ -1,41 +1,5 @@ -/**************************************************************************** -** -** Copyright (C) 2018 The Qt Company Ltd. -** Contact: https://www.qt.io/licensing/ -** -** This file is part of the QtQuick module of the Qt Toolkit. -** -** $QT_BEGIN_LICENSE:LGPL$ -** Commercial License Usage -** Licensees holding valid commercial Qt licenses may use this file in -** accordance with the commercial license agreement provided with the -** Software or, alternatively, in accordance with the terms contained in -** a written agreement between you and The Qt Company. For licensing terms -** and conditions see https://www.qt.io/terms-conditions. For further -** information use the contact form at https://www.qt.io/contact-us. -** -** GNU Lesser General Public License Usage -** Alternatively, this file may be used under the terms of the GNU Lesser -** General Public License version 3 as published by the Free Software -** Foundation and appearing in the file LICENSE.LGPL3 included in the -** packaging of this file. Please review the following information to -** ensure the GNU Lesser General Public License version 3 requirements -** will be met: https://www.gnu.org/licenses/lgpl-3.0.html. -** -** GNU General Public License Usage -** Alternatively, this file may be used under the terms of the GNU -** General Public License version 2.0 or (at your option) the GNU General -** Public license version 3 or any later version approved by the KDE Free -** Qt Foundation. The licenses are as published by the Free Software -** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3 -** included in the packaging of this file. Please review the following -** information to ensure the GNU General Public License requirements will -** be met: https://www.gnu.org/licenses/gpl-2.0.html and -** https://www.gnu.org/licenses/gpl-3.0.html. -** -** $QT_END_LICENSE$ -** -****************************************************************************/ +// 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 #ifndef QQUICKTABLEVIEW_P_P_H #define QQUICKTABLEVIEW_P_P_H @@ -54,13 +18,23 @@ #include "qquicktableview_p.h" #include <QtCore/qtimer.h> -#include <QtQml/private/qqmltableinstancemodel_p.h> +#include <QtCore/qitemselectionmodel.h> +#include <QtQmlModels/private/qqmltableinstancemodel_p.h> #include <QtQml/private/qqmlincubator_p.h> -#include <QtQml/private/qqmlchangeset_p.h> +#include <QtQmlModels/private/qqmlchangeset_p.h> #include <QtQml/qqmlinfo.h> +#include <QtGui/qdrag.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 <QtQuick/private/qquickdroparea_p.h> + +#include <QtCore/private/qminimalflatset_p.h> QT_BEGIN_NAMESPACE @@ -68,14 +42,145 @@ 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; + +/*! \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; -class Q_QML_AUTOTEST_EXPORT QQuickTableViewPrivate : public QQuickFlickablePrivate +protected: + void handleEventPoint(QPointerEvent *event, QEventPoint &point) override; +}; + +class QQuickTableViewPointerHandler : public QQuickSinglePointHandler { - Q_DECLARE_PUBLIC(QQuickTableView) + 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; +}; + +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; +}; + +/*! \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 @@ -88,54 +193,52 @@ public: public: void begin(const QPoint &cell, const QPointF &pos, QQmlIncubator::IncubationMode incubationMode) { - Q_ASSERT(!active); - active = true; - tableEdge = Qt::Edge(0); - tableCells = QLine(cell, cell); - mode = incubationMode; - cellCount = 1; - currentIndex = 0; - startPos = pos; + 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(const QLine cellsToLoad, Qt::Edge edgeToLoad, QQmlIncubator::IncubationMode incubationMode) + void begin(Qt::Edge edgeToLoad, int edgeIndex, const QVector<int> visibleCellsInEdge, QQmlIncubator::IncubationMode incubationMode) { - Q_ASSERT(!active); - active = true; - tableEdge = edgeToLoad; - tableCells = cellsToLoad; - mode = incubationMode; - cellCount = tableCells.x2() - tableCells.x1() + tableCells.y2() - tableCells.y1() + 1; - currentIndex = 0; + 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() { active = false; } - inline bool isActive() { return active; } + inline void markAsDone() { m_active = false; } + inline bool isActive() const { return m_active; } - inline QPoint firstCell() { return tableCells.p1(); } - inline QPoint lastCell() { return tableCells.p2(); } - inline QPoint currentCell() { return cellAt(currentIndex); } - inline QPoint previousCell() { return cellAt(currentIndex - 1); } + inline QPoint currentCell() const { return cellAt(m_currentIndex); } + inline bool hasCurrentCell() const { return m_currentIndex < m_visibleCellsInEdge.size(); } + inline void moveToNextCell() { ++m_currentIndex; } - inline bool atBeginning() { return currentIndex == 0; } - inline bool hasCurrentCell() { return currentIndex < cellCount; } - inline void moveToNextCell() { ++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 Qt::Edge edge() { return tableEdge; } - inline QQmlIncubator::IncubationMode incubationMode() { return mode; } + inline QPointF startPosition() const { return m_startPos; } - inline QPointF startPosition() { return startPos; } - - QString toString() + QString toString() const { QString str; QDebug dbg(&str); dbg.nospace() << "TableSectionLoadRequest(" << "edge:" - << tableEdge << " cells:" << tableCells << " incubation:"; + << m_edge << ", edgeIndex:" << m_edgeIndex << ", incubation:"; - switch (mode) { + switch (m_mode) { case QQmlIncubator::Asynchronous: dbg << "Asynchronous"; break; @@ -151,40 +254,60 @@ public: } private: - Qt::Edge tableEdge = Qt::Edge(0); - QLine tableCells; - int currentIndex = 0; - int cellCount = 0; - bool active = false; - QQmlIncubator::IncubationMode mode = QQmlIncubator::AsynchronousIfNested; - QPointF startPos; - - QPoint cellAt(int index) - { - int x = tableCells.p1().x() + (tableCells.dx() ? index : 0); - int y = tableCells.p1().y() + (tableCells.dy() ? index : 0); - return QPoint(x, y); + Qt::Edge m_edge = Qt::Edge(0); + QVector<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, - LoadAndUnloadAfterLayout, + CancelOvershoot, + UpdateContentSize, PreloadColumns, PreloadRows, MovePreloadedItemsToPool, Done }; + enum class SectionState { + Idle = 0, + Moving + }; + enum class RebuildOption { None = 0, - ViewportOnly = 0x1, - CalculateNewTopLeftRow = 0x2, - CalculateNewTopLeftColumn = 0x4, - All = 0x8, + All = 0x1, + LayoutOnly = 0x2, + ViewportOnly = 0x4, + CalculateNewTopLeftRow = 0x8, + CalculateNewTopLeftColumn = 0x10, + CalculateNewContentWidth = 0x20, + CalculateNewContentHeight = 0x40, + PositionViewAtRow = 0x80, + PositionViewAtColumn = 0x100, }; Q_DECLARE_FLAGS(RebuildOptions, RebuildOption) @@ -211,18 +334,22 @@ public: // 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)); - QQmlComponent *assignedDelegate = nullptr; + QQmlGuard<QQmlComponent> assignedDelegate; - // loadedTable describes the table cells that are currently loaded (from top left + // 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 those cells cover, and is matched agains the viewport to determine when + // 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. - QRect loadedTable; + 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; @@ -233,20 +360,41 @@ public: TableEdgeLoadRequest loadRequest; - QPoint contentSizeBenchMarkPoint = QPoint(-1, -1); QSizeF cellSpacing = QSizeF(0, 0); QQmlTableInstanceModel::ReusableFlag reusableFlag = QQmlTableInstanceModel::Reusable; bool blockItemCreatedCallback = false; - bool columnRowPositionsInvalid = false; - bool layoutWarningIssued = false; + mutable bool layoutWarningIssued = false; bool polishing = false; - bool rebuildScheduled = true; + 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; 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 @@ -261,29 +409,107 @@ public: QSizeF averageEdgeSize; - const static QPoint kLeft; - const static QPoint kRight; - const static QPoint kUp; - const static QPoint kDown; + 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; + + 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; + + QHash<int, qreal> explicitColumnWidths; + QHash<int, qreal> explicitRowHeights; + + QQuickTableViewHoverHandler *hoverHandler = nullptr; + QQuickTableViewResizeHandler *resizeHandler = nullptr; + QQuickTableViewSectionDragHandler *sectionDragHandler = nullptr; + 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; + }; + + QList<SectionData> visualIndices[Qt::Vertical]; + QList<SectionData> logicalIndices[Qt::Vertical]; + + 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; - - qreal sizeHintForColumn(int column); - qreal sizeHintForRow(int row); - void calculateTableSize(); - - qreal resolveColumnWidth(int column); - qreal resolveRowHeight(int row); - - void relayoutTable(); + 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); @@ -293,22 +519,32 @@ public: void updateContentWidth(); void updateContentHeight(); - void updateAverageEdgeSize(); + void updateAverageColumnWidth(); + void updateAverageRowHeight(); + RebuildOptions checkForVisibilityChanges(); + void forceLayout(bool immediate); - void enforceTableAtOrigin(); + void updateExtents(); void syncLoadedTableRectFromLoadedTable(); void syncLoadedTableFromLoadRequest(); + void shiftLoadedTableRect(const QPointF newPosition); + + 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); - qreal cellHeight(const QPoint &cell); + qreal cellWidth(const QPoint &cell) const; + qreal cellHeight(const QPoint &cell) const; FxTableItem *loadedTableItem(const QPoint &cell) const; - FxTableItem *itemNextTo(const FxTableItem *fxTableItem, const QPoint &direction) const; FxTableItem *createFxTableItem(const QPoint &cell, QQmlIncubator::IncubationMode incubationMode); FxTableItem *loadFxTableItem(const QPoint &cell, QQmlIncubator::IncubationMode incubationMode); @@ -316,36 +552,48 @@ public: void releaseLoadedItems(QQmlTableInstanceModel::ReusableFlag reusableFlag); void unloadItem(const QPoint &cell); - void unloadItems(const QLine &items); - - void loadInitialTopLeftItem(const QPoint &cell, const QPointF &pos); void loadEdge(Qt::Edge edge, QQmlIncubator::IncubationMode incubationMode); void unloadEdge(Qt::Edge edge); - void loadAndUnloadVisibleEdges(); + void loadAndUnloadVisibleEdges(QQmlIncubator::IncubationMode incubationMode = QQmlIncubator::AsynchronousIfNested); void drainReusePoolAfterLoadRequest(); - void cancelLoadRequest(); void processLoadRequest(); void processRebuildTable(); bool moveToNextRebuildState(); - void beginRebuildTable(); + void calculateTopLeft(QPoint &topLeft, QPointF &topLeftPos); + void loadInitialTable(); + void layoutAfterLoadingInitialTable(); + void adjustViewportXAccordingToAlignment(); + void adjustViewportYAccordingToAlignment(); + void cancelOvershootAfterLayout(); void scheduleRebuildTable(QQuickTableViewPrivate::RebuildOptions options); - void invalidateColumnRowPositions(); - - int resolveImportVersion(); - void createWrapperModel(); - void initItemCallback(int modelIndex, QObject *item); - void itemCreatedCallback(int modelIndex, QObject *object); - void itemPooledCallback(int modelIndex, QObject *object); - void itemReusedCallback(int modelIndex, QObject *object); - void modelUpdated(const QQmlChangeSet &changeSet, bool reset); +#if QT_CONFIG(cursor) + void updateCursor(); +#endif + void updateEditItem(); + void updateContentSize(); - inline void syncWithPendingChanges(); - inline void syncDelegate(); - inline void syncModel(); + 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 syncWithPendingChanges(); + virtual void syncDelegate(); + 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(); @@ -359,12 +607,81 @@ public: void columnsRemovedCallback(const QModelIndex &parent, int begin, int end); void layoutChangedCallback(const QList<QPersistentModelIndex> &parents, QAbstractItemModel::LayoutChangeHint hint); void modelResetCallback(); + 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 ¤t, const QModelIndex &previous); + void setCurrentOnDelegateItem(const QModelIndex &index, bool isCurrent); + void updateCurrentRowAndColumn(); + + 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); + 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); + + // QQuickSelectable + QQuickItem *selectionPointerHandlerTarget() 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 + void initSectionDragHandler(Qt::Orientation orientation); + void destroySectionDragHandler(); + inline void setActivePointerHandler(QQuickTableViewPointerHandler *handler) { activePtrHandler = handler; } + inline QQuickTableViewPointerHandler* activePointerHandler() const { return activePtrHandler; } + // Row/Column reordering + void moveSection(int source , int destination, Qt::Orientations orientation); + void initializeIndexMapping(); + void clearIndexMapping(); + void clearSection(Qt::Orientations 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); }; class FxTableItem : public QQuickItemViewFxItem @@ -384,6 +701,8 @@ public: QPoint cell; }; +Q_DECLARE_OPERATORS_FOR_FLAGS(QQuickTableViewPrivate::RebuildOptions) + QT_END_NAMESPACE #endif |