NOISSUE Flatten gui and logic libraries into MultiMC

launcher/tools/BaseExternalTool.cpp

@@ -0,0 +1,41 @@
+#include "BaseExternalTool.h"
+
+#include <QProcess>
+#include <QDir>
+
+#ifdef Q_OS_WIN
+#include <windows.h>
+#endif
+
+#include "BaseInstance.h"
+
+BaseExternalTool::BaseExternalTool(SettingsObjectPtr settings, InstancePtr instance, QObject *parent)
+    : QObject(parent), m_instance(instance), globalSettings(settings)
+{
+}
+
+BaseExternalTool::~BaseExternalTool()
+{
+}
+
+BaseDetachedTool::BaseDetachedTool(SettingsObjectPtr settings, InstancePtr instance, QObject *parent)
+    : BaseExternalTool(settings, instance, parent)
+{
+
+}
+
+void BaseDetachedTool::run()
+{
+    runImpl();
+}
+
+
+BaseExternalToolFactory::~BaseExternalToolFactory()
+{
+}
+
+BaseDetachedTool *BaseDetachedToolFactory::createDetachedTool(InstancePtr instance,
+                                                              QObject *parent)
+{
+    return qobject_cast<BaseDetachedTool *>(createTool(instance, parent));
+}

launcher/tools/BaseExternalTool.h

@@ -0,0 +1,58 @@
+#pragma once
+
+#include <QObject>
+#include <BaseInstance.h>
+
+class BaseInstance;
+class SettingsObject;
+class QProcess;
+
+class BaseExternalTool : public QObject
+{
+    Q_OBJECT
+public:
+    explicit BaseExternalTool(SettingsObjectPtr settings, InstancePtr instance, QObject *parent = 0);
+    virtual ~BaseExternalTool();
+
+protected:
+    InstancePtr m_instance;
+    SettingsObjectPtr globalSettings;
+};
+
+class BaseDetachedTool : public BaseExternalTool
+{
+    Q_OBJECT
+public:
+    explicit BaseDetachedTool(SettingsObjectPtr settings, InstancePtr instance, QObject *parent = 0);
+
+public
+slots:
+    void run();
+
+protected:
+    virtual void runImpl() = 0;
+};
+
+class BaseExternalToolFactory
+{
+public:
+    virtual ~BaseExternalToolFactory();
+
+    virtual QString name() const = 0;
+
+    virtual void registerSettings(SettingsObjectPtr settings) = 0;
+
+    virtual BaseExternalTool *createTool(InstancePtr instance, QObject *parent = 0) = 0;
+
+    virtual bool check(QString *error) = 0;
+    virtual bool check(const QString &path, QString *error) = 0;
+
+protected:
+    SettingsObjectPtr globalSettings;
+};
+
+class BaseDetachedToolFactory : public BaseExternalToolFactory
+{
+public:
+    virtual BaseDetachedTool *createDetachedTool(InstancePtr instance, QObject *parent = 0);
+};

launcher/tools/BaseProfiler.cpp

@@ -0,0 +1,36 @@
+#include "BaseProfiler.h"
+#include "QObjectPtr.h"
+
+#include <QProcess>
+
+BaseProfiler::BaseProfiler(SettingsObjectPtr settings, InstancePtr instance, QObject *parent)
+    : BaseExternalTool(settings, instance, parent)
+{
+}
+
+void BaseProfiler::beginProfiling(shared_qobject_ptr<LaunchTask> process)
+{
+    beginProfilingImpl(process);
+}
+
+void BaseProfiler::abortProfiling()
+{
+    abortProfilingImpl();
+}
+
+void BaseProfiler::abortProfilingImpl()
+{
+    if (!m_profilerProcess)
+    {
+        return;
+    }
+    m_profilerProcess->terminate();
+    m_profilerProcess->deleteLater();
+    m_profilerProcess = 0;
+    emit abortLaunch(tr("Profiler aborted"));
+}
+
+BaseProfiler *BaseProfilerFactory::createProfiler(InstancePtr instance, QObject *parent)
+{
+    return qobject_cast<BaseProfiler *>(createTool(instance, parent));
+}

launcher/tools/BaseProfiler.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include "BaseExternalTool.h"
+#include "QObjectPtr.h"
+
+class BaseInstance;
+class SettingsObject;
+class LaunchTask;
+class QProcess;
+
+class BaseProfiler : public BaseExternalTool
+{
+    Q_OBJECT
+public:
+    explicit BaseProfiler(SettingsObjectPtr settings, InstancePtr instance, QObject *parent = 0);
+
+public
+slots:
+    void beginProfiling(shared_qobject_ptr<LaunchTask> process);
+    void abortProfiling();
+
+protected:
+    QProcess *m_profilerProcess;
+
+    virtual void beginProfilingImpl(shared_qobject_ptr<LaunchTask> process) = 0;
+    virtual void abortProfilingImpl();
+
+signals:
+    void readyToLaunch(const QString &message);
+    void abortLaunch(const QString &message);
+};
+
+class BaseProfilerFactory : public BaseExternalToolFactory
+{
+public:
+    virtual BaseProfiler *createProfiler(InstancePtr instance, QObject *parent = 0);
+};

launcher/tools/JProfiler.cpp

@@ -0,0 +1,116 @@
+#include "JProfiler.h"
+
+#include <QDir>
+
+#include "settings/SettingsObject.h"
+#include "launch/LaunchTask.h"
+#include "BaseInstance.h"
+
+class JProfiler : public BaseProfiler
+{
+    Q_OBJECT
+public:
+    JProfiler(SettingsObjectPtr settings, InstancePtr instance, QObject *parent = 0);
+
+private slots:
+    void profilerStarted();
+    void profilerFinished(int exit, QProcess::ExitStatus status);
+
+protected:
+    void beginProfilingImpl(shared_qobject_ptr<LaunchTask> process);
+
+private:
+    int listeningPort = 0;
+};
+
+JProfiler::JProfiler(SettingsObjectPtr settings, InstancePtr instance,
+                     QObject *parent)
+    : BaseProfiler(settings, instance, parent)
+{
+}
+
+void JProfiler::profilerStarted()
+{
+    emit readyToLaunch(tr("Listening on port: %1").arg(listeningPort));
+}
+
+void JProfiler::profilerFinished(int exit, QProcess::ExitStatus status)
+{
+    if (status == QProcess::CrashExit)
+    {
+        emit abortLaunch(tr("Profiler aborted"));
+    }
+    if (m_profilerProcess)
+    {
+        m_profilerProcess->deleteLater();
+        m_profilerProcess = 0;
+    }
+}
+
+void JProfiler::beginProfilingImpl(shared_qobject_ptr<LaunchTask> process)
+{
+    listeningPort = globalSettings->get("JProfilerPort").toInt();
+    QProcess *profiler = new QProcess(this);
+    QStringList profilerArgs =
+    {
+        "-d", QString::number(process->pid()),
+        "--gui",
+        "-p", QString::number(listeningPort)
+    };
+    auto basePath = globalSettings->get("JProfilerPath").toString();
+
+#ifdef Q_OS_WIN
+    QString profilerProgram = QDir(basePath).absoluteFilePath("bin/jpenable.exe");
+#else
+    QString profilerProgram = QDir(basePath).absoluteFilePath("bin/jpenable");
+#endif
+
+    profiler->setArguments(profilerArgs);
+    profiler->setProgram(profilerProgram);
+
+    connect(profiler, SIGNAL(started()), SLOT(profilerStarted()));
+    connect(profiler, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(profilerFinished(int,QProcess::ExitStatus)));
+
+    m_profilerProcess = profiler;
+    profiler->start();
+}
+
+void JProfilerFactory::registerSettings(SettingsObjectPtr settings)
+{
+    settings->registerSetting("JProfilerPath");
+    settings->registerSetting("JProfilerPort", 42042);
+    globalSettings = settings;
+}
+
+BaseExternalTool *JProfilerFactory::createTool(InstancePtr instance, QObject *parent)
+{
+    return new JProfiler(globalSettings, instance, parent);
+}
+
+bool JProfilerFactory::check(QString *error)
+{
+    return check(globalSettings->get("JProfilerPath").toString(), error);
+}
+
+bool JProfilerFactory::check(const QString &path, QString *error)
+{
+    if (path.isEmpty())
+    {
+        *error = QObject::tr("Empty path");
+        return false;
+    }
+    QDir dir(path);
+    if (!dir.exists())
+    {
+        *error = QObject::tr("Path does not exist");
+        return false;
+    }
+    if (!dir.exists("bin") || !(dir.exists("bin/jprofiler") || dir.exists("bin/jprofiler.exe")) || !dir.exists("bin/agent.jar"))
+    {
+        *error = QObject::tr("Invalid JProfiler install");
+        return false;
+    }
+    return true;
+}
+
+#include "JProfiler.moc"

launcher/tools/JProfiler.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "BaseProfiler.h"
+
+class JProfilerFactory : public BaseProfilerFactory
+{
+public:
+    QString name() const override { return "JProfiler"; }
+    void registerSettings(SettingsObjectPtr settings) override;
+    BaseExternalTool *createTool(InstancePtr instance, QObject *parent = 0) override;
+    bool check(QString *error) override;
+    bool check(const QString &path, QString *error) override;
+};

launcher/tools/JVisualVM.cpp

@@ -0,0 +1,104 @@
+#include "JVisualVM.h"
+
+#include <QDir>
+#include <QStandardPaths>
+
+#include "settings/SettingsObject.h"
+#include "launch/LaunchTask.h"
+#include "BaseInstance.h"
+
+class JVisualVM : public BaseProfiler
+{
+    Q_OBJECT
+public:
+    JVisualVM(SettingsObjectPtr settings, InstancePtr instance, QObject *parent = 0);
+
+private slots:
+    void profilerStarted();
+    void profilerFinished(int exit, QProcess::ExitStatus status);
+
+protected:
+    void beginProfilingImpl(shared_qobject_ptr<LaunchTask> process);
+};
+
+
+JVisualVM::JVisualVM(SettingsObjectPtr settings, InstancePtr instance, QObject *parent)
+    : BaseProfiler(settings, instance, parent)
+{
+}
+
+void JVisualVM::profilerStarted()
+{
+    emit readyToLaunch(tr("JVisualVM started"));
+}
+
+void JVisualVM::profilerFinished(int exit, QProcess::ExitStatus status)
+{
+    if (status == QProcess::CrashExit)
+    {
+        emit abortLaunch(tr("Profiler aborted"));
+    }
+    if (m_profilerProcess)
+    {
+        m_profilerProcess->deleteLater();
+        m_profilerProcess = 0;
+    }
+}
+
+void JVisualVM::beginProfilingImpl(shared_qobject_ptr<LaunchTask> process)
+{
+    QProcess *profiler = new QProcess(this);
+    QStringList profilerArgs =
+    {
+        "--openpid", QString::number(process->pid())
+    };
+    auto programPath = globalSettings->get("JVisualVMPath").toString();
+
+    profiler->setArguments(profilerArgs);
+    profiler->setProgram(programPath);
+
+    connect(profiler, SIGNAL(started()), SLOT(profilerStarted()));
+    connect(profiler, SIGNAL(finished(int, QProcess::ExitStatus)), SLOT(profilerFinished(int,QProcess::ExitStatus)));
+
+    profiler->start();
+    m_profilerProcess = profiler;
+}
+
+void JVisualVMFactory::registerSettings(SettingsObjectPtr settings)
+{
+    QString defaultValue = QStandardPaths::findExecutable("jvisualvm");
+    if (defaultValue.isNull())
+    {
+        defaultValue = QStandardPaths::findExecutable("visualvm");
+    }
+    settings->registerSetting("JVisualVMPath", defaultValue);
+    globalSettings = settings;
+}
+
+BaseExternalTool *JVisualVMFactory::createTool(InstancePtr instance, QObject *parent)
+{
+    return new JVisualVM(globalSettings, instance, parent);
+}
+
+bool JVisualVMFactory::check(QString *error)
+{
+    return check(globalSettings->get("JVisualVMPath").toString(), error);
+}
+
+bool JVisualVMFactory::check(const QString &path, QString *error)
+{
+    if (path.isEmpty())
+    {
+        *error = QObject::tr("Empty path");
+        return false;
+    }
+    QFileInfo finfo(path);
+    if (!finfo.isExecutable() || !finfo.fileName().contains("visualvm"))
+    {
+        *error = QObject::tr("Invalid path to JVisualVM");
+        return false;
+    }
+    return true;
+}
+
+#include "JVisualVM.moc"

launcher/tools/JVisualVM.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include "BaseProfiler.h"
+
+class JVisualVMFactory : public BaseProfilerFactory
+{
+public:
+    QString name() const override { return "JVisualVM"; }
+    void registerSettings(SettingsObjectPtr settings) override;
+    BaseExternalTool *createTool(InstancePtr instance, QObject *parent = 0) override;
+    bool check(QString *error) override;
+    bool check(const QString &path, QString *error) override;
+};

launcher/tools/MCEditTool.cpp

@@ -0,0 +1,77 @@
+#include "MCEditTool.h"
+
+#include <QDir>
+#include <QProcess>
+#include <QUrl>
+
+#include "settings/SettingsObject.h"
+#include "BaseInstance.h"
+#include "minecraft/MinecraftInstance.h"
+
+MCEditTool::MCEditTool(SettingsObjectPtr settings)
+{
+    settings->registerSetting("MCEditPath");
+    m_settings = settings;
+}
+
+void MCEditTool::setPath(QString& path)
+{
+    m_settings->set("MCEditPath", path);
+}
+
+QString MCEditTool::path() const
+{
+    return m_settings->get("MCEditPath").toString();
+}
+
+bool MCEditTool::check(const QString& toolPath, QString& error)
+{
+    if (toolPath.isEmpty())
+    {
+        error = QObject::tr("Path is empty");
+        return false;
+    }
+    const QDir dir(toolPath);
+    if (!dir.exists())
+    {
+        error = QObject::tr("Path does not exist");
+        return false;
+    }
+    if (!dir.exists("mcedit.sh") && !dir.exists("mcedit.py") && !dir.exists("mcedit.exe") && !dir.exists("Contents") && !dir.exists("mcedit2.exe"))
+    {
+        error = QObject::tr("Path does not seem to be a MCEdit path");
+        return false;
+    }
+    return true;
+}
+
+QString MCEditTool::getProgramPath()
+{
+#ifdef Q_OS_OSX
+    return path();
+#else
+    const QString mceditPath = path();
+    QDir mceditDir(mceditPath);
+#ifdef Q_OS_LINUX
+    if (mceditDir.exists("mcedit.sh"))
+    {
+        return mceditDir.absoluteFilePath("mcedit.sh");
+    }
+    else if (mceditDir.exists("mcedit.py"))
+    {
+        return mceditDir.absoluteFilePath("mcedit.py");
+    }
+    return QString();
+#elif defined(Q_OS_WIN32)
+    if (mceditDir.exists("mcedit.exe"))
+    {
+        return mceditDir.absoluteFilePath("mcedit.exe");
+    }
+    else if (mceditDir.exists("mcedit2.exe"))
+    {
+        return mceditDir.absoluteFilePath("mcedit2.exe");
+    }
+    return QString();
+#endif
+#endif
+}

launcher/tools/MCEditTool.h

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <QString>
+#include "settings/SettingsObject.h"
+
+class MCEditTool
+{
+public:
+    MCEditTool(SettingsObjectPtr settings);
+    void setPath(QString & path);
+    QString path() const;
+    bool check(const QString &toolPath, QString &error);
+    QString getProgramPath();
+private:
+    SettingsObjectPtr m_settings;
+};