NOISSUE put legacy FTB support in a namespace, fix its base URL

api/logic/CMakeLists.txt

@@ -439,15 +439,14 @@ set(META_SOURCES
 )
 
 set(FTB_SOURCES
-    modplatform/ftb/FtbPackFetchTask.h
+    modplatform/legacy_ftb/PackFetchTask.h
-    modplatform/ftb/FtbPackFetchTask.cpp
+    modplatform/legacy_ftb/PackFetchTask.cpp
-    modplatform/ftb/FtbPackInstallTask.h
+    modplatform/legacy_ftb/PackInstallTask.h
-    modplatform/ftb/FtbPackInstallTask.cpp
+    modplatform/legacy_ftb/PackInstallTask.cpp
+    modplatform/legacy_ftb/PrivatePackManager.h
+    modplatform/legacy_ftb/PrivatePackManager.cpp
 
-    modplatform/ftb/FtbPrivatePackManager.h
+    modplatform/legacy_ftb/PackHelpers.h
-    modplatform/ftb/FtbPrivatePackManager.cpp
-
-    modplatform/ftb/PackHelpers.h
 )
 
 set(FLAME_SOURCES

api/logic/modplatform/legacy_ftb/PackFetchTask.cpp

@@ -1,34 +1,36 @@
-#include "FtbPackFetchTask.h"
+#include "PackFetchTask.h"
-#include <QDomDocument>
+#include "PrivatePackManager.h"
-#include "FtbPrivatePackManager.h"
 
+#include <QDomDocument>
 #include "net/URLConstants.h"
 
-void FtbPackFetchTask::fetch()
+namespace LegacyFTB {
+
+void PackFetchTask::fetch()
 {
     publicPacks.clear();
     thirdPartyPacks.clear();
 
-    NetJob *netJob = new NetJob("FtbModpackFetch");
+    NetJob *netJob = new NetJob("LegacyFTB::ModpackFetch");
 
-    QUrl publicPacksUrl = QUrl(URLConstants::FTB_CDN_BASE_URL + "static/modpacks.xml");
+    QUrl publicPacksUrl = QUrl(URLConstants::LEGACY_FTB_CDN_BASE_URL + "static/modpacks.xml");
     qDebug() << "Downloading public version info from" << publicPacksUrl.toString();
     netJob->addNetAction(Net::Download::makeByteArray(publicPacksUrl, &publicModpacksXmlFileData));
 
-    QUrl thirdPartyUrl = QUrl(URLConstants::FTB_CDN_BASE_URL + "static/thirdparty.xml");
+    QUrl thirdPartyUrl = QUrl(URLConstants::LEGACY_FTB_CDN_BASE_URL + "static/thirdparty.xml");
     qDebug() << "Downloading thirdparty version info from" << thirdPartyUrl.toString();
     netJob->addNetAction(Net::Download::makeByteArray(thirdPartyUrl, &thirdPartyModpacksXmlFileData));
 
-    QObject::connect(netJob, &NetJob::succeeded, this, &FtbPackFetchTask::fileDownloadFinished);
+    QObject::connect(netJob, &NetJob::succeeded, this, &PackFetchTask::fileDownloadFinished);
-    QObject::connect(netJob, &NetJob::failed, this, &FtbPackFetchTask::fileDownloadFailed);
+    QObject::connect(netJob, &NetJob::failed, this, &PackFetchTask::fileDownloadFailed);
 
     jobPtr.reset(netJob);
     netJob->start();
 }
 
-void FtbPackFetchTask::fetchPrivate(const QStringList & toFetch)
+void PackFetchTask::fetchPrivate(const QStringList & toFetch)
 {
-    QString privatePackBaseUrl = URLConstants::FTB_CDN_BASE_URL + "static/%1.xml";
+    QString privatePackBaseUrl = URLConstants::LEGACY_FTB_CDN_BASE_URL + "static/%1.xml";
 
     for (auto &packCode: toFetch)
     {
@@ -38,9 +40,9 @@ void FtbPackFetchTask::fetchPrivate(const QStringList & toFetch)
 
         QObject::connect(job, &NetJob::succeeded, this, [this, job, data, packCode]
         {
-            FtbModpackList packs;
+            ModpackList packs;
-            parseAndAddPacks(*data, FtbPackType::Private, packs);
+            parseAndAddPacks(*data, PackType::Private, packs);
-            foreach(FtbModpack currentPack, packs)
+            foreach(Modpack currentPack, packs)
             {
                 currentPack.packCode = packCode;
                 emit privateFileDownloadFinished(currentPack);
@@ -65,18 +67,18 @@ void FtbPackFetchTask::fetchPrivate(const QStringList & toFetch)
     }
 }
 
-void FtbPackFetchTask::fileDownloadFinished()
+void PackFetchTask::fileDownloadFinished()
 {
     jobPtr.reset();
 
     QStringList failedLists;
 
-    if(!parseAndAddPacks(publicModpacksXmlFileData, FtbPackType::Public, publicPacks))
+    if(!parseAndAddPacks(publicModpacksXmlFileData, PackType::Public, publicPacks))
     {
         failedLists.append(tr("Public Packs"));
     }
 
-    if(!parseAndAddPacks(thirdPartyModpacksXmlFileData, FtbPackType::ThirdParty, thirdPartyPacks))
+    if(!parseAndAddPacks(thirdPartyModpacksXmlFileData, PackType::ThirdParty, thirdPartyPacks))
     {
         failedLists.append(tr("Third Party Packs"));
     }
@@ -91,7 +93,7 @@ void FtbPackFetchTask::fileDownloadFinished()
     }
 }
 
-bool FtbPackFetchTask::parseAndAddPacks(QByteArray &data, FtbPackType packType, FtbModpackList &list)
+bool PackFetchTask::parseAndAddPacks(QByteArray &data, PackType packType, ModpackList &list)
 {
     QDomDocument doc;
 
@@ -112,7 +114,7 @@ bool FtbPackFetchTask::parseAndAddPacks(QByteArray &data, FtbPackType packType,
     {
         QDomElement element = nodes.at(i).toElement();
 
-        FtbModpack modpack;
+        Modpack modpack;
         modpack.name = element.attribute("name");
         modpack.currentVersion = element.attribute("version");
         modpack.mcVersion = element.attribute("mcVersion");
@@ -161,8 +163,10 @@ bool FtbPackFetchTask::parseAndAddPacks(QByteArray &data, FtbPackType packType,
     return true;
 }
 
-void FtbPackFetchTask::fileDownloadFailed(QString reason)
+void PackFetchTask::fileDownloadFailed(QString reason)
 {
-    qWarning() << "Fetching FtbPacks failed:" << reason;
+    qWarning() << "Fetching FTBPacks failed:" << reason;
     emit failed(reason);
 }
+
+}

api/logic/modplatform/legacy_ftb/PackFetchTask.h

@@ -6,13 +6,15 @@
 #include <QObject>
 #include "PackHelpers.h"
 
-class MULTIMC_LOGIC_EXPORT FtbPackFetchTask : public QObject {
+namespace LegacyFTB {
+
+class MULTIMC_LOGIC_EXPORT PackFetchTask : public QObject {
 
     Q_OBJECT
 
 public:
-    FtbPackFetchTask() = default;
+    PackFetchTask() = default;
-    virtual ~FtbPackFetchTask() = default;
+    virtual ~PackFetchTask() = default;
 
     void fetch();
     void fetchPrivate(const QStringList &toFetch);
@@ -23,18 +25,20 @@ private:
     QByteArray publicModpacksXmlFileData;
     QByteArray thirdPartyModpacksXmlFileData;
 
-    bool parseAndAddPacks(QByteArray &data, FtbPackType packType, FtbModpackList &list);
+    bool parseAndAddPacks(QByteArray &data, PackType packType, ModpackList &list);
-    FtbModpackList publicPacks;
+    ModpackList publicPacks;
-    FtbModpackList thirdPartyPacks;
+    ModpackList thirdPartyPacks;
 
 protected slots:
     void fileDownloadFinished();
     void fileDownloadFailed(QString reason);
 
 signals:
-    void finished(FtbModpackList publicPacks, FtbModpackList thirdPartyPacks);
+    void finished(ModpackList publicPacks, ModpackList thirdPartyPacks);
     void failed(QString reason);
 
-    void privateFileDownloadFinished(FtbModpack modpack);
+    void privateFileDownloadFinished(Modpack modpack);
     void privateFileDownloadFailed(QString reason, QString packCode);
 };
+
+}

api/logic/modplatform/legacy_ftb/PackHelpers.h

@@ -5,15 +5,17 @@
 #include <QStringList>
 #include <QMetaType>
 
+namespace LegacyFTB {
+
 //Header for structs etc...
-enum class FtbPackType
+enum class PackType
 {
     Public,
     ThirdParty,
     Private
 };
 
-struct FtbModpack
+struct Modpack
 {
     QString name;
     QString description;
@@ -31,11 +33,13 @@ struct FtbModpack
     bool bugged = false;
     bool broken = false;
 
-    FtbPackType type;
+    PackType type;
     QString packCode;
 };
 
-//We need it for the proxy model
+typedef QList<Modpack> ModpackList;
-Q_DECLARE_METATYPE(FtbModpack)
 
-typedef QList<FtbModpack> FtbModpackList;
+}
+
+//We need it for the proxy model
+Q_DECLARE_METATYPE(LegacyFTB::Modpack)

api/logic/modplatform/legacy_ftb/PackInstallTask.cpp

@@ -1,28 +1,32 @@
-#include "FtbPackInstallTask.h"
+#include "PackInstallTask.h"
+
 #include "Env.h"
 #include "MMCZip.h"
-#include "QtConcurrent"
+
 #include "BaseInstance.h"
 #include "FileSystem.h"
 #include "settings/INISettingsObject.h"
 #include "minecraft/MinecraftInstance.h"
 #include "minecraft/ComponentList.h"
 #include "minecraft/GradleSpecifier.h"
-
 #include "net/URLConstants.h"
 
-FtbPackInstallTask::FtbPackInstallTask(FtbModpack pack, QString version)
+#include <QtConcurrent>
+
+namespace LegacyFTB {
+
+PackInstallTask::PackInstallTask(Modpack pack, QString version)
 {
     m_pack = pack;
     m_version = version;
 }
 
-void FtbPackInstallTask::executeTask()
+void PackInstallTask::executeTask()
 {
     downloadPack();
 }
 
-void FtbPackInstallTask::downloadPack()
+void PackInstallTask::downloadPack()
 {
     setStatus(tr("Downloading zip for %1").arg(m_pack.name));
 
@@ -32,46 +36,46 @@ void FtbPackInstallTask::downloadPack()
 
     entry->setStale(true);
     QString url;
-    if(m_pack.type == FtbPackType::Private)
+    if(m_pack.type == PackType::Private)
     {
-        url = QString(URLConstants::FTB_CDN_BASE_URL + "privatepacks/%1").arg(packoffset);
+        url = QString(URLConstants::LEGACY_FTB_CDN_BASE_URL + "privatepacks/%1").arg(packoffset);
     }
     else
     {
-        url = QString(URLConstants::FTB_CDN_BASE_URL + "modpacks/%1").arg(packoffset);
+        url = QString(URLConstants::LEGACY_FTB_CDN_BASE_URL + "modpacks/%1").arg(packoffset);
     }
     job->addNetAction(Net::Download::makeCached(url, entry));
     archivePath = entry->getFullPath();
 
     netJobContainer.reset(job);
-    connect(job, &NetJob::succeeded, this, &FtbPackInstallTask::onDownloadSucceeded);
+    connect(job, &NetJob::succeeded, this, &PackInstallTask::onDownloadSucceeded);
-    connect(job, &NetJob::failed, this, &FtbPackInstallTask::onDownloadFailed);
+    connect(job, &NetJob::failed, this, &PackInstallTask::onDownloadFailed);
-    connect(job, &NetJob::progress, this, &FtbPackInstallTask::onDownloadProgress);
+    connect(job, &NetJob::progress, this, &PackInstallTask::onDownloadProgress);
     job->start();
 
     progress(1, 4);
 }
 
-void FtbPackInstallTask::onDownloadSucceeded()
+void PackInstallTask::onDownloadSucceeded()
 {
     abortable = false;
     unzip();
 }
 
-void FtbPackInstallTask::onDownloadFailed(QString reason)
+void PackInstallTask::onDownloadFailed(QString reason)
 {
     abortable = false;
     emitFailed(reason);
 }
 
-void FtbPackInstallTask::onDownloadProgress(qint64 current, qint64 total)
+void PackInstallTask::onDownloadProgress(qint64 current, qint64 total)
 {
     abortable = true;
     progress(current, total * 4);
     setStatus(tr("Downloading zip for %1 (%2%)").arg(m_pack.name).arg(current / 10));
 }
 
-void FtbPackInstallTask::unzip()
+void PackInstallTask::unzip()
 {
     progress(2, 4);
     setStatus(tr("Extracting modpack"));
@@ -85,22 +89,22 @@ void FtbPackInstallTask::unzip()
     }
 
     m_extractFuture = QtConcurrent::run(QThreadPool::globalInstance(), MMCZip::extractDir, archivePath, extractDir.absolutePath() + "/unzip");
-    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &FtbPackInstallTask::onUnzipFinished);
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::finished, this, &PackInstallTask::onUnzipFinished);
-    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &FtbPackInstallTask::onUnzipCanceled);
+    connect(&m_extractFutureWatcher, &QFutureWatcher<QStringList>::canceled, this, &PackInstallTask::onUnzipCanceled);
     m_extractFutureWatcher.setFuture(m_extractFuture);
 }
 
-void FtbPackInstallTask::onUnzipFinished()
+void PackInstallTask::onUnzipFinished()
 {
     install();
 }
 
-void FtbPackInstallTask::onUnzipCanceled()
+void PackInstallTask::onUnzipCanceled()
 {
     emitAborted();
 }
 
-void FtbPackInstallTask::install()
+void PackInstallTask::install()
 {
     progress(3, 4);
     setStatus(tr("Installing modpack"));
@@ -197,7 +201,7 @@ void FtbPackInstallTask::install()
     emitSucceeded();
 }
 
-bool FtbPackInstallTask::abort()
+bool PackInstallTask::abort()
 {
     if(abortable)
     {
@@ -205,3 +209,5 @@ bool FtbPackInstallTask::abort()
     }
     return false;
 }
+
+}

api/logic/modplatform/legacy_ftb/PackInstallTask.h

@@ -6,15 +6,17 @@
 #include "meta/Index.h"
 #include "meta/Version.h"
 #include "meta/VersionList.h"
-#include "modplatform/ftb/PackHelpers.h"
+#include "PackHelpers.h"
 
-class MULTIMC_LOGIC_EXPORT FtbPackInstallTask : public InstanceTask
+namespace LegacyFTB {
+
+class MULTIMC_LOGIC_EXPORT PackInstallTask : public InstanceTask
 {
     Q_OBJECT
 
 public:
-    explicit FtbPackInstallTask(FtbModpack pack, QString version);
+    explicit PackInstallTask(Modpack pack, QString version);
-    virtual ~FtbPackInstallTask(){}
+    virtual ~PackInstallTask(){}
 
     bool abort() override;
 
@@ -43,6 +45,8 @@ private: /* data */
     NetJobPtr netJobContainer;
     QString archivePath;
 
-    FtbModpack m_pack;
+    Modpack m_pack;
     QString m_version;
 };
+
+}

api/logic/modplatform/legacy_ftb/PrivatePackManager.cpp

@@ -1,10 +1,12 @@
-#include "FtbPrivatePackManager.h"
+#include "PrivatePackManager.h"
 
 #include <QDebug>
 
 #include "FileSystem.h"
 
-void FtbPrivatePackManager::load()
+namespace LegacyFTB {
+
+void PrivatePackManager::load()
 {
     try
     {
@@ -18,7 +20,7 @@ void FtbPrivatePackManager::load()
     }
 }
 
-void FtbPrivatePackManager::save() const
+void PrivatePackManager::save() const
 {
     if(!dirty)
     {
@@ -35,3 +37,5 @@ void FtbPrivatePackManager::save() const
         qWarning() << "Failed to write third party FTB pack codes to" << m_filename;
     }
 }
+
+}

api/logic/modplatform/legacy_ftb/PrivatePackManager.h

@@ -5,10 +5,12 @@
 #include <QFile>
 #include "multimc_logic_export.h"
 
-class MULTIMC_LOGIC_EXPORT FtbPrivatePackManager
+namespace LegacyFTB {
+
+class MULTIMC_LOGIC_EXPORT PrivatePackManager
 {
 public:
-    ~FtbPrivatePackManager()
+    ~PrivatePackManager()
     {
         save();
     }
@@ -38,3 +40,5 @@ private:
     QString m_filename = "private_packs.txt";
     mutable bool dirty = false;
 };
+
+}

api/logic/net/URLConstants.h

@@ -29,7 +29,8 @@ const QString IMGUR_BASE_URL("https://api.imgur.com/3/");
 const QString FMLLIBS_OUR_BASE_URL("https://files.multimc.org/fmllibs/");
 const QString FMLLIBS_FORGE_BASE_URL("https://files.minecraftforge.net/fmllibs/");
 const QString TRANSLATIONS_BASE_URL("https://files.multimc.org/translations/");
-const QString FTB_CDN_BASE_URL("https://ftb.forgecdn.net/FTB2/");
+
+const QString LEGACY_FTB_CDN_BASE_URL("https://dist.creeper.host/FTB2/");
 
 QString getJarPath(QString version);
 QString getLegacyJarUrl(QString version);

application/CMakeLists.txt

@@ -129,10 +129,10 @@ SET(MULTIMC_SOURCES
     # GUI - platform pages
     pages/modplatform/VanillaPage.cpp
     pages/modplatform/VanillaPage.h
-    pages/modplatform/FTBPage.cpp
+    pages/modplatform/legacy_ftb/Page.cpp
-    pages/modplatform/FTBPage.h
+    pages/modplatform/legacy_ftb/Page.h
-    pages/modplatform/FtbListModel.h
+    pages/modplatform/legacy_ftb/ListModel.h
-    pages/modplatform/FtbListModel.cpp
+    pages/modplatform/legacy_ftb/ListModel.cpp
     pages/modplatform/TwitchPage.cpp
     pages/modplatform/TwitchPage.h
     pages/modplatform/ImportPage.cpp
@@ -252,7 +252,7 @@ SET(MULTIMC_UIS
 
     # Platform pages
     pages/modplatform/VanillaPage.ui
-    pages/modplatform/FTBPage.ui
+    pages/modplatform/legacy_ftb/Page.ui
     pages/modplatform/TwitchPage.ui
     pages/modplatform/ImportPage.ui
 

application/dialogs/NewInstanceDialog.cpp

@@ -34,7 +34,7 @@
 
 #include "widgets/PageContainer.h"
 #include <pages/modplatform/VanillaPage.h>
-#include <pages/modplatform/FTBPage.h>
+#include <pages/modplatform/legacy_ftb/Page.h>
 #include <pages/modplatform/TwitchPage.h>
 #include <pages/modplatform/ImportPage.h>
 
@@ -131,8 +131,8 @@ QList<BasePage *> NewInstanceDialog::getPages()
     {
         new VanillaPage(this),
         importPage,
-        twitchPage,
+        new LegacyFTB::Page(this),
-        new FTBPage(this)
+        twitchPage
     };
 }
 

application/pages/modplatform/legacy_ftb/ListModel.cpp

@@ -1,4 +1,4 @@
-#include "FtbListModel.h"
+#include "ListModel.h"
 #include "MultiMC.h"
 
 #include <MMCStrings.h>
@@ -12,17 +12,19 @@
 
 #include "net/URLConstants.h"
 
-FtbFilterModel::FtbFilterModel(QObject *parent) : QSortFilterProxyModel(parent)
+namespace LegacyFTB {
+
+FilterModel::FilterModel(QObject *parent) : QSortFilterProxyModel(parent)
 {
     currentSorting = Sorting::ByGameVersion;
     sortings.insert(tr("Sort by name"), Sorting::ByName);
     sortings.insert(tr("Sort by game version"), Sorting::ByGameVersion);
 }
 
-bool FtbFilterModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
+bool FilterModel::lessThan(const QModelIndex &left, const QModelIndex &right) const
 {
-    FtbModpack leftPack = sourceModel()->data(left, Qt::UserRole).value<FtbModpack>();
+    Modpack leftPack = sourceModel()->data(left, Qt::UserRole).value<Modpack>();
-    FtbModpack rightPack = sourceModel()->data(right, Qt::UserRole).value<FtbModpack>();
+    Modpack rightPack = sourceModel()->data(right, Qt::UserRole).value<Modpack>();
 
     if(currentSorting == Sorting::ByGameVersion) {
         Version lv(leftPack.mcVersion);
@@ -38,66 +40,66 @@ bool FtbFilterModel::lessThan(const QModelIndex &left, const QModelIndex &right)
     return true;
 }
 
-bool FtbFilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
+bool FilterModel::filterAcceptsRow(int sourceRow, const QModelIndex &sourceParent) const
 {
     return true;
 }
 
-const QMap<QString, FtbFilterModel::Sorting> FtbFilterModel::getAvailableSortings()
+const QMap<QString, FilterModel::Sorting> FilterModel::getAvailableSortings()
 {
     return sortings;
 }
 
-QString FtbFilterModel::translateCurrentSorting()
+QString FilterModel::translateCurrentSorting()
 {
     return sortings.key(currentSorting);
 }
 
-void FtbFilterModel::setSorting(Sorting s)
+void FilterModel::setSorting(Sorting s)
 {
     currentSorting = s;
     invalidate();
 }
 
-FtbFilterModel::Sorting FtbFilterModel::getCurrentSorting()
+FilterModel::Sorting FilterModel::getCurrentSorting()
 {
     return currentSorting;
 }
 
-FtbListModel::FtbListModel(QObject *parent) : QAbstractListModel(parent)
+ListModel::ListModel(QObject *parent) : QAbstractListModel(parent)
 {
 }
 
-FtbListModel::~FtbListModel()
+ListModel::~ListModel()
 {
 }
 
-QString FtbListModel::translatePackType(FtbPackType type) const
+QString ListModel::translatePackType(PackType type) const
 {
     switch(type)
     {
-        case FtbPackType::Public:
+        case PackType::Public:
             return tr("Public Modpack");
-        case FtbPackType::ThirdParty:
+        case PackType::ThirdParty:
             return tr("Third Party Modpack");
-        case FtbPackType::Private:
+        case PackType::Private:
             return tr("Private Modpack");
     }
     qWarning() << "Unknown FTB modpack type:" << int(type);
     return QString();
 }
 
-int FtbListModel::rowCount(const QModelIndex &parent) const
+int ListModel::rowCount(const QModelIndex &parent) const
 {
     return modpacks.size();
 }
 
-int FtbListModel::columnCount(const QModelIndex &parent) const
+int ListModel::columnCount(const QModelIndex &parent) const
 {
     return 1;
 }
 
-QVariant FtbListModel::data(const QModelIndex &index, int role) const
+QVariant ListModel::data(const QModelIndex &index, int role) const
 {
     int pos = index.row();
     if(pos >= modpacks.size() || pos < 0 || !index.isValid())
@@ -105,7 +107,7 @@ QVariant FtbListModel::data(const QModelIndex &index, int role) const
         return QString("INVALID INDEX %1").arg(pos);
     }
 
-    FtbModpack pack = modpacks.at(pos);
+    Modpack pack = modpacks.at(pos);
     if(role == Qt::DisplayRole)
     {
         return pack.name + "\n" + translatePackType(pack.type);
@@ -129,7 +131,7 @@ QVariant FtbListModel::data(const QModelIndex &index, int role) const
             return (m_logoMap.value(pack.logo));
         }
         QIcon icon = MMC->getThemedIcon("screenshot-placeholder");
-        ((FtbListModel *)this)->requestLogo(pack.logo);
+        ((ListModel *)this)->requestLogo(pack.logo);
         return icon;
     }
     else if(role == Qt::TextColorRole)
@@ -156,33 +158,33 @@ QVariant FtbListModel::data(const QModelIndex &index, int role) const
     return QVariant();
 }
 
-void FtbListModel::fill(FtbModpackList modpacks)
+void ListModel::fill(ModpackList modpacks)
 {
     beginResetModel();
     this->modpacks = modpacks;
     endResetModel();
 }
 
-void FtbListModel::addPack(FtbModpack modpack)
+void ListModel::addPack(Modpack modpack)
 {
     beginResetModel();
     this->modpacks.append(modpack);
     endResetModel();
 }
 
-void FtbListModel::clear()
+void ListModel::clear()
 {
     beginResetModel();
     modpacks.clear();
     endResetModel();
 }
 
-FtbModpack FtbListModel::at(int row)
+Modpack ListModel::at(int row)
 {
     return modpacks.at(row);
 }
 
-void FtbListModel::remove(int row)
+void ListModel::remove(int row)
 {
     if(row < 0 || row >= modpacks.size())
     {
@@ -194,20 +196,20 @@ void FtbListModel::remove(int row)
     endRemoveRows();
 }
 
-void FtbListModel::logoLoaded(QString logo, QIcon out)
+void ListModel::logoLoaded(QString logo, QIcon out)
 {
     m_loadingLogos.removeAll(logo);
     m_logoMap.insert(logo, out);
     emit dataChanged(createIndex(0, 0), createIndex(1, 0));
 }
 
-void FtbListModel::logoFailed(QString logo)
+void ListModel::logoFailed(QString logo)
 {
     m_failedLogos.append(logo);
     m_loadingLogos.removeAll(logo);
 }
 
-void FtbListModel::requestLogo(QString file)
+void ListModel::requestLogo(QString file)
 {
     if(m_loadingLogos.contains(file) || m_failedLogos.contains(file))
     {
@@ -216,7 +218,7 @@ void FtbListModel::requestLogo(QString file)
 
     MetaEntryPtr entry = ENV.metacache()->resolveEntry("FTBPacks", QString("logos/%1").arg(file.section(".", 0, 0)));
     NetJob *job = new NetJob(QString("FTB Icon Download for %1").arg(file));
-    job->addNetAction(Net::Download::makeCached(QUrl(QString(URLConstants::FTB_CDN_BASE_URL + "static/%1").arg(file)), entry));
+    job->addNetAction(Net::Download::makeCached(QUrl(QString(URLConstants::LEGACY_FTB_CDN_BASE_URL + "static/%1").arg(file)), entry));
 
     auto fullPath = entry->getFullPath();
     QObject::connect(job, &NetJob::finished, this, [this, file, fullPath]
@@ -238,7 +240,7 @@ void FtbListModel::requestLogo(QString file)
     m_loadingLogos.append(file);
 }
 
-void FtbListModel::getLogo(const QString &logo, LogoCallback callback)
+void ListModel::getLogo(const QString &logo, LogoCallback callback)
 {
     if(m_logoMap.contains(logo))
     {
@@ -250,7 +252,9 @@ void FtbListModel::getLogo(const QString &logo, LogoCallback callback)
     }
 }
 
-Qt::ItemFlags FtbListModel::flags(const QModelIndex &index) const
+Qt::ItemFlags ListModel::flags(const QModelIndex &index) const
 {
     return QAbstractListModel::flags(index);
 }
+
+}

application/pages/modplatform/legacy_ftb/ListModel.h

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <modplatform/ftb/PackHelpers.h>
+#include <modplatform/legacy_ftb/PackHelpers.h>
 #include <RWStorage.h>
 
 #include <QAbstractListModel>
@@ -11,14 +11,16 @@
 
 #include <functional>
 
-typedef QMap<QString, QIcon> FtbLogoMap;
+namespace LegacyFTB {
+
+typedef QMap<QString, QIcon> FTBLogoMap;
 typedef std::function<void(QString)> LogoCallback;
 
-class FtbFilterModel : public QSortFilterProxyModel
+class FilterModel : public QSortFilterProxyModel
 {
     Q_OBJECT
 public:
-    FtbFilterModel(QObject* parent = Q_NULLPTR);
+    FilterModel(QObject* parent = Q_NULLPTR);
     enum Sorting {
         ByName,
         ByGameVersion
@@ -38,18 +40,18 @@ private:
 
 };
 
-class FtbListModel : public QAbstractListModel
+class ListModel : public QAbstractListModel
 {
     Q_OBJECT
 private:
-    FtbModpackList modpacks;
+    ModpackList modpacks;
     QStringList m_failedLogos;
     QStringList m_loadingLogos;
-    FtbLogoMap m_logoMap;
+    FTBLogoMap m_logoMap;
     QMap<QString, LogoCallback> waitingCallbacks;
 
     void requestLogo(QString file);
-    QString translatePackType(FtbPackType type) const;
+    QString translatePackType(PackType type) const;
 
 
 private slots:
@@ -57,18 +59,20 @@ private slots:
     void logoLoaded(QString logo, QIcon out);
 
 public:
-    FtbListModel(QObject *parent);
+    ListModel(QObject *parent);
-    ~FtbListModel();
+    ~ListModel();
     int rowCount(const QModelIndex &parent) const override;
     int columnCount(const QModelIndex &parent) const override;
     QVariant data(const QModelIndex &index, int role) const override;
     Qt::ItemFlags flags(const QModelIndex &index) const override;
 
-    void fill(FtbModpackList modpacks);
+    void fill(ModpackList modpacks);
-    void addPack(FtbModpack modpack);
+    void addPack(Modpack modpack);
     void clear();
     void remove(int row);
 
-    FtbModpack at(int row);
+    Modpack at(int row);
     void getLogo(const QString &logo, LogoCallback callback);
 };
+
+}

application/pages/modplatform/legacy_ftb/Page.cpp

@@ -1,27 +1,29 @@
-#include "FTBPage.h"
+#include "Page.h"
-#include "ui_FTBPage.h"
+#include "ui_Page.h"
 
 #include <QInputDialog>
 
 #include "MultiMC.h"
 #include "dialogs/CustomMessageBox.h"
 #include "dialogs/NewInstanceDialog.h"
-#include "modplatform/ftb/FtbPackFetchTask.h"
+#include "modplatform/legacy_ftb/PackFetchTask.h"
-#include "modplatform/ftb/FtbPackInstallTask.h"
+#include "modplatform/legacy_ftb/PackInstallTask.h"
-#include "modplatform/ftb/FtbPrivatePackManager.h"
+#include "modplatform/legacy_ftb/PrivatePackManager.h"
-#include "FtbListModel.h"
+#include "ListModel.h"
 
-FTBPage::FTBPage(NewInstanceDialog* dialog, QWidget *parent)
+namespace LegacyFTB {
-    : QWidget(parent), dialog(dialog), ui(new Ui::FTBPage)
+
+Page::Page(NewInstanceDialog* dialog, QWidget *parent)
+    : QWidget(parent), dialog(dialog), ui(new Ui::Page)
 {
-    ftbFetchTask.reset(new FtbPackFetchTask());
+    ftbFetchTask.reset(new PackFetchTask());
-    ftbPrivatePacks.reset(new FtbPrivatePackManager());
+    ftbPrivatePacks.reset(new PrivatePackManager());
 
     ui->setupUi(this);
 
     {
-        publicFilterModel = new FtbFilterModel(this);
+        publicFilterModel = new FilterModel(this);
-        publicListModel = new FtbListModel(this);
+        publicListModel = new ListModel(this);
         publicFilterModel->setSourceModel(publicListModel);
 
         ui->publicPackList->setModel(publicFilterModel);
@@ -39,8 +41,8 @@ FTBPage::FTBPage(NewInstanceDialog* dialog, QWidget *parent)
     }
 
     {
-        thirdPartyFilterModel = new FtbFilterModel(this);
+        thirdPartyFilterModel = new FilterModel(this);
-        thirdPartyModel = new FtbListModel(this);
+        thirdPartyModel = new ListModel(this);
         thirdPartyFilterModel->setSourceModel(thirdPartyModel);
 
         ui->thirdPartyPackList->setModel(thirdPartyFilterModel);
@@ -53,8 +55,8 @@ FTBPage::FTBPage(NewInstanceDialog* dialog, QWidget *parent)
     }
 
     {
-        privateFilterModel = new FtbFilterModel(this);
+        privateFilterModel = new FilterModel(this);
-        privateListModel = new FtbListModel(this);
+        privateListModel = new ListModel(this);
         privateFilterModel->setSourceModel(privateListModel);
 
         ui->privatePackList->setModel(privateFilterModel);
@@ -69,17 +71,17 @@ FTBPage::FTBPage(NewInstanceDialog* dialog, QWidget *parent)
     ui->versionSelectionBox->view()->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
     ui->versionSelectionBox->view()->parentWidget()->setMaximumHeight(300);
 
-    connect(ui->sortByBox, &QComboBox::currentTextChanged, this, &FTBPage::onSortingSelectionChanged);
+    connect(ui->sortByBox, &QComboBox::currentTextChanged, this, &Page::onSortingSelectionChanged);
-    connect(ui->versionSelectionBox, &QComboBox::currentTextChanged, this, &FTBPage::onVersionSelectionItemChanged);
+    connect(ui->versionSelectionBox, &QComboBox::currentTextChanged, this, &Page::onVersionSelectionItemChanged);
 
-    connect(ui->publicPackList->selectionModel(), &QItemSelectionModel::currentChanged, this, &FTBPage::onPublicPackSelectionChanged);
+    connect(ui->publicPackList->selectionModel(), &QItemSelectionModel::currentChanged, this, &Page::onPublicPackSelectionChanged);
-    connect(ui->thirdPartyPackList->selectionModel(), &QItemSelectionModel::currentChanged, this, &FTBPage::onThirdPartyPackSelectionChanged);
+    connect(ui->thirdPartyPackList->selectionModel(), &QItemSelectionModel::currentChanged, this, &Page::onThirdPartyPackSelectionChanged);
-    connect(ui->privatePackList->selectionModel(), &QItemSelectionModel::currentChanged, this, &FTBPage::onPrivatePackSelectionChanged);
+    connect(ui->privatePackList->selectionModel(), &QItemSelectionModel::currentChanged, this, &Page::onPrivatePackSelectionChanged);
 
-    connect(ui->addPackBtn, &QPushButton::pressed, this, &FTBPage::onAddPackClicked);
+    connect(ui->addPackBtn, &QPushButton::pressed, this, &Page::onAddPackClicked);
-    connect(ui->removePackBtn, &QPushButton::pressed, this, &FTBPage::onRemovePackClicked);
+    connect(ui->removePackBtn, &QPushButton::pressed, this, &Page::onRemovePackClicked);
 
-    connect(ui->tabWidget, &QTabWidget::currentChanged, this, &FTBPage::onTabChanged);
+    connect(ui->tabWidget, &QTabWidget::currentChanged, this, &Page::onTabChanged);
 
     // ui->modpackInfo->setOpenExternalLinks(true);
 
@@ -90,25 +92,25 @@ FTBPage::FTBPage(NewInstanceDialog* dialog, QWidget *parent)
     onTabChanged(ui->tabWidget->currentIndex());
 }
 
-FTBPage::~FTBPage()
+Page::~Page()
 {
     delete ui;
 }
 
-bool FTBPage::shouldDisplay() const
+bool Page::shouldDisplay() const
 {
     return true;
 }
 
-void FTBPage::openedImpl()
+void Page::openedImpl()
 {
     if(!initialized)
     {
-        connect(ftbFetchTask.get(), &FtbPackFetchTask::finished, this, &FTBPage::ftbPackDataDownloadSuccessfully);
+        connect(ftbFetchTask.get(), &PackFetchTask::finished, this, &Page::ftbPackDataDownloadSuccessfully);
-        connect(ftbFetchTask.get(), &FtbPackFetchTask::failed, this, &FTBPage::ftbPackDataDownloadFailed);
+        connect(ftbFetchTask.get(), &PackFetchTask::failed, this, &Page::ftbPackDataDownloadFailed);
 
-        connect(ftbFetchTask.get(), &FtbPackFetchTask::privateFileDownloadFinished, this, &FTBPage::ftbPrivatePackDataDownloadSuccessfully);
+        connect(ftbFetchTask.get(), &PackFetchTask::privateFileDownloadFinished, this, &Page::ftbPrivatePackDataDownloadSuccessfully);
-        connect(ftbFetchTask.get(), &FtbPackFetchTask::privateFileDownloadFailed, this, &FTBPage::ftbPrivatePackDataDownloadFailed);
+        connect(ftbFetchTask.get(), &PackFetchTask::privateFileDownloadFailed, this, &Page::ftbPrivatePackDataDownloadFailed);
 
         ftbFetchTask->fetch();
         ftbPrivatePacks->load();
@@ -118,13 +120,13 @@ void FTBPage::openedImpl()
     suggestCurrent();
 }
 
-void FTBPage::suggestCurrent()
+void Page::suggestCurrent()
 {
     if(isOpened)
     {
         if(!selected.broken)
         {
-            dialog->setSuggestedPack(selected.name, new FtbPackInstallTask(selected, selectedVersion));
+            dialog->setSuggestedPack(selected.name, new PackInstallTask(selected, selectedVersion));
             QString editedLogoName;
             if(selected.logo.toLower().startsWith("ftb"))
             {
@@ -137,21 +139,21 @@ void FTBPage::suggestCurrent()
 
             editedLogoName = editedLogoName.left(editedLogoName.lastIndexOf(".png"));
 
-            if(selected.type == FtbPackType::Public)
+            if(selected.type == PackType::Public)
             {
                 publicListModel->getLogo(selected.logo, [this, editedLogoName](QString logo)
                 {
                     dialog->setSuggestedIconFromFile(logo, editedLogoName);
                 });
             }
-            else if (selected.type == FtbPackType::ThirdParty)
+            else if (selected.type == PackType::ThirdParty)
             {
                 thirdPartyModel->getLogo(selected.logo, [this, editedLogoName](QString logo)
                 {
                     dialog->setSuggestedIconFromFile(logo, editedLogoName);
                 });
             }
-            else if (selected.type == FtbPackType::Private)
+            else if (selected.type == PackType::Private)
             {
                 privateListModel->getLogo(selected.logo, [this, editedLogoName](QString logo)
                 {
@@ -166,23 +168,23 @@ void FTBPage::suggestCurrent()
     }
 }
 
-void FTBPage::ftbPackDataDownloadSuccessfully(FtbModpackList publicPacks, FtbModpackList thirdPartyPacks)
+void Page::ftbPackDataDownloadSuccessfully(ModpackList publicPacks, ModpackList thirdPartyPacks)
 {
     publicListModel->fill(publicPacks);
     thirdPartyModel->fill(thirdPartyPacks);
 }
 
-void FTBPage::ftbPackDataDownloadFailed(QString reason)
+void Page::ftbPackDataDownloadFailed(QString reason)
 {
     //TODO: Display the error
 }
 
-void FTBPage::ftbPrivatePackDataDownloadSuccessfully(FtbModpack pack)
+void Page::ftbPrivatePackDataDownloadSuccessfully(Modpack pack)
 {
     privateListModel->addPack(pack);
 }
 
-void FTBPage::ftbPrivatePackDataDownloadFailed(QString reason, QString packCode)
+void Page::ftbPrivatePackDataDownloadFailed(QString reason, QString packCode)
 {
     auto reply = QMessageBox::question(
         this,
@@ -195,40 +197,40 @@ void FTBPage::ftbPrivatePackDataDownloadFailed(QString reason, QString packCode)
     }
 }
 
-void FTBPage::onPublicPackSelectionChanged(QModelIndex now, QModelIndex prev)
+void Page::onPublicPackSelectionChanged(QModelIndex now, QModelIndex prev)
 {
     if(!now.isValid())
     {
         onPackSelectionChanged();
         return;
     }
-    FtbModpack selectedPack = publicFilterModel->data(now, Qt::UserRole).value<FtbModpack>();
+    Modpack selectedPack = publicFilterModel->data(now, Qt::UserRole).value<Modpack>();
     onPackSelectionChanged(&selectedPack);
 }
 
-void FTBPage::onThirdPartyPackSelectionChanged(QModelIndex now, QModelIndex prev)
+void Page::onThirdPartyPackSelectionChanged(QModelIndex now, QModelIndex prev)
 {
     if(!now.isValid())
     {
         onPackSelectionChanged();
         return;
     }
-    FtbModpack selectedPack = thirdPartyFilterModel->data(now, Qt::UserRole).value<FtbModpack>();
+    Modpack selectedPack = thirdPartyFilterModel->data(now, Qt::UserRole).value<Modpack>();
     onPackSelectionChanged(&selectedPack);
 }
 
-void FTBPage::onPrivatePackSelectionChanged(QModelIndex now, QModelIndex prev)
+void Page::onPrivatePackSelectionChanged(QModelIndex now, QModelIndex prev)
 {
     if(!now.isValid())
     {
         onPackSelectionChanged();
         return;
     }
-    FtbModpack selectedPack = privateFilterModel->data(now, Qt::UserRole).value<FtbModpack>();
+    Modpack selectedPack = privateFilterModel->data(now, Qt::UserRole).value<Modpack>();
     onPackSelectionChanged(&selectedPack);
 }
 
-void FTBPage::onPackSelectionChanged(FtbModpack* pack)
+void Page::onPackSelectionChanged(Modpack* pack)
 {
     ui->versionSelectionBox->clear();
     if(pack)
@@ -266,7 +268,7 @@ void FTBPage::onPackSelectionChanged(FtbModpack* pack)
     suggestCurrent();
 }
 
-void FTBPage::onVersionSelectionItemChanged(QString data)
+void Page::onVersionSelectionItemChanged(QString data)
 {
     if(data.isNull() || data.isEmpty())
     {
@@ -278,15 +280,15 @@ void FTBPage::onVersionSelectionItemChanged(QString data)
     suggestCurrent();
 }
 
-void FTBPage::onSortingSelectionChanged(QString data)
+void Page::onSortingSelectionChanged(QString data)
 {
-    FtbFilterModel::Sorting toSet = publicFilterModel->getAvailableSortings().value(data);
+    FilterModel::Sorting toSet = publicFilterModel->getAvailableSortings().value(data);
     publicFilterModel->setSorting(toSet);
     thirdPartyFilterModel->setSorting(toSet);
     privateFilterModel->setSorting(toSet);
 }
 
-void FTBPage::onTabChanged(int tab)
+void Page::onTabChanged(int tab)
 {
     if(tab == 1)
     {
@@ -311,7 +313,7 @@ void FTBPage::onTabChanged(int tab)
     QModelIndex idx = currentList->currentIndex();
     if(idx.isValid())
     {
-        auto pack = currentModel->data(idx, Qt::UserRole).value<FtbModpack>();
+        auto pack = currentModel->data(idx, Qt::UserRole).value<Modpack>();
         onPackSelectionChanged(&pack);
     }
     else
@@ -320,7 +322,7 @@ void FTBPage::onTabChanged(int tab)
     }
 }
 
-void FTBPage::onAddPackClicked()
+void Page::onAddPackClicked()
 {
     bool ok;
     QString text = QInputDialog::getText(
@@ -338,7 +340,7 @@ void FTBPage::onAddPackClicked()
     }
 }
 
-void FTBPage::onRemovePackClicked()
+void Page::onRemovePackClicked()
 {
     auto index = ui->privatePackList->currentIndex();
     if(!index.isValid())
@@ -346,7 +348,7 @@ void FTBPage::onRemovePackClicked()
         return;
     }
     auto row = index.row();
-    FtbModpack pack = privateListModel->at(row);
+    Modpack pack = privateListModel->at(row);
     auto answer = QMessageBox::question(
         this,
         tr("Remove pack"),
@@ -362,3 +364,5 @@ void FTBPage::onRemovePackClicked()
     privateListModel->remove(row);
     onPackSelectionChanged();
 }
+
+}

application/pages/modplatform/legacy_ftb/Page.h

@@ -22,29 +22,32 @@
 #include "pages/BasePage.h"
 #include <MultiMC.h>
 #include "tasks/Task.h"
-#include "modplatform/ftb/PackHelpers.h"
+#include "modplatform/legacy_ftb/PackHelpers.h"
-#include "modplatform/ftb/FtbPackFetchTask.h"
+#include "modplatform/legacy_ftb/PackFetchTask.h"
 #include "QObjectPtr.h"
 
+class NewInstanceDialog;
+
+namespace LegacyFTB {
+
 namespace Ui
 {
-class FTBPage;
+class Page;
 }
 
-class FtbListModel;
+class ListModel;
-class FtbFilterModel;
+class FilterModel;
-class NewInstanceDialog;
+class PrivatePackListModel;
-class FtbPrivatePackListModel;
+class PrivatePackFilterModel;
-class FtbPrivatePackFilterModel;
+class PrivatePackManager;
-class FtbPrivatePackManager;
 
-class FTBPage : public QWidget, public BasePage
+class Page : public QWidget, public BasePage
 {
     Q_OBJECT
 
 public:
-    explicit FTBPage(NewInstanceDialog * dialog, QWidget *parent = 0);
+    explicit Page(NewInstanceDialog * dialog, QWidget *parent = 0);
-    virtual ~FTBPage();
+    virtual ~Page();
     QString displayName() const override
     {
         return tr("FTB Legacy");
@@ -55,7 +58,7 @@ public:
     }
     QString id() const override
     {
-        return "ftb";
+        return "legacy_ftb";
     }
     QString helpPage() const override
     {
@@ -66,13 +69,13 @@ public:
 
 private:
     void suggestCurrent();
-    void onPackSelectionChanged(FtbModpack *pack = nullptr);
+    void onPackSelectionChanged(Modpack *pack = nullptr);
 
 private slots:
-    void ftbPackDataDownloadSuccessfully(FtbModpackList publicPacks, FtbModpackList thirdPartyPacks);
+    void ftbPackDataDownloadSuccessfully(ModpackList publicPacks, ModpackList thirdPartyPacks);
     void ftbPackDataDownloadFailed(QString reason);
 
-    void ftbPrivatePackDataDownloadSuccessfully(FtbModpack pack);
+    void ftbPrivatePackDataDownloadSuccessfully(Modpack pack);
     void ftbPrivatePackDataDownloadFailed(QString reason, QString packCode);
 
     void onSortingSelectionChanged(QString data);
@@ -88,27 +91,29 @@ private slots:
     void onRemovePackClicked();
 
 private:
-    FtbFilterModel* currentModel = nullptr;
+    FilterModel* currentModel = nullptr;
     QTreeView* currentList = nullptr;
     QTextBrowser* currentModpackInfo = nullptr;
 
     bool initialized = false;
-    FtbModpack selected;
+    Modpack selected;
     QString selectedVersion;
 
-    FtbListModel* publicListModel = nullptr;
+    ListModel* publicListModel = nullptr;
-    FtbFilterModel* publicFilterModel = nullptr;
+    FilterModel* publicFilterModel = nullptr;
 
-    FtbListModel *thirdPartyModel = nullptr;
+    ListModel *thirdPartyModel = nullptr;
-    FtbFilterModel *thirdPartyFilterModel = nullptr;
+    FilterModel *thirdPartyFilterModel = nullptr;
 
-    FtbListModel *privateListModel = nullptr;
+    ListModel *privateListModel = nullptr;
-    FtbFilterModel *privateFilterModel = nullptr;
+    FilterModel *privateFilterModel = nullptr;
 
-    unique_qobject_ptr<FtbPackFetchTask> ftbFetchTask;
+    unique_qobject_ptr<PackFetchTask> ftbFetchTask;
-    std::unique_ptr<FtbPrivatePackManager> ftbPrivatePacks;
+    std::unique_ptr<PrivatePackManager> ftbPrivatePacks;
 
     NewInstanceDialog* dialog = nullptr;
 
-    Ui::FTBPage *ui = nullptr;
+    Ui::Page *ui = nullptr;
 };
+
+}

application/pages/modplatform/legacy_ftb/Page.ui

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <ui version="4.0">
- <class>FTBPage</class>
+ <class>LegacyFTB::Page</class>
- <widget class="QWidget" name="FTBPage">
+ <widget class="QWidget" name="LegacyFTB::Page">
   <property name="geometry">
    <rect>
     <x>0</x>