deck_list_model.h

Go to the documentation of this file.

#ifndef DECKLISTMODEL_H
#define DECKLISTMODEL_H
 
#include "libcockatrice/card/card_info.h"
#include "libcockatrice/deck_list/tree/inner_deck_list_node.h"
#include "libcockatrice/utility/card_ref.h"
 
#include <../../../../libcockatrice_deck_list/libcockatrice/deck_list/tree/abstract_deck_list_card_node.h>
#include <../../../../libcockatrice_deck_list/libcockatrice/deck_list/tree/deck_list_card_node.h>
#include <QAbstractItemModel>
#include <QList>
#include <QModelIndex>
#include <QSharedPointer>
#include <QString>
#include <QStringList>
#include <functional>
#include <qnamespace.h>
#include <qtmetamacros.h>
 
class AbstractDecklistNode;
class DeckList;
class ExactCard;
class QObject;

namespace DeckRoles
{
enum
{
    IsCardRole = Qt::UserRole + 1, 
    DepthRole,                     
    IsLegalRole,                   
    IsCustomZoneRole               
};
} // namespace DeckRoles

namespace DeckListModelColumns
{
enum
{
    CARD_AMOUNT = 0,           
    CARD_NAME = 1,             
    CARD_SET = 2,              
    CARD_COLLECTOR_NUMBER = 3, 
    CARD_PROVIDER_ID = 4       
};
} // namespace DeckListModelColumns

namespace DeckListModelGroupCriteria
{
enum Type
{
    MAIN_TYPE, 
    MANA_COST, 
    COLOR      
};
static inline QString toString(Type t)
{
    switch (t) {
        case MAIN_TYPE:
            return "Main Type";
        case MANA_COST:
            return "Mana Cost";
        case COLOR:
            return "Colors";
    }
    return {};
}
 
static inline Type fromString(const QString &s)
{
    if (s == "Main Type") {
        return MAIN_TYPE;
    }
    if (s == "Mana Cost") {
        return MANA_COST;
    }
    if (s == "Colors") {
        return COLOR;
    }
    return MAIN_TYPE; // default
}
} // namespace DeckListModelGroupCriteria

class DecklistModelCardNode : public AbstractDecklistCardNode
{
private:
    DecklistCardNode *dataNode; 
 
public:
    DecklistModelCardNode(DecklistCardNode *_dataNode, InnerDecklistNode *_parent, int position = -1)
        : AbstractDecklistCardNode(_parent, position), dataNode(_dataNode)
    {
    }
    [[nodiscard]] int getNumber() const override
    {
        return dataNode->getNumber();
    }
    void setNumber(int _number) override
    {
        dataNode->setNumber(_number);
    }
    [[nodiscard]] QString getName() const override
    {
        return dataNode->getName();
    }
    void setName(const QString &_name) override
    {
        dataNode->setName(_name);
    }
    [[nodiscard]] QString getCardProviderId() const override
    {
        return dataNode->getCardProviderId();
    }
    void setCardProviderId(const QString &_cardProviderId) override
    {
        dataNode->setCardProviderId(_cardProviderId);
    }
    [[nodiscard]] QString getCardSetShortName() const override
    {
        return dataNode->getCardSetShortName();
    }
    void setCardSetShortName(const QString &_cardSetShortName) override
    {
        dataNode->setCardSetShortName(_cardSetShortName);
    }
    [[nodiscard]] QString getCardCollectorNumber() const override
    {
        return dataNode->getCardCollectorNumber();
    }
    void setCardCollectorNumber(const QString &_cardSetNumber) override
    {
        dataNode->setCardCollectorNumber(_cardSetNumber);
    }
    bool getFormatLegality() const override
    {
        return dataNode->getFormatLegality();
    }
    void setFormatLegality(const bool _formatLegal) override
    {
        dataNode->setFormatLegality(_formatLegal);
    }

    [[nodiscard]] DecklistCardNode *getDataNode() const
    {
        return dataNode;
    }
    [[nodiscard]] bool isDeckHeader() const override
    {
        return false;
    }
};

class DeckListModel : public QAbstractItemModel
{
    Q_OBJECT
 
public slots:
    void rebuildTree();

    void setActiveGroupCriteria(DeckListModelGroupCriteria::Type newCriteria);
 
    void setActiveFormat(const QString &_format);
 
signals:
    void deckHashChanged();

    void cardsChanged();

    void cardAddedAt(const QModelIndex &index);

    void cardRemoved();

    void cardNodesChanged();

    void cardNodeAddedAt(const QModelIndex &index);

    void cardNodeRemoved();

    void deckReplaced();
 
public:
    explicit DeckListModel(QObject *parent = nullptr);
    explicit DeckListModel(QObject *parent, const QSharedPointer<DeckList> &deckList);
    ~DeckListModel() override;

    void setDisplayLanguage(const QString &lang);

    [[nodiscard]] QModelIndex getRoot() const
    {
        return nodeToIndex(root);
    }

    [[nodiscard]] int rowCount(const QModelIndex &parent) const override;
    [[nodiscard]] int columnCount(const QModelIndex & /*parent*/ = QModelIndex()) const override;
    [[nodiscard]] QVariant data(const QModelIndex &index, int role) const override;
    [[nodiscard]] QVariant headerData(int section, Qt::Orientation orientation, int role) const override;
    [[nodiscard]] QModelIndex index(int row, int column, const QModelIndex &parent) const override;
    [[nodiscard]] QModelIndex parent(const QModelIndex &index) const override;
    [[nodiscard]] Qt::ItemFlags flags(const QModelIndex &index) const override;
    bool setData(const QModelIndex &index, const QVariant &value, int role) override;
    bool removeRows(int row, int count, const QModelIndex &parent) override;
    void sort(int column, Qt::SortOrder order) override;

    [[nodiscard]] QModelIndex findCard(const QString &cardName,
                                       const QString &zoneName,
                                       const QString &providerId = "",
                                       const QString &cardNumber = "") const;

    QModelIndex addPreferredPrintingCard(const QString &cardName, const QString &zoneName, bool abAddAnyway);

    QModelIndex addCard(const ExactCard &card, const QString &zoneName);

    bool offsetCountAtIndex(const QModelIndex &idx, int offset);

    bool removeCardAtIndex(const QModelIndex &idx);

    void cleanList();
 
    [[nodiscard]] QSharedPointer<DeckList> getDeckList() const
    {
        return deckList;
    }
    void setDeckList(const QSharedPointer<DeckList> &_deck);

    void forEachCard(const std::function<void(InnerDecklistNode *, DecklistCardNode *)> &func);

    [[nodiscard]] QList<const DecklistCardNode *> getCardNodes() const;
    [[nodiscard]] QList<const DecklistCardNode *> getCardNodesForZone(const QString &zoneName) const;

    [[nodiscard]] QList<QString> getCardNames() const;
    [[nodiscard]] QList<CardRef> getCardRefs() const;
    [[nodiscard]] QList<QString> getZones() const;

    [[nodiscard]] QStringList getCustomZoneNames(const QString &boardZoneName) const;
 
private:
    QSharedPointer<DeckList> deckList; 
    InnerDecklistNode *root;           
    DeckListModelGroupCriteria::Type activeGroupCriteria = DeckListModelGroupCriteria::MAIN_TYPE;
    int lastKnownColumn;          
    Qt::SortOrder lastKnownOrder; 
    QString displayLang = "en";   
 
    InnerDecklistNode *createNodeIfNeeded(const QString &name, InnerDecklistNode *parent);
    QModelIndex nodeToIndex(AbstractDecklistNode *node) const;
    [[nodiscard]] DecklistModelCardNode *findCardNode(const QString &cardName,
                                                      const QString &zoneName,
                                                      const QString &providerId = "",
                                                      const QString &cardNumber = "") const;

    int findSortedInsertRow(const InnerDecklistNode *parent, const CardInfoPtr &cardInfo) const;

    void emitBackgroundUpdates(const QModelIndex &parent);

    void emitRecursiveUpdates(const QModelIndex &index);
 
    void sortHelper(InnerDecklistNode *node, Qt::SortOrder order);
    void sortShadowTree(InnerDecklistNode *node, Qt::SortOrder order);
 
    template <typename T> T getNode(const QModelIndex &index) const
    {
        if (!index.isValid()) {
            return dynamic_cast<T>(root);
        }
        return dynamic_cast<T>(static_cast<AbstractDecklistNode *>(index.internalPointer()));
    }
 
    void refreshCardFormatLegalities();
};
 
#endif