[Card DB Models] Move refactor (#6172)

* Refactor CardDatabaseDisplayModel, TokenDisplayModel and TokenEditModel out of CardDatabaseModel. Move every model into an appropriate folder.

Took 54 minutes

* No folder for database models.

Took 6 minutes

---------

Co-authored-by: Lukas Brübach <Bruebach.Lukas@bdosecurity.de>

cockatrice/src/database/model/card/card_completer_proxy_model.cpp

@@ -0,0 +1,18 @@
+#include "card_completer_proxy_model.h"
+
+CardCompleterProxyModel::CardCompleterProxyModel(QObject *parent) : QSortFilterProxyModel(parent)
+{
+}
+
+bool CardCompleterProxyModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+{
+    if (filterRegularExpression().pattern().isEmpty()) {
+        return true;
+    }
+
+    QModelIndex index = sourceModel()->index(sourceRow, 0, sourceParent);
+    QString data = index.data(Qt::DisplayRole).toString();
+
+    // Ensure substring matching
+    return data.contains(filterRegularExpression());
+}

cockatrice/src/database/model/card/card_completer_proxy_model.h

@@ -0,0 +1,16 @@
+#ifndef CARD_COMPLETER_PROXY_MODEL_H
+#define CARD_COMPLETER_PROXY_MODEL_H
+
+#include <QSortFilterProxyModel>
+
+class CardCompleterProxyModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    explicit CardCompleterProxyModel(QObject *parent = nullptr);
+
+protected:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+};
+
+#endif // CARD_COMPLETER_PROXY_MODEL_H

cockatrice/src/database/model/card/card_search_model.cpp

@@ -0,0 +1,72 @@
+#include "card_search_model.h"
+
+#include "../../../utility/levenshtein.h"
+#include "../card_database_model.h"
+
+#include <algorithm>
+
+CardSearchModel::CardSearchModel(CardDatabaseDisplayModel *sourceModel, QObject *parent)
+    : QAbstractListModel(parent), sourceModel(sourceModel)
+{
+}
+
+int CardSearchModel::rowCount(const QModelIndex &parent) const
+{
+    Q_UNUSED(parent);
+    return searchResults.size();
+}
+
+QVariant CardSearchModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() >= searchResults.size())
+        return QVariant();
+
+    if (role == Qt::DisplayRole) {
+        return searchResults.at(index.row()).card->getName();
+    }
+
+    return QVariant();
+}
+
+void CardSearchModel::updateSearchResults(const QString &query)
+{
+    beginResetModel();
+    searchResults.clear();
+
+    if (query.isEmpty() || !sourceModel)
+        return;
+
+    // Set the filter for the display model
+    sourceModel->setCardName(query);
+
+    // Collect matching cards and compute Levenshtein distance
+    for (int i = 0; i < sourceModel->rowCount(); ++i) {
+        QModelIndex modelIndex = sourceModel->index(i, 0);
+        QModelIndex sourceIndex = sourceModel->mapToSource(modelIndex);
+        CardDatabaseModel *sourceDbModel = qobject_cast<CardDatabaseModel *>(sourceModel->sourceModel());
+
+        if (!sourceDbModel || !sourceIndex.isValid())
+            return;
+
+        CardInfoPtr card = sourceDbModel->getCard(sourceIndex.row());
+
+        if (!card)
+            continue;
+
+        int distance = levenshteinDistance(query.toLower(), card->getName().toLower());
+        searchResults.append({card, distance});
+    }
+
+    // Sort by Levenshtein distance (lower distance = better match)
+    std::sort(searchResults.begin(), searchResults.end(),
+              [](const SearchResult &a, const SearchResult &b) { return a.distance < b.distance; });
+
+    // Keep only the top 5 results
+    if (searchResults.size() > 10)
+        searchResults = searchResults.mid(0, 10);
+
+    emit dataChanged(index(0, 0), index(rowCount() - 1, 0));
+    emit layoutChanged();
+
+    endResetModel();
+}

cockatrice/src/database/model/card/card_search_model.h

@@ -0,0 +1,30 @@
+#ifndef CARD_SEARCH_MODEL_H
+#define CARD_SEARCH_MODEL_H
+
+#include "../card_database_display_model.h"
+
+#include <QAbstractListModel>
+
+class CardSearchModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    explicit CardSearchModel(CardDatabaseDisplayModel *sourceModel, QObject *parent = nullptr);
+
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role = Qt::DisplayRole) const override;
+
+    void updateSearchResults(const QString &query); // Update results based on input
+
+private:
+    struct SearchResult
+    {
+        CardInfoPtr card;
+        int distance;
+    };
+
+    CardDatabaseDisplayModel *sourceModel;
+    QList<SearchResult> searchResults;
+};
+
+#endif // CARD_SEARCH_MODEL_H

cockatrice/src/database/model/card_database_display_model.cpp

@@ -0,0 +1,220 @@
+#include "card_database_display_model.h"
+
+#include "card_database_model.h"
+
+CardDatabaseDisplayModel::CardDatabaseDisplayModel(QObject *parent)
+    : QSortFilterProxyModel(parent), isToken(ShowAll), filterString(nullptr)
+{
+    filterTree = nullptr;
+    setFilterCaseSensitivity(Qt::CaseInsensitive);
+    setSortCaseSensitivity(Qt::CaseInsensitive);
+
+    dirtyTimer.setSingleShot(true);
+    connect(&dirtyTimer, &QTimer::timeout, this, &CardDatabaseDisplayModel::invalidate);
+
+    loadedRowCount = 0;
+}
+
+QMap<wchar_t, wchar_t> CardDatabaseDisplayModel::characterTranslation = {{L'“', L'\"'},
+                                                                         {L'”', L'\"'},
+                                                                         {L'‘', L'\''},
+                                                                         {L'’', L'\''}};
+
+bool CardDatabaseDisplayModel::canFetchMore(const QModelIndex &index) const
+{
+    return loadedRowCount < sourceModel()->rowCount(index);
+}
+
+void CardDatabaseDisplayModel::fetchMore(const QModelIndex &index)
+{
+    int remainder = sourceModel()->rowCount(index) - loadedRowCount;
+    int itemsToFetch = qMin(100, remainder);
+
+    if (itemsToFetch == 0) {
+        return;
+    }
+
+    const auto startIndex = qMin(rowCount(QModelIndex()), loadedRowCount);
+    beginInsertRows(QModelIndex(), startIndex, startIndex + itemsToFetch - 1);
+
+    loadedRowCount += itemsToFetch;
+    endInsertRows();
+}
+
+int CardDatabaseDisplayModel::rowCount(const QModelIndex &parent) const
+{
+    return QSortFilterProxyModel::rowCount(parent);
+}
+
+bool CardDatabaseDisplayModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
+{
+
+    QString leftString = sourceModel()->data(left, CardDatabaseModel::SortRole).toString();
+    QString rightString = sourceModel()->data(right, CardDatabaseModel::SortRole).toString();
+
+    if (!cardName.isEmpty() && left.column() == CardDatabaseModel::NameColumn) {
+        bool isLeftType = leftString.startsWith(cardName, Qt::CaseInsensitive);
+        bool isRightType = rightString.startsWith(cardName, Qt::CaseInsensitive);
+
+        // test for an exact match: isLeftType && leftString.size() == cardName.size()
+        // or an exclusive start match: isLeftType && !isRightType
+        if (isLeftType && (!isRightType || leftString.size() == cardName.size()))
+            return true;
+
+        // same checks for the right string
+        if (isRightType && (!isLeftType || rightString.size() == cardName.size()))
+            return false;
+    } else if (right.column() == CardDatabaseModel::PTColumn && left.column() == CardDatabaseModel::PTColumn) {
+        QStringList leftList = leftString.split("/");
+        QStringList rightList = rightString.split("/");
+
+        if (leftList.size() == 2 && rightList.size() == 2) {
+
+            // cool, have both P/T in list now
+            int lessThanNum = lessThanNumerically(leftList.at(0), rightList.at(0));
+            if (lessThanNum != 0) {
+                return lessThanNum < 0;
+            } else {
+                // power equal, check toughness
+                return lessThanNumerically(leftList.at(1), rightList.at(1)) < 0;
+            }
+        }
+    }
+    return QString::localeAwareCompare(leftString, rightString) < 0;
+}
+
+int CardDatabaseDisplayModel::lessThanNumerically(const QString &left, const QString &right)
+{
+    if (left == right) {
+        return 0;
+    }
+
+    bool okLeft, okRight;
+    float leftNum = left.toFloat(&okLeft);
+    float rightNum = right.toFloat(&okRight);
+
+    if (okLeft && okRight) {
+        if (leftNum < rightNum) {
+            return -1;
+        } else if (leftNum > rightNum) {
+            return 1;
+        } else {
+            return 0;
+        }
+    }
+    // try and parsing again, for weird ones like "1+*"
+    QString leftAfterNum = "";
+    QString rightAfterNum = "";
+    if (!okLeft) {
+        int leftNumIndex = 0;
+        for (; leftNumIndex < left.length(); leftNumIndex++) {
+            if (!left.at(leftNumIndex).isDigit()) {
+                break;
+            }
+        }
+        if (leftNumIndex != 0) {
+            leftNum = left.left(leftNumIndex).toFloat(&okLeft);
+            leftAfterNum = left.right(leftNumIndex);
+        }
+    }
+    if (!okRight) {
+        int rightNumIndex = 0;
+        for (; rightNumIndex < right.length(); rightNumIndex++) {
+            if (!right.at(rightNumIndex).isDigit()) {
+                break;
+            }
+        }
+        if (rightNumIndex != 0) {
+            rightNum = right.left(rightNumIndex).toFloat(&okRight);
+            rightAfterNum = right.right(rightNumIndex);
+        }
+    }
+    if (okLeft && okRight) {
+
+        if (leftNum != rightNum) {
+            // both parsed as numbers, but different number
+            if (leftNum < rightNum) {
+                return -1;
+            } else {
+                return 1;
+            }
+        } else {
+            // both parsed, same number, but at least one has something else
+            // so compare the part after the number - prefer nothing
+            return QString::localeAwareCompare(leftAfterNum, rightAfterNum);
+        }
+    } else if (okLeft) {
+        return -1;
+    } else if (okRight) {
+        return 1;
+    }
+    // couldn't parse it, just return String comparison
+    return QString::localeAwareCompare(left, right);
+}
+bool CardDatabaseDisplayModel::filterAcceptsRow(int sourceRow, const QModelIndex & /*sourceParent*/) const
+{
+    CardInfoPtr info = static_cast<CardDatabaseModel *>(sourceModel())->getCard(sourceRow);
+
+    if (((isToken == ShowTrue) && !info->getIsToken()) || ((isToken == ShowFalse) && info->getIsToken()))
+        return false;
+
+    if (filterString != nullptr) {
+        if (filterTree != nullptr && !filterTree->acceptsCard(info)) {
+            return false;
+        }
+        return filterString->check(info);
+    }
+
+    return rowMatchesCardName(info);
+}
+
+bool CardDatabaseDisplayModel::rowMatchesCardName(CardInfoPtr info) const
+{
+    if (!cardName.isEmpty() && !info->getName().contains(cardName, Qt::CaseInsensitive))
+        return false;
+
+    if (!cardNameSet.isEmpty() && !cardNameSet.contains(info->getName()))
+        return false;
+
+    if (filterTree != nullptr)
+        return filterTree->acceptsCard(info);
+
+    return true;
+}
+
+void CardDatabaseDisplayModel::clearFilterAll()
+{
+    cardName.clear();
+    cardText.clear();
+    cardTypes.clear();
+    cardColors.clear();
+    if (filterTree != nullptr)
+        filterTree->clear();
+    invalidateFilter();
+}
+
+void CardDatabaseDisplayModel::setFilterTree(FilterTree *_filterTree)
+{
+    if (this->filterTree != nullptr)
+        disconnect(this->filterTree, nullptr, this, nullptr);
+
+    this->filterTree = _filterTree;
+    connect(this->filterTree, &FilterTree::changed, this, &CardDatabaseDisplayModel::filterTreeChanged);
+    invalidate();
+}
+
+void CardDatabaseDisplayModel::filterTreeChanged()
+{
+    invalidate();
+}
+
+const QString CardDatabaseDisplayModel::sanitizeCardName(const QString &dirtyName, const QMap<wchar_t, wchar_t> &table)
+{
+    std::wstring toReturn = dirtyName.toStdWString();
+    for (wchar_t &ch : toReturn) {
+        if (table.contains(ch)) {
+            ch = table.value(ch);
+        }
+    }
+    return QString::fromStdWString(toReturn);
+}

cockatrice/src/database/model/card_database_display_model.h

@@ -0,0 +1,92 @@
+#ifndef COCKATRICE_CARD_DATABASE_DISPLAY_MODEL_H
+#define COCKATRICE_CARD_DATABASE_DISPLAY_MODEL_H
+
+#include "../../filters/filter_string.h"
+
+#include <QList>
+#include <QSet>
+#include <QSortFilterProxyModel>
+#include <QTimer>
+
+class FilterTree;
+class CardDatabaseDisplayModel : public QSortFilterProxyModel
+{
+    Q_OBJECT
+public:
+    enum FilterBool
+    {
+        ShowTrue,
+        ShowFalse,
+        ShowAll
+    };
+
+private:
+    FilterBool isToken;
+    QString cardName, cardText;
+    QSet<QString> cardNameSet, cardTypes, cardColors;
+    FilterTree *filterTree;
+    FilterString *filterString;
+    int loadedRowCount;
+    QTimer dirtyTimer;
+
+    /** The translation table that will be used for sanitizeCardName. */
+    static QMap<wchar_t, wchar_t> characterTranslation;
+
+public:
+    explicit CardDatabaseDisplayModel(QObject *parent = nullptr);
+    void setFilterTree(FilterTree *_filterTree);
+    void setIsToken(FilterBool _isToken)
+    {
+        isToken = _isToken;
+        emit modelDirty();
+        dirty();
+    }
+
+    void setCardName(const QString &_cardName)
+    {
+        if (filterString != nullptr) {
+            delete filterString;
+            filterString = nullptr;
+        }
+        cardName = sanitizeCardName(_cardName, characterTranslation);
+        emit modelDirty();
+        dirty();
+    }
+    void setStringFilter(const QString &_src)
+    {
+        delete filterString;
+        filterString = new FilterString(_src);
+        emit modelDirty();
+        dirty();
+    }
+    void setCardNameSet(const QSet<QString> &_cardNameSet)
+    {
+        cardNameSet = _cardNameSet;
+        emit modelDirty();
+        dirty();
+    }
+
+    void dirty()
+    {
+        dirtyTimer.start(20);
+    }
+    void clearFilterAll();
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    bool canFetchMore(const QModelIndex &parent) const override;
+    void fetchMore(const QModelIndex &parent) override;
+signals:
+    void modelDirty();
+
+protected:
+    bool lessThan(const QModelIndex &left, const QModelIndex &right) const override;
+    static int lessThanNumerically(const QString &left, const QString &right);
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+    bool rowMatchesCardName(CardInfoPtr info) const;
+
+private slots:
+    void filterTreeChanged();
+    /** Will translate all undesirable characters in DIRTYNAME according to the TABLE. */
+    const QString sanitizeCardName(const QString &dirtyName, const QMap<wchar_t, wchar_t> &table);
+};
+
+#endif // COCKATRICE_CARD_DATABASE_DISPLAY_MODEL_H

cockatrice/src/database/model/card_database_model.cpp

@@ -0,0 +1,146 @@
+#include "card_database_model.h"
+
+#include <QMap>
+
+#define CARDDBMODEL_COLUMNS 6
+
+CardDatabaseModel::CardDatabaseModel(CardDatabase *_db, bool _showOnlyCardsFromEnabledSets, QObject *parent)
+    : QAbstractListModel(parent), db(_db), showOnlyCardsFromEnabledSets(_showOnlyCardsFromEnabledSets)
+{
+    connect(db, &CardDatabase::cardAdded, this, &CardDatabaseModel::cardAdded);
+    connect(db, &CardDatabase::cardRemoved, this, &CardDatabaseModel::cardRemoved);
+    connect(db, &CardDatabase::cardDatabaseEnabledSetsChanged, this,
+            &CardDatabaseModel::cardDatabaseEnabledSetsChanged);
+
+    cardDatabaseEnabledSetsChanged();
+}
+
+CardDatabaseModel::~CardDatabaseModel() = default;
+
+int CardDatabaseModel::rowCount(const QModelIndex & /*parent*/) const
+{
+    return cardList.size();
+}
+
+int CardDatabaseModel::columnCount(const QModelIndex & /*parent*/) const
+{
+    return CARDDBMODEL_COLUMNS;
+}
+
+QVariant CardDatabaseModel::data(const QModelIndex &index, int role) const
+{
+    if (!index.isValid() || index.row() >= cardList.size() || index.column() >= CARDDBMODEL_COLUMNS ||
+        (role != Qt::DisplayRole && role != SortRole))
+        return QVariant();
+
+    CardInfoPtr card = cardList.at(index.row());
+    switch (index.column()) {
+        case NameColumn:
+            return card->getName();
+        case SetListColumn:
+            return card->getSetsNames();
+        case ManaCostColumn:
+            return role == SortRole ? QString("%1%2").arg(card->getCmc(), 4, QChar('0')).arg(card->getManaCost())
+                                    : card->getManaCost();
+        case CardTypeColumn:
+            return card->getCardType();
+        case PTColumn:
+            return card->getPowTough();
+        case ColorColumn:
+            return card->getColors();
+        default:
+            return QVariant();
+    }
+}
+
+QVariant CardDatabaseModel::headerData(int section, Qt::Orientation orientation, int role) const
+{
+    if (role != Qt::DisplayRole)
+        return QVariant();
+    if (orientation != Qt::Horizontal)
+        return QVariant();
+    switch (section) {
+        case NameColumn:
+            return QString(tr("Name"));
+        case SetListColumn:
+            return QString(tr("Sets"));
+        case ManaCostColumn:
+            return QString(tr("Mana cost"));
+        case CardTypeColumn:
+            return QString(tr("Card type"));
+        case PTColumn:
+            return QString(tr("P/T"));
+        case ColorColumn:
+            return QString(tr("Color(s)"));
+        default:
+            return QVariant();
+    }
+}
+
+void CardDatabaseModel::cardInfoChanged(CardInfoPtr card)
+{
+    const int row = cardList.indexOf(card);
+    if (row == -1)
+        return;
+
+    emit dataChanged(index(row, 0), index(row, CARDDBMODEL_COLUMNS - 1));
+}
+
+bool CardDatabaseModel::checkCardHasAtLeastOneEnabledSet(CardInfoPtr card)
+{
+    if (!showOnlyCardsFromEnabledSets)
+        return true;
+
+    for (const auto &printings : card->getSets()) {
+        for (const auto &printing : printings) {
+            if (printing.getSet()->getEnabled())
+                return true;
+        }
+    }
+
+    return false;
+}
+
+void CardDatabaseModel::cardDatabaseEnabledSetsChanged()
+{
+    // remove all the cards no more present in at least one enabled set
+    for (const CardInfoPtr &card : cardList) {
+        if (!checkCardHasAtLeastOneEnabledSet(card)) {
+            cardRemoved(card);
+        }
+    }
+
+    // re-check all the card currently not shown, maybe their part of a newly-enabled set
+    for (const CardInfoPtr &card : db->getCardList()) {
+        if (!cardListSet.contains(card)) {
+            cardAdded(card);
+        }
+    }
+}
+
+void CardDatabaseModel::cardAdded(CardInfoPtr card)
+{
+    if (checkCardHasAtLeastOneEnabledSet(card)) {
+        // add the card if it's present in at least one enabled set
+        beginInsertRows(QModelIndex(), cardList.size(), cardList.size());
+        cardList.append(card);
+        cardListSet.insert(card);
+        connect(card.data(), &CardInfo::cardInfoChanged, this, &CardDatabaseModel::cardInfoChanged);
+        endInsertRows();
+    }
+}
+
+void CardDatabaseModel::cardRemoved(CardInfoPtr card)
+{
+    const int row = cardList.indexOf(card);
+    if (row == -1) {
+        return;
+    }
+
+    beginRemoveRows(QModelIndex(), row, row);
+    disconnect(card.data(), nullptr, this, nullptr);
+    cardListSet.remove(card);
+    card.clear();
+    cardList.removeAt(row);
+    endRemoveRows();
+}

cockatrice/src/database/model/card_database_model.h

@@ -0,0 +1,56 @@
+#ifndef CARDDATABASEMODEL_H
+#define CARDDATABASEMODEL_H
+
+#include "../card_database.h"
+
+#include <QAbstractListModel>
+#include <QList>
+#include <QSet>
+
+class CardDatabaseModel : public QAbstractListModel
+{
+    Q_OBJECT
+public:
+    enum Columns
+    {
+        NameColumn,
+        SetListColumn,
+        ManaCostColumn,
+        PTColumn,
+        CardTypeColumn,
+        ColorColumn
+    };
+    enum Role
+    {
+        SortRole = Qt::UserRole
+    };
+    CardDatabaseModel(CardDatabase *_db, bool _showOnlyCardsFromEnabledSets, QObject *parent = nullptr);
+    ~CardDatabaseModel() override;
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+    int columnCount(const QModelIndex &parent = QModelIndex()) const override;
+    QVariant data(const QModelIndex &index, int role) const override;
+    QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const override;
+    CardDatabase *getDatabase() const
+    {
+        return db;
+    }
+    CardInfoPtr getCard(int index) const
+    {
+        return cardList[index];
+    }
+
+private:
+    QList<CardInfoPtr> cardList;
+    QSet<CardInfoPtr> cardListSet; // Supports faster lookups in cardDatabaseEnabledSetsChanged()
+    CardDatabase *db;
+    bool showOnlyCardsFromEnabledSets;
+
+    inline bool checkCardHasAtLeastOneEnabledSet(CardInfoPtr card);
+private slots:
+    void cardAdded(CardInfoPtr card);
+    void cardRemoved(CardInfoPtr card);
+    void cardInfoChanged(CardInfoPtr card);
+    void cardDatabaseEnabledSetsChanged();
+};
+
+#endif

cockatrice/src/database/model/token/token_display_model.cpp

@@ -0,0 +1,19 @@
+#include "token_display_model.h"
+
+#include "../card_database_model.h"
+
+TokenDisplayModel::TokenDisplayModel(QObject *parent) : CardDatabaseDisplayModel(parent)
+{
+}
+
+bool TokenDisplayModel::filterAcceptsRow(int sourceRow, const QModelIndex & /*sourceParent*/) const
+{
+    CardInfoPtr info = static_cast<CardDatabaseModel *>(sourceModel())->getCard(sourceRow);
+    return info->getIsToken() && rowMatchesCardName(info);
+}
+
+int TokenDisplayModel::rowCount(const QModelIndex &parent) const
+{
+    // always load all tokens at start
+    return QSortFilterProxyModel::rowCount(parent);
+}

cockatrice/src/database/model/token/token_display_model.h

@@ -0,0 +1,17 @@
+#ifndef COCKATRICE_TOKEN_DISPLAY_MODEL_H
+#define COCKATRICE_TOKEN_DISPLAY_MODEL_H
+
+#include "../card_database_display_model.h"
+
+class TokenDisplayModel : public CardDatabaseDisplayModel
+{
+    Q_OBJECT
+public:
+    explicit TokenDisplayModel(QObject *parent = nullptr);
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+protected:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+};
+
+#endif // COCKATRICE_TOKEN_DISPLAY_MODEL_H

cockatrice/src/database/model/token/token_edit_model.cpp

@@ -0,0 +1,19 @@
+#include "token_edit_model.h"
+
+#include "../card_database_model.h"
+
+TokenEditModel::TokenEditModel(QObject *parent) : CardDatabaseDisplayModel(parent)
+{
+}
+
+bool TokenEditModel::filterAcceptsRow(int sourceRow, const QModelIndex & /*sourceParent*/) const
+{
+    CardInfoPtr info = static_cast<CardDatabaseModel *>(sourceModel())->getCard(sourceRow);
+    return info->getIsToken() && info->getSets().contains(CardSet::TOKENS_SETNAME) && rowMatchesCardName(info);
+}
+
+int TokenEditModel::rowCount(const QModelIndex &parent) const
+{
+    // always load all tokens at start
+    return QSortFilterProxyModel::rowCount(parent);
+}

cockatrice/src/database/model/token/token_edit_model.h

@@ -0,0 +1,17 @@
+#ifndef COCKATRICE_TOKEN_EDIT_MODEL_H
+#define COCKATRICE_TOKEN_EDIT_MODEL_H
+
+#include "../card_database_display_model.h"
+
+class TokenEditModel : public CardDatabaseDisplayModel
+{
+    Q_OBJECT
+public:
+    explicit TokenEditModel(QObject *parent = nullptr);
+    int rowCount(const QModelIndex &parent = QModelIndex()) const override;
+
+protected:
+    bool filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const override;
+};
+
+#endif // COCKATRICE_TOKEN_EDIT_MODEL_H