Revision control
Copy as Markdown
// Copyright (C) 2020 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
#include <QtQuickTemplates2/private/qquickheaderview_p_p.h>
#include <algorithm>
/*!
\qmltype HorizontalHeaderView
\inqmlmodule QtQuick.Controls
\ingroup qtquickcontrols-containers
\inherits TableView
\brief Provides a horizontal header view to accompany a \l TableView.
\include qquickheaderview.qdocinc {detailed-description} {HorizontalHeaderView}
\sa VerticalHeaderView
*/
/*!
\qmltype VerticalHeaderView
\inqmlmodule QtQuick.Controls
\ingroup qtquickcontrols-containers
\inherits TableView
\brief Offers a vertical header view to accompany a \l TableView.
\include qquickheaderview.qdocinc {detailed-description} {VerticalHeaderView}
\sa HorizontalHeaderView
*/
/*!
\qmlproperty TableView QtQuick.Controls::HorizontalHeaderView::syncView
\include qquickheaderview.qdocinc {syncView} {horizontally}
*/
/*!
\qmlproperty TableView QtQuick.Controls::VerticalHeaderView::syncView
\include qquickheaderview.qdocinc {syncView} {vertically}
*/
/*!
\qmlproperty QVariant QtQuick.Controls::HorizontalHeaderView::model
\include qquickheaderview.qdocinc {model} {horizontal}
*/
/*!
\qmlproperty QVariant QtQuick.Controls::VerticalHeaderView::model
\include qquickheaderview.qdocinc {model} {vertical}
*/
/*!
\qmlproperty string QtQuick.Controls::HorizontalHeaderView::textRole
\include qquickheaderview.qdocinc {textRole}
*/
/*!
\qmlproperty string QtQuick.Controls::VerticalHeaderView::textRole
\include qquickheaderview.qdocinc {textRole}
*/
/*!
\qmlproperty bool QtQuick.Controls::HorizontalHeaderView::movableColumns
\since 6.8
\include qquickheaderview.qdocinc {movableColumns}
*/
/*!
\qmlproperty bool QtQuick.Controls::VerticalHeaderView::movableRows
\since 6.8
\include qquickheaderview.qdocinc {movableRows}
*/
/*!
\qmlproperty bool QtQuick.Controls::HorizontalHeaderView::showSortIndicator
\since 6.13
\include qquickheaderview.qdocinc {showSortIndicator}
*/
/*!
\qmlproperty bool QtQuick.Controls::HorizontalHeaderView::sortIndicatorClearable
\since 6.13
\include qquickheaderview.qdocinc {sortIndicatorClearable}
*/
/*!
\qmlsignal void QtQuick.Controls::HorizontalHeaderView::headerClicked(int logicalColumn)
\since 6.13
\include qquickheaderview.qdocinc {headerClicked}
*/
QT_BEGIN_NAMESPACE
static const char *kRequiredProperty_headerView = "headerView";
static const char *kRequiredProperty_model = "model";
QQuickHeaderViewBasePrivate::QQuickHeaderViewBasePrivate()
: QQuickTableViewPrivate()
{
}
QQuickHeaderViewBasePrivate::~QQuickHeaderViewBasePrivate()
{
}
void QQuickHeaderViewBasePrivate::init()
{
Q_Q(QQuickHeaderViewBase);
m_headerDataProxyModel.m_headerView = q;
setSizePolicy(orientation() == Qt::Horizontal ? QLayoutPolicy::Preferred : QLayoutPolicy::Fixed,
orientation() == Qt::Horizontal ? QLayoutPolicy::Fixed : QLayoutPolicy::Preferred);
q->setSyncDirection(orientation());
}
const QPointer<QQuickItem> QQuickHeaderViewBasePrivate::delegateItemAt(int row, int col) const
{
return loadedTableItem(QPoint(col, row))->item;
}
QVariant QQuickHeaderViewBasePrivate::modelImpl() const
{
// modelImpl is supposed to return the actual model that is
// is used (that is, the proxy model), and not the source model.
if (m_headerDataProxyModel.sourceModel())
return QVariant::fromValue(&m_headerDataProxyModel);
// If we're not using the proxy model, use the assigned model
return QQuickTableViewPrivate::modelImpl();
}
void QQuickHeaderViewBasePrivate::setModelImpl(const QVariant &newModel)
{
m_modelExplicitlySet = newModel.isValid();
auto asTableModel = [](QAbstractItemModel *model) -> QAbstractItemModel* {
if (qobject_cast<QAbstractTableModel *>(model))
return model;
// Since QQmlTableModel is not derived from QAbstractTableModel (QATM),
// we have to check for this model separately. We want it to behave like
// QATM to keep existing code working. This model is in the Labs module,
// and we cannot link to it to make a qobject_cast. Therefore, we are checking
// the class name.
// TODO: When QQmlTableModel leaves Labs, change to qobject_cast?
if (model && QByteArrayView(model->metaObject()->className()) == "QQmlTableModel")
return model;
return nullptr;
};
if (auto qabstracttablemodel = asTableModel(qaim(newModel))) {
if (qabstracttablemodel != m_headerDataProxyModel.sourceModel()) {
m_headerDataProxyModel.setSourceModel(qabstracttablemodel);
assignedModel = QVariant::fromValue(std::addressof(m_headerDataProxyModel));
scheduleRebuildTable(QQuickTableViewPrivate::RebuildOption::All);
emit q_func()->modelChanged();
}
return;
}
m_headerDataProxyModel.setSourceModel(nullptr);
QQuickTableViewPrivate::setModelImpl(newModel);
}
void QQuickHeaderViewBasePrivate::syncModel()
{
if (!m_modelExplicitlySet && assignedSyncView) {
// When no model has been explicitly set, but we have a syncView, we
// should use the headerData() from the syncView's model as model.
// If the model is not a QAbstractItemModel, or if it doesn't contain
// any header data, header view will be empty.
auto syncView_d = QQuickTableViewPrivate::get(assignedSyncView);
auto syncViewModelAsQaim = qaim(syncView_d->assignedModel);
if (syncViewModelAsQaim != m_headerDataProxyModel.sourceModel()) {
m_headerDataProxyModel.setSourceModel(syncViewModelAsQaim); // can be nullptr
assignedModel = QVariant::fromValue(std::addressof(m_headerDataProxyModel));
emit q_func()->modelChanged();
}
}
QQuickTableViewPrivate::syncModel();
// For models that are just a list or a number, and especially not a
// table, we transpose the view when the orientation is horizontal.
// The model (list) will then be laid out horizontally rather than
// vertically, which is otherwise the default.
isTransposed = false;
const auto aim = model->abstractItemModel();
if (orientation() == Qt::Horizontal)
isTransposed = !aim || aim->columnCount() == 1;
if (m_textRole.isEmpty() && aim)
m_textRole = QLatin1String("display");
}
void QQuickHeaderViewBasePrivate::syncSyncView()
{
if (assignedSyncDirection != orientation()) {
qmlWarning(q_func()) << "Setting syncDirection other than Qt::"
<< QVariant::fromValue(orientation()).toString()
<< " is invalid.";
assignedSyncDirection = orientation();
}
QQuickTableViewPrivate::syncSyncView();
}
QAbstractItemModel *QQuickHeaderViewBasePrivate::selectionSourceModel()
{
// Our proxy model shares no common model items with HeaderView.model. So
// selections done in HeaderView cannot be represented in an ItemSelectionModel
// that is shared with the syncView (and for the same reason, the mapping functions
// modelIndex(cell) and cellAtIndex(index) have not been overridden either).
// Instead, we set the internal proxy model as selection source model.
return &m_headerDataProxyModel;
}
void QQuickHeaderViewBasePrivate::initItemCallback(int modelIndex, QObject *object)
{
Q_Q(QQuickHeaderViewBase);
QQuickTableViewPrivate::initItemCallback(modelIndex, object);
auto item = qobject_cast<QQuickItem *>(object);
if (!item)
return;
QQmlDelegateModelItem *modelItem = tableModel->getModelItem(modelIndex);
setRequiredProperty(kRequiredProperty_headerView, QVariant::fromValue(q),
modelIndex, item, true);
setRequiredProperty(kRequiredProperty_model, QVariant::fromValue(modelItem->modelObject()),
modelIndex, item, true);
}
int QQuickHeaderViewBasePrivate::logicalRowIndex(const int visualIndex) const
{
return (m_headerDataProxyModel.orientation() == Qt::Horizontal) ? visualIndex : QQuickTableViewPrivate::logicalRowIndex(visualIndex);
}
int QQuickHeaderViewBasePrivate::logicalColumnIndex(const int visualIndex) const
{
return (m_headerDataProxyModel.orientation() == Qt::Vertical) ? visualIndex : QQuickTableViewPrivate::logicalColumnIndex(visualIndex);
}
int QQuickHeaderViewBasePrivate::visualRowIndex(const int logicalIndex) const
{
return (m_headerDataProxyModel.orientation() == Qt::Horizontal) ? logicalIndex : QQuickTableViewPrivate::visualRowIndex(logicalIndex);
}
int QQuickHeaderViewBasePrivate::visualColumnIndex(const int logicalIndex) const
{
return (m_headerDataProxyModel.orientation() == Qt::Vertical) ? logicalIndex : QQuickTableViewPrivate::visualColumnIndex(logicalIndex);
}
QQuickHeaderViewBase::QQuickHeaderViewBase(Qt::Orientation orient, QQuickItem *parent)
: QQuickTableView(*(new QQuickHeaderViewBasePrivate), parent)
{
Q_D(QQuickHeaderViewBase);
d->setOrientation(orient);
d->init();
}
QQuickHeaderViewBase::QQuickHeaderViewBase(QQuickHeaderViewBasePrivate &dd, QQuickItem *parent)
: QQuickTableView(dd, parent)
{
Q_D(QQuickHeaderViewBase);
d->init();
}
QQuickHeaderViewBase::~QQuickHeaderViewBase()
{
}
QString QQuickHeaderViewBase::textRole() const
{
Q_D(const QQuickHeaderViewBase);
return d->m_textRole;
}
void QQuickHeaderViewBase::setTextRole(const QString &role)
{
Q_D(QQuickHeaderViewBase);
if (d->m_textRole == role)
return;
d->m_textRole = role;
emit textRoleChanged();
}
Qt::Orientation QQuickHeaderViewBasePrivate::orientation() const
{
return m_headerDataProxyModel.orientation();
}
void QQuickHeaderViewBasePrivate::setOrientation(Qt::Orientation orientation)
{
if (QQuickHeaderViewBasePrivate::orientation() == orientation)
return;
m_headerDataProxyModel.setOrientation(orientation);
}
QQuickVerticalHeaderView::QQuickVerticalHeaderView(QQuickVerticalHeaderViewPrivate &dd, QQuickItem *parent)
: QQuickHeaderViewBase(dd, parent)
{
}
/*! \internal
\class QHeaderDataProxyModel
\brief
QHeaderDataProxyModel is a proxy AbstractItemModel type that maps
source model's headerData() to correspondent data()
*/
QHeaderDataProxyModel::QHeaderDataProxyModel(QObject *parent)
: QAbstractItemModel(parent)
{
}
QHeaderDataProxyModel::~QHeaderDataProxyModel() = default;
void QHeaderDataProxyModel::setSourceModel(QAbstractItemModel *newSourceModel)
{
if (m_model == newSourceModel)
return;
beginResetModel();
disconnectFromModel();
m_model = newSourceModel;
connectToModel();
endResetModel();
}
QModelIndex QHeaderDataProxyModel::index(int row, int column, const QModelIndex &parent) const
{
return hasIndex(row, column, parent) ? createIndex(row, column) : QModelIndex();
}
QModelIndex QHeaderDataProxyModel::parent(const QModelIndex &child) const
{
Q_UNUSED(child);
return QModelIndex();
}
QModelIndex QHeaderDataProxyModel::sibling(int row, int column, const QModelIndex &) const
{
return index(row, column);
}
int QHeaderDataProxyModel::rowCount(const QModelIndex &parent) const
{
if (parent.isValid())
return 0;
return m_model.isNull() ? -1 : (m_orientation == Qt::Horizontal ? 1 : m_model->rowCount(parent));
}
int QHeaderDataProxyModel::columnCount(const QModelIndex &parent) const
{
if (parent.isValid())
return 0;
return m_model.isNull() ? -1 : (m_orientation == Qt::Vertical ? 1 : m_model->columnCount(parent));
}
QVariant QHeaderDataProxyModel::data(const QModelIndex &index, int role) const
{
if (m_model.isNull() || !hasIndex(index.row(), index.column()))
return QVariant();
auto section = m_orientation == Qt::Vertical ? index.row() : index.column();
return m_model->headerData(section, m_orientation, role);
}
bool QHeaderDataProxyModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
if (!hasIndex(index.row(), index.column()))
return false;
auto section = m_orientation == Qt::Vertical ? index.row() : index.column();
auto ret = m_model->setHeaderData(section, m_orientation, value, role);
return ret;
}
bool QHeaderDataProxyModel::hasChildren(const QModelIndex &parent) const
{
if (!parent.isValid())
return rowCount(parent) > 0 && columnCount(parent) > 0;
return false;
}
QHash<int, QByteArray> QHeaderDataProxyModel::roleNames() const
{
using namespace Qt::Literals::StringLiterals;
auto names = m_model ? m_model->roleNames() : QAbstractItemModel::roleNames();
if (m_headerView) {
QString textRole = m_headerView->textRole();
if (textRole.isEmpty())
textRole = u"display"_s;
if (!names.values().contains(textRole.toUtf8().constData())) {
qmlWarning(m_headerView).nospace() << "The 'textRole' property contains a role that doesn't exist in the model: "
<< textRole << ". Check your model's roleNames() implementation";
}
}
return names;
}
QVariant QHeaderDataProxyModel::variantValue() const
{
return QVariant::fromValue(static_cast<QObject *>(const_cast<QHeaderDataProxyModel *>(this)));
}
void QHeaderDataProxyModel::setOrientation(Qt::Orientation o)
{
if (o == m_orientation)
return;
beginResetModel();
m_orientation = o;
endResetModel();
}
Qt::Orientation QHeaderDataProxyModel::orientation() const
{
return m_orientation;
}
QPointer<QAbstractItemModel> QHeaderDataProxyModel::sourceModel() const
{
return m_model;
}
void QHeaderDataProxyModel::connectToModel()
{
if (m_model.isNull())
return;
connect(m_model, &QAbstractItemModel::headerDataChanged,
this, [this](Qt::Orientation orient, int first, int last) {
if (orient != orientation())
return;
if (orient == Qt::Horizontal) {
emit dataChanged(createIndex(0, first), createIndex(0, last));
} else {
emit dataChanged(createIndex(first, 0), createIndex(last, 0));
}
});
connect(m_model, &QAbstractItemModel::modelAboutToBeReset,
this, &QHeaderDataProxyModel::modelAboutToBeReset, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::modelReset,
this, &QHeaderDataProxyModel::modelReset, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::rowsAboutToBeMoved,
this, &QHeaderDataProxyModel::rowsAboutToBeMoved, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::rowsMoved,
this, &QHeaderDataProxyModel::rowsMoved, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::rowsAboutToBeInserted,
this, &QHeaderDataProxyModel::rowsAboutToBeInserted, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::rowsInserted,
this, &QHeaderDataProxyModel::rowsInserted, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::rowsAboutToBeRemoved,
this, &QHeaderDataProxyModel::rowsAboutToBeRemoved, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::rowsRemoved,
this, &QHeaderDataProxyModel::rowsRemoved, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::columnsAboutToBeMoved,
this, &QHeaderDataProxyModel::columnsAboutToBeMoved, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::columnsMoved,
this, &QHeaderDataProxyModel::columnsMoved, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::columnsAboutToBeInserted,
this, &QHeaderDataProxyModel::columnsAboutToBeInserted, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::columnsInserted,
this, &QHeaderDataProxyModel::columnsInserted, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::columnsAboutToBeRemoved,
this, &QHeaderDataProxyModel::columnsAboutToBeRemoved, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::columnsRemoved,
this, &QHeaderDataProxyModel::columnsRemoved, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::layoutAboutToBeChanged,
this, &QHeaderDataProxyModel::layoutAboutToBeChanged, Qt::UniqueConnection);
connect(m_model, &QAbstractItemModel::layoutChanged,
this, &QHeaderDataProxyModel::layoutChanged, Qt::UniqueConnection);
}
void QHeaderDataProxyModel::disconnectFromModel()
{
if (m_model.isNull())
return;
m_model->disconnect(this);
}
QQuickHorizontalHeaderView::QQuickHorizontalHeaderView(QQuickItem *parent)
: QQuickHeaderViewBase(*(new QQuickHorizontalHeaderViewPrivate), parent)
{
setFlickableDirection(FlickableDirection::HorizontalFlick);
setResizableColumns(true);
}
QQuickHorizontalHeaderView::~QQuickHorizontalHeaderView()
{
#if QT_CONFIG(quick_draganddrop)
Q_D(QQuickHorizontalHeaderView);
d->destroySectionDragHandler();
#endif
}
bool QQuickHorizontalHeaderView::movableColumns() const
{
Q_D(const QQuickHorizontalHeaderView);
return d->m_movableColumns;
}
void QQuickHorizontalHeaderView::setMovableColumns(bool movableColumns)
{
Q_D(QQuickHorizontalHeaderView);
if (d->m_movableColumns == movableColumns)
return;
d->m_movableColumns = movableColumns;
#if QT_CONFIG(quick_draganddrop)
if (d->m_movableColumns)
d->initSectionDragHandler(Qt::Horizontal);
else
d->destroySectionDragHandler();
#endif
emit movableColumnsChanged();
}
bool QQuickHorizontalHeaderView::showSortIndicator() const
{
Q_D(const QQuickHorizontalHeaderView);
return d->showSortIndicator;
}
void QQuickHorizontalHeaderView::setShowSortIndicator(bool show)
{
Q_D(QQuickHorizontalHeaderView);
if (d->showSortIndicator == show)
return;
d->showSortIndicator = show;
emit showSortIndicatorChanged();
}
bool QQuickHorizontalHeaderView::sortIndicatorClearable() const
{
Q_D(const QQuickHorizontalHeaderView);
return d->sortIndicatorClearable;
}
void QQuickHorizontalHeaderView::setSortIndicatorClearable(bool clearable)
{
Q_D(QQuickHorizontalHeaderView);
if (d->sortIndicatorClearable == clearable)
return;
d->sortIndicatorClearable = clearable;
emit sortIndicatorClearableChanged();
}
QQuickVerticalHeaderView::QQuickVerticalHeaderView(QQuickItem *parent)
: QQuickHeaderViewBase(*(new QQuickVerticalHeaderViewPrivate), parent)
{
setFlickableDirection(FlickableDirection::VerticalFlick);
setResizableRows(true);
}
QQuickVerticalHeaderView::~QQuickVerticalHeaderView()
{
#if QT_CONFIG(quick_draganddrop)
Q_D(QQuickVerticalHeaderView);
d->destroySectionDragHandler();
#endif
}
bool QQuickVerticalHeaderView::movableRows() const
{
Q_D(const QQuickVerticalHeaderView);
return d->m_movableRows ;
}
void QQuickVerticalHeaderView::setMovableRows(bool movableRows)
{
Q_D(QQuickVerticalHeaderView);
if (d->m_movableRows == movableRows)
return;
d->m_movableRows = movableRows;
#if QT_CONFIG(quick_draganddrop)
if (d->m_movableRows)
d->initSectionDragHandler(Qt::Vertical);
else
d->destroySectionDragHandler();
#endif
emit movableRowsChanged();
}
QQuickHorizontalHeaderViewPrivate::QQuickHorizontalHeaderViewPrivate()
{
setOrientation(Qt::Horizontal);
};
QQuickHorizontalHeaderViewPrivate::~QQuickHorizontalHeaderViewPrivate() = default;
void QQuickHorizontalHeaderViewPrivate::executeTap(const QQuickHandlerPoint &point)
{
Q_Q(QQuickHorizontalHeaderView);
QQuickTableViewPrivate::executeTap(point);
const QPoint cell = q->cellAtPosition(point.position());
const int visualColumn = cell.x();
const int logicalColumn = logicalColumnIndex(visualColumn);
if (logicalColumn < 0)
return;
emit q->headerClicked(logicalColumn);
if (!assignedSyncView)
return;
QQuickTableViewPrivate::get(assignedSyncView)->requestSort(logicalColumn, sortIndicatorClearable);
}
QQuickVerticalHeaderViewPrivate::QQuickVerticalHeaderViewPrivate()
{
setOrientation(Qt::Vertical);
};
QQuickVerticalHeaderViewPrivate::~QQuickVerticalHeaderViewPrivate() = default;
QT_END_NAMESPACE
#include "moc_qquickheaderview_p_p.cpp"
#include "moc_qquickheaderview_p.cpp"