Revision control
Copy as Markdown
// Copyright (C) 2025 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 <QtQmlModels/private/qqmlsortercompositor_p.h>
#include <QtQmlModels/private/qqmlsortfilterproxymodel_p_p.h>
#include <QtQmlModels/private/qqmlsortfilterproxymodel_p.h>
QT_BEGIN_NAMESPACE
QQmlSorterCompositor::QQmlSorterCompositor(QObject *parent)
: QQmlSorterBase(new QQmlSorterCompositorPrivate, parent)
{
Q_D(QQmlSorterCompositor);
d->init();
// Connect the model reset with the update in the filter
// The cache need to be updated once the model is reset with the
// source model data.
connect(d->m_sfpmModel, &QQmlSortFilterProxyModel::modelReset,
this, &QQmlSorterCompositor::updateSorters);
connect(d->m_sfpmModel, &QQmlSortFilterProxyModel::primarySorterChanged,
this, &QQmlSorterCompositor::updateEffectiveSorters);
}
QQmlSorterCompositor::~QQmlSorterCompositor()
{
}
void QQmlSorterCompositorPrivate::init()
{
Q_Q(QQmlSorterCompositor);
m_sfpmModel = qobject_cast<QQmlSortFilterProxyModel *>(q->parent());
}
void QQmlSorterCompositor::append(QQmlListProperty<QQmlSorterBase> *sorterComp, QQmlSorterBase* sorter)
{
auto *sorterCompositor = reinterpret_cast<QQmlSorterCompositor *>(sorterComp->object);
sorterCompositor->append(sorter);
}
qsizetype QQmlSorterCompositor::count(QQmlListProperty<QQmlSorterBase> *sorterComp)
{
auto *sorterCompositor = reinterpret_cast<QQmlSorterCompositor *> (sorterComp->object);
return sorterCompositor->count();
}
QQmlSorterBase *QQmlSorterCompositor::at(QQmlListProperty<QQmlSorterBase> *sorterComp, qsizetype index)
{
auto *sorterCompositor = reinterpret_cast<QQmlSorterCompositor *> (sorterComp->object);
return sorterCompositor->at(index);
}
void QQmlSorterCompositor::clear(QQmlListProperty<QQmlSorterBase> *sorterComp)
{
auto *sorterCompositor = reinterpret_cast<QQmlSorterCompositor *> (sorterComp->object);
sorterCompositor->clear();
}
void QQmlSorterCompositor::append(QQmlSorterBase *sorter)
{
if (!sorter)
return;
Q_D(QQmlSorterCompositor);
d->m_sorters.append(sorter);
// Update sorter cache depending on the priority
updateCache();
// Connect the sorter to the corresponding slot to invalidate the model
// and the sorter cache
QObject::connect(sorter, &QQmlSorterBase::invalidateModel,
d->m_sfpmModel, &QQmlSortFilterProxyModel::invalidate);
// This is needed as its required to update cache when there is any
// change in the filter itself (for instance, a change in the priority of
// the filter)
QObject::connect(sorter, &QQmlSorterBase::invalidateCache,
this, &QQmlSorterCompositor::updateCache);
// Reset the primary sort column when any sort order or column
// changed
QObject::connect(sorter, &QQmlSorterBase::sortOrderChanged,
this, [d] { d->resetPrimarySorter(); });
QObject::connect(sorter, &QQmlSorterBase::columnChanged,
this, [d] { d->resetPrimarySorter(); });
// Since we added new filter to the list, emit the filter changed signal
// for the filters thats been appended to the list
emit d->m_sfpmModel->sortersChanged();
}
qsizetype QQmlSorterCompositor::count()
{
Q_D(QQmlSorterCompositor);
return d->m_sorters.count();
}
QQmlSorterBase* QQmlSorterCompositor::at(qsizetype index)
{
Q_D(QQmlSorterCompositor);
return d->m_sorters.at(index);
}
void QQmlSorterCompositor::clear()
{
Q_D(QQmlSorterCompositor);
d->m_effectiveSorters.clear();
d->m_sorters.clear();
// Emit the filter changed signal as we cleared the filter list
emit d->m_sfpmModel->sortersChanged();
}
QList<QQmlSorterBase *> QQmlSorterCompositor::sorters()
{
Q_D(QQmlSorterCompositor);
return d->m_sorters;
}
QQmlListProperty<QQmlSorterBase> QQmlSorterCompositor::sortersListProperty()
{
Q_D(QQmlSorterCompositor);
return QQmlListProperty<QQmlSorterBase>(reinterpret_cast<QObject*>(this), &d->m_sorters,
QQmlSorterCompositor::append,
QQmlSorterCompositor::count,
QQmlSorterCompositor::at,
QQmlSorterCompositor::clear);
}
void QQmlSorterCompositor::updateEffectiveSorters()
{
Q_D(QQmlSorterCompositor);
if (!d->m_primarySorter || !d->m_primarySorter->enabled()) {
updateCache();
return;
}
QList<QQmlSorterBase *> sorters;
sorters.append(d->m_primarySorter);
std::copy_if(d->m_effectiveSorters.constBegin(), d->m_effectiveSorters.constEnd(),
std::back_inserter(sorters), [d](QQmlSorterBase *sorter){
// Consider only the filters that are enabled and exclude the primary
// sorter as its already added to the list
return (sorter != d->m_primarySorter);
});
d->m_effectiveSorters = sorters;
}
void QQmlSorterCompositor::updateSorters()
{
Q_D(QQmlSorterCompositor);
// Update sorters that has dependency with the model data to determine
// whether it needs to be included or not
for (auto &sorter: d->m_sorters)
sorter->update(d->m_sfpmModel);
updateCache();
}
void QQmlSorterCompositor::updateCache()
{
Q_D(QQmlSorterCompositor);
// Clear the existing cache
d->m_effectiveSorters.clear();
if (d->m_sfpmModel && d->m_sfpmModel->sourceModel()) {
// Sort the filter according to their priority
QList<QQmlSorterBase *> sorters = d->m_sorters;
std::stable_sort(sorters.begin(), sorters.end(),
[](QQmlSorterBase *sorterLeft, QQmlSorterBase *sorterRight) {
return sorterLeft->priority() < sorterRight->priority();
});
// Cache only the filters that are need to be evaluated (in order)
std::copy_if(sorters.begin(), sorters.end(), std::back_inserter(d->m_effectiveSorters),
[](QQmlSorterBase *sorter) { return sorter->enabled(); });
// If there is no primary sorter set by the user explicitly, reset the
// primary sorter according to the sorters in the lists
d->resetPrimarySorter();
}
}
bool QQmlSorterCompositor::lessThan(const QModelIndex& sourceLeft, const QModelIndex& sourceRight, const QQmlSortFilterProxyModel *proxyModel) const
{
Q_D(const QQmlSorterCompositor);
for (const auto &sorter : d->m_effectiveSorters) {
const int sortSection = sorter->column();
if ((sortSection > -1) && (sortSection < proxyModel->sourceModel()->columnCount())) {
const auto *sourceModel = proxyModel->sourceModel();
const QPartialOrdering result = sorter->compare(sourceModel->index(sourceLeft.row(), sortSection),
sourceModel->index(sourceRight.row(), sortSection),
proxyModel);
if (result == QPartialOrdering::Less || result == QPartialOrdering::Greater) {
auto *priv = static_cast<const QQmlSortFilterProxyModelPrivate *>(QQmlSortFilterProxyModelPrivate::get(proxyModel));
return (priv->m_sortOrder == sorter->sortOrder()) ? result < 0 : result > 0;
}
}
}
// Verify the index order when the ordering is either equal or unordered
return sourceLeft.row() < sourceRight.row();
}
void QQmlSorterCompositorPrivate::setPrimarySorter(QQmlSorterBase *sorter)
{
if (sorter == nullptr ||
(std::find(m_sorters.constBegin(), m_sorters.constEnd(), sorter) != m_sorters.constEnd())) {
m_primarySorter = sorter;
if (m_primarySorter && m_primarySorter->enabled()) {
m_sfpmModel->setPrimarySortOrder(m_primarySorter->sortOrder());
m_sfpmModel->setPrimarySortColumn(m_primarySorter->column());
return;
}
}
resetPrimarySorter();
}
void QQmlSorterCompositorPrivate::resetPrimarySorter()
{
if (!m_primarySorter) {
if (!m_effectiveSorters.isEmpty()) {
// Set the primary sort column and its order to the proxy model
const auto *sorter = m_effectiveSorters.at(0);
m_sfpmModel->setPrimarySortOrder(sorter->sortOrder());
m_sfpmModel->setPrimarySortColumn(sorter->column());
} else {
// By default reset the sort order to ascending order and the
// column to 0
m_sfpmModel->setPrimarySortOrder(Qt::AscendingOrder);
m_sfpmModel->setPrimarySortColumn(0);
}
}
}
QT_END_NAMESPACE
#include "moc_qqmlsortercompositor_p.cpp"