Merge branch 'develop' of https://github.com/PrismLauncher/PrismLauncher into feature/java-downloader

Signed-off-by: Trial97 <alexandru.tripon97@gmail.com>

.github/workflows/build.yml

@@ -79,7 +79,7 @@ jobs:
             qt_ver: 6
             qt_host: windows
             qt_arch: ""
-            qt_version: "6.7.0"
+            qt_version: "6.7.1"
             qt_modules: "qt5compat qtimageformats qtnetworkauth"
 
           - os: windows-2022
@@ -90,7 +90,7 @@ jobs:
             qt_ver: 6
             qt_host: windows
             qt_arch: "win64_msvc2019_arm64"
-            qt_version: "6.7.0"
+            qt_version: "6.7.1"
             qt_modules: "qt5compat qtimageformats qtnetworkauth"
 
           - os: macos-12
@@ -99,7 +99,7 @@ jobs:
             qt_ver: 6
             qt_host: mac
             qt_arch: ""
-            qt_version: "6.7.0"
+            qt_version: "6.7.1"
             qt_modules: "qt5compat qtimageformats qtnetworkauth"
 
           - os: macos-12

.github/workflows/update-flake.yml

@@ -19,7 +19,7 @@ jobs:
       - uses: actions/checkout@v4
       - uses: cachix/install-nix-action@ba0dd844c9180cbf77aa72a116d6fbc515d0e87b # v27
 
-      - uses: DeterminateSystems/update-flake-lock@v21
+      - uses: DeterminateSystems/update-flake-lock@v22
         with:
           commit-msg: "chore(nix): update lockfile"
           pr-title: "chore(nix): update lockfile"

flake.lock

@@ -75,16 +75,16 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1717774105,
+        "lastModified": 1718276985,
-        "narHash": "sha256-HV97wqUQv9wvptiHCb3Y0/YH0lJ60uZ8FYfEOIzYEqI=",
+        "narHash": "sha256-u1fA0DYQYdeG+5kDm1bOoGcHtX0rtC7qs2YA2N1X++I=",
-        "owner": "nixos",
+        "owner": "NixOS",
         "repo": "nixpkgs",
-        "rev": "d226935fd75012939397c83f6c385e4d6d832288",
+        "rev": "3f84a279f1a6290ce154c5531378acc827836fbb",
         "type": "github"
       },
       "original": {
-        "owner": "nixos",
+        "owner": "NixOS",
-        "ref": "nixpkgs-unstable",
+        "ref": "nixos-unstable",
         "repo": "nixpkgs",
         "type": "github"
       }

flake.nix

@@ -7,7 +7,7 @@
   };
 
   inputs = {
-    nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
+    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
     flake-parts = {
       url = "github:hercules-ci/flake-parts";
       inputs.nixpkgs-lib.follows = "nixpkgs";

launcher/Application.cpp

@@ -852,24 +852,17 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
     {
         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());
         m_metacache->addBase("FlameMods", QDir("cache/FlameMods").absolutePath());
         m_metacache->addBase("ModrinthPacks", QDir("cache/ModrinthPacks").absolutePath());
         m_metacache->addBase("ModrinthModpacks", QDir("cache/ModrinthModpacks").absolutePath());
-        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());
         m_metacache->addBase("java", QDir("cache/java").absolutePath());
         m_metacache->Load();
@@ -951,8 +944,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
                     [[fallthrough]];
                 default: {
                     qDebug() << "Exiting because update lockfile is present";
-                    QMetaObject::invokeMethod(
+                    QMetaObject::invokeMethod(this, []() { exit(1); }, Qt::QueuedConnection);
-                        this, []() { exit(1); }, Qt::QueuedConnection);
                     return;
                 }
             }
@@ -984,8 +976,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
                     [[fallthrough]];
                 default: {
                     qDebug() << "Exiting because update lockfile is present";
-                    QMetaObject::invokeMethod(
+                    QMetaObject::invokeMethod(this, []() { exit(1); }, Qt::QueuedConnection);
-                        this, []() { exit(1); }, Qt::QueuedConnection);
                     return;
                 }
             }
@@ -997,7 +988,7 @@ Application::Application(int& argc, char** argv) : QApplication(argc, argv)
                               "\n"
                               "You are now running %1 .\n"
                               "Check the Prism Launcher updater log at: \n"
-                              "%1\n"
+                              "%2\n"
                               "for details.")
                                .arg(BuildConfig.printableVersionString())
                                .arg(update_log_path);
@@ -1679,8 +1670,7 @@ QString Application::getJarPath(QString jarFile)
 #if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
         FS::PathCombine(m_rootPath, "share", BuildConfig.LAUNCHER_NAME),
 #endif
-        FS::PathCombine(m_rootPath, "jars"),
+        FS::PathCombine(m_rootPath, "jars"), FS::PathCombine(applicationDirPath(), "jars"),
-        FS::PathCombine(applicationDirPath(), "jars"),
         FS::PathCombine(applicationDirPath(), "..", "jars")  // from inside build dir, for debuging
     };
     for (QString p : potentialPaths) {

launcher/BaseInstance.cpp

@@ -269,13 +269,18 @@ void BaseInstance::setRunning(bool running)
 
     m_isRunning = running;
 
-    if (!m_settings->get("RecordGameTime").toBool()) {
     emit runningStatusChanged(running);
+}
+
+void BaseInstance::setMinecraftRunning(bool running)
+{
+    if (!settings()->get("RecordGameTime").toBool()) {
         return;
     }
 
     if (running) {
         m_timeStarted = QDateTime::currentDateTime();
+        setLastLaunch(m_timeStarted.toMSecsSinceEpoch());
     } else {
         QDateTime timeEnded = QDateTime::currentDateTime();
 
@@ -285,8 +290,6 @@ void BaseInstance::setRunning(bool running)
 
         emit propertiesChanged(this);
     }
-
-    emit runningStatusChanged(running);
 }
 
 int64_t BaseInstance::totalTimePlayed() const

launcher/BaseInstance.h

@@ -104,6 +104,7 @@ class BaseInstance : public QObject, public std::enable_shared_from_this<BaseIns
     /// be unique.
     virtual QString id() const;
 
+    void setMinecraftRunning(bool running);
     void setRunning(bool running);
     bool isRunning() const;
     int64_t totalTimePlayed() const;

launcher/CMakeLists.txt

@@ -165,6 +165,8 @@ set(LAUNCH_SOURCES
     launch/steps/Update.h
     launch/steps/QuitAfterGameStop.cpp
     launch/steps/QuitAfterGameStop.h
+    launch/steps/PrintServers.cpp
+    launch/steps/PrintServers.h
     launch/LaunchStep.cpp
     launch/LaunchStep.h
     launch/LaunchTask.cpp

launcher/FileSystem.cpp

@@ -818,20 +818,11 @@ QString NormalizePath(QString path)
     }
 }
 
-QString removeDuplicates(QString a)
+static const QString BAD_WIN_CHARS = "<>:\"|?*\r\n";
-{
-    auto b = a.split("");
-    b.removeDuplicates();
-    return b.join("");
-}
-
-static const QString BAD_WIN_CHARS = "\"?<>:*|\r\n";
-
-static const QString BAD_FAT_CHARS = "<>:\"|?*+.,;=[]!";
 static const QString BAD_NTFS_CHARS = "<>:\"|?*";
 static const QString BAD_HFS_CHARS = ":";
 
-static const QString BAD_FILENAME_CHARS = removeDuplicates(BAD_WIN_CHARS + BAD_FAT_CHARS + BAD_NTFS_CHARS + BAD_HFS_CHARS) + "\\/";
+static const QString BAD_FILENAME_CHARS = BAD_WIN_CHARS + "\\/";
 
 QString RemoveInvalidFilenameChars(QString string, QChar replaceWith)
 {
@@ -850,9 +841,8 @@ QString RemoveInvalidPathChars(QString path, QChar replaceWith)
 
     // the null character is ignored in this check as it was not a problem until now
     switch (statFS(path).fsType) {
-        case FilesystemType::FAT:
+        case FilesystemType::FAT:  // similar to NTFS
-            invalidChars += BAD_FAT_CHARS;
+        /* fallthrough */
-            break;
         case FilesystemType::NTFS:
         /* fallthrough */
         case FilesystemType::REFS:  // similar to NTFS(should be available only on windows)

launcher/LaunchController.cpp

@@ -36,6 +36,7 @@
 
 #include "LaunchController.h"
 #include "Application.h"
+#include "launch/steps/PrintServers.h"
 #include "minecraft/auth/AccountData.h"
 #include "minecraft/auth/AccountList.h"
 
@@ -193,7 +194,8 @@ void LaunchController::login()
     bool tryagain = true;
     unsigned int tries = 0;
 
-    if (m_accountToUse->accountType() != AccountType::Offline && m_accountToUse->accountState() == AccountState::Offline) {
+    if ((m_accountToUse->accountType() != AccountType::Offline && m_accountToUse->accountState() == AccountState::Offline) ||
+        m_accountToUse->shouldRefresh()) {
         // Force account refresh on the account used to launch the instance updating the AccountState
         //  only on first try and if it is not meant to be offline
         auto accounts = APPLICATION->accounts();
@@ -345,25 +347,8 @@ void LaunchController::launchInstance()
 
         // Prepend Server Status
         QStringList servers = { "login.microsoftonline.com", "session.minecraft.net", "textures.minecraft.net", "api.mojang.com" };
-        QString resolved_servers = "";
-        QHostInfo host_info;
 
-        for (QString server : servers) {
+        m_launcher->prependStep(makeShared<PrintServers>(m_launcher.get(), servers));
-            host_info = QHostInfo::fromName(server);
-            resolved_servers = resolved_servers + server + " resolves to:\n    [";
-            if (!host_info.addresses().isEmpty()) {
-                for (QHostAddress address : host_info.addresses()) {
-                    resolved_servers = resolved_servers + address.toString();
-                    if (!host_info.addresses().endsWith(address)) {
-                        resolved_servers = resolved_servers + ", ";
-                    }
-                }
-            } else {
-                resolved_servers = resolved_servers + "N/A";
-            }
-            resolved_servers = resolved_servers + "]\n\n";
-        }
-        m_launcher->prependStep(makeShared<TextPrint>(m_launcher.get(), resolved_servers, MessageLevel::Launcher));
     } else {
         online_mode = m_demo ? "demo" : "offline";
     }

launcher/MMCZip.h

@@ -216,7 +216,7 @@ class ExtractZipTask : public Task {
     {}
     virtual ~ExtractZipTask() = default;
 
-    typedef std::optional<QString> ZipResult;
+    using ZipResult = std::optional<QString>;
 
    protected:
     virtual void executeTask() override;

launcher/java/JavaUtils.cpp

@@ -79,11 +79,9 @@ QProcessEnvironment CleanEnviroment()
 
     QStringList stripped = {
 #if defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined(Q_OS_OPENBSD)
-        "LD_LIBRARY_PATH",
+        "LD_LIBRARY_PATH", "LD_PRELOAD",
-        "LD_PRELOAD",
 #endif
-        "QT_PLUGIN_PATH",
+        "QT_PLUGIN_PATH", "QT_FONTPATH"
-        "QT_FONTPATH"
     };
     for (auto key : rawenv.keys()) {
         auto value = rawenv.value(key);
@@ -377,7 +375,19 @@ QList<QString> JavaUtils::FindJavaPaths()
     auto home = qEnvironmentVariable("HOME");
 
     // javas downloaded by sdkman
-    javas.append(FS::PathCombine(home, ".sdkman/candidates/java"));
+    QDir sdkmanDir(FS::PathCombine(home, ".sdkman/candidates/java"));
+    QStringList sdkmanJavas = sdkmanDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
+    foreach (const QString& java, sdkmanJavas) {
+        javas.append(sdkmanDir.absolutePath() + "/" + java + "/bin/java");
+    }
+
+    // java in user library folder (like from intellij downloads)
+    QDir userLibraryJVMDir(FS::PathCombine(home, "Library/Java/JavaVirtualMachines/"));
+    QStringList userLibraryJVMJavas = userLibraryJVMDir.entryList(QDir::Dirs | QDir::NoDotAndDotDot);
+    foreach (const QString& java, userLibraryJVMJavas) {
+        javas.append(userLibraryJVMDir.absolutePath() + "/" + java + "/Contents/Home/bin/java");
+        javas.append(userLibraryJVMDir.absolutePath() + "/" + java + "/Contents/Commands/java");
+    }
 
     javas.append(getMinecraftJavaBundle());
     javas.append(getPrismJavaBundle());
@@ -417,6 +427,10 @@ QList<QString> JavaUtils::FindJavaPaths()
     scanJavaDirs("/usr/lib/jvm");
     scanJavaDirs("/usr/lib64/jvm");
     scanJavaDirs("/usr/lib32/jvm");
+    // Gentoo's locations for openjdk and openjdk-bin respectively
+    scanJavaDir("/usr/lib64");
+    scanJavaDir("/usr/lib");
+    scanJavaDir("/opt");
     // javas stored in Prism Launcher's folder
     scanJavaDirs("java");
     // manually installed JDKs in /opt

launcher/launch/steps/PrintServers.cpp

@@ -0,0 +1,65 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2024 Leia uwu <leia@tutamail.com>
+ *
+ *  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/>.
+ */
+
+#include "PrintServers.h"
+#include "QHostInfo"
+
+PrintServers::PrintServers(LaunchTask* parent, const QStringList& servers) : LaunchStep(parent)
+{
+    m_servers = servers;
+}
+
+void PrintServers::executeTask()
+{
+    for (QString server : m_servers) {
+        QHostInfo::lookupHost(server, this, &PrintServers::resolveServer);
+    }
+}
+
+void PrintServers::resolveServer(const QHostInfo& host_info)
+{
+    QString server = host_info.hostName();
+    QString addresses = server + " resolves to:\n    [";
+
+    if (!host_info.addresses().isEmpty()) {
+        for (QHostAddress address : host_info.addresses()) {
+            addresses += address.toString();
+            if (!host_info.addresses().endsWith(address)) {
+                addresses += ", ";
+            }
+        }
+    } else {
+        addresses += "N/A";
+    }
+    addresses += "]\n\n";
+
+    m_server_to_address.insert(server, addresses);
+
+    // print server info in order once all servers are resolved
+    if (m_server_to_address.size() >= m_servers.size()) {
+        for (QString serv : m_servers) {
+            emit logLine(m_server_to_address.value(serv), MessageLevel::Launcher);
+        }
+        emitSucceeded();
+    }
+}
+
+bool PrintServers::canAbort() const
+{
+    return true;
+}

launcher/launch/steps/PrintServers.h

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  Prism Launcher - Minecraft Launcher
+ *  Copyright (c) 2024 Leia uwu <leia@tutamail.com>
+ *
+ *  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/>.
+ */
+#pragma once
+
+#include <LoggedProcess.h>
+#include <java/JavaChecker.h>
+#include <launch/LaunchStep.h>
+#include <QHostInfo>
+
+class PrintServers : public LaunchStep {
+    Q_OBJECT
+   public:
+    PrintServers(LaunchTask* parent, const QStringList& servers);
+
+    virtual void executeTask();
+    virtual bool canAbort() const;
+
+   private:
+    void resolveServer(const QHostInfo& host_info);
+    QMap<QString, QString> m_server_to_address;
+    QStringList m_servers;
+};

launcher/minecraft/launch/LauncherPartLaunch.cpp

@@ -178,6 +178,7 @@ void LauncherPartLaunch::on_state(LoggedProcess::State state)
                 APPLICATION->showMainWindow();
 
             m_parent->setPid(-1);
+            m_parent->instance()->setMinecraftRunning(false);
             // if the exit code wasn't 0, report this as a crash
             auto exitCode = m_process.exitCode();
             if (exitCode != 0) {
@@ -193,7 +194,6 @@ void LauncherPartLaunch::on_state(LoggedProcess::State state)
         case LoggedProcess::Running:
             emit logLine(QString("Minecraft process ID: %1\n\n").arg(m_process.processId()), MessageLevel::Launcher);
             m_parent->setPid(m_process.processId());
-            m_parent->instance()->setLastLaunch();
             // send the launch script to the launcher part
             m_process.write(m_launchScript.toUtf8());
 
@@ -213,6 +213,7 @@ void LauncherPartLaunch::setWorkingDirectory(const QString& wd)
 void LauncherPartLaunch::proceed()
 {
     if (mayProceed) {
+        m_parent->instance()->setMinecraftRunning(true);
         QString launchString("launch\n");
         m_process.write(launchString.toUtf8());
         mayProceed = false;

launcher/minecraft/mod/DataPack.cpp

@@ -28,15 +28,52 @@
 #include "Version.h"
 
 // Values taken from:
-// https://minecraft.wiki/w/Tutorials/Creating_a_data_pack#%22pack_format%22
+// https://minecraft.wiki/w/Pack_format#List_of_data_pack_formats
-static const QMap<int, std::pair<Version, Version>> s_pack_format_versions = {
+static const QMap<int, std::pair<Version, Version>> s_pack_format_versions = { { 4, { Version("1.13"), Version("1.14.4") } },
-    { 4, { Version("1.13"), Version("1.14.4") } },    { 5, { Version("1.15"), Version("1.16.1") } },
+                                                                               { 5, { Version("1.15"), Version("1.16.1") } },
-    { 6, { Version("1.16.2"), Version("1.16.5") } },  { 7, { Version("1.17"), Version("1.17.1") } },
+                                                                               { 6, { Version("1.16.2"), Version("1.16.5") } },
-    { 8, { Version("1.18"), Version("1.18.1") } },    { 9, { Version("1.18.2"), Version("1.18.2") } },
+                                                                               { 7, { Version("1.17"), Version("1.17.1") } },
-    { 10, { Version("1.19"), Version("1.19.3") } },   { 11, { Version("23w03a"), Version("23w05a") } },
+                                                                               { 8, { Version("1.18"), Version("1.18.1") } },
-    { 12, { Version("1.19.4"), Version("1.19.4") } }, { 13, { Version("23w12a"), Version("23w14a") } },
+                                                                               { 9, { Version("1.18.2"), Version("1.18.2") } },
-    { 14, { Version("23w16a"), Version("23w17a") } }, { 15, { Version("1.20"), Version("1.20") } },
+                                                                               { 10, { Version("1.19"), Version("1.19.3") } },
-};
+                                                                               { 11, { Version("23w03a"), Version("23w05a") } },
+                                                                               { 12, { Version("1.19.4"), Version("1.19.4") } },
+                                                                               { 13, { Version("23w12a"), Version("23w14a") } },
+                                                                               { 14, { Version("23w16a"), Version("23w17a") } },
+                                                                               { 15, { Version("1.20"), Version("1.20.1") } },
+                                                                               { 16, { Version("23w31a"), Version("23w31a") } },
+                                                                               { 17, { Version("23w32a"), Version("23w35a") } },
+                                                                               { 18, { Version("1.20.2"), Version("1.20.2") } },
+                                                                               { 19, { Version("23w40a"), Version("23w40a") } },
+                                                                               { 20, { Version("23w41a"), Version("23w41a") } },
+                                                                               { 21, { Version("23w42a"), Version("23w42a") } },
+                                                                               { 22, { Version("23w43a"), Version("23w43b") } },
+                                                                               { 23, { Version("23w44a"), Version("23w44a") } },
+                                                                               { 24, { Version("23w45a"), Version("23w45a") } },
+                                                                               { 25, { Version("23w46a"), Version("23w46a") } },
+                                                                               { 26, { Version("1.20.3"), Version("1.20.4") } },
+                                                                               { 27, { Version("23w51a"), Version("23w51b") } },
+                                                                               { 28, { Version("24w05a"), Version("24w05b") } },
+                                                                               { 29, { Version("24w04a"), Version("24w04a") } },
+                                                                               { 30, { Version("24w05a"), Version("24w05b") } },
+                                                                               { 31, { Version("24w06a"), Version("24w06a") } },
+                                                                               { 32, { Version("24w07a"), Version("24w07a") } },
+                                                                               { 33, { Version("24w09a"), Version("24w09a") } },
+                                                                               { 34, { Version("24w10a"), Version("24w10a") } },
+                                                                               { 35, { Version("24w11a"), Version("24w11a") } },
+                                                                               { 36, { Version("24w12a"), Version("24w12a") } },
+                                                                               { 37, { Version("24w13a"), Version("24w13a") } },
+                                                                               { 38, { Version("24w14a"), Version("24w14a") } },
+                                                                               { 39, { Version("1.20.5-pre1"), Version("1.20.5-pre1") } },
+                                                                               { 40, { Version("1.20.5-pre2"), Version("1.20.5-pre2") } },
+                                                                               { 41, { Version("1.20.5"), Version("1.20.6") } },
+                                                                               { 42, { Version("24w18a"), Version("24w18a") } },
+                                                                               { 43, { Version("24w19a"), Version("24w19b") } },
+                                                                               { 44, { Version("24w20a"), Version("24w20a") } },
+                                                                               { 45, { Version("21w21a"), Version("21w21b") } },
+                                                                               { 46, { Version("1.21-pre1"), Version("1.21-pre1") } },
+                                                                               { 47, { Version("1.21-pre2"), Version("1.21-pre2") } },
+                                                                               { 48, { Version("1.21"), Version("1.21") } } };
 
 void DataPack::setPackFormat(int new_format_id)
 {

launcher/minecraft/mod/Mod.cpp

@@ -50,8 +50,6 @@
 #include "minecraft/mod/tasks/LocalModParseTask.h"
 #include "modplatform/ModIndex.h"
 
-static ModPlatform::ProviderCapabilities ProviderCaps;
-
 Mod::Mod(const QFileInfo& file) : Resource(file), m_local_details()
 {
     m_enabled = (file.suffix() != "disabled");
@@ -250,7 +248,7 @@ void Mod::finishResolvingWithDetails(ModDetails&& details)
 auto Mod::provider() const -> std::optional<QString>
 {
     if (metadata())
-        return ProviderCaps.readableName(metadata()->provider);
+        return ModPlatform::ProviderCapabilities::readableName(metadata()->provider);
     return {};
 }
 

launcher/minecraft/mod/ModFolderModel.cpp

@@ -65,9 +65,9 @@ ModFolderModel::ModFolderModel(const QString& dir, BaseInstance* instance, bool
     : ResourceFolderModel(QDir(dir), instance, nullptr, create_dir), m_is_indexed(is_indexed)
 {
     m_column_names = QStringList({ "Enable", "Image", "Name", "Version", "Last Modified", "Provider", "Size", "Side", "Loaders",
-                                   "Miecraft Versions", "Release Type" });
+                                   "Minecraft Versions", "Release Type" });
     m_column_names_translated = QStringList({ tr("Enable"), tr("Image"), tr("Name"), tr("Version"), tr("Last Modified"), tr("Provider"),
-                                              tr("Size"), tr("Side"), tr("Loaders"), tr("Miecraft Versions"), tr("Release Type") });
+                                              tr("Size"), tr("Side"), tr("Loaders"), tr("Minecraft Versions"), tr("Release Type") });
     m_column_sort_keys = { SortType::ENABLED, SortType::NAME,        SortType::NAME,        SortType::VERSION,
                            SortType::DATE,    SortType::PROVIDER,    SortType::SIZE,        SortType::SIDE,
                            SortType::LOADERS, SortType::MC_VERSIONS, SortType::RELEASE_TYPE };

launcher/minecraft/mod/ResourceFolderModel.cpp

@@ -282,8 +282,7 @@ void ResourceFolderModel::resolveResource(Resource* res)
 
     connect(
         task.get(), &Task::succeeded, this, [=] { onParseSucceeded(ticket, res->internal_id()); }, Qt::ConnectionType::QueuedConnection);
-    connect(
+    connect(task.get(), &Task::failed, this, [=] { onParseFailed(ticket, res->internal_id()); }, Qt::ConnectionType::QueuedConnection);
-        task.get(), &Task::failed, this, [=] { onParseFailed(ticket, res->internal_id()); }, Qt::ConnectionType::QueuedConnection);
     connect(
         task.get(), &Task::finished, this,
         [=] {

launcher/minecraft/mod/ResourcePack.cpp

@@ -11,7 +11,7 @@
 #include "minecraft/mod/tasks/LocalResourcePackParseTask.h"
 
 // Values taken from:
-// https://minecraft.wiki/w/Tutorials/Creating_a_resource_pack#Formatting_pack.mcmeta
+// https://minecraft.wiki/w/Pack_format#List_of_resource_pack_formats
 static const QMap<int, std::pair<Version, Version>> s_pack_format_versions = {
     { 1, { Version("1.6.1"), Version("1.8.9") } },         { 2, { Version("1.9"), Version("1.10.2") } },
     { 3, { Version("1.11"), Version("1.12.2") } },         { 4, { Version("1.13"), Version("1.14.4") } },
@@ -19,7 +19,16 @@ static const QMap<int, std::pair<Version, Version>> s_pack_format_versions = {
     { 7, { Version("1.17"), Version("1.17.1") } },         { 8, { Version("1.18"), Version("1.18.2") } },
     { 9, { Version("1.19"), Version("1.19.2") } },         { 11, { Version("22w42a"), Version("22w44a") } },
     { 12, { Version("1.19.3"), Version("1.19.3") } },      { 13, { Version("1.19.4"), Version("1.19.4") } },
-    { 14, { Version("1.20"), Version("1.20") } }
+    { 14, { Version("23w14a"), Version("23w16a") } },      { 15, { Version("1.20"), Version("1.20.1") } },
+    { 16, { Version("23w31a"), Version("23w31a") } },      { 17, { Version("23w32a"), Version("23w35a") } },
+    { 18, { Version("1.20.2"), Version("23w16a") } },      { 19, { Version("23w42a"), Version("23w42a") } },
+    { 20, { Version("23w43a"), Version("23w44a") } },      { 21, { Version("23w45a"), Version("23w46a") } },
+    { 22, { Version("1.20.3-pre1"), Version("23w51b") } }, { 24, { Version("24w03a"), Version("24w04a") } },
+    { 25, { Version("24w05a"), Version("24w05b") } },      { 26, { Version("24w06a"), Version("24w07a") } },
+    { 28, { Version("24w09a"), Version("24w10a") } },      { 29, { Version("24w11a"), Version("24w11a") } },
+    { 30, { Version("24w12a"), Version("23w12a") } },      { 31, { Version("24w13a"), Version("1.20.5-pre3") } },
+    { 32, { Version("1.20.5-pre4"), Version("1.20.6") } }, { 33, { Version("24w18a"), Version("24w20a") } },
+    { 34, { Version("24w21a"), Version("1.21") } }
 };
 
 void ResourcePack::setPackFormat(int new_format_id)

launcher/minecraft/mod/TexturePackFolderModel.cpp

@@ -37,7 +37,6 @@
 
 #include "Application.h"
 
-#include "StringUtils.h"
 #include "TexturePackFolderModel.h"
 
 #include "minecraft/mod/tasks/BasicFolderLoadTask.h"

launcher/modplatform/EnsureMetadataTask.cpp

@@ -15,8 +15,6 @@
 #include "modplatform/modrinth/ModrinthAPI.h"
 #include "modplatform/modrinth/ModrinthPackIndex.h"
 
-static ModPlatform::ProviderCapabilities ProviderCaps;
-
 static ModrinthAPI modrinth_api;
 static FlameAPI flame_api;
 
@@ -162,10 +160,10 @@ void EnsureMetadataTask::executeTask()
     });
 
     if (m_mods.size() > 1)
-        setStatus(tr("Requesting metadata information from %1...").arg(ProviderCaps.readableName(m_provider)));
+        setStatus(tr("Requesting metadata information from %1...").arg(ModPlatform::ProviderCapabilities::readableName(m_provider)));
     else if (!m_mods.empty())
         setStatus(tr("Requesting metadata information from %1 for '%2'...")
-                      .arg(ProviderCaps.readableName(m_provider), m_mods.begin().value()->name()));
+                      .arg(ModPlatform::ProviderCapabilities::readableName(m_provider), m_mods.begin().value()->name()));
 
     m_current_task = version_task;
     version_task->start();
@@ -215,7 +213,7 @@ void EnsureMetadataTask::emitFail(Mod* m, QString key, RemoveFromList remove)
 
 Task::Ptr EnsureMetadataTask::modrinthVersionsTask()
 {
-    auto hash_type = ProviderCaps.hashType(ModPlatform::ResourceProvider::MODRINTH).first();
+    auto hash_type = ModPlatform::ProviderCapabilities::hashType(ModPlatform::ResourceProvider::MODRINTH).first();
 
     auto response = std::make_shared<QByteArray>();
     auto ver_task = modrinth_api.currentVersions(m_mods.keys(), hash_type, response);

launcher/modplatform/ModIndex.cpp

@@ -59,7 +59,7 @@ IndexedVersionType::VersionType IndexedVersionType::enumFromString(const QString
     return s_indexed_version_type_names.value(type, IndexedVersionType::VersionType::Unknown);
 }
 
-auto ProviderCapabilities::name(ResourceProvider p) -> const char*
+const char* ProviderCapabilities::name(ResourceProvider p)
 {
     switch (p) {
         case ResourceProvider::MODRINTH:
@@ -69,7 +69,8 @@ auto ProviderCapabilities::name(ResourceProvider p) -> const char*
     }
     return {};
 }
-auto ProviderCapabilities::readableName(ResourceProvider p) -> QString
+
+QString ProviderCapabilities::readableName(ResourceProvider p)
 {
     switch (p) {
         case ResourceProvider::MODRINTH:
@@ -79,7 +80,8 @@ auto ProviderCapabilities::readableName(ResourceProvider p) -> QString
     }
     return {};
 }
-auto ProviderCapabilities::hashType(ResourceProvider p) -> QStringList
+
+QStringList ProviderCapabilities::hashType(ResourceProvider p)
 {
     switch (p) {
         case ResourceProvider::MODRINTH:
@@ -91,26 +93,6 @@ auto ProviderCapabilities::hashType(ResourceProvider p) -> QStringList
     return {};
 }
 
-auto ProviderCapabilities::hash(ResourceProvider p, QIODevice* device, QString type) -> QString
-{
-    QCryptographicHash::Algorithm algo = QCryptographicHash::Sha1;
-    switch (p) {
-        case ResourceProvider::MODRINTH:
-            algo = (type == "sha1") ? QCryptographicHash::Sha1 : QCryptographicHash::Sha512;
-            break;
-        case ResourceProvider::FLAME:
-            algo = (type == "sha1") ? QCryptographicHash::Sha1 : QCryptographicHash::Md5;
-            break;
-    }
-
-    QCryptographicHash hash(algo);
-    if (!hash.addData(device))
-        qCritical() << "Failed to read JAR to create hash!";
-
-    Q_ASSERT(hash.result().length() == hash.hashLength(algo));
-    return { hash.result().toHex() };
-}
-
 QString getMetaURL(ResourceProvider provider, QVariant projectID)
 {
     return ((provider == ModPlatform::ResourceProvider::FLAME) ? "https://www.curseforge.com/projects/" : "https://modrinth.com/mod/") +

launcher/modplatform/ModIndex.h

@@ -40,13 +40,11 @@ enum class ResourceType { MOD, RESOURCE_PACK, SHADER_PACK };
 
 enum class DependencyType { REQUIRED, OPTIONAL, INCOMPATIBLE, EMBEDDED, TOOL, INCLUDE, UNKNOWN };
 
-class ProviderCapabilities {
+namespace ProviderCapabilities {
-   public:
+const char* name(ResourceProvider);
-    auto name(ResourceProvider) -> const char*;
+QString readableName(ResourceProvider);
-    auto readableName(ResourceProvider) -> QString;
+QStringList hashType(ResourceProvider);
-    auto hashType(ResourceProvider) -> QStringList;
+};  // namespace ProviderCapabilities
-    auto hash(ResourceProvider, QIODevice*, QString type = "") -> QString;
-};
 
 struct ModpackAuthor {
     QString name;

launcher/modplatform/flame/FlameModIndex.cpp

@@ -7,7 +7,6 @@
 #include "modplatform/flame/FlameAPI.h"
 
 static FlameAPI api;
-static ModPlatform::ProviderCapabilities ProviderCaps;
 
 void FlameMod::loadIndexedPack(ModPlatform::IndexedPack& pack, QJsonObject& obj)
 {
@@ -21,6 +20,9 @@ void FlameMod::loadIndexedPack(ModPlatform::IndexedPack& pack, QJsonObject& obj)
     QJsonObject logo = Json::ensureObject(obj, "logo");
     pack.logoName = Json::ensureString(logo, "title");
     pack.logoUrl = Json::ensureString(logo, "thumbnailUrl");
+    if (pack.logoUrl.isEmpty()) {
+        pack.logoUrl = Json::ensureString(logo, "url");
+    }
 
     auto authors = Json::ensureArray(obj, "authors");
     for (auto authorIter : authors) {
@@ -161,7 +163,7 @@ auto FlameMod::loadIndexedPackVersion(QJsonObject& obj, bool load_changelog) ->
     auto hash_list = Json::ensureArray(obj, "hashes");
     for (auto h : hash_list) {
         auto hash_entry = Json::ensureObject(h);
-        auto hash_types = ProviderCaps.hashType(ModPlatform::ResourceProvider::FLAME);
+        auto hash_types = ModPlatform::ProviderCapabilities::hashType(ModPlatform::ResourceProvider::FLAME);
         auto hash_algo = enumToString(Json::ensureInteger(hash_entry, "algo", 1, "algorithm"));
         if (hash_types.contains(hash_algo)) {
             file.hash = Json::requireString(hash_entry, "value");

launcher/modplatform/flame/FlamePackExportTask.cpp

@@ -116,7 +116,7 @@ void FlamePackExportTask::collectHashes()
 
         if (relative.startsWith("resourcepacks/") &&
             (relative.endsWith(".zip") || relative.endsWith(".zip.disabled"))) {  // is resourcepack
-            auto hashTask = Hashing::createFlameHasher(file.absoluteFilePath());
+            auto hashTask = Hashing::createHasher(file.absoluteFilePath(), ModPlatform::ResourceProvider::FLAME);
             connect(hashTask.get(), &Hashing::Hasher::resultsReady, [this, relative, file](QString hash) {
                 if (m_state == Task::State::Running) {
                     pendingHashes.insert(hash, { relative, file.absoluteFilePath(), relative.endsWith(".zip") });
@@ -140,7 +140,7 @@ void FlamePackExportTask::collectHashes()
                 continue;
             }
 
-            auto hashTask = Hashing::createFlameHasher(mod->fileinfo().absoluteFilePath());
+            auto hashTask = Hashing::createHasher(mod->fileinfo().absoluteFilePath(), ModPlatform::ResourceProvider::FLAME);
             connect(hashTask.get(), &Hashing::Hasher::resultsReady, [this, mod](QString hash) {
                 if (m_state == Task::State::Running) {
                     pendingHashes.insert(hash, { mod->name(), mod->fileinfo().absoluteFilePath(), mod->enabled(), true });

launcher/modplatform/helpers/HashUtils.cpp

@@ -1,24 +1,22 @@
 #include "HashUtils.h"
 
+#include <QBuffer>
 #include <QDebug>
 #include <QFile>
-
+#include <QtConcurrentRun>
-#include "FileSystem.h"
-#include "StringUtils.h"
 
 #include <MurmurHash2.h>
 
 namespace Hashing {
 
-static ModPlatform::ProviderCapabilities ProviderCaps;
-
 Hasher::Ptr createHasher(QString file_path, ModPlatform::ResourceProvider provider)
 {
     switch (provider) {
         case ModPlatform::ResourceProvider::MODRINTH:
-            return createModrinthHasher(file_path);
+            return makeShared<Hasher>(file_path,
+                                      ModPlatform::ProviderCapabilities::hashType(ModPlatform::ResourceProvider::MODRINTH).first());
         case ModPlatform::ResourceProvider::FLAME:
-            return createFlameHasher(file_path);
+            return makeShared<Hasher>(file_path, Algorithm::Murmur2);
         default:
             qCritical() << "[Hashing]"
                         << "Unrecognized mod platform!";
@@ -26,119 +24,142 @@ Hasher::Ptr createHasher(QString file_path, ModPlatform::ResourceProvider provid
     }
 }
 
-Hasher::Ptr createModrinthHasher(QString file_path)
+Hasher::Ptr createHasher(QString file_path, QString type)
 {
-    return makeShared<ModrinthHasher>(file_path);
+    return makeShared<Hasher>(file_path, type);
 }
 
-Hasher::Ptr createFlameHasher(QString file_path)
+class QIODeviceReader : public Murmur2::Reader {
+   public:
+    QIODeviceReader(QIODevice* device) : m_device(device) {}
+    virtual ~QIODeviceReader() = default;
+    virtual int read(char* s, int n) { return m_device->read(s, n); }
+    virtual bool eof() { return m_device->atEnd(); }
+    virtual void goToBeginning() { m_device->seek(0); }
+    virtual void close() { m_device->close(); }
+
+   private:
+    QIODevice* m_device;
+};
+
+QString algorithmToString(Algorithm type)
 {
-    return makeShared<FlameHasher>(file_path);
+    switch (type) {
+        case Algorithm::Md4:
+            return "md4";
+        case Algorithm::Md5:
+            return "md5";
+        case Algorithm::Sha1:
+            return "sha1";
+        case Algorithm::Sha256:
+            return "sha256";
+        case Algorithm::Sha512:
+            return "sha512";
+        case Algorithm::Murmur2:
+            return "murmur2";
+        // case Algorithm::Unknown:
+        default:
+            break;
+    }
+    return "unknown";
 }
 
-Hasher::Ptr createBlockedModHasher(QString file_path, ModPlatform::ResourceProvider provider)
+Algorithm algorithmFromString(QString type)
 {
-    return makeShared<BlockedModHasher>(file_path, provider);
+    if (type == "md4")
+        return Algorithm::Md4;
+    if (type == "md5")
+        return Algorithm::Md5;
+    if (type == "sha1")
+        return Algorithm::Sha1;
+    if (type == "sha256")
+        return Algorithm::Sha256;
+    if (type == "sha512")
+        return Algorithm::Sha512;
+    if (type == "murmur2")
+        return Algorithm::Murmur2;
+    return Algorithm::Unknown;
 }
 
-Hasher::Ptr createBlockedModHasher(QString file_path, ModPlatform::ResourceProvider provider, QString type)
+QString hash(QIODevice* device, Algorithm type)
 {
-    auto hasher = makeShared<BlockedModHasher>(file_path, provider);
+    if (!device->isOpen() && !device->open(QFile::ReadOnly))
-    hasher->useHashType(type);
+        return "";
-    return hasher;
+    QCryptographicHash::Algorithm alg = QCryptographicHash::Sha1;
-}
+    switch (type) {
-
+        case Algorithm::Md4:
-void ModrinthHasher::executeTask()
+            alg = QCryptographicHash::Algorithm::Md4;
-{
+            break;
-    QFile file(m_path);
+        case Algorithm::Md5:
-
+            alg = QCryptographicHash::Algorithm::Md5;
-    try {
+            break;
-        file.open(QFile::ReadOnly);
+        case Algorithm::Sha1:
-    } catch (FS::FileSystemException& e) {
+            alg = QCryptographicHash::Algorithm::Sha1;
-        qCritical() << QString("Failed to open JAR file in %1").arg(m_path);
+            break;
-        qCritical() << QString("Reason: ") << e.cause();
+        case Algorithm::Sha256:
-
+            alg = QCryptographicHash::Algorithm::Sha256;
-        emitFailed("Failed to open file for hashing.");
+            break;
-        return;
+        case Algorithm::Sha512:
-    }
+            alg = QCryptographicHash::Algorithm::Sha512;
-
+            break;
-    auto hash_type = ProviderCaps.hashType(ModPlatform::ResourceProvider::MODRINTH).first();
+        case Algorithm::Murmur2: {  // CF-specific
-    m_hash = ProviderCaps.hash(ModPlatform::ResourceProvider::MODRINTH, &file, hash_type);
-
-    file.close();
-
-    if (m_hash.isEmpty()) {
-        emitFailed("Empty hash!");
-    } else {
-        emitSucceeded();
-        emit resultsReady(m_hash);
-    }
-}
-
-void FlameHasher::executeTask()
-{
-    // CF-specific
             auto should_filter_out = [](char c) { return (c == 9 || c == 10 || c == 13 || c == 32); };
+            auto reader = std::make_unique<QIODeviceReader>(device);
+            auto result = QString::number(Murmur2::hash(reader.get(), 4 * MiB, should_filter_out));
+            device->close();
+            return result;
+        }
+        case Algorithm::Unknown:
+            device->close();
+            return "";
+    }
 
-    std::ifstream file_stream(StringUtils::toStdString(m_path).c_str(), std::ifstream::binary);
+    QCryptographicHash hash(alg);
-    // TODO: This is very heavy work, but apparently QtConcurrent can't use move semantics, so we can't boop this to another thread.
+    if (!hash.addData(device))
-    // How do we make this non-blocking then?
+        qCritical() << "Failed to read JAR to create hash!";
-    m_hash = QString::number(MurmurHash2(std::move(file_stream), 4 * MiB, should_filter_out));
 
-    if (m_hash.isEmpty()) {
+    Q_ASSERT(hash.result().length() == hash.hashLength(alg));
+    auto result = hash.result().toHex();
+    device->close();
+    return result;
+}
+
+QString hash(QString fileName, Algorithm type)
+{
+    QFile file(fileName);
+    return hash(&file, type);
+}
+
+QString hash(QByteArray data, Algorithm type)
+{
+    QBuffer buff(&data);
+    return hash(&buff, type);
+}
+
+void Hasher::executeTask()
+{
+    m_future = QtConcurrent::run(QThreadPool::globalInstance(), [this]() { return hash(m_path, m_alg); });
+    connect(&m_watcher, &QFutureWatcher<QString>::finished, this, [this] {
+        if (m_future.isCanceled()) {
+            emitAborted();
+        } else if (m_result = m_future.result(); m_result.isEmpty()) {
             emitFailed("Empty hash!");
         } else {
             emitSucceeded();
-        emit resultsReady(m_hash);
+            emit resultsReady(m_result);
         }
+    });
+    m_watcher.setFuture(m_future);
 }
 
-BlockedModHasher::BlockedModHasher(QString file_path, ModPlatform::ResourceProvider provider) : Hasher(file_path), provider(provider)
+bool Hasher::abort()
 {
-    setObjectName(QString("BlockedModHasher: %1").arg(file_path));
+    if (m_future.isRunning()) {
-    hash_type = ProviderCaps.hashType(provider).first();
+        m_future.cancel();
-}
+        // NOTE: Here we don't do `emitAborted()` because it will be done when `m_build_zip_future` actually cancels, which may not
-
+        // occur immediately.
-void BlockedModHasher::executeTask()
-{
-    QFile file(m_path);
-
-    try {
-        file.open(QFile::ReadOnly);
-    } catch (FS::FileSystemException& e) {
-        qCritical() << QString("Failed to open JAR file in %1").arg(m_path);
-        qCritical() << QString("Reason: ") << e.cause();
-
-        emitFailed("Failed to open file for hashing.");
-        return;
-    }
-
-    m_hash = ProviderCaps.hash(provider, &file, hash_type);
-
-    file.close();
-
-    if (m_hash.isEmpty()) {
-        emitFailed("Empty hash!");
-    } else {
-        emitSucceeded();
-        emit resultsReady(m_hash);
-    }
-}
-
-QStringList BlockedModHasher::getHashTypes()
-{
-    return ProviderCaps.hashType(provider);
-}
-
-bool BlockedModHasher::useHashType(QString type)
-{
-    auto types = ProviderCaps.hashType(provider);
-    if (types.contains(type)) {
-        hash_type = type;
         return true;
     }
-    qDebug() << "Bad hash type " << type << " for provider";
     return false;
 }
-
 }  // namespace Hashing

launcher/modplatform/helpers/HashUtils.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <QCryptographicHash>
+#include <QFuture>
+#include <QFutureWatcher>
 #include <QString>
 
 #include "modplatform/ModIndex.h"
@@ -7,61 +10,42 @@
 
 namespace Hashing {
 
+enum class Algorithm { Md4, Md5, Sha1, Sha256, Sha512, Murmur2, Unknown };
+
+QString algorithmToString(Algorithm type);
+Algorithm algorithmFromString(QString type);
+QString hash(QIODevice* device, Algorithm type);
+QString hash(QString fileName, Algorithm type);
+QString hash(QByteArray data, Algorithm type);
+
 class Hasher : public Task {
     Q_OBJECT
    public:
     using Ptr = shared_qobject_ptr<Hasher>;
 
-    Hasher(QString file_path) : m_path(std::move(file_path)) {}
+    Hasher(QString file_path, Algorithm alg) : m_path(file_path), m_alg(alg) {}
+    Hasher(QString file_path, QString alg) : Hasher(file_path, algorithmFromString(alg)) {}
 
-    /* We can't really abort this task, but we can say we aborted and finish our thing quickly :) */
+    bool abort() override;
-    bool abort() override { return true; }
 
-    void executeTask() override = 0;
+    void executeTask() override;
 
-    QString getResult() const { return m_hash; };
+    QString getResult() const { return m_result; };
     QString getPath() const { return m_path; };
 
    signals:
     void resultsReady(QString hash);
 
-   protected:
-    QString m_hash;
-    QString m_path;
-};
-
-class FlameHasher : public Hasher {
-   public:
-    FlameHasher(QString file_path) : Hasher(file_path) { setObjectName(QString("FlameHasher: %1").arg(file_path)); }
-
-    void executeTask() override;
-};
-
-class ModrinthHasher : public Hasher {
-   public:
-    ModrinthHasher(QString file_path) : Hasher(file_path) { setObjectName(QString("ModrinthHasher: %1").arg(file_path)); }
-
-    void executeTask() override;
-};
-
-class BlockedModHasher : public Hasher {
-   public:
-    BlockedModHasher(QString file_path, ModPlatform::ResourceProvider provider);
-
-    void executeTask() override;
-
-    QStringList getHashTypes();
-    bool useHashType(QString type);
-
    private:
-    ModPlatform::ResourceProvider provider;
+    QString m_result;
-    QString hash_type;
+    QString m_path;
+    Algorithm m_alg;
+
+    QFuture<QString> m_future;
+    QFutureWatcher<QString> m_watcher;
 };
 
 Hasher::Ptr createHasher(QString file_path, ModPlatform::ResourceProvider provider);
-Hasher::Ptr createFlameHasher(QString file_path);
+Hasher::Ptr createHasher(QString file_path, QString type);
-Hasher::Ptr createModrinthHasher(QString file_path);
-Hasher::Ptr createBlockedModHasher(QString file_path, ModPlatform::ResourceProvider provider);
-Hasher::Ptr createBlockedModHasher(QString file_path, ModPlatform::ResourceProvider provider, QString type);
 
 }  // namespace Hashing

launcher/modplatform/modrinth/ModrinthCheckUpdate.cpp

@@ -13,7 +13,6 @@
 #include "minecraft/mod/ModFolderModel.h"
 
 static ModrinthAPI api;
-static ModPlatform::ProviderCapabilities ProviderCaps;
 
 bool ModrinthCheckUpdate::abort()
 {
@@ -36,7 +35,7 @@ void ModrinthCheckUpdate::executeTask()
 
     // Create all hashes
     QStringList hashes;
-    auto best_hash_type = ProviderCaps.hashType(ModPlatform::ResourceProvider::MODRINTH).first();
+    auto best_hash_type = ModPlatform::ProviderCapabilities::hashType(ModPlatform::ResourceProvider::MODRINTH).first();
 
     ConcurrentTask hashing_task(this, "MakeModrinthHashesTask", APPLICATION->settings()->get("NumberOfConcurrentTasks").toInt());
     for (auto* mod : m_mods) {
@@ -51,7 +50,7 @@ void ModrinthCheckUpdate::executeTask()
         // need to generate a new hash if the current one is innadequate
         // (though it will rarely happen, if at all)
         if (mod->metadata()->hash_format != best_hash_type) {
-            auto hash_task = Hashing::createModrinthHasher(mod->fileinfo().absoluteFilePath());
+            auto hash_task = Hashing::createHasher(mod->fileinfo().absoluteFilePath(), ModPlatform::ResourceProvider::MODRINTH);
             connect(hash_task.get(), &Hashing::Hasher::resultsReady, [&hashes, &mappings, mod](QString hash) {
                 hashes.append(hash);
                 mappings.insert(hash, mod);

launcher/modplatform/modrinth/ModrinthPackExportTask.cpp

@@ -27,6 +27,7 @@
 #include "minecraft/PackProfile.h"
 #include "minecraft/mod/MetadataHandler.h"
 #include "minecraft/mod/ModFolderModel.h"
+#include "modplatform/helpers/HashUtils.h"
 
 const QStringList ModrinthPackExportTask::PREFIXES({ "mods/", "coremods/", "resourcepacks/", "texturepacks/", "shaderpacks/" });
 const QStringList ModrinthPackExportTask::FILE_EXTENSIONS({ "jar", "litemod", "zip" });
@@ -102,8 +103,6 @@ void ModrinthPackExportTask::collectHashes()
             }))
             continue;
 
-        QCryptographicHash sha512(QCryptographicHash::Algorithm::Sha512);
-
         QFile openFile(file.absoluteFilePath());
         if (!openFile.open(QFile::ReadOnly)) {
             qWarning() << "Could not open" << file << "for hashing";
@@ -115,7 +114,7 @@ void ModrinthPackExportTask::collectHashes()
             qWarning() << "Could not read" << file;
             continue;
         }
-        sha512.addData(data);
+        auto sha512 = Hashing::hash(data, Hashing::Algorithm::Sha512);
 
         auto allMods = mcInstance->loaderModList()->allMods();
         if (auto modIter = std::find_if(allMods.begin(), allMods.end(), [&file](Mod* mod) { return mod->fileinfo() == file; });
@@ -127,11 +126,9 @@ void ModrinthPackExportTask::collectHashes()
                 if (!url.isEmpty() && BuildConfig.MODRINTH_MRPACK_HOSTS.contains(url.host())) {
                     qDebug() << "Resolving" << relative << "from index";
 
-                    QCryptographicHash sha1(QCryptographicHash::Algorithm::Sha1);
+                    auto sha1 = Hashing::hash(data, Hashing::Algorithm::Sha1);
-                    sha1.addData(data);
 
-                    ResolvedFile resolvedFile{ sha1.result().toHex(), sha512.result().toHex(), url.toEncoded(), openFile.size(),
+                    ResolvedFile resolvedFile{ sha1, sha512, url.toEncoded(), openFile.size(), mod->metadata()->side };
-                                               mod->metadata()->side };
                     resolvedFiles[relative] = resolvedFile;
 
                     // nice! we've managed to resolve based on local metadata!
@@ -142,7 +139,7 @@ void ModrinthPackExportTask::collectHashes()
         }
 
         qDebug() << "Enqueueing" << relative << "for Modrinth query";
-        pendingHashes[relative] = sha512.result().toHex();
+        pendingHashes[relative] = sha512;
     }
 
     setAbortable(true);

launcher/modplatform/modrinth/ModrinthPackIndex.cpp

@@ -27,7 +27,6 @@
 #include "modplatform/ModIndex.h"
 
 static ModrinthAPI api;
-static ModPlatform::ProviderCapabilities ProviderCaps;
 
 bool shouldDownloadOnSide(QString side)
 {
@@ -132,8 +131,9 @@ void Modrinth::loadIndexedPackVersions(ModPlatform::IndexedPack& pack, QJsonArra
     pack.versionsLoaded = true;
 }
 
-auto Modrinth::loadIndexedPackVersion(QJsonObject& obj, QString preferred_hash_type, QString preferred_file_name)
+auto Modrinth::loadIndexedPackVersion(QJsonObject& obj,
-    -> ModPlatform::IndexedVersion
+                                      QString preferred_hash_type,
+                                      QString preferred_file_name) -> ModPlatform::IndexedVersion
 {
     ModPlatform::IndexedVersion file;
 
@@ -231,7 +231,7 @@ auto Modrinth::loadIndexedPackVersion(QJsonObject& obj, QString preferred_hash_t
             file.hash = Json::requireString(hash_list, preferred_hash_type);
             file.hash_type = preferred_hash_type;
         } else {
-            auto hash_types = ProviderCaps.hashType(ModPlatform::ResourceProvider::MODRINTH);
+            auto hash_types = ModPlatform::ProviderCapabilities::hashType(ModPlatform::ResourceProvider::MODRINTH);
             for (auto& hash_type : hash_types) {
                 if (hash_list.contains(hash_type)) {
                     file.hash = Json::requireString(hash_list, hash_type);
@@ -247,8 +247,9 @@ auto Modrinth::loadIndexedPackVersion(QJsonObject& obj, QString preferred_hash_t
     return {};
 }
 
-auto Modrinth::loadDependencyVersions([[maybe_unused]] const ModPlatform::Dependency& m, QJsonArray& arr, const BaseInstance* inst)
+auto Modrinth::loadDependencyVersions([[maybe_unused]] const ModPlatform::Dependency& m,
-    -> ModPlatform::IndexedVersion
+                                      QJsonArray& arr,
+                                      const BaseInstance* inst) -> ModPlatform::IndexedVersion
 {
     auto profile = (dynamic_cast<const MinecraftInstance*>(inst))->getPackProfile();
     QString mcVersion = profile->getComponentVersion("net.minecraft");

launcher/modplatform/packwiz/Packwiz.cpp

@@ -67,8 +67,6 @@ static inline auto indexFileName(QString const& mod_slug) -> QString
     return QString("%1.pw.toml").arg(mod_slug);
 }
 
-static ModPlatform::ProviderCapabilities ProviderCaps;
-
 // Helper functions for extracting data from the TOML file
 auto stringEntry(toml::table table, QString entry_name) -> QString
 {
@@ -92,8 +90,9 @@ auto intEntry(toml::table table, QString entry_name) -> int
     return node.value_or(0);
 }
 
-auto V1::createModFormat([[maybe_unused]] QDir& index_dir, ModPlatform::IndexedPack& mod_pack, ModPlatform::IndexedVersion& mod_version)
+auto V1::createModFormat([[maybe_unused]] QDir& index_dir,
-    -> Mod
+                         ModPlatform::IndexedPack& mod_pack,
+                         ModPlatform::IndexedVersion& mod_version) -> Mod
 {
     Mod mod;
 
@@ -219,7 +218,7 @@ void V1::updateModIndex(QDir& index_dir, Mod& mod)
                                       { "hash-format", mod.hash_format.toStdString() },
                                       { "hash", mod.hash.toStdString() },
                                   } },
-                                { "update", toml::table{ { ProviderCaps.name(mod.provider), update } } } };
+                                { "update", toml::table{ { ModPlatform::ProviderCapabilities::name(mod.provider), update } } } };
         std::stringstream ss;
         ss << tbl;
         in_stream << QString::fromStdString(ss.str());
@@ -340,11 +339,11 @@ auto V1::getIndexForMod(QDir& index_dir, QString slug) -> Mod
         }
 
         toml::table* mod_provider_table = nullptr;
-        if ((mod_provider_table = update_table[ProviderCaps.name(Provider::FLAME)].as_table())) {
+        if ((mod_provider_table = update_table[ModPlatform::ProviderCapabilities::name(Provider::FLAME)].as_table())) {
             mod.provider = Provider::FLAME;
             mod.file_id = intEntry(*mod_provider_table, "file-id");
             mod.project_id = intEntry(*mod_provider_table, "project-id");
-        } else if ((mod_provider_table = update_table[ProviderCaps.name(Provider::MODRINTH)].as_table())) {
+        } else if ((mod_provider_table = update_table[ModPlatform::ProviderCapabilities::name(Provider::MODRINTH)].as_table())) {
             mod.provider = Provider::MODRINTH;
             mod.mod_id() = stringEntry(*mod_provider_table, "mod-id");
             mod.version() = stringEntry(*mod_provider_table, "version");

launcher/net/HttpMetaCache.cpp

@@ -175,6 +175,8 @@ void HttpMetaCache::evictAll()
             if (!evictEntry(entry))
                 qCWarning(taskHttpMetaCacheLogC) << "Unexpected missing cache entry" << entry->m_basePath;
         }
+        map.entry_list.clear();
+        FS::deletePath(map.base_path);
     }
 }
 

launcher/ui/MainWindow.cpp

@@ -1560,7 +1560,7 @@ void MainWindow::on_actionCreateInstanceShortcut_triggered()
         QFileDialog fileDialog;
         // workaround to make sure the portal file dialog opens in the desktop directory
         fileDialog.setDirectoryUrl(desktopPath);
-        desktopFilePath = fileDialog.getSaveFileName(this, tr("Create Shortcut"), desktopFilePath, tr("Desktop Entries (*.desktop)"));
+        desktopFilePath = fileDialog.getSaveFileName(this, tr("Create Shortcut"), desktopFilePath, tr("Desktop Entries") + " (*.desktop)");
         if (desktopFilePath.isEmpty())
             return;  // file dialog canceled by user
         appPath = "flatpak";

launcher/ui/dialogs/BlockedModsDialog.cpp

@@ -266,7 +266,7 @@ void BlockedModsDialog::addHashTask(QString path)
 /// @param path the path to the local file being hashed
 void BlockedModsDialog::buildHashTask(QString path)
 {
-    auto hash_task = Hashing::createBlockedModHasher(path, ModPlatform::ResourceProvider::FLAME, m_hash_type);
+    auto hash_task = Hashing::createHasher(path, m_hash_type);
 
     qDebug() << "[Blocked Mods Dialog] Creating Hash task for path: " << path;
 

launcher/ui/dialogs/ChooseProviderDialog.cpp

@@ -6,8 +6,6 @@
 
 #include "modplatform/ModIndex.h"
 
-static ModPlatform::ProviderCapabilities ProviderCaps;
-
 ChooseProviderDialog::ChooseProviderDialog(QWidget* parent, bool single_choice, bool allow_skipping)
     : QDialog(parent), ui(new Ui::ChooseProviderDialog)
 {
@@ -78,7 +76,7 @@ void ChooseProviderDialog::addProviders()
     QRadioButton* btn;
 
     for (auto& provider : { ModPlatform::ResourceProvider::MODRINTH, ModPlatform::ResourceProvider::FLAME }) {
-        btn = new QRadioButton(ProviderCaps.readableName(provider), this);
+        btn = new QRadioButton(ModPlatform::ProviderCapabilities::readableName(provider), this);
         m_providers.addButton(btn, btn_index++);
         ui->providersLayout->addWidget(btn);
     }

launcher/ui/dialogs/ExportPackDialog.cpp

@@ -129,14 +129,14 @@ void ExportPackDialog::done(int result)
         QString output;
         if (m_provider == ModPlatform::ResourceProvider::MODRINTH) {
             output = QFileDialog::getSaveFileName(this, tr("Export %1").arg(name), FS::PathCombine(QDir::homePath(), filename + ".mrpack"),
-                                                  "Modrinth pack (*.mrpack *.zip)", nullptr);
+                                                  tr("Modrinth pack") + " (*.mrpack *.zip)", nullptr);
             if (output.isEmpty())
                 return;
             if (!(output.endsWith(".zip") || output.endsWith(".mrpack")))
                 output.append(".mrpack");
         } else {
             output = QFileDialog::getSaveFileName(this, tr("Export %1").arg(name), FS::PathCombine(QDir::homePath(), filename + ".zip"),
-                                                  "CurseForge pack (*.zip)", nullptr);
+                                                  tr("CurseForge pack") + " (*.zip)", nullptr);
             if (output.isEmpty())
                 return;
             if (!output.endsWith(".zip"))

launcher/ui/dialogs/ExportToModListDialog.cpp

@@ -160,7 +160,7 @@ void ExportToModListDialog::done(int result)
         const QString filename = FS::RemoveInvalidFilenameChars(m_name);
         const QString output =
             QFileDialog::getSaveFileName(this, tr("Export %1").arg(m_name), FS::PathCombine(QDir::homePath(), filename + extension()),
-                                         "File (*.txt *.html *.md *.json *.csv)", nullptr);
+                                         tr("File") + " (*.txt *.html *.md *.json *.csv)", nullptr);
 
         if (output.isEmpty())
             return;

launcher/ui/dialogs/ModUpdateDialog.cpp

@@ -25,8 +25,6 @@
 
 #include <optional>
 
-static ModPlatform::ProviderCapabilities ProviderCaps;
-
 static std::list<Version> mcVersions(BaseInstance* inst)
 {
     return { static_cast<MinecraftInstance*>(inst)->getPackProfile()->getComponent("net.minecraft")->getVersion() };
@@ -94,17 +92,15 @@ void ModUpdateDialog::checkCandidates()
 
     if (!m_modrinth_to_update.empty()) {
         m_modrinth_check_task.reset(new ModrinthCheckUpdate(m_modrinth_to_update, versions, loaders, m_mod_model));
-        connect(m_modrinth_check_task.get(), &CheckUpdateTask::checkFailed, this, [this](Mod* mod, QString reason, QUrl recover_url) {
+        connect(m_modrinth_check_task.get(), &CheckUpdateTask::checkFailed, this,
-            m_failed_check_update.append({ mod, reason, recover_url });
+                [this](Mod* mod, QString reason, QUrl recover_url) { m_failed_check_update.append({ mod, reason, recover_url }); });
-        });
         check_task.addTask(m_modrinth_check_task);
     }
 
     if (!m_flame_to_update.empty()) {
         m_flame_check_task.reset(new FlameCheckUpdate(m_flame_to_update, versions, loaders, m_mod_model));
-        connect(m_flame_check_task.get(), &CheckUpdateTask::checkFailed, this, [this](Mod* mod, QString reason, QUrl recover_url) {
+        connect(m_flame_check_task.get(), &CheckUpdateTask::checkFailed, this,
-            m_failed_check_update.append({ mod, reason, recover_url });
+                [this](Mod* mod, QString reason, QUrl recover_url) { m_failed_check_update.append({ mod, reason, recover_url }); });
-        });
         check_task.addTask(m_flame_check_task);
     }
 
@@ -427,7 +423,7 @@ void ModUpdateDialog::appendMod(CheckUpdateTask::UpdatableMod const& info, QStri
     item_top->setExpanded(true);
 
     auto provider_item = new QTreeWidgetItem(item_top);
-    provider_item->setText(0, tr("Provider: %1").arg(ProviderCaps.readableName(info.provider)));
+    provider_item->setText(0, tr("Provider: %1").arg(ModPlatform::ProviderCapabilities::readableName(info.provider)));
 
     auto old_version_item = new QTreeWidgetItem(item_top);
     old_version_item->setText(0, tr("Old version: %1").arg(info.old_version.isEmpty() ? tr("Not installed") : info.old_version));

launcher/ui/dialogs/NewInstanceDialog.cpp

@@ -200,7 +200,7 @@ void NewInstanceDialog::setSuggestedPack(const QString& name, InstanceTask* task
     importVersion.clear();
 
     if (!task) {
-        ui->iconButton->setIcon(APPLICATION->icons()->getIcon("default"));
+        ui->iconButton->setIcon(APPLICATION->icons()->getIcon(InstIconKey));
         importIcon = false;
     }
 
@@ -216,7 +216,7 @@ void NewInstanceDialog::setSuggestedPack(const QString& name, QString version, I
     importVersion = std::move(version);
 
     if (!task) {
-        ui->iconButton->setIcon(APPLICATION->icons()->getIcon("default"));
+        ui->iconButton->setIcon(APPLICATION->icons()->getIcon(InstIconKey));
         importIcon = false;
     }
 
@@ -236,6 +236,9 @@ void NewInstanceDialog::setSuggestedIconFromFile(const QString& path, const QStr
 
 void NewInstanceDialog::setSuggestedIcon(const QString& key)
 {
+    if (key == "default")
+        return;
+
     auto icon = APPLICATION->icons()->getIcon(key);
     importIcon = false;
 

launcher/ui/dialogs/ResourceDownloadDialog.cpp

@@ -92,6 +92,19 @@ void ResourceDownloadDialog::accept()
 
 void ResourceDownloadDialog::reject()
 {
+    auto selected = getTasks();
+    if (selected.count() > 0) {
+        auto reply = CustomMessageBox::selectable(this, tr("Confirmation Needed"),
+                                                  tr("You have %1 selected resources.\n"
+                                                     "Are you sure you want to close this dialog?")
+                                                      .arg(selected.count()),
+                                                  QMessageBox::Question, QMessageBox::Yes | QMessageBox::No, QMessageBox::No)
+                         ->exec();
+        if (reply != QMessageBox::Yes) {
+            return;
+        }
+    }
+
     if (!geometrySaveKey().isEmpty())
         APPLICATION->settings()->set(geometrySaveKey(), saveGeometry().toBase64());
 
@@ -126,8 +139,6 @@ void ResourceDownloadDialog::connectButtons()
     connect(HelpButton, &QPushButton::clicked, m_container, &PageContainer::help);
 }
 
-static ModPlatform::ProviderCapabilities ProviderCaps;
-
 void ResourceDownloadDialog::confirm()
 {
     auto confirm_dialog = ReviewMessageBox::create(this, tr("Confirm %1 to download").arg(resourcesString()));
@@ -169,7 +180,7 @@ void ResourceDownloadDialog::confirm()
     for (auto& task : selected) {
         auto extraInfo = dependencyExtraInfo.value(task->getPack()->addonId.toString());
         confirm_dialog->appendResource({ task->getName(), task->getFilename(), task->getCustomPath(),
-                                         ProviderCaps.name(task->getProvider()), extraInfo.required_by,
+                                         ModPlatform::ProviderCapabilities::name(task->getProvider()), extraInfo.required_by,
                                          task->getVersion().version_type.toString(), !extraInfo.maybe_installed });
     }
 
@@ -358,4 +369,20 @@ QList<BasePage*> ShaderPackDownloadDialog::getPages()
     return pages;
 }
 
+void ModDownloadDialog::setModMetadata(std::shared_ptr<Metadata::ModStruct> meta)
+{
+    switch (meta->provider) {
+        case ModPlatform::ResourceProvider::MODRINTH:
+            selectPage(Modrinth::id());
+            break;
+        case ModPlatform::ResourceProvider::FLAME:
+            selectPage(Flame::id());
+            break;
+    }
+    setWindowTitle(tr("Change %1 version").arg(meta->name));
+    m_container->hidePageList();
+    m_buttons.hide();
+    auto page = selectedPage();
+    page->openProject(meta->project_id);
+}
 }  // namespace ResourceDownload

launcher/ui/dialogs/ResourceDownloadDialog.h

@@ -107,6 +107,8 @@ class ModDownloadDialog final : public ResourceDownloadDialog {
     QList<BasePage*> getPages() override;
     GetModDependenciesTask::Ptr getModDependenciesTask() override;
 
+    void setModMetadata(std::shared_ptr<Metadata::ModStruct>);
+
    private:
     BaseInstance* m_instance;
 };

launcher/ui/dialogs/skins/SkinManageDialog.cpp

@@ -118,7 +118,7 @@ void SkinManageDialog::selectionChanged(QItemSelection selected, QItemSelection
     auto skin = m_list.skin(key);
     if (!skin)
         return;
-    ui->selectedModel->setPixmap(skin->getTexture().scaled(128, 128, Qt::KeepAspectRatio, Qt::FastTransformation));
+    ui->selectedModel->setPixmap(skin->getTexture().scaled(size() * (1. / 3), Qt::KeepAspectRatio, Qt::FastTransformation));
     ui->capeCombo->setCurrentIndex(m_capes_idx.value(skin->getCapeId()));
     ui->steveBtn->setChecked(skin->getModel() == SkinModel::CLASSIC);
     ui->alexBtn->setChecked(skin->getModel() == SkinModel::SLIM);
@@ -212,7 +212,7 @@ void SkinManageDialog::setupCapes()
 void SkinManageDialog::on_capeCombo_currentIndexChanged(int index)
 {
     auto id = ui->capeCombo->currentData();
-    ui->capeImage->setPixmap(m_capes.value(id.toString(), {}));
+    ui->capeImage->setPixmap(m_capes.value(id.toString(), {}).scaled(size() * (1. / 3), Qt::KeepAspectRatio, Qt::FastTransformation));
     if (auto skin = m_list.skin(m_selected_skin); skin) {
         skin->setCapeId(id.toString());
     }
@@ -498,3 +498,15 @@ void SkinManageDialog::on_userBtn_clicked()
     }
     m_list.updateSkin(&s);
 }
+
+void SkinManageDialog::resizeEvent(QResizeEvent* event)
+{
+    QWidget::resizeEvent(event);
+    QSize s = size() * (1. / 3);
+
+    if (auto skin = m_list.skin(m_selected_skin); skin) {
+        ui->selectedModel->setPixmap(skin->getTexture().scaled(s, Qt::KeepAspectRatio, Qt::FastTransformation));
+    }
+    auto id = ui->capeCombo->currentData();
+    ui->capeImage->setPixmap(m_capes.value(id.toString(), {}).scaled(s, Qt::KeepAspectRatio, Qt::FastTransformation));
+}

launcher/ui/dialogs/skins/SkinManageDialog.h

@@ -34,6 +34,7 @@ class SkinManageDialog : public QDialog {
    public:
     explicit SkinManageDialog(QWidget* parent, MinecraftAccountPtr acct);
     virtual ~SkinManageDialog();
+    void resizeEvent(QResizeEvent* event) override;
 
    public slots:
     void selectionChanged(QItemSelection, QItemSelection);

launcher/ui/dialogs/skins/SkinManageDialog.ui

@@ -24,7 +24,10 @@
           <string/>
          </property>
          <property name="scaledContents">
-          <bool>true</bool>
+          <bool>false</bool>
+         </property>
+         <property name="alignment">
+          <set>Qt::AlignCenter</set>
          </property>
         </widget>
        </item>
@@ -75,7 +78,10 @@
              <string/>
             </property>
             <property name="scaledContents">
-             <bool>true</bool>
+             <bool>false</bool>
+            </property>
+            <property name="alignment">
+             <set>Qt::AlignCenter</set>
             </property>
            </widget>
           </item>

launcher/ui/pages/instance/ManagedPackPage.cpp

@@ -371,7 +371,7 @@ void ModrinthManagedPackPage::update()
 
 void ModrinthManagedPackPage::updateFromFile()
 {
-    auto output = QFileDialog::getOpenFileUrl(this, tr("Choose update file"), QDir::homePath(), "Modrinth pack (*.mrpack *.zip)");
+    auto output = QFileDialog::getOpenFileUrl(this, tr("Choose update file"), QDir::homePath(), tr("Modrinth pack") + " (*.mrpack *.zip)");
     if (output.isEmpty())
         return;
     QMap<QString, QString> extra_info;
@@ -538,7 +538,7 @@ void FlameManagedPackPage::update()
 
 void FlameManagedPackPage::updateFromFile()
 {
-    auto output = QFileDialog::getOpenFileUrl(this, tr("Choose update file"), QDir::homePath(), "CurseForge pack (*.zip)");
+    auto output = QFileDialog::getOpenFileUrl(this, tr("Choose update file"), QDir::homePath(), tr("CurseForge pack") + " (*.zip)");
     if (output.isEmpty())
         return;
 

launcher/ui/pages/instance/ModFolderPage.cpp

@@ -41,6 +41,7 @@
 #include "ui_ExternalResourcesPage.h"
 
 #include <QAbstractItemModel>
+#include <QAction>
 #include <QEvent>
 #include <QKeyEvent>
 #include <QMenu>
@@ -122,13 +123,19 @@ ModFolderPage::ModFolderPage(BaseInstance* inst, std::shared_ptr<ModFolderModel>
         ui->actionsToolbar->addAction(ui->actionVisitItemPage);
         connect(ui->actionVisitItemPage, &QAction::triggered, this, &ModFolderPage::visitModPages);
 
+        auto changeVersion = new QAction(tr("Change Version"));
+        changeVersion->setToolTip(tr("Change mod version"));
+        changeVersion->setEnabled(false);
+        ui->actionsToolbar->insertActionAfter(ui->actionUpdateItem, changeVersion);
+        connect(changeVersion, &QAction::triggered, this, &ModFolderPage::changeModVersion);
+
         ui->actionsToolbar->insertActionAfter(ui->actionVisitItemPage, ui->actionExportMetadata);
         connect(ui->actionExportMetadata, &QAction::triggered, this, &ModFolderPage::exportModMetadata);
 
         auto check_allow_update = [this] { return ui->treeView->selectionModel()->hasSelection() || !m_model->empty(); };
 
         connect(ui->treeView->selectionModel(), &QItemSelectionModel::selectionChanged, this,
-                [this, check_allow_update, actionRemoveItemMetadata] {
+                [this, check_allow_update, actionRemoveItemMetadata, changeVersion] {
                     ui->actionUpdateItem->setEnabled(check_allow_update());
 
                     auto selection = m_filterModel->mapSelectionToSource(ui->treeView->selectionModel()->selection()).indexes();
@@ -138,11 +145,12 @@ ModFolderPage::ModFolderPage(BaseInstance* inst, std::shared_ptr<ModFolderModel>
                     if (selected <= 1) {
                         ui->actionVisitItemPage->setText(tr("Visit mod's page"));
                         ui->actionVisitItemPage->setToolTip(tr("Go to mod's home page"));
-
                     } else {
                         ui->actionVisitItemPage->setText(tr("Visit mods' pages"));
                         ui->actionVisitItemPage->setToolTip(tr("Go to the pages of the selected mods"));
                     }
+
+                    changeVersion->setEnabled(mods_list.length() == 1 && mods_list[0]->metadata() != nullptr);
                     ui->actionVisitItemPage->setEnabled(selected != 0);
                     actionRemoveItemMetadata->setEnabled(selected != 0);
                 });
@@ -377,6 +385,57 @@ void ModFolderPage::deleteModMetadata()
     m_model->deleteModsMetadata(selection);
 }
 
+void ModFolderPage::changeModVersion()
+{
+    if (m_instance->typeName() != "Minecraft")
+        return;  // this is a null instance or a legacy instance
+
+    auto profile = static_cast<MinecraftInstance*>(m_instance)->getPackProfile();
+    if (!profile->getModLoaders().has_value()) {
+        QMessageBox::critical(this, tr("Error"), tr("Please install a mod loader first!"));
+        return;
+    }
+    if (APPLICATION->settings()->get("ModMetadataDisabled").toBool()) {
+        QMessageBox::critical(this, tr("Error"), tr("Mod updates are unavailable when metadata is disabled!"));
+        return;
+    }
+    auto selection = m_filterModel->mapSelectionToSource(ui->treeView->selectionModel()->selection()).indexes();
+    auto mods_list = m_model->selectedMods(selection);
+    if (mods_list.length() != 1 || mods_list[0]->metadata() == nullptr)
+        return;
+
+    ResourceDownload::ModDownloadDialog mdownload(this, m_model, m_instance);
+    mdownload.setModMetadata((*mods_list.begin())->metadata());
+    if (mdownload.exec()) {
+        auto tasks = new ConcurrentTask(this, "Download Mods", APPLICATION->settings()->get("NumberOfConcurrentDownloads").toInt());
+        connect(tasks, &Task::failed, [this, tasks](QString reason) {
+            CustomMessageBox::selectable(this, tr("Error"), reason, QMessageBox::Critical)->show();
+            tasks->deleteLater();
+        });
+        connect(tasks, &Task::aborted, [this, tasks]() {
+            CustomMessageBox::selectable(this, tr("Aborted"), tr("Download stopped by user."), QMessageBox::Information)->show();
+            tasks->deleteLater();
+        });
+        connect(tasks, &Task::succeeded, [this, tasks]() {
+            QStringList warnings = tasks->warnings();
+            if (warnings.count())
+                CustomMessageBox::selectable(this, tr("Warnings"), warnings.join('\n'), QMessageBox::Warning)->show();
+
+            tasks->deleteLater();
+        });
+
+        for (auto& task : mdownload.getTasks()) {
+            tasks->addTask(task);
+        }
+
+        ProgressDialog loadDialog(this);
+        loadDialog.setSkipButton(true, tr("Abort"));
+        loadDialog.execWithTask(tasks);
+
+        m_model->update();
+    }
+}
+
 void ModFolderPage::exportModMetadata()
 {
     auto selection = m_filterModel->mapSelectionToSource(ui->treeView->selectionModel()->selection()).indexes();

launcher/ui/pages/instance/ModFolderPage.h

@@ -67,6 +67,7 @@ class ModFolderPage : public ExternalResourcesPage {
     void installMods();
     void updateMods(bool includeDeps = false);
     void visitModPages();
+    void changeModVersion();
 
    protected:
     std::shared_ptr<ModFolderModel> m_model;

launcher/ui/pages/instance/VersionPage.cpp

@@ -297,7 +297,7 @@ void VersionPage::on_actionRemove_triggered()
 
 void VersionPage::on_actionAdd_to_Minecraft_jar_triggered()
 {
-    auto list = GuiUtil::BrowseForFiles("jarmod", tr("Select jar mods"), tr("Minecraft.jar mods (*.zip *.jar)"),
+    auto list = GuiUtil::BrowseForFiles("jarmod", tr("Select jar mods"), tr("Minecraft.jar mods") + " (*.zip *.jar)",
                                         APPLICATION->settings()->get("CentralModsDir").toString(), this->parentWidget());
     if (!list.empty()) {
         m_profile->installJarMods(list);
@@ -307,7 +307,7 @@ void VersionPage::on_actionAdd_to_Minecraft_jar_triggered()
 
 void VersionPage::on_actionReplace_Minecraft_jar_triggered()
 {
-    auto jarPath = GuiUtil::BrowseForFile("jar", tr("Select jar"), tr("Minecraft.jar replacement (*.jar)"),
+    auto jarPath = GuiUtil::BrowseForFile("jar", tr("Select jar"), tr("Minecraft.jar replacement") + " (*.jar)",
                                           APPLICATION->settings()->get("CentralModsDir").toString(), this->parentWidget());
     if (!jarPath.isEmpty()) {
         m_profile->installCustomJar(jarPath);
@@ -317,7 +317,7 @@ void VersionPage::on_actionReplace_Minecraft_jar_triggered()
 
 void VersionPage::on_actionImport_Components_triggered()
 {
-    QStringList list = GuiUtil::BrowseForFiles("component", tr("Select components"), tr("Components (*.json)"),
+    QStringList list = GuiUtil::BrowseForFiles("component", tr("Select components"), tr("Components") + " (*.json)",
                                                APPLICATION->settings()->get("CentralModsDir").toString(), this->parentWidget());
 
     if (!list.isEmpty()) {
@@ -332,7 +332,7 @@ void VersionPage::on_actionImport_Components_triggered()
 
 void VersionPage::on_actionAdd_Agents_triggered()
 {
-    QStringList list = GuiUtil::BrowseForFiles("agent", tr("Select agents"), tr("Java agents (*.jar)"),
+    QStringList list = GuiUtil::BrowseForFiles("agent", tr("Select agents"), tr("Java agents") + " (*.jar)",
                                                APPLICATION->settings()->get("CentralModsDir").toString(), this->parentWidget());
 
     if (!list.isEmpty())

launcher/ui/pages/instance/WorldListPage.cpp

@@ -343,7 +343,7 @@ void WorldListPage::worldChanged([[maybe_unused]] const QModelIndex& current, [[
 
 void WorldListPage::on_actionAdd_triggered()
 {
-    auto list = GuiUtil::BrowseForFiles(displayName(), tr("Select a Minecraft world zip"), tr("Minecraft World Zip File (*.zip)"),
+    auto list = GuiUtil::BrowseForFiles(displayName(), tr("Select a Minecraft world zip"), tr("Minecraft World Zip File") + " (*.zip)",
                                         QString(), this->parentWidget());
     if (!list.empty()) {
         m_worlds->stopWatching();

launcher/ui/pages/modplatform/ModModel.cpp

@@ -88,6 +88,17 @@ bool ModModel::isPackInstalled(ModPlatform::IndexedPack::Ptr pack) const
     });
 }
 
+QVariant ModModel::getInstalledPackVersion(ModPlatform::IndexedPack::Ptr pack) const
+{
+    auto allMods = static_cast<MinecraftInstance&>(m_base_instance).loaderModList()->allMods();
+    for (auto mod : allMods) {
+        if (auto meta = mod->metadata(); meta && meta->provider == pack->provider && meta->project_id == pack->addonId) {
+            return meta->version();
+        }
+    }
+    return {};
+}
+
 bool checkSide(QString filter, QString value)
 {
     return filter.isEmpty() || value.isEmpty() || filter == "both" || value == "both" || filter == value;

launcher/ui/pages/modplatform/ModModel.h

@@ -35,6 +35,7 @@ class ModModel : public ResourceModel {
     virtual ModPlatform::IndexedVersion loadDependencyVersions(const ModPlatform::Dependency& m, QJsonArray& arr) = 0;
 
     void setFilter(std::shared_ptr<ModFilterWidget::Filter> filter) { m_filter = filter; }
+    virtual QVariant getInstalledPackVersion(ModPlatform::IndexedPack::Ptr) const override;
 
    public slots:
     ResourceAPI::SearchArgs createSearchArguments() override;

launcher/ui/pages/modplatform/ResourceModel.h

@@ -56,6 +56,7 @@ class ResourceModel : public QAbstractListModel {
 
     [[nodiscard]] auto getSortingMethods() const { return m_api->getSortingMethods(); }
 
+    virtual QVariant getInstalledPackVersion(ModPlatform::IndexedPack::Ptr) const { return {}; }
     /** Whether the version is opted out or not. Currently only makes sense in CF. */
     virtual bool optedOut(const ModPlatform::IndexedVersion& ver) const
     {

launcher/ui/pages/modplatform/ResourcePage.cpp

@@ -271,7 +271,9 @@ void ResourcePage::updateVersionList()
     m_ui->versionSelectionBox->clear();
     m_ui->versionSelectionBox->blockSignals(false);
 
-    if (current_pack)
+    if (current_pack) {
+        auto installedVersion = m_model->getInstalledPackVersion(current_pack);
+
         for (int i = 0; i < current_pack->versions.size(); i++) {
             auto& version = current_pack->versions[i];
             if (!m_model->checkVersionFilters(version))
@@ -280,9 +282,10 @@ void ResourcePage::updateVersionList()
             auto release_type = current_pack->versions[i].version_type.isValid()
                                     ? QString(" [%1]").arg(current_pack->versions[i].version_type.toString())
                                     : "";
-            m_ui->versionSelectionBox->addItem(current_pack->versions[i].version, QVariant(i));
-        }
 
+            m_ui->versionSelectionBox->addItem(QString("%1%2").arg(version.version, release_type), QVariant(i));
+        }
+    }
     if (m_ui->versionSelectionBox->count() == 0) {
         m_ui->versionSelectionBox->addItem(tr("No valid version found."), QVariant(-1));
         m_ui->resourceSelectionButton->setText(tr("Cannot select invalid version :("));
@@ -399,7 +402,7 @@ void ResourcePage::openUrl(const QUrl& url)
         }
     }
 
-    if (!page.isNull()) {
+    if (!page.isNull() && !m_do_not_jump_to_mod) {
         const QString slug = match.captured(1);
 
         // ensure the user isn't opening the same mod
@@ -443,4 +446,52 @@ void ResourcePage::openUrl(const QUrl& url)
     QDesktopServices::openUrl(url);
 }
 
+void ResourcePage::openProject(QVariant projectID)
+{
+    m_ui->sortByBox->hide();
+    m_ui->searchEdit->hide();
+    m_ui->resourceFilterButton->hide();
+    m_ui->packView->hide();
+    m_ui->resourceSelectionButton->hide();
+    m_do_not_jump_to_mod = true;
+
+    auto buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
+
+    auto okBtn = buttonBox->button(QDialogButtonBox::Ok);
+    okBtn->setDefault(true);
+    okBtn->setAutoDefault(true);
+    okBtn->setText(tr("Reinstall"));
+    okBtn->setShortcut(tr("Ctrl+Return"));
+    okBtn->setEnabled(false);
+
+    auto cancelBtn = buttonBox->button(QDialogButtonBox::Cancel);
+    cancelBtn->setDefault(false);
+    cancelBtn->setAutoDefault(false);
+
+    connect(okBtn, &QPushButton::clicked, this, [this] {
+        onResourceSelected();
+        m_parent_dialog->accept();
+    });
+
+    connect(cancelBtn, &QPushButton::clicked, m_parent_dialog, &ResourceDownloadDialog::reject);
+    m_ui->gridLayout_4->addWidget(buttonBox, 1, 2);
+
+    auto jump = [this, okBtn] {
+        for (int row = 0; row < m_model->rowCount({}); row++) {
+            const QModelIndex index = m_model->index(row);
+            m_ui->packView->setCurrentIndex(index);
+            okBtn->setEnabled(true);
+            return;
+        }
+        m_ui->packDescription->setText(tr("The resource was not found"));
+    };
+
+    m_ui->searchEdit->setText("#" + projectID.toString());
+    triggerSearch();
+
+    if (m_model->hasActiveSearchJob())
+        connect(m_model->activeSearchJob().get(), &Task::finished, jump);
+    else
+        jump();
+}
 }  // namespace ResourceDownload

launcher/ui/pages/modplatform/ResourcePage.h

@@ -83,6 +83,8 @@ class ResourcePage : public QWidget, public BasePage {
     QList<DownloadTaskPtr> selectedPacks() { return m_model->selectedPacks(); }
     bool hasSelectedPacks() { return !(m_model->selectedPacks().isEmpty()); }
 
+    virtual void openProject(QVariant projectID);
+
    protected slots:
     virtual void triggerSearch() = 0;
 
@@ -111,6 +113,8 @@ class ResourcePage : public QWidget, public BasePage {
 
     // Used to do instant searching with a delay to cache quick changes
     QTimer m_search_timer;
+
+    bool m_do_not_jump_to_mod = false;
 };
 
 }  // namespace ResourceDownload

launcher/ui/widgets/PageContainer.h

@@ -36,6 +36,7 @@
 
 #pragma once
 
+#include <QListView>
 #include <QModelIndex>
 #include <QWidget>
 
@@ -86,6 +87,8 @@ class PageContainer : public QWidget, public BasePageContainer {
 
     void changeEvent(QEvent*) override;
 
+    void hidePageList() { m_pageList->hide(); }
+
    private:
     void createUI();
     void retranslate();

launcher/updater/prismupdater/PrismUpdater.cpp

@@ -469,8 +469,7 @@ PrismUpdaterApp::PrismUpdaterApp(int& argc, char** argv) : QApplication(argc, ar
             target_dir = QDir(m_rootPath).absoluteFilePath("..");
         }
 
-        QMetaObject::invokeMethod(
+        QMetaObject::invokeMethod(this, [this, target_dir]() { moveAndFinishUpdate(target_dir); }, Qt::QueuedConnection);
-            this, [this, target_dir]() { moveAndFinishUpdate(target_dir); }, Qt::QueuedConnection);
 
     } else {
         QMetaObject::invokeMethod(this, &PrismUpdaterApp::loadReleaseList, Qt::QueuedConnection);

libraries/murmur2/src/MurmurHash2.cpp

@@ -8,14 +8,14 @@
 
 #include "MurmurHash2.h"
 
-//-----------------------------------------------------------------------------
+namespace Murmur2 {
 
 // 'm' and 'r' are mixing constants generated offline.
 // They're not really 'magic', they just happen to work well.
 const uint32_t m = 0x5bd1e995;
 const int r = 24;
 
-uint32_t MurmurHash2(std::ifstream&& file_stream, std::size_t buffer_size, std::function<bool(char)> filter_out)
+uint32_t hash(Reader* file_stream, std::size_t buffer_size, std::function<bool(char)> filter_out)
 {
     auto* buffer = new char[buffer_size];
     char data[4];
@@ -26,24 +26,21 @@ uint32_t MurmurHash2(std::ifstream&& file_stream, std::size_t buffer_size, std::
     // We need the size without the filtered out characters before actually calculating the hash,
     // to setup the initial value for the hash.
     do {
-        file_stream.read(buffer, buffer_size);
+        read = file_stream->read(buffer, buffer_size);
-        read = file_stream.gcount();
         for (int i = 0; i < read; i++) {
             if (!filter_out(buffer[i]))
                 size += 1;
         }
-    } while (!file_stream.eof());
+    } while (!file_stream->eof());
 
-    file_stream.clear();
+    file_stream->goToBeginning();
-    file_stream.seekg(0, file_stream.beg);
 
     int index = 0;
 
     // This forces a seed of 1.
     IncrementalHashInfo info{ (uint32_t)1 ^ size, (uint32_t)size };
     do {
-        file_stream.read(buffer, buffer_size);
+        read = file_stream->read(buffer, buffer_size);
-        read = file_stream.gcount();
         for (int i = 0; i < read; i++) {
             char c = buffer[i];
 
@@ -57,14 +54,13 @@ uint32_t MurmurHash2(std::ifstream&& file_stream, std::size_t buffer_size, std::
             if (index == 0)
                 FourBytes_MurmurHash2(reinterpret_cast<unsigned char*>(&data), info);
         }
-    } while (!file_stream.eof());
+    } while (!file_stream->eof());
 
     // Do one last bit shuffle in the hash
     FourBytes_MurmurHash2(reinterpret_cast<unsigned char*>(&data), info);
 
     delete[] buffer;
 
-    file_stream.close();
     return info.h;
 }
 
@@ -109,4 +105,4 @@ void FourBytes_MurmurHash2(const unsigned char* data, IncrementalHashInfo& prev)
     }
 }
 
-//-----------------------------------------------------------------------------
+}  // namespace Murmur2

libraries/murmur2/src/MurmurHash2.h

@@ -9,19 +9,22 @@
 #pragma once
 
 #include <cstdint>
-#include <fstream>
-
 #include <functional>
 
-//-----------------------------------------------------------------------------
+namespace Murmur2 {
 
 #define KiB 1024
 #define MiB 1024 * KiB
 
-uint32_t MurmurHash2(
+class Reader {
-    std::ifstream&& file_stream,
+   public:
-    std::size_t buffer_size = 4 * MiB,
+    virtual ~Reader() = default;
-    std::function<bool(char)> filter_out = [](char) { return false; });
+    virtual int read(char* s, int n) = 0;
+    virtual bool eof() = 0;
+    virtual void goToBeginning() = 0;
+};
+
+uint32_t hash(Reader* file_stream, std::size_t buffer_size = 4 * MiB, std::function<bool(char)> filter_out = [](char) { return false; });
 
 struct IncrementalHashInfo {
     uint32_t h;
@@ -29,5 +32,4 @@ struct IncrementalHashInfo {
 };
 
 void FourBytes_MurmurHash2(const unsigned char* data, IncrementalHashInfo& prev);
-
+}  // namespace Murmur2
-//-----------------------------------------------------------------------------

nix/dev.nix

@@ -19,7 +19,7 @@
         };
       };
 
-      tools.clang-tools = lib.mkForce pkgs.clang-tools_16;
+      tools.clang-tools = lib.mkForce pkgs.clang-tools_18;
     };
 
     devShells.default = pkgs.mkShell {

nix/distribution.nix

@@ -13,8 +13,6 @@
     in {
       inherit
         (ourPackages)
-        prismlauncher-qt5-unwrapped
-        prismlauncher-qt5
         prismlauncher-unwrapped
         prismlauncher
         ;
@@ -25,21 +23,12 @@
   flake = {
     overlays.default = final: prev: let
       version = builtins.substring 0 8 self.lastModifiedDate or "dirty";
-
+    in {
-      # common args for prismlauncher evaluations
+      prismlauncher-unwrapped = prev.qt6Packages.callPackage ./pkg {
-      unwrappedArgs = {
         inherit (inputs) libnbtplusplus;
         inherit ((final.darwin or prev.darwin).apple_sdk.frameworks) Cocoa;
         inherit version;
       };
-    in {
-      prismlauncher-qt5-unwrapped = prev.libsForQt5.callPackage ./pkg unwrappedArgs;
-
-      prismlauncher-qt5 = prev.libsForQt5.callPackage ./pkg/wrapper.nix {
-        prismlauncher-unwrapped = final.prismlauncher-qt5-unwrapped;
-      };
-
-      prismlauncher-unwrapped = prev.qt6Packages.callPackage ./pkg unwrappedArgs;
 
       prismlauncher = prev.qt6Packages.callPackage ./pkg/wrapper.nix {
         inherit (final) prismlauncher-unwrapped;

tests/ResourceFolderModel_test.cpp

@@ -203,7 +203,10 @@ class ResourceFolderModelTest : public QObject {
 
         QCOMPARE(model.size(), 0);
 
-        { EXEC_UPDATE_TASK(model.installResource(folder_resource), QVERIFY) } {
+        {
+            EXEC_UPDATE_TASK(model.installResource(folder_resource), QVERIFY)
+        }
+        {
             EXEC_UPDATE_TASK(model.installResource(file_mod), QVERIFY)
         }