Deck loader is a gui class.

Took 31 minutes

Took 3 minutes

cockatrice/src/interface/deck_loader/deck_loader.cpp

@@ -0,0 +1,605 @@
+#include "deck_loader.h"
+
+#include <QApplication>
+#include <QClipboard>
+#include <QDebug>
+#include <QDir>
+#include <QFile>
+#include <QFileInfo>
+#include <QFutureWatcher>
+#include <QRegularExpression>
+#include <QStringList>
+#include <QtConcurrentRun>
+#include <libcockatrice/card/database/card_database.h>
+#include <libcockatrice/card/database/card_database_manager.h>
+#include <libcockatrice/deck_list/deck_list.h>
+#include <libcockatrice/deck_list/deck_list_card_node.h>
+
+const QStringList DeckLoader::ACCEPTED_FILE_EXTENSIONS = {"*.cod", "*.dec", "*.dek", "*.txt", "*.mwDeck"};
+
+const QStringList DeckLoader::FILE_NAME_FILTERS = {
+    tr("Common deck formats (%1)").arg(ACCEPTED_FILE_EXTENSIONS.join(" ")), tr("All files (*.*)")};
+
+DeckLoader::DeckLoader() : DeckList(), lastFileName(QString()), lastFileFormat(CockatriceFormat), lastRemoteDeckId(-1)
+{
+}
+
+DeckLoader::DeckLoader(const QString &nativeString)
+    : DeckList(nativeString), lastFileName(QString()), lastFileFormat(CockatriceFormat), lastRemoteDeckId(-1)
+{
+}
+
+DeckLoader::DeckLoader(const DeckList &other)
+    : DeckList(other), lastFileName(QString()), lastFileFormat(CockatriceFormat), lastRemoteDeckId(-1)
+{
+}
+
+DeckLoader::DeckLoader(const DeckLoader &other)
+    : DeckList(other), lastFileName(other.lastFileName), lastFileFormat(other.lastFileFormat),
+      lastRemoteDeckId(other.lastRemoteDeckId)
+{
+}
+
+bool DeckLoader::loadFromFile(const QString &fileName, FileFormat fmt, bool userRequest)
+{
+    QFile file(fileName);
+    if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+        return false;
+    }
+
+    bool result = false;
+    switch (fmt) {
+        case PlainTextFormat:
+            result = loadFromFile_Plain(&file);
+            break;
+        case CockatriceFormat: {
+            result = loadFromFile_Native(&file);
+            qCInfo(DeckLoaderLog) << "Loaded from" << fileName << "-" << result;
+            if (!result) {
+                qCInfo(DeckLoaderLog) << "Retrying as plain format";
+                file.seek(0);
+                result = loadFromFile_Plain(&file);
+                fmt = PlainTextFormat;
+            }
+            break;
+        }
+
+        default:
+            break;
+    }
+
+    if (result) {
+        lastFileName = fileName;
+        lastFileFormat = fmt;
+        if (userRequest) {
+            updateLastLoadedTimestamp(fileName, fmt);
+        }
+
+        emit deckLoaded();
+    }
+
+    qCInfo(DeckLoaderLog) << "Deck was loaded -" << result;
+    return result;
+}
+
+bool DeckLoader::loadFromFileAsync(const QString &fileName, FileFormat fmt, bool userRequest)
+{
+    auto *watcher = new QFutureWatcher<bool>(this);
+
+    connect(watcher, &QFutureWatcher<bool>::finished, this, [this, watcher, fileName, fmt, userRequest]() {
+        const bool result = watcher->result();
+        watcher->deleteLater();
+
+        if (result) {
+            lastFileName = fileName;
+            lastFileFormat = fmt;
+            if (userRequest) {
+                updateLastLoadedTimestamp(fileName, fmt);
+            }
+            emit deckLoaded();
+        }
+
+        emit loadFinished(result);
+    });
+
+    QFuture<bool> future = QtConcurrent::run([=, this]() {
+        QFile file(fileName);
+        if (!file.open(QIODevice::ReadOnly | QIODevice::Text)) {
+            return false;
+        }
+
+        switch (fmt) {
+            case PlainTextFormat:
+                return loadFromFile_Plain(&file);
+            case CockatriceFormat: {
+                bool result = false;
+                result = loadFromFile_Native(&file);
+                if (!result) {
+                    file.seek(0);
+                    return loadFromFile_Plain(&file);
+                }
+                return result;
+            }
+            default:
+                return false;
+                break;
+        }
+    });
+
+    watcher->setFuture(future);
+    return true; // Return immediately to indicate the async task was started
+}
+
+bool DeckLoader::loadFromRemote(const QString &nativeString, int remoteDeckId)
+{
+    bool result = loadFromString_Native(nativeString);
+    if (result) {
+        lastFileName = QString();
+        lastFileFormat = CockatriceFormat;
+        lastRemoteDeckId = remoteDeckId;
+
+        emit deckLoaded();
+    }
+    return result;
+}
+
+bool DeckLoader::saveToFile(const QString &fileName, FileFormat fmt)
+{
+    QFile file(fileName);
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        return false;
+    }
+
+    bool result = false;
+    switch (fmt) {
+        case PlainTextFormat:
+            result = saveToFile_Plain(&file);
+            break;
+        case CockatriceFormat:
+            result = saveToFile_Native(&file);
+            break;
+    }
+
+    if (result) {
+        lastFileName = fileName;
+        lastFileFormat = fmt;
+    }
+
+    file.flush();
+    file.close();
+
+    return result;
+}
+
+bool DeckLoader::updateLastLoadedTimestamp(const QString &fileName, FileFormat fmt)
+{
+    QFileInfo fileInfo(fileName);
+    if (!fileInfo.exists()) {
+        qCWarning(DeckLoaderLog) << "File does not exist:" << fileName;
+        return false;
+    }
+
+    QDateTime originalTimestamp = fileInfo.lastModified();
+
+    // Open the file for writing
+    QFile file(fileName);
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        qCWarning(DeckLoaderLog) << "Failed to open file for writing:" << fileName;
+        return false;
+    }
+
+    bool result = false;
+
+    // Perform file modifications
+    switch (fmt) {
+        case PlainTextFormat:
+            result = saveToFile_Plain(&file);
+            break;
+        case CockatriceFormat:
+            setLastLoadedTimestamp(QDateTime::currentDateTime().toString());
+            result = saveToFile_Native(&file);
+            break;
+    }
+
+    file.close(); // Close the file to ensure changes are flushed
+
+    if (result) {
+        lastFileName = fileName;
+        lastFileFormat = fmt;
+
+        // Re-open the file and set the original timestamp
+        if (!file.open(QIODevice::ReadWrite)) {
+            qCWarning(DeckLoaderLog) << "Failed to re-open file to set timestamp:" << fileName;
+            return false;
+        }
+
+        if (!file.setFileTime(originalTimestamp, QFileDevice::FileModificationTime)) {
+            qCWarning(DeckLoaderLog) << "Failed to set modification time for file:" << fileName;
+            file.close();
+            return false;
+        }
+
+        file.close();
+    }
+
+    return result;
+}
+
+static QString getDomainForWebsite(DeckLoader::DecklistWebsite website)
+{
+    switch (website) {
+        case DeckLoader::DecklistOrg:
+            return "www.decklist.org";
+        case DeckLoader::DecklistXyz:
+            return "www.decklist.xyz";
+        default:
+            qCWarning(DeckLoaderLog) << "Invalid decklist website enum:" << website;
+            return "";
+    }
+}
+
+/**
+ * Converts the card to the String that represents it in the decklist export
+ */
+static QString toDecklistExportString(const DecklistCardNode *card)
+{
+    QString cardString;
+    // Get the number of cards and add the card name
+    cardString += QString::number(card->getNumber());
+    // Add a space between card num and name
+    cardString += "%20";
+    // Add card name
+    cardString += card->getName();
+
+    if (!card->getCardSetShortName().isNull()) {
+        cardString += "%20";
+        cardString += "(" + card->getCardSetShortName() + ")";
+    }
+    if (!card->getCardCollectorNumber().isNull()) {
+        cardString += "%20";
+        cardString += card->getCardCollectorNumber();
+    }
+
+    // Add a return at the end of the card
+    cardString += "%0A";
+
+    return cardString;
+}
+
+/**
+ * Export deck to decklist function, called to format the deck in a way to be sent to a server
+ * @param website The website we're sending the deck to
+ */
+QString DeckLoader::exportDeckToDecklist(DecklistWebsite website)
+{
+    // Add the base url
+    QString deckString = "https://" + getDomainForWebsite(website) + "/?";
+    // Create two strings to pass to function
+    QString mainBoardCards, sideBoardCards;
+
+    // Set up the function to call
+    auto formatDeckListForExport = [&mainBoardCards, &sideBoardCards](const auto *node, const auto *card) {
+        // Get the card name
+        CardInfoPtr dbCard = CardDatabaseManager::query()->getCardInfo(card->getName());
+        if (!dbCard || dbCard->getIsToken()) {
+            // If it's a token, we don't care about the card.
+            return;
+        }
+
+        // Check if it's a sideboard card.
+        if (node->getName() == DECK_ZONE_SIDE) {
+            sideBoardCards += toDecklistExportString(card);
+        } else {
+            // If it's a mainboard card, do the same thing, but for the mainboard card string
+            mainBoardCards += toDecklistExportString(card);
+        }
+    };
+
+    // call our struct function for each card in the deck
+    forEachCard(formatDeckListForExport);
+    // Remove the extra return at the end of the last cards
+    mainBoardCards.chop(3);
+    sideBoardCards.chop(3);
+    // if after we've called it for each card, and the strings are empty, we know that
+    // there were no non-token cards in the deck, so show an error message.
+    if ((QString::compare(mainBoardCards, "", Qt::CaseInsensitive) == 0) &&
+        (QString::compare(sideBoardCards, "", Qt::CaseInsensitive) == 0)) {
+        return "";
+    }
+    // return a string with the url for decklist export
+    deckString += "deckmain=" + mainBoardCards + "&deckside=" + sideBoardCards;
+    return deckString;
+}
+
+// This struct is here to support the forEachCard function call, defined in decklist.
+// It requires a function to be called for each card, and it will set the providerId to the preferred printing.
+struct SetProviderIdToPreferred
+{
+    // Main operator for struct, allowing the foreachcard to work.
+    SetProviderIdToPreferred()
+    {
+    }
+
+    void operator()(const InnerDecklistNode *node, DecklistCardNode *card) const
+    {
+        Q_UNUSED(node);
+        PrintingInfo preferredPrinting = CardDatabaseManager::query()->getPreferredPrinting(card->getName());
+        QString providerId = preferredPrinting.getUuid();
+        QString setShortName = preferredPrinting.getSet()->getShortName();
+        QString collectorNumber = preferredPrinting.getProperty("num");
+
+        card->setCardProviderId(providerId);
+        card->setCardCollectorNumber(collectorNumber);
+        card->setCardSetShortName(setShortName);
+    }
+};
+
+/**
+ * This function iterates through each card in the decklist and sets the providerId
+ * on each card based on its set name and collector number.
+ */
+void DeckLoader::setProviderIdToPreferredPrinting()
+{
+    // Set up the struct to call.
+    SetProviderIdToPreferred setProviderIdToPreferred;
+
+    // Call the forEachCard method for each card in the deck
+    forEachCard(setProviderIdToPreferred);
+}
+
+/**
+ * Sets the providerId on each card in the decklist based on its set name and collector number.
+ */
+void DeckLoader::resolveSetNameAndNumberToProviderID()
+{
+    auto setProviderId = [](const auto node, const auto card) {
+        Q_UNUSED(node);
+        // Retrieve the providerId based on setName and collectorNumber
+        QString providerId =
+            CardDatabaseManager::getInstance()
+                ->query()
+                ->getSpecificPrinting(card->getName(), card->getCardSetShortName(), card->getCardCollectorNumber())
+                .getUuid();
+
+        // Set the providerId on the card
+        card->setCardProviderId(providerId);
+    };
+
+    forEachCard(setProviderId);
+}
+
+// This struct is here to support the forEachCard function call, defined in decklist.
+// It requires a function to be called for each card, and it will set the providerId.
+struct ClearSetNameNumberAndProviderId
+{
+    // Main operator for struct, allowing the foreachcard to work.
+    ClearSetNameNumberAndProviderId()
+    {
+    }
+
+    void operator()(const InnerDecklistNode *node, DecklistCardNode *card) const
+    {
+        Q_UNUSED(node);
+        // Set the providerId on the card
+        card->setCardSetShortName(nullptr);
+        card->setCardCollectorNumber(nullptr);
+        card->setCardProviderId(nullptr);
+    }
+};
+
+/**
+ * Clears the set name and numbers on each card in the decklist.
+ */
+void DeckLoader::clearSetNamesAndNumbers()
+{
+    auto clearSetNameAndNumber = [](const auto node, auto card) {
+        Q_UNUSED(node)
+        // Set the providerId on the card
+        card->setCardSetShortName(nullptr);
+        card->setCardCollectorNumber(nullptr);
+        card->setCardProviderId(nullptr);
+    };
+
+    forEachCard(clearSetNameAndNumber);
+}
+
+DeckLoader::FileFormat DeckLoader::getFormatFromName(const QString &fileName)
+{
+    if (fileName.endsWith(".cod", Qt::CaseInsensitive)) {
+        return CockatriceFormat;
+    }
+    return PlainTextFormat;
+}
+
+void DeckLoader::saveToClipboard(bool addComments, bool addSetNameAndNumber) const
+{
+    QString buffer;
+    QTextStream stream(&buffer);
+    saveToStream_Plain(stream, addComments, addSetNameAndNumber);
+    QApplication::clipboard()->setText(buffer, QClipboard::Clipboard);
+    QApplication::clipboard()->setText(buffer, QClipboard::Selection);
+}
+
+bool DeckLoader::saveToStream_Plain(QTextStream &out, bool addComments, bool addSetNameAndNumber) const
+{
+    if (addComments) {
+        saveToStream_DeckHeader(out);
+    }
+
+    // loop zones
+    for (int i = 0; i < getRoot()->size(); i++) {
+        const auto *zoneNode = dynamic_cast<InnerDecklistNode *>(getRoot()->at(i));
+
+        saveToStream_DeckZone(out, zoneNode, addComments, addSetNameAndNumber);
+
+        // end of zone
+        out << "\n";
+    }
+
+    return true;
+}
+
+void DeckLoader::saveToStream_DeckHeader(QTextStream &out) const
+{
+    if (!getName().isEmpty()) {
+        out << "// " << getName() << "\n\n";
+    }
+
+    if (!getComments().isEmpty()) {
+        QStringList commentRows = getComments().split(QRegularExpression("\n|\r\n|\r"));
+        for (const QString &row : commentRows) {
+            out << "// " << row << "\n";
+        }
+        out << "\n";
+    }
+}
+
+void DeckLoader::saveToStream_DeckZone(QTextStream &out,
+                                       const InnerDecklistNode *zoneNode,
+                                       bool addComments,
+                                       bool addSetNameAndNumber) const
+{
+    // group cards by card type and count the subtotals
+    QMultiMap<QString, DecklistCardNode *> cardsByType;
+    QMap<QString, int> cardTotalByType;
+    int cardTotal = 0;
+
+    for (int j = 0; j < zoneNode->size(); j++) {
+        auto *card = dynamic_cast<DecklistCardNode *>(zoneNode->at(j));
+
+        CardInfoPtr info = CardDatabaseManager::query()->getCardInfo(card->getName());
+        QString cardType = info ? info->getMainCardType() : "unknown";
+
+        cardsByType.insert(cardType, card);
+
+        if (cardTotalByType.contains(cardType)) {
+            cardTotalByType[cardType] += card->getNumber();
+        } else {
+            cardTotalByType[cardType] = card->getNumber();
+        }
+
+        cardTotal += card->getNumber();
+    }
+
+    if (addComments) {
+        out << "// " << cardTotal << " " << zoneNode->getVisibleName() << "\n";
+    }
+
+    // print cards to stream
+    for (const QString &cardType : cardsByType.uniqueKeys()) {
+        if (addComments) {
+            out << "// " << cardTotalByType[cardType] << " " << cardType << "\n";
+        }
+
+        QList<DecklistCardNode *> cards = cardsByType.values(cardType);
+
+        saveToStream_DeckZoneCards(out, zoneNode, cards, addComments, addSetNameAndNumber);
+
+        if (addComments) {
+            out << "\n";
+        }
+    }
+}
+
+void DeckLoader::saveToStream_DeckZoneCards(QTextStream &out,
+                                            const InnerDecklistNode *zoneNode,
+                                            QList<DecklistCardNode *> cards,
+                                            bool addComments,
+                                            bool addSetNameAndNumber) const
+{
+    // QMultiMap sorts values in reverse order
+    for (int i = cards.size() - 1; i >= 0; --i) {
+        DecklistCardNode *card = cards[i];
+
+        if (zoneNode->getName() == DECK_ZONE_SIDE && addComments) {
+            out << "SB: ";
+        }
+
+        if (card->getNumber()) {
+            out << card->getNumber();
+        }
+        if (!card->getName().isNull() && !card->getName().isEmpty()) {
+            out << " " << card->getName();
+        }
+        if (addSetNameAndNumber) {
+            if (!card->getCardSetShortName().isNull() && !card->getCardSetShortName().isEmpty()) {
+                out << " "
+                    << "(" << card->getCardSetShortName() << ")";
+            }
+            if (!card->getCardCollectorNumber().isNull()) {
+                out << " " << card->getCardCollectorNumber();
+            }
+        }
+        out << "\n";
+    }
+}
+
+bool DeckLoader::convertToCockatriceFormat(QString fileName)
+{
+    // Change the file extension to .cod
+    QFileInfo fileInfo(fileName);
+    QString newFileName = QDir::toNativeSeparators(fileInfo.path() + "/" + fileInfo.completeBaseName() + ".cod");
+
+    // Open the new file for writing
+    QFile file(newFileName);
+    if (!file.open(QIODevice::WriteOnly | QIODevice::Text)) {
+        qCWarning(DeckLoaderLog) << "Failed to open file for writing:" << newFileName;
+        return false;
+    }
+
+    bool result = false;
+
+    // Perform file modifications based on the detected format
+    switch (getFormatFromName(fileName)) {
+        case PlainTextFormat:
+            // Save in Cockatrice's native format
+            result = saveToFile_Native(&file);
+            break;
+        case CockatriceFormat:
+            qCInfo(DeckLoaderLog) << "File is already in Cockatrice format. No conversion needed.";
+            result = true;
+            break;
+        default:
+            qCWarning(DeckLoaderLog) << "Unsupported file format for conversion:" << fileName;
+            result = false;
+            break;
+    }
+
+    file.close();
+
+    // Delete the old file if conversion was successful
+    if (result) {
+        if (!QFile::remove(fileName)) {
+            qCWarning(DeckLoaderLog) << "Failed to delete original file:" << fileName;
+        } else {
+            qCInfo(DeckLoaderLog) << "Original file deleted successfully:" << fileName;
+        }
+        lastFileName = newFileName;
+        lastFileFormat = CockatriceFormat;
+    }
+
+    return result;
+}
+
+QString DeckLoader::getCardZoneFromName(QString cardName, QString currentZoneName)
+{
+    CardInfoPtr card = CardDatabaseManager::query()->getCardInfo(cardName);
+
+    if (card && card->getIsToken()) {
+        return DECK_ZONE_TOKENS;
+    }
+
+    return currentZoneName;
+}
+
+QString DeckLoader::getCompleteCardName(const QString &cardName) const
+{
+    if (CardDatabaseManager::getInstance()) {
+        ExactCard temp = CardDatabaseManager::query()->guessCard({cardName});
+        if (temp) {
+            return temp.getName();
+        }
+    }
+
+    return cardName;
+}

cockatrice/src/interface/deck_loader/deck_loader.h

@@ -0,0 +1,111 @@
+/**
+ * @file deck_loader.h
+ * @ingroup ImportExport
+ * @brief TODO: Document this.
+ */
+
+#ifndef DECK_LOADER_H
+#define DECK_LOADER_H
+
+#include <QLoggingCategory>
+#include <libcockatrice/deck_list/deck_list.h>
+
+inline Q_LOGGING_CATEGORY(DeckLoaderLog, "deck_loader")
+
+    class DeckLoader : public DeckList
+{
+    Q_OBJECT
+signals:
+    void deckLoaded();
+    void loadFinished(bool success);
+
+public:
+    enum FileFormat
+    {
+        PlainTextFormat,
+        CockatriceFormat
+    };
+
+    /**
+     * Supported file extensions for decklist files
+     */
+    static const QStringList ACCEPTED_FILE_EXTENSIONS;
+
+    /**
+     * For use with `QFileDialog::setNameFilters`
+     */
+    static const QStringList FILE_NAME_FILTERS;
+
+    enum DecklistWebsite
+    {
+        DecklistOrg,
+        DecklistXyz
+    };
+
+private:
+    QString lastFileName;
+    FileFormat lastFileFormat;
+    int lastRemoteDeckId;
+
+public:
+    DeckLoader();
+    explicit DeckLoader(const QString &nativeString);
+    explicit DeckLoader(const DeckList &other);
+    DeckLoader(const DeckLoader &other);
+    const QString &getLastFileName() const
+    {
+        return lastFileName;
+    }
+    void setLastFileName(const QString &_lastFileName)
+    {
+        lastFileName = _lastFileName;
+    }
+    FileFormat getLastFileFormat() const
+    {
+        return lastFileFormat;
+    }
+    int getLastRemoteDeckId() const
+    {
+        return lastRemoteDeckId;
+    }
+
+    bool hasNotBeenLoaded() const
+    {
+        return getLastFileName().isEmpty() && getLastRemoteDeckId() == -1;
+    }
+
+    void clearSetNamesAndNumbers();
+    static FileFormat getFormatFromName(const QString &fileName);
+
+    bool loadFromFile(const QString &fileName, FileFormat fmt, bool userRequest = false);
+    bool loadFromFileAsync(const QString &fileName, FileFormat fmt, bool userRequest);
+    bool loadFromRemote(const QString &nativeString, int remoteDeckId);
+    bool saveToFile(const QString &fileName, FileFormat fmt);
+    bool updateLastLoadedTimestamp(const QString &fileName, FileFormat fmt);
+    QString exportDeckToDecklist(DecklistWebsite website);
+    void setProviderIdToPreferredPrinting();
+
+    void resolveSetNameAndNumberToProviderID();
+
+    void saveToClipboard(bool addComments = true, bool addSetNameAndNumber = true) const;
+
+    // overload
+    bool saveToStream_Plain(QTextStream &out, bool addComments = true, bool addSetNameAndNumber = true) const;
+    bool convertToCockatriceFormat(QString fileName);
+
+protected:
+    void saveToStream_DeckHeader(QTextStream &out) const;
+    void saveToStream_DeckZone(QTextStream &out,
+                               const InnerDecklistNode *zoneNode,
+                               bool addComments = true,
+                               bool addSetNameAndNumber = true) const;
+    void saveToStream_DeckZoneCards(QTextStream &out,
+                                    const InnerDecklistNode *zoneNode,
+                                    QList<DecklistCardNode *> cards,
+                                    bool addComments = true,
+                                    bool addSetNameAndNumber = true) const;
+    [[nodiscard]] QString getCardZoneFromName(QString cardName, QString currentZoneName) override;
+    [[nodiscard]] QString getCompleteCardName(const QString &cardName) const override;
+};
+
+#endif

cockatrice/src/interface/widgets/deck_analytics/mana_base_widget.cpp

@@ -1,5 +1,6 @@
 #include "mana_base_widget.h"
 
+#include "../../deck_loader/deck_loader.h"
 #include "../general/display/banner_widget.h"
 #include "../general/display/bar_widget.h"
 
@@ -8,7 +9,6 @@
 #include <libcockatrice/card/database/card_database.h>
 #include <libcockatrice/card/database/card_database_manager.h>
 #include <libcockatrice/deck_list/deck_list.h>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 
 ManaBaseWidget::ManaBaseWidget(QWidget *parent, DeckListModel *_deckListModel)
     : QWidget(parent), deckListModel(_deckListModel)

cockatrice/src/interface/widgets/deck_analytics/mana_curve_widget.cpp

@@ -1,13 +1,13 @@
 #include "mana_curve_widget.h"
 
 #include "../../../main.h"
+#include "../../deck_loader/deck_loader.h"
 #include "../general/display/banner_widget.h"
 #include "../general/display/bar_widget.h"
 
 #include <libcockatrice/card/database/card_database.h>
 #include <libcockatrice/card/database/card_database_manager.h>
 #include <libcockatrice/deck_list/deck_list.h>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 #include <unordered_map>
 
 ManaCurveWidget::ManaCurveWidget(QWidget *parent, DeckListModel *_deckListModel)

cockatrice/src/interface/widgets/deck_analytics/mana_devotion_widget.cpp

@@ -1,6 +1,7 @@
 #include "mana_devotion_widget.h"
 
 #include "../../../main.h"
+#include "../../deck_loader/deck_loader.h"
 #include "../general/display/banner_widget.h"
 #include "../general/display/bar_widget.h"
 
@@ -8,7 +9,6 @@
 #include <libcockatrice/card/database/card_database.h>
 #include <libcockatrice/card/database/card_database_manager.h>
 #include <libcockatrice/deck_list/deck_list.h>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 #include <regex>
 #include <string>
 #include <unordered_map>

cockatrice/src/interface/widgets/deck_editor/deck_editor_deck_dock_widget.cpp

@@ -1,6 +1,7 @@
 #include "deck_editor_deck_dock_widget.h"
 
 #include "../../../client/settings/cache_settings.h"
+#include "../../deck_loader/deck_loader.h"
 
 #include <QComboBox>
 #include <QDockWidget>
@@ -366,7 +367,11 @@ void DeckEditorDeckDockWidget::syncBannerCardComboBoxSelectionWithDeck()
  */
 void DeckEditorDeckDockWidget::setDeck(DeckLoader *_deck)
 {
-    deckModel->setDeckList(_deck);
+    deckLoader = _deck;
+
+    deckModel->setDeckList(qobject_cast<DeckList *>(_deck));
+    connect(_deck, &DeckLoader::deckLoaded, deckModel, &DeckListModel::rebuildTree);
+    connect(_deck, &DeckLoader::deckHashChanged, deckModel, &DeckListModel::deckHashChanged);
 
     nameEdit->setText(deckModel->getDeckList()->getName());
     commentsEdit->setText(deckModel->getDeckList()->getComments());
@@ -383,11 +388,16 @@ void DeckEditorDeckDockWidget::setDeck(DeckLoader *_deck)
     emit deckChanged();
 }
 
-DeckLoader *DeckEditorDeckDockWidget::getDeckList()
+DeckList *DeckEditorDeckDockWidget::getDeckList()
 {
     return deckModel->getDeckList();
 }
 
+DeckLoader *DeckEditorDeckDockWidget::getDeckLoader()
+{
+    return deckLoader;
+}
+
 /**
  * Resets the tab to the state for a blank new tab.
  */

cockatrice/src/interface/widgets/deck_editor/deck_editor_deck_dock_widget.h

@@ -27,6 +27,7 @@ class DeckEditorDeckDockWidget : public QDockWidget
     Q_OBJECT
 public:
     explicit DeckEditorDeckDockWidget(AbstractTabDeckEditor *parent);
+    DeckLoader *deckLoader;
     DeckListModel *deckModel;
     QTreeView *deckView;
     QComboBox *bannerCardComboBox;
@@ -50,7 +51,8 @@ public slots:
     void cleanDeck();
     void updateBannerCardComboBox();
     void setDeck(DeckLoader *_deck);
-    DeckLoader *getDeckList();
+    DeckList *getDeckList();
+    DeckLoader *getDeckLoader();
     void actIncrement();
     bool swapCard(const QModelIndex &idx);
     void actDecrementCard(const ExactCard &card, QString zoneName);

cockatrice/src/interface/widgets/dialogs/dlg_load_deck.cpp

@@ -1,8 +1,7 @@
 #include "dlg_load_deck.h"
 
 #include "../../../client/settings/cache_settings.h"
-
-#include <libcockatrice/models/deck_list/deck_loader.h>
+#include "../../deck_loader/deck_loader.h"
 
 DlgLoadDeck::DlgLoadDeck(QWidget *parent) : QFileDialog(parent, tr("Load Deck"))
 {

cockatrice/src/interface/widgets/dialogs/dlg_load_deck_from_clipboard.cpp

@@ -1,6 +1,7 @@
 #include "dlg_load_deck_from_clipboard.h"
 
 #include "../../../client/settings/cache_settings.h"
+#include "../../deck_loader/deck_loader.h"
 #include "dlg_settings.h"
 
 #include <QApplication>
@@ -12,7 +13,6 @@
 #include <QPushButton>
 #include <QTextStream>
 #include <QVBoxLayout>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 
 /**
  * Creates the main layout and connects the signals that are common to all versions of this window

cockatrice/src/interface/widgets/dialogs/dlg_select_set_for_cards.cpp

@@ -1,5 +1,6 @@
 #include "dlg_select_set_for_cards.h"
 
+#include "../../deck_loader/deck_loader.h"
 #include "../interface/widgets/cards/card_info_picture_widget.h"
 #include "../interface/widgets/general/layout_containers/flow_widget.h"
 #include "dlg_select_set_for_cards.h"
@@ -16,7 +17,6 @@
 #include <QVBoxLayout>
 #include <algorithm>
 #include <libcockatrice/card/database/card_database_manager.h>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 #include <qdrag.h>
 #include <qevent.h>
 
@@ -162,14 +162,14 @@ void DlgSelectSetForCards::actOK()
 
 void DlgSelectSetForCards::actClear()
 {
-    model->getDeckList()->clearSetNamesAndNumbers();
+    qobject_cast<DeckLoader *>(model->getDeckList())->clearSetNamesAndNumbers();
     accept();
 }
 
 void DlgSelectSetForCards::actSetAllToPreferred()
 {
-    model->getDeckList()->clearSetNamesAndNumbers();
-    model->getDeckList()->setProviderIdToPreferredPrinting();
+    qobject_cast<DeckLoader *>(model->getDeckList())->clearSetNamesAndNumbers();
+    qobject_cast<DeckLoader *>(model->getDeckList())->setProviderIdToPreferredPrinting();
     accept();
 }
 

cockatrice/src/interface/widgets/printing_selector/all_zones_card_amount_widget.h

@@ -7,12 +7,12 @@
 
 #ifndef ALL_ZONES_CARD_AMOUNT_WIDGET_H
 #define ALL_ZONES_CARD_AMOUNT_WIDGET_H
+#include "../../deck_loader/deck_loader.h"
 #include "card_amount_widget.h"
 
 #include <QVBoxLayout>
 #include <QWidget>
 #include <libcockatrice/models/deck_list/deck_list_model.h>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 
 class AllZonesCardAmountWidget : public QWidget
 {

cockatrice/src/interface/widgets/printing_selector/card_amount_widget.h

@@ -9,6 +9,7 @@
 #define CARD_AMOUNT_WIDGET_H
 
 #include "../../../interface/widgets/tabs/abstract_tab_deck_editor.h"
+#include "../../deck_loader/deck_loader.h"
 #include "../general/display/dynamic_font_size_push_button.h"
 
 #include <QHBoxLayout>
@@ -18,7 +19,6 @@
 #include <QWidget>
 #include <libcockatrice/card/card_info.h>
 #include <libcockatrice/models/deck_list/deck_list_model.h>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 
 class CardAmountWidget : public QWidget
 {

cockatrice/src/interface/widgets/tabs/abstract_tab_deck_editor.cpp

@@ -217,11 +217,16 @@ void AbstractTabDeckEditor::setDeck(DeckLoader *_deck)
 }
 
 /** @brief Returns the currently loaded deck. */
-DeckLoader *AbstractTabDeckEditor::getDeckList() const
+DeckList *AbstractTabDeckEditor::getDeckList() const
 {
     return deckDockWidget->getDeckList();
 }
 
+DeckLoader *AbstractTabDeckEditor::getDeckLoader() const
+{
+    return deckDockWidget->getDeckLoader();
+}
+
 /**
  * @brief Sets the modified state of the tab.
  * @param _modified True if tab is modified, false otherwise.
@@ -237,7 +242,7 @@ void AbstractTabDeckEditor::setModified(bool _modified)
  */
 bool AbstractTabDeckEditor::isBlankNewDeck() const
 {
-    DeckLoader *deck = getDeckList();
+    DeckLoader *deck = deckDockWidget->getDeckLoader();
     return !modified && deck->isBlankDeck() && deck->hasNotBeenLoaded();
 }
 
@@ -377,7 +382,7 @@ void AbstractTabDeckEditor::openDeckFromFile(const QString &fileName, DeckOpenLo
  */
 bool AbstractTabDeckEditor::actSaveDeck()
 {
-    DeckLoader *const deck = getDeckList();
+    DeckLoader *const deck = getDeckLoader();
     if (deck->getLastRemoteDeckId() != -1) {
         QString deckString = deck->writeToString_Native();
         if (deckString.length() > MAX_FILE_LENGTH) {
@@ -426,7 +431,7 @@ bool AbstractTabDeckEditor::actSaveDeckAs()
     QString fileName = dialog.selectedFiles().at(0);
     DeckLoader::FileFormat fmt = DeckLoader::getFormatFromName(fileName);
 
-    if (!getDeckList()->saveToFile(fileName, fmt)) {
+    if (!getDeckLoader()->saveToFile(fileName, fmt)) {
         QMessageBox::critical(
             this, tr("Error"),
             tr("The deck could not be saved.\nPlease check that the directory is writable and try again."));
@@ -480,7 +485,7 @@ void AbstractTabDeckEditor::actLoadDeckFromClipboard()
  */
 void AbstractTabDeckEditor::editDeckInClipboard(bool annotated)
 {
-    DlgEditDeckInClipboard dlg(*getDeckList(), annotated, this);
+    DlgEditDeckInClipboard dlg(*getDeckLoader(), annotated, this);
     if (!dlg.exec())
         return;
 
@@ -504,25 +509,25 @@ void AbstractTabDeckEditor::actEditDeckInClipboardRaw()
 /** @brief Saves deck to clipboard with set info and annotation. */
 void AbstractTabDeckEditor::actSaveDeckToClipboard()
 {
-    getDeckList()->saveToClipboard(true, true);
+    getDeckLoader()->saveToClipboard(true, true);
 }
 
 /** @brief Saves deck to clipboard with annotation, without set info. */
 void AbstractTabDeckEditor::actSaveDeckToClipboardNoSetInfo()
 {
-    getDeckList()->saveToClipboard(true, false);
+    getDeckLoader()->saveToClipboard(true, false);
 }
 
 /** @brief Saves deck to clipboard without annotations, with set info. */
 void AbstractTabDeckEditor::actSaveDeckToClipboardRaw()
 {
-    getDeckList()->saveToClipboard(false, true);
+    getDeckLoader()->saveToClipboard(false, true);
 }
 
 /** @brief Saves deck to clipboard without annotations or set info. */
 void AbstractTabDeckEditor::actSaveDeckToClipboardRawNoSetInfo()
 {
-    getDeckList()->saveToClipboard(false, false);
+    getDeckLoader()->saveToClipboard(false, false);
 }
 
 /** @brief Prints the deck using a QPrintPreviewDialog. */
@@ -562,7 +567,7 @@ void AbstractTabDeckEditor::actLoadDeckFromWebsite()
  */
 void AbstractTabDeckEditor::exportToDecklistWebsite(DeckLoader::DecklistWebsite website)
 {
-    if (DeckLoader *const deck = getDeckList()) {
+    if (DeckLoader *const deck = getDeckLoader()) {
         QString decklistUrlString = deck->exportDeckToDecklist(website);
         // Check to make sure the string isn't empty.
         if (decklistUrlString.isEmpty()) {

cockatrice/src/interface/widgets/tabs/abstract_tab_deck_editor.h

@@ -117,7 +117,8 @@ public:
     void openDeck(DeckLoader *deck);
 
     /** @brief Returns the currently active deck. */
-    DeckLoader *getDeckList() const;
+    DeckList *getDeckList() const;
+    DeckLoader *getDeckLoader() const;
 
     /** @brief Sets the modified state of the tab.
      *  @param _windowModified Whether the tab is modified.

cockatrice/src/interface/widgets/tabs/api/edhrec/api_response/average_deck/edhrec_deck_api_response.cpp

@@ -1,11 +1,12 @@
 #include "edhrec_deck_api_response.h"
 
+#include "../../../../../../deck_loader/deck_loader.h"
+
 #include <QApplication>
 #include <QDebug>
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QMainWindow>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 
 void EdhrecDeckApiResponse::fromJson(const QJsonArray &json)
 {

cockatrice/src/interface/widgets/tabs/api/edhrec/api_response/average_deck/edhrec_deck_api_response.h

@@ -7,12 +7,13 @@
 #ifndef EDHREC_DECK_API_RESPONSE_H
 #define EDHREC_DECK_API_RESPONSE_H
 
+#include "../../../../../../deck_loader/deck_loader.h"
+
 #include <QDebug>
 #include <QJsonArray>
 #include <QJsonObject>
 #include <QString>
 #include <QVector>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 
 class EdhrecDeckApiResponse
 {

cockatrice/src/interface/widgets/tabs/tab_deck_storage.cpp

@@ -1,6 +1,7 @@
 #include "tab_deck_storage.h"
 
 #include "../../../client/settings/cache_settings.h"
+#include "../../deck_loader/deck_loader.h"
 #include "../interface/widgets/server/remote/remote_decklist_tree_widget.h"
 #include "../interface/widgets/utility/get_text_with_max.h"
 
@@ -19,7 +20,6 @@
 #include <QUrl>
 #include <QVBoxLayout>
 #include <libcockatrice/deck_list/deck_list.h>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 #include <libcockatrice/protocol/pb/command_deck_del.pb.h>
 #include <libcockatrice/protocol/pb/command_deck_del_dir.pb.h>
 #include <libcockatrice/protocol/pb/command_deck_download.pb.h>

cockatrice/src/interface/widgets/tabs/tab_supervisor.h

@@ -8,6 +8,7 @@
 #ifndef TAB_SUPERVISOR_H
 #define TAB_SUPERVISOR_H
 
+#include "../../deck_loader/deck_loader.h"
 #include "../interface/widgets/server/user/user_list_proxy.h"
 #include "abstract_tab_deck_editor.h"
 #include "api/edhrec/tab_edhrec.h"
@@ -23,7 +24,6 @@
 #include <QMap>
 #include <QProxyStyle>
 #include <QTabWidget>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 
 inline Q_LOGGING_CATEGORY(TabSupervisorLog, "tab_supervisor");
 

cockatrice/src/interface/widgets/visual_deck_editor/visual_deck_editor_sample_hand_widget.cpp

@@ -1,10 +1,10 @@
 #include "visual_deck_editor_sample_hand_widget.h"
 
 #include "../../../client/settings/cache_settings.h"
+#include "../../deck_loader/deck_loader.h"
 #include "../cards/card_info_picture_widget.h"
 
 #include <libcockatrice/card/database/card_database_manager.h>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 #include <random>
 
 VisualDeckEditorSampleHandWidget::VisualDeckEditorSampleHandWidget(QWidget *parent, DeckListModel *_deckListModel)

cockatrice/src/interface/widgets/visual_deck_editor/visual_deck_editor_widget.cpp

@@ -1,6 +1,7 @@
 #include "visual_deck_editor_widget.h"
 
 #include "../../../main.h"
+#include "../../deck_loader/deck_loader.h"
 #include "../../layouts/overlap_layout.h"
 #include "../cards/card_info_picture_with_text_overlay_widget.h"
 #include "../cards/deck_card_zone_display_widget.h"
@@ -22,7 +23,6 @@
 #include <libcockatrice/models/database/card/card_search_model.h>
 #include <libcockatrice/models/database/card_database_model.h>
 #include <libcockatrice/models/deck_list/deck_list_model.h>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 #include <qscrollarea.h>
 
 VisualDeckEditorWidget::VisualDeckEditorWidget(QWidget *parent, DeckListModel *_deckListModel)

cockatrice/src/interface/widgets/visual_deck_storage/deck_preview/deck_preview_deck_tags_display_widget.h

@@ -7,10 +7,10 @@
 #ifndef DECK_PREVIEW_DECK_TAGS_DISPLAY_WIDGET_H
 #define DECK_PREVIEW_DECK_TAGS_DISPLAY_WIDGET_H
 
+#include "../../../deck_loader/deck_loader.h"
 #include "deck_preview_widget.h"
 
 #include <QWidget>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 
 inline bool confirmOverwriteIfExists(QWidget *parent, const QString &filePath);
 

cockatrice/src/interface/widgets/visual_deck_storage/deck_preview/deck_preview_widget.h

@@ -7,6 +7,7 @@
 #ifndef DECK_PREVIEW_WIDGET_H
 #define DECK_PREVIEW_WIDGET_H
 
+#include "../../../deck_loader/deck_loader.h"
 #include "../../cards/additional_info/color_identity_widget.h"
 #include "../../cards/deck_preview_card_picture_widget.h"
 #include "../visual_deck_storage_widget.h"
@@ -18,7 +19,6 @@
 #include <QEvent>
 #include <QVBoxLayout>
 #include <QWidget>
-#include <libcockatrice/models/deck_list/deck_loader.h>
 
 class QMenu;
 class VisualDeckStorageWidget;

cockatrice/src/interface/widgets/visual_deck_storage/visual_deck_storage_widget.h

@@ -7,6 +7,7 @@
 #ifndef VISUAL_DECK_STORAGE_WIDGET_H
 #define VISUAL_DECK_STORAGE_WIDGET_H
 
+#include "../../deck_loader/deck_loader.h"
 #include "../cards/card_size_widget.h"
 #include "../general/layout_containers/flow_widget.h"
 #include "../quick_settings/settings_button_widget.h"