qstringlistmodel.cpp

Go to the documentation of this file.

// Copyright (C) 2016 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
 
/*
    A simple model that uses a QStringList as its data source.
*/
 
#include "qstringlistmodel.h"
 
#include <QtCore/qlist.h>
#include <QtCore/qmap.h>
 
#include <algorithm>
 
QT_BEGIN_NAMESPACE
 
QStringListModel::QStringListModel(QObject *parent)
    : QAbstractListModel(parent)
{
}
 
QStringListModel::QStringListModel(const QStringList &strings, QObject *parent)
    : QAbstractListModel(parent), lst(strings)
{
}
 
int QStringListModel::rowCount(const QModelIndex &parent) const
{
    if (parent.isValid())
        return 0;
 
    return lst.size();
}
 
QModelIndex QStringListModel::sibling(int row, int column, const QModelIndex &idx) const
{
    if (!idx.isValid() || column != 0 || row >= lst.size() || row < 0)
        return QModelIndex();
 
    return createIndex(row, 0);
}
 
QMap<int, QVariant> QStringListModel::itemData(const QModelIndex &index) const
{
    if (!checkIndex(index, CheckIndexOption::IndexIsValid | CheckIndexOption::ParentIsInvalid))
        return QMap<int, QVariant>{};
    const QVariant displayData = lst.at(index.row());
    return QMap<int, QVariant>{{
        std::make_pair<int>(Qt::DisplayRole, displayData),
        std::make_pair<int>(Qt::EditRole, displayData)
    }};
}
 
bool QStringListModel::setItemData(const QModelIndex &index, const QMap<int, QVariant> &roles)
{
    if (roles.isEmpty())
        return false;
    if (std::any_of(roles.keyBegin(), roles.keyEnd(), [](int role) -> bool {
        return role != Qt::DisplayRole && role != Qt::EditRole;
    })) {
        return false;
    }
    auto roleIter = roles.constFind(Qt::EditRole);
    if (roleIter == roles.constEnd())
        roleIter = roles.constFind(Qt::DisplayRole);
    Q_ASSERT(roleIter != roles.constEnd());
    return setData(index, roleIter.value(), roleIter.key());
}
 
QVariant QStringListModel::data(const QModelIndex &index, int role) const
{
    if (index.row() < 0 || index.row() >= lst.size())
        return QVariant();
 
    if (role == Qt::DisplayRole || role == Qt::EditRole)
        return lst.at(index.row());
 
    return QVariant();
}
 
Qt::ItemFlags QStringListModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return QAbstractListModel::flags(index) | Qt::ItemIsDropEnabled;
 
    return QAbstractListModel::flags(index) | Qt::ItemIsEditable | Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled;
}
 
bool QStringListModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (index.row() >= 0 && index.row() < lst.size()
        && (role == Qt::EditRole || role == Qt::DisplayRole)) {
        const QString valueString = value.toString();
        if (lst.at(index.row()) == valueString)
            return true;
        lst.replace(index.row(), valueString);
        emit dataChanged(index, index, {Qt::DisplayRole, Qt::EditRole});
        return true;
    }
    return false;
}
 
bool QStringListModel::clearItemData(const QModelIndex &index)
{
    return setData(index, QVariant(), Qt::EditRole);
}
 
bool QStringListModel::insertRows(int row, int count, const QModelIndex &parent)
{
    if (count < 1 || row < 0 || row > rowCount(parent))
        return false;
 
    beginInsertRows(QModelIndex(), row, row + count - 1);
 
    for (int r = 0; r < count; ++r)
        lst.insert(row, QString());
 
    endInsertRows();
 
    return true;
}
 
bool QStringListModel::removeRows(int row, int count, const QModelIndex &parent)
{
    if (count <= 0 || row < 0 || (row + count) > rowCount(parent))
        return false;
 
    beginRemoveRows(QModelIndex(), row, row + count - 1);
 
    const auto it = lst.begin() + row;
    lst.erase(it, it + count);
 
    endRemoveRows();
 
    return true;
}
 
bool QStringListModel::moveRows(const QModelIndex &sourceParent, int sourceRow, int count, const QModelIndex &destinationParent, int destinationChild)
{
    if (sourceRow < 0
        || sourceRow + count - 1 >= rowCount(sourceParent)
        || destinationChild < 0
        || destinationChild > rowCount(destinationParent)
        || sourceRow == destinationChild
        || sourceRow == destinationChild - 1
        || count <= 0
        || sourceParent.isValid()
        || destinationParent.isValid()) {
        return false;
    }
    if (!beginMoveRows(QModelIndex(), sourceRow, sourceRow + count - 1, QModelIndex(), destinationChild))
        return false;
 
    int fromRow = sourceRow;
    if (destinationChild < sourceRow)
        fromRow += count - 1;
    else
        destinationChild--;
    while (count--)
        lst.move(fromRow, destinationChild);
    endMoveRows();
    return true;
}
 
static bool ascendingLessThan(const std::pair<QString, int> &s1, const std::pair<QString, int> &s2)
{
    return s1.first < s2.first;
}
 
static bool decendingLessThan(const std::pair<QString, int> &s1, const std::pair<QString, int> &s2)
{
    return s1.first > s2.first;
}
 
void QStringListModel::sort(int, Qt::SortOrder order)
{
    emit layoutAboutToBeChanged(QList<QPersistentModelIndex>(), VerticalSortHint);
 
    QList<std::pair<QString, int>> list;
    const int lstCount = lst.size();
    list.reserve(lstCount);
    for (int i = 0; i < lstCount; ++i)
        list.emplace_back(lst.at(i), i);
 
    if (order == Qt::AscendingOrder)
        std::sort(list.begin(), list.end(), ascendingLessThan);
    else
        std::sort(list.begin(), list.end(), decendingLessThan);
 
    lst.clear();
    QList<int> forwarding(lstCount);
    for (int i = 0; i < lstCount; ++i) {
        lst.append(list.at(i).first);
        forwarding[list.at(i).second] = i;
    }
 
    QModelIndexList oldList = persistentIndexList();
    QModelIndexList newList;
    const int numOldIndexes = oldList.size();
    newList.reserve(numOldIndexes);
    for (int i = 0; i < numOldIndexes; ++i)
        newList.append(index(forwarding.at(oldList.at(i).row()), 0));
    changePersistentIndexList(oldList, newList);
 
    emit layoutChanged(QList<QPersistentModelIndex>(), VerticalSortHint);
}
 
QStringList QStringListModel::stringList() const
{
    return lst;
}
 
void QStringListModel::setStringList(const QStringList &strings)
{
    beginResetModel();
    lst = strings;
    endResetModel();
}
 
Qt::DropActions QStringListModel::supportedDropActions() const
{
    return QAbstractItemModel::supportedDropActions() | Qt::MoveAction;
}
 
QT_END_NAMESPACE
 
#include "moc_qstringlistmodel.cpp"