2022-10-25 01:20:35 +05:30
|
|
|
// SPDX-FileCopyrightText: 2022 Sefa Eyeoglu <contact@scrumplex.net>
|
|
|
|
//
|
|
|
|
// SPDX-License-Identifier: GPL-3.0-only AND Apache-2.0
|
|
|
|
|
2022-03-19 17:16:56 +05:30
|
|
|
/*
|
2022-11-03 09:24:57 +05:30
|
|
|
* Prism Launcher - Minecraft Launcher
|
2022-03-19 17:16:56 +05:30
|
|
|
* Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
|
2022-05-13 22:18:19 +05:30
|
|
|
* Copyright (C) 2022 Lenny McLennington <lenny@sneed.church>
|
2022-11-01 20:11:08 +05:30
|
|
|
* Copyright (C) 2022 Tayou <tayou@gmx.net>
|
2023-03-01 15:24:49 +05:30
|
|
|
* Copyright (C) 2023 TheKodeToad <TheKodeToad@proton.me>
|
2023-05-06 02:43:34 +05:30
|
|
|
* Copyright (C) 2023 Rachel Powers <508861+Ryex@users.noreply.github.com>
|
2022-03-19 17:16:56 +05:30
|
|
|
*
|
|
|
|
* This program is free software: you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation, version 3.
|
|
|
|
*
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
*
|
|
|
|
* This file incorporates work covered by the following copyright and
|
|
|
|
* permission notice:
|
|
|
|
*
|
|
|
|
* Copyright 2013-2021 MultiMC Contributors
|
|
|
|
*
|
|
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
* you may not use this file except in compliance with the License.
|
|
|
|
* You may obtain a copy of the License at
|
|
|
|
*
|
|
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
*
|
|
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
* See the License for the specific language governing permissions and
|
|
|
|
* limitations under the License.
|
|
|
|
*/
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
#include "Application.h"
|
2014-04-06 07:29:37 +05:30
|
|
|
#include "BuildConfig.h"
|
2019-07-22 00:42:05 +05:30
|
|
|
|
2022-10-23 05:15:32 +05:30
|
|
|
#include "DataMigrationTask.h"
|
2022-05-12 02:14:06 +05:30
|
|
|
#include "net/PasteUpload.h"
|
2022-10-23 05:15:32 +05:30
|
|
|
#include "pathmatcher/MultiMatcher.h"
|
|
|
|
#include "pathmatcher/SimplePrefixMatcher.h"
|
2023-04-01 07:55:01 +05:30
|
|
|
#include "settings/INIFile.h"
|
2021-11-22 08:25:16 +05:30
|
|
|
#include "ui/MainWindow.h"
|
|
|
|
#include "ui/InstanceWindow.h"
|
2019-07-22 00:42:05 +05:30
|
|
|
|
2022-10-23 05:15:32 +05:30
|
|
|
#include "ui/dialogs/ProgressDialog.h"
|
2021-11-22 08:25:16 +05:30
|
|
|
#include "ui/instanceview/AccessibleInstanceView.h"
|
2016-10-21 12:37:26 +05:30
|
|
|
|
2021-11-22 08:25:16 +05:30
|
|
|
#include "ui/pages/BasePageProvider.h"
|
|
|
|
#include "ui/pages/global/LauncherPage.h"
|
|
|
|
#include "ui/pages/global/MinecraftPage.h"
|
|
|
|
#include "ui/pages/global/JavaPage.h"
|
|
|
|
#include "ui/pages/global/LanguagePage.h"
|
|
|
|
#include "ui/pages/global/ProxyPage.h"
|
|
|
|
#include "ui/pages/global/ExternalToolsPage.h"
|
|
|
|
#include "ui/pages/global/AccountListPage.h"
|
2022-02-13 00:38:50 +05:30
|
|
|
#include "ui/pages/global/APIPage.h"
|
2021-11-22 08:25:16 +05:30
|
|
|
#include "ui/pages/global/CustomCommandsPage.h"
|
|
|
|
|
|
|
|
#include "ui/setupwizard/SetupWizard.h"
|
|
|
|
#include "ui/setupwizard/LanguageWizardPage.h"
|
|
|
|
#include "ui/setupwizard/JavaWizardPage.h"
|
2022-05-17 09:30:06 +05:30
|
|
|
#include "ui/setupwizard/PasteWizardPage.h"
|
2022-10-22 23:13:04 +05:30
|
|
|
#include "ui/setupwizard/ThemeWizardPage.h"
|
2021-11-22 08:25:16 +05:30
|
|
|
|
|
|
|
#include "ui/dialogs/CustomMessageBox.h"
|
2021-11-01 02:12:06 +05:30
|
|
|
|
2021-11-22 08:25:16 +05:30
|
|
|
#include "ui/pagedialog/PageDialog.h"
|
|
|
|
|
2022-11-01 20:11:08 +05:30
|
|
|
#include "ui/themes/ThemeManager.h"
|
|
|
|
|
2021-11-22 08:25:16 +05:30
|
|
|
#include "ApplicationMessage.h"
|
2016-12-01 06:47:27 +05:30
|
|
|
|
2013-09-07 07:30:58 +05:30
|
|
|
#include <iostream>
|
2023-02-02 04:01:12 +05:30
|
|
|
#include <mutex>
|
2021-11-22 08:25:16 +05:30
|
|
|
|
2023-02-13 11:02:34 +05:30
|
|
|
#include <QFileOpenEvent>
|
2021-11-22 08:25:16 +05:30
|
|
|
#include <QAccessible>
|
2022-09-26 16:00:49 +05:30
|
|
|
#include <QCommandLineParser>
|
2013-09-07 07:30:58 +05:30
|
|
|
#include <QDir>
|
2013-12-07 00:29:58 +05:30
|
|
|
#include <QFileInfo>
|
2013-09-07 07:30:58 +05:30
|
|
|
#include <QNetworkAccessManager>
|
2013-09-09 03:13:19 +05:30
|
|
|
#include <QTranslator>
|
|
|
|
#include <QLibraryInfo>
|
2020-02-05 04:59:23 +05:30
|
|
|
#include <QList>
|
2013-12-07 00:29:58 +05:30
|
|
|
#include <QStringList>
|
2015-02-02 06:44:14 +05:30
|
|
|
#include <QDebug>
|
2016-10-22 05:13:36 +05:30
|
|
|
#include <QStyleFactory>
|
2022-04-16 11:37:29 +05:30
|
|
|
#include <QWindow>
|
2022-05-02 22:40:45 +05:30
|
|
|
#include <QIcon>
|
2013-09-07 07:30:58 +05:30
|
|
|
|
2015-02-09 06:21:14 +05:30
|
|
|
#include "InstanceList.h"
|
2022-11-16 02:43:15 +05:30
|
|
|
#include "MTPixmapCache.h"
|
2016-10-03 04:25:54 +05:30
|
|
|
|
2021-07-27 01:14:11 +05:30
|
|
|
#include <minecraft/auth/AccountList.h>
|
2015-02-09 06:21:14 +05:30
|
|
|
#include "icons/IconList.h"
|
|
|
|
#include "net/HttpMetaCache.h"
|
2013-09-07 07:30:58 +05:30
|
|
|
|
2015-02-09 06:21:14 +05:30
|
|
|
#include "java/JavaUtils.h"
|
2013-10-07 04:14:34 +05:30
|
|
|
|
2022-11-02 03:15:15 +05:30
|
|
|
#include "updater/ExternalUpdater.h"
|
2013-10-07 04:14:34 +05:30
|
|
|
|
2015-02-09 06:21:14 +05:30
|
|
|
#include "tools/JProfiler.h"
|
|
|
|
#include "tools/JVisualVM.h"
|
|
|
|
#include "tools/MCEditTool.h"
|
2014-02-15 18:49:35 +05:30
|
|
|
|
2015-02-09 06:21:14 +05:30
|
|
|
#include "settings/INISettingsObject.h"
|
|
|
|
#include "settings/Setting.h"
|
2015-02-02 06:44:14 +05:30
|
|
|
|
2016-12-05 06:59:08 +05:30
|
|
|
#include "translations/TranslationsModel.h"
|
2021-11-22 03:51:12 +05:30
|
|
|
#include "meta/Index.h"
|
2013-09-07 07:30:58 +05:30
|
|
|
|
2015-10-05 05:17:27 +05:30
|
|
|
#include <FileSystem.h>
|
2016-01-05 12:02:52 +05:30
|
|
|
#include <DesktopServices.h>
|
2016-10-30 07:07:38 +05:30
|
|
|
#include <LocalPeer.h>
|
2016-11-22 06:32:49 +05:30
|
|
|
|
|
|
|
#include <sys.h>
|
2015-10-05 05:17:27 +05:30
|
|
|
|
2022-08-09 00:33:02 +05:30
|
|
|
#ifdef Q_OS_LINUX
|
|
|
|
#include <dlfcn.h>
|
|
|
|
#include "gamemode_client.h"
|
2022-12-11 15:31:33 +05:30
|
|
|
#include "MangoHud.h"
|
2022-08-09 00:33:02 +05:30
|
|
|
#endif
|
|
|
|
|
2022-11-02 03:15:15 +05:30
|
|
|
#ifdef Q_OS_MAC
|
|
|
|
#include "updater/MacSparkleUpdater.h"
|
|
|
|
#endif
|
|
|
|
|
2018-02-17 04:30:06 +05:30
|
|
|
|
2016-06-09 05:28:50 +05:30
|
|
|
#if defined Q_OS_WIN32
|
|
|
|
#ifndef WIN32_LEAN_AND_MEAN
|
|
|
|
#define WIN32_LEAN_AND_MEAN
|
|
|
|
#endif
|
|
|
|
#include <windows.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#endif
|
|
|
|
|
2017-05-13 04:54:15 +05:30
|
|
|
#define STRINGIFY(x) #x
|
|
|
|
#define TOSTRING(x) STRINGIFY(x)
|
|
|
|
|
2016-11-18 20:34:08 +05:30
|
|
|
static const QLatin1String liveCheckFile("live.check");
|
|
|
|
|
2022-11-16 02:43:15 +05:30
|
|
|
PixmapCache* PixmapCache::s_instance = nullptr;
|
|
|
|
|
2021-09-05 00:57:09 +05:30
|
|
|
namespace {
|
2022-08-19 06:02:57 +05:30
|
|
|
|
|
|
|
/** This is used so that we can output to the log file in addition to the CLI. */
|
2021-09-05 00:57:09 +05:30
|
|
|
void appDebugOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
|
2017-07-05 21:32:49 +05:30
|
|
|
{
|
2023-02-02 04:01:12 +05:30
|
|
|
static std::mutex loggerMutex;
|
|
|
|
const std::lock_guard<std::mutex> lock(loggerMutex); // synchronized, QFile logFile is not thread-safe
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2022-08-19 06:02:57 +05:30
|
|
|
QString out = qFormatLogMessage(type, context, msg);
|
|
|
|
out += QChar::LineFeed;
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
APPLICATION->logFile->write(out.toUtf8());
|
|
|
|
APPLICATION->logFile->flush();
|
2018-07-15 18:21:05 +05:30
|
|
|
QTextStream(stderr) << out.toLocal8Bit();
|
|
|
|
fflush(stderr);
|
2017-07-05 21:32:49 +05:30
|
|
|
}
|
|
|
|
|
2021-09-05 00:57:09 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
Application::Application(int &argc, char **argv) : QApplication(argc, argv)
|
2013-09-07 07:30:58 +05:30
|
|
|
{
|
2016-06-09 05:28:50 +05:30
|
|
|
#if defined Q_OS_WIN32
|
2018-07-15 18:21:05 +05:30
|
|
|
// attach the parent console
|
|
|
|
if(AttachConsole(ATTACH_PARENT_PROCESS))
|
|
|
|
{
|
|
|
|
// if attach succeeds, reopen and sync all the i/o
|
|
|
|
if(freopen("CON", "w", stdout))
|
|
|
|
{
|
|
|
|
std::cout.sync_with_stdio();
|
|
|
|
}
|
|
|
|
if(freopen("CON", "w", stderr))
|
|
|
|
{
|
|
|
|
std::cerr.sync_with_stdio();
|
|
|
|
}
|
|
|
|
if(freopen("CON", "r", stdin))
|
|
|
|
{
|
|
|
|
std::cin.sync_with_stdio();
|
|
|
|
}
|
|
|
|
auto out = GetStdHandle (STD_OUTPUT_HANDLE);
|
|
|
|
DWORD written;
|
|
|
|
const char * endline = "\n";
|
|
|
|
WriteConsole(out, endline, strlen(endline), &written, NULL);
|
|
|
|
consoleAttached = true;
|
|
|
|
}
|
2016-06-09 05:28:50 +05:30
|
|
|
#endif
|
2021-10-18 04:17:02 +05:30
|
|
|
setOrganizationName(BuildConfig.LAUNCHER_NAME);
|
|
|
|
setOrganizationDomain(BuildConfig.LAUNCHER_DOMAIN);
|
|
|
|
setApplicationName(BuildConfig.LAUNCHER_NAME);
|
2022-06-18 17:30:28 +05:30
|
|
|
setApplicationDisplayName(QString("%1 %2").arg(BuildConfig.LAUNCHER_DISPLAYNAME, BuildConfig.printableVersionString()));
|
2022-11-16 07:03:51 +05:30
|
|
|
setApplicationVersion(BuildConfig.printableVersionString() + "\n" + BuildConfig.GIT_COMMIT);
|
2022-02-14 00:34:49 +05:30
|
|
|
setDesktopFileName(BuildConfig.LAUNCHER_DESKTOPFILENAME);
|
2018-07-15 18:21:05 +05:30
|
|
|
startTime = QDateTime::currentDateTime();
|
|
|
|
|
|
|
|
// Don't quit on hiding the last window
|
|
|
|
this->setQuitOnLastWindowClosed(false);
|
|
|
|
|
|
|
|
// Commandline parsing
|
2022-09-26 16:00:49 +05:30
|
|
|
QCommandLineParser parser;
|
2022-10-18 13:20:27 +05:30
|
|
|
parser.setApplicationDescription(BuildConfig.LAUNCHER_DISPLAYNAME);
|
2022-09-26 16:00:49 +05:30
|
|
|
|
|
|
|
parser.addOptions({
|
|
|
|
{{"d", "dir"}, "Use a custom path as application root (use '.' for current directory)", "directory"},
|
|
|
|
{{"l", "launch"}, "Launch the specified instance (by instance ID)", "instance"},
|
|
|
|
{{"s", "server"}, "Join the specified server on launch (only valid in combination with --launch)", "address"},
|
|
|
|
{{"a", "profile"}, "Use the account specified by its profile name (only valid in combination with --launch)", "profile"},
|
|
|
|
{"alive", "Write a small '" + liveCheckFile + "' file after the launcher starts"},
|
2022-10-22 00:10:28 +05:30
|
|
|
{{"I", "import"}, "Import instance from specified zip (local path or URL)", "file"},
|
|
|
|
{"show", "Opens the window for the specified instance (by instance ID)", "show"}
|
2022-09-26 16:00:49 +05:30
|
|
|
});
|
|
|
|
parser.addHelpOption();
|
|
|
|
parser.addVersionOption();
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2022-09-26 16:00:49 +05:30
|
|
|
parser.process(arguments());
|
2022-02-16 21:54:58 +05:30
|
|
|
|
2022-09-26 16:00:49 +05:30
|
|
|
m_instanceIdToLaunch = parser.value("launch");
|
|
|
|
m_serverToJoin = parser.value("server");
|
|
|
|
m_profileToUse = parser.value("profile");
|
|
|
|
m_liveCheck = parser.isSet("alive");
|
2023-02-06 03:41:58 +05:30
|
|
|
|
2022-10-22 00:10:28 +05:30
|
|
|
m_instanceIdToShowWindowOf = parser.value("show");
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2022-12-31 06:36:17 +05:30
|
|
|
for (auto zip_path : parser.values("import")){
|
2023-01-02 21:25:32 +05:30
|
|
|
m_zipsToImport.append(QUrl::fromLocalFile(QFileInfo(zip_path).absoluteFilePath()));
|
2022-12-31 06:36:17 +05:30
|
|
|
}
|
|
|
|
|
2023-01-14 01:41:20 +05:30
|
|
|
// treat unspecified positional arguments as import urls
|
|
|
|
for (auto zip_path : parser.positionalArguments()) {
|
2023-01-02 21:25:32 +05:30
|
|
|
m_zipsToImport.append(QUrl::fromLocalFile(QFileInfo(zip_path).absoluteFilePath()));
|
2022-12-31 06:36:17 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
|
2022-02-17 19:59:09 +05:30
|
|
|
// error if --launch is missing with --server or --profile
|
|
|
|
if((!m_serverToJoin.isEmpty() || !m_profileToUse.isEmpty()) && m_instanceIdToLaunch.isEmpty())
|
2022-02-16 21:54:58 +05:30
|
|
|
{
|
2022-02-17 19:59:09 +05:30
|
|
|
std::cerr << "--server and --profile can only be used in combination with --launch!" << std::endl;
|
2022-02-16 21:54:58 +05:30
|
|
|
m_status = Application::Failed;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
QString origcwdPath = QDir::currentPath();
|
|
|
|
QString binPath = applicationDirPath();
|
2022-03-23 17:50:14 +05:30
|
|
|
|
|
|
|
{
|
|
|
|
// Root path is used for updates and portable data
|
2022-08-04 00:44:23 +05:30
|
|
|
#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
|
2022-03-23 17:50:14 +05:30
|
|
|
QDir foo(FS::PathCombine(binPath, "..")); // typically portable-root or /usr
|
|
|
|
m_rootPath = foo.absolutePath();
|
|
|
|
#elif defined(Q_OS_WIN32)
|
|
|
|
m_rootPath = binPath;
|
|
|
|
#elif defined(Q_OS_MAC)
|
|
|
|
QDir foo(FS::PathCombine(binPath, "../.."));
|
|
|
|
m_rootPath = foo.absolutePath();
|
|
|
|
// on macOS, touch the root to force Finder to reload the .app metadata (and fix any icon change issues)
|
|
|
|
FS::updateTimestamp(m_rootPath);
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
QString adjustedBy;
|
|
|
|
QString dataPath;
|
|
|
|
// change folder
|
2022-09-26 16:00:49 +05:30
|
|
|
QString dirParam = parser.value("dir");
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!dirParam.isEmpty())
|
|
|
|
{
|
|
|
|
// the dir param. it makes multimc data path point to whatever the user specified
|
|
|
|
// on command line
|
2022-03-23 17:50:14 +05:30
|
|
|
adjustedBy = "Command line";
|
2018-07-15 18:21:05 +05:30
|
|
|
dataPath = dirParam;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-12-31 01:38:15 +05:30
|
|
|
QDir foo(FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), ".."));
|
2021-07-02 04:49:55 +05:30
|
|
|
dataPath = foo.absolutePath();
|
2022-03-23 17:50:14 +05:30
|
|
|
adjustedBy = "Persistent data path";
|
2022-02-15 00:50:11 +05:30
|
|
|
|
2022-03-23 19:08:58 +05:30
|
|
|
#ifndef Q_OS_MACOS
|
2022-03-23 17:50:14 +05:30
|
|
|
if (QFile::exists(FS::PathCombine(m_rootPath, "portable.txt"))) {
|
|
|
|
dataPath = m_rootPath;
|
|
|
|
adjustedBy = "Portable data path";
|
2023-04-04 03:44:24 +05:30
|
|
|
m_portable = true;
|
2022-03-23 17:50:14 +05:30
|
|
|
}
|
2022-03-23 19:08:58 +05:30
|
|
|
#endif
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
if (!FS::ensureFolderPathExists(dataPath))
|
|
|
|
{
|
|
|
|
showFatalErrorMessage(
|
2021-10-18 04:17:02 +05:30
|
|
|
"The launcher data folder could not be created.",
|
2021-12-15 05:16:35 +05:30
|
|
|
QString(
|
|
|
|
"The launcher data folder could not be created.\n"
|
|
|
|
"\n"
|
|
|
|
"Make sure you have the right permissions to the launcher data folder and any folder needed to access it.\n"
|
|
|
|
"(%1)\n"
|
|
|
|
"\n"
|
|
|
|
"The launcher cannot continue until you fix this problem."
|
2021-12-19 23:42:43 +05:30
|
|
|
).arg(dataPath)
|
2018-07-15 18:21:05 +05:30
|
|
|
);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
if (!QDir::setCurrent(dataPath))
|
|
|
|
{
|
|
|
|
showFatalErrorMessage(
|
2021-10-18 04:17:02 +05:30
|
|
|
"The launcher data folder could not be opened.",
|
2021-12-15 05:16:35 +05:30
|
|
|
QString(
|
|
|
|
"The launcher data folder could not be opened.\n"
|
|
|
|
"\n"
|
|
|
|
"Make sure you have the right permissions to the launcher data folder.\n"
|
|
|
|
"(%1)\n"
|
|
|
|
"\n"
|
|
|
|
"The launcher cannot continue until you fix this problem."
|
2021-12-19 23:42:43 +05:30
|
|
|
).arg(dataPath)
|
2018-07-15 18:21:05 +05:30
|
|
|
);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
2022-12-31 06:36:17 +05:30
|
|
|
* Establish the mechanism for communication with an already running PrismLauncher that uses the same data path.
|
2018-07-15 18:21:05 +05:30
|
|
|
* If there is one, tell it what the user actually wanted to do and exit.
|
|
|
|
* We want to initialize this before logging to avoid messing with the log of a potential already running copy.
|
|
|
|
*/
|
|
|
|
auto appID = ApplicationId::fromPathAndVersion(QDir::currentPath(), BuildConfig.printableVersionString());
|
|
|
|
{
|
|
|
|
// FIXME: you can run the same binaries with multiple data dirs and they won't clash. This could cause issues for updates.
|
|
|
|
m_peerInstance = new LocalPeer(this, appID);
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(m_peerInstance, &LocalPeer::messageReceived, this, &Application::messageReceived);
|
2021-11-01 02:12:06 +05:30
|
|
|
if(m_peerInstance->isClient()) {
|
2020-02-05 04:59:23 +05:30
|
|
|
int timeout = 2000;
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
if(m_instanceIdToLaunch.isEmpty())
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
ApplicationMessage activate;
|
2021-11-01 02:12:06 +05:30
|
|
|
activate.command = "activate";
|
|
|
|
m_peerInstance->sendMessage(activate.serialize(), timeout);
|
2020-02-05 04:59:23 +05:30
|
|
|
|
2022-12-31 06:36:17 +05:30
|
|
|
if(!m_zipsToImport.isEmpty())
|
2020-02-05 04:59:23 +05:30
|
|
|
{
|
2022-12-31 06:36:17 +05:30
|
|
|
for (auto zip_url : m_zipsToImport) {
|
|
|
|
ApplicationMessage import;
|
|
|
|
import.command = "import";
|
|
|
|
import.args.insert("path", zip_url.toString());
|
|
|
|
m_peerInstance->sendMessage(import.serialize(), timeout);
|
2023-02-06 03:41:58 +05:30
|
|
|
}
|
2020-02-05 04:59:23 +05:30
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
ApplicationMessage launch;
|
2021-11-01 02:12:06 +05:30
|
|
|
launch.command = "launch";
|
|
|
|
launch.args["id"] = m_instanceIdToLaunch;
|
|
|
|
|
2021-05-23 18:12:20 +05:30
|
|
|
if(!m_serverToJoin.isEmpty())
|
|
|
|
{
|
2021-11-01 02:12:06 +05:30
|
|
|
launch.args["server"] = m_serverToJoin;
|
2021-05-23 18:12:20 +05:30
|
|
|
}
|
2021-11-01 02:12:06 +05:30
|
|
|
if(!m_profileToUse.isEmpty())
|
2021-05-23 18:12:20 +05:30
|
|
|
{
|
2021-11-01 02:12:06 +05:30
|
|
|
launch.args["profile"] = m_profileToUse;
|
2021-05-23 18:12:20 +05:30
|
|
|
}
|
2021-11-01 02:12:06 +05:30
|
|
|
m_peerInstance->sendMessage(launch.serialize(), timeout);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2021-11-20 20:52:22 +05:30
|
|
|
m_status = Application::Succeeded;
|
2018-07-15 18:21:05 +05:30
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// init the logger
|
|
|
|
{
|
2021-10-18 04:17:02 +05:30
|
|
|
static const QString logBase = BuildConfig.LAUNCHER_NAME + "-%0.log";
|
2018-07-15 18:21:05 +05:30
|
|
|
auto moveFile = [](const QString &oldName, const QString &newName)
|
|
|
|
{
|
|
|
|
QFile::remove(newName);
|
|
|
|
QFile::copy(oldName, newName);
|
|
|
|
QFile::remove(oldName);
|
|
|
|
};
|
|
|
|
|
|
|
|
moveFile(logBase.arg(3), logBase.arg(4));
|
|
|
|
moveFile(logBase.arg(2), logBase.arg(3));
|
|
|
|
moveFile(logBase.arg(1), logBase.arg(2));
|
|
|
|
moveFile(logBase.arg(0), logBase.arg(1));
|
|
|
|
|
|
|
|
logFile = std::unique_ptr<QFile>(new QFile(logBase.arg(0)));
|
|
|
|
if(!logFile->open(QIODevice::WriteOnly | QIODevice::Text | QIODevice::Truncate))
|
|
|
|
{
|
|
|
|
showFatalErrorMessage(
|
2021-10-18 04:17:02 +05:30
|
|
|
"The launcher data folder is not writable!",
|
2021-12-15 05:16:35 +05:30
|
|
|
QString(
|
|
|
|
"The launcher couldn't create a log file - the data folder is not writable.\n"
|
|
|
|
"\n"
|
|
|
|
"Make sure you have write permissions to the data folder.\n"
|
|
|
|
"(%1)\n"
|
|
|
|
"\n"
|
|
|
|
"The launcher cannot continue until you fix this problem."
|
2021-12-19 23:42:43 +05:30
|
|
|
).arg(dataPath)
|
2018-07-15 18:21:05 +05:30
|
|
|
);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
qInstallMessageHandler(appDebugOutput);
|
2022-08-19 06:02:57 +05:30
|
|
|
|
|
|
|
qSetMessagePattern(
|
|
|
|
"%{time process}" " "
|
|
|
|
"%{if-debug}D%{endif}" "%{if-info}I%{endif}" "%{if-warning}W%{endif}" "%{if-critical}C%{endif}" "%{if-fatal}F%{endif}"
|
|
|
|
" " "|" " "
|
|
|
|
"%{if-category}[%{category}]: %{endif}"
|
|
|
|
"%{message}");
|
2023-04-04 03:44:24 +05:30
|
|
|
|
|
|
|
bool foundLoggingRules = false;
|
2023-04-01 07:55:01 +05:30
|
|
|
|
2023-04-04 03:44:24 +05:30
|
|
|
auto logRulesFile = QStringLiteral("qtlogging.ini");
|
|
|
|
auto logRulesPath = FS::PathCombine(dataPath, logRulesFile);
|
|
|
|
|
|
|
|
qDebug() << "Testing" << logRulesPath << "...";
|
|
|
|
foundLoggingRules = QFile::exists(logRulesPath);
|
|
|
|
|
|
|
|
// search the dataPath()
|
2023-05-07 07:40:58 +05:30
|
|
|
// seach app data standard path
|
2023-05-06 02:43:34 +05:30
|
|
|
if(!foundLoggingRules && !isPortable() && dirParam.isEmpty()) {
|
2023-05-07 07:40:58 +05:30
|
|
|
logRulesPath = QStandardPaths::locate(QStandardPaths::AppDataLocation, FS::PathCombine("..", logRulesFile));
|
2023-04-04 03:44:24 +05:30
|
|
|
if(!logRulesPath.isEmpty()) {
|
|
|
|
qDebug() << "Found" << logRulesPath << "...";
|
|
|
|
foundLoggingRules = true;
|
|
|
|
}
|
|
|
|
}
|
2023-05-07 07:40:58 +05:30
|
|
|
// seach root path
|
|
|
|
if(!foundLoggingRules) {
|
2023-04-04 03:44:24 +05:30
|
|
|
logRulesPath = FS::PathCombine(m_rootPath, logRulesFile);
|
|
|
|
qDebug() << "Testing" << logRulesPath << "...";
|
|
|
|
foundLoggingRules = QFile::exists(logRulesPath);
|
|
|
|
}
|
|
|
|
|
|
|
|
if(foundLoggingRules) {
|
2023-04-01 07:55:01 +05:30
|
|
|
// load and set logging rules
|
2023-04-04 03:44:24 +05:30
|
|
|
qDebug() << "Loading logging rules from:" << logRulesPath;
|
|
|
|
QSettings loggingRules(logRulesPath, QSettings::IniFormat);
|
|
|
|
loggingRules.beginGroup("Rules");
|
|
|
|
QStringList rule_names = loggingRules.childKeys();
|
|
|
|
QStringList rules;
|
|
|
|
qDebug() << "Setting log rules:";
|
|
|
|
for (auto rule_name : rule_names) {
|
|
|
|
auto rule = QString("%1=%2").arg(rule_name).arg(loggingRules.value(rule_name).toString());
|
|
|
|
rules.append(rule);
|
|
|
|
qDebug() << " " << rule;
|
2023-04-01 07:55:01 +05:30
|
|
|
}
|
2023-04-04 03:44:24 +05:30
|
|
|
auto rules_str = rules.join("\n");
|
|
|
|
QLoggingCategory::setFilterRules(rules_str);
|
2023-04-01 07:55:01 +05:30
|
|
|
}
|
2022-08-19 06:02:57 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "<> Log initialized.";
|
|
|
|
}
|
|
|
|
|
2022-10-23 05:15:32 +05:30
|
|
|
{
|
|
|
|
bool migrated = false;
|
|
|
|
|
|
|
|
if (!migrated)
|
|
|
|
migrated = handleDataMigration(dataPath, FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../PolyMC"), "PolyMC", "polymc.cfg");
|
|
|
|
if (!migrated)
|
|
|
|
migrated = handleDataMigration(dataPath, FS::PathCombine(QStandardPaths::writableLocation(QStandardPaths::AppDataLocation), "../../multimc"), "MultiMC", "multimc.cfg");
|
|
|
|
}
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2021-12-17 23:22:13 +05:30
|
|
|
|
2021-10-18 04:17:02 +05:30
|
|
|
qDebug() << BuildConfig.LAUNCHER_DISPLAYNAME << ", (c) 2013-2021 " << BuildConfig.LAUNCHER_COPYRIGHT;
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "Version : " << BuildConfig.printableVersionString();
|
|
|
|
qDebug() << "Git commit : " << BuildConfig.GIT_COMMIT;
|
|
|
|
qDebug() << "Git refspec : " << BuildConfig.GIT_REFSPEC;
|
|
|
|
if (adjustedBy.size())
|
|
|
|
{
|
|
|
|
qDebug() << "Work dir before adjustment : " << origcwdPath;
|
|
|
|
qDebug() << "Work dir after adjustment : " << QDir::currentPath();
|
|
|
|
qDebug() << "Adjusted by : " << adjustedBy;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
qDebug() << "Work dir : " << QDir::currentPath();
|
|
|
|
}
|
|
|
|
qDebug() << "Binary path : " << binPath;
|
|
|
|
qDebug() << "Application root path : " << m_rootPath;
|
|
|
|
if(!m_instanceIdToLaunch.isEmpty())
|
|
|
|
{
|
|
|
|
qDebug() << "ID of instance to launch : " << m_instanceIdToLaunch;
|
|
|
|
}
|
2021-05-23 18:12:20 +05:30
|
|
|
if(!m_serverToJoin.isEmpty())
|
|
|
|
{
|
|
|
|
qDebug() << "Address of server to join :" << m_serverToJoin;
|
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "<> Paths set.";
|
|
|
|
}
|
|
|
|
|
2022-02-16 21:54:58 +05:30
|
|
|
if(m_liveCheck)
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2022-02-16 21:54:58 +05:30
|
|
|
QFile check(liveCheckFile);
|
|
|
|
if(check.open(QIODevice::WriteOnly | QIODevice::Truncate))
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
auto payload = appID.toString().toUtf8();
|
2022-02-16 21:54:58 +05:30
|
|
|
if(check.write(payload) == payload.size())
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2022-02-16 21:54:58 +05:30
|
|
|
check.close();
|
|
|
|
} else {
|
2019-09-15 09:01:13 +05:30
|
|
|
qWarning() << "Could not write into" << liveCheckFile << "!";
|
2022-02-16 21:54:58 +05:30
|
|
|
check.remove(); // also closes file!
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2022-02-16 21:54:58 +05:30
|
|
|
} else {
|
|
|
|
qWarning() << "Could not open" << liveCheckFile << "for writing!";
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2022-02-16 21:54:58 +05:30
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// Initialize application settings
|
|
|
|
{
|
2022-10-18 20:30:47 +05:30
|
|
|
// Provide a fallback for migration from PolyMC
|
2022-10-19 02:10:34 +05:30
|
|
|
m_settings.reset(new INISettingsObject({ BuildConfig.LAUNCHER_CONFIGFILE, "polymc.cfg", "multimc.cfg" }, this));
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// Theming
|
2022-01-16 22:32:53 +05:30
|
|
|
m_settings->registerSetting("IconTheme", QString("pe_colored"));
|
2023-01-04 19:00:25 +05:30
|
|
|
m_settings->registerSetting("ApplicationTheme", QString());
|
2022-11-02 03:36:27 +05:30
|
|
|
m_settings->registerSetting("BackgroundCat", QString("kitteh"));
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// Remembered state
|
|
|
|
m_settings->registerSetting("LastUsedGroupForNewInstance", QString());
|
|
|
|
|
2022-04-16 03:55:37 +05:30
|
|
|
m_settings->registerSetting("MenuBarInsteadOfToolBar", false);
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
QString defaultMonospace;
|
|
|
|
int defaultSize = 11;
|
2017-07-05 21:32:49 +05:30
|
|
|
#ifdef Q_OS_WIN32
|
2018-07-15 18:21:05 +05:30
|
|
|
defaultMonospace = "Courier";
|
|
|
|
defaultSize = 10;
|
2017-07-05 21:32:49 +05:30
|
|
|
#elif defined(Q_OS_MAC)
|
2018-07-15 18:21:05 +05:30
|
|
|
defaultMonospace = "Menlo";
|
2017-07-05 21:32:49 +05:30
|
|
|
#else
|
2018-07-15 18:21:05 +05:30
|
|
|
defaultMonospace = "Monospace";
|
2017-07-05 21:32:49 +05:30
|
|
|
#endif
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
// resolve the font so the default actually matches
|
|
|
|
QFont consoleFont;
|
|
|
|
consoleFont.setFamily(defaultMonospace);
|
|
|
|
consoleFont.setStyleHint(QFont::Monospace);
|
|
|
|
consoleFont.setFixedPitch(true);
|
|
|
|
QFontInfo consoleFontInfo(consoleFont);
|
|
|
|
QString resolvedDefaultMonospace = consoleFontInfo.family();
|
|
|
|
QFont resolvedFont(resolvedDefaultMonospace);
|
|
|
|
qDebug() << "Detected default console font:" << resolvedDefaultMonospace
|
|
|
|
<< ", substitutions:" << resolvedFont.substitutions().join(',');
|
|
|
|
|
|
|
|
m_settings->registerSetting("ConsoleFont", resolvedDefaultMonospace);
|
|
|
|
m_settings->registerSetting("ConsoleFontSize", defaultSize);
|
|
|
|
m_settings->registerSetting("ConsoleMaxLines", 100000);
|
|
|
|
m_settings->registerSetting("ConsoleOverflowStop", true);
|
|
|
|
|
|
|
|
// Folders
|
|
|
|
m_settings->registerSetting("InstanceDir", "instances");
|
|
|
|
m_settings->registerSetting({"CentralModsDir", "ModsDir"}, "mods");
|
|
|
|
m_settings->registerSetting("IconsDir", "icons");
|
2023-03-13 21:07:45 +05:30
|
|
|
m_settings->registerSetting("DownloadsDir", QStandardPaths::writableLocation(QStandardPaths::DownloadLocation));
|
2023-03-28 07:31:53 +05:30
|
|
|
m_settings->registerSetting("DownloadsDirWatchRecursive", false);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// Editors
|
|
|
|
m_settings->registerSetting("JsonEditor", QString());
|
|
|
|
|
|
|
|
// Language
|
|
|
|
m_settings->registerSetting("Language", QString());
|
|
|
|
|
|
|
|
// Console
|
|
|
|
m_settings->registerSetting("ShowConsole", false);
|
|
|
|
m_settings->registerSetting("AutoCloseConsole", false);
|
|
|
|
m_settings->registerSetting("ShowConsoleOnError", true);
|
|
|
|
m_settings->registerSetting("LogPrePostOutput", true);
|
|
|
|
|
|
|
|
// Window Size
|
|
|
|
m_settings->registerSetting({"LaunchMaximized", "MCWindowMaximize"}, false);
|
|
|
|
m_settings->registerSetting({"MinecraftWinWidth", "MCWindowWidth"}, 854);
|
|
|
|
m_settings->registerSetting({"MinecraftWinHeight", "MCWindowHeight"}, 480);
|
|
|
|
|
|
|
|
// Proxy Settings
|
|
|
|
m_settings->registerSetting("ProxyType", "None");
|
|
|
|
m_settings->registerSetting({"ProxyAddr", "ProxyHostName"}, "127.0.0.1");
|
|
|
|
m_settings->registerSetting("ProxyPort", 8080);
|
|
|
|
m_settings->registerSetting({"ProxyUser", "ProxyUsername"}, "");
|
|
|
|
m_settings->registerSetting({"ProxyPass", "ProxyPassword"}, "");
|
|
|
|
|
|
|
|
// Memory
|
|
|
|
m_settings->registerSetting({"MinMemAlloc", "MinMemoryAlloc"}, 512);
|
2022-11-04 11:58:58 +05:30
|
|
|
m_settings->registerSetting({"MaxMemAlloc", "MaxMemoryAlloc"}, suitableMaxMem());
|
2018-07-15 18:21:05 +05:30
|
|
|
m_settings->registerSetting("PermGen", 128);
|
|
|
|
|
|
|
|
// Java Settings
|
|
|
|
m_settings->registerSetting("JavaPath", "");
|
|
|
|
m_settings->registerSetting("JavaTimestamp", 0);
|
|
|
|
m_settings->registerSetting("JavaArchitecture", "");
|
2022-06-11 14:18:56 +05:30
|
|
|
m_settings->registerSetting("JavaRealArchitecture", "");
|
2018-07-15 18:21:05 +05:30
|
|
|
m_settings->registerSetting("JavaVersion", "");
|
2020-09-08 01:58:41 +05:30
|
|
|
m_settings->registerSetting("JavaVendor", "");
|
2018-07-15 18:21:05 +05:30
|
|
|
m_settings->registerSetting("LastHostname", "");
|
|
|
|
m_settings->registerSetting("JvmArgs", "");
|
2022-03-24 19:17:22 +05:30
|
|
|
m_settings->registerSetting("IgnoreJavaCompatibility", false);
|
2022-04-30 18:49:57 +05:30
|
|
|
m_settings->registerSetting("IgnoreJavaWizard", false);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2020-09-11 02:40:17 +05:30
|
|
|
// Native library workarounds
|
|
|
|
m_settings->registerSetting("UseNativeOpenAL", false);
|
|
|
|
m_settings->registerSetting("UseNativeGLFW", false);
|
|
|
|
|
2022-06-30 02:07:25 +05:30
|
|
|
// Peformance related options
|
|
|
|
m_settings->registerSetting("EnableFeralGamemode", false);
|
|
|
|
m_settings->registerSetting("EnableMangoHud", false);
|
|
|
|
m_settings->registerSetting("UseDiscreteGpu", false);
|
|
|
|
|
2020-12-10 03:46:01 +05:30
|
|
|
// Game time
|
|
|
|
m_settings->registerSetting("ShowGameTime", true);
|
2021-10-14 02:44:02 +05:30
|
|
|
m_settings->registerSetting("ShowGlobalGameTime", true);
|
2020-12-10 03:46:01 +05:30
|
|
|
m_settings->registerSetting("RecordGameTime", true);
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
// Minecraft launch method
|
|
|
|
m_settings->registerSetting("MCLaunchMethod", "LauncherPart");
|
|
|
|
|
2022-04-17 18:49:23 +05:30
|
|
|
// Minecraft mods
|
2022-04-22 00:15:20 +05:30
|
|
|
m_settings->registerSetting("ModMetadataDisabled", false);
|
2022-04-17 18:49:23 +05:30
|
|
|
|
2022-03-28 18:10:34 +05:30
|
|
|
// Minecraft offline player name
|
|
|
|
m_settings->registerSetting("LastOfflinePlayerName", "");
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
// Wrapper command for launch
|
|
|
|
m_settings->registerSetting("WrapperCommand", "");
|
|
|
|
|
|
|
|
// Custom Commands
|
|
|
|
m_settings->registerSetting({"PreLaunchCommand", "PreLaunchCmd"}, "");
|
|
|
|
m_settings->registerSetting({"PostExitCommand", "PostExitCmd"}, "");
|
|
|
|
|
|
|
|
// The cat
|
|
|
|
m_settings->registerSetting("TheCat", false);
|
|
|
|
|
2022-10-26 03:52:11 +05:30
|
|
|
m_settings->registerSetting("ToolbarsLocked", false);
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
m_settings->registerSetting("InstSortMode", "Name");
|
|
|
|
m_settings->registerSetting("SelectedInstance", QString());
|
|
|
|
|
|
|
|
// Window state and geometry
|
|
|
|
m_settings->registerSetting("MainWindowState", "");
|
|
|
|
m_settings->registerSetting("MainWindowGeometry", "");
|
|
|
|
|
|
|
|
m_settings->registerSetting("ConsoleWindowState", "");
|
|
|
|
m_settings->registerSetting("ConsoleWindowGeometry", "");
|
|
|
|
|
|
|
|
m_settings->registerSetting("SettingsGeometry", "");
|
|
|
|
|
|
|
|
m_settings->registerSetting("PagedGeometry", "");
|
|
|
|
|
|
|
|
m_settings->registerSetting("NewInstanceGeometry", "");
|
|
|
|
|
|
|
|
m_settings->registerSetting("UpdateDialogGeometry", "");
|
|
|
|
|
2022-07-19 22:20:02 +05:30
|
|
|
m_settings->registerSetting("ModDownloadGeometry", "");
|
2022-12-17 04:56:10 +05:30
|
|
|
m_settings->registerSetting("RPDownloadGeometry", "");
|
2023-01-30 02:37:49 +05:30
|
|
|
m_settings->registerSetting("TPDownloadGeometry", "");
|
2022-12-30 22:36:07 +05:30
|
|
|
m_settings->registerSetting("ShaderDownloadGeometry", "");
|
2022-07-19 22:20:02 +05:30
|
|
|
|
2022-05-13 22:18:19 +05:30
|
|
|
// HACK: This code feels so stupid is there a less stupid way of doing this?
|
2022-05-12 02:14:06 +05:30
|
|
|
{
|
|
|
|
m_settings->registerSetting("PastebinURL", "");
|
2022-05-17 09:30:06 +05:30
|
|
|
m_settings->registerSetting("PastebinType", PasteUpload::PasteType::Mclogs);
|
|
|
|
m_settings->registerSetting("PastebinCustomAPIBase", "");
|
2022-05-12 02:14:06 +05:30
|
|
|
|
2022-05-17 09:30:06 +05:30
|
|
|
QString pastebinURL = m_settings->get("PastebinURL").toString();
|
2022-05-12 02:14:06 +05:30
|
|
|
|
2022-05-17 09:30:06 +05:30
|
|
|
bool userHadDefaultPastebin = pastebinURL == "https://0x0.st";
|
2022-05-21 03:00:00 +05:30
|
|
|
if (!pastebinURL.isEmpty() && !userHadDefaultPastebin)
|
2022-05-17 09:30:06 +05:30
|
|
|
{
|
|
|
|
m_settings->set("PastebinType", PasteUpload::PasteType::NullPointer);
|
|
|
|
m_settings->set("PastebinCustomAPIBase", pastebinURL);
|
2022-05-12 02:14:06 +05:30
|
|
|
m_settings->reset("PastebinURL");
|
|
|
|
}
|
|
|
|
|
|
|
|
bool ok;
|
2022-05-13 22:18:19 +05:30
|
|
|
int pasteType = m_settings->get("PastebinType").toInt(&ok);
|
2022-05-12 02:14:06 +05:30
|
|
|
// If PastebinType is invalid then reset the related settings.
|
|
|
|
if (!ok || !(PasteUpload::PasteType::First <= pasteType && pasteType <= PasteUpload::PasteType::Last))
|
|
|
|
{
|
|
|
|
m_settings->reset("PastebinType");
|
|
|
|
m_settings->reset("PastebinCustomAPIBase");
|
|
|
|
}
|
|
|
|
}
|
2022-04-14 02:30:32 +05:30
|
|
|
// meta URL
|
|
|
|
m_settings->registerSetting("MetaURLOverride", "");
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2022-01-30 05:34:44 +05:30
|
|
|
m_settings->registerSetting("CloseAfterLaunch", false);
|
2022-03-23 23:36:17 +05:30
|
|
|
m_settings->registerSetting("QuitAfterGameStop", false);
|
2022-01-30 05:34:44 +05:30
|
|
|
|
2022-05-30 00:59:07 +05:30
|
|
|
// Custom Microsoft Authentication Client ID
|
2022-02-13 00:38:50 +05:30
|
|
|
m_settings->registerSetting("MSAClientIDOverride", "");
|
2022-05-30 00:59:07 +05:30
|
|
|
|
|
|
|
// Custom Flame API Key
|
|
|
|
{
|
|
|
|
m_settings->registerSetting("CFKeyOverride", "");
|
|
|
|
m_settings->registerSetting("FlameKeyOverride", "");
|
|
|
|
|
|
|
|
QString flameKey = m_settings->get("CFKeyOverride").toString();
|
|
|
|
|
|
|
|
if (!flameKey.isEmpty())
|
|
|
|
m_settings->set("FlameKeyOverride", flameKey);
|
|
|
|
m_settings->reset("CFKeyOverride");
|
|
|
|
}
|
2022-12-21 04:12:34 +05:30
|
|
|
m_settings->registerSetting("FlameKeyShouldBeFetchedOnStartup", true);
|
2023-03-01 15:24:49 +05:30
|
|
|
m_settings->registerSetting("ModrinthToken", "");
|
2022-06-04 13:03:17 +05:30
|
|
|
m_settings->registerSetting("UserAgentOverride", "");
|
2022-02-13 00:38:50 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
// Init page provider
|
|
|
|
{
|
|
|
|
m_globalSettingsProvider = std::make_shared<GenericPageProvider>(tr("Settings"));
|
2021-10-13 05:29:25 +05:30
|
|
|
m_globalSettingsProvider->addPage<LauncherPage>();
|
2018-07-15 18:21:05 +05:30
|
|
|
m_globalSettingsProvider->addPage<MinecraftPage>();
|
|
|
|
m_globalSettingsProvider->addPage<JavaPage>();
|
2019-01-09 09:08:35 +05:30
|
|
|
m_globalSettingsProvider->addPage<LanguagePage>();
|
2018-07-15 18:21:05 +05:30
|
|
|
m_globalSettingsProvider->addPage<CustomCommandsPage>();
|
|
|
|
m_globalSettingsProvider->addPage<ProxyPage>();
|
|
|
|
m_globalSettingsProvider->addPage<ExternalToolsPage>();
|
|
|
|
m_globalSettingsProvider->addPage<AccountListPage>();
|
2022-02-13 00:38:50 +05:30
|
|
|
m_globalSettingsProvider->addPage<APIPage>();
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2022-11-16 02:43:15 +05:30
|
|
|
|
|
|
|
PixmapCache::setInstance(new PixmapCache(this));
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "<> Settings loaded.";
|
|
|
|
}
|
|
|
|
|
2019-10-01 17:58:06 +05:30
|
|
|
#ifndef QT_NO_ACCESSIBILITY
|
2019-07-22 00:42:05 +05:30
|
|
|
QAccessible::installFactory(groupViewAccessibleFactory);
|
2019-10-01 17:58:06 +05:30
|
|
|
#endif /* !QT_NO_ACCESSIBILITY */
|
2019-07-22 00:42:05 +05:30
|
|
|
|
2021-11-22 03:51:12 +05:30
|
|
|
// initialize network access and proxy setup
|
|
|
|
{
|
2023-01-25 01:22:09 +05:30
|
|
|
m_network.reset(new QNetworkAccessManager());
|
2021-11-22 03:51:12 +05:30
|
|
|
QString proxyTypeStr = settings()->get("ProxyType").toString();
|
|
|
|
QString addr = settings()->get("ProxyAddr").toString();
|
|
|
|
int port = settings()->get("ProxyPort").value<qint16>();
|
|
|
|
QString user = settings()->get("ProxyUser").toString();
|
|
|
|
QString pass = settings()->get("ProxyPass").toString();
|
|
|
|
updateProxySettings(proxyTypeStr, addr, port, user, pass);
|
|
|
|
qDebug() << "<> Network done.";
|
|
|
|
}
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
// load translations
|
|
|
|
{
|
|
|
|
m_translations.reset(new TranslationsModel("translations"));
|
|
|
|
auto bcp47Name = m_settings->get("Language").toString();
|
|
|
|
m_translations->selectLanguage(bcp47Name);
|
|
|
|
qDebug() << "Your language is" << bcp47Name;
|
|
|
|
qDebug() << "<> Translations loaded.";
|
|
|
|
}
|
|
|
|
|
|
|
|
// initialize the updater
|
|
|
|
if(BuildConfig.UPDATER_ENABLED)
|
|
|
|
{
|
2022-11-02 03:15:15 +05:30
|
|
|
qDebug() << "Initializing updater";
|
|
|
|
#ifdef Q_OS_MAC
|
|
|
|
m_updater.reset(new MacSparkleUpdater());
|
|
|
|
#endif
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "<> Updater started.";
|
|
|
|
}
|
|
|
|
|
|
|
|
// Instance icons
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
auto setting = APPLICATION->settings()->getSetting("IconsDir");
|
2018-07-15 18:21:05 +05:30
|
|
|
QStringList instFolders =
|
|
|
|
{
|
|
|
|
":/icons/multimc/32x32/instances/",
|
|
|
|
":/icons/multimc/50x50/instances/",
|
2019-06-01 04:29:02 +05:30
|
|
|
":/icons/multimc/128x128/instances/",
|
|
|
|
":/icons/multimc/scalable/instances/"
|
2018-07-15 18:21:05 +05:30
|
|
|
};
|
|
|
|
m_icons.reset(new IconList(instFolders, setting->get().toString()));
|
|
|
|
connect(setting.get(), &Setting::SettingChanged,[&](const Setting &, QVariant value)
|
|
|
|
{
|
|
|
|
m_icons->directoryChanged(value.toString());
|
|
|
|
});
|
|
|
|
qDebug() << "<> Instance icons intialized.";
|
|
|
|
}
|
|
|
|
|
2022-10-29 22:57:20 +05:30
|
|
|
// Themes
|
2022-11-01 20:11:08 +05:30
|
|
|
m_themeManager = std::make_unique<ThemeManager>(m_mainWindow);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
// initialize and load all instances
|
|
|
|
{
|
|
|
|
auto InstDirSetting = m_settings->getSetting("InstanceDir");
|
|
|
|
// instance path: check for problems with '!' in instance path and warn the user in the log
|
2019-09-15 09:01:13 +05:30
|
|
|
// and remember that we have to show him a dialog when the gui starts (if it does so)
|
2018-07-15 18:21:05 +05:30
|
|
|
QString instDir = InstDirSetting->get().toString();
|
|
|
|
qDebug() << "Instance path : " << instDir;
|
|
|
|
if (FS::checkProblemticPathJava(QDir(instDir)))
|
|
|
|
{
|
2019-09-15 09:01:13 +05:30
|
|
|
qWarning() << "Your instance path contains \'!\' and this is known to cause java problems!";
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2018-07-24 04:54:06 +05:30
|
|
|
m_instances.reset(new InstanceList(m_settings, instDir, this));
|
|
|
|
connect(InstDirSetting.get(), &Setting::SettingChanged, m_instances.get(), &InstanceList::on_InstFolderChanged);
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "Loading Instances...";
|
2018-07-24 03:41:24 +05:30
|
|
|
m_instances->loadList();
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "<> Instances loaded.";
|
|
|
|
}
|
|
|
|
|
|
|
|
// and accounts
|
|
|
|
{
|
2021-07-27 01:14:11 +05:30
|
|
|
m_accounts.reset(new AccountList(this));
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "Loading accounts...";
|
|
|
|
m_accounts->setListFilePath("accounts.json", true);
|
|
|
|
m_accounts->loadList();
|
2021-12-04 05:48:05 +05:30
|
|
|
m_accounts->fillQueue();
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "<> Accounts loaded.";
|
|
|
|
}
|
|
|
|
|
|
|
|
// init the http meta cache
|
|
|
|
{
|
2021-11-22 03:51:12 +05:30
|
|
|
m_metacache.reset(new HttpMetaCache("metacache"));
|
|
|
|
m_metacache->addBase("asset_indexes", QDir("assets/indexes").absolutePath());
|
|
|
|
m_metacache->addBase("asset_objects", QDir("assets/objects").absolutePath());
|
|
|
|
m_metacache->addBase("versions", QDir("versions").absolutePath());
|
|
|
|
m_metacache->addBase("libraries", QDir("libraries").absolutePath());
|
|
|
|
m_metacache->addBase("minecraftforge", QDir("mods/minecraftforge").absolutePath());
|
|
|
|
m_metacache->addBase("fmllibs", QDir("mods/minecraftforge/libs").absolutePath());
|
|
|
|
m_metacache->addBase("liteloader", QDir("mods/liteloader").absolutePath());
|
|
|
|
m_metacache->addBase("general", QDir("cache").absolutePath());
|
|
|
|
m_metacache->addBase("ATLauncherPacks", QDir("cache/ATLauncherPacks").absolutePath());
|
|
|
|
m_metacache->addBase("FTBPacks", QDir("cache/FTBPacks").absolutePath());
|
|
|
|
m_metacache->addBase("ModpacksCHPacks", QDir("cache/ModpacksCHPacks").absolutePath());
|
|
|
|
m_metacache->addBase("TechnicPacks", QDir("cache/TechnicPacks").absolutePath());
|
|
|
|
m_metacache->addBase("FlamePacks", QDir("cache/FlamePacks").absolutePath());
|
2022-07-17 05:06:14 +05:30
|
|
|
m_metacache->addBase("FlameMods", QDir("cache/FlameMods").absolutePath());
|
2022-05-16 23:47:19 +05:30
|
|
|
m_metacache->addBase("ModrinthPacks", QDir("cache/ModrinthPacks").absolutePath());
|
2022-08-02 23:44:25 +05:30
|
|
|
m_metacache->addBase("ModrinthModpacks", QDir("cache/ModrinthModpacks").absolutePath());
|
2021-11-22 03:51:12 +05:30
|
|
|
m_metacache->addBase("root", QDir::currentPath());
|
|
|
|
m_metacache->addBase("translations", QDir("translations").absolutePath());
|
|
|
|
m_metacache->addBase("icons", QDir("cache/icons").absolutePath());
|
|
|
|
m_metacache->addBase("meta", QDir("meta").absolutePath());
|
2022-08-07 23:08:53 +05:30
|
|
|
m_metacache->addBase("injectors", QDir("injectors").absolutePath());
|
2021-11-22 03:51:12 +05:30
|
|
|
m_metacache->Load();
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "<> Cache initialized.";
|
|
|
|
}
|
|
|
|
|
|
|
|
// now we have network, download translation updates
|
|
|
|
m_translations->downloadIndex();
|
|
|
|
|
|
|
|
//FIXME: what to do with these?
|
|
|
|
m_profilers.insert("jprofiler", std::shared_ptr<BaseProfilerFactory>(new JProfilerFactory()));
|
|
|
|
m_profilers.insert("jvisualvm", std::shared_ptr<BaseProfilerFactory>(new JVisualVMFactory()));
|
|
|
|
for (auto profiler : m_profilers.values())
|
|
|
|
{
|
|
|
|
profiler->registerSettings(m_settings);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create the MCEdit thing... why is this here?
|
|
|
|
{
|
|
|
|
m_mcedit.reset(new MCEditTool(m_settings));
|
|
|
|
}
|
|
|
|
|
2022-05-24 13:48:02 +05:30
|
|
|
#ifdef Q_OS_MACOS
|
2022-05-24 11:05:01 +05:30
|
|
|
connect(this, &Application::clickedOnDock, [this]() {
|
|
|
|
this->showMainWindow();
|
|
|
|
});
|
2022-05-24 13:48:02 +05:30
|
|
|
#endif
|
2022-05-24 11:05:01 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(this, &Application::aboutToQuit, [this](){
|
2018-07-15 18:21:05 +05:30
|
|
|
if(m_instances)
|
|
|
|
{
|
|
|
|
// save any remaining instance state
|
|
|
|
m_instances->saveNow();
|
|
|
|
}
|
|
|
|
if(logFile)
|
|
|
|
{
|
|
|
|
logFile->flush();
|
|
|
|
logFile->close();
|
|
|
|
}
|
|
|
|
});
|
|
|
|
|
2023-04-08 22:18:02 +05:30
|
|
|
applyCurrentlySelectedTheme(true);
|
2018-07-15 18:21:05 +05:30
|
|
|
|
2022-10-06 18:16:12 +05:30
|
|
|
updateCapabilities();
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
if(createSetupWizard())
|
|
|
|
{
|
|
|
|
return;
|
|
|
|
}
|
2022-08-09 00:19:49 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
performMainStartupAction();
|
2017-01-21 22:48:53 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
bool Application::createSetupWizard()
|
2017-01-21 22:48:53 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
bool javaRequired = [&]()
|
|
|
|
{
|
2022-04-30 18:49:57 +05:30
|
|
|
bool ignoreJavaWizard = m_settings->get("IgnoreJavaWizard").toBool();
|
|
|
|
if(ignoreJavaWizard) {
|
|
|
|
return false;
|
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
QString currentHostName = QHostInfo::localHostName();
|
|
|
|
QString oldHostName = settings()->get("LastHostname").toString();
|
|
|
|
if (currentHostName != oldHostName)
|
|
|
|
{
|
|
|
|
settings()->set("LastHostname", currentHostName);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
QString currentJavaPath = settings()->get("JavaPath").toString();
|
|
|
|
QString actualPath = FS::ResolveExecutable(currentJavaPath);
|
|
|
|
if (actualPath.isNull())
|
|
|
|
{
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}();
|
|
|
|
bool languageRequired = [&]()
|
|
|
|
{
|
|
|
|
if (settings()->get("Language").toString().isEmpty())
|
|
|
|
return true;
|
|
|
|
return false;
|
|
|
|
}();
|
2022-05-17 09:30:06 +05:30
|
|
|
bool pasteInterventionRequired = settings()->get("PastebinURL") != "";
|
2023-01-09 21:28:27 +05:30
|
|
|
bool themeInterventionRequired = settings()->get("ApplicationTheme") == "";
|
|
|
|
bool wizardRequired = javaRequired || languageRequired || pasteInterventionRequired || themeInterventionRequired;
|
2018-07-15 18:21:05 +05:30
|
|
|
|
|
|
|
if(wizardRequired)
|
|
|
|
{
|
|
|
|
m_setupWizard = new SetupWizard(nullptr);
|
|
|
|
if (languageRequired)
|
|
|
|
{
|
|
|
|
m_setupWizard->addPage(new LanguageWizardPage(m_setupWizard));
|
|
|
|
}
|
2022-04-30 18:49:57 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
if (javaRequired)
|
|
|
|
{
|
|
|
|
m_setupWizard->addPage(new JavaWizardPage(m_setupWizard));
|
|
|
|
}
|
2022-05-17 09:30:06 +05:30
|
|
|
|
|
|
|
if (pasteInterventionRequired)
|
|
|
|
{
|
|
|
|
m_setupWizard->addPage(new PasteWizardPage(m_setupWizard));
|
|
|
|
}
|
2022-10-22 23:13:04 +05:30
|
|
|
|
|
|
|
if (themeInterventionRequired)
|
|
|
|
{
|
2023-01-09 21:28:27 +05:30
|
|
|
settings()->set("ApplicationTheme", QString("system")); // set default theme after going into theme wizard
|
2022-10-22 23:13:04 +05:30
|
|
|
m_setupWizard->addPage(new ThemeWizardPage(m_setupWizard));
|
|
|
|
}
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(m_setupWizard, &QDialog::finished, this, &Application::setupWizardFinished);
|
2018-07-15 18:21:05 +05:30
|
|
|
m_setupWizard->show();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2017-01-06 10:38:45 +05:30
|
|
|
}
|
|
|
|
|
2022-11-19 21:08:05 +05:30
|
|
|
bool Application::event(QEvent* event)
|
|
|
|
{
|
2022-05-24 11:05:01 +05:30
|
|
|
#ifdef Q_OS_MACOS
|
|
|
|
if (event->type() == QEvent::ApplicationStateChange) {
|
|
|
|
auto ev = static_cast<QApplicationStateChangeEvent*>(event);
|
|
|
|
|
2022-11-19 21:08:05 +05:30
|
|
|
if (m_prevAppState == Qt::ApplicationActive && ev->applicationState() == Qt::ApplicationActive) {
|
2022-05-24 11:05:01 +05:30
|
|
|
emit clickedOnDock();
|
|
|
|
}
|
|
|
|
m_prevAppState = ev->applicationState();
|
|
|
|
}
|
|
|
|
#endif
|
2022-10-22 18:21:46 +05:30
|
|
|
|
|
|
|
if (event->type() == QEvent::FileOpen) {
|
|
|
|
auto ev = static_cast<QFileOpenEvent*>(event);
|
2022-12-31 06:36:17 +05:30
|
|
|
m_mainWindow->processURLs({ ev->url() });
|
2022-05-24 11:05:01 +05:30
|
|
|
}
|
2022-10-22 21:17:53 +05:30
|
|
|
|
2022-05-24 11:05:01 +05:30
|
|
|
return QApplication::event(event);
|
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::setupWizardFinished(int status)
|
2017-01-06 10:38:45 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
qDebug() << "Wizard result =" << status;
|
|
|
|
performMainStartupAction();
|
2017-01-06 10:38:45 +05:30
|
|
|
}
|
2016-12-01 06:47:27 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::performMainStartupAction()
|
2017-01-06 10:38:45 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
m_status = Application::Initialized;
|
2018-07-15 18:21:05 +05:30
|
|
|
if(!m_instanceIdToLaunch.isEmpty())
|
|
|
|
{
|
|
|
|
auto inst = instances()->getInstanceById(m_instanceIdToLaunch);
|
|
|
|
if(inst)
|
|
|
|
{
|
2021-05-23 18:12:20 +05:30
|
|
|
MinecraftServerTargetPtr serverToJoin = nullptr;
|
2021-11-01 02:12:06 +05:30
|
|
|
MinecraftAccountPtr accountToUse = nullptr;
|
2021-05-23 18:12:20 +05:30
|
|
|
|
2021-11-01 02:12:06 +05:30
|
|
|
qDebug() << "<> Instance" << m_instanceIdToLaunch << "launching";
|
2021-05-23 18:12:20 +05:30
|
|
|
if(!m_serverToJoin.isEmpty())
|
|
|
|
{
|
2021-11-01 02:12:06 +05:30
|
|
|
// FIXME: validate the server string
|
2021-05-23 18:12:20 +05:30
|
|
|
serverToJoin.reset(new MinecraftServerTarget(MinecraftServerTarget::parse(m_serverToJoin)));
|
2021-11-01 02:12:06 +05:30
|
|
|
qDebug() << " Launching with server" << m_serverToJoin;
|
2021-05-23 18:12:20 +05:30
|
|
|
}
|
2021-11-01 02:12:06 +05:30
|
|
|
|
|
|
|
if(!m_profileToUse.isEmpty())
|
2021-05-23 18:12:20 +05:30
|
|
|
{
|
2021-11-01 02:12:06 +05:30
|
|
|
accountToUse = accounts()->getAccountByProfileName(m_profileToUse);
|
|
|
|
if(!accountToUse) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
qDebug() << " Launching with account" << m_profileToUse;
|
2021-05-23 18:12:20 +05:30
|
|
|
}
|
|
|
|
|
2022-07-12 00:16:11 +05:30
|
|
|
launch(inst, true, false, nullptr, serverToJoin, accountToUse);
|
2018-07-15 18:21:05 +05:30
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2022-10-22 00:10:28 +05:30
|
|
|
if(!m_instanceIdToShowWindowOf.isEmpty())
|
|
|
|
{
|
|
|
|
auto inst = instances()->getInstanceById(m_instanceIdToShowWindowOf);
|
|
|
|
if(inst)
|
|
|
|
{
|
|
|
|
qDebug() << "<> Showing window of instance " << m_instanceIdToShowWindowOf;
|
|
|
|
showInstanceWindow(inst);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
2022-12-21 04:12:34 +05:30
|
|
|
|
|
|
|
{
|
|
|
|
bool shouldFetch = m_settings->get("FlameKeyShouldBeFetchedOnStartup").toBool();
|
|
|
|
if (!BuildConfig.FLAME_API_KEY_API_URL.isEmpty() && shouldFetch && !(capabilities() & Capability::SupportsFlame))
|
|
|
|
{
|
|
|
|
// don't ask, just fetch
|
|
|
|
QString apiKey = GuiUtil::fetchFlameKey();
|
|
|
|
if (!apiKey.isEmpty())
|
|
|
|
{
|
|
|
|
m_settings->set("FlameKeyOverride", apiKey);
|
|
|
|
updateCapabilities();
|
|
|
|
}
|
|
|
|
m_settings->set("FlameKeyShouldBeFetchedOnStartup", false);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
if(!m_mainWindow)
|
|
|
|
{
|
|
|
|
// normal main window
|
|
|
|
showMainWindow(false);
|
|
|
|
qDebug() << "<> Main window shown.";
|
|
|
|
}
|
2022-12-31 06:36:17 +05:30
|
|
|
if(!m_zipsToImport.isEmpty())
|
2020-02-05 04:59:23 +05:30
|
|
|
{
|
2022-12-31 06:36:17 +05:30
|
|
|
qDebug() << "<> Importing from zip:" << m_zipsToImport;
|
|
|
|
m_mainWindow->processURLs( m_zipsToImport );
|
2020-02-05 04:59:23 +05:30
|
|
|
}
|
2013-09-07 07:30:58 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::showFatalErrorMessage(const QString& title, const QString& content)
|
2017-01-14 20:17:58 +05:30
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
m_status = Application::Failed;
|
2018-07-15 18:21:05 +05:30
|
|
|
auto dialog = CustomMessageBox::selectable(nullptr, title, content, QMessageBox::Critical);
|
|
|
|
dialog->exec();
|
2017-01-14 20:17:58 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
Application::~Application()
|
2013-09-07 07:30:58 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
// Shut down logger by setting the logger function to nothing
|
|
|
|
qInstallMessageHandler(nullptr);
|
2017-07-05 23:15:10 +05:30
|
|
|
|
2016-06-09 05:28:50 +05:30
|
|
|
#if defined Q_OS_WIN32
|
2018-07-15 18:21:05 +05:30
|
|
|
// Detach from Windows console
|
|
|
|
if(consoleAttached)
|
|
|
|
{
|
|
|
|
fclose(stdout);
|
|
|
|
fclose(stdin);
|
|
|
|
fclose(stderr);
|
|
|
|
FreeConsole();
|
|
|
|
}
|
2016-06-09 05:28:50 +05:30
|
|
|
#endif
|
2013-09-07 07:30:58 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::messageReceived(const QByteArray& message)
|
2016-10-30 07:07:38 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if(status() != Initialized)
|
|
|
|
{
|
|
|
|
qDebug() << "Received message" << message << "while still initializing. It will be ignored.";
|
|
|
|
return;
|
|
|
|
}
|
2020-02-05 04:59:23 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
ApplicationMessage received;
|
2021-11-01 02:12:06 +05:30
|
|
|
received.parse(message);
|
|
|
|
|
|
|
|
auto & command = received.command;
|
2020-02-05 04:59:23 +05:30
|
|
|
|
|
|
|
if(command == "activate")
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
|
|
|
showMainWindow();
|
|
|
|
}
|
2020-02-05 04:59:23 +05:30
|
|
|
else if(command == "import")
|
|
|
|
{
|
2021-11-01 02:12:06 +05:30
|
|
|
QString path = received.args["path"];
|
|
|
|
if(path.isEmpty())
|
2020-02-05 04:59:23 +05:30
|
|
|
{
|
|
|
|
qWarning() << "Received" << command << "message without a zip path/URL.";
|
|
|
|
return;
|
|
|
|
}
|
2023-01-02 21:25:32 +05:30
|
|
|
m_mainWindow->processURLs({ QUrl::fromLocalFile(QFileInfo(path).absoluteFilePath()) });
|
2020-02-05 04:59:23 +05:30
|
|
|
}
|
|
|
|
else if(command == "launch")
|
2018-07-15 18:21:05 +05:30
|
|
|
{
|
2021-11-01 02:12:06 +05:30
|
|
|
QString id = received.args["id"];
|
|
|
|
QString server = received.args["server"];
|
|
|
|
QString profile = received.args["profile"];
|
|
|
|
|
|
|
|
InstancePtr instance;
|
|
|
|
if(!id.isEmpty()) {
|
|
|
|
instance = instances()->getInstanceById(id);
|
|
|
|
if(!instance) {
|
|
|
|
qWarning() << "Launch command requires an valid instance ID. " << id << "resolves to nothing.";
|
|
|
|
return;
|
|
|
|
}
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
2021-11-01 02:12:06 +05:30
|
|
|
else {
|
|
|
|
qWarning() << "Launch command called without an instance ID...";
|
2021-05-23 18:12:20 +05:30
|
|
|
return;
|
|
|
|
}
|
2021-11-01 02:12:06 +05:30
|
|
|
|
|
|
|
MinecraftServerTargetPtr serverObject = nullptr;
|
|
|
|
if(!server.isEmpty()) {
|
|
|
|
serverObject = std::make_shared<MinecraftServerTarget>(MinecraftServerTarget::parse(server));
|
2021-05-23 18:12:20 +05:30
|
|
|
}
|
2021-11-01 02:12:06 +05:30
|
|
|
|
|
|
|
MinecraftAccountPtr accountObject;
|
|
|
|
if(!profile.isEmpty()) {
|
|
|
|
accountObject = accounts()->getAccountByProfileName(profile);
|
|
|
|
if(!accountObject) {
|
|
|
|
qWarning() << "Launch command requires the specified profile to be valid. " << profile << "does not resolve to any account.";
|
|
|
|
return;
|
|
|
|
}
|
2021-05-23 18:12:20 +05:30
|
|
|
}
|
2021-11-01 02:12:06 +05:30
|
|
|
|
|
|
|
launch(
|
|
|
|
instance,
|
|
|
|
true,
|
2022-07-12 00:16:11 +05:30
|
|
|
false,
|
2021-11-01 02:12:06 +05:30
|
|
|
nullptr,
|
|
|
|
serverObject,
|
|
|
|
accountObject
|
|
|
|
);
|
2021-05-23 18:12:20 +05:30
|
|
|
}
|
2020-02-05 04:59:23 +05:30
|
|
|
else
|
|
|
|
{
|
|
|
|
qWarning() << "Received invalid message" << message;
|
|
|
|
}
|
2016-10-30 07:07:38 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
std::shared_ptr<TranslationsModel> Application::translations()
|
2016-12-05 06:59:08 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
return m_translations;
|
2016-12-05 06:59:08 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
std::shared_ptr<JavaInstallList> Application::javalist()
|
2013-10-14 07:29:21 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!m_javalist)
|
|
|
|
{
|
|
|
|
m_javalist.reset(new JavaInstallList());
|
|
|
|
}
|
|
|
|
return m_javalist;
|
2013-10-14 07:29:21 +05:30
|
|
|
}
|
|
|
|
|
2022-11-01 20:11:08 +05:30
|
|
|
QList<ITheme*> Application::getValidApplicationThemes()
|
2016-10-21 12:37:26 +05:30
|
|
|
{
|
2022-10-29 22:57:20 +05:30
|
|
|
return m_themeManager->getValidApplicationThemes();
|
2016-10-21 12:37:26 +05:30
|
|
|
}
|
|
|
|
|
2023-04-08 22:18:02 +05:30
|
|
|
void Application::applyCurrentlySelectedTheme(bool initial)
|
2022-10-22 23:13:04 +05:30
|
|
|
{
|
2023-04-08 22:18:02 +05:30
|
|
|
m_themeManager->applyCurrentlySelectedTheme(initial);
|
2022-10-22 23:13:04 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
void Application::setApplicationTheme(const QString& name)
|
2016-10-21 12:37:26 +05:30
|
|
|
{
|
2022-10-22 23:13:04 +05:30
|
|
|
m_themeManager->setApplicationTheme(name);
|
2016-10-21 12:37:26 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::setIconTheme(const QString& name)
|
2015-03-02 02:50:57 +05:30
|
|
|
{
|
2022-10-29 22:57:20 +05:30
|
|
|
m_themeManager->setIconTheme(name);
|
2015-03-02 02:50:57 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
QIcon Application::getThemedIcon(const QString& name)
|
2015-03-02 02:50:57 +05:30
|
|
|
{
|
2021-10-18 04:17:02 +05:30
|
|
|
if(name == "logo") {
|
2022-10-29 18:33:44 +05:30
|
|
|
return QIcon(":/" + BuildConfig.LAUNCHER_SVGFILENAME);
|
2021-10-18 04:17:02 +05:30
|
|
|
}
|
2022-05-02 22:40:45 +05:30
|
|
|
return QIcon::fromTheme(name);
|
2015-03-02 02:50:57 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
bool Application::openJsonEditor(const QString &filename)
|
2013-12-29 22:21:16 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
const QString file = QDir::current().absoluteFilePath(filename);
|
|
|
|
if (m_settings->get("JsonEditor").toString().isEmpty())
|
|
|
|
{
|
|
|
|
return DesktopServices::openUrl(QUrl::fromLocalFile(file));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
//return DesktopServices::openFile(m_settings->get("JsonEditor").toString(), file);
|
|
|
|
return DesktopServices::run(m_settings->get("JsonEditor").toString(), {file});
|
|
|
|
}
|
2013-12-29 22:21:16 +05:30
|
|
|
}
|
2013-09-07 07:30:58 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
bool Application::launch(
|
2021-05-22 21:37:08 +05:30
|
|
|
InstancePtr instance,
|
|
|
|
bool online,
|
2022-07-12 00:16:11 +05:30
|
|
|
bool demo,
|
2021-05-22 21:37:08 +05:30
|
|
|
BaseProfilerFactory *profiler,
|
2021-11-01 02:12:06 +05:30
|
|
|
MinecraftServerTargetPtr serverToJoin,
|
|
|
|
MinecraftAccountPtr accountToUse
|
2021-05-22 21:37:08 +05:30
|
|
|
) {
|
2018-07-15 18:21:05 +05:30
|
|
|
if(m_updateRunning)
|
|
|
|
{
|
2019-09-15 09:01:13 +05:30
|
|
|
qDebug() << "Cannot launch instances while an update is running. Please try again when updates are completed.";
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
else if(instance->canLaunch())
|
|
|
|
{
|
|
|
|
auto & extras = m_instanceExtras[instance->id()];
|
|
|
|
auto & window = extras.window;
|
|
|
|
if(window)
|
|
|
|
{
|
|
|
|
if(!window->saveAll())
|
|
|
|
{
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
auto & controller = extras.controller;
|
|
|
|
controller.reset(new LaunchController());
|
|
|
|
controller->setInstance(instance);
|
|
|
|
controller->setOnline(online);
|
2022-07-12 00:16:11 +05:30
|
|
|
controller->setDemo(demo);
|
2018-07-15 18:21:05 +05:30
|
|
|
controller->setProfiler(profiler);
|
2021-05-22 21:37:08 +05:30
|
|
|
controller->setServerToJoin(serverToJoin);
|
2021-11-01 02:12:06 +05:30
|
|
|
controller->setAccountToUse(accountToUse);
|
2018-07-15 18:21:05 +05:30
|
|
|
if(window)
|
|
|
|
{
|
|
|
|
controller->setParentWidget(window);
|
|
|
|
}
|
|
|
|
else if(m_mainWindow)
|
|
|
|
{
|
|
|
|
controller->setParentWidget(m_mainWindow);
|
|
|
|
}
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(controller.get(), &LaunchController::succeeded, this, &Application::controllerSucceeded);
|
|
|
|
connect(controller.get(), &LaunchController::failed, this, &Application::controllerFailed);
|
2022-08-04 13:32:54 +05:30
|
|
|
connect(controller.get(), &LaunchController::aborted, this, [this] {
|
|
|
|
controllerFailed(tr("Aborted"));
|
|
|
|
});
|
2018-07-15 18:21:05 +05:30
|
|
|
addRunningInstance();
|
|
|
|
controller->start();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else if (instance->isRunning())
|
|
|
|
{
|
|
|
|
showInstanceWindow(instance, "console");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
else if (instance->canEdit())
|
|
|
|
{
|
|
|
|
showInstanceWindow(instance);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
2016-10-30 07:07:38 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
bool Application::kill(InstancePtr instance)
|
2016-11-26 22:36:08 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if (!instance->isRunning())
|
|
|
|
{
|
2019-09-15 09:01:13 +05:30
|
|
|
qWarning() << "Attempted to kill instance" << instance->id() << ", which isn't running.";
|
2018-07-15 18:21:05 +05:30
|
|
|
return false;
|
|
|
|
}
|
|
|
|
auto & extras = m_instanceExtras[instance->id()];
|
|
|
|
// NOTE: copy of the shared pointer keeps it alive
|
|
|
|
auto controller = extras.controller;
|
|
|
|
if(controller)
|
|
|
|
{
|
|
|
|
return controller->abort();
|
|
|
|
}
|
|
|
|
return true;
|
2016-11-26 22:36:08 +05:30
|
|
|
}
|
|
|
|
|
2022-04-16 11:37:29 +05:30
|
|
|
void Application::closeCurrentWindow()
|
|
|
|
{
|
|
|
|
if (focusWindow())
|
|
|
|
focusWindow()->close();
|
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::addRunningInstance()
|
2017-05-02 05:13:18 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
m_runningInstances ++;
|
|
|
|
if(m_runningInstances == 1)
|
|
|
|
{
|
|
|
|
emit updateAllowedChanged(false);
|
|
|
|
}
|
2017-05-02 05:13:18 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::subRunningInstance()
|
2017-05-02 05:13:18 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if(m_runningInstances == 0)
|
|
|
|
{
|
|
|
|
qCritical() << "Something went really wrong and we now have less than 0 running instances... WTF";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
m_runningInstances --;
|
|
|
|
if(m_runningInstances == 0)
|
|
|
|
{
|
|
|
|
emit updateAllowedChanged(true);
|
|
|
|
}
|
2017-05-02 05:13:18 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
bool Application::shouldExitNow() const
|
2017-05-02 05:13:18 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
return m_runningInstances == 0 && m_openWindows == 0;
|
2017-05-02 05:13:18 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
bool Application::updatesAreAllowed()
|
2017-05-02 05:13:18 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
return m_runningInstances == 0;
|
2017-05-02 05:13:18 +05:30
|
|
|
}
|
2016-11-26 22:36:08 +05:30
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::updateIsRunning(bool running)
|
2017-05-03 02:59:47 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
m_updateRunning = running;
|
2017-05-03 02:59:47 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::controllerSucceeded()
|
2016-11-01 05:55:04 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
auto controller = qobject_cast<LaunchController *>(QObject::sender());
|
|
|
|
if(!controller)
|
|
|
|
return;
|
|
|
|
auto id = controller->id();
|
|
|
|
auto & extras = m_instanceExtras[id];
|
|
|
|
|
|
|
|
// on success, do...
|
|
|
|
if (controller->instance()->settings()->get("AutoCloseConsole").toBool())
|
|
|
|
{
|
|
|
|
if(extras.window)
|
|
|
|
{
|
|
|
|
extras.window->close();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
extras.controller.reset();
|
|
|
|
subRunningInstance();
|
|
|
|
|
|
|
|
// quit when there are no more windows.
|
|
|
|
if(shouldExitNow())
|
|
|
|
{
|
|
|
|
m_status = Status::Succeeded;
|
|
|
|
exit(0);
|
|
|
|
}
|
2016-11-01 05:55:04 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::controllerFailed(const QString& error)
|
2016-11-01 05:55:04 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
Q_UNUSED(error);
|
|
|
|
auto controller = qobject_cast<LaunchController *>(QObject::sender());
|
|
|
|
if(!controller)
|
|
|
|
return;
|
|
|
|
auto id = controller->id();
|
|
|
|
auto & extras = m_instanceExtras[id];
|
|
|
|
|
|
|
|
// on failure, do... nothing
|
|
|
|
extras.controller.reset();
|
|
|
|
subRunningInstance();
|
|
|
|
|
|
|
|
// quit when there are no more windows.
|
|
|
|
if(shouldExitNow())
|
|
|
|
{
|
|
|
|
m_status = Status::Failed;
|
|
|
|
exit(1);
|
|
|
|
}
|
2016-11-01 05:55:04 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::ShowGlobalSettings(class QWidget* parent, QString open_page)
|
2019-06-01 15:58:53 +05:30
|
|
|
{
|
|
|
|
if(!m_globalSettingsProvider) {
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
emit globalSettingsAboutToOpen();
|
|
|
|
{
|
2021-11-20 20:52:22 +05:30
|
|
|
SettingsObject::Lock lock(APPLICATION->settings());
|
2019-06-01 15:58:53 +05:30
|
|
|
PageDialog dlg(m_globalSettingsProvider.get(), open_page, parent);
|
|
|
|
dlg.exec();
|
|
|
|
}
|
|
|
|
emit globalSettingsClosed();
|
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
MainWindow* Application::showMainWindow(bool minimized)
|
2016-10-30 07:07:38 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if(m_mainWindow)
|
|
|
|
{
|
|
|
|
m_mainWindow->setWindowState(m_mainWindow->windowState() & ~Qt::WindowMinimized);
|
|
|
|
m_mainWindow->raise();
|
|
|
|
m_mainWindow->activateWindow();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_mainWindow = new MainWindow();
|
2021-11-20 20:52:22 +05:30
|
|
|
m_mainWindow->restoreState(QByteArray::fromBase64(APPLICATION->settings()->get("MainWindowState").toByteArray()));
|
|
|
|
m_mainWindow->restoreGeometry(QByteArray::fromBase64(APPLICATION->settings()->get("MainWindowGeometry").toByteArray()));
|
2023-01-10 01:06:31 +05:30
|
|
|
|
2018-07-15 18:21:05 +05:30
|
|
|
if(minimized)
|
|
|
|
{
|
|
|
|
m_mainWindow->showMinimized();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
m_mainWindow->show();
|
|
|
|
}
|
|
|
|
|
|
|
|
m_mainWindow->checkInstancePathForProblems();
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(this, &Application::updateAllowedChanged, m_mainWindow, &MainWindow::updatesAllowedChanged);
|
|
|
|
connect(m_mainWindow, &MainWindow::isClosing, this, &Application::on_windowClose);
|
2018-07-15 18:21:05 +05:30
|
|
|
m_openWindows++;
|
|
|
|
}
|
|
|
|
return m_mainWindow;
|
2016-10-30 07:07:38 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
InstanceWindow *Application::showInstanceWindow(InstancePtr instance, QString page)
|
2016-10-30 07:07:38 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
if(!instance)
|
|
|
|
return nullptr;
|
|
|
|
auto id = instance->id();
|
|
|
|
auto & extras = m_instanceExtras[id];
|
|
|
|
auto & window = extras.window;
|
|
|
|
|
|
|
|
if(window)
|
|
|
|
{
|
|
|
|
window->raise();
|
|
|
|
window->activateWindow();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
window = new InstanceWindow(instance);
|
|
|
|
m_openWindows ++;
|
2021-11-20 20:52:22 +05:30
|
|
|
connect(window, &InstanceWindow::isClosing, this, &Application::on_windowClose);
|
2018-07-15 18:21:05 +05:30
|
|
|
}
|
|
|
|
if(!page.isEmpty())
|
|
|
|
{
|
|
|
|
window->selectPage(page);
|
|
|
|
}
|
|
|
|
if(extras.controller)
|
|
|
|
{
|
|
|
|
extras.controller->setParentWidget(window);
|
|
|
|
}
|
|
|
|
return window;
|
2016-10-30 07:07:38 +05:30
|
|
|
}
|
|
|
|
|
2021-11-20 20:52:22 +05:30
|
|
|
void Application::on_windowClose()
|
2016-10-30 07:07:38 +05:30
|
|
|
{
|
2018-07-15 18:21:05 +05:30
|
|
|
m_openWindows--;
|
|
|
|
auto instWindow = qobject_cast<InstanceWindow *>(QObject::sender());
|
|
|
|
if(instWindow)
|
|
|
|
{
|
|
|
|
auto & extras = m_instanceExtras[instWindow->instanceId()];
|
|
|
|
extras.window = nullptr;
|
|
|
|
if(extras.controller)
|
|
|
|
{
|
|
|
|
extras.controller->setParentWidget(m_mainWindow);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
auto mainWindow = qobject_cast<MainWindow *>(QObject::sender());
|
|
|
|
if(mainWindow)
|
|
|
|
{
|
|
|
|
m_mainWindow = nullptr;
|
|
|
|
}
|
|
|
|
// quit when there are no more windows.
|
|
|
|
if(shouldExitNow())
|
|
|
|
{
|
|
|
|
exit(0);
|
|
|
|
}
|
2016-10-30 07:07:38 +05:30
|
|
|
}
|
2021-11-20 20:52:22 +05:30
|
|
|
|
2021-11-22 03:51:12 +05:30
|
|
|
void Application::updateProxySettings(QString proxyTypeStr, QString addr, int port, QString user, QString password)
|
|
|
|
{
|
|
|
|
// Set the application proxy settings.
|
|
|
|
if (proxyTypeStr == "SOCKS5")
|
|
|
|
{
|
|
|
|
QNetworkProxy::setApplicationProxy(
|
|
|
|
QNetworkProxy(QNetworkProxy::Socks5Proxy, addr, port, user, password));
|
|
|
|
}
|
|
|
|
else if (proxyTypeStr == "HTTP")
|
|
|
|
{
|
|
|
|
QNetworkProxy::setApplicationProxy(
|
|
|
|
QNetworkProxy(QNetworkProxy::HttpProxy, addr, port, user, password));
|
|
|
|
}
|
|
|
|
else if (proxyTypeStr == "None")
|
|
|
|
{
|
|
|
|
// If we have no proxy set, set no proxy and return.
|
|
|
|
QNetworkProxy::setApplicationProxy(QNetworkProxy(QNetworkProxy::NoProxy));
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// If we have "Default" selected, set Qt to use the system proxy settings.
|
|
|
|
QNetworkProxyFactory::setUseSystemConfiguration(true);
|
|
|
|
}
|
|
|
|
|
|
|
|
qDebug() << "Detecting proxy settings...";
|
|
|
|
QNetworkProxy proxy = QNetworkProxy::applicationProxy();
|
|
|
|
m_network->setProxy(proxy);
|
|
|
|
|
|
|
|
QString proxyDesc;
|
|
|
|
if (proxy.type() == QNetworkProxy::NoProxy)
|
|
|
|
{
|
|
|
|
qDebug() << "Using no proxy is an option!";
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
switch (proxy.type())
|
|
|
|
{
|
|
|
|
case QNetworkProxy::DefaultProxy:
|
|
|
|
proxyDesc = "Default proxy: ";
|
|
|
|
break;
|
|
|
|
case QNetworkProxy::Socks5Proxy:
|
|
|
|
proxyDesc = "Socks5 proxy: ";
|
|
|
|
break;
|
|
|
|
case QNetworkProxy::HttpProxy:
|
|
|
|
proxyDesc = "HTTP proxy: ";
|
|
|
|
break;
|
|
|
|
case QNetworkProxy::HttpCachingProxy:
|
|
|
|
proxyDesc = "HTTP caching: ";
|
|
|
|
break;
|
|
|
|
case QNetworkProxy::FtpCachingProxy:
|
|
|
|
proxyDesc = "FTP caching: ";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
proxyDesc = "DERP proxy: ";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
proxyDesc += QString("%1:%2")
|
|
|
|
.arg(proxy.hostName())
|
|
|
|
.arg(proxy.port());
|
|
|
|
qDebug() << proxyDesc;
|
|
|
|
}
|
|
|
|
|
|
|
|
shared_qobject_ptr< HttpMetaCache > Application::metacache()
|
|
|
|
{
|
|
|
|
return m_metacache;
|
|
|
|
}
|
|
|
|
|
|
|
|
shared_qobject_ptr<QNetworkAccessManager> Application::network()
|
|
|
|
{
|
|
|
|
return m_network;
|
|
|
|
}
|
|
|
|
|
|
|
|
shared_qobject_ptr<Meta::Index> Application::metadataIndex()
|
|
|
|
{
|
|
|
|
if (!m_metadataIndex)
|
|
|
|
{
|
|
|
|
m_metadataIndex.reset(new Meta::Index());
|
|
|
|
}
|
|
|
|
return m_metadataIndex;
|
|
|
|
}
|
|
|
|
|
2022-08-09 00:19:49 +05:30
|
|
|
void Application::updateCapabilities()
|
2022-05-30 00:48:34 +05:30
|
|
|
{
|
2022-08-09 00:19:49 +05:30
|
|
|
m_capabilities = None;
|
2022-05-30 00:48:34 +05:30
|
|
|
if (!getMSAClientID().isEmpty())
|
2022-08-09 00:19:49 +05:30
|
|
|
m_capabilities |= SupportsMSA;
|
2022-05-30 00:48:34 +05:30
|
|
|
if (!getFlameAPIKey().isEmpty())
|
2022-08-09 00:19:49 +05:30
|
|
|
m_capabilities |= SupportsFlame;
|
2022-08-09 00:33:02 +05:30
|
|
|
|
|
|
|
#ifdef Q_OS_LINUX
|
|
|
|
if (gamemode_query_status() >= 0)
|
|
|
|
m_capabilities |= SupportsGameMode;
|
|
|
|
|
2022-12-11 15:31:33 +05:30
|
|
|
if (!MangoHud::getLibraryString().isEmpty())
|
|
|
|
m_capabilities |= SupportsMangoHud;
|
2022-08-09 00:33:02 +05:30
|
|
|
#endif
|
2022-05-30 00:48:34 +05:30
|
|
|
}
|
|
|
|
|
2022-06-15 01:30:24 +05:30
|
|
|
QString Application::getJarPath(QString jarFile)
|
2021-11-22 03:51:12 +05:30
|
|
|
{
|
2022-06-15 01:30:24 +05:30
|
|
|
QStringList potentialPaths = {
|
|
|
|
#if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
|
2022-10-22 18:48:58 +05:30
|
|
|
FS::PathCombine(m_rootPath, "share/" + BuildConfig.LAUNCHER_APP_BINARY_NAME),
|
2022-06-15 01:30:24 +05:30
|
|
|
#endif
|
|
|
|
FS::PathCombine(m_rootPath, "jars"),
|
2023-01-24 07:06:58 +05:30
|
|
|
FS::PathCombine(applicationDirPath(), "jars"),
|
2023-01-24 21:54:12 +05:30
|
|
|
FS::PathCombine(applicationDirPath(), "..", "jars") // from inside build dir, for debuging
|
2022-06-15 01:30:24 +05:30
|
|
|
};
|
|
|
|
for(QString p : potentialPaths)
|
2021-11-22 03:51:12 +05:30
|
|
|
{
|
2022-06-15 01:30:24 +05:30
|
|
|
QString jarPath = FS::PathCombine(p, jarFile);
|
|
|
|
if (QFileInfo(jarPath).isFile())
|
|
|
|
return jarPath;
|
2021-11-22 03:51:12 +05:30
|
|
|
}
|
2022-06-15 01:30:24 +05:30
|
|
|
return {};
|
2021-11-22 03:51:12 +05:30
|
|
|
}
|
2022-02-13 00:50:51 +05:30
|
|
|
|
2022-02-21 05:53:08 +05:30
|
|
|
QString Application::getMSAClientID()
|
2022-02-13 00:50:51 +05:30
|
|
|
{
|
|
|
|
QString clientIDOverride = m_settings->get("MSAClientIDOverride").toString();
|
|
|
|
if (!clientIDOverride.isEmpty()) {
|
|
|
|
return clientIDOverride;
|
|
|
|
}
|
|
|
|
|
|
|
|
return BuildConfig.MSA_CLIENT_ID;
|
|
|
|
}
|
2022-05-20 23:26:27 +05:30
|
|
|
|
2022-05-30 00:59:07 +05:30
|
|
|
QString Application::getFlameAPIKey()
|
2022-05-20 23:26:27 +05:30
|
|
|
{
|
2022-05-30 00:59:07 +05:30
|
|
|
QString keyOverride = m_settings->get("FlameKeyOverride").toString();
|
2022-05-20 23:26:27 +05:30
|
|
|
if (!keyOverride.isEmpty()) {
|
|
|
|
return keyOverride;
|
|
|
|
}
|
|
|
|
|
2022-05-30 00:59:07 +05:30
|
|
|
return BuildConfig.FLAME_API_KEY;
|
2022-05-20 23:26:27 +05:30
|
|
|
}
|
2022-06-04 13:03:17 +05:30
|
|
|
|
2023-03-01 15:24:49 +05:30
|
|
|
QString Application::getModrinthAPIToken()
|
|
|
|
{
|
|
|
|
QString tokenOverride = m_settings->get("ModrinthToken").toString();
|
|
|
|
if (!tokenOverride.isEmpty())
|
|
|
|
return tokenOverride;
|
|
|
|
|
|
|
|
return QString();
|
|
|
|
}
|
|
|
|
|
2022-06-04 13:03:17 +05:30
|
|
|
QString Application::getUserAgent()
|
|
|
|
{
|
2022-06-04 20:29:57 +05:30
|
|
|
QString uaOverride = m_settings->get("UserAgentOverride").toString();
|
|
|
|
if (!uaOverride.isEmpty()) {
|
|
|
|
return uaOverride.replace("$LAUNCHER_VER", BuildConfig.printableVersionString());
|
2022-06-04 13:03:17 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
return BuildConfig.USER_AGENT;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString Application::getUserAgentUncached()
|
|
|
|
{
|
2022-06-04 20:29:57 +05:30
|
|
|
QString uaOverride = m_settings->get("UserAgentOverride").toString();
|
|
|
|
if (!uaOverride.isEmpty()) {
|
2022-06-05 21:22:21 +05:30
|
|
|
uaOverride += " (Uncached)";
|
2022-06-04 20:29:57 +05:30
|
|
|
return uaOverride.replace("$LAUNCHER_VER", BuildConfig.printableVersionString());
|
2022-06-04 13:03:17 +05:30
|
|
|
}
|
|
|
|
|
|
|
|
return BuildConfig.USER_AGENT_UNCACHED;
|
|
|
|
}
|
2022-11-04 11:58:58 +05:30
|
|
|
|
|
|
|
int Application::suitableMaxMem()
|
|
|
|
{
|
|
|
|
float totalRAM = (float)Sys::getSystemRam() / (float)Sys::mebibyte;
|
|
|
|
int maxMemoryAlloc;
|
|
|
|
|
|
|
|
// If totalRAM < 6GB, use (totalRAM / 1.5), else 4GB
|
|
|
|
if (totalRAM < (4096 * 1.5))
|
|
|
|
maxMemoryAlloc = (int) (totalRAM / 1.5);
|
|
|
|
else
|
|
|
|
maxMemoryAlloc = 4096;
|
|
|
|
|
|
|
|
return maxMemoryAlloc;
|
|
|
|
}
|
2022-10-23 05:15:32 +05:30
|
|
|
|
|
|
|
bool Application::handleDataMigration(const QString& currentData,
|
|
|
|
const QString& oldData,
|
|
|
|
const QString& name,
|
|
|
|
const QString& configFile) const
|
|
|
|
{
|
2022-11-10 23:34:42 +05:30
|
|
|
QString nomigratePath = FS::PathCombine(currentData, name + "_nomigrate.txt");
|
2022-10-23 05:15:32 +05:30
|
|
|
QStringList configPaths = { FS::PathCombine(oldData, configFile), FS::PathCombine(oldData, BuildConfig.LAUNCHER_CONFIGFILE) };
|
|
|
|
|
|
|
|
QLocale locale;
|
|
|
|
|
|
|
|
// Is there a valid config at the old location?
|
|
|
|
bool configExists = false;
|
|
|
|
for (QString configPath : configPaths) {
|
|
|
|
configExists |= QFileInfo::exists(configPath);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!configExists || QFileInfo::exists(nomigratePath)) {
|
|
|
|
qDebug() << "<> No migration needed from" << name;
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
QString message;
|
|
|
|
bool currentExists = QFileInfo::exists(FS::PathCombine(currentData, BuildConfig.LAUNCHER_CONFIGFILE));
|
|
|
|
|
|
|
|
if (currentExists) {
|
|
|
|
message = tr("Old data from %1 was found, but you already have existing data for %2. Sadly you will need to migrate yourself. Do "
|
|
|
|
"you want to be reminded of the pending data migration next time you start %2?")
|
|
|
|
.arg(name, BuildConfig.LAUNCHER_DISPLAYNAME);
|
|
|
|
} else {
|
|
|
|
message = tr("It looks like you used %1 before. Do you want to migrate your data to the new location of %2?")
|
|
|
|
.arg(name, BuildConfig.LAUNCHER_DISPLAYNAME);
|
|
|
|
|
|
|
|
QFileInfo logInfo(FS::PathCombine(oldData, name + "-0.log"));
|
|
|
|
if (logInfo.exists()) {
|
|
|
|
QString lastModified = logInfo.lastModified().toString(locale.dateFormat());
|
|
|
|
message = tr("It looks like you used %1 on %2 before. Do you want to migrate your data to the new location of %3?")
|
|
|
|
.arg(name, lastModified, BuildConfig.LAUNCHER_DISPLAYNAME);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
QMessageBox::StandardButton askMoveDialogue =
|
|
|
|
QMessageBox::question(nullptr, BuildConfig.LAUNCHER_DISPLAYNAME, message, QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes);
|
|
|
|
|
|
|
|
auto setDoNotMigrate = [&nomigratePath] {
|
|
|
|
QFile file(nomigratePath);
|
|
|
|
file.open(QIODevice::WriteOnly);
|
|
|
|
};
|
|
|
|
|
|
|
|
// create no-migrate file if user doesn't want to migrate
|
|
|
|
if (askMoveDialogue != QMessageBox::Yes) {
|
|
|
|
qDebug() << "<> Migration declined for" << name;
|
|
|
|
setDoNotMigrate();
|
|
|
|
return currentExists; // cancel further migrations, if we already have a data directory
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!currentExists) {
|
|
|
|
// Migrate!
|
|
|
|
auto matcher = std::make_shared<MultiMatcher>();
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>(configFile));
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>(
|
|
|
|
BuildConfig.LAUNCHER_CONFIGFILE)); // it's possible that we already used that directory before
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>("accounts.json"));
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>("accounts/"));
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>("assets/"));
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>("icons/"));
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>("instances/"));
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>("libraries/"));
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>("mods/"));
|
|
|
|
matcher->add(std::make_shared<SimplePrefixMatcher>("themes/"));
|
|
|
|
|
2022-11-10 23:34:42 +05:30
|
|
|
ProgressDialog diag;
|
2022-10-23 05:15:32 +05:30
|
|
|
DataMigrationTask task(nullptr, oldData, currentData, matcher);
|
|
|
|
if (diag.execWithTask(&task)) {
|
|
|
|
qDebug() << "<> Migration succeeded";
|
|
|
|
setDoNotMigrate();
|
|
|
|
} else {
|
|
|
|
QString reason = task.failReason();
|
|
|
|
QMessageBox::critical(nullptr, BuildConfig.LAUNCHER_DISPLAYNAME, tr("Migration failed! Reason: %1").arg(reason));
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
qWarning() << "<> Migration was skipped, due to existing data";
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
2022-12-21 01:53:42 +05:30
|
|
|
|
2022-11-02 03:15:15 +05:30
|
|
|
void Application::triggerUpdateCheck()
|
|
|
|
{
|
|
|
|
if (m_updater) {
|
|
|
|
qDebug() << "Checking for updates.";
|
|
|
|
m_updater->setBetaAllowed(false); // There are no other channels than stable
|
|
|
|
m_updater->checkForUpdates();
|
|
|
|
} else {
|
|
|
|
qDebug() << "Updater not available.";
|
|
|
|
}
|
|
|
|
}
|