Loading...
Searching...
No Matches
qlimitproxymodelqml.cpp
/*
* Copyright (C) 2012, 2013 Canonical Ltd.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 3.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
// self
#include "qlimitproxymodelqml.h"
// Qt
#include <QDebug>
QLimitProxyModelQML::QLimitProxyModelQML(QObject *parent)
: QIdentityProxyModel(parent)
, m_limit(-1)
, m_sourceInserting(false)
, m_sourceRemoving(false)
, m_dataChangedBegin(-1)
, m_dataChangedEnd(-1)
{
connect(this, &QLimitProxyModelQML::modelReset, this, &QLimitProxyModelQML::countChanged);
connect(this, &QLimitProxyModelQML::rowsInserted, this, &QLimitProxyModelQML::countChanged);
connect(this, &QLimitProxyModelQML::rowsRemoved, this, &QLimitProxyModelQML::countChanged);
}
QHash<int, QByteArray> QLimitProxyModelQML::roleNames() const
{
return sourceModel() ? sourceModel()->roleNames() : QHash<int, QByteArray>();
}
void
QLimitProxyModelQML::setModel(QAbstractItemModel *itemModel)
{
if (itemModel != sourceModel()) {
if (sourceModel() != nullptr) {
sourceModel()->disconnect(this);
}
setSourceModel(itemModel);
if (sourceModel() != nullptr) {
// Disconnect the QIdentityProxyModel handling for rows removed/added...
disconnect(sourceModel(), &QAbstractItemModel::rowsAboutToBeInserted, this, nullptr);
disconnect(sourceModel(), &QAbstractItemModel::rowsInserted, this, nullptr);
disconnect(sourceModel(), &QAbstractItemModel::rowsAboutToBeRemoved, this, nullptr);
disconnect(sourceModel(), &QAbstractItemModel::rowsRemoved, this, nullptr);
// ... and use our own
connect(sourceModel(), &QAbstractItemModel::rowsAboutToBeInserted,
this, &QLimitProxyModelQML::sourceRowsAboutToBeInserted);
connect(sourceModel(), &QAbstractItemModel::rowsInserted,
this, &QLimitProxyModelQML::sourceRowsInserted);
connect(sourceModel(), &QAbstractItemModel::rowsAboutToBeRemoved,
this, &QLimitProxyModelQML::sourceRowsAboutToBeRemoved);
connect(sourceModel(), &QAbstractItemModel::rowsRemoved,
this, &QLimitProxyModelQML::sourceRowsRemoved);
}
Q_EMIT modelChanged();
}
}
int
QLimitProxyModelQML::rowCount(const QModelIndex &parent) const
{
if (parent.isValid()) // We are not a tree
return 0;
const int unlimitedCount = QIdentityProxyModel::rowCount(parent);
return m_limit < 0 ? unlimitedCount : qMin(m_limit, unlimitedCount);
}
int
QLimitProxyModelQML::limit() const
{
return m_limit;
}
void
QLimitProxyModelQML::setLimit(int limit)
{
if (limit != m_limit) {
bool inserting = false;
bool removing = false;
const int oldCount = rowCount();
const int unlimitedCount = QIdentityProxyModel::rowCount();
if (m_limit < 0) {
if (limit < oldCount) {
removing = true;
beginRemoveRows(QModelIndex(), limit, oldCount - 1);
}
} else if (limit < 0) {
if (m_limit < unlimitedCount) {
inserting = true;
beginInsertRows(QModelIndex(), m_limit, unlimitedCount - 1);
}
} else {
if (limit > m_limit && unlimitedCount > m_limit) {
inserting = true;
beginInsertRows(QModelIndex(), m_limit, qMin(limit, unlimitedCount) - 1);
} else if (limit < m_limit && limit < oldCount) {
removing = true;
beginRemoveRows(QModelIndex(), limit, oldCount - 1);
}
}
m_limit = limit;
if (inserting) {
endInsertRows();
} else if (removing) {
endRemoveRows();
}
Q_EMIT limitChanged();
}
}
void
QLimitProxyModelQML::sourceRowsAboutToBeInserted(const QModelIndex &parent, int start, int end)
{
if (m_limit < 0) {
beginInsertRows(mapFromSource(parent), start, end);
m_sourceInserting = true;
} else if (start < m_limit) {
const int nSourceAddedItems = end - start + 1;
const int currentCount = QIdentityProxyModel::rowCount();
if (currentCount + nSourceAddedItems <= m_limit) {
// After Inserting items we will be under the limit
// so just proceed with the insertion normally
beginInsertRows(mapFromSource(parent), start, end);
m_sourceInserting = true;
} else if (currentCount >= m_limit) {
// We are already over the limit so to our users we are not adding items, just
// changing it's data, i.e we had something like
// A B C D E
// with a limit of 5
// after inserting (let's say three 'F' at position 1) we will have
// A F F F B
// so we just need to signal a dataChanged from 1 to 4
m_dataChangedBegin = start;
m_dataChangedEnd = m_limit - 1;
} else { // currentCount < m_limit && currentCount + nSourceAddedItems > m_limit
// We have less items than the limit but after adding them we will be over
// To our users this means we need to insert some items and change the
// data of some others, i.e we had something like
// A B C
// with a limit of 5
// after inserting (let's say three 'F' at position 1) we will have
// A F F F B
// so we need to signal an insetion from position 1 to 2, instead of from
// position 1 to 3 and a after that a data changed from 3 to 4
const int nItemsToInsert = m_limit - currentCount;
beginInsertRows(mapFromSource(parent), start, start + nItemsToInsert - 1);
m_sourceInserting = true;
m_dataChangedBegin = start + nItemsToInsert;
m_dataChangedEnd = m_limit - 1;
if (m_dataChangedBegin > m_dataChangedEnd) {
// Just in case we were empty and insert 6 items with a limit of 5
// We don't want to signal a dataChanged from 5 to 4
m_dataChangedBegin = -1;
m_dataChangedEnd = -1;
}
}
}
}
void
QLimitProxyModelQML::sourceRowsAboutToBeRemoved(const QModelIndex &parent, int start, int end)
{
if (m_limit < 0) {
beginRemoveRows(mapFromSource(parent), start, end);
m_sourceRemoving = true;
} else if (start < m_limit) {
const int nSourceRemovedItems = end - start + 1;
const int currentCount = QIdentityProxyModel::rowCount();
if (currentCount <= m_limit) {
// We are already under the limit so
// so just proceed with the removal normally
beginRemoveRows(mapFromSource(parent), start, end);
m_sourceRemoving = true;
} else if (currentCount - nSourceRemovedItems >= m_limit) {
// Even after removing items we will be at or over the limit
// So to our users we are not removing anything, just changing the data
// i.e. we had a internal model with
// A B C D E F G H
// and a limit of 5, our users just see
// A B C D E
// so if we remove 3 items starting at 1 we have to expose
// A E F G H
// that is, a dataChanged from 1 to 4
m_dataChangedBegin = start;
m_dataChangedEnd = m_limit - 1;
} else { // currentCount > m_limit && currentCount - nSourceRemovedItems < m_limit
// We have more items than the limit but after removing we will be below it
// So to our users we both removing and changing the data
// i.e. we had a internal model with
// A B C D E F G
// and a limit of 5, our users just see
// A B C D E
// so if we remove items from 1 to 3 we have to expose
// A E F G
// that is, a remove from 4 to 4 and a dataChanged from 1 to 3
const int nItemsToRemove = m_limit - (currentCount - nSourceRemovedItems);
beginRemoveRows(mapFromSource(parent), m_limit - nItemsToRemove, m_limit - 1);
m_sourceRemoving = true;
m_dataChangedBegin = start;
m_dataChangedEnd = m_limit - nItemsToRemove - 1;
if (m_dataChangedBegin > m_dataChangedEnd) {
m_dataChangedBegin = -1;
m_dataChangedEnd = -1;
}
}
}
}
void
QLimitProxyModelQML::sourceRowsInserted(const QModelIndex & /*parent*/, int /*start*/, int /*end*/)
{
if (m_sourceInserting) {
endInsertRows();
m_sourceInserting = false;
}
if (m_dataChangedBegin != -1 && m_dataChangedEnd != -1) {
dataChanged(index(m_dataChangedBegin, 0), index(m_dataChangedEnd, 0));
m_dataChangedBegin = -1;
m_dataChangedEnd = -1;
}
}
void
QLimitProxyModelQML::sourceRowsRemoved(const QModelIndex & /*parent*/, int /*start*/, int /*end*/)
{
if (m_sourceRemoving) {
endRemoveRows();
m_sourceRemoving = false;
}
if (m_dataChangedBegin != -1 && m_dataChangedEnd != -1) {
dataChanged(index(m_dataChangedBegin, 0), index(m_dataChangedEnd, 0));
m_dataChangedBegin = -1;
m_dataChangedEnd = -1;
}
}