feat: add basic ManagedPackPage classes

The idea is to have a base class that defines common behavior, and
subclasses for each modpack provider, adding specific behavior.

Signed-off-by: flow <flowlnlnln@gmail.com>

2 files changed, 227 insertions, 0 deletions

diff --git a/launcher/ui/pages/instance/ManagedPackPage.cpp b/launcher/ui/pages/instance/ManagedPackPage.cpp
new file mode 100644
index 00000000..725f8ce5
--- /dev/null
+++ b/launcher/ui/pages/instance/ManagedPackPage.cpp
@@ -0,0 +1,129 @@
+#include "ManagedPackPage.h"
+#include "ui_ManagedPackPage.h"
+
+#include <QListView>
+#include <QProxyStyle>
+
+#include "Application.h"
+
+/** This is just to override the combo box popup behavior so that the combo box doesn't take the whole screen.
+ *  ... thanks Qt.
+ */
+class NoBigComboBoxStyle : public QProxyStyle {
+    Q_OBJECT
+
+   public:
+    NoBigComboBoxStyle(QStyle* style) : QProxyStyle(style) {}
+
+    // clang-format off
+    int styleHint(QStyle::StyleHint hint, const QStyleOption* option = nullptr, const QWidget* widget = nullptr, QStyleHintReturn* returnData = nullptr) const override
+    {
+        if (hint == QStyle::SH_ComboBox_Popup)
+            return false;
+
+        return QProxyStyle::styleHint(hint, option, widget, returnData);
+    }
+    // clang-format on
+};
+
+ManagedPackPage* ManagedPackPage::createPage(BaseInstance* inst, QString type, QWidget* parent)
+{
+    if (type == "modrinth")
+        return new ModrinthManagedPackPage(inst, parent);
+    if (type == "flame")
+        return new FlameManagedPackPage(inst, parent);
+
+    return new GenericManagedPackPage(inst, parent);
+}
+
+ManagedPackPage::ManagedPackPage(BaseInstance* inst, QWidget* parent) : QWidget(parent), ui(new Ui::ManagedPackPage), m_inst(inst)
+{
+    Q_ASSERT(inst);
+
+    ui->setupUi(this);
+
+    ui->versionsComboBox->setStyle(new NoBigComboBoxStyle(ui->versionsComboBox->style()));
+}
+
+ManagedPackPage::~ManagedPackPage()
+{
+    delete ui;
+}
+
+void ManagedPackPage::openedImpl()
+{
+    ui->packName->setText(m_inst->getManagedPackName());
+    ui->packVersion->setText(m_inst->getManagedPackVersionName());
+    ui->packOrigin->setText(tr("Website: %1    |    Pack ID: %2    |    Version ID: %3")
+                                .arg(displayName(), m_inst->getManagedPackID(), m_inst->getManagedPackVersionID()));
+
+    parseManagedPack();
+}
+
+QString ManagedPackPage::displayName() const
+{
+    auto type = m_inst->getManagedPackType();
+    if (type.isEmpty())
+        return {};
+    return type.replace(0, 1, type[0].toUpper());
+}
+
+QIcon ManagedPackPage::icon() const
+{
+    return APPLICATION->getThemedIcon(m_inst->getManagedPackType());
+}
+
+QString ManagedPackPage::helpPage() const
+{
+    return {};
+}
+
+void ManagedPackPage::retranslate()
+{
+    ui->retranslateUi(this);
+}
+
+bool ManagedPackPage::shouldDisplay() const
+{
+    return m_inst->isManagedPack();
+}
+
+ModrinthManagedPackPage::ModrinthManagedPackPage(BaseInstance* inst, QWidget* parent) : ManagedPackPage(inst, parent)
+{
+    Q_ASSERT(inst->isManagedPack());
+    connect(ui->versionsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(suggestVersion()));
+}
+
+void ModrinthManagedPackPage::parseManagedPack()
+{
+}
+
+QString ModrinthManagedPackPage::url() const
+{
+    return {};
+}
+
+void ModrinthManagedPackPage::suggestVersion()
+{
+}
+
+FlameManagedPackPage::FlameManagedPackPage(BaseInstance* inst, QWidget* parent) : ManagedPackPage(inst, parent)
+{
+    Q_ASSERT(inst->isManagedPack());
+    connect(ui->versionsComboBox, SIGNAL(currentIndexChanged(int)), this, SLOT(suggestVersion()));
+}
+
+void FlameManagedPackPage::parseManagedPack()
+{
+}
+
+QString FlameManagedPackPage::url() const
+{
+    return {};
+}
+
+void FlameManagedPackPage::suggestVersion()
+{
+}
+
+#include "ManagedPackPage.moc"
diff --git a/launcher/ui/pages/instance/ManagedPackPage.h b/launcher/ui/pages/instance/ManagedPackPage.h
new file mode 100644
index 00000000..be49383c
--- /dev/null
+++ b/launcher/ui/pages/instance/ManagedPackPage.h
@@ -0,0 +1,98 @@
+#pragma once
+
+#include "BaseInstance.h"
+
+#include "modplatform/modrinth/ModrinthAPI.h"
+#include "modplatform/modrinth/ModrinthPackManifest.h"
+
+#include "ui/pages/BasePage.h"
+
+#include <QWidget>
+
+namespace Ui {
+class ManagedPackPage;
+}
+
+class ManagedPackPage : public QWidget, public BasePage {
+    Q_OBJECT
+
+   public:
+    inline static ManagedPackPage* createPage(BaseInstance* inst, QWidget* parent = nullptr)
+    {
+        return ManagedPackPage::createPage(inst, inst->getManagedPackType(), parent);
+    }
+
+    static ManagedPackPage* createPage(BaseInstance* inst, QString type, QWidget* parent = nullptr);
+    ~ManagedPackPage() override;
+
+    [[nodiscard]] QString displayName() const override;
+    [[nodiscard]] QIcon icon() const override;
+    [[nodiscard]] QString helpPage() const override;
+    [[nodiscard]] QString id() const override { return "managed_pack"; }
+    [[nodiscard]] bool shouldDisplay() const override;
+
+    void openedImpl() override;
+
+    bool apply() override { return true; }
+    void retranslate() override;
+
+    /** Gets the necessary information about the managed pack, such as
+     *  available versions*/
+    virtual void parseManagedPack() {};
+
+    /** URL of the managed pack.
+     *  Not the version-specific one.
+     */
+    [[nodiscard]] virtual QString url() const { return {}; };
+
+   public slots:
+    /** Gets the current version selection and update the changelog.
+     */
+    virtual void suggestVersion() {};
+
+   protected:
+    ManagedPackPage(BaseInstance* inst, QWidget* parent = nullptr);
+
+   protected:
+    Ui::ManagedPackPage* ui;
+    BaseInstance* m_inst;
+
+    bool m_loaded = false;
+};
+
+/** Simple page for when we aren't a managed pack. */
+class GenericManagedPackPage final : public ManagedPackPage {
+    Q_OBJECT
+
+   public:
+    GenericManagedPackPage(BaseInstance* inst, QWidget* parent = nullptr) : ManagedPackPage(inst, parent) {}
+    ~GenericManagedPackPage() override = default;
+};
+
+class ModrinthManagedPackPage final : public ManagedPackPage {
+    Q_OBJECT
+
+   public:
+    ModrinthManagedPackPage(BaseInstance* inst, QWidget* parent = nullptr);
+    ~ModrinthManagedPackPage() override = default;
+
+    void parseManagedPack() override;
+    [[nodiscard]] QString url() const override;
+
+   public slots:
+    void suggestVersion() override;
+};
+
+class FlameManagedPackPage final : public ManagedPackPage {
+    Q_OBJECT
+
+   public:
+    FlameManagedPackPage(BaseInstance* inst, QWidget* parent = nullptr);
+    ~FlameManagedPackPage() override = default;
+
+    void parseManagedPack() override;
+    [[nodiscard]] QString url() const override;
+
+   public slots:
+    void suggestVersion() override;
+};