Merge pull request #781 from Scrumplex/chore-bump-1.3.2

Avoid re-registering InstanceType

.clang-format

@@ -0,0 +1,16 @@
+---
+Language:        Cpp
+BasedOnStyle:  Chromium
+IndentWidth: 4
+AlignConsecutiveMacros: false
+AlignConsecutiveAssignments: false
+AllowShortIfStatementsOnASingleLine: false
+BraceWrapping:
+  AfterFunction:   true
+  SplitEmptyFunction: false
+  SplitEmptyRecord: false
+  SplitEmptyNamespace: false
+BreakBeforeBraces: Custom
+BreakConstructorInitializers: BeforeComma
+ColumnLimit:     140
+Cpp11BracedListStyle: false

.github/FUNDING.yml

@@ -0,0 +1 @@
+open_collective: polymc

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -23,6 +23,13 @@ body:
     - macOS
     - Linux
     - Other
+- type: textarea
+  attributes:
+    label: Version of PolyMC
+    description: The version of PolyMC used in the bug report.
+    placeholder: PolyMC 1.2.2
+  validations:
+    required: true
 - type: textarea
   attributes:
     label: Description of bug

.github/workflows/build.yml

@@ -17,6 +17,9 @@ jobs:
 
           - os: ubuntu-20.04
 
+          - os: ubuntu-20.04
+            appimage: true
+
           - os: windows-2022
             name: "Windows-i686"
             msystem: mingw32
@@ -36,6 +39,7 @@ jobs:
       INSTALL_PORTABLE_DIR: "install-portable"
       INSTALL_APPIMAGE_DIR: "install-appdir"
       BUILD_DIR: "build"
+      CCACHE_VAR: ""
 
     steps:
       ##
@@ -59,6 +63,39 @@ jobs:
             cmake:p
             ninja:p
             qt5:p
+            ccache:p
+            nsis:p
+
+      - name: Setup ccache
+        if: runner.os != 'Windows' && inputs.build_type == 'Debug'
+        uses: hendrikmuhs/ccache-action@v1.2.1
+        with:
+          key: ${{ matrix.os }}-${{ matrix.appimage }}
+
+      - name: Setup ccache (Windows)
+        if: runner.os == 'Windows' && inputs.build_type == 'Debug'
+        shell: msys2 {0}
+        run: |
+          ccache --set-config=cache_dir='${{ github.workspace }}\.ccache'
+          ccache --set-config=max_size='500M'
+          ccache --set-config=compression=true
+          ccache -p  # Show config
+          ccache -z  # Zero stats
+
+      - name: Use ccache on Debug builds only
+        if: inputs.build_type == 'Debug'
+        shell: bash
+        run: |
+          echo "CCACHE_VAR=ccache" >> $GITHUB_ENV
+
+      - name: Retrieve ccache cache (Windows)
+        if: runner.os == 'Windows' && inputs.build_type == 'Debug'
+        uses: actions/cache@v3.0.2
+        with:
+          path: '${{ github.workspace }}\.ccache'
+          key: ${{ matrix.os }}-${{ matrix.msystem }}
+          restore-keys: |
+              ${{ matrix.os }}-${{ matrix.msystem }}
 
       - name: Set short version
         shell: bash
@@ -66,30 +103,28 @@ jobs:
           ver_short=`git rev-parse --short HEAD`
           echo "VERSION=$ver_short" >> $GITHUB_ENV
 
-      - name: Install OpenJDK
-        uses: actions/setup-java@v3
-        with:
-          distribution: 'temurin'
-          java-version: '17'
-
       - name: Install Qt (macOS)
         if: runner.os == 'macOS'
         run: |
          brew update
-         brew install qt@5
+         brew install qt@5 ninja
+
+      - name: Update Qt (AppImage)
+        if: runner.os == 'Linux' && matrix.appimage == true
+        run: |
+         sudo add-apt-repository ppa:savoury1/qt-5-15
+         sudo add-apt-repository ppa:savoury1/kde-5-80
+         sudo add-apt-repository ppa:savoury1/gpg
+         sudo add-apt-repository ppa:savoury1/ffmpeg4
 
       - name: Install Qt (Linux)
         if: runner.os == 'Linux'
         run: |
           sudo apt-get -y update
-          sudo apt-get -y install qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools libqt5core5a libqt5network5 libqt5gui5
-
-      - name: Install Ninja
-        if: runner.os != 'Windows'
-        uses: urkle/action-get-ninja@v1
+          sudo apt-get -y install qtbase5-dev qtchooser qt5-qmake qtbase5-dev-tools libqt5core5a libqt5network5 libqt5gui5 ninja-build qt5-image-formats-plugins
 
       - name: Prepare AppImage (Linux)
-        if: runner.os == 'Linux'
+        if: runner.os == 'Linux' && matrix.appimage == true
         run: |
           wget "https://github.com/linuxdeploy/linuxdeploy/releases/download/continuous/linuxdeploy-x86_64.AppImage"
           wget "https://github.com/linuxdeploy/linuxdeploy-plugin-appimage/releases/download/continuous/linuxdeploy-plugin-appimage-x86_64.AppImage"
@@ -104,18 +139,18 @@ jobs:
       - name: Configure CMake (macOS)
         if: runner.os == 'macOS'
         run: |
-          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=${{ env.INSTALL_DIR }} -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DQt5_DIR=/usr/local/opt/qt@5 -DCMAKE_PREFIX_PATH=/usr/local/opt/qt@5 -DLauncher_BUILD_PLATFORM=macOS -G Ninja
+          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=${{ env.INSTALL_DIR }} -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DQt5_DIR=/usr/local/opt/qt@5 -DCMAKE_PREFIX_PATH=/usr/local/opt/qt@5 -DLauncher_BUILD_PLATFORM=macOS -DCMAKE_C_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DCMAKE_CXX_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -G Ninja
 
       - name: Configure CMake (Windows)
         if: runner.os == 'Windows'
         shell: msys2 {0}
         run: |
-          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=${{ env.INSTALL_DIR }} -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DLauncher_BUILD_PLATFORM=${{ matrix.name }} -G Ninja
+          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=${{ env.INSTALL_DIR }} -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DLauncher_BUILD_PLATFORM=${{ matrix.name }} -DCMAKE_C_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DCMAKE_CXX_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -G Ninja
 
       - name: Configure CMake (Linux)
         if: runner.os == 'Linux'
         run: |
-          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DLauncher_BUILD_PLATFORM=Linux -G Ninja
+          cmake -S . -B ${{ env.BUILD_DIR }} -DCMAKE_INSTALL_PREFIX=/usr -DCMAKE_BUILD_TYPE=${{ inputs.build_type }} -DENABLE_LTO=ON -DLauncher_BUILD_PLATFORM=Linux -DCMAKE_C_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -DCMAKE_CXX_COMPILER_LAUNCHER=${{ env.CCACHE_VAR }} -G Ninja
 
       ##
       # BUILD
@@ -166,8 +201,15 @@ jobs:
           cp -r ${{ env.INSTALL_DIR }} ${{ env.INSTALL_PORTABLE_DIR }}  # cmake install on Windows is slow, let's just copy instead
           cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_PORTABLE_DIR }} --component portable
 
+      - name: Package (Windows, installer)
+        if: runner.os == 'Windows'
+        shell: msys2 {0}
+        run: |
+          cd ${{ env.INSTALL_DIR }}
+          makensis -NOCD "${{ github.workspace }}/${{ env.BUILD_DIR }}/program_info/win_install.nsi"
+
       - name: Package (Linux)
-        if: runner.os == 'Linux'
+        if: runner.os == 'Linux' && matrix.appimage != true
         run: |
           cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_DIR }}
 
@@ -175,7 +217,7 @@ jobs:
           tar --owner root --group root -czf ../PolyMC.tar.gz *
 
       - name: Package (Linux, portable)
-        if: runner.os == 'Linux'
+        if: runner.os == 'Linux' && matrix.appimage != true
         run: |
           cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_PORTABLE_DIR }}
           cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_PORTABLE_DIR }} --component portable
@@ -184,7 +226,7 @@ jobs:
           tar -czf ../PolyMC-portable.tar.gz *
 
       - name: Package AppImage (Linux)
-        if: runner.os == 'Linux'
+        if: runner.os == 'Linux' && matrix.appimage == true
         shell: bash
         run: |
           cmake --install ${{ env.BUILD_DIR }} --prefix ${{ env.INSTALL_APPIMAGE_DIR }}/usr
@@ -233,22 +275,29 @@ jobs:
           name: PolyMC-${{ matrix.name }}-Portable-${{ env.VERSION }}-${{ inputs.build_type }}
           path: ${{ env.INSTALL_PORTABLE_DIR }}/**
 
+      - name: Upload installer (Windows)
+        if: runner.os == 'Windows'
+        uses: actions/upload-artifact@v3
+        with:
+          name: PolyMC-${{ matrix.name }}-Setup-${{ env.VERSION }}-${{ inputs.build_type }}
+          path: PolyMC-Setup.exe
+
       - name: Upload binary tarball (Linux)
-        if: runner.os == 'Linux'
+        if: runner.os == 'Linux' && matrix.appimage != true
         uses: actions/upload-artifact@v3
         with:
           name: PolyMC-${{ runner.os }}-${{ env.VERSION }}-${{ inputs.build_type }}
           path: PolyMC.tar.gz
 
       - name: Upload binary tarball (Linux, portable)
-        if: runner.os == 'Linux'
+        if: runner.os == 'Linux' && matrix.appimage != true
         uses: actions/upload-artifact@v3
         with:
           name: PolyMC-${{ runner.os }}-Portable-${{ env.VERSION }}-${{ inputs.build_type }}
           path: PolyMC-portable.tar.gz
 
       - name: Upload AppImage (Linux)
-        if: runner.os == 'Linux'
+        if: runner.os == 'Linux' && matrix.appimage == true
         uses: actions/upload-artifact@v3
         with:
           name: PolyMC-${{ runner.os }}-${{ env.VERSION }}-${{ inputs.build_type }}-x86_64.AppImage

.github/workflows/pr-comment.yml

@@ -1,7 +1,7 @@
 name: Comment on pull request
 on:
   workflow_run:
-    workflows: ['Test workflow with upload']
+    workflows: ['Build Application']
     types: [completed]
 jobs:
   pr_comment:

.github/workflows/trigger_release.yml

@@ -43,10 +43,12 @@ jobs:
           for d in PolyMC-Windows-*; do
             cd "${d}" || continue
             ARCH="$(echo -n ${d} | cut -d '-' -f 3)"
+            INST="$(echo -n ${d} | grep -o Setup || true)"
             PORT="$(echo -n ${d} | grep -o Portable || true)"
             NAME="PolyMC-Windows-${ARCH}"
             test -z "${PORT}" || NAME="${NAME}-Portable"
-            zip -r -9 "../${NAME}-${{ env.VERSION }}.zip" *
+            test -z "${INST}" || mv PolyMC-*.exe ../${NAME}-Setup-${{ env.VERSION }}.exe
+            test -n "${INST}" || zip -r -9 "../${NAME}-${{ env.VERSION }}.zip" *
             cd ..
           done
 
@@ -66,7 +68,9 @@ jobs:
             PolyMC-Linux-${{ env.VERSION }}-x86_64.AppImage
             PolyMC-Windows-i686-${{ env.VERSION }}.zip
             PolyMC-Windows-i686-Portable-${{ env.VERSION }}.zip
+            PolyMC-Windows-i686-Setup-${{ env.VERSION }}.exe
             PolyMC-Windows-x86_64-${{ env.VERSION }}.zip
             PolyMC-Windows-x86_64-Portable-${{ env.VERSION }}.zip
+            PolyMC-Windows-x86_64-Setup-${{ env.VERSION }}.exe
             PolyMC-macOS-${{ env.VERSION }}.tar.gz
             PolyMC-${{ env.VERSION }}.tar.gz

.gitignore

@@ -14,6 +14,7 @@ CMakeLists.txt.user.*
 /.project
 /.settings
 /.idea
+/.vscode
 cmake-build-*/
 Debug
 

CMakeLists.txt

@@ -1,4 +1,4 @@
-cmake_minimum_required(VERSION 3.9.4)
+cmake_minimum_required(VERSION 3.15)  # minimum version required by QuaZip
 
 if(WIN32)
     # In Qt 5.1+ we have our own main() function, don't autolink to qtmain on Windows
@@ -34,15 +34,19 @@ set(CMAKE_C_STANDARD_REQUIRED true)
 set(CMAKE_CXX_STANDARD 11)
 set(CMAKE_C_STANDARD 11)
 include(GenerateExportHeader)
-set(CMAKE_CXX_FLAGS " -Wall -pedantic -Werror -Wno-deprecated-declarations -D_GLIBCXX_USE_CXX11_ABI=0 -fstack-protector-strong --param=ssp-buffer-size=4 -O3 -D_FORTIFY_SOURCE=2 ${CMAKE_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS "-Wall -pedantic -Werror -Wno-deprecated-declarations -D_GLIBCXX_USE_CXX11_ABI=0 -fstack-protector-strong --param=ssp-buffer-size=4 ${CMAKE_CXX_FLAGS}")
 if(UNIX AND APPLE)
-    set(CMAKE_CXX_FLAGS " -stdlib=libc++ ${CMAKE_CXX_FLAGS}")
+    set(CMAKE_CXX_FLAGS "-stdlib=libc++ ${CMAKE_CXX_FLAGS}")
 endif()
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -Werror=return-type")
 
 # Fix build with Qt 5.13
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DQT_NO_DEPRECATED_WARNINGS=Y")
 
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -DQT_DISABLE_DEPRECATED_BEFORE=0x050C00")
+
+# set CXXFLAGS for build targets
+set(CMAKE_CXX_FLAGS_RELEASE "-O2 -D_FORTIFY_SOURCE=2 ${CMAKE_CXX_FLAGS_RELEASE}")
+
 option(ENABLE_LTO "Enable Link Time Optimization" off)
 
 if(ENABLE_LTO)
@@ -68,8 +72,8 @@ set(Launcher_HELP_URL "https://polymc.org/wiki/help-pages/%1" CACHE STRING "URL
 
 ######## Set version numbers ########
 set(Launcher_VERSION_MAJOR    1)
-set(Launcher_VERSION_MINOR    2)
-set(Launcher_VERSION_HOTFIX   1)
+set(Launcher_VERSION_MINOR    3)
+set(Launcher_VERSION_HOTFIX   2)
 
 # Build number
 set(Launcher_VERSION_BUILD -1 CACHE STRING "Build number. -1 for no build number.")
@@ -86,9 +90,6 @@ set(Launcher_META_URL "https://meta.polymc.org/v1/" CACHE STRING "URL to fetch L
 # Imgur API Client ID
 set(Launcher_IMGUR_CLIENT_ID "5b97b0713fba4a3" CACHE STRING "Client ID you can get from Imgur when you register an application")
 
-# MSA Client ID
-set(Launcher_MSA_CLIENT_ID "549033b2-1532-4d4e-ae77-1bbaa46f9d74" CACHE STRING "Client ID you can get from Microsoft Identity Platform when you register an application")
-
 # Bug tracker URL
 set(Launcher_BUG_TRACKER_URL "https://github.com/PolyMC/PolyMC/issues" CACHE STRING "URL for the bug tracker.")
 
@@ -110,6 +111,22 @@ set(Launcher_SUBREDDIT_URL "https://www.reddit.com/r/PolyMCLauncher/" CACHE STRI
 set(Launcher_FORCE_BUNDLED_LIBS OFF CACHE BOOL "Prevent using system libraries, if they are available as submodules")
 set(Launcher_QT_VERSION_MAJOR "5" CACHE STRING "Major Qt version to build against")
 
+# API Keys
+# NOTE: These API keys are here for convenience. If you rebrand this software or intend to break the terms of service
+# of these platforms, please change these API keys beforehand.
+# Be aware that if you were to use these API keys for malicious purposes they might get revoked, which might cause
+# breakage to thousands of users.
+# If you don't plan to use these features of this software, you can just remove these values.
+
+# By using this key in your builds you accept the terms of use laid down in
+# https://docs.microsoft.com/en-us/legal/microsoft-identity-platform/terms-of-use
+set(Launcher_MSA_CLIENT_ID "549033b2-1532-4d4e-ae77-1bbaa46f9d74" CACHE STRING "Client ID you can get from Microsoft Identity Platform when you register an application")
+
+# By using this key in your builds you accept the terms and conditions laid down in
+# https://support.curseforge.com/en/support/solutions/articles/9000207405-curse-forge-3rd-party-api-terms-and-conditions
+# NOTE: CurseForge requires you to change this if you make any kind of derivative work.
+set(Launcher_CURSEFORGE_API_KEY "$2a$10$1Oqr2MX3O4n/ilhFGc597u8tfI3L2Hyr9/rtWDAMRjghSQV2QUuxq" CACHE STRING "CurseForge API Key")
+
 
 #### Check the current Git commit and branch
 include(GetGitRevisionDescription)
@@ -119,6 +136,8 @@ message(STATUS "Git commit: ${Launcher_GIT_COMMIT}")
 message(STATUS "Git refspec: ${Launcher_GIT_REFSPEC}")
 
 set(Launcher_RELEASE_VERSION_NAME "${Launcher_VERSION_MAJOR}.${Launcher_VERSION_MINOR}.${Launcher_VERSION_HOTFIX}")
+set(Launcher_RELEASE_VERSION_NAME4 "${Launcher_RELEASE_VERSION_NAME}.0")
+set(Launcher_RELEASE_VERSION_NAME4_COMMA "${Launcher_VERSION_MAJOR},${Launcher_VERSION_MINOR},${Launcher_VERSION_HOTFIX},0")
 string(TIMESTAMP TODAY "%Y-%m-%d")
 set(Launcher_RELEASE_TIMESTAMP "${TODAY}")
 
@@ -134,7 +153,7 @@ if(Launcher_QT_VERSION_MAJOR EQUAL 5)
     find_package(Qt5 REQUIRED COMPONENTS Core Widgets Concurrent Network Test Xml)
 
     if(NOT Launcher_FORCE_BUNDLED_LIBS)
-        find_package(QuaZip-Qt5 1.3)
+        find_package(QuaZip-Qt5 1.3 QUIET)
     endif()
     if (NOT QuaZip-Qt5_FOUND)
         set(QUAZIP_QT_MAJOR_VERSION ${QT_VERSION_MAJOR} CACHE STRING "Qt version to use (4, 5 or 6), defaults to ${QT_VERSION_MAJOR}" FORCE)

README.md

@@ -6,7 +6,8 @@
 
 PolyMC is a custom launcher for Minecraft that focuses on predictability, long term stability and simplicity.
 
-This is a **fork** of the MultiMC Launcher and not endorsed by MultiMC. The PolyMC community felt that the maintainer was not acting in the spirit of Free Software so this fork was made.
+This is a **fork** of the MultiMC Launcher and not endorsed by MultiMC.
+If you want to read about why this fork was created, check out [our FAQ page](https://polymc.org/wiki/overview/faq/).
 <br>
 
 # Installation
@@ -81,8 +82,11 @@ To modify download information or change packaging information send a pull reque
 
 Do whatever you want, we don't care. Just follow the license. If you have any questions about this feel free to ask in an issue.
 
-All launcher code is available under the GPL-3 license.
+Be aware that if you build this software without removing the provided API keys in [CMakeLists.txt](CMakeLists.txt) you are accepting the following terms and conditions:
+ - [Microsoft Identity Platform Terms of Use](https://docs.microsoft.com/en-us/legal/microsoft-identity-platform/terms-of-use)
+ - [CurseForge 3rd Party API Terms and Conditions](https://support.curseforge.com/en/support/solutions/articles/9000207405-curse-forge-3rd-party-api-terms-and-conditions)
+If you do not agree with these terms and conditions, then remove the associated API keys from the [CMakeLists.txt](CMakeLists.txt) file.
 
-[Source for the website](https://github.com/PolyMC/polymc.github.io) is hosted under the AGPL-3 License.
+All launcher code is available under the GPL-3.0-only license.
   
 The logo and related assets are under the CC BY-SA 4.0 license.

buildconfig/BuildConfig.cpp.in

@@ -90,6 +90,7 @@ Config::Config()
     HELP_URL = "@Launcher_HELP_URL@";
     IMGUR_CLIENT_ID = "@Launcher_IMGUR_CLIENT_ID@";
     MSA_CLIENT_ID = "@Launcher_MSA_CLIENT_ID@";
+    CURSEFORGE_API_KEY = "@Launcher_CURSEFORGE_API_KEY@";
     META_URL = "@Launcher_META_URL@";
 
     BUG_TRACKER_URL = "@Launcher_BUG_TRACKER_URL@";

buildconfig/BuildConfig.h

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0-only
 /*
  *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
  *
  *  This program is free software: you can redistribute it and/or modify
@@ -39,9 +40,8 @@
 /**
  * \brief The Config class holds all the build-time information passed from the build system.
  */
-class Config
-{
-public:
+class Config {
+   public:
     Config();
     QString LAUNCHER_NAME;
     QString LAUNCHER_DISPLAYNAME;
@@ -74,7 +74,6 @@ public:
     /// URL for the updater's channel
     QString UPDATER_BASE;
 
-
     /// User-Agent to use.
     QString USER_AGENT;
 
@@ -116,6 +115,11 @@ public:
      */
     QString MSA_CLIENT_ID;
 
+    /**
+     * Client API key for CurseForge
+     */
+    QString CURSEFORGE_API_KEY;
+
     /**
      * Metadata repository URL prefix
      */
@@ -139,6 +143,7 @@ public:
     QString LEGACY_FTB_CDN_BASE_URL = "https://dist.creeper.host/FTB2/";
 
     QString ATL_DOWNLOAD_SERVER_URL = "https://download.nodecdn.net/containers/atl/";
+    QString ATL_API_BASE_URL = "https://api.atlauncher.com/v1/";
 
     QString TECHNIC_API_BASE_URL = "https://api.technicpack.net/";
     /**
@@ -146,6 +151,9 @@ public:
      */
     QString TECHNIC_API_BUILD = "multimc";
 
+    QString MODRINTH_STAGING_URL = "https://staging-api.modrinth.com/v2";
+    QString MODRINTH_PROD_URL = "https://api.modrinth.com/v2";
+
     /**
      * \brief Converts the Version to a string.
      * \return The version number in string format (major.minor.revision.build).
@@ -154,4 +162,3 @@ public:
 };
 
 extern const Config BuildConfig;
-

cmake/BundleUtilities.cmake

@@ -1,786 +0,0 @@
-# - Functions to help assemble a standalone bundle application.
-# A collection of CMake utility functions useful for dealing with .app
-# bundles on the Mac and bundle-like directories on any OS.
-#
-# The following functions are provided by this module:
-#   fixup_bundle
-#   copy_and_fixup_bundle
-#   verify_app
-#   get_bundle_main_executable
-#   get_dotapp_dir
-#   get_bundle_and_executable
-#   get_bundle_all_executables
-#   get_item_key
-#   clear_bundle_keys
-#   set_bundle_key_values
-#   get_bundle_keys
-#   copy_resolved_item_into_bundle
-#   copy_resolved_framework_into_bundle
-#   fixup_bundle_item
-#   verify_bundle_prerequisites
-#   verify_bundle_symlinks
-# Requires CMake 2.6 or greater because it uses function, break and
-# PARENT_SCOPE. Also depends on GetPrerequisites.cmake.
-#
-#  FIXUP_BUNDLE(<app> <libs> <dirs>)
-# Fix up a bundle in-place and make it standalone, such that it can be
-# drag-n-drop copied to another machine and run on that machine as long as all
-# of the system libraries are compatible.
-#
-# If you pass plugins to fixup_bundle as the libs parameter, you should install
-# them or copy them into the bundle before calling fixup_bundle. The "libs"
-# parameter is a list of libraries that must be fixed up, but that cannot be
-# determined by otool output analysis. (i.e., plugins)
-#
-# Gather all the keys for all the executables and libraries in a bundle, and
-# then, for each key, copy each prerequisite into the bundle. Then fix each one
-# up according to its own list of prerequisites.
-#
-# Then clear all the keys and call verify_app on the final bundle to ensure
-# that it is truly standalone.
-#
-#  COPY_AND_FIXUP_BUNDLE(<src> <dst> <libs> <dirs>)
-# Makes a copy of the bundle <src> at location <dst> and then fixes up the
-# new copied bundle in-place at <dst>...
-#
-#  VERIFY_APP(<app>)
-# Verifies that an application <app> appears valid based on running analysis
-# tools on it. Calls "message(FATAL_ERROR" if the application is not verified.
-#
-#  GET_BUNDLE_MAIN_EXECUTABLE(<bundle> <result_var>)
-# The result will be the full path name of the bundle's main executable file
-# or an "error:" prefixed string if it could not be determined.
-#
-#  GET_DOTAPP_DIR(<exe> <dotapp_dir_var>)
-# Returns the nearest parent dir whose name ends with ".app" given the full
-# path to an executable. If there is no such parent dir, then simply return
-# the dir containing the executable.
-#
-# The returned directory may or may not exist.
-#
-#  GET_BUNDLE_AND_EXECUTABLE(<app> <bundle_var> <executable_var> <valid_var>)
-# Takes either a ".app" directory name or the name of an executable
-# nested inside a ".app" directory and returns the path to the ".app"
-# directory in <bundle_var> and the path to its main executable in
-# <executable_var>
-#
-#  GET_BUNDLE_ALL_EXECUTABLES(<bundle> <exes_var>)
-# Scans the given bundle recursively for all executable files and accumulates
-# them into a variable.
-#
-#  GET_ITEM_KEY(<item> <key_var>)
-# Given a file (item) name, generate a key that should be unique considering
-# the set of libraries that need copying or fixing up to make a bundle
-# standalone. This is essentially the file name including extension with "."
-# replaced by "_"
-#
-# This key is used as a prefix for CMake variables so that we can associate a
-# set of variables with a given item based on its key.
-#
-#  CLEAR_BUNDLE_KEYS(<keys_var>)
-# Loop over the list of keys, clearing all the variables associated with each
-# key. After the loop, clear the list of keys itself.
-#
-# Caller of get_bundle_keys should call clear_bundle_keys when done with list
-# of keys.
-#
-#  SET_BUNDLE_KEY_VALUES(<keys_var> <context> <item> <exepath> <dirs>
-#                        <copyflag>)
-# Add a key to the list (if necessary) for the given item. If added,
-# also set all the variables associated with that key.
-#
-#  GET_BUNDLE_KEYS(<app> <libs> <dirs> <keys_var>)
-# Loop over all the executable and library files within the bundle (and given
-# as extra <libs>) and accumulate a list of keys representing them. Set
-# values associated with each key such that we can loop over all of them and
-# copy prerequisite libs into the bundle and then do appropriate
-# install_name_tool fixups.
-#
-#  COPY_RESOLVED_ITEM_INTO_BUNDLE(<resolved_item> <resolved_embedded_item>)
-# Copy a resolved item into the bundle if necessary. Copy is not necessary if
-# the resolved_item is "the same as" the resolved_embedded_item.
-#
-#  COPY_RESOLVED_FRAMEWORK_INTO_BUNDLE(<resolved_item> <resolved_embedded_item>)
-# Copy a resolved framework into the bundle if necessary. Copy is not necessary
-# if the resolved_item is "the same as" the resolved_embedded_item.
-#
-# By default, BU_COPY_FULL_FRAMEWORK_CONTENTS is not set. If you want full
-# frameworks embedded in your bundles, set BU_COPY_FULL_FRAMEWORK_CONTENTS to
-# ON before calling fixup_bundle. By default,
-# COPY_RESOLVED_FRAMEWORK_INTO_BUNDLE copies the framework dylib itself plus
-# the framework Resources directory.
-#
-#  FIXUP_BUNDLE_ITEM(<resolved_embedded_item> <exepath> <dirs>)
-# Get the direct/non-system prerequisites of the resolved embedded item. For
-# each prerequisite, change the way it is referenced to the value of the
-# _EMBEDDED_ITEM keyed variable for that prerequisite. (Most likely changing to
-# an "@executable_path" style reference.)
-#
-# This function requires that the resolved_embedded_item be "inside" the bundle
-# already. In other words, if you pass plugins to fixup_bundle as the libs
-# parameter, you should install them or copy them into the bundle before
-# calling fixup_bundle. The "libs" parameter is a list of libraries that must
-# be fixed up, but that cannot be determined by otool output analysis. (i.e.,
-# plugins)
-#
-# Also, change the id of the item being fixed up to its own _EMBEDDED_ITEM
-# value.
-#
-# Accumulate changes in a local variable and make *one* call to
-# install_name_tool at the end of the function with all the changes at once.
-#
-# If the BU_CHMOD_BUNDLE_ITEMS variable is set then bundle items will be
-# marked writable before install_name_tool tries to change them.
-#
-#  VERIFY_BUNDLE_PREREQUISITES(<bundle> <result_var> <info_var>)
-# Verifies that the sum of all prerequisites of all files inside the bundle
-# are contained within the bundle or are "system" libraries, presumed to exist
-# everywhere.
-#
-#  VERIFY_BUNDLE_SYMLINKS(<bundle> <result_var> <info_var>)
-# Verifies that any symlinks found in the bundle point to other files that are
-# already also in the bundle... Anything that points to an external file causes
-# this function to fail the verification.
-
-#=============================================================================
-# Copyright 2008-2009 Kitware, Inc.
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-# The functions defined in this file depend on the get_prerequisites function
-# (and possibly others) found in:
-#
-get_filename_component(BundleUtilities_cmake_dir "${CMAKE_CURRENT_LIST_FILE}" PATH)
-include("${BundleUtilities_cmake_dir}/GetPrerequisites.cmake")
-
-
-function(get_bundle_main_executable bundle result_var)
-  set(result "error: '${bundle}/Contents/Info.plist' file does not exist")
-
-  if(EXISTS "${bundle}/Contents/Info.plist")
-    set(result "error: no CFBundleExecutable in '${bundle}/Contents/Info.plist' file")
-    set(line_is_main_executable 0)
-    set(bundle_executable "")
-
-    # Read Info.plist as a list of lines:
-    #
-    set(eol_char "E")
-    file(READ "${bundle}/Contents/Info.plist" info_plist)
-    string(REGEX REPLACE ";" "\\\\;" info_plist "${info_plist}")
-    string(REGEX REPLACE "\n" "${eol_char};" info_plist "${info_plist}")
-
-    # Scan the lines for "<key>CFBundleExecutable</key>" - the line after that
-    # is the name of the main executable.
-    #
-    foreach(line ${info_plist})
-      if(line_is_main_executable)
-        string(REGEX REPLACE "^.*<string>(.*)</string>.*$" "\\1" bundle_executable "${line}")
-        break()
-      endif()
-
-      if(line MATCHES "^.*<key>CFBundleExecutable</key>.*$")
-        set(line_is_main_executable 1)
-      endif()
-    endforeach()
-
-    if(NOT "${bundle_executable}" STREQUAL "")
-      if(EXISTS "${bundle}/Contents/MacOS/${bundle_executable}")
-        set(result "${bundle}/Contents/MacOS/${bundle_executable}")
-      else()
-
-        # Ultimate goal:
-        # If not in "Contents/MacOS" then scan the bundle for matching files. If
-        # there is only one executable file that matches, then use it, otherwise
-        # it's an error...
-        #
-        #file(GLOB_RECURSE file_list "${bundle}/${bundle_executable}")
-
-        # But for now, pragmatically, it's an error. Expect the main executable
-        # for the bundle to be in Contents/MacOS, it's an error if it's not:
-        #
-        set(result "error: '${bundle}/Contents/MacOS/${bundle_executable}' does not exist")
-      endif()
-    endif()
-  else()
-    #
-    # More inclusive technique... (This one would work on Windows and Linux
-    # too, if a developer followed the typical Mac bundle naming convention...)
-    #
-    # If there is no Info.plist file, try to find an executable with the same
-    # base name as the .app directory:
-    #
-  endif()
-
-  set(${result_var} "${result}" PARENT_SCOPE)
-endfunction()
-
-
-function(get_dotapp_dir exe dotapp_dir_var)
-  set(s "${exe}")
-
-  if(s MATCHES "^.*/.*\\.app/.*$")
-    # If there is a ".app" parent directory,
-    # ascend until we hit it:
-    #   (typical of a Mac bundle executable)
-    #
-    set(done 0)
-    while(NOT ${done})
-      get_filename_component(snamewe "${s}" NAME_WE)
-      get_filename_component(sname "${s}" NAME)
-      get_filename_component(sdir "${s}" PATH)
-      set(s "${sdir}")
-      if(sname MATCHES "\\.app$")
-        set(done 1)
-        set(dotapp_dir "${sdir}/${sname}")
-      endif()
-    endwhile()
-  else()
-    # Otherwise use a directory containing the exe
-    #   (typical of a non-bundle executable on Mac, Windows or Linux)
-    #
-    is_file_executable("${s}" is_executable)
-    if(is_executable)
-      get_filename_component(sdir "${s}" PATH)
-      set(dotapp_dir "${sdir}")
-    else()
-      set(dotapp_dir "${s}")
-    endif()
-  endif()
-
-
-  set(${dotapp_dir_var} "${dotapp_dir}" PARENT_SCOPE)
-endfunction()
-
-
-function(get_bundle_and_executable app bundle_var executable_var valid_var)
-  set(valid 0)
-
-  if(EXISTS "${app}")
-    # Is it a directory ending in .app?
-    if(IS_DIRECTORY "${app}")
-      if(app MATCHES "\\.app$")
-        get_bundle_main_executable("${app}" executable)
-        if(EXISTS "${app}" AND EXISTS "${executable}")
-          set(${bundle_var} "${app}" PARENT_SCOPE)
-          set(${executable_var} "${executable}" PARENT_SCOPE)
-          set(valid 1)
-          #message(STATUS "info: handled .app directory case...")
-        else()
-          message(STATUS "warning: *NOT* handled - .app directory case...")
-        endif()
-      else()
-        message(STATUS "warning: *NOT* handled - directory but not .app case...")
-      endif()
-    else()
-      # Is it an executable file?
-      is_file_executable("${app}" is_executable)
-      if(is_executable)
-        get_dotapp_dir("${app}" dotapp_dir)
-        if(EXISTS "${dotapp_dir}")
-          set(${bundle_var} "${dotapp_dir}" PARENT_SCOPE)
-          set(${executable_var} "${app}" PARENT_SCOPE)
-          set(valid 1)
-          #message(STATUS "info: handled executable file in .app dir case...")
-        else()
-          get_filename_component(app_dir "${app}" PATH)
-          set(${bundle_var} "${app_dir}" PARENT_SCOPE)
-          set(${executable_var} "${app}" PARENT_SCOPE)
-          set(valid 1)
-          #message(STATUS "info: handled executable file in any dir case...")
-        endif()
-      else()
-        message(STATUS "warning: *NOT* handled - not .app dir, not executable file...")
-      endif()
-    endif()
-  else()
-    message(STATUS "warning: *NOT* handled - directory/file ${app} does not exist...")
-  endif()
-
-  if(NOT valid)
-    set(${bundle_var} "error: not a bundle" PARENT_SCOPE)
-    set(${executable_var} "error: not a bundle" PARENT_SCOPE)
-  endif()
-
-  set(${valid_var} ${valid} PARENT_SCOPE)
-endfunction()
-
-
-function(get_bundle_all_executables bundle exes_var)
-  set(exes "")
-
-  file(GLOB_RECURSE file_list "${bundle}/*")
-  foreach(f ${file_list})
-    is_file_executable("${f}" is_executable)
-    if(is_executable)
-      set(exes ${exes} "${f}")
-    endif()
-  endforeach()
-
-  set(${exes_var} "${exes}" PARENT_SCOPE)
-endfunction()
-
-
-function(get_item_key item key_var)
-  get_filename_component(item_name "${item}" NAME)
-  if(WIN32)
-    string(TOLOWER "${item_name}" item_name)
-  endif()
-  string(REGEX REPLACE "\\." "_" ${key_var} "${item_name}")
-  set(${key_var} ${${key_var}} PARENT_SCOPE)
-endfunction()
-
-
-function(clear_bundle_keys keys_var)
-  foreach(key ${${keys_var}})
-    set(${key}_ITEM PARENT_SCOPE)
-    set(${key}_RESOLVED_ITEM PARENT_SCOPE)
-    set(${key}_DEFAULT_EMBEDDED_PATH PARENT_SCOPE)
-    set(${key}_EMBEDDED_ITEM PARENT_SCOPE)
-    set(${key}_RESOLVED_EMBEDDED_ITEM PARENT_SCOPE)
-    set(${key}_COPYFLAG PARENT_SCOPE)
-  endforeach()
-  set(${keys_var} PARENT_SCOPE)
-endfunction()
-
-
-function(set_bundle_key_values keys_var context item exepath dirs copyflag)
-  get_filename_component(item_name "${item}" NAME)
-
-  get_item_key("${item}" key)
-
-  list(LENGTH ${keys_var} length_before)
-  gp_append_unique(${keys_var} "${key}")
-  list(LENGTH ${keys_var} length_after)
-
-  if(NOT length_before EQUAL length_after)
-    gp_resolve_item("${context}" "${item}" "${exepath}" "${dirs}" resolved_item)
-
-    gp_item_default_embedded_path("${item}" default_embedded_path)
-
-    if(item MATCHES "[^/]+\\.framework/")
-      # For frameworks, construct the name under the embedded path from the
-      # opening "${item_name}.framework/" to the closing "/${item_name}":
-      #
-      string(REGEX REPLACE "^.*(${item_name}.framework/.*/?${item_name}).*$" "${default_embedded_path}/\\1" embedded_item "${item}")
-    else()
-      # For other items, just use the same name as the original, but in the
-      # embedded path:
-      #
-      set(embedded_item "${default_embedded_path}/${item_name}")
-    endif()
-
-    # Replace @executable_path and resolve ".." references:
-    #
-    string(REPLACE "@executable_path" "${exepath}" resolved_embedded_item "${embedded_item}")
-    get_filename_component(resolved_embedded_item "${resolved_embedded_item}" ABSOLUTE)
-
-    # *But* -- if we are not copying, then force resolved_embedded_item to be
-    # the same as resolved_item. In the case of multiple executables in the
-    # original bundle, using the default_embedded_path results in looking for
-    # the resolved executable next to the main bundle executable. This is here
-    # so that exes in the other sibling directories (like "bin") get fixed up
-    # properly...
-    #
-    if(NOT copyflag)
-      set(resolved_embedded_item "${resolved_item}")
-    endif()
-
-    set(${keys_var} ${${keys_var}} PARENT_SCOPE)
-    set(${key}_ITEM "${item}" PARENT_SCOPE)
-    set(${key}_RESOLVED_ITEM "${resolved_item}" PARENT_SCOPE)
-    set(${key}_DEFAULT_EMBEDDED_PATH "${default_embedded_path}" PARENT_SCOPE)
-    set(${key}_EMBEDDED_ITEM "${embedded_item}" PARENT_SCOPE)
-    set(${key}_RESOLVED_EMBEDDED_ITEM "${resolved_embedded_item}" PARENT_SCOPE)
-    set(${key}_COPYFLAG "${copyflag}" PARENT_SCOPE)
-  else()
-    #message("warning: item key '${key}' already in the list, subsequent references assumed identical to first")
-  endif()
-endfunction()
-
-
-function(get_bundle_keys app libs dirs keys_var)
-  set(${keys_var} PARENT_SCOPE)
-
-  get_bundle_and_executable("${app}" bundle executable valid)
-  if(valid)
-    # Always use the exepath of the main bundle executable for @executable_path
-    # replacements:
-    #
-    get_filename_component(exepath "${executable}" PATH)
-
-    # But do fixups on all executables in the bundle:
-    #
-    get_bundle_all_executables("${bundle}" exes)
-
-    # For each extra lib, accumulate a key as well and then also accumulate
-    # any of its prerequisites. (Extra libs are typically dynamically loaded
-    # plugins: libraries that are prerequisites for full runtime functionality
-    # but that do not show up in otool -L output...)
-    #
-    foreach(lib ${libs})
-      set_bundle_key_values(${keys_var} "${lib}" "${lib}" "${exepath}" "${dirs}" 0)
-
-      set(prereqs "")
-      get_prerequisites("${lib}" prereqs 1 1 "${exepath}" "${dirs}")
-      foreach(pr ${prereqs})
-        set_bundle_key_values(${keys_var} "${lib}" "${pr}" "${exepath}" "${dirs}" 1)
-      endforeach()
-    endforeach()
-
-    # For each executable found in the bundle, accumulate keys as we go.
-    # The list of keys should be complete when all prerequisites of all
-    # binaries in the bundle have been analyzed.
-    #
-    foreach(exe ${exes})
-      # Add the exe itself to the keys:
-      #
-      set_bundle_key_values(${keys_var} "${exe}" "${exe}" "${exepath}" "${dirs}" 0)
-
-      # Add each prerequisite to the keys:
-      #
-      set(prereqs "")
-      get_prerequisites("${exe}" prereqs 1 1 "${exepath}" "${dirs}")
-      foreach(pr ${prereqs})
-        set_bundle_key_values(${keys_var} "${exe}" "${pr}" "${exepath}" "${dirs}" 1)
-      endforeach()
-    endforeach()
-
-    # Propagate values to caller's scope:
-    #
-    set(${keys_var} ${${keys_var}} PARENT_SCOPE)
-    foreach(key ${${keys_var}})
-      set(${key}_ITEM "${${key}_ITEM}" PARENT_SCOPE)
-      set(${key}_RESOLVED_ITEM "${${key}_RESOLVED_ITEM}" PARENT_SCOPE)
-      set(${key}_DEFAULT_EMBEDDED_PATH "${${key}_DEFAULT_EMBEDDED_PATH}" PARENT_SCOPE)
-      set(${key}_EMBEDDED_ITEM "${${key}_EMBEDDED_ITEM}" PARENT_SCOPE)
-      set(${key}_RESOLVED_EMBEDDED_ITEM "${${key}_RESOLVED_EMBEDDED_ITEM}" PARENT_SCOPE)
-      set(${key}_COPYFLAG "${${key}_COPYFLAG}" PARENT_SCOPE)
-    endforeach()
-  endif()
-endfunction()
-
-
-function(copy_resolved_item_into_bundle resolved_item resolved_embedded_item)
-  if(WIN32)
-    # ignore case on Windows
-    string(TOLOWER "${resolved_item}" resolved_item_compare)
-    string(TOLOWER "${resolved_embedded_item}" resolved_embedded_item_compare)
-  else()
-    set(resolved_item_compare "${resolved_item}")
-    set(resolved_embedded_item_compare "${resolved_embedded_item}")
-  endif()
-
-  if("${resolved_item_compare}" STREQUAL "${resolved_embedded_item_compare}")
-    message(STATUS "warning: resolved_item == resolved_embedded_item - not copying...")
-  else()
-    #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy ${resolved_item} ${resolved_embedded_item}")
-    execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}" "${resolved_embedded_item}")
-    if(UNIX AND NOT APPLE)
-      file(RPATH_REMOVE FILE "${resolved_embedded_item}")
-    endif()
-  endif()
-
-endfunction()
-
-
-function(copy_resolved_framework_into_bundle resolved_item resolved_embedded_item)
-  if(WIN32)
-    # ignore case on Windows
-    string(TOLOWER "${resolved_item}" resolved_item_compare)
-    string(TOLOWER "${resolved_embedded_item}" resolved_embedded_item_compare)
-  else()
-    set(resolved_item_compare "${resolved_item}")
-    set(resolved_embedded_item_compare "${resolved_embedded_item}")
-  endif()
-
-  if("${resolved_item_compare}" STREQUAL "${resolved_embedded_item_compare}")
-    message(STATUS "warning: resolved_item == resolved_embedded_item - not copying...")
-  else()
-    if(BU_COPY_FULL_FRAMEWORK_CONTENTS)
-      # Full Framework (everything):
-      get_filename_component(resolved_dir "${resolved_item}" PATH)
-      get_filename_component(resolved_dir "${resolved_dir}/../.." ABSOLUTE)
-      get_filename_component(resolved_embedded_dir "${resolved_embedded_item}" PATH)
-      get_filename_component(resolved_embedded_dir "${resolved_embedded_dir}/../.." ABSOLUTE)
-      #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy_directory '${resolved_dir}' '${resolved_embedded_dir}'")
-      execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${resolved_dir}" "${resolved_embedded_dir}")
-    else()
-      # Framework lib itself:
-      #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy ${resolved_item} ${resolved_embedded_item}")
-      execute_process(COMMAND ${CMAKE_COMMAND} -E copy "${resolved_item}" "${resolved_embedded_item}")
-
-      # Plus Resources, if they exist:
-      string(REGEX REPLACE "^(.*)/[^/]+/[^/]+/[^/]+$" "\\1/Resources" resolved_resources "${resolved_item}")
-      string(REGEX REPLACE "^(.*)/[^/]+/[^/]+/[^/]+$" "\\1/Resources" resolved_embedded_resources "${resolved_embedded_item}")
-      if(EXISTS "${resolved_resources}")
-        #message(STATUS "copying COMMAND ${CMAKE_COMMAND} -E copy_directory '${resolved_resources}' '${resolved_embedded_resources}'")
-        execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${resolved_resources}" "${resolved_embedded_resources}")
-      endif()
-    endif()
-    if(UNIX AND NOT APPLE)
-      file(RPATH_REMOVE FILE "${resolved_embedded_item}")
-    endif()
-  endif()
-
-endfunction()
-
-
-function(fixup_bundle_item resolved_embedded_item exepath dirs)
-  # This item's key is "ikey":
-  #
-  get_item_key("${resolved_embedded_item}" ikey)
-
-  # Ensure the item is "inside the .app bundle" -- it should not be fixed up if
-  # it is not in the .app bundle... Otherwise, we'll modify files in the build
-  # tree, or in other varied locations around the file system, with our call to
-  # install_name_tool. Make sure that doesn't happen here:
-  #
-  get_dotapp_dir("${exepath}" exe_dotapp_dir)
-  string(LENGTH "${exe_dotapp_dir}/" exe_dotapp_dir_length)
-  string(LENGTH "${resolved_embedded_item}" resolved_embedded_item_length)
-  set(path_too_short 0)
-  set(is_embedded 0)
-  if(${resolved_embedded_item_length} LESS ${exe_dotapp_dir_length})
-    set(path_too_short 1)
-  endif()
-  if(NOT path_too_short)
-    string(SUBSTRING "${resolved_embedded_item}" 0 ${exe_dotapp_dir_length} item_substring)
-    if("${exe_dotapp_dir}/" STREQUAL "${item_substring}")
-      set(is_embedded 1)
-    endif()
-  endif()
-  if(NOT is_embedded)
-    message("  exe_dotapp_dir/='${exe_dotapp_dir}/'")
-    message("  item_substring='${item_substring}'")
-    message("  resolved_embedded_item='${resolved_embedded_item}'")
-    message("")
-    message("Install or copy the item into the bundle before calling fixup_bundle.")
-    message("Or maybe there's a typo or incorrect path in one of the args to fixup_bundle?")
-    message("")
-    message(FATAL_ERROR "cannot fixup an item that is not in the bundle...")
-  endif()
-
-  set(prereqs "")
-  get_prerequisites("${resolved_embedded_item}" prereqs 1 0 "${exepath}" "${dirs}")
-
-  set(changes "")
-
-  foreach(pr ${prereqs})
-    # Each referenced item's key is "rkey" in the loop:
-    #
-    get_item_key("${pr}" rkey)
-
-    if(NOT "${${rkey}_EMBEDDED_ITEM}" STREQUAL "")
-      set(changes ${changes} "-change" "${pr}" "${${rkey}_EMBEDDED_ITEM}")
-    else()
-      message("warning: unexpected reference to '${pr}'")
-    endif()
-  endforeach()
-
-  if(BU_CHMOD_BUNDLE_ITEMS)
-    execute_process(COMMAND chmod u+w "${resolved_embedded_item}")
-  endif()
-
-  # Change this item's id and all of its references in one call
-  # to install_name_tool:
-  #
-  execute_process(COMMAND install_name_tool
-    ${changes} -id "${${ikey}_EMBEDDED_ITEM}" "${resolved_embedded_item}"
-  )
-endfunction()
-
-
-function(fixup_bundle app libs dirs)
-  message(STATUS "fixup_bundle")
-  message(STATUS "  app='${app}'")
-  message(STATUS "  libs='${libs}'")
-  message(STATUS "  dirs='${dirs}'")
-
-  get_bundle_and_executable("${app}" bundle executable valid)
-  if(valid)
-    get_filename_component(exepath "${executable}" PATH)
-
-    message(STATUS "fixup_bundle: preparing...")
-    get_bundle_keys("${app}" "${libs}" "${dirs}" keys)
-
-    message(STATUS "fixup_bundle: copying...")
-    list(LENGTH keys n)
-    math(EXPR n ${n}*2)
-
-    set(i 0)
-    foreach(key ${keys})
-      math(EXPR i ${i}+1)
-      if(${${key}_COPYFLAG})
-        message(STATUS "${i}/${n}: copying '${${key}_RESOLVED_ITEM}'")
-      else()
-        message(STATUS "${i}/${n}: *NOT* copying '${${key}_RESOLVED_ITEM}'")
-      endif()
-
-      set(show_status 0)
-      if(show_status)
-        message(STATUS "key='${key}'")
-        message(STATUS "item='${${key}_ITEM}'")
-        message(STATUS "resolved_item='${${key}_RESOLVED_ITEM}'")
-        message(STATUS "default_embedded_path='${${key}_DEFAULT_EMBEDDED_PATH}'")
-        message(STATUS "embedded_item='${${key}_EMBEDDED_ITEM}'")
-        message(STATUS "resolved_embedded_item='${${key}_RESOLVED_EMBEDDED_ITEM}'")
-        message(STATUS "copyflag='${${key}_COPYFLAG}'")
-        message(STATUS "")
-      endif()
-
-      if(${${key}_COPYFLAG})
-        set(item "${${key}_ITEM}")
-        if(item MATCHES "[^/]+\\.framework/")
-          copy_resolved_framework_into_bundle("${${key}_RESOLVED_ITEM}"
-            "${${key}_RESOLVED_EMBEDDED_ITEM}")
-        else()
-          copy_resolved_item_into_bundle("${${key}_RESOLVED_ITEM}"
-            "${${key}_RESOLVED_EMBEDDED_ITEM}")
-        endif()
-      endif()
-    endforeach()
-
-    message(STATUS "fixup_bundle: fixing...")
-    foreach(key ${keys})
-      math(EXPR i ${i}+1)
-      if(APPLE)
-        message(STATUS "${i}/${n}: fixing up '${${key}_RESOLVED_EMBEDDED_ITEM}'")
-        fixup_bundle_item("${${key}_RESOLVED_EMBEDDED_ITEM}" "${exepath}" "${dirs}")
-      else()
-        message(STATUS "${i}/${n}: fix-up not required on this platform '${${key}_RESOLVED_EMBEDDED_ITEM}'")
-      endif()
-    endforeach()
-
-    message(STATUS "fixup_bundle: cleaning up...")
-    clear_bundle_keys(keys)
-
-    message(STATUS "fixup_bundle: verifying...")
-    verify_app("${app}")
-  else()
-    message(SEND_ERROR "error: fixup_bundle: not a valid bundle")
-  endif()
-
-  message(STATUS "fixup_bundle: done")
-endfunction()
-
-
-function(copy_and_fixup_bundle src dst libs dirs)
-  execute_process(COMMAND ${CMAKE_COMMAND} -E copy_directory "${src}" "${dst}")
-  fixup_bundle("${dst}" "${libs}" "${dirs}")
-endfunction()
-
-
-function(verify_bundle_prerequisites bundle result_var info_var)
-  set(result 1)
-  set(info "")
-  set(count 0)
-
-  get_bundle_main_executable("${bundle}" main_bundle_exe)
-
-  file(GLOB_RECURSE file_list "${bundle}/*")
-  foreach(f ${file_list})
-    is_file_executable("${f}" is_executable)
-    if(is_executable)
-      get_filename_component(exepath "${f}" PATH)
-      math(EXPR count "${count} + 1")
-
-      message(STATUS "executable file ${count}: ${f}")
-
-      set(prereqs "")
-      get_prerequisites("${f}" prereqs 1 1 "${exepath}" "")
-
-      # On the Mac,
-      # "embedded" and "system" prerequisites are fine... anything else means
-      # the bundle's prerequisites are not verified (i.e., the bundle is not
-      # really "standalone")
-      #
-      # On Windows (and others? Linux/Unix/...?)
-      # "local" and "system" prereqs are fine...
-      #
-      set(external_prereqs "")
-
-      foreach(p ${prereqs})
-        set(p_type "")
-        gp_file_type("${f}" "${p}" p_type)
-
-        if(APPLE)
-          if(NOT "${p_type}" STREQUAL "embedded" AND NOT "${p_type}" STREQUAL "system")
-            set(external_prereqs ${external_prereqs} "${p}")
-          endif()
-        else()
-          if(NOT "${p_type}" STREQUAL "local" AND NOT "${p_type}" STREQUAL "system")
-            set(external_prereqs ${external_prereqs} "${p}")
-          endif()
-        endif()
-      endforeach()
-
-      if(external_prereqs)
-        # Found non-system/somehow-unacceptable prerequisites:
-        set(result 0)
-        set(info ${info} "external prerequisites found:\nf='${f}'\nexternal_prereqs='${external_prereqs}'\n")
-      endif()
-    endif()
-  endforeach()
-
-  if(result)
-    set(info "Verified ${count} executable files in '${bundle}'")
-  endif()
-
-  set(${result_var} "${result}" PARENT_SCOPE)
-  set(${info_var} "${info}" PARENT_SCOPE)
-endfunction()
-
-
-function(verify_bundle_symlinks bundle result_var info_var)
-  set(result 1)
-  set(info "")
-  set(count 0)
-
-  # TODO: implement this function for real...
-  # Right now, it is just a stub that verifies unconditionally...
-
-  set(${result_var} "${result}" PARENT_SCOPE)
-  set(${info_var} "${info}" PARENT_SCOPE)
-endfunction()
-
-
-function(verify_app app)
-  set(verified 0)
-  set(info "")
-
-  get_bundle_and_executable("${app}" bundle executable valid)
-
-  message(STATUS "===========================================================================")
-  message(STATUS "Analyzing app='${app}'")
-  message(STATUS "bundle='${bundle}'")
-  message(STATUS "executable='${executable}'")
-  message(STATUS "valid='${valid}'")
-
-  # Verify that the bundle does not have any "external" prerequisites:
-  #
-  verify_bundle_prerequisites("${bundle}" verified info)
-  message(STATUS "verified='${verified}'")
-  message(STATUS "info='${info}'")
-  message(STATUS "")
-
-  if(verified)
-    # Verify that the bundle does not have any symlinks to external files:
-    #
-    verify_bundle_symlinks("${bundle}" verified info)
-    message(STATUS "verified='${verified}'")
-    message(STATUS "info='${info}'")
-    message(STATUS "")
-  endif()
-
-  if(NOT verified)
-    message(FATAL_ERROR "error: verify_app failed")
-  endif()
-endfunction()

cmake/GetPrerequisites.cmake

@@ -1,902 +0,0 @@
-# - Functions to analyze and list executable file prerequisites.
-# This module provides functions to list the .dll, .dylib or .so
-# files that an executable or shared library file depends on. (Its
-# prerequisites.)
-#
-# It uses various tools to obtain the list of required shared library files:
-#   dumpbin (Windows)
-#   objdump (MinGW on Windows)
-#   ldd (Linux/Unix)
-#   otool (Mac OSX)
-# The following functions are provided by this module:
-#   get_prerequisites
-#   list_prerequisites
-#   list_prerequisites_by_glob
-#   gp_append_unique
-#   is_file_executable
-#   gp_item_default_embedded_path
-#     (projects can override with gp_item_default_embedded_path_override)
-#   gp_resolve_item
-#     (projects can override with gp_resolve_item_override)
-#   gp_resolved_file_type
-#     (projects can override with gp_resolved_file_type_override)
-#   gp_file_type
-# Requires CMake 2.6 or greater because it uses function, break, return and
-# PARENT_SCOPE.
-#
-#  GET_PREREQUISITES(<target> <prerequisites_var> <exclude_system> <recurse>
-#                    <exepath> <dirs>)
-# Get the list of shared library files required by <target>. The list in
-# the variable named <prerequisites_var> should be empty on first entry to
-# this function. On exit, <prerequisites_var> will contain the list of
-# required shared library files.
-#
-# <target> is the full path to an executable file. <prerequisites_var> is the
-# name of a CMake variable to contain the results. <exclude_system> must be 0
-# or 1 indicating whether to include or exclude "system" prerequisites. If
-# <recurse> is set to 1 all prerequisites will be found recursively, if set to
-# 0 only direct prerequisites are listed. <exepath> is the path to the top
-# level executable used for @executable_path replacment on the Mac. <dirs> is
-# a list of paths where libraries might be found: these paths are searched
-# first when a target without any path info is given. Then standard system
-# locations are also searched: PATH, Framework locations, /usr/lib...
-#
-#  LIST_PREREQUISITES(<target> [<recurse> [<exclude_system> [<verbose>]]])
-# Print a message listing the prerequisites of <target>.
-#
-# <target> is the name of a shared library or executable target or the full
-# path to a shared library or executable file. If <recurse> is set to 1 all
-# prerequisites will be found recursively, if set to 0 only direct
-# prerequisites are listed. <exclude_system> must be 0 or 1 indicating whether
-# to include or exclude "system" prerequisites. With <verbose> set to 0 only
-# the full path names of the prerequisites are printed, set to 1 extra
-# informatin will be displayed.
-#
-#  LIST_PREREQUISITES_BY_GLOB(<glob_arg> <glob_exp>)
-# Print the prerequisites of shared library and executable files matching a
-# globbing pattern. <glob_arg> is GLOB or GLOB_RECURSE and <glob_exp> is a
-# globbing expression used with "file(GLOB" or "file(GLOB_RECURSE" to retrieve
-# a list of matching files. If a matching file is executable, its prerequisites
-# are listed.
-#
-# Any additional (optional) arguments provided are passed along as the
-# optional arguments to the list_prerequisites calls.
-#
-#  GP_APPEND_UNIQUE(<list_var> <value>)
-# Append <value> to the list variable <list_var> only if the value is not
-# already in the list.
-#
-#  IS_FILE_EXECUTABLE(<file> <result_var>)
-# Return 1 in <result_var> if <file> is a binary executable, 0 otherwise.
-#
-#  GP_ITEM_DEFAULT_EMBEDDED_PATH(<item> <default_embedded_path_var>)
-# Return the path that others should refer to the item by when the item
-# is embedded inside a bundle.
-#
-# Override on a per-project basis by providing a project-specific
-# gp_item_default_embedded_path_override function.
-#
-#  GP_RESOLVE_ITEM(<context> <item> <exepath> <dirs> <resolved_item_var>)
-# Resolve an item into an existing full path file.
-#
-# Override on a per-project basis by providing a project-specific
-# gp_resolve_item_override function.
-#
-#  GP_RESOLVED_FILE_TYPE(<original_file> <file> <exepath> <dirs> <type_var>)
-# Return the type of <file> with respect to <original_file>. String
-# describing type of prerequisite is returned in variable named <type_var>.
-#
-# Use <exepath> and <dirs> if necessary to resolve non-absolute <file>
-# values -- but only for non-embedded items.
-#
-# Possible types are:
-#   system
-#   local
-#   embedded
-#   other
-# Override on a per-project basis by providing a project-specific
-# gp_resolved_file_type_override function.
-#
-#  GP_FILE_TYPE(<original_file> <file> <type_var>)
-# Return the type of <file> with respect to <original_file>. String
-# describing type of prerequisite is returned in variable named <type_var>.
-#
-# Possible types are:
-#   system
-#   local
-#   embedded
-#   other
-
-#=============================================================================
-# Copyright 2008-2009 Kitware, Inc.
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-function(gp_append_unique list_var value)
-  set(contains 0)
-
-  foreach(item ${${list_var}})
-    if("${item}" STREQUAL "${value}")
-      set(contains 1)
-      break()
-    endif()
-  endforeach()
-
-  if(NOT contains)
-    set(${list_var} ${${list_var}} "${value}" PARENT_SCOPE)
-  endif()
-endfunction()
-
-
-function(is_file_executable file result_var)
-  #
-  # A file is not executable until proven otherwise:
-  #
-  set(${result_var} 0 PARENT_SCOPE)
-
-  get_filename_component(file_full "${file}" ABSOLUTE)
-  string(TOLOWER "${file_full}" file_full_lower)
-
-  # If file name ends in .exe on Windows, *assume* executable:
-  #
-  if(WIN32 AND NOT UNIX)
-    if("${file_full_lower}" MATCHES "\\.exe$")
-      set(${result_var} 1 PARENT_SCOPE)
-      return()
-    endif()
-
-    # A clause could be added here that uses output or return value of dumpbin
-    # to determine ${result_var}. In 99%+? practical cases, the exe name
-    # match will be sufficient...
-    #
-  endif()
-
-  # Use the information returned from the Unix shell command "file" to
-  # determine if ${file_full} should be considered an executable file...
-  #
-  # If the file command's output contains "executable" and does *not* contain
-  # "text" then it is likely an executable suitable for prerequisite analysis
-  # via the get_prerequisites macro.
-  #
-  if(UNIX)
-    if(NOT file_cmd)
-      find_program(file_cmd "file")
-      mark_as_advanced(file_cmd)
-    endif()
-
-    if(file_cmd)
-      execute_process(COMMAND "${file_cmd}" "${file_full}"
-        OUTPUT_VARIABLE file_ov
-        OUTPUT_STRIP_TRAILING_WHITESPACE
-        )
-
-      # Replace the name of the file in the output with a placeholder token
-      # (the string " _file_full_ ") so that just in case the path name of
-      # the file contains the word "text" or "executable" we are not fooled
-      # into thinking "the wrong thing" because the file name matches the
-      # other 'file' command output we are looking for...
-      #
-      string(REPLACE "${file_full}" " _file_full_ " file_ov "${file_ov}")
-      string(TOLOWER "${file_ov}" file_ov)
-
-      #message(STATUS "file_ov='${file_ov}'")
-      if("${file_ov}" MATCHES "executable")
-        #message(STATUS "executable!")
-        if("${file_ov}" MATCHES "text")
-          #message(STATUS "but text, so *not* a binary executable!")
-        else()
-          set(${result_var} 1 PARENT_SCOPE)
-          return()
-        endif()
-      endif()
-
-      # Also detect position independent executables on Linux,
-      # where "file" gives "shared object ... (uses shared libraries)"
-      if("${file_ov}" MATCHES "shared object.*\(uses shared libs\)")
-        set(${result_var} 1 PARENT_SCOPE)
-        return()
-      endif()
-
-      # "file" version 5.22 does not print "(used shared libraries)"
-      # but uses "interpreter"
-      if("${file_ov}" MATCHES "shared object.*interpreter")
-        set(${result_var} 1 PARENT_SCOPE)
-        return()
-      endif()
-
-    else()
-      message(STATUS "warning: No 'file' command, skipping execute_process...")
-    endif()
-  endif()
-endfunction()
-
-
-function(gp_item_default_embedded_path item default_embedded_path_var)
-
-  # On Windows and Linux, "embed" prerequisites in the same directory
-  # as the executable by default:
-  #
-  set(path "@executable_path")
-  set(overridden 0)
-
-  # On the Mac, relative to the executable depending on the type
-  # of the thing we are embedding:
-  #
-  if(APPLE)
-    #
-    # The assumption here is that all executables in the bundle will be
-    # in same-level-directories inside the bundle. The parent directory
-    # of an executable inside the bundle should be MacOS or a sibling of
-    # MacOS and all embedded paths returned from here will begin with
-    # "@executable_path/../" and will work from all executables in all
-    # such same-level-directories inside the bundle.
-    #
-
-    # By default, embed things right next to the main bundle executable:
-    #
-    set(path "@executable_path/../../Contents/MacOS")
-
-    # Embed .dylibs right next to the main bundle executable:
-    #
-    if(item MATCHES "\\.dylib$")
-      set(path "@executable_path/../MacOS")
-      set(overridden 1)
-    endif()
-
-    # Embed frameworks in the embedded "Frameworks" directory (sibling of MacOS):
-    #
-    if(NOT overridden)
-      if(item MATCHES "[^/]+\\.framework/")
-        set(path "@executable_path/../Frameworks")
-        set(overridden 1)
-      endif()
-    endif()
-  endif()
-
-  # Provide a hook so that projects can override the default embedded location
-  # of any given library by whatever logic they choose:
-  #
-  if(COMMAND gp_item_default_embedded_path_override)
-    gp_item_default_embedded_path_override("${item}" path)
-  endif()
-
-  set(${default_embedded_path_var} "${path}" PARENT_SCOPE)
-endfunction()
-
-
-function(gp_resolve_item context item exepath dirs resolved_item_var)
-  set(resolved 0)
-  set(resolved_item "${item}")
-
-  # Is it already resolved?
-  #
-  if(IS_ABSOLUTE "${resolved_item}" AND EXISTS "${resolved_item}")
-    set(resolved 1)
-  endif()
-
-  if(NOT resolved)
-    if(item MATCHES "@executable_path")
-      #
-      # @executable_path references are assumed relative to exepath
-      #
-      string(REPLACE "@executable_path" "${exepath}" ri "${item}")
-      get_filename_component(ri "${ri}" ABSOLUTE)
-
-      if(EXISTS "${ri}")
-        #message(STATUS "info: embedded item exists (${ri})")
-        set(resolved 1)
-        set(resolved_item "${ri}")
-      else()
-        message(STATUS "warning: embedded item does not exist '${ri}'")
-      endif()
-    endif()
-  endif()
-
-  if(NOT resolved)
-    if(item MATCHES "@loader_path")
-      #
-      # @loader_path references are assumed relative to the
-      # PATH of the given "context" (presumably another library)
-      #
-      get_filename_component(contextpath "${context}" PATH)
-      string(REPLACE "@loader_path" "${contextpath}" ri "${item}")
-      get_filename_component(ri "${ri}" ABSOLUTE)
-
-      if(EXISTS "${ri}")
-        #message(STATUS "info: embedded item exists (${ri})")
-        set(resolved 1)
-        set(resolved_item "${ri}")
-      else()
-        message(STATUS "warning: embedded item does not exist '${ri}'")
-      endif()
-    endif()
-  endif()
-
-  if(NOT resolved)
-    if(item MATCHES "@rpath")
-      #
-      # @rpath references are relative to the paths built into the binaries with -rpath
-      # We handle this case like we do for other Unixes
-      #
-      string(REPLACE "@rpath/" "" norpath_item "${item}")
-
-      set(ri "ri-NOTFOUND")
-      find_file(ri "${norpath_item}" ${exepath} ${dirs} NO_DEFAULT_PATH)
-      if(ri)
-        #message(STATUS "info: 'find_file' in exepath/dirs (${ri})")
-        set(resolved 1)
-        set(resolved_item "${ri}")
-        set(ri "ri-NOTFOUND")
-      endif()
-
-    endif()
-  endif()
-
-  if(NOT resolved)
-    set(ri "ri-NOTFOUND")
-    find_file(ri "${item}" ${exepath} ${dirs} NO_DEFAULT_PATH)
-    find_file(ri "${item}" ${exepath} ${dirs} /usr/lib)
-    if(ri)
-      #message(STATUS "info: 'find_file' in exepath/dirs (${ri})")
-      set(resolved 1)
-      set(resolved_item "${ri}")
-      set(ri "ri-NOTFOUND")
-    endif()
-  endif()
-
-  if(NOT resolved)
-    if(item MATCHES "[^/]+\\.framework/")
-      set(fw "fw-NOTFOUND")
-      find_file(fw "${item}"
-        "~/Library/Frameworks"
-        "/Library/Frameworks"
-        "/System/Library/Frameworks"
-      )
-      if(fw)
-        #message(STATUS "info: 'find_file' found framework (${fw})")
-        set(resolved 1)
-        set(resolved_item "${fw}")
-        set(fw "fw-NOTFOUND")
-      endif()
-    endif()
-  endif()
-
-  # Using find_program on Windows will find dll files that are in the PATH.
-  # (Converting simple file names into full path names if found.)
-  #
-  if(WIN32 AND NOT UNIX)
-  if(NOT resolved)
-    set(ri "ri-NOTFOUND")
-    find_program(ri "${item}" PATHS "${exepath};${dirs}" NO_DEFAULT_PATH)
-    find_program(ri "${item}" PATHS "${exepath};${dirs}")
-    if(ri)
-      #message(STATUS "info: 'find_program' in exepath/dirs (${ri})")
-      set(resolved 1)
-      set(resolved_item "${ri}")
-      set(ri "ri-NOTFOUND")
-    endif()
-  endif()
-  endif()
-
-  # Provide a hook so that projects can override item resolution
-  # by whatever logic they choose:
-  #
-  if(COMMAND gp_resolve_item_override)
-    gp_resolve_item_override("${context}" "${item}" "${exepath}" "${dirs}" resolved_item resolved)
-  endif()
-
-  if(NOT resolved)
-    message(STATUS "
-warning: cannot resolve item '${item}'
-
-  possible problems:
-    need more directories?
-    need to use InstallRequiredSystemLibraries?
-    run in install tree instead of build tree?
-")
-#    message(STATUS "
-#******************************************************************************
-#warning: cannot resolve item '${item}'
-#
-#  possible problems:
-#    need more directories?
-#    need to use InstallRequiredSystemLibraries?
-#    run in install tree instead of build tree?
-#
-#    context='${context}'
-#    item='${item}'
-#    exepath='${exepath}'
-#    dirs='${dirs}'
-#    resolved_item_var='${resolved_item_var}'
-#******************************************************************************
-#")
-  endif()
-
-  set(${resolved_item_var} "${resolved_item}" PARENT_SCOPE)
-endfunction()
-
-
-function(gp_resolved_file_type original_file file exepath dirs type_var)
-  #message(STATUS "**")
-
-  if(NOT IS_ABSOLUTE "${original_file}")
-    message(STATUS "warning: gp_resolved_file_type expects absolute full path for first arg original_file")
-  endif()
-
-  set(is_embedded 0)
-  set(is_local 0)
-  set(is_system 0)
-
-  set(resolved_file "${file}")
-
-  if("${file}" MATCHES "^@(executable|loader)_path")
-    set(is_embedded 1)
-  endif()
-
-  if(NOT is_embedded)
-    if(NOT IS_ABSOLUTE "${file}")
-      gp_resolve_item("${original_file}" "${file}" "${exepath}" "${dirs}" resolved_file)
-    endif()
-
-    string(TOLOWER "${original_file}" original_lower)
-    string(TOLOWER "${resolved_file}" lower)
-
-    if(UNIX)
-      if(resolved_file MATCHES "^(/lib/|/lib32/|/lib64/|/usr/lib/|/usr/lib32/|/usr/lib64/|/usr/X11R6/|/usr/bin/)")
-        set(is_system 1)
-      endif()
-    endif()
-
-    if(APPLE)
-      if(resolved_file MATCHES "^(/System/Library/|/usr/lib/)")
-        set(is_system 1)
-      endif()
-    endif()
-
-    if(WIN32)
-      string(TOLOWER "$ENV{SystemRoot}" sysroot)
-      string(REGEX REPLACE "\\\\" "/" sysroot "${sysroot}")
-
-      string(TOLOWER "$ENV{windir}" windir)
-      string(REGEX REPLACE "\\\\" "/" windir "${windir}")
-
-      if(lower MATCHES "^(${sysroot}/sys(tem|wow)|${windir}/sys(tem|wow)|(.*/)*msvc[^/]+dll)")
-        set(is_system 1)
-      endif()
-
-      if(UNIX)
-        # if cygwin, we can get the properly formed windows paths from cygpath
-        find_program(CYGPATH_EXECUTABLE cygpath)
-
-        if(CYGPATH_EXECUTABLE)
-          execute_process(COMMAND ${CYGPATH_EXECUTABLE} -W
-                          OUTPUT_VARIABLE env_windir
-                          OUTPUT_STRIP_TRAILING_WHITESPACE)
-          execute_process(COMMAND ${CYGPATH_EXECUTABLE} -S
-                          OUTPUT_VARIABLE env_sysdir
-                          OUTPUT_STRIP_TRAILING_WHITESPACE)
-          string(TOLOWER "${env_windir}" windir)
-          string(TOLOWER "${env_sysdir}" sysroot)
-
-          if(lower MATCHES "^(${sysroot}/sys(tem|wow)|${windir}/sys(tem|wow)|(.*/)*msvc[^/]+dll)")
-            set(is_system 1)
-          endif()
-        endif()
-      endif()
-    endif()
-
-    if(NOT is_system)
-      get_filename_component(original_path "${original_lower}" PATH)
-      get_filename_component(path "${lower}" PATH)
-      if("${original_path}" STREQUAL "${path}")
-        set(is_local 1)
-      else()
-        string(LENGTH "${original_path}/" original_length)
-        string(LENGTH "${lower}" path_length)
-        if(${path_length} GREATER ${original_length})
-          string(SUBSTRING "${lower}" 0 ${original_length} path)
-          if("${original_path}/" STREQUAL "${path}")
-            set(is_embedded 1)
-          endif()
-        endif()
-      endif()
-    endif()
-  endif()
-
-  # Return type string based on computed booleans:
-  #
-  set(type "other")
-
-  if(is_system)
-    set(type "system")
-  elseif(is_embedded)
-    set(type "embedded")
-  elseif(is_local)
-    set(type "local")
-  endif()
-
-  #message(STATUS "gp_resolved_file_type: '${file}' '${resolved_file}'")
-  #message(STATUS "                type: '${type}'")
-
-  if(NOT is_embedded)
-    if(NOT IS_ABSOLUTE "${resolved_file}")
-      if(lower MATCHES "^msvc[^/]+dll" AND is_system)
-        message(STATUS "info: non-absolute msvc file '${file}' returning type '${type}'")
-      else()
-        message(STATUS "warning: gp_resolved_file_type non-absolute file '${file}' returning type '${type}' -- possibly incorrect")
-      endif()
-    endif()
-  endif()
-
-  # Provide a hook so that projects can override the decision on whether a
-  # library belongs to the system or not by whatever logic they choose:
-  #
-  if(COMMAND gp_resolved_file_type_override)
-    gp_resolved_file_type_override("${resolved_file}" type)
-  endif()
-
-  set(${type_var} "${type}" PARENT_SCOPE)
-
-  #message(STATUS "**")
-endfunction()
-
-
-function(gp_file_type original_file file type_var)
-  if(NOT IS_ABSOLUTE "${original_file}")
-    message(STATUS "warning: gp_file_type expects absolute full path for first arg original_file")
-  endif()
-
-  get_filename_component(exepath "${original_file}" PATH)
-
-  set(type "")
-  gp_resolved_file_type("${original_file}" "${file}" "${exepath}" "" type)
-
-  set(${type_var} "${type}" PARENT_SCOPE)
-endfunction()
-
-
-function(get_prerequisites target prerequisites_var exclude_system recurse exepath dirs)
-  set(verbose 0)
-  set(eol_char "E")
-
-  if(NOT IS_ABSOLUTE "${target}")
-    message("warning: target '${target}' is not absolute...")
-  endif()
-
-  if(NOT EXISTS "${target}")
-    message("warning: target '${target}' does not exist...")
-  endif()
-
-  set(gp_cmd_paths ${gp_cmd_paths}
-    "C:/Program Files/Microsoft Visual Studio 9.0/VC/bin"
-    "C:/Program Files (x86)/Microsoft Visual Studio 9.0/VC/bin"
-    "C:/Program Files/Microsoft Visual Studio 8/VC/BIN"
-    "C:/Program Files (x86)/Microsoft Visual Studio 8/VC/BIN"
-    "C:/Program Files/Microsoft Visual Studio .NET 2003/VC7/BIN"
-    "C:/Program Files (x86)/Microsoft Visual Studio .NET 2003/VC7/BIN"
-    "/usr/local/bin"
-    "/usr/bin"
-    )
-
-  # <setup-gp_tool-vars>
-  #
-  # Try to choose the right tool by default. Caller can set gp_tool prior to
-  # calling this function to force using a different tool.
-  #
-  if("${gp_tool}" STREQUAL "")
-    set(gp_tool "ldd")
-
-    if(APPLE)
-      set(gp_tool "otool")
-    endif()
-
-    if(WIN32 AND NOT UNIX) # This is how to check for cygwin, har!
-      find_program(gp_dumpbin "dumpbin" PATHS ${gp_cmd_paths})
-      if(gp_dumpbin)
-        set(gp_tool "dumpbin")
-      else() # Try harder. Maybe we're on MinGW
-        set(gp_tool "objdump")
-      endif()
-    endif()
-  endif()
-
-  find_program(gp_cmd ${gp_tool} PATHS ${gp_cmd_paths})
-
-  if(NOT gp_cmd)
-    message(FATAL_ERROR "FATAL ERROR: could not find '${gp_tool}' - cannot analyze prerequisites!")
-    return()
-  endif()
-
-  set(gp_tool_known 0)
-
-  if("${gp_tool}" STREQUAL "ldd")
-    set(gp_cmd_args "")
-    set(gp_regex "^[\t ]*[^\t ]+ => ([^\t\(]+) .*${eol_char}$")
-    set(gp_regex_error "not found${eol_char}$")
-    set(gp_regex_fallback "^[\t ]*([^\t ]+) => ([^\t ]+).*${eol_char}$")
-    set(gp_regex_cmp_count 1)
-    set(gp_tool_known 1)
-  endif()
-
-  if("${gp_tool}" STREQUAL "otool")
-    set(gp_cmd_args "-L")
-    set(gp_regex "^\t([^\t]+) \\(compatibility version ([0-9]+.[0-9]+.[0-9]+), current version ([0-9]+.[0-9]+.[0-9]+)\\)${eol_char}$")
-    set(gp_regex_error "")
-    set(gp_regex_fallback "")
-    set(gp_regex_cmp_count 3)
-    set(gp_tool_known 1)
-  endif()
-
-  if("${gp_tool}" STREQUAL "dumpbin")
-    set(gp_cmd_args "/dependents")
-    set(gp_regex "^    ([^ ].*[Dd][Ll][Ll])${eol_char}$")
-    set(gp_regex_error "")
-    set(gp_regex_fallback "")
-    set(gp_regex_cmp_count 1)
-    set(gp_tool_known 1)
-  endif()
-
-  if("${gp_tool}" STREQUAL "objdump")
-    set(gp_cmd_args "-p")
-    set(gp_regex "^\t*DLL Name: (.*\\.[Dd][Ll][Ll])${eol_char}$")
-    set(gp_regex_error "")
-    set(gp_regex_fallback "")
-    set(gp_regex_cmp_count 1)
-    set(gp_tool_known 1)
-  endif()
-
-  if(NOT gp_tool_known)
-    message(STATUS "warning: gp_tool='${gp_tool}' is an unknown tool...")
-    message(STATUS "CMake function get_prerequisites needs more code to handle '${gp_tool}'")
-    message(STATUS "Valid gp_tool values are dumpbin, ldd, objdump and otool.")
-    return()
-  endif()
-
-
-  if("${gp_tool}" STREQUAL "dumpbin")
-    # When running dumpbin, it also needs the "Common7/IDE" directory in the
-    # PATH. It will already be in the PATH if being run from a Visual Studio
-    # command prompt. Add it to the PATH here in case we are running from a
-    # different command prompt.
-    #
-    get_filename_component(gp_cmd_dir "${gp_cmd}" PATH)
-    get_filename_component(gp_cmd_dlls_dir "${gp_cmd_dir}/../../Common7/IDE" ABSOLUTE)
-    # Use cmake paths as a user may have a PATH element ending with a backslash.
-    # This will escape the list delimiter and create havoc!
-    if(EXISTS "${gp_cmd_dlls_dir}")
-      # only add to the path if it is not already in the path
-      set(gp_found_cmd_dlls_dir 0)
-      file(TO_CMAKE_PATH "$ENV{PATH}" env_path)
-      foreach(gp_env_path_element ${env_path})
-        if("${gp_env_path_element}" STREQUAL "${gp_cmd_dlls_dir}")
-          set(gp_found_cmd_dlls_dir 1)
-        endif()
-      endforeach()
-
-      if(NOT gp_found_cmd_dlls_dir)
-        file(TO_NATIVE_PATH "${gp_cmd_dlls_dir}" gp_cmd_dlls_dir)
-        set(ENV{PATH} "$ENV{PATH};${gp_cmd_dlls_dir}")
-      endif()
-    endif()
-  endif()
-  #
-  # </setup-gp_tool-vars>
-
-  if("${gp_tool}" STREQUAL "ldd")
-    set(old_ld_env "$ENV{LD_LIBRARY_PATH}")
-    foreach(dir ${exepath} ${dirs})
-      set(ENV{LD_LIBRARY_PATH} "${dir}:$ENV{LD_LIBRARY_PATH}")
-    endforeach()
-  endif()
-
-
-  # Track new prerequisites at each new level of recursion. Start with an
-  # empty list at each level:
-  #
-  set(unseen_prereqs)
-
-  # Run gp_cmd on the target:
-  #
-  execute_process(
-    COMMAND ${gp_cmd} ${gp_cmd_args} ${target}
-    OUTPUT_VARIABLE gp_cmd_ov
-    )
-
-  if("${gp_tool}" STREQUAL "ldd")
-    set(ENV{LD_LIBRARY_PATH} "${old_ld_env}")
-  endif()
-
-  if(verbose)
-    message(STATUS "<RawOutput cmd='${gp_cmd} ${gp_cmd_args} ${target}'>")
-    message(STATUS "gp_cmd_ov='${gp_cmd_ov}'")
-    message(STATUS "</RawOutput>")
-  endif()
-
-  get_filename_component(target_dir "${target}" PATH)
-
-  # Convert to a list of lines:
-  #
-  string(REGEX REPLACE ";" "\\\\;" candidates "${gp_cmd_ov}")
-  string(REGEX REPLACE "\n" "${eol_char};" candidates "${candidates}")
-
-  # check for install id and remove it from list, since otool -L can include a
-  # reference to itself
-  set(gp_install_id)
-  if("${gp_tool}" STREQUAL "otool")
-    execute_process(
-      COMMAND otool -D ${target}
-      OUTPUT_VARIABLE gp_install_id_ov
-      )
-    # second line is install name
-    string(REGEX REPLACE ".*:\n" "" gp_install_id "${gp_install_id_ov}")
-    if(gp_install_id)
-      # trim
-      string(REGEX MATCH "[^\n ].*[^\n ]" gp_install_id "${gp_install_id}")
-      #message("INSTALL ID is \"${gp_install_id}\"")
-    endif()
-  endif()
-
-  # Analyze each line for file names that match the regular expression:
-  #
-  foreach(candidate ${candidates})
-  if("${candidate}" MATCHES "${gp_regex}")
-
-    # Extract information from each candidate:
-    if(gp_regex_error AND "${candidate}" MATCHES "${gp_regex_error}")
-      string(REGEX REPLACE "${gp_regex_fallback}" "\\1" raw_item "${candidate}")
-    else()
-      string(REGEX REPLACE "${gp_regex}" "\\1" raw_item "${candidate}")
-    endif()
-
-    if(gp_regex_cmp_count GREATER 1)
-      string(REGEX REPLACE "${gp_regex}" "\\2" raw_compat_version "${candidate}")
-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" compat_major_version "${raw_compat_version}")
-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" compat_minor_version "${raw_compat_version}")
-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" compat_patch_version "${raw_compat_version}")
-    endif()
-
-    if(gp_regex_cmp_count GREATER 2)
-      string(REGEX REPLACE "${gp_regex}" "\\3" raw_current_version "${candidate}")
-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\1" current_major_version "${raw_current_version}")
-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\2" current_minor_version "${raw_current_version}")
-      string(REGEX REPLACE "^([0-9]+)\\.([0-9]+)\\.([0-9]+)$" "\\3" current_patch_version "${raw_current_version}")
-    endif()
-
-    # Use the raw_item as the list entries returned by this function. Use the
-    # gp_resolve_item function to resolve it to an actual full path file if
-    # necessary.
-    #
-    set(item "${raw_item}")
-
-    # Add each item unless it is excluded:
-    #
-    set(add_item 1)
-
-    if("${item}" STREQUAL "${gp_install_id}")
-      set(add_item 0)
-    endif()
-
-    if(add_item AND ${exclude_system})
-      set(type "")
-      gp_resolved_file_type("${target}" "${item}" "${exepath}" "${dirs}" type)
-
-      if("${type}" STREQUAL "system")
-        set(add_item 0)
-      endif()
-    endif()
-
-    if(add_item)
-      list(LENGTH ${prerequisites_var} list_length_before_append)
-      gp_append_unique(${prerequisites_var} "${item}")
-      list(LENGTH ${prerequisites_var} list_length_after_append)
-
-      if(${recurse})
-        # If item was really added, this is the first time we have seen it.
-        # Add it to unseen_prereqs so that we can recursively add *its*
-        # prerequisites...
-        #
-        # But first: resolve its name to an absolute full path name such
-        # that the analysis tools can simply accept it as input.
-        #
-        if(NOT list_length_before_append EQUAL list_length_after_append)
-          gp_resolve_item("${target}" "${item}" "${exepath}" "${dirs}" resolved_item)
-          set(unseen_prereqs ${unseen_prereqs} "${resolved_item}")
-        endif()
-      endif()
-    endif()
-  else()
-    if(verbose)
-      message(STATUS "ignoring non-matching line: '${candidate}'")
-    endif()
-  endif()
-  endforeach()
-
-  list(LENGTH ${prerequisites_var} prerequisites_var_length)
-  if(prerequisites_var_length GREATER 0)
-    list(SORT ${prerequisites_var})
-  endif()
-  if(${recurse})
-    set(more_inputs ${unseen_prereqs})
-    foreach(input ${more_inputs})
-      get_prerequisites("${input}" ${prerequisites_var} ${exclude_system} ${recurse} "${exepath}" "${dirs}")
-    endforeach()
-  endif()
-
-  set(${prerequisites_var} ${${prerequisites_var}} PARENT_SCOPE)
-endfunction()
-
-
-function(list_prerequisites target)
-  if("${ARGV1}" STREQUAL "")
-    set(all 1)
-  else()
-    set(all "${ARGV1}")
-  endif()
-
-  if("${ARGV2}" STREQUAL "")
-    set(exclude_system 0)
-  else()
-    set(exclude_system "${ARGV2}")
-  endif()
-
-  if("${ARGV3}" STREQUAL "")
-    set(verbose 0)
-  else()
-    set(verbose "${ARGV3}")
-  endif()
-
-  set(count 0)
-  set(count_str "")
-  set(print_count "${verbose}")
-  set(print_prerequisite_type "${verbose}")
-  set(print_target "${verbose}")
-  set(type_str "")
-
-  get_filename_component(exepath "${target}" PATH)
-
-  set(prereqs "")
-  get_prerequisites("${target}" prereqs ${exclude_system} ${all} "${exepath}" "")
-
-  if(print_target)
-    message(STATUS "File '${target}' depends on:")
-  endif()
-
-  foreach(d ${prereqs})
-    math(EXPR count "${count} + 1")
-
-    if(print_count)
-      set(count_str "${count}. ")
-    endif()
-
-    if(print_prerequisite_type)
-      gp_file_type("${target}" "${d}" type)
-      set(type_str " (${type})")
-    endif()
-
-    message(STATUS "${count_str}${d}${type_str}")
-  endforeach()
-endfunction()
-
-
-function(list_prerequisites_by_glob glob_arg glob_exp)
-  message(STATUS "=============================================================================")
-  message(STATUS "List prerequisites of executables matching ${glob_arg} '${glob_exp}'")
-  message(STATUS "")
-  file(${glob_arg} file_list ${glob_exp})
-  foreach(f ${file_list})
-    is_file_executable("${f}" is_f_executable)
-    if(is_f_executable)
-      message(STATUS "=============================================================================")
-      list_prerequisites("${f}" ${ARGN})
-      message(STATUS "")
-    endif()
-  endforeach()
-endfunction()

cmake/MacOSXBundleInfo.plist.in

@@ -2,10 +2,10 @@
 <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
-	<key>NSCameraUsageDescription</key>
-	<string>A Minecraft mod wants to access your camera.</string>
-	<key>NSMicrophoneUsageDescription</key>
-	<string>A Minecraft mod wants to access your microphone.</string>
+    <key>NSCameraUsageDescription</key>
+    <string>A Minecraft mod wants to access your camera.</string>
+    <key>NSMicrophoneUsageDescription</key>
+    <string>A Minecraft mod wants to access your microphone.</string>
     <key>NSPrincipalClass</key>
     <string>NSApplication</string>
     <key>NSHighResolutionCapable</key>

cmake/UseJava.cmake

@@ -1,881 +0,0 @@
-# - Use Module for Java
-# This file provides functions for Java. It is assumed that FindJava.cmake
-# has already been loaded.  See FindJava.cmake for information on how to
-# load Java into your CMake project.
-#
-# add_jar(TARGET_NAME SRC1 SRC2 .. SRCN RCS1 RCS2 .. RCSN)
-#
-# This command creates a <TARGET_NAME>.jar. It compiles the given source
-# files (SRC) and adds the given resource files (RCS) to the jar file.
-# If only resource files are given then just a jar file is created.
-#
-# Additional instructions:
-#   To add compile flags to the target you can set these flags with
-#   the following variable:
-#
-#       set(CMAKE_JAVA_COMPILE_FLAGS -nowarn)
-#
-#   To add a path or a jar file to the class path you can do this
-#   with the CMAKE_JAVA_INCLUDE_PATH variable.
-#
-#       set(CMAKE_JAVA_INCLUDE_PATH /usr/share/java/shibboleet.jar)
-#
-#   To use a different output name for the target you can set it with:
-#
-#       set(CMAKE_JAVA_TARGET_OUTPUT_NAME shibboleet.jar)
-#       add_jar(foobar foobar.java)
-#
-#   To use a different output directory than CMAKE_CURRENT_BINARY_DIR
-#   you can set it with:
-#
-#       set(CMAKE_JAVA_TARGET_OUTPUT_DIR ${PROJECT_BINARY_DIR}/bin)
-#
-#   To define an entry point in your jar you can set it with:
-#
-#       set(CMAKE_JAVA_JAR_ENTRY_POINT com/examples/MyProject/Main)
-#
-#   To add a VERSION to the target output name you can set it using
-#   CMAKE_JAVA_TARGET_VERSION. This will create a jar file with the name
-#   shibboleet-1.0.0.jar and will create a symlink shibboleet.jar
-#   pointing to the jar with the version information.
-#
-#       set(CMAKE_JAVA_TARGET_VERSION 1.2.0)
-#       add_jar(shibboleet shibbotleet.java)
-#
-#    If the target is a JNI library, utilize the following commands to
-#    create a JNI symbolic link:
-#
-#       set(CMAKE_JNI_TARGET TRUE)
-#       set(CMAKE_JAVA_TARGET_VERSION 1.2.0)
-#       add_jar(shibboleet shibbotleet.java)
-#       install_jar(shibboleet ${LIB_INSTALL_DIR}/shibboleet)
-#       install_jni_symlink(shibboleet ${JAVA_LIB_INSTALL_DIR})
-#
-#    If a single target needs to produce more than one jar from its
-#    java source code, to prevent the accumulation of duplicate class
-#    files in subsequent jars, set/reset CMAKE_JAR_CLASSES_PREFIX prior
-#    to calling the add_jar() function:
-#
-#       set(CMAKE_JAR_CLASSES_PREFIX com/redhat/foo)
-#       add_jar(foo foo.java)
-#
-#       set(CMAKE_JAR_CLASSES_PREFIX com/redhat/bar)
-#       add_jar(bar bar.java)
-#
-# Target Properties:
-#   The add_jar() functions sets some target properties. You can get these
-#   properties with the
-#      get_property(TARGET <target_name> PROPERTY <propery_name>)
-#   command.
-#
-#   INSTALL_FILES      The files which should be installed. This is used by
-#                      install_jar().
-#   JNI_SYMLINK        The JNI symlink which should be installed.
-#                      This is used by install_jni_symlink().
-#   JAR_FILE           The location of the jar file so that you can include
-#                      it.
-#   CLASS_DIR          The directory where the class files can be found. For
-#                      example to use them with javah.
-#
-# find_jar(<VAR>
-#          name | NAMES name1 [name2 ...]
-#          [PATHS path1 [path2 ... ENV var]]
-#          [VERSIONS version1 [version2]]
-#          [DOC "cache documentation string"]
-#         )
-#
-# This command is used to find a full path to the named jar. A cache
-# entry named by <VAR> is created to stor the result of this command. If
-# the full path to a jar is found the result is stored in the variable
-# and the search will not repeated unless the variable is cleared. If
-# nothing is found, the result will be <VAR>-NOTFOUND, and the search
-# will be attempted again next time find_jar is invoked with the same
-# variable.
-# The name of the full path to a file that is searched for is specified
-# by the names listed after NAMES argument. Additional search locations
-# can be specified after the PATHS argument. If you require special a
-# version of a jar file you can specify it with the VERSIONS argument.
-# The argument after DOC will be used for the documentation string in
-# the cache.
-#
-# install_jar(TARGET_NAME DESTINATION)
-#
-# This command installs the TARGET_NAME files to the given DESTINATION.
-# It should be called in the same scope as add_jar() or it will fail.
-#
-# install_jni_symlink(TARGET_NAME DESTINATION)
-#
-# This command installs the TARGET_NAME JNI symlinks to the given
-# DESTINATION. It should be called in the same scope as add_jar()
-# or it will fail.
-#
-# create_javadoc(<VAR>
-#                PACKAGES pkg1 [pkg2 ...]
-#                [SOURCEPATH <sourcepath>]
-#                [CLASSPATH <classpath>]
-#                [INSTALLPATH <install path>]
-#                [DOCTITLE "the documentation title"]
-#                [WINDOWTITLE "the title of the document"]
-#                [AUTHOR TRUE|FALSE]
-#                [USE TRUE|FALSE]
-#                [VERSION TRUE|FALSE]
-#               )
-#
-# Create java documentation based on files or packages. For more
-# details please read the javadoc manpage.
-#
-# There are two main signatures for create_javadoc. The first
-# signature works with package names on a path with source files:
-#
-#   Example:
-#   create_javadoc(my_example_doc
-#     PACKAGES com.exmaple.foo com.example.bar
-#     SOURCEPATH "${CMAKE_CURRENT_SOURCE_DIR}"
-#     CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
-#     WINDOWTITLE "My example"
-#     DOCTITLE "<h1>My example</h1>"
-#     AUTHOR TRUE
-#     USE TRUE
-#     VERSION TRUE
-#   )
-#
-# The second signature for create_javadoc works on a given list of
-# files.
-#
-#   create_javadoc(<VAR>
-#                  FILES file1 [file2 ...]
-#                  [CLASSPATH <classpath>]
-#                  [INSTALLPATH <install path>]
-#                  [DOCTITLE "the documentation title"]
-#                  [WINDOWTITLE "the title of the document"]
-#                  [AUTHOR TRUE|FALSE]
-#                  [USE TRUE|FALSE]
-#                  [VERSION TRUE|FALSE]
-#                 )
-#
-# Example:
-#   create_javadoc(my_example_doc
-#     FILES ${example_SRCS}
-#     CLASSPATH ${CMAKE_JAVA_INCLUDE_PATH}
-#     WINDOWTITLE "My example"
-#     DOCTITLE "<h1>My example</h1>"
-#     AUTHOR TRUE
-#     USE TRUE
-#     VERSION TRUE
-#   )
-#
-# Both signatures share most of the options. These options are the
-# same as what you can find in the javadoc manpage. Please look at
-# the manpage for CLASSPATH, DOCTITLE, WINDOWTITLE, AUTHOR, USE and
-# VERSION.
-#
-# The documentation will be by default installed to
-#
-#   ${CMAKE_INSTALL_PREFIX}/share/javadoc/<VAR>
-#
-# if you don't set the INSTALLPATH.
-#
-
-#=============================================================================
-# Copyright 2010-2011 Andreas schneider <asn@redhat.com>
-# Copyright 2010 Ben Boeckel <ben.boeckel@kitware.com>
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-function (__java_copy_file src dest comment)
-    add_custom_command(
-        OUTPUT  ${dest}
-        COMMAND cmake -E copy_if_different
-        ARGS    ${src}
-                ${dest}
-        DEPENDS ${src}
-        COMMENT ${comment})
-endfunction (__java_copy_file src dest comment)
-
-# define helper scripts
-set(_JAVA_CLASS_FILELIST_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJavaClassFilelist.cmake)
-set(_JAVA_SYMLINK_SCRIPT ${CMAKE_CURRENT_LIST_DIR}/UseJavaSymlinks.cmake)
-
-function(add_jar _TARGET_NAME)
-    set(_JAVA_SOURCE_FILES ${ARGN})
-
-    if (NOT DEFINED CMAKE_JAVA_TARGET_OUTPUT_DIR)
-      set(CMAKE_JAVA_TARGET_OUTPUT_DIR ${CMAKE_CURRENT_BINARY_DIR})
-    endif(NOT DEFINED CMAKE_JAVA_TARGET_OUTPUT_DIR)
-
-    if (CMAKE_JAVA_JAR_ENTRY_POINT)
-      set(_ENTRY_POINT_OPTION e)
-      set(_ENTRY_POINT_VALUE ${CMAKE_JAVA_JAR_ENTRY_POINT})
-    endif (CMAKE_JAVA_JAR_ENTRY_POINT)
-
-    if (LIBRARY_OUTPUT_PATH)
-        set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${LIBRARY_OUTPUT_PATH})
-    else (LIBRARY_OUTPUT_PATH)
-        set(CMAKE_JAVA_LIBRARY_OUTPUT_PATH ${CMAKE_JAVA_TARGET_OUTPUT_DIR})
-    endif (LIBRARY_OUTPUT_PATH)
-
-    set(CMAKE_JAVA_INCLUDE_PATH
-        ${CMAKE_JAVA_INCLUDE_PATH}
-        ${CMAKE_CURRENT_SOURCE_DIR}
-        ${CMAKE_JAVA_OBJECT_OUTPUT_PATH}
-        ${CMAKE_JAVA_LIBRARY_OUTPUT_PATH}
-    )
-
-    if (WIN32 AND NOT CYGWIN AND NOT CMAKE_CROSSCOMPILING)
-        set(CMAKE_JAVA_INCLUDE_FLAG_SEP ";")
-    else ()
-        set(CMAKE_JAVA_INCLUDE_FLAG_SEP ":")
-    endif()
-
-    foreach (JAVA_INCLUDE_DIR ${CMAKE_JAVA_INCLUDE_PATH})
-       set(CMAKE_JAVA_INCLUDE_PATH_FINAL "${CMAKE_JAVA_INCLUDE_PATH_FINAL}${CMAKE_JAVA_INCLUDE_FLAG_SEP}${JAVA_INCLUDE_DIR}")
-    endforeach(JAVA_INCLUDE_DIR)
-
-    set(CMAKE_JAVA_CLASS_OUTPUT_PATH "${CMAKE_JAVA_TARGET_OUTPUT_DIR}${CMAKE_FILES_DIRECTORY}/${_TARGET_NAME}.dir")
-
-    set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}.jar")
-    if (CMAKE_JAVA_TARGET_OUTPUT_NAME AND CMAKE_JAVA_TARGET_VERSION)
-        set(_JAVA_TARGET_OUTPUT_NAME "${CMAKE_JAVA_TARGET_OUTPUT_NAME}-${CMAKE_JAVA_TARGET_VERSION}.jar")
-        set(_JAVA_TARGET_OUTPUT_LINK "${CMAKE_JAVA_TARGET_OUTPUT_NAME}.jar")
-    elseif (CMAKE_JAVA_TARGET_VERSION)
-        set(_JAVA_TARGET_OUTPUT_NAME "${_TARGET_NAME}-${CMAKE_JAVA_TARGET_VERSION}.jar")
-        set(_JAVA_TARGET_OUTPUT_LINK "${_TARGET_NAME}.jar")
-    elseif (CMAKE_JAVA_TARGET_OUTPUT_NAME)
-        set(_JAVA_TARGET_OUTPUT_NAME "${CMAKE_JAVA_TARGET_OUTPUT_NAME}.jar")
-    endif (CMAKE_JAVA_TARGET_OUTPUT_NAME AND CMAKE_JAVA_TARGET_VERSION)
-    # reset
-    set(CMAKE_JAVA_TARGET_OUTPUT_NAME)
-
-    set(_JAVA_CLASS_FILES)
-    set(_JAVA_COMPILE_FILES)
-    set(_JAVA_DEPENDS)
-    set(_JAVA_RESOURCE_FILES)
-    foreach(_JAVA_SOURCE_FILE ${_JAVA_SOURCE_FILES})
-        get_filename_component(_JAVA_EXT ${_JAVA_SOURCE_FILE} EXT)
-        get_filename_component(_JAVA_FILE ${_JAVA_SOURCE_FILE} NAME_WE)
-        get_filename_component(_JAVA_PATH ${_JAVA_SOURCE_FILE} PATH)
-        get_filename_component(_JAVA_FULL ${_JAVA_SOURCE_FILE} ABSOLUTE)
-
-        file(RELATIVE_PATH _JAVA_REL_BINARY_PATH ${CMAKE_JAVA_TARGET_OUTPUT_DIR} ${_JAVA_FULL})
-        file(RELATIVE_PATH _JAVA_REL_SOURCE_PATH ${CMAKE_CURRENT_SOURCE_DIR} ${_JAVA_FULL})
-        string(LENGTH ${_JAVA_REL_BINARY_PATH} _BIN_LEN)
-        string(LENGTH ${_JAVA_REL_SOURCE_PATH} _SRC_LEN)
-        if (${_BIN_LEN} LESS ${_SRC_LEN})
-            set(_JAVA_REL_PATH ${_JAVA_REL_BINARY_PATH})
-        else (${_BIN_LEN} LESS ${_SRC_LEN})
-            set(_JAVA_REL_PATH ${_JAVA_REL_SOURCE_PATH})
-        endif (${_BIN_LEN} LESS ${_SRC_LEN})
-        get_filename_component(_JAVA_REL_PATH ${_JAVA_REL_PATH} PATH)
-
-        if (_JAVA_EXT MATCHES ".java")
-            list(APPEND _JAVA_COMPILE_FILES ${_JAVA_SOURCE_FILE})
-            set(_JAVA_CLASS_FILE "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_REL_PATH}/${_JAVA_FILE}.class")
-            set(_JAVA_CLASS_FILES ${_JAVA_CLASS_FILES} ${_JAVA_CLASS_FILE})
-
-        elseif (_JAVA_EXT MATCHES ".jar"
-                OR _JAVA_EXT MATCHES ".war"
-                OR _JAVA_EXT MATCHES ".ear"
-                OR _JAVA_EXT MATCHES ".sar")
-            list(APPEND CMAKE_JAVA_INCLUDE_PATH ${_JAVA_SOURCE_FILE})
-
-        elseif (_JAVA_EXT STREQUAL "")
-            list(APPEND CMAKE_JAVA_INCLUDE_PATH ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}} ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}_CLASSPATH})
-            list(APPEND _JAVA_DEPENDS ${JAVA_JAR_TARGET_${_JAVA_SOURCE_FILE}})
-
-        else (_JAVA_EXT MATCHES ".java")
-            __java_copy_file(${CMAKE_CURRENT_SOURCE_DIR}/${_JAVA_SOURCE_FILE}
-                             ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${_JAVA_SOURCE_FILE}
-                             "Copying ${_JAVA_SOURCE_FILE} to the build directory")
-            list(APPEND _JAVA_RESOURCE_FILES ${_JAVA_SOURCE_FILE})
-        endif (_JAVA_EXT MATCHES ".java")
-    endforeach(_JAVA_SOURCE_FILE)
-
-    # create an empty java_class_filelist
-    if (NOT EXISTS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist)
-        file(WRITE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist "")
-    endif()
-
-    if (_JAVA_COMPILE_FILES)
-        # Compile the java files and create a list of class files
-        add_custom_command(
-            # NOTE: this command generates an artificial dependency file
-            OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
-            COMMAND ${Java_JAVAC_EXECUTABLE}
-                ${CMAKE_JAVA_COMPILE_FLAGS}
-                -classpath "${CMAKE_JAVA_INCLUDE_PATH_FINAL}"
-                -d ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
-                ${_JAVA_COMPILE_FILES}
-            COMMAND ${CMAKE_COMMAND} -E touch ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
-            DEPENDS ${_JAVA_COMPILE_FILES}
-            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-            COMMENT "Building Java objects for ${_TARGET_NAME}.jar"
-        )
-        add_custom_command(
-            OUTPUT ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
-            COMMAND ${CMAKE_COMMAND}
-                -DCMAKE_JAVA_CLASS_OUTPUT_PATH=${CMAKE_JAVA_CLASS_OUTPUT_PATH}
-                -DCMAKE_JAR_CLASSES_PREFIX="${CMAKE_JAR_CLASSES_PREFIX}"
-                -P ${_JAVA_CLASS_FILELIST_SCRIPT}
-            DEPENDS ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_compiled_${_TARGET_NAME}
-            WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-        )
-    endif (_JAVA_COMPILE_FILES)
-
-    # create the jar file
-    set(_JAVA_JAR_OUTPUT_PATH
-      ${CMAKE_JAVA_TARGET_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_NAME})
-    if (CMAKE_JNI_TARGET)
-        add_custom_command(
-            OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
-            COMMAND ${Java_JAR_EXECUTABLE}
-                -cf${_ENTRY_POINT_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE}
-                ${_JAVA_RESOURCE_FILES} @java_class_filelist
-            COMMAND ${CMAKE_COMMAND}
-                -D_JAVA_TARGET_DIR=${CMAKE_JAVA_TARGET_OUTPUT_DIR}
-                -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
-                -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
-                -P ${_JAVA_SYMLINK_SCRIPT}
-            COMMAND ${CMAKE_COMMAND}
-                -D_JAVA_TARGET_DIR=${CMAKE_JAVA_TARGET_OUTPUT_DIR}
-                -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_JAR_OUTPUT_PATH}
-                -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
-                -P ${_JAVA_SYMLINK_SCRIPT}
-            DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
-            WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
-            COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
-        )
-    else ()
-        add_custom_command(
-            OUTPUT ${_JAVA_JAR_OUTPUT_PATH}
-            COMMAND ${Java_JAR_EXECUTABLE}
-                -cf${_ENTRY_POINT_OPTION} ${_JAVA_JAR_OUTPUT_PATH} ${_ENTRY_POINT_VALUE}
-                ${_JAVA_RESOURCE_FILES} @java_class_filelist
-            COMMAND ${CMAKE_COMMAND}
-                -D_JAVA_TARGET_DIR=${CMAKE_JAVA_TARGET_OUTPUT_DIR}
-                -D_JAVA_TARGET_OUTPUT_NAME=${_JAVA_TARGET_OUTPUT_NAME}
-                -D_JAVA_TARGET_OUTPUT_LINK=${_JAVA_TARGET_OUTPUT_LINK}
-                -P ${_JAVA_SYMLINK_SCRIPT}
-            WORKING_DIRECTORY ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
-            DEPENDS ${_JAVA_RESOURCE_FILES} ${_JAVA_DEPENDS} ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist
-            COMMENT "Creating Java archive ${_JAVA_TARGET_OUTPUT_NAME}"
-        )
-    endif (CMAKE_JNI_TARGET)
-
-    # Add the target and make sure we have the latest resource files.
-    add_custom_target(${_TARGET_NAME} ALL DEPENDS ${_JAVA_JAR_OUTPUT_PATH})
-
-    set_property(
-        TARGET
-            ${_TARGET_NAME}
-        PROPERTY
-            INSTALL_FILES
-                ${_JAVA_JAR_OUTPUT_PATH}
-    )
-
-    if (_JAVA_TARGET_OUTPUT_LINK)
-        set_property(
-            TARGET
-                ${_TARGET_NAME}
-            PROPERTY
-                INSTALL_FILES
-                    ${_JAVA_JAR_OUTPUT_PATH}
-                    ${CMAKE_JAVA_TARGET_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
-        )
-
-        if (CMAKE_JNI_TARGET)
-            set_property(
-                TARGET
-                    ${_TARGET_NAME}
-                PROPERTY
-                    JNI_SYMLINK
-                        ${CMAKE_JAVA_TARGET_OUTPUT_DIR}/${_JAVA_TARGET_OUTPUT_LINK}
-            )
-        endif (CMAKE_JNI_TARGET)
-    endif (_JAVA_TARGET_OUTPUT_LINK)
-
-    set_property(
-        TARGET
-            ${_TARGET_NAME}
-        PROPERTY
-            JAR_FILE
-                ${_JAVA_JAR_OUTPUT_PATH}
-    )
-
-    set_property(
-        TARGET
-            ${_TARGET_NAME}
-        PROPERTY
-            CLASSDIR
-                ${CMAKE_JAVA_CLASS_OUTPUT_PATH}
-    )
-
-endfunction(add_jar)
-
-function(INSTALL_JAR _TARGET_NAME _DESTINATION)
-    get_property(__FILES
-        TARGET
-            ${_TARGET_NAME}
-        PROPERTY
-            INSTALL_FILES
-    )
-
-    if (__FILES)
-        install(
-            FILES
-                ${__FILES}
-            DESTINATION
-                ${_DESTINATION}
-        )
-    else (__FILES)
-        message(SEND_ERROR "The target ${_TARGET_NAME} is not known in this scope.")
-    endif (__FILES)
-endfunction(INSTALL_JAR _TARGET_NAME _DESTINATION)
-
-function(INSTALL_JNI_SYMLINK _TARGET_NAME _DESTINATION)
-    get_property(__SYMLINK
-        TARGET
-            ${_TARGET_NAME}
-        PROPERTY
-            JNI_SYMLINK
-    )
-
-    if (__SYMLINK)
-        install(
-            FILES
-                ${__SYMLINK}
-            DESTINATION
-                ${_DESTINATION}
-        )
-    else (__SYMLINK)
-        message(SEND_ERROR "The target ${_TARGET_NAME} is not known in this scope.")
-    endif (__SYMLINK)
-endfunction(INSTALL_JNI_SYMLINK _TARGET_NAME _DESTINATION)
-
-function (find_jar VARIABLE)
-    set(_jar_names)
-    set(_jar_files)
-    set(_jar_versions)
-    set(_jar_paths
-        /usr/share/java/
-        /usr/local/share/java/
-        ${Java_JAR_PATHS})
-    set(_jar_doc "NOTSET")
-
-    set(_state "name")
-
-    foreach (arg ${ARGN})
-        if (${_state} STREQUAL "name")
-            if (${arg} STREQUAL "VERSIONS")
-                set(_state "versions")
-            elseif (${arg} STREQUAL "NAMES")
-                set(_state "names")
-            elseif (${arg} STREQUAL "PATHS")
-                set(_state "paths")
-            elseif (${arg} STREQUAL "DOC")
-                set(_state "doc")
-            else (${arg} STREQUAL "NAMES")
-                set(_jar_names ${arg})
-                if (_jar_doc STREQUAL "NOTSET")
-                    set(_jar_doc "Finding ${arg} jar")
-                endif (_jar_doc STREQUAL "NOTSET")
-            endif (${arg} STREQUAL "VERSIONS")
-        elseif (${_state} STREQUAL "versions")
-            if (${arg} STREQUAL "NAMES")
-                set(_state "names")
-            elseif (${arg} STREQUAL "PATHS")
-                set(_state "paths")
-            elseif (${arg} STREQUAL "DOC")
-                set(_state "doc")
-            else (${arg} STREQUAL "NAMES")
-                set(_jar_versions ${_jar_versions} ${arg})
-            endif (${arg} STREQUAL "NAMES")
-        elseif (${_state} STREQUAL "names")
-            if (${arg} STREQUAL "VERSIONS")
-                set(_state "versions")
-            elseif (${arg} STREQUAL "PATHS")
-                set(_state "paths")
-            elseif (${arg} STREQUAL "DOC")
-                set(_state "doc")
-            else (${arg} STREQUAL "VERSIONS")
-                set(_jar_names ${_jar_names} ${arg})
-                if (_jar_doc STREQUAL "NOTSET")
-                    set(_jar_doc "Finding ${arg} jar")
-                endif (_jar_doc STREQUAL "NOTSET")
-            endif (${arg} STREQUAL "VERSIONS")
-        elseif (${_state} STREQUAL "paths")
-            if (${arg} STREQUAL "VERSIONS")
-                set(_state "versions")
-            elseif (${arg} STREQUAL "NAMES")
-                set(_state "names")
-            elseif (${arg} STREQUAL "DOC")
-                set(_state "doc")
-            else (${arg} STREQUAL "VERSIONS")
-                set(_jar_paths ${_jar_paths} ${arg})
-            endif (${arg} STREQUAL "VERSIONS")
-        elseif (${_state} STREQUAL "doc")
-            if (${arg} STREQUAL "VERSIONS")
-                set(_state "versions")
-            elseif (${arg} STREQUAL "NAMES")
-                set(_state "names")
-            elseif (${arg} STREQUAL "PATHS")
-                set(_state "paths")
-            else (${arg} STREQUAL "VERSIONS")
-                set(_jar_doc ${arg})
-            endif (${arg} STREQUAL "VERSIONS")
-        endif (${_state} STREQUAL "name")
-    endforeach (arg ${ARGN})
-
-    if (NOT _jar_names)
-        message(FATAL_ERROR "find_jar: No name to search for given")
-    endif (NOT _jar_names)
-
-    foreach (jar_name ${_jar_names})
-        foreach (version ${_jar_versions})
-            set(_jar_files ${_jar_files} ${jar_name}-${version}.jar)
-        endforeach (version ${_jar_versions})
-        set(_jar_files ${_jar_files} ${jar_name}.jar)
-    endforeach (jar_name ${_jar_names})
-
-    find_file(${VARIABLE}
-        NAMES   ${_jar_files}
-        PATHS   ${_jar_paths}
-        DOC     ${_jar_doc}
-        NO_DEFAULT_PATH)
-endfunction (find_jar VARIABLE)
-
-function(create_javadoc _target)
-    set(_javadoc_packages)
-    set(_javadoc_files)
-    set(_javadoc_sourcepath)
-    set(_javadoc_classpath)
-    set(_javadoc_installpath "${CMAKE_INSTALL_PREFIX}/share/javadoc")
-    set(_javadoc_doctitle)
-    set(_javadoc_windowtitle)
-    set(_javadoc_author FALSE)
-    set(_javadoc_version FALSE)
-    set(_javadoc_use FALSE)
-
-    set(_state "package")
-
-    foreach (arg ${ARGN})
-        if (${_state} STREQUAL "package")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "CLASSPATH")
-                set(_state "classpath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                set(_javadoc_packages ${arg})
-                set(_state "packages")
-            endif ()
-        elseif (${_state} STREQUAL "packages")
-            if (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "CLASSPATH")
-                set(_state "classpath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                list(APPEND _javadoc_packages ${arg})
-            endif ()
-        elseif (${_state} STREQUAL "files")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "CLASSPATH")
-                set(_state "classpath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                list(APPEND _javadoc_files ${arg})
-            endif ()
-        elseif (${_state} STREQUAL "sourcepath")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "CLASSPATH")
-                set(_state "classpath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                list(APPEND _javadoc_sourcepath ${arg})
-            endif ()
-        elseif (${_state} STREQUAL "classpath")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                list(APPEND _javadoc_classpath ${arg})
-            endif ()
-        elseif (${_state} STREQUAL "installpath")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                set(_javadoc_installpath ${arg})
-            endif ()
-        elseif (${_state} STREQUAL "doctitle")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "CLASSPATH")
-                set(_state "classpath")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                set(_javadoc_doctitle ${arg})
-            endif ()
-        elseif (${_state} STREQUAL "windowtitle")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "CLASSPATH")
-                set(_state "classpath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                set(_javadoc_windowtitle ${arg})
-            endif ()
-        elseif (${_state} STREQUAL "author")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "CLASSPATH")
-                set(_state "classpath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                set(_javadoc_author ${arg})
-            endif ()
-        elseif (${_state} STREQUAL "use")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "CLASSPATH")
-                set(_state "classpath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                set(_javadoc_use ${arg})
-            endif ()
-        elseif (${_state} STREQUAL "version")
-            if (${arg} STREQUAL "PACKAGES")
-                set(_state "packages")
-            elseif (${arg} STREQUAL "FILES")
-                set(_state "files")
-            elseif (${arg} STREQUAL "SOURCEPATH")
-                set(_state "sourcepath")
-            elseif (${arg} STREQUAL "CLASSPATH")
-                set(_state "classpath")
-            elseif (${arg} STREQUAL "INSTALLPATH")
-                set(_state "installpath")
-            elseif (${arg} STREQUAL "DOCTITLE")
-                set(_state "doctitle")
-            elseif (${arg} STREQUAL "WINDOWTITLE")
-                set(_state "windowtitle")
-            elseif (${arg} STREQUAL "AUTHOR")
-                set(_state "author")
-            elseif (${arg} STREQUAL "USE")
-                set(_state "use")
-            elseif (${arg} STREQUAL "VERSION")
-                set(_state "version")
-            else ()
-                set(_javadoc_version ${arg})
-            endif ()
-        endif (${_state} STREQUAL "package")
-    endforeach (arg ${ARGN})
-
-    set(_javadoc_builddir ${CMAKE_CURRENT_BINARY_DIR}/javadoc/${_target})
-    set(_javadoc_options -d ${_javadoc_builddir})
-
-    if (_javadoc_sourcepath)
-        set(_start TRUE)
-        foreach(_path ${_javadoc_sourcepath})
-            if (_start)
-                set(_sourcepath ${_path})
-                set(_start FALSE)
-            else (_start)
-                set(_sourcepath ${_sourcepath}:${_path})
-            endif (_start)
-        endforeach(_path ${_javadoc_sourcepath})
-        set(_javadoc_options ${_javadoc_options} -sourcepath ${_sourcepath})
-    endif (_javadoc_sourcepath)
-
-    if (_javadoc_classpath)
-        set(_start TRUE)
-        foreach(_path ${_javadoc_classpath})
-            if (_start)
-                set(_classpath ${_path})
-                set(_start FALSE)
-            else (_start)
-                set(_classpath ${_classpath}:${_path})
-            endif (_start)
-        endforeach(_path ${_javadoc_classpath})
-        set(_javadoc_options ${_javadoc_options} -classpath "${_classpath}")
-    endif (_javadoc_classpath)
-
-    if (_javadoc_doctitle)
-        set(_javadoc_options ${_javadoc_options} -doctitle '${_javadoc_doctitle}')
-    endif (_javadoc_doctitle)
-
-    if (_javadoc_windowtitle)
-        set(_javadoc_options ${_javadoc_options} -windowtitle '${_javadoc_windowtitle}')
-    endif (_javadoc_windowtitle)
-
-    if (_javadoc_author)
-        set(_javadoc_options ${_javadoc_options} -author)
-    endif (_javadoc_author)
-
-    if (_javadoc_use)
-        set(_javadoc_options ${_javadoc_options} -use)
-    endif (_javadoc_use)
-
-    if (_javadoc_version)
-        set(_javadoc_options ${_javadoc_options} -version)
-    endif (_javadoc_version)
-
-    add_custom_target(${_target}_javadoc ALL
-        COMMAND ${Java_JAVADOC_EXECUTABLE} ${_javadoc_options}
-                            ${_javadoc_files}
-                            ${_javadoc_packages}
-        WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
-    )
-
-    install(
-        DIRECTORY ${_javadoc_builddir}
-        DESTINATION ${_javadoc_installpath}
-    )
-endfunction(create_javadoc)

cmake/UseJavaClassFilelist.cmake

@@ -1,52 +0,0 @@
-#
-# This script create a list of compiled Java class files to be added to a
-# jar file. This avoids including cmake files which get created in the
-# binary directory.
-#
-
-#=============================================================================
-# Copyright 2010-2011 Andreas schneider <asn@redhat.com>
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-if (CMAKE_JAVA_CLASS_OUTPUT_PATH)
-    if (EXISTS "${CMAKE_JAVA_CLASS_OUTPUT_PATH}")
-
-        set(_JAVA_GLOBBED_FILES)
-        if (CMAKE_JAR_CLASSES_PREFIX)
-            foreach(JAR_CLASS_PREFIX ${CMAKE_JAR_CLASSES_PREFIX})
-                message(STATUS "JAR_CLASS_PREFIX: ${JAR_CLASS_PREFIX}")
-
-                file(GLOB_RECURSE _JAVA_GLOBBED_TMP_FILES "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/${JAR_CLASS_PREFIX}/*.class")
-                if (_JAVA_GLOBBED_TMP_FILES)
-                    list(APPEND _JAVA_GLOBBED_FILES ${_JAVA_GLOBBED_TMP_FILES})
-                endif (_JAVA_GLOBBED_TMP_FILES)
-            endforeach(JAR_CLASS_PREFIX ${CMAKE_JAR_CLASSES_PREFIX})
-        else()
-            file(GLOB_RECURSE _JAVA_GLOBBED_FILES "${CMAKE_JAVA_CLASS_OUTPUT_PATH}/*.class")
-        endif (CMAKE_JAR_CLASSES_PREFIX)
-
-        set(_JAVA_CLASS_FILES)
-        # file(GLOB_RECURSE foo RELATIVE) is broken so we need this.
-        foreach(_JAVA_GLOBBED_FILE ${_JAVA_GLOBBED_FILES})
-            file(RELATIVE_PATH _JAVA_CLASS_FILE ${CMAKE_JAVA_CLASS_OUTPUT_PATH} ${_JAVA_GLOBBED_FILE})
-            set(_JAVA_CLASS_FILES ${_JAVA_CLASS_FILES}${_JAVA_CLASS_FILE}\n)
-        endforeach(_JAVA_GLOBBED_FILE ${_JAVA_GLOBBED_FILES})
-
-        # write to file
-        file(WRITE ${CMAKE_JAVA_CLASS_OUTPUT_PATH}/java_class_filelist ${_JAVA_CLASS_FILES})
-
-    else (EXISTS "${CMAKE_JAVA_CLASS_OUTPUT_PATH}")
-        message(SEND_ERROR "FATAL: Java class output path doesn't exist")
-    endif (EXISTS "${CMAKE_JAVA_CLASS_OUTPUT_PATH}")
-else (CMAKE_JAVA_CLASS_OUTPUT_PATH)
-    message(SEND_ERROR "FATAL: Can't find CMAKE_JAVA_CLASS_OUTPUT_PATH")
-endif (CMAKE_JAVA_CLASS_OUTPUT_PATH)

cmake/UseJavaSymlinks.cmake

@@ -1,32 +0,0 @@
-#
-# Helper script for UseJava.cmake
-#
-
-#=============================================================================
-# Copyright 2010-2011 Andreas schneider <asn@redhat.com>
-#
-# Distributed under the OSI-approved BSD License (the "License");
-# see accompanying file Copyright.txt for details.
-#
-# This software is distributed WITHOUT ANY WARRANTY; without even the
-# implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
-# See the License for more information.
-#=============================================================================
-# (To distribute this file outside of CMake, substitute the full
-#  License text for the above reference.)
-
-if (UNIX AND _JAVA_TARGET_OUTPUT_LINK)
-    if (_JAVA_TARGET_OUTPUT_NAME)
-        find_program(LN_EXECUTABLE
-            NAMES
-                ln
-        )
-
-        execute_process(
-            COMMAND ${LN_EXECUTABLE} -sf "${_JAVA_TARGET_OUTPUT_NAME}" "${_JAVA_TARGET_OUTPUT_LINK}"
-            WORKING_DIRECTORY ${_JAVA_TARGET_DIR}
-        )
-    else (_JAVA_TARGET_OUTPUT_NAME)
-        message(SEND_ERROR "FATAL: Can't find _JAVA_TARGET_OUTPUT_NAME")
-    endif (_JAVA_TARGET_OUTPUT_NAME)
-endif (UNIX AND _JAVA_TARGET_OUTPUT_LINK)

default.nix

@@ -1 +1 @@
-(import packages/nix/flake-compat.nix).defaultNix
+(import nix/flake-compat.nix).defaultNix

flake.lock

@@ -3,11 +3,11 @@
     "flake-compat": {
       "flake": false,
       "locked": {
-        "lastModified": 1648199409,
-        "narHash": "sha256-JwPKdC2PoVBkG6E+eWw3j6BMR6sL3COpYWfif7RVb8Y=",
+        "lastModified": 1650374568,
+        "narHash": "sha256-Z+s0J8/r907g149rllvwhb4pKi8Wam5ij0st8PwAh+E=",
         "owner": "edolstra",
         "repo": "flake-compat",
-        "rev": "64a525ee38886ab9028e6f61790de0832aa3ef03",
+        "rev": "b4a34015c698c7793d592d66adbab377907a2be8",
         "type": "github"
       },
       "original": {
@@ -34,11 +34,11 @@
     },
     "nixpkgs": {
       "locked": {
-        "lastModified": 1648219316,
-        "narHash": "sha256-Ctij+dOi0ZZIfX5eMhgwugfvB+WZSrvVNAyAuANOsnQ=",
+        "lastModified": 1654665288,
+        "narHash": "sha256-7blJpfoZEu7GKb84uh3io/5eSJNdaagXD9d15P9iQMs=",
         "owner": "nixos",
         "repo": "nixpkgs",
-        "rev": "30d3d79b7d3607d56546dd2a6b49e156ba0ec634",
+        "rev": "43ecbe7840d155fa933ee8a500fb00dbbc651fc8",
         "type": "github"
       },
       "original": {
@@ -48,28 +48,11 @@
         "type": "github"
       }
     },
-    "quazip": {
-      "flake": false,
-      "locked": {
-        "lastModified": 1643049383,
-        "narHash": "sha256-LcJY6yd6GyeL7X5MP4L94diceM1TYespWByliBsjK98=",
-        "owner": "stachenov",
-        "repo": "quazip",
-        "rev": "09ec1d10c6d627f895109b21728dda000cbfa7d1",
-        "type": "github"
-      },
-      "original": {
-        "owner": "stachenov",
-        "repo": "quazip",
-        "type": "github"
-      }
-    },
     "root": {
       "inputs": {
         "flake-compat": "flake-compat",
         "libnbtplusplus": "libnbtplusplus",
-        "nixpkgs": "nixpkgs",
-        "quazip": "quazip"
+        "nixpkgs": "nixpkgs"
       }
     }
   },

flake.nix

@@ -5,10 +5,9 @@
     nixpkgs.url = "github:nixos/nixpkgs/nixpkgs-unstable";
     flake-compat = { url = "github:edolstra/flake-compat"; flake = false; };
     libnbtplusplus = { url = "github:multimc/libnbtplusplus"; flake = false; };
-    quazip = { url = "github:stachenov/quazip"; flake = false; };
   };
 
-  outputs = { self, nixpkgs, libnbtplusplus, quazip, ... }:
+  outputs = { self, nixpkgs, libnbtplusplus, ... }:
     let
       # Generate a user-friendly version number.
       version = builtins.substring 0 8 self.lastModifiedDate;
@@ -23,11 +22,17 @@
       pkgs = forAllSystems (system: nixpkgs.legacyPackages.${system});
     in
     {
-      packages = forAllSystems (system: { polymc = pkgs.${system}.libsForQt5.callPackage ./packages/nix/polymc { inherit version self quazip libnbtplusplus; }; });
-      defaultPackage = forAllSystems (system: self.packages.${system}.polymc);
+      packages = forAllSystems (system: rec {
+        polymc = pkgs.${system}.libsForQt5.callPackage ./nix { inherit version self libnbtplusplus; };
+        polymc-qt6 = pkgs.${system}.qt6Packages.callPackage ./nix { inherit version self libnbtplusplus; };
         
-      apps = forAllSystems (system: { polymc = { type = "app"; program = "${self.defaultPackage.${system}}/bin/polymc"; }; });
-      defaultApp = forAllSystems (system: self.apps.${system}.polymc);
+        default = polymc;
+      });
+
+      defaultPackage = forAllSystems (system: self.packages.${system}.default);
+
+      apps = forAllSystems (system: rec { polymc = { type = "app"; program = "${self.defaultPackage.${system}}/bin/polymc"; }; default = polymc; });
+      defaultApp = forAllSystems (system: self.apps.${system}.default);
 
       overlay = final: prev: { polymc = self.defaultPackage.${final.system}; };
     };

launcher/Application.cpp

@@ -2,6 +2,7 @@
 /*
  *  PolyMC - Minecraft Launcher
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2022 Lenny McLennington <lenny@sneed.church>
  *
  *  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
@@ -36,6 +37,7 @@
 #include "Application.h"
 #include "BuildConfig.h"
 
+#include "net/PasteUpload.h"
 #include "ui/MainWindow.h"
 #include "ui/InstanceWindow.h"
 
@@ -61,6 +63,7 @@
 #include "ui/setupwizard/SetupWizard.h"
 #include "ui/setupwizard/LanguageWizardPage.h"
 #include "ui/setupwizard/JavaWizardPage.h"
+#include "ui/setupwizard/PasteWizardPage.h"
 
 #include "ui/dialogs/CustomMessageBox.h"
 
@@ -223,9 +226,7 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
     setApplicationName(BuildConfig.LAUNCHER_NAME);
     setApplicationDisplayName(BuildConfig.LAUNCHER_DISPLAYNAME);
     setApplicationVersion(BuildConfig.printableVersionString());
-    #if (QT_VERSION >= QT_VERSION_CHECK(5,7,0))
-        setDesktopFileName(BuildConfig.LAUNCHER_DESKTOPFILENAME);
-    #endif
+    setDesktopFileName(BuildConfig.LAUNCHER_DESKTOPFILENAME);
     startTime = QDateTime::currentDateTime();
 
     // Don't quit on hiding the last window
@@ -409,69 +410,6 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
         return;
     }
 
-#if defined(Q_OS_MAC)
-    // move user data to new location if on macOS and it still exists in Contents/MacOS
-    QDir fi(applicationDirPath());
-    QString originalData = fi.absolutePath();
-    // if the config file exists in Contents/MacOS, then user data is still there and needs to moved
-    if (QFileInfo::exists(FS::PathCombine(originalData, BuildConfig.LAUNCHER_CONFIGFILE)))
-    {
-        if (!QFileInfo::exists(FS::PathCombine(originalData, "dontmovemacdata")))
-        {
-            QMessageBox::StandardButton askMoveDialogue;
-            askMoveDialogue = QMessageBox::question(
-                nullptr,
-                BuildConfig.LAUNCHER_DISPLAYNAME,
-                "Would you like to move application data to a new data location? It will improve the launcher's performance, but if you switch to older versions it will look like instances have disappeared. If you select no, you can migrate later in settings. You should select yes unless you're commonly switching between different versions (eg. develop and stable).",
-                QMessageBox::Yes | QMessageBox::No,
-                QMessageBox::Yes
-            );
-            if (askMoveDialogue == QMessageBox::Yes)
-            {
-                qDebug() << "On macOS and found config file in old location, moving user data...";
-                QDir dir;
-                QStringList dataFiles {
-                    "*.log", // Launcher log files: ${Launcher_Name}-@.log
-                    "accounts.json",
-                    "accounts",
-                    "assets",
-                    "cache",
-                    "icons",
-                    "instances",
-                    "libraries",
-                    "meta",
-                    "metacache",
-                    "mods",
-                    BuildConfig.LAUNCHER_CONFIGFILE,
-                    "themes",
-                    "translations"
-                };
-                QDirIterator files(originalData, dataFiles);
-                while (files.hasNext()) {
-                    QString filePath(files.next());
-                    QString fileName(files.fileName());
-                    if (!dir.rename(filePath, FS::PathCombine(dataPath, fileName)))
-                    {
-                        qWarning() << "Failed to move " << fileName;
-                    }
-                }
-            }
-            else
-            {
-                dataPath = originalData;
-                QDir::setCurrent(dataPath);
-                QFile file(originalData + "/dontmovemacdata");
-                file.open(QIODevice::WriteOnly);
-            }
-        }
-        else
-        {
-            dataPath = originalData;
-            QDir::setCurrent(dataPath);
-        }
-    }
-#endif
-
     /*
      * Establish the mechanism for communication with an already running PolyMC that uses the same data path.
      * If there is one, tell it what the user actually wanted to do and exit.
@@ -691,6 +629,7 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
         m_settings->registerSetting("LastHostname", "");
         m_settings->registerSetting("JvmArgs", "");
         m_settings->registerSetting("IgnoreJavaCompatibility", false);
+        m_settings->registerSetting("IgnoreJavaWizard", false);
 
         // Native library workarounds
         m_settings->registerSetting("UseNativeOpenAL", false);
@@ -735,14 +674,40 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
 
         m_settings->registerSetting("UpdateDialogGeometry", "");
 
-        // pastebin URL
-        m_settings->registerSetting("PastebinURL", "https://0x0.st");
+        // HACK: This code feels so stupid is there a less stupid way of doing this?
+        {
+            m_settings->registerSetting("PastebinURL", "");
+            m_settings->registerSetting("PastebinType", PasteUpload::PasteType::Mclogs);
+            m_settings->registerSetting("PastebinCustomAPIBase", "");
+
+            QString pastebinURL = m_settings->get("PastebinURL").toString();
+
+            bool userHadDefaultPastebin = pastebinURL == "https://0x0.st";
+            if (!pastebinURL.isEmpty() && !userHadDefaultPastebin)
+            {
+                m_settings->set("PastebinType", PasteUpload::PasteType::NullPointer);
+                m_settings->set("PastebinCustomAPIBase", pastebinURL);
+                m_settings->reset("PastebinURL");
+            }
+
+            bool ok;
+            int pasteType = m_settings->get("PastebinType").toInt(&ok);
+            // 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");
+            }
+        }
+        // meta URL
+        m_settings->registerSetting("MetaURLOverride", "");
 
         m_settings->registerSetting("CloseAfterLaunch", false);
         m_settings->registerSetting("QuitAfterGameStop", false);
 
         // Custom MSA credentials
         m_settings->registerSetting("MSAClientIDOverride", "");
+        m_settings->registerSetting("CFKeyOverride", "");
 
         // Init page provider
         {
@@ -881,6 +846,7 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
         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("ModrinthPacks", QDir("cache/ModrinthPacks").absolutePath());
         m_metacache->addBase("root", QDir::currentPath());
         m_metacache->addBase("translations", QDir("translations").absolutePath());
         m_metacache->addBase("icons", QDir("cache/icons").absolutePath());
@@ -905,6 +871,12 @@ Application::Application(int &argc, char **argv) : QApplication(argc, argv)
         m_mcedit.reset(new MCEditTool(m_settings));
     }
 
+#ifdef Q_OS_MACOS
+    connect(this, &Application::clickedOnDock, [this]() {
+        this->showMainWindow();
+    });
+#endif
+
     connect(this, &Application::aboutToQuit, [this](){
         if(m_instances)
         {
@@ -936,6 +908,10 @@ bool Application::createSetupWizard()
 {
     bool javaRequired = [&]()
     {
+        bool ignoreJavaWizard = m_settings->get("IgnoreJavaWizard").toBool();
+        if(ignoreJavaWizard) {
+            return false;
+        }
         QString currentHostName = QHostInfo::localHostName();
         QString oldHostName = settings()->get("LastHostname").toString();
         if (currentHostName != oldHostName)
@@ -957,7 +933,8 @@ bool Application::createSetupWizard()
             return true;
         return false;
     }();
-    bool wizardRequired = javaRequired || languageRequired;
+    bool pasteInterventionRequired = settings()->get("PastebinURL") != "";
+    bool wizardRequired = javaRequired || languageRequired || pasteInterventionRequired;
 
     if(wizardRequired)
     {
@@ -966,10 +943,16 @@ bool Application::createSetupWizard()
         {
             m_setupWizard->addPage(new LanguageWizardPage(m_setupWizard));
         }
+
         if (javaRequired)
         {
             m_setupWizard->addPage(new JavaWizardPage(m_setupWizard));
         }
+
+        if (pasteInterventionRequired)
+        {
+            m_setupWizard->addPage(new PasteWizardPage(m_setupWizard));
+        }
         connect(m_setupWizard, &QDialog::finished, this, &Application::setupWizardFinished);
         m_setupWizard->show();
         return true;
@@ -977,6 +960,21 @@ bool Application::createSetupWizard()
     return false;
 }
 
+bool Application::event(QEvent* event) {
+#ifdef Q_OS_MACOS
+    if (event->type() == QEvent::ApplicationStateChange) {
+        auto ev = static_cast<QApplicationStateChangeEvent*>(event);
+
+        if (m_prevAppState == Qt::ApplicationActive
+                && ev->applicationState() == Qt::ApplicationActive) {
+            emit clickedOnDock();
+        }
+        m_prevAppState = ev->applicationState();
+    }
+#endif
+    return QApplication::event(event);
+}
+
 void Application::setupWizardFinished(int status)
 {
     qDebug() << "Wizard result =" << status;
@@ -1566,3 +1564,13 @@ QString Application::getMSAClientID()
 
     return BuildConfig.MSA_CLIENT_ID;
 }
+
+QString Application::getCurseKey()
+{
+    QString keyOverride = m_settings->get("CFKeyOverride").toString();
+    if (!keyOverride.isEmpty()) {
+        return keyOverride;
+    }
+
+    return BuildConfig.CURSEFORGE_API_KEY;
+}

launcher/Application.h

@@ -94,6 +94,8 @@ public:
     Application(int &argc, char **argv);
     virtual ~Application();
 
+    bool event(QEvent* event) override;
+
     std::shared_ptr<SettingsObject> settings() const {
         return m_settings;
     }
@@ -155,6 +157,7 @@ public:
     QString getJarsPath();
 
     QString getMSAClientID();
+    QString getCurseKey();
 
     /// this is the root of the 'installation'. Used for automatic updates
     const QString &root() {
@@ -180,6 +183,10 @@ signals:
     void globalSettingsAboutToOpen();
     void globalSettingsClosed();
 
+#ifdef Q_OS_MACOS
+    void clickedOnDock();
+#endif
+
 public slots:
     bool launch(
         InstancePtr instance,
@@ -237,6 +244,10 @@ private:
     QString m_rootPath;
     Status m_status = Application::StartingUp;
 
+#ifdef Q_OS_MACOS
+    Qt::ApplicationState m_prevAppState = Qt::ApplicationInactive;
+#endif
+
 #if defined Q_OS_WIN32
     // used on Windows to attach the standard IO streams
     bool consoleAttached = false;

launcher/BaseInstance.cpp

@@ -59,7 +59,11 @@ BaseInstance::BaseInstance(SettingsObjectPtr globalSettings, SettingsObjectPtr s
     m_settings->registerSetting("lastLaunchTime", 0);
     m_settings->registerSetting("totalTimePlayed", 0);
     m_settings->registerSetting("lastTimePlayed", 0);
-    m_settings->registerSetting("InstanceType", "OneSix");
+
+    // NOTE: Sometimees InstanceType is already registered, as it was used to identify the type of
+    // a locally stored instance
+    if (!m_settings->getSetting("InstanceType"))
+        m_settings->registerSetting("InstanceType", "");
 
     // Custom Commands
     auto commandSetting = m_settings->registerSetting({"OverrideCommands","OverrideLaunchCmd"}, false);

launcher/CMakeLists.txt

@@ -128,6 +128,8 @@ set(NET_SOURCES
     net/PasteUpload.h
     net/Sink.h
     net/Validator.h
+    net/Upload.cpp
+    net/Upload.h
 )
 
 # Game launch logic
@@ -235,6 +237,8 @@ set(MINECRAFT_SOURCES
     minecraft/auth/steps/MigrationEligibilityStep.h
     minecraft/auth/steps/MinecraftProfileStep.cpp
     minecraft/auth/steps/MinecraftProfileStep.h
+    minecraft/auth/steps/MinecraftProfileStepMojang.cpp
+    minecraft/auth/steps/MinecraftProfileStepMojang.h
     minecraft/auth/steps/MSAStep.cpp
     minecraft/auth/steps/MSAStep.h
     minecraft/auth/steps/XboxAuthorizationStep.cpp
@@ -530,6 +534,8 @@ set(FLAME_SOURCES
 set(MODRINTH_SOURCES
     modplatform/modrinth/ModrinthPackIndex.cpp
     modplatform/modrinth/ModrinthPackIndex.h
+    modplatform/modrinth/ModrinthPackManifest.cpp
+    modplatform/modrinth/ModrinthPackManifest.h
 )
 
 set(MODPACKSCH_SOURCES
@@ -557,6 +563,8 @@ set(ATLAUNCHER_SOURCES
     modplatform/atlauncher/ATLPackInstallTask.h
     modplatform/atlauncher/ATLPackManifest.cpp
     modplatform/atlauncher/ATLPackManifest.h
+    modplatform/atlauncher/ATLShareCode.cpp
+    modplatform/atlauncher/ATLShareCode.h
 )
 
 add_unit_test(Index
@@ -655,6 +663,8 @@ SET(LAUNCHER_SOURCES
     ui/setupwizard/JavaWizardPage.h
     ui/setupwizard/LanguageWizardPage.cpp
     ui/setupwizard/LanguageWizardPage.h
+    ui/setupwizard/PasteWizardPage.cpp
+    ui/setupwizard/PasteWizardPage.h
 
     # GUI - themes
     ui/themes/FusionTheme.cpp
@@ -770,6 +780,11 @@ SET(LAUNCHER_SOURCES
     ui/pages/modplatform/flame/FlameModPage.cpp
     ui/pages/modplatform/flame/FlameModPage.h
 
+    ui/pages/modplatform/modrinth/ModrinthPage.cpp
+    ui/pages/modplatform/modrinth/ModrinthPage.h
+    ui/pages/modplatform/modrinth/ModrinthModel.cpp
+    ui/pages/modplatform/modrinth/ModrinthModel.h
+
     ui/pages/modplatform/technic/TechnicModel.cpp
     ui/pages/modplatform/technic/TechnicModel.h
     ui/pages/modplatform/technic/TechnicPage.cpp
@@ -778,10 +793,10 @@ SET(LAUNCHER_SOURCES
     ui/pages/modplatform/ImportPage.cpp
     ui/pages/modplatform/ImportPage.h
 
-    ui/pages/modplatform/modrinth/ModrinthModel.cpp
-    ui/pages/modplatform/modrinth/ModrinthModel.h
-    ui/pages/modplatform/modrinth/ModrinthPage.cpp
-    ui/pages/modplatform/modrinth/ModrinthPage.h
+    ui/pages/modplatform/modrinth/ModrinthModModel.cpp
+    ui/pages/modplatform/modrinth/ModrinthModModel.h
+    ui/pages/modplatform/modrinth/ModrinthModPage.cpp
+    ui/pages/modplatform/modrinth/ModrinthModPage.h
 
     # GUI - dialogs
     ui/dialogs/AboutDialog.cpp
@@ -824,6 +839,8 @@ SET(LAUNCHER_SOURCES
     ui/dialogs/SkinUploadDialog.h
     ui/dialogs/ModDownloadDialog.cpp
     ui/dialogs/ModDownloadDialog.h
+    ui/dialogs/ScrollMessageBox.cpp
+    ui/dialogs/ScrollMessageBox.h
 
     # GUI - widgets
     ui/widgets/Common.cpp
@@ -879,6 +896,7 @@ SET(LAUNCHER_SOURCES
 )
 
 qt5_wrap_ui(LAUNCHER_UI
+    ui/setupwizard/PasteWizardPage.ui
     ui/pages/global/AccountListPage.ui
     ui/pages/global/JavaPage.ui
     ui/pages/global/LauncherPage.ui
@@ -904,6 +922,7 @@ qt5_wrap_ui(LAUNCHER_UI
     ui/pages/modplatform/legacy_ftb/Page.ui
     ui/pages/modplatform/ImportPage.ui
     ui/pages/modplatform/ftb/FtbPage.ui
+    ui/pages/modplatform/modrinth/ModrinthPage.ui
     ui/pages/modplatform/technic/TechnicPage.ui
     ui/widgets/InstanceCardWidget.ui
     ui/widgets/CustomCommands.ui
@@ -925,6 +944,7 @@ qt5_wrap_ui(LAUNCHER_UI
     ui/dialogs/LoginDialog.ui
     ui/dialogs/EditAccountDialog.ui
     ui/dialogs/ReviewMessageBox.ui
+    ui/dialogs/ScrollMessageBox.ui
 )
 
 qt5_add_resources(LAUNCHER_RESOURCES
@@ -943,7 +963,7 @@ qt5_add_resources(LAUNCHER_RESOURCES
 
 ######## Windows resource files ########
 if(WIN32)
-    set(LAUNCHER_RCS ../${Launcher_Branding_WindowsRC})
+    set(LAUNCHER_RCS ${CMAKE_CURRENT_BINARY_DIR}/../${Launcher_Branding_WindowsRC})
 endif()
 
 # Add executable

launcher/FileSystem.cpp

@@ -454,4 +454,47 @@ bool createShortCut(QString location, QString dest, QStringList args, QString na
     return false;
 #endif
 }
+
+QStringList listFolderPaths(QDir root)
+{
+    auto createAbsPath = [](QFileInfo const& entry) { return FS::PathCombine(entry.path(), entry.fileName()); };
+
+    QStringList entries;
+
+    root.refresh();
+    for (auto entry : root.entryInfoList(QDir::Filter::Files)) {
+        entries.append(createAbsPath(entry));
+    }
+
+    for (auto entry : root.entryInfoList(QDir::Filter::AllDirs | QDir::Filter::NoDotAndDotDot)) {
+        entries.append(listFolderPaths(createAbsPath(entry)));
+    }
+
+    return entries;
+}
+
+bool overrideFolder(QString overwritten_path, QString override_path)
+{
+    if (!FS::ensureFolderPathExists(overwritten_path))
+        return false;
+
+    QStringList paths_to_override;
+    QDir root_override (override_path);
+    for (auto file : listFolderPaths(root_override)) {
+        QString destination = file;
+        destination.replace(override_path, overwritten_path);
+
+        qDebug() << QString("Applying override %1 in %2").arg(file, destination);
+
+        if (QFile::exists(destination))
+            QFile::remove(destination);
+        if (!QFile::rename(file, destination)) {
+            qCritical() << QString("Failed to apply override from %1 to %2").arg(file, destination);
+            return false;
+        }
+    }
+
+    return true;
+}
+
 }

launcher/FileSystem.h

@@ -124,4 +124,8 @@ QString getDesktopDir();
 // call it *name* and assign it the icon *icon*
 // return true if operation succeeded
 bool createShortCut(QString location, QString dest, QStringList args, QString name, QString iconLocation);
+
+// Overrides one folder with the contents of another, preserving items exclusive to the first folder
+// Equivalent to doing QDir::rename, but allowing for overrides
+bool overrideFolder(QString overwritten_path, QString override_path);
 }

launcher/InstanceImportTask.cpp

@@ -1,48 +1,79 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #include "InstanceImportTask.h"
+#include <QtConcurrentRun>
+#include "Application.h"
 #include "BaseInstance.h"
 #include "FileSystem.h"
-#include "Application.h"
 #include "MMCZip.h"
 #include "NullInstance.h"
-#include "settings/INISettingsObject.h"
+#include "icons/IconList.h"
 #include "icons/IconUtils.h"
-#include <QtConcurrentRun>
+#include "settings/INISettingsObject.h"
 
 // FIXME: this does not belong here, it's Minecraft/Flame specific
+#include <quazip/quazipdir.h>
+#include "Json.h"
 #include "minecraft/MinecraftInstance.h"
 #include "minecraft/PackProfile.h"
 #include "modplatform/flame/FileResolvingTask.h"
 #include "modplatform/flame/PackManifest.h"
-#include "Json.h"
-#include <quazip/quazipdir.h>
+#include "modplatform/modrinth/ModrinthPackManifest.h"
 #include "modplatform/technic/TechnicPackProcessor.h"
 
-#include "icons/IconList.h"
 #include "Application.h"
+#include "icons/IconList.h"
+#include "net/ChecksumValidator.h"
 
-InstanceImportTask::InstanceImportTask(const QUrl sourceUrl)
+#include "ui/dialogs/CustomMessageBox.h"
+#include "ui/dialogs/ScrollMessageBox.h"
+
+#include <algorithm>
+
+InstanceImportTask::InstanceImportTask(const QUrl sourceUrl, QWidget* parent)
 {
     m_sourceUrl = sourceUrl;
+    m_parent = parent;
 }
 
 bool InstanceImportTask::abort()
 {
-    m_filesNetJob->abort();
+    if (m_filesNetJob)
+        m_filesNetJob->abort();
     m_extractFuture.cancel();
 
     return false;
@@ -105,17 +136,20 @@ void InstanceImportTask::processZipPack()
         return;
     }
 
-    QStringList blacklist = {"instance.cfg", "manifest.json"};
-    QString mmcFound = MMCZip::findFolderOfFileInZip(m_packZip.get(), "instance.cfg");
-    bool technicFound = QuaZipDir(m_packZip.get()).exists("/bin/modpack.jar") || QuaZipDir(m_packZip.get()).exists("/bin/version.json");
-    QString flameFound = MMCZip::findFolderOfFileInZip(m_packZip.get(), "manifest.json");
+    QuaZipDir packZipDir(m_packZip.get());
+
+    // https://docs.modrinth.com/docs/modpacks/format_definition/#storage
+    bool modrinthFound = packZipDir.exists("/modrinth.index.json");
+    bool technicFound = packZipDir.exists("/bin/modpack.jar") || packZipDir.exists("/bin/version.json");
     QString root;
-    if(!mmcFound.isNull())
+
+    // NOTE: Prioritize modpack platforms that aren't searched for recursively.
+    // Especially Flame has a very common filename for its manifest, which may appear inside overrides for example
+    if(modrinthFound)
     {
-        // process as MultiMC instance/pack
-        qDebug() << "MultiMC:" << mmcFound;
-        root = mmcFound;
-        m_modpackType = ModpackType::MultiMC;
+        // process as Modrinth pack
+        qDebug() << "Modrinth:" << modrinthFound;
+        m_modpackType = ModpackType::Modrinth;
     }
     else if (technicFound)
     {
@@ -125,12 +159,25 @@ void InstanceImportTask::processZipPack()
         extractDir.cd(".minecraft");
         m_modpackType = ModpackType::Technic;
     }
-    else if(!flameFound.isNull())
+    else
     {
-        // process as Flame pack
-        qDebug() << "Flame:" << flameFound;
-        root = flameFound;
-        m_modpackType = ModpackType::Flame;
+        QString mmcRoot = MMCZip::findFolderOfFileInZip(m_packZip.get(), "instance.cfg");
+        QString flameRoot = MMCZip::findFolderOfFileInZip(m_packZip.get(), "manifest.json");
+
+        if (!mmcRoot.isNull())
+        {
+            // process as MultiMC instance/pack
+            qDebug() << "MultiMC:" << mmcRoot;
+            root = mmcRoot;
+            m_modpackType = ModpackType::MultiMC;
+        }
+        else if(!flameRoot.isNull())
+        {
+            // process as Flame pack
+            qDebug() << "Flame:" << flameRoot;
+            root = flameRoot;
+            m_modpackType = ModpackType::Flame;
+        }
     }
     if(m_modpackType == ModpackType::Unknown)
     {
@@ -188,15 +235,18 @@ void InstanceImportTask::extractFinished()
 
     switch(m_modpackType)
     {
-        case ModpackType::Flame:
-            processFlame();
-            return;
         case ModpackType::MultiMC:
             processMultiMC();
             return;
         case ModpackType::Technic:
             processTechnic();
             return;
+        case ModpackType::Flame:
+            processFlame();
+            return;
+        case ModpackType::Modrinth:
+            processModrinth();
+            return;
         case ModpackType::Unknown:
             emitFailed(tr("Archive does not contain a recognized modpack type."));
             return;
@@ -344,61 +394,136 @@ void InstanceImportTask::processFlame()
     connect(m_modIdResolver.get(), &Flame::FileResolvingTask::succeeded, [&]()
     {
         auto results = m_modIdResolver->getResults();
-        m_filesNetJob = new NetJob(tr("Mod download"), APPLICATION->network());
-        for(auto result: results.files)
-        {
-            QString filename = result.fileName;
-            if(!result.required)
-            {
-                filename += ".disabled";
-            }
-
-            auto relpath = FS::PathCombine("minecraft", result.targetFolder, filename);
-            auto path = FS::PathCombine(m_stagingPath , relpath);
-
-            switch(result.type)
-            {
-                case Flame::File::Type::Folder:
-                {
-                    logWarning(tr("This 'Folder' may need extracting: %1").arg(relpath));
-                    // fall-through intentional, we treat these as plain old mods and dump them wherever.
-                }
-                case Flame::File::Type::SingleFile:
-                case Flame::File::Type::Mod:
-                {
-                    qDebug() << "Will download" << result.url << "to" << path;
-                    auto dl = Net::Download::makeFile(result.url, path);
-                    m_filesNetJob->addNetAction(dl);
-                    break;
-                }
-                case Flame::File::Type::Modpack:
-                    logWarning(tr("Nesting modpacks in modpacks is not implemented, nothing was downloaded: %1").arg(relpath));
-                    break;
-                case Flame::File::Type::Cmod2:
-                case Flame::File::Type::Ctoc:
-                case Flame::File::Type::Unknown:
-                    logWarning(tr("Unrecognized/unhandled PackageType for: %1").arg(relpath));
-                    break;
+        //first check for blocked mods
+        QString text;
+        auto anyBlocked = false;
+        for(const auto& result: results.files.values()) {
+            if (!result.resolved || result.url.isEmpty()) {
+                text += QString("%1: <a href='%2'>%2</a><br/>").arg(result.fileName, result.websiteUrl);
+                anyBlocked = true;
             }
         }
-        m_modIdResolver.reset();
-        connect(m_filesNetJob.get(), &NetJob::succeeded, this, [&]()
-        {
-            m_filesNetJob.reset();
-            emitSucceeded();
+        if(anyBlocked) {
+            qWarning() << "Blocked mods found, displaying mod list";
+
+            auto message_dialog = new ScrollMessageBox(m_parent,
+                                                       tr("Blocked mods found"),
+                                                       tr("The following mods were blocked on third party launchers.<br/>"
+                                                          "You will need to manually download them and add them to the modpack"),
+                                                       text);
+            message_dialog->setModal(true);
+            message_dialog->show();
+            connect(message_dialog, &QDialog::rejected, [&]() {
+                m_modIdResolver.reset();
+                emitFailed("Canceled");
+            });
+            connect(message_dialog, &QDialog::accepted, [&]() {
+                m_filesNetJob = new NetJob(tr("Mod download"), APPLICATION->network());
+                for (const auto &result: m_modIdResolver->getResults().files) {
+                    QString filename = result.fileName;
+                    if (!result.required) {
+                        filename += ".disabled";
+                    }
+
+                    auto relpath = FS::PathCombine("minecraft", result.targetFolder, filename);
+                    auto path = FS::PathCombine(m_stagingPath, relpath);
+
+                    switch (result.type) {
+                        case Flame::File::Type::Folder: {
+                            logWarning(tr("This 'Folder' may need extracting: %1").arg(relpath));
+                            // fall-through intentional, we treat these as plain old mods and dump them wherever.
+                        }
+                        case Flame::File::Type::SingleFile:
+                        case Flame::File::Type::Mod: {
+                            if (!result.url.isEmpty()) {
+                                qDebug() << "Will download" << result.url << "to" << path;
+                                auto dl = Net::Download::makeFile(result.url, path);
+                                m_filesNetJob->addNetAction(dl);
+                            }
+                            break;
+                        }
+                        case Flame::File::Type::Modpack:
+                            logWarning(
+                                    tr("Nesting modpacks in modpacks is not implemented, nothing was downloaded: %1").arg(
+                                            relpath));
+                            break;
+                        case Flame::File::Type::Cmod2:
+                        case Flame::File::Type::Ctoc:
+                        case Flame::File::Type::Unknown:
+                            logWarning(tr("Unrecognized/unhandled PackageType for: %1").arg(relpath));
+                            break;
+                    }
+                }
+                m_modIdResolver.reset();
+                connect(m_filesNetJob.get(), &NetJob::succeeded, this, [&]() {
+                            m_filesNetJob.reset();
+                            emitSucceeded();
+                        }
+                );
+                connect(m_filesNetJob.get(), &NetJob::failed, [&](QString reason) {
+                    m_filesNetJob.reset();
+                    emitFailed(reason);
+                });
+                connect(m_filesNetJob.get(), &NetJob::progress, [&](qint64 current, qint64 total) {
+                    setProgress(current, total);
+                });
+                setStatus(tr("Downloading mods..."));
+                m_filesNetJob->start();
+            });
+        }else{
+            //TODO extract to function ?
+            m_filesNetJob = new NetJob(tr("Mod download"), APPLICATION->network());
+            for (const auto &result: m_modIdResolver->getResults().files) {
+                QString filename = result.fileName;
+                if (!result.required) {
+                    filename += ".disabled";
+                }
+
+                auto relpath = FS::PathCombine("minecraft", result.targetFolder, filename);
+                auto path = FS::PathCombine(m_stagingPath, relpath);
+
+                switch (result.type) {
+                    case Flame::File::Type::Folder: {
+                        logWarning(tr("This 'Folder' may need extracting: %1").arg(relpath));
+                        // fall-through intentional, we treat these as plain old mods and dump them wherever.
+                    }
+                    case Flame::File::Type::SingleFile:
+                    case Flame::File::Type::Mod: {
+                        if (!result.url.isEmpty()) {
+                            qDebug() << "Will download" << result.url << "to" << path;
+                            auto dl = Net::Download::makeFile(result.url, path);
+                            m_filesNetJob->addNetAction(dl);
+                        }
+                        break;
+                    }
+                    case Flame::File::Type::Modpack:
+                        logWarning(
+                                tr("Nesting modpacks in modpacks is not implemented, nothing was downloaded: %1").arg(
+                                        relpath));
+                        break;
+                    case Flame::File::Type::Cmod2:
+                    case Flame::File::Type::Ctoc:
+                    case Flame::File::Type::Unknown:
+                        logWarning(tr("Unrecognized/unhandled PackageType for: %1").arg(relpath));
+                        break;
+                }
+            }
+            m_modIdResolver.reset();
+            connect(m_filesNetJob.get(), &NetJob::succeeded, this, [&]() {
+                        m_filesNetJob.reset();
+                        emitSucceeded();
+                    }
+            );
+            connect(m_filesNetJob.get(), &NetJob::failed, [&](QString reason) {
+                m_filesNetJob.reset();
+                emitFailed(reason);
+            });
+            connect(m_filesNetJob.get(), &NetJob::progress, [&](qint64 current, qint64 total) {
+                setProgress(current, total);
+            });
+            setStatus(tr("Downloading mods..."));
+            m_filesNetJob->start();
         }
-        );
-        connect(m_filesNetJob.get(), &NetJob::failed, [&](QString reason)
-        {
-            m_filesNetJob.reset();
-            emitFailed(reason);
-        });
-        connect(m_filesNetJob.get(), &NetJob::progress, [&](qint64 current, qint64 total)
-        {
-            setProgress(current, total);
-        });
-        setStatus(tr("Downloading mods..."));
-        m_filesNetJob->start();
     }
     );
     connect(m_modIdResolver.get(), &Flame::FileResolvingTask::failed, [&](QString reason)
@@ -439,25 +564,216 @@ void InstanceImportTask::processMultiMC()
     instance.setName(m_instName);
 
     // if the icon was specified by user, use that. otherwise pull icon from the pack
+    if (m_instIcon != "default") {
+        instance.setIconKey(m_instIcon);
+    } else {
+        m_instIcon = instance.iconKey();
+
+        auto importIconPath = IconUtils::findBestIconIn(instance.instanceRoot(), m_instIcon);
+        if (!importIconPath.isNull() && QFile::exists(importIconPath)) {
+            // import icon
+            auto iconList = APPLICATION->icons();
+            if (iconList->iconFileExists(m_instIcon)) {
+                iconList->deleteIcon(m_instIcon);
+            }
+            iconList->installIcons({ importIconPath });
+        }
+    }
+    emitSucceeded();
+}
+
+// https://docs.modrinth.com/docs/modpacks/format_definition/
+void InstanceImportTask::processModrinth()
+{
+    std::vector<Modrinth::File> files;
+    QString minecraftVersion, fabricVersion, quiltVersion, forgeVersion;
+    try {
+        QString indexPath = FS::PathCombine(m_stagingPath, "modrinth.index.json");
+        auto doc = Json::requireDocument(indexPath);
+        auto obj = Json::requireObject(doc, "modrinth.index.json");
+        int formatVersion = Json::requireInteger(obj, "formatVersion", "modrinth.index.json");
+        if (formatVersion == 1) {
+            auto game = Json::requireString(obj, "game", "modrinth.index.json");
+            if (game != "minecraft") {
+                throw JSONValidationError("Unknown game: " + game);
+            }
+
+            auto jsonFiles = Json::requireIsArrayOf<QJsonObject>(obj, "files", "modrinth.index.json");
+            bool had_optional = false;
+            for (auto modInfo : jsonFiles) {
+                Modrinth::File file;
+                file.path = Json::requireString(modInfo, "path");
+
+                auto env = Json::ensureObject(modInfo, "env");
+                // 'env' field is optional
+                if (!env.isEmpty()) {
+                    QString support = Json::ensureString(env, "client", "unsupported");
+                    if (support == "unsupported") {
+                        continue;
+                    } else if (support == "optional") {
+                        // TODO: Make a review dialog for choosing which ones the user wants!
+                        if (!had_optional) {
+                            had_optional = true;
+                            auto info = CustomMessageBox::selectable(
+                                m_parent, tr("Optional mod detected!"),
+                                tr("One or more mods from this modpack are optional. They will be downloaded, but disabled by default!"),
+                                QMessageBox::Information);
+                            info->exec();
+                        }
+
+                        if (file.path.endsWith(".jar"))
+                            file.path += ".disabled";
+                    }
+                }
+
+                QJsonObject hashes = Json::requireObject(modInfo, "hashes");
+                QString hash;
+                QCryptographicHash::Algorithm hashAlgorithm;
+                hash = Json::ensureString(hashes, "sha1");
+                hashAlgorithm = QCryptographicHash::Sha1;
+                if (hash.isEmpty()) {
+                    hash = Json::ensureString(hashes, "sha512");
+                    hashAlgorithm = QCryptographicHash::Sha512;
+                    if (hash.isEmpty()) {
+                        hash = Json::ensureString(hashes, "sha256");
+                        hashAlgorithm = QCryptographicHash::Sha256;
+                        if (hash.isEmpty()) {
+                            throw JSONValidationError("No hash found for: " + file.path);
+                        }
+                    }
+                }
+                file.hash = QByteArray::fromHex(hash.toLatin1());
+                file.hashAlgorithm = hashAlgorithm;
+                
+                // Do not use requireUrl, which uses StrictMode, instead use QUrl's default TolerantMode
+                // (as Modrinth seems to incorrectly handle spaces)
+                
+                auto download_arr = Json::ensureArray(modInfo, "downloads");
+                for(auto download : download_arr) {
+                    qWarning() << download.toString();
+                    bool is_last = download.toString() == download_arr.last().toString();
+
+                    auto download_url = QUrl(download.toString());
+
+                    if (!download_url.isValid()) {
+                        qDebug() << QString("Download URL (%1) for %2 is not a correctly formatted URL")
+                                        .arg(download_url.toString(), file.path);
+                        if(is_last && file.downloads.isEmpty())
+                            throw JSONValidationError(tr("Download URL for %1 is not a correctly formatted URL").arg(file.path));
+                    }
+                    else {
+                        file.downloads.push_back(download_url);
+                    }
+                }
+
+                files.push_back(file);
+            }
+
+            auto dependencies = Json::requireObject(obj, "dependencies", "modrinth.index.json");
+            for (auto it = dependencies.begin(), end = dependencies.end(); it != end; ++it) {
+                QString name = it.key();
+                if (name == "minecraft") {
+                    minecraftVersion = Json::requireString(*it, "Minecraft version");
+                }
+                else if (name == "fabric-loader") {
+                    fabricVersion = Json::requireString(*it, "Fabric Loader version");
+                }
+                else if (name == "quilt-loader") {
+                    quiltVersion = Json::requireString(*it, "Quilt Loader version");
+                }
+                else if (name == "forge") {
+                    forgeVersion = Json::requireString(*it, "Forge version");
+                }
+                else {
+                    throw JSONValidationError("Unknown dependency type: " + name);
+                }
+            }
+        } else {
+            throw JSONValidationError(QStringLiteral("Unknown format version: %s").arg(formatVersion));
+        }
+        QFile::remove(indexPath);
+    } catch (const JSONValidationError& e) {
+        emitFailed(tr("Could not understand pack index:\n") + e.cause());
+        return;
+    }
+    
+    auto mcPath = FS::PathCombine(m_stagingPath, ".minecraft");
+
+    auto override_path = FS::PathCombine(m_stagingPath, "overrides");
+    if (QFile::exists(override_path)) {
+        if (!QFile::rename(override_path, mcPath)) {
+            emitFailed(tr("Could not rename the overrides folder:\n") + "overrides");
+            return;
+        }
+    }
+
+    // Do client overrides
+    auto client_override_path = FS::PathCombine(m_stagingPath, "client-overrides");
+    if (QFile::exists(client_override_path)) {
+        if (!FS::overrideFolder(mcPath, client_override_path)) {
+            emitFailed(tr("Could not rename the client overrides folder:\n") + "client overrides");
+            return;
+        }
+    }
+
+    QString configPath = FS::PathCombine(m_stagingPath, "instance.cfg");
+    auto instanceSettings = std::make_shared<INISettingsObject>(configPath);
+    MinecraftInstance instance(m_globalSettings, instanceSettings, m_stagingPath);
+    auto components = instance.getPackProfile();
+    components->buildingFromScratch();
+    components->setComponentVersion("net.minecraft", minecraftVersion, true);
+    if (!fabricVersion.isEmpty())
+        components->setComponentVersion("net.fabricmc.fabric-loader", fabricVersion, true);
+    if (!quiltVersion.isEmpty())
+        components->setComponentVersion("org.quiltmc.quilt-loader", quiltVersion, true);
+    if (!forgeVersion.isEmpty())
+        components->setComponentVersion("net.minecraftforge", forgeVersion, true);
     if (m_instIcon != "default")
     {
         instance.setIconKey(m_instIcon);
     }
     else
     {
-        m_instIcon = instance.iconKey();
+        instance.setIconKey("modrinth");
+    }
+    instance.setName(m_instName);
+    instance.saveNow();
 
-        auto importIconPath = IconUtils::findBestIconIn(instance.instanceRoot(), m_instIcon);
-        if (!importIconPath.isNull() && QFile::exists(importIconPath))
-        {
-            // import icon
-            auto iconList = APPLICATION->icons();
-            if (iconList->iconFileExists(m_instIcon))
-            {
-                iconList->deleteIcon(m_instIcon);
-            }
-            iconList->installIcons({importIconPath});
+    m_filesNetJob = new NetJob(tr("Mod download"), APPLICATION->network());
+    for (auto file : files)
+    {
+        auto path = FS::PathCombine(m_stagingPath, ".minecraft", file.path);
+        qDebug() << "Will try to download" << file.downloads.front() << "to" << path;
+        auto dl = Net::Download::makeFile(file.downloads.dequeue(), path);
+        dl->addValidator(new Net::ChecksumValidator(file.hashAlgorithm, file.hash));
+        m_filesNetJob->addNetAction(dl);
+
+        if (file.downloads.size() > 0) {
+            // FIXME: This really needs to be put into a ConcurrentTask of
+            // MultipleOptionsTask's , once those exist :)
+            connect(dl.get(), &NetAction::failed, [this, &file, path, dl]{
+                auto dl = Net::Download::makeFile(file.downloads.dequeue(), path);
+                dl->addValidator(new Net::ChecksumValidator(file.hashAlgorithm, file.hash));
+                m_filesNetJob->addNetAction(dl);
+                dl->succeeded();
+            });
         }
     }
-    emitSucceeded();
+    connect(m_filesNetJob.get(), &NetJob::succeeded, this, [&]()
+            {
+                m_filesNetJob.reset();
+                emitSucceeded();
+            }
+    );
+    connect(m_filesNetJob.get(), &NetJob::failed, [&](const QString &reason)
+    {
+        m_filesNetJob.reset();
+        emitFailed(reason);
+    });
+    connect(m_filesNetJob.get(), &NetJob::progress, [&](qint64 current, qint64 total)
+    {
+        setProgress(current, total);
+    });
+    setStatus(tr("Downloading mods..."));
+    m_filesNetJob->start();
 }

launcher/InstanceImportTask.h

@@ -1,16 +1,36 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #pragma once
@@ -22,6 +42,7 @@
 #include <QFutureWatcher>
 #include "settings/SettingsObject.h"
 #include "QObjectPtr.h"
+#include "modplatform/flame/PackManifest.h"
 
 #include <nonstd/optional>
 
@@ -35,10 +56,14 @@ class InstanceImportTask : public InstanceTask
 {
     Q_OBJECT
 public:
-    explicit InstanceImportTask(const QUrl sourceUrl);
+    explicit InstanceImportTask(const QUrl sourceUrl, QWidget* parent = nullptr);
 
     bool canAbort() const override { return true; }
     bool abort() override;
+    const QVector<Flame::File> &getBlockedFiles() const
+    {
+        return m_blockedMods;
+    }
 
 protected:
     //! Entry point for tasks.
@@ -47,8 +72,9 @@ protected:
 private:
     void processZipPack();
     void processMultiMC();
-    void processFlame();
     void processTechnic();
+    void processFlame();
+    void processModrinth();
 
 private slots:
     void downloadSucceeded();
@@ -66,10 +92,15 @@ private: /* data */
     std::unique_ptr<QuaZip> m_packZip;
     QFuture<nonstd::optional<QStringList>> m_extractFuture;
     QFutureWatcher<nonstd::optional<QStringList>> m_extractFutureWatcher;
+    QVector<Flame::File> m_blockedMods;
     enum class ModpackType{
         Unknown,
         MultiMC,
+        Technic,
         Flame,
-        Technic
+        Modrinth,
     } m_modpackType = ModpackType::Unknown;
+
+    //FIXME: nuke
+    QWidget* m_parent;
 };

launcher/InstanceList.cpp

@@ -38,6 +38,10 @@
 #include "ExponentialSeries.h"
 #include "WatchLock.h"
 
+#ifdef Q_OS_WIN32
+#include <Windows.h>
+#endif
+
 const static int GROUP_FILE_FORMAT_VERSION = 1;
 
 InstanceList::InstanceList(SettingsObjectPtr settings, const QString & instDir, QObject *parent)
@@ -543,8 +547,20 @@ InstancePtr InstanceList::loadInstance(const InstanceId& id)
     auto instanceRoot = FS::PathCombine(m_instDir, id);
     auto instanceSettings = std::make_shared<INISettingsObject>(FS::PathCombine(instanceRoot, "instance.cfg"));
     InstancePtr inst;
-    // TODO: Handle incompatible instances
-    inst.reset(new MinecraftInstance(m_globalSettings, instanceSettings, instanceRoot));
+
+    instanceSettings->registerSetting("InstanceType", "");
+
+    QString inst_type = instanceSettings->get("InstanceType").toString();
+
+    // NOTE: Some PolyMC versions didn't save the InstanceType properly. We will just bank on the probability that this is probably a OneSix instance
+    if (inst_type == "OneSix" || inst_type.isEmpty())
+    {
+        inst.reset(new MinecraftInstance(m_globalSettings, instanceSettings, instanceRoot));
+    }
+    else
+    {
+        inst.reset(new NullInstance(m_globalSettings, instanceSettings, instanceRoot));
+    }
     qDebug() << "Loaded instance " << inst->name() << " from " << inst->instanceRoot();
     return inst;
 }
@@ -851,13 +867,18 @@ Task * InstanceList::wrapInstanceTask(InstanceTask * task)
 QString InstanceList::getStagedInstancePath()
 {
     QString key = QUuid::createUuid().toString();
-    QString relPath = FS::PathCombine("_LAUNCHER_TEMP/" , key);
+    QString tempDir = ".LAUNCHER_TEMP/";
+    QString relPath = FS::PathCombine(tempDir, key);
     QDir rootPath(m_instDir);
     auto path = FS::PathCombine(m_instDir, relPath);
     if(!rootPath.mkpath(relPath))
     {
         return QString();
     }
+#ifdef Q_OS_WIN32
+    auto tempPath = FS::PathCombine(m_instDir, tempDir);
+    SetFileAttributesA(tempPath.toStdString().c_str(), FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_NOT_CONTENT_INDEXED);
+#endif
     return path;
 }
 

launcher/LaunchController.cpp

@@ -93,7 +93,7 @@ void LaunchController::decideAccount()
         auto reply = CustomMessageBox::selectable(
             m_parentWidget,
             tr("No Accounts"),
-            tr("In order to play Minecraft, you must have at least one Mojang or Minecraft "
+            tr("In order to play Minecraft, you must have at least one Mojang or Microsoft "
                "account logged in. "
                "Would you like to open the account manager to add an account now?"),
             QMessageBox::Information,
@@ -105,6 +105,11 @@ void LaunchController::decideAccount()
             // Open the account manager.
             APPLICATION->ShowGlobalSettings(m_parentWidget, "accounts");
         }
+        else if (reply == QMessageBox::No)
+        {
+            // Do not open "profile select" dialog.
+            return;
+        }
     }
 
     m_accountToUse = accounts->defaultAccount();

launcher/MMCZip.cpp

@@ -297,20 +297,40 @@ nonstd::optional<QStringList> MMCZip::extractSubDir(QuaZip *zip, const QString &
         {
             continue;
         }
+
         name.remove(0, subdir.size());
-        QString absFilePath = directory.absoluteFilePath(name);
+        auto original_name = name;
+
+        // Fix weird "folders with a single file get squashed" thing
+        QString path;
+        if(name.contains('/') && !name.endsWith('/')){
+            path = name.section('/', 0, -2) + "/";
+            FS::ensureFolderPathExists(path);
+
+            name = name.split('/').last();
+        }
+
+        QString absFilePath;
         if(name.isEmpty())
         {
-            absFilePath += "/";
+            absFilePath = directory.absoluteFilePath(name) + "/";
         }
+        else
+        {
+            absFilePath = directory.absoluteFilePath(path + name);
+        }
+
         if (!JlCompress::extractFile(zip, "", absFilePath))
         {
-            qWarning() << "Failed to extract file" << name << "to" << absFilePath;
+            qWarning() << "Failed to extract file" << original_name << "to" << absFilePath;
             JlCompress::removeFile(extracted);
             return nonstd::nullopt;
         }
+
         extracted.append(absFilePath);
-        qDebug() << "Extracted file" << name;
+        QFile::setPermissions(absFilePath, QFileDevice::Permission::ReadUser | QFileDevice::Permission::WriteUser | QFileDevice::Permission::ExeUser);
+
+        qDebug() << "Extracted file" << name << "to" << absFilePath;
     } while (zip->goToNextFile());
     return extracted;
 }

launcher/UpdateController.cpp

@@ -93,7 +93,7 @@ void UpdateController::installUpdates()
     qDebug() << "Installing updates.";
 #ifdef Q_OS_WIN
     QString finishCmd = QApplication::applicationFilePath();
-#elif defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD) || defined (Q_OS_OPENBSD)
+#elif defined(Q_OS_LINUX) || defined(Q_OS_FREEBSD)
     QString finishCmd = FS::PathCombine(m_root, BuildConfig.LAUNCHER_NAME);
 #elif defined Q_OS_MAC
     QString finishCmd = QApplication::applicationFilePath();
@@ -138,20 +138,6 @@ void UpdateController::installUpdates()
                 }
 #endif
                 QFileInfo destination (FS::PathCombine(m_root, op.destination));
-#ifdef Q_OS_WIN32
-                if(QSysInfo::windowsVersion() < QSysInfo::WV_VISTA)
-                {
-                    if(destination.fileName() == windowsExeName)
-                    {
-                        QDir rootDir(m_root);
-                        exeOrigin = rootDir.relativeFilePath(op.source);
-                        exePath = rootDir.relativeFilePath(op.destination);
-                        exeBackup = rootDir.relativeFilePath(FS::PathCombine(backupPath, destination.fileName()));
-                        useXPHack = true;
-                        continue;
-                    }
-                }
-#endif
                 if(destination.exists())
                 {
                     QString backupName = op.destination;

launcher/icons/IconList.cpp

@@ -36,7 +36,7 @@ IconList::IconList(const QStringList &builtinPaths, QString path, QObject *paren
         auto file_info_list = instance_icons.entryInfoList(QDir::Files, QDir::Name);
         for (auto file_info : file_info_list)
         {
-            builtinNames.insert(file_info.baseName());
+            builtinNames.insert(file_info.completeBaseName());
         }
     }
     for(auto & builtinName : builtinNames)
@@ -51,6 +51,18 @@ IconList::IconList(const QStringList &builtinPaths, QString path, QObject *paren
     connect(m_watcher.get(), SIGNAL(fileChanged(QString)), SLOT(fileChanged(QString)));
 
     directoryChanged(path);
+
+    // Forces the UI to update, so that lengthy icon names are shown properly from the start
+    emit iconUpdated({});
+}
+
+void IconList::sortIconList()
+{
+    qDebug() << "Sorting icon list...";
+    std::sort(icons.begin(), icons.end(), [](const MMCIcon& a, const MMCIcon& b) {
+        return a.m_key.localeAwareCompare(b.m_key) < 0;
+    });
+    reindex();
 }
 
 void IconList::directoryChanged(const QString &path)
@@ -94,7 +106,13 @@ void IconList::directoryChanged(const QString &path)
     {
         qDebug() << "Removing " << remove;
         QFileInfo rmfile(remove);
-        QString key = rmfile.baseName();
+        QString key = rmfile.completeBaseName();
+
+        QString suffix = rmfile.suffix();
+        // The icon doesnt have a suffix, but it can have other .s in the name, so we account for those as well
+        if (suffix != "jpeg" && suffix != "png" && suffix != "jpg" && suffix != "ico" && suffix != "svg" && suffix != "gif")
+            key = rmfile.fileName();
+
         int idx = getIconIndex(key);
         if (idx == -1)
             continue;
@@ -117,14 +135,23 @@ void IconList::directoryChanged(const QString &path)
     for (auto add : to_add)
     {
         qDebug() << "Adding " << add;
+
         QFileInfo addfile(add);
-        QString key = addfile.baseName();
+        QString key = addfile.completeBaseName();
+
+        QString suffix = addfile.suffix();
+        // The icon doesnt have a suffix, but it can have other .s in the name, so we account for those as well
+        if (suffix != "jpeg" && suffix != "png" && suffix != "jpg" && suffix != "ico" && suffix != "svg" && suffix != "gif")
+            key = addfile.fileName();
+
         if (addIcon(key, QString(), addfile.filePath(), IconType::FileBased))
         {
             m_watcher->addPath(add);
             emit iconUpdated(key);
         }
     }
+
+    sortIconList();
 }
 
 void IconList::fileChanged(const QString &path)
@@ -133,7 +160,7 @@ void IconList::fileChanged(const QString &path)
     QFileInfo checkfile(path);
     if (!checkfile.exists())
         return;
-    QString key = checkfile.baseName();
+    QString key = checkfile.completeBaseName();
     int idx = getIconIndex(key);
     if (idx == -1)
         return;
@@ -257,7 +284,7 @@ void IconList::installIcons(const QStringList &iconFiles)
         QFileInfo fileinfo(file);
         if (!fileinfo.isReadable() || !fileinfo.isFile())
             continue;
-        QString target = FS::PathCombine(m_dir.dirName(), fileinfo.fileName());
+        QString target = FS::PathCombine(getDirectory(), fileinfo.fileName());
 
         QString suffix = fileinfo.suffix();
         if (suffix != "jpeg" && suffix != "png" && suffix != "jpg" && suffix != "ico" && suffix != "svg" && suffix != "gif")
@@ -274,7 +301,7 @@ void IconList::installIcon(const QString &file, const QString &name)
     if(!fileinfo.isReadable() || !fileinfo.isFile())
         return;
 
-    QString target = FS::PathCombine(m_dir.dirName(), name);
+    QString target = FS::PathCombine(getDirectory(), name);
 
     QFile::copy(file, target);
 }

launcher/icons/IconList.h

@@ -71,6 +71,7 @@ private:
     // hide assign op
     IconList &operator=(const IconList &) = delete;
     void reindex();
+    void sortIconList();
 
 public slots:
     void directoryChanged(const QString &path);

launcher/main.cpp

@@ -24,14 +24,8 @@ int main(int argc, char *argv[])
     return 42;
 #endif
 
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 6, 0))
     QApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
     QGuiApplication::setAttribute(Qt::AA_UseHighDpiPixmaps);
-#endif
-
-#if (QT_VERSION >= QT_VERSION_CHECK(5, 14, 0))
-    QApplication::setHighDpiScaleFactorRoundingPolicy(Qt::HighDpiScaleFactorRoundingPolicy::PassThrough);
-#endif
 
     // initialize Qt
     Application app(argc, argv);

launcher/meta/BaseEntity.cpp

@@ -75,7 +75,16 @@ Meta::BaseEntity::~BaseEntity()
 
 QUrl Meta::BaseEntity::url() const
 {
-    return QUrl(BuildConfig.META_URL).resolved(localFilename());
+    auto s = APPLICATION->settings();
+    QString metaOverride = s->get("MetaURLOverride").toString();
+    if(metaOverride.isEmpty())
+    {
+        return QUrl(BuildConfig.META_URL).resolved(localFilename());
+    }
+    else
+    {
+        return QUrl(metaOverride).resolved(localFilename());
+    }
 }
 
 bool Meta::BaseEntity::loadLocalFile()

launcher/minecraft/AssetsUtils.cpp

@@ -1,16 +1,36 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #include <QFileInfo>
@@ -297,7 +317,7 @@ NetAction::Ptr AssetObject::getDownloadAction()
             auto rawHash = QByteArray::fromHex(hash.toLatin1());
             objectDL->addValidator(new Net::ChecksumValidator(QCryptographicHash::Sha1, rawHash));
         }
-        objectDL->m_total_progress = size;
+        objectDL->setProgress(objectDL->getProgress(), size);
         return objectDL;
     }
     return nullptr;

launcher/minecraft/GradleSpecifier.h

@@ -124,7 +124,7 @@ struct GradleSpecifier
     }
     bool matchName(const GradleSpecifier & other) const
     {
-        return other.artifactId() == artifactId() && other.groupId() == groupId();
+        return other.artifactId() == artifactId() && other.groupId() == groupId() && other.classifier() == classifier();
     }
     bool operator==(const GradleSpecifier & other) const
     {

launcher/minecraft/MinecraftInstance.cpp

@@ -2,6 +2,7 @@
 /*
  *  PolyMC - Minecraft Launcher
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
  *
  *  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
@@ -162,6 +163,13 @@ MinecraftInstance::MinecraftInstance(SettingsObjectPtr globalSettings, SettingsO
     m_settings->registerSetting("JoinServerOnLaunch", false);
     m_settings->registerSetting("JoinServerOnLaunchAddress", "");
 
+    // Miscellaneous
+    auto miscellaneousOverride = m_settings->registerSetting("OverrideMiscellaneous", false);
+    m_settings->registerOverride(globalSettings->getSetting("CloseAfterLaunch"), miscellaneousOverride);
+    m_settings->registerOverride(globalSettings->getSetting("QuitAfterGameStop"), miscellaneousOverride);
+
+    m_settings->set("InstanceType", "OneSix");
+
     m_components.reset(new PackProfile(this));
 }
 
@@ -482,9 +490,8 @@ QStringList MinecraftInstance::processMinecraftArgs(
         }
     }
 
-    // blatant self-promotion.
-    token_mapping["profile_name"] = token_mapping["version_name"] = BuildConfig.LAUNCHER_NAME;
-
+    token_mapping["profile_name"] = name();
+    token_mapping["version_name"] = profile->getMinecraftVersion();
     token_mapping["version_type"] = profile->getMinecraftVersionType();
 
     QString absRootDir = QDir(gameRoot()).absolutePath();
@@ -984,7 +991,7 @@ shared_qobject_ptr<LaunchTask> MinecraftInstance::createLaunchTask(AuthSessionPt
     {
         process->setCensorFilter(createCensorFilterFromSession(session));
     }
-    if(APPLICATION->settings()->get("QuitAfterGameStop").toBool())
+    if(m_settings->get("QuitAfterGameStop").toBool())
     {
         auto step = new QuitAfterGameStop(pptr);
         process->appendStep(step);

launcher/minecraft/PackProfile.cpp

@@ -36,6 +36,13 @@
 #include "ComponentUpdateTask.h"
 
 #include "Application.h"
+#include "modplatform/ModAPI.h"
+
+static const QMap<QString, ModAPI::ModLoaderType> modloaderMapping{
+    {"net.minecraftforge", ModAPI::Forge},
+    {"net.fabricmc.fabric-loader", ModAPI::Fabric},
+    {"org.quiltmc.quilt-loader", ModAPI::Quilt}
+};
 
 PackProfile::PackProfile(MinecraftInstance * instance)
     : QAbstractListModel()
@@ -971,19 +978,19 @@ void PackProfile::disableInteraction(bool disable)
     }
 }
 
-ModAPI::ModLoaderType PackProfile::getModLoader()
+ModAPI::ModLoaderTypes PackProfile::getModLoaders()
 {
-    if (!getComponentVersion("net.minecraftforge").isEmpty())
+    ModAPI::ModLoaderTypes result = ModAPI::Unspecified;
+
+    QMapIterator<QString, ModAPI::ModLoaderType> i(modloaderMapping);
+
+    while (i.hasNext())
     {
-        return ModAPI::Forge;
+        i.next();
+        Component* c = getComponent(i.key());
+        if (c != nullptr && c->isEnabled()) {
+            result |= i.value();
+        }
     }
-    else if (!getComponentVersion("net.fabricmc.fabric-loader").isEmpty())
-    {
-        return ModAPI::Fabric;
-    }
-    else if (!getComponentVersion("org.quiltmc.quilt-loader").isEmpty())
-    {
-        return ModAPI::Quilt;
-    }
-    return ModAPI::Unspecified;
+    return result;
 }

launcher/minecraft/PackProfile.h

@@ -118,7 +118,7 @@ public:
     // todo(merged): is this the best approach
     void appendComponent(ComponentPtr component);
 
-    ModAPI::ModLoaderType getModLoader();
+    ModAPI::ModLoaderTypes getModLoaders();
 
 private:
     void scheduleSave();

launcher/minecraft/VersionFile.cpp

@@ -2,6 +2,7 @@
 /*
  *  PolyMC - Minecraft Launcher
  *  Copyright (C) 2022 Sefa Eyeoglu <contact@scrumplex.net>
+ *  Copyright (C) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
  *
  *  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
@@ -55,7 +56,7 @@ void VersionFile::applyTo(LaunchProfile *profile)
     // Only real Minecraft can set those. Don't let anything override them.
     if (isMinecraftVersion(uid))
     {
-        profile->applyMinecraftVersion(minecraftVersion);
+        profile->applyMinecraftVersion(version);
         profile->applyMinecraftVersionType(type);
         // HACK: ignore assets from other version files than Minecraft
         // workaround for stupid assets issue caused by amazon:

launcher/minecraft/auth/Parsers.cpp

@@ -1,4 +1,5 @@
 #include "Parsers.h"
+#include "Json.h"
 
 #include <QJsonDocument>
 #include <QJsonArray>
@@ -212,6 +213,180 @@ bool parseMinecraftProfile(QByteArray & data, MinecraftProfile &output) {
     return true;
 }
 
+namespace {
+    // these skin URLs are for the MHF_Steve and MHF_Alex accounts (made by a Mojang employee)
+    // they are needed because the session server doesn't return skin urls for default skins
+    static const QString SKIN_URL_STEVE = "http://textures.minecraft.net/texture/1a4af718455d4aab528e7a61f86fa25e6a369d1768dcb13f7df319a713eb810b";
+    static const QString SKIN_URL_ALEX = "http://textures.minecraft.net/texture/83cee5ca6afcdb171285aa00e8049c297b2dbeba0efb8ff970a5677a1b644032";
+
+    bool isDefaultModelSteve(QString uuid) {
+        // need to calculate *Java* hashCode of UUID
+        // if number is even, skin/model is steve, otherwise it is alex
+
+        // just in case dashes are in the id
+        uuid.remove('-');
+
+        if (uuid.size() != 32) {
+            return true;
+        }
+
+        // qulonglong is guaranteed to be 64 bits
+        // we need to use unsigned numbers to guarantee truncation below
+        qulonglong most = uuid.left(16).toULongLong(nullptr, 16);
+        qulonglong least = uuid.right(16).toULongLong(nullptr, 16);
+        qulonglong xored = most ^ least;
+        return ((static_cast<quint32>(xored >> 32)) ^ static_cast<quint32>(xored)) % 2 == 0;
+    }
+}
+
+/**
+Uses session server for skin/cape lookup instead of profile,
+because locked Mojang accounts cannot access profile endpoint
+(https://api.minecraftservices.com/minecraft/profile/)
+
+ref: https://wiki.vg/Mojang_API#UUID_to_Profile_and_Skin.2FCape
+
+{
+    "id": "<profile identifier>",
+    "name": "<player name>",
+    "properties": [
+        {
+            "name": "textures",
+            "value": "<base64 string>"
+        }
+    ]
+}
+
+decoded base64 "value":
+{
+    "timestamp": <java time in ms>,
+    "profileId": "<profile uuid>",
+    "profileName": "<player name>",
+    "textures": {
+        "SKIN": {
+            "url": "<player skin URL>"
+        },
+        "CAPE": {
+            "url": "<player cape URL>"
+        }
+    }
+}
+*/
+
+bool parseMinecraftProfileMojang(QByteArray & data, MinecraftProfile &output) {
+    qDebug() << "Parsing Minecraft profile...";
+#ifndef NDEBUG
+    qDebug() << data;
+#endif
+
+    QJsonParseError jsonError;
+    QJsonDocument doc = QJsonDocument::fromJson(data, &jsonError);
+    if(jsonError.error) {
+        qWarning() << "Failed to parse response as JSON: " << jsonError.errorString();
+        return false;
+    }
+
+    auto obj = Json::requireObject(doc, "mojang minecraft profile");
+    if(!getString(obj.value("id"), output.id)) {
+        qWarning() << "Minecraft profile id is not a string";
+        return false;
+    }
+
+    if(!getString(obj.value("name"), output.name)) {
+        qWarning() << "Minecraft profile name is not a string";
+        return false;
+    }
+
+    auto propsArray = obj.value("properties").toArray();
+    QByteArray texturePayload;
+    for( auto p : propsArray) {
+        auto pObj = p.toObject();
+        auto name = pObj.value("name");
+        if (!name.isString() || name.toString() != "textures") {
+            continue;
+        }
+
+        auto value = pObj.value("value");
+        if (value.isString()) {
+#if QT_VERSION >= QT_VERSION_CHECK(5, 15, 0)
+            texturePayload = QByteArray::fromBase64(value.toString().toUtf8(), QByteArray::AbortOnBase64DecodingErrors);
+#else
+            texturePayload = QByteArray::fromBase64(value.toString().toUtf8());
+#endif
+        }
+
+        if (!texturePayload.isEmpty()) {
+            break;
+        }
+    }
+
+    if (texturePayload.isNull()) {
+        qWarning() << "No texture payload data";
+        return false;
+    }
+
+    doc = QJsonDocument::fromJson(texturePayload, &jsonError);
+    if(jsonError.error) {
+        qWarning() << "Failed to parse response as JSON: " << jsonError.errorString();
+        return false;
+    }
+
+    obj = Json::requireObject(doc, "session texture payload");
+    auto textures = obj.value("textures");
+    if (!textures.isObject()) {
+        qWarning() << "No textures array in response";
+        return false;
+    }
+
+    Skin skinOut;
+    // fill in default skin info ourselves, as this endpoint doesn't provide it
+    bool steve = isDefaultModelSteve(output.id);
+    skinOut.variant = steve ? "classic" : "slim";
+    skinOut.url = steve ? SKIN_URL_STEVE : SKIN_URL_ALEX;
+    // sadly we can't figure this out, but I don't think it really matters...
+    skinOut.id = "00000000-0000-0000-0000-000000000000";
+    Cape capeOut;
+    auto tObj = textures.toObject();
+    for (auto idx = tObj.constBegin(); idx != tObj.constEnd(); ++idx) {
+        if (idx->isObject()) {
+            if (idx.key() == "SKIN") {
+                auto skin = idx->toObject();
+                if (!getString(skin.value("url"), skinOut.url)) {
+                    qWarning() << "Skin url is not a string";
+                    return false;
+                }
+
+                auto maybeMeta = skin.find("metadata");
+                if (maybeMeta != skin.end() && maybeMeta->isObject()) {
+                    auto meta = maybeMeta->toObject();
+                    // might not be present
+                    getString(meta.value("model"), skinOut.variant);
+                }
+            }
+            else if (idx.key() == "CAPE") {
+                auto cape = idx->toObject();
+                if (!getString(cape.value("url"), capeOut.url)) {
+                    qWarning() << "Cape url is not a string";
+                    return false;
+                }
+
+                // we don't know the cape ID as it is not returned from the session server
+                // so just fake it - changing capes is probably locked anyway :(
+                capeOut.alias = "cape";
+            }
+        }
+    }
+
+    output.skin = skinOut;
+    if (capeOut.alias == "cape") {
+        output.capes = QMap<QString, Cape>({{capeOut.alias, capeOut}});
+        output.currentCape = capeOut.alias;
+    }
+
+    output.validity = Katabasis::Validity::Certain;
+    return true;
+}
+
 bool parseMinecraftEntitlements(QByteArray & data, MinecraftEntitlement &output) {
     qDebug() << "Parsing Minecraft entitlements...";
 #ifndef NDEBUG

launcher/minecraft/auth/Parsers.h

@@ -14,6 +14,7 @@ namespace Parsers
     bool parseMojangResponse(QByteArray &data, Katabasis::Token &output);
 
     bool parseMinecraftProfile(QByteArray &data, MinecraftProfile &output);
+    bool parseMinecraftProfileMojang(QByteArray &data, MinecraftProfile &output);
     bool parseMinecraftEntitlements(QByteArray &data, MinecraftEntitlement &output);
     bool parseRolloutResponse(QByteArray &data, bool& result);
 }

launcher/minecraft/auth/Yggdrasil.cpp

@@ -209,6 +209,28 @@ void Yggdrasil::processResponse(QJsonObject responseData) {
     m_data->yggdrasilToken.validity = Katabasis::Validity::Certain;
     m_data->yggdrasilToken.issueInstant = QDateTime::currentDateTimeUtc();
 
+    // Get UUID here since we need it for later
+    auto profile = responseData.value("selectedProfile");
+    if (!profile.isObject()) {
+        changeState(AccountTaskState::STATE_FAILED_HARD, tr("Authentication server didn't send a selected profile."));
+        return;
+    }
+
+    auto profileObj = profile.toObject();
+    for (auto i = profileObj.constBegin(); i != profileObj.constEnd(); ++i) {
+        if (i.key() == "name" && i.value().isString()) {
+            m_data->minecraftProfile.name = i->toString();
+        }
+        else if (i.key() == "id" && i.value().isString()) {
+            m_data->minecraftProfile.id = i->toString();
+        }
+    }
+
+    if (m_data->minecraftProfile.id.isEmpty()) {
+        changeState(AccountTaskState::STATE_FAILED_HARD, tr("Authentication server didn't send a UUID in selected profile."));
+        return;
+    }
+
     // We've made it through the minefield of possible errors. Return true to indicate that
     // we've succeeded.
     qDebug() << "Finished reading authentication response.";

launcher/minecraft/auth/flows/Mojang.cpp

@@ -1,7 +1,7 @@
 #include "Mojang.h"
 
 #include "minecraft/auth/steps/YggdrasilStep.h"
-#include "minecraft/auth/steps/MinecraftProfileStep.h"
+#include "minecraft/auth/steps/MinecraftProfileStepMojang.h"
 #include "minecraft/auth/steps/MigrationEligibilityStep.h"
 #include "minecraft/auth/steps/GetSkinStep.h"
 
@@ -10,7 +10,7 @@ MojangRefresh::MojangRefresh(
     QObject *parent
 ) : AuthFlow(data, parent) {
     m_steps.append(new YggdrasilStep(m_data, QString()));
-    m_steps.append(new MinecraftProfileStep(m_data));
+    m_steps.append(new MinecraftProfileStepMojang(m_data));
     m_steps.append(new MigrationEligibilityStep(m_data));
     m_steps.append(new GetSkinStep(m_data));
 }
@@ -21,7 +21,7 @@ MojangLogin::MojangLogin(
     QObject *parent
 ): AuthFlow(data, parent), m_password(password) {
     m_steps.append(new YggdrasilStep(m_data, m_password));
-    m_steps.append(new MinecraftProfileStep(m_data));
+    m_steps.append(new MinecraftProfileStepMojang(m_data));
     m_steps.append(new MigrationEligibilityStep(m_data));
     m_steps.append(new GetSkinStep(m_data));
 }

launcher/minecraft/auth/steps/LauncherLoginStep.cpp

@@ -50,7 +50,9 @@ void LauncherLoginStep::onRequestDone(
     auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
     requestor->deleteLater();
 
+#ifndef NDEBUG
     qDebug() << data;
+#endif
     if (error != QNetworkReply::NoError) {
         qWarning() << "Reply error:" << error;
 #ifndef NDEBUG

launcher/minecraft/auth/steps/MinecraftProfileStepMojang.cpp

@@ -0,0 +1,94 @@
+#include "MinecraftProfileStepMojang.h"
+
+#include <QNetworkRequest>
+
+#include "minecraft/auth/AuthRequest.h"
+#include "minecraft/auth/Parsers.h"
+
+MinecraftProfileStepMojang::MinecraftProfileStepMojang(AccountData* data) : AuthStep(data) {
+
+}
+
+MinecraftProfileStepMojang::~MinecraftProfileStepMojang() noexcept = default;
+
+QString MinecraftProfileStepMojang::describe() {
+    return tr("Fetching the Minecraft profile.");
+}
+
+
+void MinecraftProfileStepMojang::perform() {
+    if (m_data->minecraftProfile.id.isEmpty()) {
+        emit finished(AccountTaskState::STATE_FAILED_HARD, tr("A UUID is required to get the profile."));
+        return;
+    }
+
+    // use session server instead of profile due to profile endpoint being locked for locked Mojang accounts
+    QUrl url = QUrl("https://sessionserver.mojang.com/session/minecraft/profile/" + m_data->minecraftProfile.id);
+    QNetworkRequest req = QNetworkRequest(url);
+    AuthRequest *request = new AuthRequest(this);
+    connect(request, &AuthRequest::finished, this, &MinecraftProfileStepMojang::onRequestDone);
+    request->get(req);
+}
+
+void MinecraftProfileStepMojang::rehydrate() {
+    // NOOP, for now. We only save bools and there's nothing to check.
+}
+
+void MinecraftProfileStepMojang::onRequestDone(
+    QNetworkReply::NetworkError error,
+    QByteArray data,
+    QList<QNetworkReply::RawHeaderPair> headers
+) {
+    auto requestor = qobject_cast<AuthRequest *>(QObject::sender());
+    requestor->deleteLater();
+
+#ifndef NDEBUG
+    qDebug() << data;
+#endif
+    if (error == QNetworkReply::ContentNotFoundError) {
+        // NOTE: Succeed even if we do not have a profile. This is a valid account state.
+        if(m_data->type == AccountType::Mojang) {
+            m_data->minecraftEntitlement.canPlayMinecraft = false;
+            m_data->minecraftEntitlement.ownsMinecraft = false;
+        }
+        m_data->minecraftProfile = MinecraftProfile();
+        emit finished(
+            AccountTaskState::STATE_SUCCEEDED,
+            tr("Account has no Minecraft profile.")
+        );
+        return;
+    }
+    if (error != QNetworkReply::NoError) {
+        qWarning() << "Error getting profile:";
+        qWarning() << " HTTP Status:        " << requestor->httpStatus_;
+        qWarning() << " Internal error no.: " << error;
+        qWarning() << " Error string:       " << requestor->errorString_;
+
+        qWarning() << " Response:";
+        qWarning() << QString::fromUtf8(data);
+
+        emit finished(
+            AccountTaskState::STATE_FAILED_SOFT,
+            tr("Minecraft Java profile acquisition failed.")
+        );
+        return;
+    }
+    if(!Parsers::parseMinecraftProfileMojang(data, m_data->minecraftProfile)) {
+        m_data->minecraftProfile = MinecraftProfile();
+        emit finished(
+            AccountTaskState::STATE_FAILED_SOFT,
+            tr("Minecraft Java profile response could not be parsed")
+        );
+        return;
+    }
+
+    if(m_data->type == AccountType::Mojang) {
+        auto validProfile = m_data->minecraftProfile.validity == Katabasis::Validity::Certain;
+        m_data->minecraftEntitlement.canPlayMinecraft = validProfile;
+        m_data->minecraftEntitlement.ownsMinecraft = validProfile;
+    }
+    emit finished(
+        AccountTaskState::STATE_WORKING,
+        tr("Minecraft Java profile acquisition succeeded.")
+    );
+}

launcher/minecraft/auth/steps/MinecraftProfileStepMojang.h

@@ -0,0 +1,22 @@
+#pragma once
+#include <QObject>
+
+#include "QObjectPtr.h"
+#include "minecraft/auth/AuthStep.h"
+
+
+class MinecraftProfileStepMojang : public AuthStep {
+    Q_OBJECT
+
+public:
+    explicit MinecraftProfileStepMojang(AccountData *data);
+    virtual ~MinecraftProfileStepMojang() noexcept;
+
+    void perform() override;
+    void rehydrate() override;
+
+    QString describe() override;
+
+private slots:
+    void onRequestDone(QNetworkReply::NetworkError, QByteArray, QList<QNetworkReply::RawHeaderPair>);
+};

launcher/minecraft/launch/LauncherPartLaunch.cpp

@@ -25,7 +25,8 @@
 
 LauncherPartLaunch::LauncherPartLaunch(LaunchTask *parent) : LaunchStep(parent)
 {
-    if (APPLICATION->settings()->get("CloseAfterLaunch").toBool())
+    auto instance = parent->instance();
+    if (instance->settings()->get("CloseAfterLaunch").toBool())
     {
         std::shared_ptr<QMetaObject::Connection> connection{new QMetaObject::Connection};
         *connection = connect(&m_process, &LoggedProcess::log, this, [=](QStringList lines, MessageLevel::Enum level) {
@@ -168,7 +169,8 @@ void LauncherPartLaunch::on_state(LoggedProcess::State state)
         }
         case LoggedProcess::Finished:
         {
-            if (APPLICATION->settings()->get("CloseAfterLaunch").toBool())
+            auto instance = m_parent->instance();
+            if (instance->settings()->get("CloseAfterLaunch").toBool())
                 APPLICATION->showMainWindow();
 
             m_parent->setPid(-1);

launcher/minecraft/mod/LocalModParseTask.cpp

@@ -8,6 +8,7 @@
 #include <quazip/quazipfile.h>
 #include <toml.h>
 
+#include "Json.h"
 #include "settings/INIFile.h"
 #include "FileSystem.h"
 
@@ -262,6 +263,44 @@ std::shared_ptr<ModDetails> ReadFabricModInfo(QByteArray contents)
     return details;
 }
 
+// https://github.com/QuiltMC/rfcs/blob/master/specification/0002-quilt.mod.json.md
+std::shared_ptr<ModDetails> ReadQuiltModInfo(QByteArray contents)
+{
+    QJsonParseError jsonError;
+    QJsonDocument jsonDoc = QJsonDocument::fromJson(contents, &jsonError);
+    auto object = Json::requireObject(jsonDoc, "quilt.mod.json");
+    auto schemaVersion = Json::ensureInteger(object.value("schema_version"), 0, "Quilt schema_version");
+
+    std::shared_ptr<ModDetails> details = std::make_shared<ModDetails>();
+
+    // https://github.com/QuiltMC/rfcs/blob/be6ba280d785395fefa90a43db48e5bfc1d15eb4/specification/0002-quilt.mod.json.md
+    if (schemaVersion == 1)
+    {
+        auto modInfo = Json::requireObject(object.value("quilt_loader"), "Quilt mod info");
+
+        details->mod_id = Json::requireString(modInfo.value("id"), "Mod ID");
+        details->version = Json::requireString(modInfo.value("version"), "Mod version");
+
+        auto modMetadata = Json::ensureObject(modInfo.value("metadata"));
+
+        details->name = Json::ensureString(modMetadata.value("name"), details->mod_id);
+        details->description = Json::ensureString(modMetadata.value("description"));
+
+        auto modContributors = Json::ensureObject(modMetadata.value("contributors"));
+
+        // We don't really care about the role of a contributor here
+        details->authors += modContributors.keys();
+
+        auto modContact = Json::ensureObject(modMetadata.value("contact"));
+
+        if (modContact.contains("homepage"))
+        {
+            details->homeurl = Json::requireString(modContact.value("homepage"));
+        }
+    }
+    return details;
+}
+
 std::shared_ptr<ModDetails> ReadForgeInfo(QByteArray contents)
 {
     std::shared_ptr<ModDetails> details = std::make_shared<ModDetails>();
@@ -391,7 +430,20 @@ void LocalModParseTask::processAsZip()
         zip.close();
         return;
     }
-    else if (zip.setCurrentFile("fabric.mod.json"))  // TODO: Support quilt.mod.json
+    else if (zip.setCurrentFile("quilt.mod.json"))
+    {
+        if (!file.open(QIODevice::ReadOnly))
+        {
+            zip.close();
+            return;
+        }
+
+        m_result->details = ReadQuiltModInfo(file.readAll());
+        file.close();
+        zip.close();
+        return;
+    }
+    else if (zip.setCurrentFile("fabric.mod.json"))
     {
         if (!file.open(QIODevice::ReadOnly))
         {

launcher/modplatform/ModAPI.h

@@ -16,14 +16,21 @@ class ModAPI {
    public:
     virtual ~ModAPI() = default;
 
-    // https://docs.curseforge.com/?http#tocS_ModLoaderType
-    enum ModLoaderType { Unspecified = 0, Forge = 1, Cauldron = 2, LiteLoader = 3, Fabric = 4, Quilt = 5 };
+    enum ModLoaderType {
+        Unspecified = 0,
+        Forge = 1 << 0,
+        Cauldron = 1 << 1,
+        LiteLoader = 1 << 2,
+        Fabric = 1 << 3,
+        Quilt = 1 << 4
+    };
+    Q_DECLARE_FLAGS(ModLoaderTypes, ModLoaderType)
 
     struct SearchArgs {
         int offset;
         QString search;
         QString sorting;
-        ModLoaderType mod_loader;
+        ModLoaderTypes loaders;
         std::list<Version> versions;
     };
 
@@ -33,7 +40,7 @@ class ModAPI {
     struct VersionSearchArgs {
         QString addonId;
         std::list<Version> mcVersions;
-        ModLoaderType loader;
+        ModLoaderTypes loaders;
     };
 
     virtual void getVersions(CallerType* caller, VersionSearchArgs&& args) const = 0;
@@ -61,7 +68,7 @@ class ModAPI {
     {
         QString s;
         for(auto& ver : mcVersions){
-            s += QString("%1,").arg(ver.toString());
+            s += QString("\"%1\",").arg(ver.toString());
         }
         s.remove(s.length() - 1, 1); //remove last comma
         return s;

launcher/modplatform/atlauncher/ATLPackInstallTask.cpp

@@ -1,18 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
 /*
- * Copyright 2020-2021 Jamie Mansfield <jmansfield@cadixdev.org>
- * Copyright 2021 Petr Mrazek <peterix@gmail.com>
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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 2020-2021 Jamie Mansfield <jmansfield@cadixdev.org>
+ *      Copyright 2021 Petr Mrazek <peterix@gmail.com>
+ *
+ *      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.
  */
 
 #include "ATLPackInstallTask.h"
@@ -39,6 +58,8 @@
 
 namespace ATLauncher {
 
+static Meta::VersionPtr getComponentVersion(const QString& uid, const QString& version);
+
 PackInstallTask::PackInstallTask(UserInteractionSupport *support, QString pack, QString version)
 {
     m_support = support;
@@ -74,14 +95,13 @@ void PackInstallTask::onDownloadSucceeded()
     qDebug() << "PackInstallTask::onDownloadSucceeded: " << QThread::currentThreadId();
     jobPtr.reset();
 
-    QJsonParseError parse_error;
+    QJsonParseError parse_error {};
     QJsonDocument doc = QJsonDocument::fromJson(response, &parse_error);
     if(parse_error.error != QJsonParseError::NoError) {
         qWarning() << "Error while parsing JSON response from FTB at " << parse_error.offset << " reason: " << parse_error.errorString();
         qWarning() << response;
         return;
     }
-
     auto obj = doc.object();
 
     ATLauncher::PackVersion version;
@@ -96,19 +116,15 @@ void PackInstallTask::onDownloadSucceeded()
     }
     m_version = version;
 
-    auto vlist = APPLICATION->metadataIndex()->get("net.minecraft");
-    if(!vlist)
-    {
-        emitFailed(tr("Failed to get local metadata index for %1").arg("net.minecraft"));
-        return;
-    }
+    // Display install message if one exists
+    if (!m_version.messages.install.isEmpty())
+        m_support->displayMessage(m_version.messages.install);
 
-    auto ver = vlist->getVersion(m_version.minecraft);
+    auto ver = getComponentVersion("net.minecraft", m_version.minecraft);
     if (!ver) {
-        emitFailed(tr("Failed to get local metadata index for '%1' v%2").arg("net.minecraft").arg(m_version.minecraft));
+        emitFailed(tr("Failed to get local metadata index for '%1' v%2").arg("net.minecraft", m_version.minecraft));
         return;
     }
-    ver->load(Net::Mode::Online);
     minecraftVersion = ver;
 
     if(m_version.noConfigs) {
@@ -305,7 +321,48 @@ bool PackInstallTask::createLibrariesComponent(QString instanceRoot, std::shared
     auto f = std::make_shared<VersionFile>();
     f->name = m_pack + " " + m_version_name + " (libraries)";
 
+    const static QMap<QString, QString> liteLoaderMap = {
+            { "61179803bcd5fb7790789b790908663d", "1.12-SNAPSHOT" },
+            { "1420785ecbfed5aff4a586c5c9dd97eb", "1.12.2-SNAPSHOT" },
+            { "073f68e2fcb518b91fd0d99462441714", "1.6.2_03" },
+            { "10a15b52fc59b1bfb9c05b56de1097d6", "1.6.2_02" },
+            { "b52f90f08303edd3d4c374e268a5acf1", "1.6.2_04" },
+            { "ea747e24e03e24b7cad5bc8a246e0319", "1.6.2_01" },
+            { "55785ccc82c07ff0ba038fe24be63ea2", "1.7.10_01" },
+            { "63ada46e033d0cb6782bada09ad5ca4e", "1.7.10_04" },
+            { "7983e4b28217c9ae8569074388409c86", "1.7.10_03" },
+            { "c09882458d74fe0697c7681b8993097e", "1.7.10_02" },
+            { "db7235aefd407ac1fde09a7baba50839", "1.7.10_00" },
+            { "6e9028816027f53957bd8fcdfabae064", "1.8" },
+            { "5e732dc446f9fe2abe5f9decaec40cde", "1.10-SNAPSHOT" },
+            { "3a98b5ed95810bf164e71c1a53be568d", "1.11.2-SNAPSHOT" },
+            { "ba8e6285966d7d988a96496f48cbddaa", "1.8.9-SNAPSHOT" },
+            { "8524af3ac3325a82444cc75ae6e9112f", "1.11-SNAPSHOT" },
+            { "53639d52340479ccf206a04f5e16606f", "1.5.2_01" },
+            { "1fcdcf66ce0a0806b7ad8686afdce3f7", "1.6.4_00" },
+            { "531c116f71ae2b11033f9a11a0f8e668", "1.6.4_01" },
+            { "4009eeb99c9068f608d3483a6439af88", "1.7.2_03" },
+            { "66f343354b8417abce1a10d557d2c6e9", "1.7.2_04" },
+            { "ab554c21f28fbc4ae9b098bcb5f4cceb", "1.7.2_05" },
+            { "e1d76a05a3723920e2f80a5e66c45f16", "1.7.2_02" },
+            { "00318cb0c787934d523f63cdfe8ddde4", "1.9-SNAPSHOT" },
+            { "986fd1ee9525cb0dcab7609401cef754", "1.9.4-SNAPSHOT" },
+            { "571ad5e6edd5ff40259570c9be588bb5", "1.9.4" },
+            { "1cdd72f7232e45551f16cc8ffd27ccf3", "1.10.2-SNAPSHOT" },
+            { "8a7c21f32d77ee08b393dd3921ced8eb", "1.10.2" },
+            { "b9bef8abc8dc309069aeba6fbbe58980", "1.12.1-SNAPSHOT" }
+    };
+
     for(const auto & lib : m_version.libraries) {
+        // If the library is LiteLoader, we need to ignore it and handle it separately.
+        if (liteLoaderMap.contains(lib.md5)) {
+            auto ver = getComponentVersion("com.mumfrey.liteloader", liteLoaderMap.value(lib.md5));
+            if (ver) {
+                componentsToInstall.insert("com.mumfrey.liteloader", ver);
+                continue;
+            }
+        }
+
         auto libName = detectLibrary(lib);
         GradleSpecifier libSpecifier(libName);
 
@@ -357,7 +414,31 @@ bool PackInstallTask::createLibrariesComponent(QString instanceRoot, std::shared
 
 bool PackInstallTask::createPackComponent(QString instanceRoot, std::shared_ptr<PackProfile> profile)
 {
-    if(m_version.mainClass == QString() && m_version.extraArguments == QString()) {
+    if (m_version.mainClass.mainClass.isEmpty() && m_version.extraArguments.arguments.isEmpty()) {
+        return true;
+    }
+
+    auto mainClass = m_version.mainClass.mainClass;
+    auto extraArguments = m_version.extraArguments.arguments;
+
+    auto hasMainClassDepends = !m_version.mainClass.depends.isEmpty();
+    auto hasExtraArgumentsDepends = !m_version.extraArguments.depends.isEmpty();
+    if (hasMainClassDepends || hasExtraArgumentsDepends) {
+        QSet<QString> mods;
+        for (const auto& item : m_version.mods) {
+            mods.insert(item.name);
+        }
+
+        if (hasMainClassDepends && !mods.contains(m_version.mainClass.depends)) {
+            mainClass = "";
+        }
+
+        if (hasExtraArgumentsDepends && !mods.contains(m_version.extraArguments.depends)) {
+            extraArguments = "";
+        }
+    }
+
+    if (mainClass.isEmpty() && extraArguments.isEmpty()) {
         return true;
     }
 
@@ -385,12 +466,12 @@ bool PackInstallTask::createPackComponent(QString instanceRoot, std::shared_ptr<
 
     auto f = std::make_shared<VersionFile>();
     f->name = m_pack + " " + m_version_name;
-    if(m_version.mainClass != QString() && !mainClasses.contains(m_version.mainClass)) {
-        f->mainClass = m_version.mainClass;
+    if (!mainClass.isEmpty() && !mainClasses.contains(mainClass)) {
+        f->mainClass = mainClass;
     }
 
     // Parse out tweakers
-    auto args = m_version.extraArguments.split(" ");
+    auto args = extraArguments.split(" ");
     QString previous;
     for(auto arg : args) {
         if(arg.startsWith("--tweakClass=") || previous == "--tweakClass") {
@@ -502,7 +583,7 @@ void PackInstallTask::downloadMods()
     QVector<QString> selectedMods;
     if (!optionalMods.isEmpty()) {
         setStatus(tr("Selecting optional mods..."));
-        selectedMods = m_support->chooseOptionalMods(optionalMods);
+        selectedMods = m_support->chooseOptionalMods(m_version, optionalMods);
     }
 
     setStatus(tr("Downloading mods..."));
@@ -574,19 +655,12 @@ void PackInstallTask::downloadMods()
             jobPtr->addNetAction(dl);
 
             auto path = FS::PathCombine(m_stagingPath, "minecraft", relpath, mod.file);
-            qDebug() << "Will download" << url << "to" << path;
-            modsToCopy[entry->getFullPath()] = path;
 
             if(mod.type == ModType::Forge) {
-                auto vlist = APPLICATION->metadataIndex()->get("net.minecraftforge");
-                if(vlist)
-                {
-                    auto ver = vlist->getVersion(mod.version);
-                    if(ver) {
-                        ver->load(Net::Mode::Online);
-                        componentsToInstall.insert("net.minecraftforge", ver);
-                        continue;
-                    }
+                auto ver = getComponentVersion("net.minecraftforge", mod.version);
+                if (ver) {
+                    componentsToInstall.insert("net.minecraftforge", ver);
+                    continue;
                 }
 
                 qDebug() << "Jarmod: " + path;
@@ -597,6 +671,10 @@ void PackInstallTask::downloadMods()
                 qDebug() << "Jarmod: " + path;
                 jarmods.push_back(path);
             }
+
+            // Download after Forge handling, to avoid downloading Forge twice.
+            qDebug() << "Will download" << url << "to" << path;
+            modsToCopy[entry->getFullPath()] = path;
         }
     }
 
@@ -703,6 +781,17 @@ bool PackInstallTask::extractMods(
     for (auto iter = toCopy.begin(); iter != toCopy.end(); iter++) {
         auto &from = iter.key();
         auto &to = iter.value();
+
+        // If the file already exists, assume the mod is the correct copy - and remove
+        // the copy from the Configs.zip
+        QFileInfo fileInfo(to);
+        if (fileInfo.exists()) {
+            if (!QFile::remove(to)) {
+                qWarning() << "Failed to delete" << to;
+                return false;
+            }
+        }
+
         FS::copy fileCopyOperation(from, to);
         if(!fileCopyOperation()) {
             qWarning() << "Failed to copy" << from << "to" << to;
@@ -779,4 +868,23 @@ void PackInstallTask::install()
     emitSucceeded();
 }
 
+static Meta::VersionPtr getComponentVersion(const QString& uid, const QString& version)
+{
+    auto vlist = APPLICATION->metadataIndex()->get(uid);
+    if (!vlist)
+        return {};
+
+    if (!vlist->isLoaded())
+        vlist->load(Net::Mode::Online);
+
+    auto ver = vlist->getVersion(version);
+    if (!ver)
+        return {};
+
+    if (!ver->isLoaded())
+        ver->load(Net::Mode::Online);
+
+    return ver;
+}
+
 }

launcher/modplatform/atlauncher/ATLPackInstallTask.h

@@ -1,18 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
 /*
- * Copyright 2020-2021 Jamie Mansfield <jmansfield@cadixdev.org>
- * Copyright 2021 Petr Mrazek <peterix@gmail.com>
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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 2020-2021 Jamie Mansfield <jmansfield@cadixdev.org>
+ *      Copyright 2021 Petr Mrazek <peterix@gmail.com>
+ *
+ *      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.
  */
 
 #pragma once
@@ -37,7 +56,7 @@ public:
     /**
      * Requests a user interaction to select which optional mods should be installed.
      */
-    virtual QVector<QString> chooseOptionalMods(QVector<ATLauncher::VersionMod> mods) = 0;
+    virtual QVector<QString> chooseOptionalMods(PackVersion version, QVector<ATLauncher::VersionMod> mods) = 0;
 
     /**
      * Requests a user interaction to select a component version from a given version list
@@ -45,6 +64,10 @@ public:
      */
     virtual QString chooseVersion(Meta::VersionListPtr vlist, QString minecraftVersion) = 0;
 
+    /**
+     * Requests a user interaction to display a message.
+     */
+    virtual void displayMessage(QString message) = 0;
 };
 
 class PackInstallTask : public InstanceTask

launcher/modplatform/atlauncher/ATLPackManifest.cpp

@@ -1,18 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
 /*
- * Copyright 2020-2021 Jamie Mansfield <jmansfield@cadixdev.org>
- * Copyright 2021 Petr Mrazek <peterix@gmail.com>
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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 2020-2021 Jamie Mansfield <jmansfield@cadixdev.org>
+ *      Copyright 2021 Petr Mrazek <peterix@gmail.com>
+ *
+ *      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.
  */
 
 #include "ATLPackManifest.h"
@@ -178,6 +197,8 @@ static void loadVersionMod(ATLauncher::VersionMod & p, QJsonObject & obj) {
             p.depends.append(Json::requireString(depends));
         }
     }
+    p.colour = Json::ensureString(obj, QString("colour"), "");
+    p.warning = Json::ensureString(obj, QString("warning"), "");
 
     p.client = Json::ensureBoolean(obj, QString("client"), false);
 
@@ -185,6 +206,24 @@ static void loadVersionMod(ATLauncher::VersionMod & p, QJsonObject & obj) {
     p.effectively_hidden = p.hidden || p.library;
 }
 
+static void loadVersionMessages(ATLauncher::VersionMessages& m, QJsonObject& obj)
+{
+    m.install = Json::ensureString(obj, "install", "");
+    m.update = Json::ensureString(obj, "update", "");
+}
+
+static void loadVersionMainClass(ATLauncher::PackVersionMainClass& m, QJsonObject& obj)
+{
+    m.mainClass = Json::ensureString(obj, "mainClass", "");
+    m.depends = Json::ensureString(obj, "depends", "");
+}
+
+static void loadVersionExtraArguments(ATLauncher::PackVersionExtraArguments& a, QJsonObject& obj)
+{
+    a.arguments = Json::ensureString(obj, "arguments", "");
+    a.depends = Json::ensureString(obj, "depends", "");
+}
+
 void ATLauncher::loadVersion(PackVersion & v, QJsonObject & obj)
 {
     v.version = Json::requireString(obj, "version");
@@ -193,12 +232,12 @@ void ATLauncher::loadVersion(PackVersion & v, QJsonObject & obj)
 
     if(obj.contains("mainClass")) {
         auto main = Json::requireObject(obj, "mainClass");
-        v.mainClass = Json::ensureString(main, "mainClass", "");
+        loadVersionMainClass(v.mainClass, main);
     }
 
     if(obj.contains("extraArguments")) {
         auto arguments = Json::requireObject(obj, "extraArguments");
-        v.extraArguments = Json::ensureString(arguments, "arguments", "");
+        loadVersionExtraArguments(v.extraArguments, arguments);
     }
 
     if(obj.contains("loader")) {
@@ -232,4 +271,17 @@ void ATLauncher::loadVersion(PackVersion & v, QJsonObject & obj)
         auto configsObj = Json::requireObject(obj, "configs");
         loadVersionConfigs(v.configs, configsObj);
     }
+
+    auto colourObj = Json::ensureObject(obj, "colours");
+    for (const auto &key : colourObj.keys()) {
+        v.colours[key] = Json::requireString(colourObj.value(key), "colour");
+    }
+
+    auto warningsObj = Json::ensureObject(obj, "warnings");
+    for (const auto &key : warningsObj.keys()) {
+        v.warnings[key] = Json::requireString(warningsObj.value(key), "warning");
+    }
+
+    auto messages = Json::ensureObject(obj, "messages");
+    loadVersionMessages(v.messages, messages);
 }

launcher/modplatform/atlauncher/ATLPackManifest.h

@@ -1,24 +1,44 @@
+// SPDX-License-Identifier: GPL-3.0-only
 /*
- * Copyright 2020 Jamie Mansfield <jmansfield@cadixdev.org>
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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 2020 Jamie Mansfield <jmansfield@cadixdev.org>
+ *
+ *      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.
  */
 
 #pragma once
 
+#include <QJsonObject>
+#include <QMap>
 #include <QString>
 #include <QVector>
-#include <QJsonObject>
 
 namespace ATLauncher
 {
@@ -109,6 +129,8 @@ struct VersionMod
     bool library;
     QString group;
     QVector<QString> depends;
+    QString colour;
+    QString warning;
 
     bool client;
 
@@ -122,18 +144,40 @@ struct VersionConfigs
     QString sha1;
 };
 
+struct VersionMessages
+{
+    QString install;
+    QString update;
+};
+
+struct PackVersionMainClass
+{
+    QString mainClass;
+    QString depends;
+};
+
+struct PackVersionExtraArguments
+{
+    QString arguments;
+    QString depends;
+};
+
 struct PackVersion
 {
     QString version;
     QString minecraft;
     bool noConfigs;
-    QString mainClass;
-    QString extraArguments;
+    PackVersionMainClass mainClass;
+    PackVersionExtraArguments extraArguments;
 
     VersionLoader loader;
     QVector<VersionLibrary> libraries;
     QVector<VersionMod> mods;
     VersionConfigs configs;
+
+    QMap<QString, QString> colours;
+    QMap<QString, QString> warnings;
+    VersionMessages messages;
 };
 
 void loadVersion(PackVersion & v, QJsonObject & obj);

launcher/modplatform/atlauncher/ATLShareCode.cpp

@@ -0,0 +1,60 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
+ *
+ *  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 "ATLShareCode.h"
+
+#include "Json.h"
+
+namespace ATLauncher {
+
+static void loadShareCodeMod(ShareCodeMod& m, QJsonObject& obj)
+{
+    m.selected = Json::requireBoolean(obj, "selected");
+    m.name = Json::requireString(obj, "name");
+}
+
+static void loadShareCode(ShareCode& c, QJsonObject& obj)
+{
+    c.pack = Json::requireString(obj, "pack");
+    c.version = Json::requireString(obj, "version");
+
+    auto mods = Json::requireObject(obj, "mods");
+    auto optional = Json::requireArray(mods, "optional");
+    for (const auto modRaw : optional) {
+        auto modObj = Json::requireObject(modRaw);
+        ShareCodeMod mod;
+        loadShareCodeMod(mod, modObj);
+        c.mods.append(mod);
+    }
+}
+
+void loadShareCodeResponse(ShareCodeResponse& r, QJsonObject& obj)
+{
+    r.error = Json::requireBoolean(obj, "error");
+    r.code = Json::requireInteger(obj, "code");
+
+    if (obj.contains("message") && !obj.value("message").isNull())
+        r.message = Json::requireString(obj, "message");
+
+    if (!r.error) {
+        auto dataRaw = Json::requireObject(obj, "data");
+        loadShareCode(r.data, dataRaw);
+    }
+}
+
+}

launcher/modplatform/atlauncher/ATLShareCode.h

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 Jamie Mansfield <jmansfield@cadixdev.org>
+ *
+ *  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 <QString>
+#include <QVector>
+#include <QJsonObject>
+
+namespace ATLauncher {
+
+struct ShareCodeMod {
+    bool selected;
+    QString name;
+};
+
+struct ShareCode {
+    QString pack;
+    QString version;
+    QVector<ShareCodeMod> mods;
+};
+
+struct ShareCodeResponse {
+    bool error;
+    int code;
+    QString message;
+    ShareCode data;
+};
+
+void loadShareCodeResponse(ShareCodeResponse& r, QJsonObject& obj);
+
+}

launcher/modplatform/flame/FileResolvingTask.cpp

@@ -1,63 +1,127 @@
 #include "FileResolvingTask.h"
+
 #include "Json.h"
+#include "net/Upload.h"
 
-namespace {
-    const char * metabase = "https://cursemeta.dries007.net";
-}
-
-Flame::FileResolvingTask::FileResolvingTask(shared_qobject_ptr<QNetworkAccessManager> network, Flame::Manifest& toProcess)
+Flame::FileResolvingTask::FileResolvingTask(const shared_qobject_ptr<QNetworkAccessManager>& network, Flame::Manifest& toProcess)
     : m_network(network), m_toProcess(toProcess)
-{
-}
+{}
 
 void Flame::FileResolvingTask::executeTask()
 {
     setStatus(tr("Resolving mod IDs..."));
     setProgress(0, m_toProcess.files.size());
     m_dljob = new NetJob("Mod id resolver", m_network);
-    results.resize(m_toProcess.files.size());
-    int index = 0;
-    for(auto & file: m_toProcess.files)
-    {
-        auto projectIdStr = QString::number(file.projectId);
-        auto fileIdStr = QString::number(file.fileId);
-        QString metaurl = QString("%1/%2/%3.json").arg(metabase, projectIdStr, fileIdStr);
-        auto dl = Net::Download::makeByteArray(QUrl(metaurl), &results[index]);
-        m_dljob->addNetAction(dl);
-        index ++;
-    }
+    result.reset(new QByteArray());
+    //build json data to send
+    QJsonObject object;
+
+    object["fileIds"] = QJsonArray::fromVariantList(std::accumulate(m_toProcess.files.begin(), m_toProcess.files.end(), QVariantList(), [](QVariantList& l, const File& s) {
+        l.push_back(s.fileId);
+        return l;
+    }));
+    QByteArray data = Json::toText(object);
+    auto dl = Net::Upload::makeByteArray(QUrl("https://api.curseforge.com/v1/mods/files"), result.get(), data);
+    m_dljob->addNetAction(dl);
     connect(m_dljob.get(), &NetJob::finished, this, &Flame::FileResolvingTask::netJobFinished);
     m_dljob->start();
 }
 
 void Flame::FileResolvingTask::netJobFinished()
 {
-    bool failed = false;
     int index = 0;
-    for(auto & bytes: results)
-    {
-        auto & out = m_toProcess.files[index];
-        try
-        {
-            failed &= (!out.parseFromBytes(bytes));
-        }
-        catch (const JSONValidationError &e)
-        {
+    // job to check modrinth for blocked projects
+    auto job = new NetJob("Modrinth check", m_network);
+    blockedProjects = QMap<File *,QByteArray *>();
+    auto doc = Json::requireDocument(*result);
+    auto array = Json::requireArray(doc.object()["data"]);
+    for (QJsonValueRef file : array) {
+        auto fileid = Json::requireInteger(Json::requireObject(file)["id"]);
+        auto& out = m_toProcess.files[fileid];
+        try {
+           out.parseFromObject(Json::requireObject(file));
+        } catch (const JSONValidationError& e) {
+            qDebug() << "Blocked mod on curseforge" << out.fileName;
+            auto hash = out.hash;
+            if(!hash.isEmpty()) {
+                auto url = QString("https://api.modrinth.com/v2/version_file/%1?algorithm=sha1").arg(hash);
+                auto output = new QByteArray();
+                auto dl = Net::Download::makeByteArray(QUrl(url), output);
+                QObject::connect(dl.get(), &Net::Download::succeeded, [&out]() {
+                    out.resolved = true;
+                });
 
-            qCritical() << "Resolving of" << out.projectId << out.fileId << "failed because of a parsing error:";
-            qCritical() << e.cause();
-            qCritical() << "JSON:";
-            qCritical() << bytes;
-            failed = true;
+                job->addNetAction(dl);
+                blockedProjects.insert(&out, output);
+            }
         }
         index++;
     }
-    if(!failed)
-    {
+    connect(job, &NetJob::finished, this, &Flame::FileResolvingTask::modrinthCheckFinished);
+
+    job->start();
+}
+
+void Flame::FileResolvingTask::modrinthCheckFinished() {
+    qDebug() << "Finished with blocked mods : " << blockedProjects.size();
+
+    for (auto it = blockedProjects.keyBegin(); it != blockedProjects.keyEnd(); it++) {
+        auto &out = *it;
+        auto bytes = blockedProjects[out];
+        if (!out->resolved) {
+            delete bytes;
+            continue;
+        }
+        QJsonDocument doc = QJsonDocument::fromJson(*bytes);
+        auto obj = doc.object();
+        auto array = Json::requireArray(obj,"files");
+        for (auto file: array) {
+            auto fileObj = Json::requireObject(file);
+            auto primary = Json::requireBoolean(fileObj,"primary");
+            if (primary) {
+                out->url = Json::requireUrl(fileObj,"url");
+                qDebug() << "Found alternative on modrinth " << out->fileName;
+                break;
+            }
+        }
+        delete bytes;
+    }
+    //copy to an output list and filter out projects found on modrinth
+    auto block = new QList<File *>();
+    auto it = blockedProjects.keys();
+    std::copy_if(it.begin(), it.end(), std::back_inserter(*block), [](File *f) {
+        return !f->resolved;
+    });
+    //Display not found mods early
+    if (!block->empty()) {
+        //blocked mods found, we need the slug for displaying.... we need another job :D !
+        auto slugJob = new NetJob("Slug Job", m_network);
+        auto slugs = QVector<QByteArray>(block->size());
+        auto index = 0;
+        for (auto fileInfo: *block) {
+            auto projectId = fileInfo->projectId;
+            slugs[index] = QByteArray();
+            auto url = QString("https://api.curseforge.com/v1/mods/%1").arg(projectId);
+            auto dl = Net::Download::makeByteArray(url, &slugs[index]);
+            slugJob->addNetAction(dl);
+            index++;
+        }
+        connect(slugJob, &NetJob::succeeded, this, [slugs, this, slugJob, block]() {
+            slugJob->deleteLater();
+            auto index = 0;
+            for (const auto &slugResult: slugs) {
+                auto json = QJsonDocument::fromJson(slugResult);
+                auto base = Json::requireString(Json::requireObject(Json::requireObject(Json::requireObject(json),"data"),"links"),
+                        "websiteUrl");
+                auto mod = block->at(index);
+                auto link = QString("%1/download/%2").arg(base, QString::number(mod->fileId));
+                mod->websiteUrl = link;
+                index++;
+            }
+            emitSucceeded();
+        });
+        slugJob->start();
+    } else {
         emitSucceeded();
     }
-    else
-    {
-        emitFailed(tr("Some mod ID resolving tasks failed."));
-    }
 }

launcher/modplatform/flame/FileResolvingTask.h

@@ -10,7 +10,7 @@ class FileResolvingTask : public Task
 {
     Q_OBJECT
 public:
-    explicit FileResolvingTask(shared_qobject_ptr<QNetworkAccessManager> network, Flame::Manifest &toProcess);
+    explicit FileResolvingTask(const shared_qobject_ptr<QNetworkAccessManager>& network, Flame::Manifest &toProcess);
     virtual ~FileResolvingTask() {};
 
     const Flame::Manifest &getResults() const
@@ -27,7 +27,11 @@ protected slots:
 private: /* data */
     shared_qobject_ptr<QNetworkAccessManager> m_network;
     Flame::Manifest m_toProcess;
-    QVector<QByteArray> results;
+    std::shared_ptr<QByteArray> result;
     NetJob::Ptr m_dljob;
+
+    void modrinthCheckFinished();
+
+    QMap<File *, QByteArray *> blockedProjects;
 };
 }

launcher/modplatform/flame/FlameAPI.h

@@ -3,41 +3,66 @@
 #include "modplatform/helpers/NetworkModAPI.h"
 
 class FlameAPI : public NetworkModAPI {
+   private:
+    inline auto getSortFieldInt(QString sortString) const -> int
+    {
+        return sortString == "Featured"         ? 1
+               : sortString == "Popularity"     ? 2
+               : sortString == "LastUpdated"    ? 3
+               : sortString == "Name"           ? 4
+               : sortString == "Author"         ? 5
+               : sortString == "TotalDownloads" ? 6
+               : sortString == "Category"       ? 7
+               : sortString == "GameVersion"    ? 8
+                                                : 1;
+    }
+
    private:
     inline auto getModSearchURL(SearchArgs& args) const -> QString override
     {
         auto gameVersionStr = args.versions.size() != 0 ? QString("gameVersion=%1").arg(args.versions.front().toString()) : QString();
 
         return QString(
-                   "https://addons-ecs.forgesvc.net/api/v2/addon/search?"
+                   "https://api.curseforge.com/v1/mods/search?"
                    "gameId=432&"
-                   "categoryId=0&"
-                   "sectionId=6&"
+                   "classId=6&"
 
                    "index=%1&"
                    "pageSize=25&"
                    "searchFilter=%2&"
-                   "sort=%3&"
+                   "sortField=%3&"
+                   "sortOrder=desc&"
                    "modLoaderType=%4&"
                    "%5")
             .arg(args.offset)
             .arg(args.search)
-            .arg(args.sorting)
-            .arg(getMappedModLoader(args.mod_loader))
+            .arg(getSortFieldInt(args.sorting))
+            .arg(getMappedModLoader(args.loaders))
             .arg(gameVersionStr);
     };
 
     inline auto getVersionsURL(VersionSearchArgs& args) const -> QString override
     {
-        return QString("https://addons-ecs.forgesvc.net/api/v2/addon/%1/files").arg(args.addonId);
+        QString gameVersionQuery = args.mcVersions.size() == 1 ? QString("gameVersion=%1&").arg(args.mcVersions.front().toString()) : "";
+        QString modLoaderQuery = QString("modLoaderType=%1&").arg(getMappedModLoader(args.loaders));
+
+        return QString("https://api.curseforge.com/v1/mods/%1/files?pageSize=10000&%2%3")
+            .arg(args.addonId)
+            .arg(gameVersionQuery)
+            .arg(modLoaderQuery);
     };
 
    public:
-    static auto getMappedModLoader(const ModLoaderType type) -> const ModLoaderType
+    static auto getMappedModLoader(const ModLoaderTypes loaders) -> const int
     {
+        // https://docs.curseforge.com/?http#tocS_ModLoaderType
+        if (loaders & Forge)
+            return 1;
+        if (loaders & Fabric)
+            return 4;
         // TODO: remove this once Quilt drops official Fabric support
-        if (type == Quilt)  // NOTE: Most if not all Fabric mods should work *currently*
-            return Fabric;
-        return type;
+        if (loaders & Quilt)  // NOTE: Most if not all Fabric mods should work *currently*
+            return 4;  // Quilt would probably be 5
+        return 0;
     }
 };

launcher/modplatform/flame/FlameModIndex.cpp

@@ -10,23 +10,12 @@ void FlameMod::loadIndexedPack(ModPlatform::IndexedPack& pack, QJsonObject& obj)
 {
     pack.addonId = Json::requireInteger(obj, "id");
     pack.name = Json::requireString(obj, "name");
-    pack.websiteUrl = Json::ensureString(obj, "websiteUrl", "");
+    pack.websiteUrl = Json::ensureString(Json::ensureObject(obj, "links"), "websiteUrl", "");
     pack.description = Json::ensureString(obj, "summary", "");
 
-    bool thumbnailFound = false;
-    auto attachments = Json::requireArray(obj, "attachments");
-    for (auto attachmentRaw : attachments) {
-        auto attachmentObj = Json::requireObject(attachmentRaw);
-        bool isDefault = attachmentObj.value("isDefault").toBool(false);
-        if (isDefault) {
-            thumbnailFound = true;
-            pack.logoName = Json::requireString(attachmentObj, "title");
-            pack.logoUrl = Json::requireString(attachmentObj, "thumbnailUrl");
-            break;
-        }
-    }
-
-    if (!thumbnailFound) { throw JSONValidationError(QString("Pack without an icon, skipping: %1").arg(pack.name)); }
+    QJsonObject logo = Json::requireObject(obj, "logo");
+    pack.logoName = Json::requireString(logo, "title");
+    pack.logoUrl = Json::requireString(logo, "thumbnailUrl");
 
     auto authors = Json::requireArray(obj, "authors");
     for (auto authorIter : authors) {
@@ -45,18 +34,22 @@ void FlameMod::loadIndexedPackVersions(ModPlatform::IndexedPack& pack,
 {
     QVector<ModPlatform::IndexedVersion> unsortedVersions;
     auto profile = (dynamic_cast<MinecraftInstance*>(inst))->getPackProfile();
-    bool hasFabric = FlameAPI::getMappedModLoader(profile->getModLoader()) == ModAPI::Fabric;
     QString mcVersion = profile->getComponentVersion("net.minecraft");
 
     for (auto versionIter : arr) {
         auto obj = versionIter.toObject();
 
-        auto versionArray = Json::requireArray(obj, "gameVersion");
-        if (versionArray.isEmpty()) { continue; }
+        auto versionArray = Json::requireArray(obj, "gameVersions");
+        if (versionArray.isEmpty()) {
+            continue;
+        }
 
         ModPlatform::IndexedVersion file;
         for (auto mcVer : versionArray) {
-            file.mcVersion.append(mcVer.toString());
+            auto str = mcVer.toString();
+
+            if (str.contains('.'))
+                file.mcVersion.append(str);
         }
 
         file.addonId = pack.addonId;
@@ -66,28 +59,9 @@ void FlameMod::loadIndexedPackVersions(ModPlatform::IndexedPack& pack,
         file.downloadUrl = Json::requireString(obj, "downloadUrl");
         file.fileName = Json::requireString(obj, "fileName");
 
-        auto modules = Json::requireArray(obj, "modules");
-        bool is_valid_fabric_version = false;
-        for (auto m : modules) {
-            auto fname = Json::requireString(m.toObject(), "foldername");
-            // FIXME: This does not work properly when a mod supports more than one mod loader, since
-            // FIXME: This also doesn't deal with Quilt mods at the moment
-            // they bundle the meta files for all of them in the same arquive, even when that version
-            // doesn't support the given mod loader.
-            if (hasFabric) {
-                if (fname == "fabric.mod.json") {
-                    is_valid_fabric_version = true;
-                    break;
-                }
-            } else
-                break;
-            // NOTE: Since we're not validating forge versions, we can just skip this loop.
-        }
-
-        if (hasFabric && !is_valid_fabric_version) continue;
-
         unsortedVersions.append(file);
     }
+
     auto orderSortPredicate = [](const ModPlatform::IndexedVersion& a, const ModPlatform::IndexedVersion& b) -> bool {
         // dates are in RFC 3339 format
         return a.date > b.date;

launcher/modplatform/flame/FlamePackIndex.cpp

@@ -2,90 +2,78 @@
 
 #include "Json.h"
 
-void Flame::loadIndexedPack(Flame::IndexedPack & pack, QJsonObject & obj)
+void Flame::loadIndexedPack(Flame::IndexedPack& pack, QJsonObject& obj)
 {
     pack.addonId = Json::requireInteger(obj, "id");
     pack.name = Json::requireString(obj, "name");
-    pack.websiteUrl = Json::ensureString(obj, "websiteUrl", "");
+    pack.websiteUrl = Json::ensureString(Json::ensureObject(obj, "links"), "websiteUrl", "");
     pack.description = Json::ensureString(obj, "summary", "");
 
-    bool thumbnailFound = false;
-    auto attachments = Json::requireArray(obj, "attachments");
-    for(auto attachmentRaw: attachments) {
-        auto attachmentObj = Json::requireObject(attachmentRaw);
-        bool isDefault = attachmentObj.value("isDefault").toBool(false);
-        if(isDefault) {
-            thumbnailFound = true;
-            pack.logoName = Json::requireString(attachmentObj, "title");
-            pack.logoUrl = Json::requireString(attachmentObj, "thumbnailUrl");
-            break;
-        }
-    }
-
-    if(!thumbnailFound) {
-        throw JSONValidationError(QString("Pack without an icon, skipping: %1").arg(pack.name));
-    }
+    auto logo = Json::requireObject(obj, "logo");
+    pack.logoName = Json::requireString(logo, "title");
+    pack.logoUrl = Json::requireString(logo, "thumbnailUrl");
 
     auto authors = Json::requireArray(obj, "authors");
-    for(auto authorIter: authors) {
+    for (auto authorIter : authors) {
         auto author = Json::requireObject(authorIter);
         Flame::ModpackAuthor packAuthor;
         packAuthor.name = Json::requireString(author, "name");
         packAuthor.url = Json::requireString(author, "url");
         pack.authors.append(packAuthor);
     }
-    int defaultFileId = Json::requireInteger(obj, "defaultFileId");
+    int defaultFileId = Json::requireInteger(obj, "mainFileId");
 
     bool found = false;
     // check if there are some files before adding the pack
     auto files = Json::requireArray(obj, "latestFiles");
-    for(auto fileIter: files) {
+    for (auto fileIter : files) {
         auto file = Json::requireObject(fileIter);
         int id = Json::requireInteger(file, "id");
 
         // NOTE: for now, ignore everything that's not the default...
-        if(id != defaultFileId) {
+        if (id != defaultFileId) {
             continue;
         }
 
-        auto versionArray = Json::requireArray(file, "gameVersion");
-        if(versionArray.size() < 1) {
+        auto versionArray = Json::requireArray(file, "gameVersions");
+        if (versionArray.size() < 1) {
             continue;
         }
 
         found = true;
         break;
     }
-    if(!found) {
+    if (!found) {
         throw JSONValidationError(QString("Pack with no good file, skipping: %1").arg(pack.name));
     }
 }
 
-void Flame::loadIndexedPackVersions(Flame::IndexedPack & pack, QJsonArray & arr)
+void Flame::loadIndexedPackVersions(Flame::IndexedPack& pack, QJsonArray& arr)
 {
     QVector<Flame::IndexedVersion> unsortedVersions;
-    for(auto versionIter: arr) {
+    for (auto versionIter : arr) {
         auto version = Json::requireObject(versionIter);
         Flame::IndexedVersion file;
 
         file.addonId = pack.addonId;
         file.fileId = Json::requireInteger(version, "id");
-        auto versionArray = Json::requireArray(version, "gameVersion");
-        if(versionArray.size() < 1) {
+        auto versionArray = Json::requireArray(version, "gameVersions");
+        if (versionArray.size() < 1) {
             continue;
         }
 
         // pick the latest version supported
         file.mcVersion = versionArray[0].toString();
         file.version = Json::requireString(version, "displayName");
-        file.downloadUrl = Json::requireString(version, "downloadUrl");
-        unsortedVersions.append(file);
+        file.downloadUrl = Json::ensureString(version, "downloadUrl");
+
+        // only add if we have a download URL (third party distribution is enabled)
+        if (!file.downloadUrl.isEmpty()) {
+            unsortedVersions.append(file);
+        }
     }
 
-    auto orderSortPredicate = [](const IndexedVersion & a, const IndexedVersion & b) -> bool
-    {
-        return a.fileId > b.fileId;
-    };
+    auto orderSortPredicate = [](const IndexedVersion& a, const IndexedVersion& b) -> bool { return a.fileId > b.fileId; };
     std::sort(unsortedVersions.begin(), unsortedVersions.end(), orderSortPredicate);
     pack.versions = unsortedVersions;
     pack.versionsLoaded = true;

launcher/modplatform/flame/PackManifest.cpp

@@ -1,28 +1,27 @@
 #include "PackManifest.h"
 #include "Json.h"
 
-static void loadFileV1(Flame::File & f, QJsonObject & file)
+static void loadFileV1(Flame::File& f, QJsonObject& file)
 {
     f.projectId = Json::requireInteger(file, "projectID");
     f.fileId = Json::requireInteger(file, "fileID");
     f.required = Json::ensureBoolean(file, QString("required"), true);
 }
 
-static void loadModloaderV1(Flame::Modloader & m, QJsonObject & modLoader)
+static void loadModloaderV1(Flame::Modloader& m, QJsonObject& modLoader)
 {
     m.id = Json::requireString(modLoader, "id");
     m.primary = Json::ensureBoolean(modLoader, QString("primary"), false);
 }
 
-static void loadMinecraftV1(Flame::Minecraft & m, QJsonObject & minecraft)
+static void loadMinecraftV1(Flame::Minecraft& m, QJsonObject& minecraft)
 {
     m.version = Json::requireString(minecraft, "version");
     // extra libraries... apparently only used for a custom Minecraft launcher in the 1.2.5 FTB retro pack
     // intended use is likely hardcoded in the 'Flame' client, the manifest says nothing
     m.libraries = Json::ensureString(minecraft, QString("libraries"), QString());
     auto arr = Json::ensureArray(minecraft, "modLoaders", QJsonArray());
-    for (QJsonValueRef item : arr)
-    {
+    for (QJsonValueRef item : arr) {
         auto obj = Json::requireObject(item);
         Flame::Modloader loader;
         loadModloaderV1(loader, obj);
@@ -30,97 +29,72 @@ static void loadMinecraftV1(Flame::Minecraft & m, QJsonObject & minecraft)
     }
 }
 
-static void loadManifestV1(Flame::Manifest & m, QJsonObject & manifest)
+static void loadManifestV1(Flame::Manifest& m, QJsonObject& manifest)
 {
     auto mc = Json::requireObject(manifest, "minecraft");
     loadMinecraftV1(m.minecraft, mc);
     m.name = Json::ensureString(manifest, QString("name"), "Unnamed");
     m.version = Json::ensureString(manifest, QString("version"), QString());
-    m.author = Json::ensureString(manifest, QString("author"), "Anonymous Coward");
+    m.author = Json::ensureString(manifest, QString("author"), "Anonymous");
     auto arr = Json::ensureArray(manifest, "files", QJsonArray());
-    for (QJsonValueRef item : arr)
-    {
+    for (QJsonValueRef item : arr) {
         auto obj = Json::requireObject(item);
         Flame::File file;
         loadFileV1(file, obj);
-        m.files.append(file);
+        m.files.insert(file.fileId,file);
     }
     m.overrides = Json::ensureString(manifest, "overrides", "overrides");
 }
 
-void Flame::loadManifest(Flame::Manifest & m, const QString &filepath)
+void Flame::loadManifest(Flame::Manifest& m, const QString& filepath)
 {
     auto doc = Json::requireDocument(filepath);
     auto obj = Json::requireObject(doc);
     m.manifestType = Json::requireString(obj, "manifestType");
-    if(m.manifestType != "minecraftModpack")
-    {
+    if (m.manifestType != "minecraftModpack") {
         throw JSONValidationError("Not a modpack manifest!");
     }
     m.manifestVersion = Json::requireInteger(obj, "manifestVersion");
-    if(m.manifestVersion != 1)
-    {
+    if (m.manifestVersion != 1) {
         throw JSONValidationError(QString("Unknown manifest version (%1)").arg(m.manifestVersion));
     }
     loadManifestV1(m, obj);
 }
 
-bool Flame::File::parseFromBytes(const QByteArray& bytes)
+bool Flame::File::parseFromObject(const QJsonObject& obj)
 {
-    auto doc = Json::requireDocument(bytes);
-    auto obj = Json::requireObject(doc);
-    // result code signifies true failure.
-    if(obj.contains("code"))
-    {
-        qCritical() << "Resolving of" << projectId << fileId << "failed because of a negative result:";
-        qCritical() << bytes;
-        return false;
-    }
-    fileName = Json::requireString(obj, "FileNameOnDisk");
-    QString rawUrl = Json::requireString(obj, "DownloadURL");
-    url = QUrl(rawUrl, QUrl::TolerantMode);
-    if(!url.isValid())
-    {
-        throw JSONValidationError(QString("Invalid URL: %1").arg(rawUrl));
-    }
+    fileName = Json::requireString(obj, "fileName");
     // This is a piece of a Flame project JSON pulled out into the file metadata (here) for convenience
     // It is also optional
-    QJsonObject projObj = Json::ensureObject(obj, "_Project", {});
-    if(!projObj.isEmpty())
-    {
-        QString strType = Json::ensureString(projObj, "PackageType", "mod").toLower();
-        if(strType == "singlefile")
-        {
-            type = File::Type::SingleFile;
-        }
-        else if(strType == "ctoc")
-        {
-            type = File::Type::Ctoc;
-        }
-        else if(strType == "cmod2")
-        {
-            type = File::Type::Cmod2;
-        }
-        else if(strType == "mod")
-        {
-            type = File::Type::Mod;
-        }
-        else if(strType == "folder")
-        {
-            type = File::Type::Folder;
-        }
-        else if(strType == "modpack")
-        {
-            type = File::Type::Modpack;
-        }
-        else
-        {
-            qCritical() << "Resolving of" << projectId << fileId << "failed because of unknown file type:" << strType;
-            type = File::Type::Unknown;
-            return false;
-        }
-        targetFolder = Json::ensureString(projObj, "Path", "mods");
+    type = File::Type::SingleFile;
+
+    if (fileName.endsWith(".zip")) {
+        // this is probably a resource pack
+        targetFolder = "resourcepacks";
+    } else {
+        // this is probably a mod, dunno what else could modpacks download
+        targetFolder = "mods";
     }
+    // get the hash
+    hash = QString();
+    auto hashes = Json::ensureArray(obj, "hashes");
+    for(QJsonValueRef item : hashes) {
+        auto hobj = Json::requireObject(item);
+        auto algo = Json::requireInteger(hobj, "algo");
+        auto value = Json::requireString(hobj, "value");
+        if (algo == 1) {
+            hash = value;
+        }
+    }
+
+
+    // may throw, if the project is blocked
+    QString rawUrl = Json::ensureString(obj, "downloadUrl");
+    url = QUrl(rawUrl, QUrl::TolerantMode);
+    if (!url.isValid()) {
+        throw JSONValidationError(QString("Invalid URL: %1").arg(rawUrl));
+    }
+
     resolved = true;
     return true;
 }

launcher/modplatform/flame/PackManifest.h

@@ -2,19 +2,24 @@
 
 #include <QString>
 #include <QVector>
+#include <QMap>
 #include <QUrl>
+#include <QJsonObject>
 
 namespace Flame
 {
 struct File
 {
     // NOTE: throws JSONValidationError
-    bool parseFromBytes(const QByteArray &bytes);
+    bool parseFromObject(const QJsonObject& object);
 
     int projectId = 0;
     int fileId = 0;
     // NOTE: the opposite to 'optional'. This is at the time of writing unused.
     bool required = true;
+    QString hash;
+    // NOTE: only set on blocked files ! Empty otherwise.
+    QString websiteUrl;
 
     // our
     bool resolved = false;
@@ -54,7 +59,8 @@ struct Manifest
     QString name;
     QString version;
     QString author;
-    QVector<Flame::File> files;
+    //File id -> File
+    QMap<int,Flame::File> files;
     QString overrides;
 };
 

launcher/modplatform/modrinth/ModrinthAPI.h

@@ -1,5 +1,24 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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 "BuildConfig.h"
 #include "modplatform/ModAPI.h"
 #include "modplatform/helpers/NetworkModAPI.h"
 
@@ -9,30 +28,25 @@ class ModrinthAPI : public NetworkModAPI {
    public:
     inline auto getAuthorURL(const QString& name) const -> QString { return "https://modrinth.com/user/" + name; };
 
-    static auto getModLoaderStrings(ModLoaderType type) -> const QStringList
+    static auto getModLoaderStrings(const ModLoaderTypes types) -> const QStringList
     {
         QStringList l;
-        switch (type)
+        for (auto loader : {Forge, Fabric, Quilt})
         {
-            case Unspecified:
-                for (auto loader : {Forge, Fabric, Quilt})
-                {
-                    l << ModAPI::getModLoaderString(loader);
-                }
-                break;
-
-            case Quilt:
-                l << ModAPI::getModLoaderString(Fabric);
-            default:
-                l << ModAPI::getModLoaderString(type);
+            if ((types & loader) || types == Unspecified)
+            {
+                l << ModAPI::getModLoaderString(loader);
+            }
         }
+        if ((types & Quilt) && (~types & Fabric))  // Add Fabric if Quilt is in use, if Fabric isn't already there
+            l << ModAPI::getModLoaderString(Fabric);
         return l;
     }
 
-    static auto getModLoaderFilters(ModLoaderType type) -> const QString
+    static auto getModLoaderFilters(ModLoaderTypes types) -> const QString
     {
         QStringList l;
-        for (auto loader : getModLoaderStrings(type))
+        for (auto loader : getModLoaderStrings(types))
         {
             l << QString("\"categories:%1\"").arg(loader);
         }
@@ -42,33 +56,34 @@ class ModrinthAPI : public NetworkModAPI {
    private:
     inline auto getModSearchURL(SearchArgs& args) const -> QString override
     {
-        if (!validateModLoader(args.mod_loader)) {
+        if (!validateModLoaders(args.loaders)) {
             qWarning() << "Modrinth only have Forge and Fabric-compatible mods!";
             return "";
         }
 
-        return QString(
-                   "https://api.modrinth.com/v2/search?"
-                   "offset=%1&"
-                   "limit=25&"
-                   "query=%2&"
-                   "index=%3&"
-                   "facets=[[%4],%5[\"project_type:mod\"]]")
+        return QString(BuildConfig.MODRINTH_PROD_URL +
+                       "/search?"
+                       "offset=%1&"
+                       "limit=25&"
+                       "query=%2&"
+                       "index=%3&"
+                       "facets=[[%4],%5[\"project_type:mod\"]]")
             .arg(args.offset)
             .arg(args.search)
             .arg(args.sorting)
-            .arg(getModLoaderFilters(args.mod_loader))
+            .arg(getModLoaderFilters(args.loaders))
             .arg(getGameVersionsArray(args.versions));
     };
 
     inline auto getVersionsURL(VersionSearchArgs& args) const -> QString override
     {
-        return QString("https://api.modrinth.com/v2/project/%1/version?"
-                "game_versions=[%2]"
-                "loaders=[\"%3\"]")
-            .arg(args.addonId)
-            .arg(getGameVersionsString(args.mcVersions))
-            .arg(getModLoaderStrings(args.loader).join("\",\""));
+        return QString(BuildConfig.MODRINTH_PROD_URL +
+                       "/project/%1/version?"
+                       "game_versions=[%2]&"
+                       "loaders=[\"%3\"]")
+            .arg(args.addonId,
+             getGameVersionsString(args.mcVersions),
+             getModLoaderStrings(args.loaders).join("\",\""));
     };
 
     auto getGameVersionsArray(std::list<Version> mcVersions) const -> QString
@@ -81,9 +96,9 @@ class ModrinthAPI : public NetworkModAPI {
         return s.isEmpty() ? QString() : QString("[%1],").arg(s);
     }
 
-    inline auto validateModLoader(ModLoaderType modLoader) const -> bool
+    inline auto validateModLoaders(ModLoaderTypes loaders) const -> bool
     {
-        return modLoader == Unspecified || modLoader == Forge || modLoader == Fabric || modLoader == Quilt;
+        return (loaders == Unspecified) || (loaders & (Forge | Fabric | Quilt));
     }
 
 };

launcher/modplatform/modrinth/ModrinthPackIndex.cpp

@@ -1,3 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *
+ *  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 "ModrinthPackIndex.h"
 #include "ModrinthAPI.h"
 

launcher/modplatform/modrinth/ModrinthPackIndex.h

@@ -1,3 +1,20 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *
+ *  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 "modplatform/ModIndex.h"

launcher/modplatform/modrinth/ModrinthPackManifest.cpp

@@ -0,0 +1,138 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *      Copyright 2022 kb1000
+ *
+ *      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.
+ */
+
+#include "ModrinthPackManifest.h"
+#include "Json.h"
+
+#include "modplatform/modrinth/ModrinthAPI.h"
+
+#include "minecraft/MinecraftInstance.h"
+#include "minecraft/PackProfile.h"
+
+#include <QSet>
+
+static ModrinthAPI api;
+
+namespace Modrinth {
+
+void loadIndexedPack(Modpack& pack, QJsonObject& obj)
+{
+    pack.id = Json::ensureString(obj, "project_id");
+
+    pack.name = Json::ensureString(obj, "title");
+    pack.description = Json::ensureString(obj, "description");
+    auto temp_author_name = Json::ensureString(obj, "author");
+    pack.author = std::make_tuple(temp_author_name, api.getAuthorURL(temp_author_name));
+    pack.iconName = QString("modrinth_%1").arg(Json::ensureString(obj, "slug"));
+    pack.iconUrl = Json::ensureString(obj, "icon_url");
+}
+
+void loadIndexedInfo(Modpack& pack, QJsonObject& obj)
+{
+    pack.extra.body = Json::ensureString(obj, "body");
+    pack.extra.projectUrl = QString("https://modrinth.com/modpack/%1").arg(Json::ensureString(obj, "slug"));
+    pack.extra.sourceUrl = Json::ensureString(obj, "source_url");
+    pack.extra.wikiUrl = Json::ensureString(obj, "wiki_url");
+
+    pack.extraInfoLoaded = true;
+}
+
+void loadIndexedVersions(Modpack& pack, QJsonDocument& doc)
+{
+    QVector<ModpackVersion> unsortedVersions;
+
+    auto arr = Json::requireArray(doc);
+
+    for (auto versionIter : arr) {
+        auto obj = Json::requireObject(versionIter);
+        auto file = loadIndexedVersion(obj);
+
+        if(!file.id.isEmpty()) // Heuristic to check if the returned value is valid
+            unsortedVersions.append(file);
+    }
+    auto orderSortPredicate = [](const ModpackVersion& a, const ModpackVersion& b) -> bool {
+        // dates are in RFC 3339 format
+        return a.date > b.date;
+    };
+
+    std::sort(unsortedVersions.begin(), unsortedVersions.end(), orderSortPredicate);
+
+    pack.versions.swap(unsortedVersions);
+
+    pack.versionsLoaded = true;
+}
+
+auto loadIndexedVersion(QJsonObject &obj) -> ModpackVersion
+{
+    ModpackVersion file;
+
+    file.name = Json::requireString(obj, "name");
+    file.version = Json::requireString(obj, "version_number");
+
+    file.id = Json::requireString(obj, "id");
+    file.project_id = Json::requireString(obj, "project_id");
+    
+    file.date = Json::requireString(obj, "date_published");
+
+    auto files = Json::requireArray(obj, "files");
+
+
+    for (auto file_iter : files) {
+        File indexed_file;
+        auto parent = Json::requireObject(file_iter);
+        auto is_primary = Json::ensureBoolean(parent, "primary", false);
+        if (!is_primary) {
+            auto filename = Json::ensureString(parent, "filename");
+            // Checking suffix here is fine because it's the response from Modrinth,
+            // so one would assume it will always be in English.
+            if(!filename.endsWith("mrpack") && !filename.endsWith("zip"))
+                continue;
+        }
+
+        auto url = Json::requireString(parent, "url");
+
+        file.download_url = url;
+        if(is_primary)
+            break;
+    }
+
+    if(file.download_url.isEmpty())
+        return {};
+
+    return file;
+}        
+
+}  // namespace Modrinth

launcher/modplatform/modrinth/ModrinthPackManifest.h

@@ -0,0 +1,106 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * This file incorporates work covered by the following copyright and
+ * permission notice:
+ *
+ *      Copyright 2013-2021 MultiMC Contributors
+ *      Copyright 2022 kb1000
+ *
+ *      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.
+ */
+
+#pragma once
+
+#include <QMetaType>
+
+#include <QByteArray>
+#include <QCryptographicHash>
+#include <QQueue>
+#include <QString>
+#include <QUrl>
+#include <QVector>
+
+class MinecraftInstance;
+
+namespace Modrinth {
+
+struct File {
+    QString path;
+
+    QCryptographicHash::Algorithm hashAlgorithm;
+    QByteArray hash;
+    QQueue<QUrl> downloads;
+};
+
+struct ModpackExtra {
+    QString body;
+
+    QString projectUrl;
+    QString sourceUrl;
+    QString wikiUrl;
+};
+
+struct ModpackVersion {
+    QString name;
+    QString version;
+
+    QString id;
+    QString project_id;
+
+    QString date;
+
+    QString download_url;
+};
+
+struct Modpack {
+    QString id;
+
+    QString name;
+    QString description;
+    std::tuple<QString, QUrl> author;
+    QString iconName;
+    QUrl    iconUrl;
+
+    bool    versionsLoaded = false;
+    bool    extraInfoLoaded = false;
+
+    ModpackExtra extra;
+    QVector<ModpackVersion> versions;
+};
+
+void loadIndexedPack(Modpack&, QJsonObject&);
+void loadIndexedInfo(Modpack&, QJsonObject&);
+void loadIndexedVersions(Modpack&, QJsonDocument&);
+auto loadIndexedVersion(QJsonObject&) -> ModpackVersion;
+
+auto validateDownloadUrl(QUrl) -> bool;
+
+}
+
+Q_DECLARE_METATYPE(Modrinth::Modpack)
+Q_DECLARE_METATYPE(Modrinth::ModpackVersion)

launcher/modplatform/technic/SolderPackManifest.cpp

@@ -37,7 +37,7 @@ void loadPack(Pack& v, QJsonObject& obj)
 static void loadPackBuildMod(PackBuildMod& b, QJsonObject& obj)
 {
     b.name = Json::requireString(obj, "name");
-    b.version = Json::requireString(obj, "version");
+    b.version = Json::ensureString(obj, "version", "");
     b.md5 = Json::requireString(obj, "md5");
     b.url = Json::requireString(obj, "url");
 }

launcher/modplatform/technic/TechnicPackProcessor.cpp

@@ -185,13 +185,22 @@ void Technic::TechnicPackProcessor::run(SettingsObjectPtr globalSettings, const
                     components->setComponentVersion("net.minecraftforge", libraryName.section('-', 1, 1));
                 }
             }
-            else if (libraryName.startsWith("net.minecraftforge:minecraftforge:"))
+            else
             {
-                components->setComponentVersion("net.minecraftforge", libraryName.section(':', 2));
-            }
-            else if (libraryName.startsWith("net.fabricmc:fabric-loader:"))
-            {
-                components->setComponentVersion("net.fabricmc.fabric-loader", libraryName.section(':', 2));
+                static QStringList possibleLoaders{
+                        "net.minecraftforge:minecraftforge:",
+                        "net.fabricmc:fabric-loader:",
+                        "org.quiltmc:quilt-loader:"
+                };
+                for (const auto& loader : possibleLoaders)
+                {
+                    if (libraryName.startsWith(loader))
+                    {
+                        auto loaderComponent = loader.chopped(1).replace(":", ".");
+                        components->setComponentVersion(loaderComponent, libraryName.section(':', 2));
+                        break;
+                    }
+                }
             }
         }
     }

launcher/net/ByteArraySink.h

@@ -1,62 +1,89 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * 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.
+ */
+
 #pragma once
 
 #include "Sink.h"
 
 namespace Net {
+
 /*
  * Sink object for downloads that uses an external QByteArray it doesn't own as a target.
+ * FIXME: It is possible that the QByteArray is freed while we're doing some operation on it,
+ * causing a segmentation fault.
  */
-class ByteArraySink : public Sink
-{
-public:
-    ByteArraySink(QByteArray *output)
-        :m_output(output)
-    {
-        // nil
-    };
+class ByteArraySink : public Sink {
+   public:
+    ByteArraySink(QByteArray* output) : m_output(output){};
 
-    virtual ~ByteArraySink()
-    {
-        // nil
-    }
+    virtual ~ByteArraySink() = default;
 
-public:
-    JobStatus init(QNetworkRequest & request) override
+   public:
+    auto init(QNetworkRequest& request) -> Task::State override
     {
         m_output->clear();
-        if(initAllValidators(request))
-            return Job_InProgress;
-        return Job_Failed;
+        if (initAllValidators(request))
+            return Task::State::Running;
+        return Task::State::Failed;
     };
 
-    JobStatus write(QByteArray & data) override
+    auto write(QByteArray& data) -> Task::State override
     {
         m_output->append(data);
-        if(writeAllValidators(data))
-            return Job_InProgress;
-        return Job_Failed;
+        if (writeAllValidators(data))
+            return Task::State::Running;
+        return Task::State::Failed;
     }
 
-    JobStatus abort() override
+    auto abort() -> Task::State override
     {
         m_output->clear();
         failAllValidators();
-        return Job_Failed;
+        return Task::State::Failed;
     }
 
-    JobStatus finalize(QNetworkReply &reply) override
+    auto finalize(QNetworkReply& reply) -> Task::State override
     {
-        if(finalizeAllValidators(reply))
-            return Job_Finished;
-        return Job_Failed;
+        if (finalizeAllValidators(reply))
+            return Task::State::Succeeded;
+        return Task::State::Failed;
     }
 
-    bool hasLocalData() override
-    {
-        return false;
-    }
+    auto hasLocalData() -> bool override { return false; }
 
-private:
-    QByteArray * m_output;
+   private:
+    QByteArray* m_output;
 };
-}
+}  // namespace Net

launcher/net/ChecksumValidator.h

@@ -1,55 +1,82 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * 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.
+ */
+
 #pragma once
 
 #include "Validator.h"
+
 #include <QCryptographicHash>
-#include <memory>
 #include <QFile>
 
 namespace Net {
-class ChecksumValidator: public Validator
-{
-public: /* con/des */
+class ChecksumValidator : public Validator {
+   public:
     ChecksumValidator(QCryptographicHash::Algorithm algorithm, QByteArray expected = QByteArray())
-        :m_checksum(algorithm), m_expected(expected)
-    {
-    };
-    virtual ~ChecksumValidator() {};
+        : m_checksum(algorithm), m_expected(expected){};
+    virtual ~ChecksumValidator() = default;
 
-public: /* methods */
-    bool init(QNetworkRequest &) override
+   public:
+    auto init(QNetworkRequest&) -> bool override
     {
         m_checksum.reset();
         return true;
     }
-    bool write(QByteArray & data) override
+
+    auto write(QByteArray& data) -> bool override
     {
         m_checksum.addData(data);
         return true;
     }
-    bool abort() override
+
+    auto abort() -> bool override { return true; }
+
+    auto validate(QNetworkReply&) -> bool override
     {
-        return true;
-    }
-    bool validate(QNetworkReply &) override
-    {
-        if(m_expected.size() && m_expected != hash())
-        {
+        if (m_expected.size() && m_expected != hash()) {
             qWarning() << "Checksum mismatch, download is bad.";
             return false;
         }
         return true;
     }
-    QByteArray hash()
-    {
-        return m_checksum.result();
-    }
-    void setExpected(QByteArray expected)
-    {
-        m_expected = expected;
-    }
 
-private: /* data */
+    auto hash() -> QByteArray { return m_checksum.result(); }
+
+    void setExpected(QByteArray expected) { m_expected = expected; }
+
+   private:
     QCryptographicHash m_checksum;
     QByteArray m_expected;
 };
-}
+}  // namespace Net

launcher/net/Download.cpp

@@ -1,108 +1,131 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #include "Download.h"
 
-#include <QFileInfo>
 #include <QDateTime>
-#include <QDebug>
+#include <QFileInfo>
 
-#include "FileSystem.h"
-#include "ChecksumValidator.h"
-#include "MetaCacheSink.h"
 #include "ByteArraySink.h"
+#include "ChecksumValidator.h"
+#include "FileSystem.h"
+#include "MetaCacheSink.h"
 
 #include "BuildConfig.h"
+#include "Application.h"
 
 namespace Net {
 
-Download::Download():NetAction()
+Download::Download() : NetAction()
 {
-    m_status = Job_NotStarted;
+    m_state = State::Inactive;
 }
 
-Download::Ptr Download::makeCached(QUrl url, MetaEntryPtr entry, Options options)
+auto Download::makeCached(QUrl url, MetaEntryPtr entry, Options options) -> Download::Ptr
 {
-    Download * dl = new Download();
+    auto* dl = new Download();
     dl->m_url = url;
     dl->m_options = options;
     auto md5Node = new ChecksumValidator(QCryptographicHash::Md5);
     auto cachedNode = new MetaCacheSink(entry, md5Node);
     dl->m_sink.reset(cachedNode);
-    dl->m_target_path = entry->getFullPath();
     return dl;
 }
 
-Download::Ptr Download::makeByteArray(QUrl url, QByteArray *output, Options options)
+auto Download::makeByteArray(QUrl url, QByteArray* output, Options options) -> Download::Ptr
 {
-    Download * dl = new Download();
+    auto* dl = new Download();
     dl->m_url = url;
     dl->m_options = options;
     dl->m_sink.reset(new ByteArraySink(output));
     return dl;
 }
 
-Download::Ptr Download::makeFile(QUrl url, QString path, Options options)
+auto Download::makeFile(QUrl url, QString path, Options options) -> Download::Ptr
 {
-    Download * dl = new Download();
+    auto* dl = new Download();
     dl->m_url = url;
     dl->m_options = options;
     dl->m_sink.reset(new FileSink(path));
     return dl;
 }
 
-void Download::addValidator(Validator * v)
+void Download::addValidator(Validator* v)
 {
     m_sink->addValidator(v);
 }
 
-void Download::startImpl()
+void Download::executeTask()
 {
-    if(m_status == Job_Aborted)
-    {
+    setStatus(tr("Downloading %1").arg(m_url.toString()));
+
+    if (getState() == Task::State::AbortedByUser) {
         qWarning() << "Attempt to start an aborted Download:" << m_url.toString();
-        emit aborted(m_index_within_job);
+        emitAborted();
         return;
     }
+
     QNetworkRequest request(m_url);
-    m_status = m_sink->init(request);
-    switch(m_status)
-    {
-        case Job_Finished:
-            emit succeeded(m_index_within_job);
+    m_state = m_sink->init(request);
+    switch (m_state) {
+        case State::Succeeded:
+            emit succeeded();
             qDebug() << "Download cache hit " << m_url.toString();
             return;
-        case Job_InProgress:
+        case State::Running:
             qDebug() << "Downloading " << m_url.toString();
             break;
-        case Job_Failed_Proceed: // this is meaningless in this context. We do need a sink.
-        case Job_NotStarted:
-        case Job_Failed:
-            emit failed(m_index_within_job);
+        case State::Inactive:
+        case State::Failed:
+            emitFailed();
             return;
-        case Job_Aborted:
+        case State::AbortedByUser:
+            emitAborted();
             return;
     }
 
     request.setHeader(QNetworkRequest::UserAgentHeader, BuildConfig.USER_AGENT);
+    if (request.url().host().contains("api.curseforge.com")) {
+        request.setRawHeader("x-api-key", APPLICATION->getCurseKey().toUtf8());
+    };
 
-    QNetworkReply *rep = m_network->get(request);
+    QNetworkReply* rep = m_network->get(request);
 
     m_reply.reset(rep);
-    connect(rep, SIGNAL(downloadProgress(qint64, qint64)), SLOT(downloadProgress(qint64, qint64)));
-    connect(rep, SIGNAL(finished()), SLOT(downloadFinished()));
+    connect(rep, &QNetworkReply::downloadProgress, this, &Download::downloadProgress);
+    connect(rep, &QNetworkReply::finished, this, &Download::downloadFinished);
     connect(rep, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(downloadError(QNetworkReply::NetworkError)));
     connect(rep, &QNetworkReply::sslErrors, this, &Download::sslErrors);
     connect(rep, &QNetworkReply::readyRead, this, &Download::downloadReadyRead);
@@ -110,39 +133,31 @@ void Download::startImpl()
 
 void Download::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
 {
-    m_total_progress = bytesTotal;
-    m_progress = bytesReceived;
-    emit netActionProgress(m_index_within_job, bytesReceived, bytesTotal);
+    setProgress(bytesReceived, bytesTotal);
 }
 
 void Download::downloadError(QNetworkReply::NetworkError error)
 {
-    if(error == QNetworkReply::OperationCanceledError)
-    {
+    if (error == QNetworkReply::OperationCanceledError) {
         qCritical() << "Aborted " << m_url.toString();
-        m_status = Job_Aborted;
-    }
-    else
-    {
-        if(m_options & Option::AcceptLocalFiles)
-        {
-            if(m_sink->hasLocalData())
-            {
-                m_status = Job_Failed_Proceed;
+        m_state = State::AbortedByUser;
+    } else {
+        if (m_options & Option::AcceptLocalFiles) {
+            if (m_sink->hasLocalData()) {
+                m_state = State::Succeeded;
                 return;
             }
         }
         // error happened during download.
         qCritical() << "Failed " << m_url.toString() << " with reason " << error;
-        m_status = Job_Failed;
+        m_state = State::Failed;
     }
 }
 
-void Download::sslErrors(const QList<QSslError> & errors)
+void Download::sslErrors(const QList<QSslError>& errors)
 {
     int i = 1;
-    for (auto error : errors)
-    {
+    for (auto error : errors) {
         qCritical() << "Download" << m_url.toString() << "SSL Error #" << i << " : " << error.errorString();
         auto cert = error.certificate();
         qCritical() << "Certificate in question:\n" << cert.toText();
@@ -150,36 +165,30 @@ void Download::sslErrors(const QList<QSslError> & errors)
     }
 }
 
-bool Download::handleRedirect()
+auto Download::handleRedirect() -> bool
 {
     QUrl redirect = m_reply->header(QNetworkRequest::LocationHeader).toUrl();
-    if(!redirect.isValid())
-    {
-        if(!m_reply->hasRawHeader("Location"))
-        {
+    if (!redirect.isValid()) {
+        if (!m_reply->hasRawHeader("Location")) {
             // no redirect -> it's fine to continue
             return false;
         }
         // there is a Location header, but it's not correct. we need to apply some workarounds...
         QByteArray redirectBA = m_reply->rawHeader("Location");
-        if(redirectBA.size() == 0)
-        {
+        if (redirectBA.size() == 0) {
             // empty, yet present redirect header? WTF?
             return false;
         }
         QString redirectStr = QString::fromUtf8(redirectBA);
 
-        if(redirectStr.startsWith("//"))
-        {
+        if (redirectStr.startsWith("//")) {
             /*
              * IF the URL begins with //, we need to insert the URL scheme.
              * See: https://bugreports.qt.io/browse/QTBUG-41061
              * See: http://tools.ietf.org/html/rfc3986#section-4.2
              */
             redirectStr = m_reply->url().scheme() + ":" + redirectStr;
-        }
-        else if(redirectStr.startsWith("/"))
-        {
+        } else if (redirectStr.startsWith("/")) {
             /*
              * IF the URL begins with /, we need to process it as a relative URL
              */
@@ -193,118 +202,97 @@ bool Download::handleRedirect()
          * FIXME: report Qt bug for this
          */
         redirect = QUrl(redirectStr, QUrl::TolerantMode);
-        if(!redirect.isValid())
-        {
+        if (!redirect.isValid()) {
             qWarning() << "Failed to parse redirect URL:" << redirectStr;
             downloadError(QNetworkReply::ProtocolFailure);
             return false;
         }
         qDebug() << "Fixed location header:" << redirect;
-    }
-    else
-    {
+    } else {
         qDebug() << "Location header:" << redirect;
     }
 
     m_url = QUrl(redirect.toString());
     qDebug() << "Following redirect to " << m_url.toString();
-    start(m_network);
+    startAction(m_network);
+
     return true;
 }
 
-
 void Download::downloadFinished()
 {
     // handle HTTP redirection first
-    if(handleRedirect())
-    {
+    if (handleRedirect()) {
         qDebug() << "Download redirected:" << m_url.toString();
         return;
     }
 
     // if the download failed before this point ...
-    if (m_status == Job_Failed_Proceed)
+    if (m_state == State::Succeeded)  // pretend to succeed so we continue processing :)
     {
         qDebug() << "Download failed but we are allowed to proceed:" << m_url.toString();
         m_sink->abort();
         m_reply.reset();
-        emit succeeded(m_index_within_job);
+        emit succeeded();
         return;
-    }
-    else if (m_status == Job_Failed)
-    {
+    } else if (m_state == State::Failed) {
         qDebug() << "Download failed in previous step:" << m_url.toString();
         m_sink->abort();
         m_reply.reset();
-        emit failed(m_index_within_job);
+        emit failed("");
         return;
-    }
-    else if(m_status == Job_Aborted)
-    {
+    } else if (m_state == State::AbortedByUser) {
         qDebug() << "Download aborted in previous step:" << m_url.toString();
         m_sink->abort();
         m_reply.reset();
-        emit aborted(m_index_within_job);
+        emit aborted();
         return;
     }
 
     // make sure we got all the remaining data, if any
     auto data = m_reply->readAll();
-    if(data.size())
-    {
-        qDebug() << "Writing extra" << data.size() << "bytes to" << m_target_path;
-        m_status = m_sink->write(data);
+    if (data.size()) {
+        qDebug() << "Writing extra" << data.size() << "bytes";
+        m_state = m_sink->write(data);
     }
 
     // otherwise, finalize the whole graph
-    m_status = m_sink->finalize(*m_reply.get());
-    if (m_status != Job_Finished)
-    {
+    m_state = m_sink->finalize(*m_reply.get());
+    if (m_state != State::Succeeded) {
         qDebug() << "Download failed to finalize:" << m_url.toString();
         m_sink->abort();
         m_reply.reset();
-        emit failed(m_index_within_job);
+        emit failed("");
         return;
     }
+
     m_reply.reset();
     qDebug() << "Download succeeded:" << m_url.toString();
-    emit succeeded(m_index_within_job);
+    emit succeeded();
 }
 
 void Download::downloadReadyRead()
 {
-    if(m_status == Job_InProgress)
-    {
+    if (m_state == State::Running) {
         auto data = m_reply->readAll();
-        m_status = m_sink->write(data);
-        if(m_status == Job_Failed)
-        {
-            qCritical() << "Failed to process response chunk for " << m_target_path;
+        m_state = m_sink->write(data);
+        if (m_state == State::Failed) {
+            qCritical() << "Failed to process response chunk";
         }
         // qDebug() << "Download" << m_url.toString() << "gained" << data.size() << "bytes";
-    }
-    else
-    {
-        qCritical() << "Cannot write to " << m_target_path << ", illegal status" << m_status;
+    } else {
+        qCritical() << "Cannot write download data! illegal status " << m_status;
     }
 }
 
-}
+}  // namespace Net
 
-bool Net::Download::abort()
+auto Net::Download::abort() -> bool
 {
-    if(m_reply)
-    {
+    if (m_reply) {
         m_reply->abort();
-    }
-    else
-    {
-        m_status = Job_Aborted;
+    } else {
+        m_state = State::AbortedByUser;
     }
     return true;
 }
-
-bool Net::Download::canAbort()
-{
-    return true;
-}

launcher/net/Download.h

@@ -1,77 +1,88 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #pragma once
 
-#include "NetAction.h"
 #include "HttpMetaCache.h"
-#include "Validator.h"
+#include "NetAction.h"
 #include "Sink.h"
+#include "Validator.h"
 
 #include "QObjectPtr.h"
 
 namespace Net {
-class Download : public NetAction
-{
+class Download : public NetAction {
     Q_OBJECT
 
-public: /* types */
-    typedef shared_qobject_ptr<class Download> Ptr;
-    enum class Option
-    {
-        NoOptions = 0,
-        AcceptLocalFiles = 1
-    };
+   public:
+    using Ptr = shared_qobject_ptr<class Download>;
+    enum class Option { NoOptions = 0, AcceptLocalFiles = 1 };
     Q_DECLARE_FLAGS(Options, Option)
 
-protected: /* con/des */
+   protected:
     explicit Download();
-public:
-    virtual ~Download(){};
-    static Download::Ptr makeCached(QUrl url, MetaEntryPtr entry, Options options = Option::NoOptions);
-    static Download::Ptr makeByteArray(QUrl url, QByteArray *output, Options options = Option::NoOptions);
-    static Download::Ptr makeFile(QUrl url, QString path, Options options = Option::NoOptions);
 
-public: /* methods */
-    QString getTargetFilepath()
-    {
-        return m_target_path;
-    }
-    void addValidator(Validator * v);
-    bool abort() override;
-    bool canAbort() override;
+   public:
+    ~Download() override = default;
 
-private: /* methods */
-    bool handleRedirect();
+    static auto makeCached(QUrl url, MetaEntryPtr entry, Options options = Option::NoOptions) -> Download::Ptr;
+    static auto makeByteArray(QUrl url, QByteArray* output, Options options = Option::NoOptions) -> Download::Ptr;
+    static auto makeFile(QUrl url, QString path, Options options = Option::NoOptions) -> Download::Ptr;
 
-protected slots:
+   public:
+    void addValidator(Validator* v);
+    auto abort() -> bool override;
+    auto canAbort() const -> bool override { return true; };
+
+   private:
+    auto handleRedirect() -> bool;
+
+   protected slots:
     void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) override;
     void downloadError(QNetworkReply::NetworkError error) override;
-    void sslErrors(const QList<QSslError> & errors);
+    void sslErrors(const QList<QSslError>& errors);
     void downloadFinished() override;
     void downloadReadyRead() override;
 
-public slots:
-    void startImpl() override;
+   public slots:
+    void executeTask() override;
 
-private: /* data */
-    // FIXME: remove this, it has no business being here.
-    QString m_target_path;
+   private:
     std::unique_ptr<Sink> m_sink;
     Options m_options;
 };
-}
+}  // namespace Net
 
 Q_DECLARE_OPERATORS_FOR_FLAGS(Net::Download::Options)

launcher/net/FileSink.cpp

@@ -1,109 +1,131 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * 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.
+ */
+
 #include "FileSink.h"
-#include <QFile>
-#include <QFileInfo>
+
 #include "FileSystem.h"
 
 namespace Net {
 
-FileSink::FileSink(QString filename)
-    :m_filename(filename)
-{
-    // nil
-}
-
-FileSink::~FileSink()
-{
-    // nil
-}
-
-JobStatus FileSink::init(QNetworkRequest& request)
+Task::State FileSink::init(QNetworkRequest& request)
 {
     auto result = initCache(request);
-    if(result != Job_InProgress)
-    {
+    if (result != Task::State::Running) {
         return result;
     }
+
     // create a new save file and open it for writing
-    if (!FS::ensureFilePathExists(m_filename))
-    {
+    if (!FS::ensureFilePathExists(m_filename)) {
         qCritical() << "Could not create folder for " + m_filename;
-        return Job_Failed;
+        return Task::State::Failed;
     }
+
     wroteAnyData = false;
     m_output_file.reset(new QSaveFile(m_filename));
-    if (!m_output_file->open(QIODevice::WriteOnly))
-    {
+    if (!m_output_file->open(QIODevice::WriteOnly)) {
         qCritical() << "Could not open " + m_filename + " for writing";
-        return Job_Failed;
+        return Task::State::Failed;
     }
 
-    if(initAllValidators(request))
-        return Job_InProgress;
-    return Job_Failed;
+    if (initAllValidators(request))
+        return Task::State::Running;
+    return Task::State::Failed;
 }
 
-JobStatus FileSink::initCache(QNetworkRequest &)
+Task::State FileSink::write(QByteArray& data)
 {
-    return Job_InProgress;
-}
-
-JobStatus FileSink::write(QByteArray& data)
-{
-    if (!writeAllValidators(data) || m_output_file->write(data) != data.size())
-    {
+    if (!writeAllValidators(data) || m_output_file->write(data) != data.size()) {
         qCritical() << "Failed writing into " + m_filename;
         m_output_file->cancelWriting();
         m_output_file.reset();
         wroteAnyData = false;
-        return Job_Failed;
+        return Task::State::Failed;
     }
+
     wroteAnyData = true;
-    return Job_InProgress;
+    return Task::State::Running;
 }
 
-JobStatus FileSink::abort()
+Task::State FileSink::abort()
 {
     m_output_file->cancelWriting();
     failAllValidators();
-    return Job_Failed;
+    return Task::State::Failed;
 }
 
-JobStatus FileSink::finalize(QNetworkReply& reply)
+Task::State FileSink::finalize(QNetworkReply& reply)
 {
     bool gotFile = false;
     QVariant statusCodeV = reply.attribute(QNetworkRequest::HttpStatusCodeAttribute);
     bool validStatus = false;
     int statusCode = statusCodeV.toInt(&validStatus);
-    if(validStatus)
-    {
+    if (validStatus) {
         // this leaves out 304 Not Modified
         gotFile = statusCode == 200 || statusCode == 203;
     }
+
     // if we wrote any data to the save file, we try to commit the data to the real file.
     // if it actually got a proper file, we write it even if it was empty
-    if (gotFile || wroteAnyData)
-    {
+    if (gotFile || wroteAnyData) {
         // ask validators for data consistency
         // we only do this for actual downloads, not 'your data is still the same' cache hits
-        if(!finalizeAllValidators(reply))
-            return Job_Failed;
+        if (!finalizeAllValidators(reply))
+            return Task::State::Failed;
+
         // nothing went wrong...
-        if (!m_output_file->commit())
-        {
+        if (!m_output_file->commit()) {
             qCritical() << "Failed to commit changes to " << m_filename;
             m_output_file->cancelWriting();
-            return Job_Failed;
+            return Task::State::Failed;
         }
     }
+
     // then get rid of the save file
     m_output_file.reset();
 
     return finalizeCache(reply);
 }
 
-JobStatus FileSink::finalizeCache(QNetworkReply &)
+Task::State FileSink::initCache(QNetworkRequest&)
 {
-    return Job_Finished;
+    return Task::State::Running;
+}
+
+Task::State FileSink::finalizeCache(QNetworkReply&)
+{
+    return Task::State::Succeeded;
 }
 
 bool FileSink::hasLocalData()
@@ -111,4 +133,4 @@ bool FileSink::hasLocalData()
     QFileInfo info(m_filename);
     return info.exists() && info.size() != 0;
 }
-}
+}  // namespace Net

launcher/net/FileSink.h

@@ -1,28 +1,65 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * 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.
+ */
+
 #pragma once
-#include "Sink.h"
+
 #include <QSaveFile>
 
+#include "Sink.h"
+
 namespace Net {
-class FileSink : public Sink
-{
-public: /* con/des */
-    FileSink(QString filename);
-    virtual ~FileSink();
+class FileSink : public Sink {
+   public:
+    FileSink(QString filename) : m_filename(filename){};
+    virtual ~FileSink() = default;
 
-public: /* methods */
-    JobStatus init(QNetworkRequest & request) override;
-    JobStatus write(QByteArray & data) override;
-    JobStatus abort() override;
-    JobStatus finalize(QNetworkReply & reply) override;
-    bool hasLocalData() override;
+   public:
+    auto init(QNetworkRequest& request) -> Task::State override;
+    auto write(QByteArray& data) -> Task::State override;
+    auto abort() -> Task::State override;
+    auto finalize(QNetworkReply& reply) -> Task::State override;
 
-protected: /* methods */
-    virtual JobStatus initCache(QNetworkRequest &);
-    virtual JobStatus finalizeCache(QNetworkReply &reply);
+    auto hasLocalData() -> bool override;
 
-protected: /* data */
+   protected:
+    virtual auto initCache(QNetworkRequest&) -> Task::State;
+    virtual auto finalizeCache(QNetworkReply& reply) -> Task::State;
+
+   protected:
     QString m_filename;
     bool wroteAnyData = false;
     std::unique_ptr<QSaveFile> m_output_file;
 };
-}
+}  // namespace Net

launcher/net/HttpMetaCache.cpp

@@ -1,43 +1,60 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #include "HttpMetaCache.h"
 #include "FileSystem.h"
+#include "Json.h"
 
-#include <QFileInfo>
-#include <QFile>
-#include <QDateTime>
 #include <QCryptographicHash>
+#include <QDateTime>
+#include <QFile>
+#include <QFileInfo>
 
 #include <QDebug>
 
-#include <QJsonDocument>
-#include <QJsonArray>
-#include <QJsonObject>
-
-QString MetaEntry::getFullPath()
+auto MetaEntry::getFullPath() -> QString
 {
     // FIXME: make local?
     return FS::PathCombine(basePath, relativePath);
 }
 
-HttpMetaCache::HttpMetaCache(QString path) : QObject()
+HttpMetaCache::HttpMetaCache(QString path) : QObject(), m_index_file(path)
 {
-    m_index_file = path;
     saveBatchingTimer.setSingleShot(true);
     saveBatchingTimer.setTimerType(Qt::VeryCoarseTimer);
+
     connect(&saveBatchingTimer, SIGNAL(timeout()), SLOT(SaveNow()));
 }
 
@@ -47,45 +64,42 @@ HttpMetaCache::~HttpMetaCache()
     SaveNow();
 }
 
-MetaEntryPtr HttpMetaCache::getEntry(QString base, QString resource_path)
+auto HttpMetaCache::getEntry(QString base, QString resource_path) -> MetaEntryPtr
 {
     // no base. no base path. can't store
-    if (!m_entries.contains(base))
-    {
+    if (!m_entries.contains(base)) {
         // TODO: log problem
-        return MetaEntryPtr();
+        return {};
     }
-    EntryMap &map = m_entries[base];
-    if (map.entry_list.contains(resource_path))
-    {
+
+    EntryMap& map = m_entries[base];
+    if (map.entry_list.contains(resource_path)) {
         return map.entry_list[resource_path];
     }
-    return MetaEntryPtr();
+
+    return {};
 }
 
-MetaEntryPtr HttpMetaCache::resolveEntry(QString base, QString resource_path, QString expected_etag)
+auto HttpMetaCache::resolveEntry(QString base, QString resource_path, QString expected_etag) -> MetaEntryPtr
 {
     auto entry = getEntry(base, resource_path);
     // it's not present? generate a default stale entry
-    if (!entry)
-    {
+    if (!entry) {
         return staleEntry(base, resource_path);
     }
 
-    auto &selected_base = m_entries[base];
+    auto& selected_base = m_entries[base];
     QString real_path = FS::PathCombine(selected_base.base_path, resource_path);
     QFileInfo finfo(real_path);
 
     // is the file really there? if not -> stale
-    if (!finfo.isFile() || !finfo.isReadable())
-    {
+    if (!finfo.isFile() || !finfo.isReadable()) {
         // if the file doesn't exist, we disown the entry
         selected_base.entry_list.remove(resource_path);
         return staleEntry(base, resource_path);
     }
 
-    if (!expected_etag.isEmpty() && expected_etag != entry->etag)
-    {
+    if (!expected_etag.isEmpty() && expected_etag != entry->etag) {
         // if the etag doesn't match expected, we disown the entry
         selected_base.entry_list.remove(resource_path);
         return staleEntry(base, resource_path);
@@ -93,18 +107,15 @@ MetaEntryPtr HttpMetaCache::resolveEntry(QString base, QString resource_path, QS
 
     // if the file changed, check md5sum
     qint64 file_last_changed = finfo.lastModified().toUTC().toMSecsSinceEpoch();
-    if (file_last_changed != entry->local_changed_timestamp)
-    {
+    if (file_last_changed != entry->local_changed_timestamp) {
         QFile input(real_path);
         input.open(QIODevice::ReadOnly);
-        QString md5sum = QCryptographicHash::hash(input.readAll(), QCryptographicHash::Md5)
-                             .toHex()
-                             .constData();
-        if (entry->md5sum != md5sum)
-        {
+        QString md5sum = QCryptographicHash::hash(input.readAll(), QCryptographicHash::Md5).toHex().constData();
+        if (entry->md5sum != md5sum) {
             selected_base.entry_list.remove(resource_path);
             return staleEntry(base, resource_path);
         }
+
         // md5sums matched... keep entry and save the new state to file
         entry->local_changed_timestamp = file_last_changed;
         SaveEventually();
@@ -115,42 +126,42 @@ MetaEntryPtr HttpMetaCache::resolveEntry(QString base, QString resource_path, QS
     return entry;
 }
 
-bool HttpMetaCache::updateEntry(MetaEntryPtr stale_entry)
+auto HttpMetaCache::updateEntry(MetaEntryPtr stale_entry) -> bool
 {
-    if (!m_entries.contains(stale_entry->baseId))
-    {
-        qCritical() << "Cannot add entry with unknown base: "
-                     << stale_entry->baseId.toLocal8Bit();
+    if (!m_entries.contains(stale_entry->baseId)) {
+        qCritical() << "Cannot add entry with unknown base: " << stale_entry->baseId.toLocal8Bit();
         return false;
     }
-    if (stale_entry->stale)
-    {
+
+    if (stale_entry->stale) {
         qCritical() << "Cannot add stale entry: " << stale_entry->getFullPath().toLocal8Bit();
         return false;
     }
+
     m_entries[stale_entry->baseId].entry_list[stale_entry->relativePath] = stale_entry;
     SaveEventually();
+
+    return true;
+}
+
+auto HttpMetaCache::evictEntry(MetaEntryPtr entry) -> bool
+{
+    if (!entry)
+        return false;
+
+    entry->stale = true;
+    SaveEventually();
     return true;
 }
 
-bool HttpMetaCache::evictEntry(MetaEntryPtr entry)
-{
-    if(entry)
-    {
-        entry->stale = true;
-        SaveEventually();
-        return true;
-    }
-    return false;
-}
-
-MetaEntryPtr HttpMetaCache::staleEntry(QString base, QString resource_path)
+auto HttpMetaCache::staleEntry(QString base, QString resource_path) -> MetaEntryPtr
 {
     auto foo = new MetaEntry();
     foo->baseId = base;
     foo->basePath = getBasePath(base);
     foo->relativePath = resource_path;
     foo->stale = true;
+
     return MetaEntryPtr(foo);
 }
 
@@ -159,24 +170,25 @@ void HttpMetaCache::addBase(QString base, QString base_root)
     // TODO: report error
     if (m_entries.contains(base))
         return;
+
     // TODO: check if the base path is valid
     EntryMap foo;
     foo.base_path = base_root;
     m_entries[base] = foo;
 }
 
-QString HttpMetaCache::getBasePath(QString base)
+auto HttpMetaCache::getBasePath(QString base) -> QString
 {
-    if (m_entries.contains(base))
-    {
+    if (m_entries.contains(base)) {
         return m_entries[base].base_path;
     }
-    return QString();
+
+    return {};
 }
 
 void HttpMetaCache::Load()
 {
-    if(m_index_file.isNull())
+    if (m_index_file.isNull())
         return;
 
     QFile index(m_index_file);
@@ -184,41 +196,35 @@ void HttpMetaCache::Load()
         return;
 
     QJsonDocument json = QJsonDocument::fromJson(index.readAll());
-    if (!json.isObject())
-        return;
-    auto root = json.object();
+
+    auto root = Json::requireObject(json, "HttpMetaCache root");
+
     // check file version first
-    auto version_val = root.value("version");
-    if (!version_val.isString())
-        return;
-    if (version_val.toString() != "1")
+    auto version_val = Json::ensureString(root, "version");
+    if (version_val != "1")
         return;
 
     // read the entry array
-    auto entries_val = root.value("entries");
-    if (!entries_val.isArray())
-        return;
-    QJsonArray array = entries_val.toArray();
-    for (auto element : array)
-    {
-        if (!element.isObject())
-            return;
-        auto element_obj = element.toObject();
-        QString base = element_obj.value("base").toString();
+    auto array = Json::ensureArray(root, "entries");
+    for (auto element : array) {
+        auto element_obj = Json::ensureObject(element);
+        auto base = Json::ensureString(element_obj, "base");
         if (!m_entries.contains(base))
             continue;
-        auto &entrymap = m_entries[base];
+
+        auto& entrymap = m_entries[base];
+
         auto foo = new MetaEntry();
         foo->baseId = base;
-        QString path = foo->relativePath = element_obj.value("path").toString();
-        foo->md5sum = element_obj.value("md5sum").toString();
-        foo->etag = element_obj.value("etag").toString();
-        foo->local_changed_timestamp = element_obj.value("last_changed_timestamp").toDouble();
-        foo->remote_changed_timestamp =
-            element_obj.value("remote_changed_timestamp").toString();
+        foo->relativePath = Json::ensureString(element_obj, "path");
+        foo->md5sum = Json::ensureString(element_obj, "md5sum");
+        foo->etag = Json::ensureString(element_obj, "etag");
+        foo->local_changed_timestamp = Json::ensureDouble(element_obj, "last_changed_timestamp");
+        foo->remote_changed_timestamp = Json::ensureString(element_obj, "remote_changed_timestamp");
         // presumed innocent until closer examination
         foo->stale = false;
-        entrymap.entry_list[path] = MetaEntryPtr(foo);
+
+        entrymap.entry_list[foo->relativePath] = MetaEntryPtr(foo);
     }
 }
 
@@ -231,42 +237,36 @@ void HttpMetaCache::SaveEventually()
 
 void HttpMetaCache::SaveNow()
 {
-    if(m_index_file.isNull())
+    if (m_index_file.isNull())
         return;
+
     QJsonObject toplevel;
-    toplevel.insert("version", QJsonValue(QString("1")));
+    Json::writeString(toplevel, "version", "1");
+
     QJsonArray entriesArr;
-    for (auto group : m_entries)
-    {
-        for (auto entry : group.entry_list)
-        {
+    for (auto group : m_entries) {
+        for (auto entry : group.entry_list) {
             // do not save stale entries. they are dead.
-            if(entry->stale)
-            {
+            if (entry->stale) {
                 continue;
             }
+
             QJsonObject entryObj;
-            entryObj.insert("base", QJsonValue(entry->baseId));
-            entryObj.insert("path", QJsonValue(entry->relativePath));
-            entryObj.insert("md5sum", QJsonValue(entry->md5sum));
-            entryObj.insert("etag", QJsonValue(entry->etag));
-            entryObj.insert("last_changed_timestamp",
-                            QJsonValue(double(entry->local_changed_timestamp)));
+            Json::writeString(entryObj, "base", entry->baseId);
+            Json::writeString(entryObj, "path", entry->relativePath);
+            Json::writeString(entryObj, "md5sum", entry->md5sum);
+            Json::writeString(entryObj, "etag", entry->etag);
+            entryObj.insert("last_changed_timestamp", QJsonValue(double(entry->local_changed_timestamp)));
             if (!entry->remote_changed_timestamp.isEmpty())
-                entryObj.insert("remote_changed_timestamp",
-                                QJsonValue(entry->remote_changed_timestamp));
+                entryObj.insert("remote_changed_timestamp", QJsonValue(entry->remote_changed_timestamp));
             entriesArr.append(entryObj);
         }
     }
     toplevel.insert("entries", entriesArr);
 
-    QJsonDocument doc(toplevel);
-    try
-    {
-        FS::write(m_index_file, doc.toJson());
-    }
-    catch (const Exception &e)
-    {
+    try {
+        Json::write(toplevel, m_index_file);
+    } catch (const Exception& e) {
         qWarning() << e.what();
     }
 }

launcher/net/HttpMetaCache.h

@@ -1,122 +1,122 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #pragma once
-#include <QString>
+
 #include <QMap>
-#include <qtimer.h>
+#include <QString>
+#include <QTimer>
 #include <memory>
 
 class HttpMetaCache;
 
-class MetaEntry
-{
-friend class HttpMetaCache;
-protected:
-    MetaEntry() {}
-public:
-    bool isStale()
-    {
-        return stale;
-    }
-    void setStale(bool stale)
-    {
-        this->stale = stale;
-    }
-    QString getFullPath();
-    QString getRemoteChangedTimestamp()
-    {
-        return remote_changed_timestamp;
-    }
-    void setRemoteChangedTimestamp(QString remote_changed_timestamp)
-    {
-        this->remote_changed_timestamp = remote_changed_timestamp;
-    }
-    void setLocalChangedTimestamp(qint64 timestamp)
-    {
-        local_changed_timestamp = timestamp;
-    }
-    QString getETag()
-    {
-        return etag;
-    }
-    void setETag(QString etag)
-    {
-        this->etag = etag;
-    }
-    QString getMD5Sum()
-    {
-        return md5sum;
-    }
-    void setMD5Sum(QString md5sum)
-    {
-        this->md5sum = md5sum;
-    }
-protected:
+class MetaEntry {
+    friend class HttpMetaCache;
+
+   protected:
+    MetaEntry() = default;
+
+   public:
+    auto isStale() -> bool { return stale; }
+    void setStale(bool stale) { this->stale = stale; }
+
+    auto getFullPath() -> QString;
+
+    auto getRemoteChangedTimestamp() -> QString { return remote_changed_timestamp; }
+    void setRemoteChangedTimestamp(QString remote_changed_timestamp) { this->remote_changed_timestamp = remote_changed_timestamp; }
+    void setLocalChangedTimestamp(qint64 timestamp) { local_changed_timestamp = timestamp; }
+
+    auto getETag() -> QString { return etag; }
+    void setETag(QString etag) { this->etag = etag; }
+
+    auto getMD5Sum() -> QString { return md5sum; }
+    void setMD5Sum(QString md5sum) { this->md5sum = md5sum; }
+
+   protected:
     QString baseId;
     QString basePath;
     QString relativePath;
     QString md5sum;
     QString etag;
     qint64 local_changed_timestamp = 0;
-    QString remote_changed_timestamp; // QString for now, RFC 2822 encoded time
+    QString remote_changed_timestamp;  // QString for now, RFC 2822 encoded time
     bool stale = true;
 };
 
-typedef std::shared_ptr<MetaEntry> MetaEntryPtr;
+using MetaEntryPtr = std::shared_ptr<MetaEntry>;
 
-class HttpMetaCache : public QObject
-{
+class HttpMetaCache : public QObject {
     Q_OBJECT
-public:
+   public:
     // supply path to the cache index file
     HttpMetaCache(QString path = QString());
-    ~HttpMetaCache();
+    ~HttpMetaCache() override;
 
     // get the entry solely from the cache
     // you probably don't want this, unless you have some specific caching needs.
-    MetaEntryPtr getEntry(QString base, QString resource_path);
+    auto getEntry(QString base, QString resource_path) -> MetaEntryPtr;
 
     // get the entry from cache and verify that it isn't stale (within reason)
-    MetaEntryPtr resolveEntry(QString base, QString resource_path,
-                              QString expected_etag = QString());
+    auto resolveEntry(QString base, QString resource_path, QString expected_etag = QString()) -> MetaEntryPtr;
 
     // add a previously resolved stale entry
-    bool updateEntry(MetaEntryPtr stale_entry);
+    auto updateEntry(MetaEntryPtr stale_entry) -> bool;
 
     // evict selected entry from cache
-    bool evictEntry(MetaEntryPtr entry);
+    auto evictEntry(MetaEntryPtr entry) -> bool;
 
     void addBase(QString base, QString base_root);
 
     // (re)start a timer that calls SaveNow later.
     void SaveEventually();
     void Load();
-    QString getBasePath(QString base);
-public
-slots:
+
+    auto getBasePath(QString base) -> QString;
+
+   public slots:
     void SaveNow();
 
-private:
+   private:
     // create a new stale entry, given the parameters
-    MetaEntryPtr staleEntry(QString base, QString resource_path);
-    struct EntryMap
-    {
+    auto staleEntry(QString base, QString resource_path) -> MetaEntryPtr;
+
+    struct EntryMap {
         QString base_path;
         QMap<QString, MetaEntryPtr> entry_list;
     };
+
     QMap<QString, EntryMap> m_entries;
     QString m_index_file;
     QTimer saveBatchingTimer;

launcher/net/MetaCacheSink.cpp

@@ -1,3 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * 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.
+ */
+
 #include "MetaCacheSink.h"
 #include <QFile>
 #include <QFileInfo>
@@ -12,17 +47,13 @@ MetaCacheSink::MetaCacheSink(MetaEntryPtr entry, ChecksumValidator * md5sum)
     addValidator(md5sum);
 }
 
-MetaCacheSink::~MetaCacheSink()
-{
-    // nil
-}
-
-JobStatus MetaCacheSink::initCache(QNetworkRequest& request)
+Task::State MetaCacheSink::initCache(QNetworkRequest& request)
 {
     if (!m_entry->isStale())
     {
-        return Job_Finished;
+        return Task::State::Succeeded;
     }
+
     // check if file exists, if it does, use its information for the request
     QFile current(m_filename);
     if(current.exists() && current.size() != 0)
@@ -36,25 +67,31 @@ JobStatus MetaCacheSink::initCache(QNetworkRequest& request)
             request.setRawHeader(QString("If-None-Match").toLatin1(), m_entry->getETag().toLatin1());
         }
     }
-    return Job_InProgress;
+
+    return Task::State::Running;
 }
 
-JobStatus MetaCacheSink::finalizeCache(QNetworkReply & reply)
+Task::State MetaCacheSink::finalizeCache(QNetworkReply & reply)
 {
     QFileInfo output_file_info(m_filename);
+
     if(wroteAnyData)
     {
         m_entry->setMD5Sum(m_md5Node->hash().toHex().constData());
     }
+
     m_entry->setETag(reply.rawHeader("ETag").constData());
+
     if (reply.hasRawHeader("Last-Modified"))
     {
         m_entry->setRemoteChangedTimestamp(reply.rawHeader("Last-Modified").constData());
     }
+
     m_entry->setLocalChangedTimestamp(output_file_info.lastModified().toUTC().toMSecsSinceEpoch());
     m_entry->setStale(false);
     APPLICATION->metacache()->updateEntry(m_entry);
-    return Job_Finished;
+
+    return Task::State::Succeeded;
 }
 
 bool MetaCacheSink::hasLocalData()

launcher/net/MetaCacheSink.h

@@ -1,22 +1,58 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * 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.
+ */
+
 #pragma once
-#include "FileSink.h"
+
 #include "ChecksumValidator.h"
+#include "FileSink.h"
 #include "net/HttpMetaCache.h"
 
 namespace Net {
-class MetaCacheSink : public FileSink
-{
-public: /* con/des */
-    MetaCacheSink(MetaEntryPtr entry, ChecksumValidator * md5sum);
-    virtual ~MetaCacheSink();
-    bool hasLocalData() override;
+class MetaCacheSink : public FileSink {
+   public:
+    MetaCacheSink(MetaEntryPtr entry, ChecksumValidator* md5sum);
+    virtual ~MetaCacheSink() = default;
 
-protected: /* methods */
-    JobStatus initCache(QNetworkRequest & request) override;
-    JobStatus finalizeCache(QNetworkReply & reply) override;
+    auto hasLocalData() -> bool override;
 
-private: /* data */
+   protected:
+    auto initCache(QNetworkRequest& request) -> Task::State override;
+    auto finalizeCache(QNetworkReply& reply) -> Task::State override;
+
+   private:
     MetaEntryPtr m_entry;
-    ChecksumValidator * m_md5Node;
+    ChecksumValidator* m_md5Node;
 };
-}
+}  // namespace Net

launcher/net/Mode.h

@@ -1,10 +1,5 @@
 #pragma once
 
-namespace Net
-{
-enum class Mode
-{
-    Offline,
-    Online
-};
+namespace Net {
+enum class Mode { Offline, Online };
 }

launcher/net/NetAction.h

@@ -1,108 +1,76 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #pragma once
 
-#include <QObject>
-#include <QUrl>
-#include <memory>
 #include <QNetworkReply>
-#include <QObjectPtr.h>
+#include <QUrl>
 
-enum JobStatus
-{
-    Job_NotStarted,
-    Job_InProgress,
-    Job_Finished,
-    Job_Failed,
-    Job_Aborted,
-    /*
-     * FIXME: @NUKE this confuses the task failing with us having a fallback in the form of local data. Clear up the confusion.
-     * Same could be true for aborted task - the presence of pre-existing result is a separate concern
-     */
-    Job_Failed_Proceed
-};
+#include "QObjectPtr.h"
+#include "tasks/Task.h"
 
-class NetAction : public QObject
-{
+class NetAction : public Task {
     Q_OBJECT
-protected:
-    explicit NetAction() : QObject(nullptr) {};
+   protected:
+    explicit NetAction() : Task() {};
 
-public:
+   public:
     using Ptr = shared_qobject_ptr<NetAction>;
 
-    virtual ~NetAction() {};
+    virtual ~NetAction() = default;
 
-    bool isRunning() const
-    {
-        return m_status == Job_InProgress;
-    }
-    bool isFinished() const
-    {
-        return m_status >= Job_Finished;
-    }
-    bool wasSuccessful() const
-    {
-        return m_status == Job_Finished || m_status == Job_Failed_Proceed;
-    }
+    QUrl url() { return m_url; }
+    auto index() -> int { return m_index_within_job; }
 
-    qint64 totalProgress() const
-    {
-        return m_total_progress;
-    }
-    qint64 currentProgress() const
-    {
-        return m_progress;
-    }
-    virtual bool abort()
-    {
-        return false;
-    }
-    virtual bool canAbort()
-    {
-        return false;
-    }
-    QUrl url()
-    {
-        return m_url;
-    }
-
-signals:
-    void started(int index);
-    void netActionProgress(int index, qint64 current, qint64 total);
-    void succeeded(int index);
-    void failed(int index);
-    void aborted(int index);
-
-protected slots:
+   protected slots:
     virtual void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) = 0;
     virtual void downloadError(QNetworkReply::NetworkError error) = 0;
     virtual void downloadFinished() = 0;
     virtual void downloadReadyRead() = 0;
 
-public slots:
-    void start(shared_qobject_ptr<QNetworkAccessManager> network) {
+   public slots:
+    void startAction(shared_qobject_ptr<QNetworkAccessManager> network)
+    {
         m_network = network;
-        startImpl();
+        executeTask();
     }
 
-protected:
-    virtual void startImpl() = 0;
+   protected:
+    void executeTask() override {};
 
-public:
+   public:
     shared_qobject_ptr<QNetworkAccessManager> m_network;
 
     /// index within the parent job, FIXME: nuke
@@ -113,10 +81,4 @@ public:
 
     /// source URL
     QUrl m_url;
-
-    qint64 m_progress = 0;
-    qint64 m_total_progress = 1;
-
-protected:
-    JobStatus m_status = Job_NotStarted;
 };

launcher/net/NetJob.cpp

@@ -1,79 +1,173 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #include "NetJob.h"
 #include "Download.h"
 
-#include <QDebug>
+auto NetJob::addNetAction(NetAction::Ptr action) -> bool
+{
+    action->m_index_within_job = m_downloads.size();
+    m_downloads.append(action);
+    part_info pi;
+    m_parts_progress.append(pi);
+
+    partProgress(m_parts_progress.count() - 1, action->getProgress(), action->getTotalProgress());
+
+    if (action->isRunning()) {
+        connect(action.get(), &NetAction::succeeded, [this, action]{ partSucceeded(action->index()); });
+        connect(action.get(), &NetAction::failed, [this, action](QString){ partFailed(action->index()); });
+        connect(action.get(), &NetAction::aborted, [this, action](){ partAborted(action->index()); });
+        connect(action.get(), &NetAction::progress, [this, action](qint64 done, qint64 total) { partProgress(action->index(), done, total); });
+        connect(action.get(), &NetAction::status, this, &NetJob::status);
+    } else {
+        m_todo.append(m_parts_progress.size() - 1);
+    }
+
+    return true;
+}
+
+auto NetJob::canAbort() const -> bool
+{
+    bool canFullyAbort = true;
+
+    // can abort the downloads on the queue?
+    for (auto index : m_todo) {
+        auto part = m_downloads[index];
+        canFullyAbort &= part->canAbort();
+    }
+    // can abort the active downloads?
+    for (auto index : m_doing) {
+        auto part = m_downloads[index];
+        canFullyAbort &= part->canAbort();
+    }
+
+    return canFullyAbort;
+}
+
+void NetJob::executeTask()
+{
+    // hack that delays early failures so they can be caught easier
+    QMetaObject::invokeMethod(this, "startMoreParts", Qt::QueuedConnection);
+}
+
+auto NetJob::getFailedFiles() -> QStringList
+{
+    QStringList failed;
+    for (auto index : m_failed) {
+        failed.push_back(m_downloads[index]->url().toString());
+    }
+    failed.sort();
+    return failed;
+}
+
+auto NetJob::abort() -> bool
+{
+    bool fullyAborted = true;
+
+    // fail all downloads on the queue
+    m_failed.unite(m_todo.toSet());
+    m_todo.clear();
+
+    // abort active downloads
+    auto toKill = m_doing.toList();
+    for (auto index : toKill) {
+        auto part = m_downloads[index];
+        fullyAborted &= part->abort();
+    }
+
+    return fullyAborted;
+}
 
 void NetJob::partSucceeded(int index)
 {
     // do progress. all slots are 1 in size at least
-    auto &slot = parts_progress[index];
+    auto& slot = m_parts_progress[index];
     partProgress(index, slot.total_progress, slot.total_progress);
 
     m_doing.remove(index);
     m_done.insert(index);
-    downloads[index].get()->disconnect(this);
+    m_downloads[index].get()->disconnect(this);
+
     startMoreParts();
 }
 
 void NetJob::partFailed(int index)
 {
     m_doing.remove(index);
-    auto &slot = parts_progress[index];
-    if (slot.failures == 3)
-    {
+
+    auto& slot = m_parts_progress[index];
+    // Can try 3 times before failing by definitive
+    if (slot.failures == 3) {
         m_failed.insert(index);
-    }
-    else
-    {
+    } else {
         slot.failures++;
         m_todo.enqueue(index);
     }
-    downloads[index].get()->disconnect(this);
+
+    m_downloads[index].get()->disconnect(this);
+
     startMoreParts();
 }
 
 void NetJob::partAborted(int index)
 {
     m_aborted = true;
+
     m_doing.remove(index);
     m_failed.insert(index);
-    downloads[index].get()->disconnect(this);
+    m_downloads[index].get()->disconnect(this);
+
     startMoreParts();
 }
 
 void NetJob::partProgress(int index, qint64 bytesReceived, qint64 bytesTotal)
 {
-    auto &slot = parts_progress[index];
+    auto& slot = m_parts_progress[index];
     slot.current_progress = bytesReceived;
     slot.total_progress = bytesTotal;
 
     int done = m_done.size();
     int doing = m_doing.size();
-    int all = parts_progress.size();
+    int all = m_parts_progress.size();
 
     qint64 bytesAll = 0;
     qint64 bytesTotalAll = 0;
-    for(auto & partIdx: m_doing)
-    {
-        auto part = parts_progress[partIdx];
+    for (auto& partIdx : m_doing) {
+        auto part = m_parts_progress[partIdx];
         // do not count parts with unknown/nonsensical total size
-        if(part.total_progress <= 0)
-        {
+        if (part.total_progress <= 0) {
             continue;
         }
         bytesAll += part.current_progress;
@@ -85,134 +179,54 @@ void NetJob::partProgress(int index, qint64 bytesReceived, qint64 bytesTotal)
     auto current_total = all * 1000;
     // HACK: make sure it never jumps backwards.
     // FAIL: This breaks if the size is not known (or is it something else?) and jumps to 1000, so if it is 1000 reset it to inprogress
-    if(m_current_progress == 1000) {
+    if (m_current_progress == 1000) {
         m_current_progress = inprogress;
     }
-    if(m_current_progress > current)
-    {
+    if (m_current_progress > current) {
         current = m_current_progress;
     }
     m_current_progress = current;
     setProgress(current, current_total);
 }
 
-void NetJob::executeTask()
-{
-    // hack that delays early failures so they can be caught easier
-    QMetaObject::invokeMethod(this, "startMoreParts", Qt::QueuedConnection);
-}
-
 void NetJob::startMoreParts()
 {
-    if(!isRunning())
-    {
-        // this actually makes sense. You can put running downloads into a NetJob and then not start it until much later.
+    if (!isRunning()) {
+        // this actually makes sense. You can put running m_downloads into a NetJob and then not start it until much later.
         return;
     }
+
     // OK. We are actively processing tasks, proceed.
     // Check for final conditions if there's nothing in the queue.
-    if(!m_todo.size())
-    {
-        if(!m_doing.size())
-        {
-            if(!m_failed.size())
-            {
+    if (!m_todo.size()) {
+        if (!m_doing.size()) {
+            if (!m_failed.size()) {
                 emitSucceeded();
-            }
-            else if(m_aborted)
-            {
+            } else if (m_aborted) {
                 emitAborted();
-            }
-            else
-            {
+            } else {
                 emitFailed(tr("Job '%1' failed to process:\n%2").arg(objectName()).arg(getFailedFiles().join("\n")));
             }
         }
         return;
     }
-    // There's work to do, try to start more parts.
-    while (m_doing.size() < 6)
-    {
-        if(!m_todo.size())
+
+    // There's work to do, try to start more parts, to a maximum of 6 concurrent ones.
+    while (m_doing.size() < 6) {
+        if (m_todo.size() == 0)
             return;
         int doThis = m_todo.dequeue();
         m_doing.insert(doThis);
-        auto part = downloads[doThis];
+
+        auto part = m_downloads[doThis];
+
         // connect signals :D
-        connect(part.get(), SIGNAL(succeeded(int)), SLOT(partSucceeded(int)));
-        connect(part.get(), SIGNAL(failed(int)), SLOT(partFailed(int)));
-        connect(part.get(), SIGNAL(aborted(int)), SLOT(partAborted(int)));
-        connect(part.get(), SIGNAL(netActionProgress(int, qint64, qint64)),
-                SLOT(partProgress(int, qint64, qint64)));
-        part->start(m_network);
+        connect(part.get(), &NetAction::succeeded, this, [this, part]{ partSucceeded(part->index()); });
+        connect(part.get(), &NetAction::failed, this, [this, part](QString){ partFailed(part->index()); });
+        connect(part.get(), &NetAction::aborted, this, [this, part]{ partAborted(part->index()); });
+        connect(part.get(), &NetAction::progress, this, [this, part](qint64 done, qint64 total) { partProgress(part->index(), done, total); });
+        connect(part.get(), &NetAction::status, this, &NetJob::status);
+
+        part->startAction(m_network);
     }
 }
-
-
-QStringList NetJob::getFailedFiles()
-{
-    QStringList failed;
-    for (auto index: m_failed)
-    {
-        failed.push_back(downloads[index]->url().toString());
-    }
-    failed.sort();
-    return failed;
-}
-
-bool NetJob::canAbort() const
-{
-    bool canFullyAbort = true;
-    // can abort the waiting?
-    for(auto index: m_todo)
-    {
-        auto part = downloads[index];
-        canFullyAbort &= part->canAbort();
-    }
-    // can abort the active?
-    for(auto index: m_doing)
-    {
-        auto part = downloads[index];
-        canFullyAbort &= part->canAbort();
-    }
-    return canFullyAbort;
-}
-
-bool NetJob::abort()
-{
-    bool fullyAborted = true;
-    // fail all waiting
-    m_failed.unite(m_todo.toSet());
-    m_todo.clear();
-    // abort active
-    auto toKill = m_doing.toList();
-    for(auto index: toKill)
-    {
-        auto part = downloads[index];
-        fullyAborted &= part->abort();
-    }
-    return fullyAborted;
-}
-
-bool NetJob::addNetAction(NetAction::Ptr action)
-{
-    action->m_index_within_job = downloads.size();
-    downloads.append(action);
-    part_info pi;
-    parts_progress.append(pi);
-    partProgress(parts_progress.count() - 1, action->currentProgress(), action->totalProgress());
-
-    if(action->isRunning())
-    {
-        connect(action.get(), SIGNAL(succeeded(int)), SLOT(partSucceeded(int)));
-        connect(action.get(), SIGNAL(failed(int)), SLOT(partFailed(int)));
-        connect(action.get(), SIGNAL(netActionProgress(int, qint64, qint64)), SLOT(partProgress(int, qint64, qint64)));
-    }
-    else
-    {
-        m_todo.append(parts_progress.size() - 1);
-    }
-    return true;
-}
-
-NetJob::~NetJob() = default;

launcher/net/NetJob.h

@@ -1,88 +1,98 @@
-/* Copyright 2013-2021 MultiMC Contributors
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.com>
  *
- * 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
+ *  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.
  *
- *     http://www.apache.org/licenses/LICENSE-2.0
+ *  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.
  *
- * 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.
+ *  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.
  */
 
 #pragma once
+
 #include <QtNetwork>
+
+#include <QObject>
 #include "NetAction.h"
-#include "Download.h"
-#include "HttpMetaCache.h"
 #include "tasks/Task.h"
-#include "QObjectPtr.h"
 
-class NetJob;
+// Those are included so that they are also included by anyone using NetJob
+#include "net/Download.h"
+#include "net/HttpMetaCache.h"
 
-class NetJob : public Task
-{
+class NetJob : public Task {
     Q_OBJECT
-public:
+
+   public:
     using Ptr = shared_qobject_ptr<NetJob>;
 
     explicit NetJob(QString job_name, shared_qobject_ptr<QNetworkAccessManager> network) : Task(), m_network(network)
     {
         setObjectName(job_name);
     }
-    virtual ~NetJob();
+    virtual ~NetJob() = default;
 
-    bool addNetAction(NetAction::Ptr action);
+    void executeTask() override;
 
-    NetAction::Ptr operator[](int index)
-    {
-        return downloads[index];
-    }
-    const NetAction::Ptr at(const int index)
-    {
-        return downloads.at(index);
-    }
-    NetAction::Ptr first()
-    {
-        if (downloads.size())
-            return downloads[0];
-        return NetAction::Ptr();
-    }
-    int size() const
-    {
-        return downloads.size();
-    }
-    QStringList getFailedFiles();
+    auto canAbort() const -> bool override;
 
-    bool canAbort() const override;
+    auto addNetAction(NetAction::Ptr action) -> bool;
 
-private slots:
+    auto operator[](int index) -> NetAction::Ptr { return m_downloads[index]; }
+    auto at(int index) -> const NetAction::Ptr { return m_downloads.at(index); }
+    auto size() const -> int { return m_downloads.size(); }
+    auto first() -> NetAction::Ptr { return m_downloads.size() != 0 ? m_downloads[0] : NetAction::Ptr{}; }
+
+    auto getFailedFiles() -> QStringList;
+
+   public slots:
+    // Qt can't handle auto at the start for some reason?
+    bool abort() override;
+
+   private slots:
     void startMoreParts();
 
-public slots:
-    virtual void executeTask() override;
-    virtual bool abort() override;
-
-private slots:
     void partProgress(int index, qint64 bytesReceived, qint64 bytesTotal);
     void partSucceeded(int index);
     void partFailed(int index);
     void partAborted(int index);
 
-private:
+   private:
     shared_qobject_ptr<QNetworkAccessManager> m_network;
 
-    struct part_info
-    {
+    struct part_info {
         qint64 current_progress = 0;
         qint64 total_progress = 1;
         int failures = 0;
     };
-    QList<NetAction::Ptr> downloads;
-    QList<part_info> parts_progress;
+
+    QList<NetAction::Ptr> m_downloads;
+    QList<part_info> m_parts_progress;
     QQueue<int> m_todo;
     QSet<int> m_doing;
     QSet<int> m_done;

launcher/net/PasteUpload.cpp

@@ -1,3 +1,39 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (C) 2022 Lenny McLennington <lenny@sneed.church>
+ *  Copyright (C) 2022 Swirl <swurl@swurl.xyz>
+ *
+ *  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.
+ */
+
 #include "PasteUpload.h"
 #include "BuildConfig.h"
 #include "Application.h"
@@ -8,8 +44,22 @@
 #include <QJsonDocument>
 #include <QFile>
 
-PasteUpload::PasteUpload(QWidget *window, QString text, QString url) : m_window(window), m_uploadUrl(url), m_text(text.toUtf8())
+std::array<PasteUpload::PasteTypeInfo, 4> PasteUpload::PasteTypes = {
+    {{"0x0.st", "https://0x0.st", ""},
+     {"hastebin", "https://hst.sh", "/documents"},
+     {"paste.gg", "https://paste.gg", "/api/v1/pastes"},
+     {"mclo.gs", "https://api.mclo.gs", "/1/log"}}};
+
+PasteUpload::PasteUpload(QWidget *window, QString text, QString baseUrl, PasteType pasteType) : m_window(window), m_baseUrl(baseUrl), m_pasteType(pasteType), m_text(text.toUtf8())
 {
+    if (m_baseUrl == "")
+        m_baseUrl = PasteTypes.at(pasteType).defaultBase;
+
+    // HACK: Paste's docs say the standard API path is at /api/<version> but the official instance paste.gg doesn't follow that??
+    if (pasteType == PasteGG && m_baseUrl == PasteTypes.at(pasteType).defaultBase)
+        m_uploadUrl = "https://api.paste.gg/v1/pastes";
+    else
+        m_uploadUrl = m_baseUrl + PasteTypes.at(pasteType).endpointPath;
 }
 
 PasteUpload::~PasteUpload()
@@ -19,26 +69,73 @@ PasteUpload::~PasteUpload()
 void PasteUpload::executeTask()
 {
     QNetworkRequest request{QUrl(m_uploadUrl)};
+    QNetworkReply *rep{};
+
     request.setHeader(QNetworkRequest::UserAgentHeader, BuildConfig.USER_AGENT_UNCACHED);
 
-    QHttpMultiPart *multiPart = new QHttpMultiPart{QHttpMultiPart::FormDataType};
+    switch (m_pasteType) {
+    case NullPointer: {
+        QHttpMultiPart *multiPart =
+          new QHttpMultiPart{QHttpMultiPart::FormDataType};
 
-    QHttpPart filePart;
-    filePart.setBody(m_text);
-    filePart.setHeader(QNetworkRequest::ContentTypeHeader, "text/plain");
-    filePart.setHeader(QNetworkRequest::ContentDispositionHeader, "form-data; name=\"file\"; filename=\"log.txt\"");
+        QHttpPart filePart;
+        filePart.setBody(m_text);
+        filePart.setHeader(QNetworkRequest::ContentTypeHeader, "text/plain");
+        filePart.setHeader(QNetworkRequest::ContentDispositionHeader,
+                         "form-data; name=\"file\"; filename=\"log.txt\"");
+        multiPart->append(filePart);
 
-    multiPart->append(filePart);
+        rep = APPLICATION->network()->post(request, multiPart);
+        multiPart->setParent(rep);
 
-    QNetworkReply *rep = APPLICATION->network()->post(request, multiPart);
-    multiPart->setParent(rep);
+        break;
+    }
+    case Hastebin: {
+        request.setHeader(QNetworkRequest::UserAgentHeader, BuildConfig.USER_AGENT_UNCACHED);
+        rep = APPLICATION->network()->post(request, m_text);
+        break;
+    }
+    case Mclogs: {
+        QUrlQuery postData;
+        postData.addQueryItem("content", m_text);
+        request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
+        rep = APPLICATION->network()->post(request, postData.toString().toUtf8());
+        break;
+    }
+    case PasteGG: {
+        QJsonObject obj;
+        QJsonDocument doc;
+        request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
 
-    m_reply = std::shared_ptr<QNetworkReply>(rep);
-    setStatus(tr("Uploading to %1").arg(m_uploadUrl));
+        obj.insert("expires", QDateTime::currentDateTimeUtc().addDays(100).toString(Qt::DateFormat::ISODate));
+
+        QJsonArray files;
+        QJsonObject logFileInfo;
+        QJsonObject logFileContentInfo;
+        logFileContentInfo.insert("format", "text");
+        logFileContentInfo.insert("value", QString::fromUtf8(m_text));
+        logFileInfo.insert("name", "log.txt");
+        logFileInfo.insert("content", logFileContentInfo);
+        files.append(logFileInfo);
+
+        obj.insert("files", files);
+
+        doc.setObject(obj);
+        rep = APPLICATION->network()->post(request, doc.toJson());
+        break;
+    }
+    }
 
     connect(rep, &QNetworkReply::uploadProgress, this, &Task::setProgress);
-    connect(rep, SIGNAL(error(QNetworkReply::NetworkError)), this, SLOT(downloadError(QNetworkReply::NetworkError)));
-    connect(rep, SIGNAL(finished()), this, SLOT(downloadFinished()));
+    connect(rep, &QNetworkReply::finished, this, &PasteUpload::downloadFinished);
+    // This function call would be a lot shorter if we were using the latest Qt
+    connect(rep,
+            static_cast<void (QNetworkReply::*)(QNetworkReply::NetworkError)>(&QNetworkReply::error),
+            this, &PasteUpload::downloadError);
+
+    m_reply = std::shared_ptr<QNetworkReply>(rep);
+
+    setStatus(tr("Uploading to %1").arg(m_uploadUrl));
 }
 
 void PasteUpload::downloadError(QNetworkReply::NetworkError error)
@@ -68,6 +165,82 @@ void PasteUpload::downloadFinished()
         return;
     }
 
-    m_pasteLink = QString::fromUtf8(data).trimmed();
+    switch (m_pasteType)
+    {
+    case NullPointer:
+        m_pasteLink = QString::fromUtf8(data).trimmed();
+        break;
+    case Hastebin: {
+        QJsonDocument jsonDoc{QJsonDocument::fromJson(data)};
+        QJsonObject jsonObj{jsonDoc.object()};
+        if (jsonObj.contains("key") && jsonObj["key"].isString())
+        {
+            QString key = jsonDoc.object()["key"].toString();
+            m_pasteLink = m_baseUrl + "/" + key;
+        }
+        else
+        {
+            emitFailed(tr("Error: %1 returned a malformed response body").arg(m_uploadUrl));
+            qCritical() << m_uploadUrl << " returned malformed response body: " << data;
+            return;
+        }
+        break;
+    }
+    case Mclogs: {
+        QJsonDocument jsonDoc{QJsonDocument::fromJson(data)};
+        QJsonObject jsonObj{jsonDoc.object()};
+        if (jsonObj.contains("success") && jsonObj["success"].isBool())
+        {
+            bool success = jsonObj["success"].toBool();
+            if (success)
+            {
+                m_pasteLink = jsonObj["url"].toString();
+            }
+            else
+            {
+                QString error = jsonObj["error"].toString();
+                emitFailed(tr("Error: %1 returned an error: %2").arg(m_uploadUrl, error));
+                qCritical() << m_uploadUrl << " returned error: " << error;
+                qCritical() << "Response body: " << data;
+                return;
+            }
+        }
+        else
+        {
+            emitFailed(tr("Error: %1 returned a malformed response body").arg(m_uploadUrl));
+            qCritical() << m_uploadUrl << " returned malformed response body: " << data;
+            return;
+        }
+        break;
+    }
+    case PasteGG:
+        QJsonDocument jsonDoc{QJsonDocument::fromJson(data)};
+        QJsonObject jsonObj{jsonDoc.object()};
+        if (jsonObj.contains("status") && jsonObj["status"].isString())
+        {
+            QString status = jsonObj["status"].toString();
+            if (status == "success")
+            {
+                m_pasteLink = m_baseUrl + "/p/anonymous/" + jsonObj["result"].toObject()["id"].toString();
+            }
+            else
+            {
+                QString error = jsonObj["error"].toString();
+                QString message = (jsonObj.contains("message") && jsonObj["message"].isString()) ? jsonObj["message"].toString() : "none";
+                emitFailed(tr("Error: %1 returned an error code: %2\nError message: %3").arg(m_uploadUrl, error, message));
+                qCritical() << m_uploadUrl << " returned error: " << error;
+                qCritical() << "Error message: " << message;
+                qCritical() << "Response body: " << data;
+                return;
+            }
+        }
+        else
+        {
+            emitFailed(tr("Error: %1 returned a malformed response body").arg(m_uploadUrl));
+            qCritical() << m_uploadUrl << " returned malformed response body: " << data;
+            return;
+        }
+        break;
+    }
     emitSucceeded();
 }

launcher/net/PasteUpload.h

@@ -1,14 +1,74 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (C) 2022 Lenny McLennington <lenny@sneed.church>
+ *
+ *  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.
+ */
+
 #pragma once
+
 #include "tasks/Task.h"
 #include <QNetworkReply>
+#include <QString>
 #include <QBuffer>
 #include <memory>
+#include <array>
 
 class PasteUpload : public Task
 {
     Q_OBJECT
 public:
-    PasteUpload(QWidget *window, QString text, QString url);
+    enum PasteType : int {
+        // 0x0.st
+        NullPointer,
+        // hastebin.com
+        Hastebin,
+        // paste.gg
+        PasteGG,
+        // mclo.gs
+        Mclogs,
+        // Helpful to get the range of valid values on the enum for input sanitisation:
+        First = NullPointer,
+        Last = Mclogs
+    };
+
+    struct PasteTypeInfo {
+        const QString name;
+        const QString defaultBase;
+        const QString endpointPath;
+    };
+
+    static std::array<PasteTypeInfo, 4> PasteTypes;
+
+    PasteUpload(QWidget *window, QString text, QString url, PasteType pasteType);
     virtual ~PasteUpload();
 
     QString pasteLink()
@@ -21,7 +81,9 @@ protected:
 private:
     QWidget *m_window;
     QString m_pasteLink;
+    QString m_baseUrl;
     QString m_uploadUrl;
+    PasteType m_pasteType;
     QByteArray m_text;
     std::shared_ptr<QNetworkReply> m_reply;
 public

launcher/net/Sink.h

@@ -1,3 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * 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.
+ */
+
 #pragma once
 
 #include "net/NetAction.h"
@@ -5,33 +40,39 @@
 #include "Validator.h"
 
 namespace Net {
-class Sink
-{
-public: /* con/des */
-    Sink() {};
-    virtual ~Sink() {};
+class Sink {
+   public:
+    Sink() = default;
+    virtual ~Sink() = default;
 
-public: /* methods */
-    virtual JobStatus init(QNetworkRequest & request) = 0;
-    virtual JobStatus write(QByteArray & data) = 0;
-    virtual JobStatus abort() = 0;
-    virtual JobStatus finalize(QNetworkReply & reply) = 0;
-    virtual bool hasLocalData() = 0;
+   public:
+    virtual auto init(QNetworkRequest& request) -> Task::State = 0;
+    virtual auto write(QByteArray& data) -> Task::State = 0;
+    virtual auto abort() -> Task::State = 0;
+    virtual auto finalize(QNetworkReply& reply) -> Task::State = 0;
 
-    void addValidator(Validator * validator)
+    virtual auto hasLocalData() -> bool = 0;
+
+    void addValidator(Validator* validator)
     {
-        if(validator)
-        {
+        if (validator) {
             validators.push_back(std::shared_ptr<Validator>(validator));
         }
     }
 
-protected: /* methods */
-    bool finalizeAllValidators(QNetworkReply & reply)
+   protected:
+    bool initAllValidators(QNetworkRequest& request)
     {
-        for(auto & validator: validators)
-        {
-            if(!validator->validate(reply))
+        for (auto& validator : validators) {
+            if (!validator->init(request))
+                return false;
+        }
+        return true;
+    }
+    bool finalizeAllValidators(QNetworkReply& reply)
+    {
+        for (auto& validator : validators) {
+            if (!validator->validate(reply))
                 return false;
         }
         return true;
@@ -39,32 +80,21 @@ protected: /* methods */
     bool failAllValidators()
     {
         bool success = true;
-        for(auto & validator: validators)
-        {
+        for (auto& validator : validators) {
             success &= validator->abort();
         }
         return success;
     }
-    bool initAllValidators(QNetworkRequest & request)
+    bool writeAllValidators(QByteArray& data)
     {
-        for(auto & validator: validators)
-        {
-            if(!validator->init(request))
-                return false;
-        }
-        return true;
-    }
-    bool writeAllValidators(QByteArray & data)
-    {
-        for(auto & validator: validators)
-        {
-            if(!validator->write(data))
+        for (auto& validator : validators) {
+            if (!validator->write(data))
                 return false;
         }
         return true;
     }
 
-protected: /* data */
+   protected:
     std::vector<std::shared_ptr<Validator>> validators;
 };
-}
+}  // namespace Net

launcher/net/Upload.cpp

@@ -0,0 +1,199 @@
+//
+// Created by timoreo on 20/05/22.
+//
+
+#include "Upload.h"
+
+#include <utility>
+#include "ByteArraySink.h"
+#include "BuildConfig.h"
+#include "Application.h"
+
+namespace Net {
+
+    void Upload::downloadProgress(qint64 bytesReceived, qint64 bytesTotal) {
+        setProgress(bytesReceived, bytesTotal);
+    }
+
+    void Upload::downloadError(QNetworkReply::NetworkError error) {
+        if (error == QNetworkReply::OperationCanceledError) {
+            qCritical() << "Aborted " << m_url.toString();
+            m_state = State::AbortedByUser;
+        } else {
+            // error happened during download.
+            qCritical() << "Failed " << m_url.toString() << " with reason " << error;
+            m_state = State::Failed;
+        }
+    }
+
+    void Upload::sslErrors(const QList<QSslError> &errors) {
+        int i = 1;
+        for (const auto& error : errors) {
+            qCritical() << "Upload" << m_url.toString() << "SSL Error #" << i << " : " << error.errorString();
+            auto cert = error.certificate();
+            qCritical() << "Certificate in question:\n" << cert.toText();
+            i++;
+        }
+    }
+
+    bool Upload::handleRedirect()
+    {
+        QUrl redirect = m_reply->header(QNetworkRequest::LocationHeader).toUrl();
+        if (!redirect.isValid()) {
+            if (!m_reply->hasRawHeader("Location")) {
+                // no redirect -> it's fine to continue
+                return false;
+            }
+            // there is a Location header, but it's not correct. we need to apply some workarounds...
+            QByteArray redirectBA = m_reply->rawHeader("Location");
+            if (redirectBA.size() == 0) {
+                // empty, yet present redirect header? WTF?
+                return false;
+            }
+            QString redirectStr = QString::fromUtf8(redirectBA);
+
+            if (redirectStr.startsWith("//")) {
+                /*
+                 * IF the URL begins with //, we need to insert the URL scheme.
+                 * See: https://bugreports.qt.io/browse/QTBUG-41061
+                 * See: http://tools.ietf.org/html/rfc3986#section-4.2
+                 */
+                redirectStr = m_reply->url().scheme() + ":" + redirectStr;
+            } else if (redirectStr.startsWith("/")) {
+                /*
+                 * IF the URL begins with /, we need to process it as a relative URL
+                 */
+                auto url = m_reply->url();
+                url.setPath(redirectStr, QUrl::TolerantMode);
+                redirectStr = url.toString();
+            }
+
+            /*
+             * Next, make sure the URL is parsed in tolerant mode. Qt doesn't parse the location header in tolerant mode, which causes issues.
+             * FIXME: report Qt bug for this
+             */
+            redirect = QUrl(redirectStr, QUrl::TolerantMode);
+            if (!redirect.isValid()) {
+                qWarning() << "Failed to parse redirect URL:" << redirectStr;
+                downloadError(QNetworkReply::ProtocolFailure);
+                return false;
+            }
+            qDebug() << "Fixed location header:" << redirect;
+        } else {
+            qDebug() << "Location header:" << redirect;
+        }
+
+        m_url = QUrl(redirect.toString());
+        qDebug() << "Following redirect to " << m_url.toString();
+        startAction(m_network);
+        return true;
+    }
+
+    void Upload::downloadFinished() {
+        // handle HTTP redirection first
+        // very unlikely for post requests, still can happen
+        if (handleRedirect()) {
+            qDebug() << "Upload redirected:" << m_url.toString();
+            return;
+        }
+
+        // if the download failed before this point ...
+        if (m_state == State::Succeeded) {
+            qDebug() << "Upload failed but we are allowed to proceed:" << m_url.toString();
+            m_sink->abort();
+            m_reply.reset();
+            emit succeeded();
+            return;
+        } else if (m_state == State::Failed) {
+            qDebug() << "Upload failed in previous step:" << m_url.toString();
+            m_sink->abort();
+            m_reply.reset();
+            emit failed("");
+            return;
+        } else if (m_state == State::AbortedByUser) {
+            qDebug() << "Upload aborted in previous step:" << m_url.toString();
+            m_sink->abort();
+            m_reply.reset();
+            emit aborted();
+            return;
+        }
+
+        // make sure we got all the remaining data, if any
+        auto data = m_reply->readAll();
+        if (data.size()) {
+            qDebug() << "Writing extra" << data.size() << "bytes";
+            m_state = m_sink->write(data);
+        }
+
+        // otherwise, finalize the whole graph
+        m_state = m_sink->finalize(*m_reply.get());
+        if (m_state != State::Succeeded) {
+            qDebug() << "Upload failed to finalize:" << m_url.toString();
+            m_sink->abort();
+            m_reply.reset();
+            emit failed("");
+            return;
+        }
+        m_reply.reset();
+        qDebug() << "Upload succeeded:" << m_url.toString();
+        emit succeeded();
+    }
+
+    void Upload::downloadReadyRead() {
+        if (m_state == State::Running) {
+            auto data = m_reply->readAll();
+            m_state = m_sink->write(data);
+        }
+    }
+
+    void Upload::executeTask() {
+        setStatus(tr("Uploading %1").arg(m_url.toString()));
+
+        if (m_state == State::AbortedByUser) {
+            qWarning() << "Attempt to start an aborted Upload:" << m_url.toString();
+            emit aborted();
+            return;
+        }
+        QNetworkRequest request(m_url);
+        m_state = m_sink->init(request);
+        switch (m_state) {
+            case State::Succeeded:
+                emitSucceeded();
+                qDebug() << "Upload cache hit " << m_url.toString();
+                return;
+            case State::Running:
+                qDebug() << "Uploading " << m_url.toString();
+                break;
+            case State::Inactive:
+            case State::Failed:
+                emitFailed("");
+                return;
+            case State::AbortedByUser:
+                emitAborted();
+                return;
+        }
+
+        request.setHeader(QNetworkRequest::UserAgentHeader, BuildConfig.USER_AGENT);
+        if (request.url().host().contains("api.curseforge.com")) {
+            request.setRawHeader("x-api-key", APPLICATION->getCurseKey().toUtf8());
+        }
+        //TODO other types of post requests ?
+        request.setHeader(QNetworkRequest::ContentTypeHeader, "application/json");
+        QNetworkReply* rep = m_network->post(request, m_post_data);
+
+        m_reply.reset(rep);
+        connect(rep, SIGNAL(downloadProgress(qint64, qint64)), SLOT(downloadProgress(qint64, qint64)));
+        connect(rep, SIGNAL(finished()), SLOT(downloadFinished()));
+        connect(rep, SIGNAL(error(QNetworkReply::NetworkError)), SLOT(downloadError(QNetworkReply::NetworkError)));
+        connect(rep, &QNetworkReply::sslErrors, this, &Upload::sslErrors);
+        connect(rep, &QNetworkReply::readyRead, this, &Upload::downloadReadyRead);
+    }
+
+    Upload::Ptr Upload::makeByteArray(QUrl url, QByteArray *output, QByteArray m_post_data) {
+        auto* up = new Upload();
+        up->m_url = std::move(url);
+        up->m_sink.reset(new ByteArraySink(output));
+        up->m_post_data = std::move(m_post_data);
+        return up;
+    }
+} // Net

launcher/net/Upload.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "NetAction.h"
+#include "Sink.h"
+
+namespace Net {
+
+    class Upload : public NetAction {
+        Q_OBJECT
+
+    public:
+        static Upload::Ptr makeByteArray(QUrl url, QByteArray *output, QByteArray m_post_data);
+
+    protected slots:
+        void downloadProgress(qint64 bytesReceived, qint64 bytesTotal) override;
+        void downloadError(QNetworkReply::NetworkError error) override;
+        void sslErrors(const QList<QSslError> & errors);
+        void downloadFinished() override;
+        void downloadReadyRead() override;
+
+    public slots:
+        void executeTask() override;
+    private:
+        std::unique_ptr<Sink> m_sink;
+        QByteArray m_post_data;
+
+        bool handleRedirect();
+    };
+
+} // Net
+

launcher/net/Validator.h

@@ -1,3 +1,37 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *
+ *  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.
+ */
+
 #pragma once
 
 #include "net/NetAction.h"

launcher/resources/multimc/multimc.qrc

@@ -6,8 +6,7 @@
         <!-- REDDIT logo icon, needs reddit license! -->
         <file>scalable/reddit-alien.svg</file>
 
-        <!-- Icon for CurseForge. Unknown license? -->
-        <file alias="32x32/flame.png">32x32/instances/flame.png</file>
+        <!-- Icon for CurseForge. CC0 -->
         <file alias="128x128/flame.png">128x128/instances/flame.png</file>
 
         <!-- launcher settings page -->
@@ -20,6 +19,9 @@
         <file>scalable/atlauncher.svg</file>
         <file>scalable/atlauncher-placeholder.png</file>
 
+        <!-- Modrinth logo icon -->
+        <file>scalable/instances/modrinth.svg</file>
+
         <!-- A proxy icon. Our own. SSSsss -->
         <file>scalable/proxy.svg</file>
 
@@ -269,12 +271,8 @@
         <file>32x32/instances/ftb_logo.png</file>
         <file>128x128/instances/ftb_logo.png</file>
 
-        <file>32x32/instances/flame.png</file>
         <file>128x128/instances/flame.png</file>
 
-        <file>32x32/instances/modrinth.png</file>
-        <file>128x128/instances/modrinth.png</file>
-
         <file>32x32/instances/gear.png</file>
         <file>128x128/instances/gear.png</file>
 
@@ -313,5 +311,6 @@
 
         <file>scalable/instances/fox.svg</file>
         <file>scalable/instances/bee.svg</file>
+        <file>scalable/instances/polymc.svg</file>
     </qresource>
 </RCC>

launcher/resources/multimc/scalable/instances/modrinth.svg

@@ -0,0 +1,4 @@
+<svg width="512" height="514" viewBox="0 0 512 514" fill="none" xmlns="http://www.w3.org/2000/svg">
+  <path fill-rule="evenodd" clip-rule="evenodd" d="M503.16 323.56C514.55 281.47 515.32 235.91 503.2 190.76C466.57 54.2299 326.04 -26.8001 189.33 9.77991C83.8101 38.0199 11.3899 128.07 0.689941 230.47H43.99C54.29 147.33 113.74 74.7298 199.75 51.7098C306.05 23.2598 415.13 80.6699 453.17 181.38L411.03 192.65C391.64 145.8 352.57 111.45 306.3 96.8198L298.56 140.66C335.09 154.13 364.72 184.5 375.56 224.91C391.36 283.8 361.94 344.14 308.56 369.17L320.09 412.16C390.25 383.21 432.4 310.3 422.43 235.14L464.41 223.91C468.91 252.62 467.35 281.16 460.55 308.07L503.16 323.56Z" fill="#30b27b"/>
+  <path d="M321.99 504.22C185.27 540.8 44.7501 459.77 8.11011 323.24C3.84011 307.31 1.17 291.33 0 275.46H43.27C44.36 287.37 46.4699 299.35 49.6799 311.29C53.0399 323.8 57.45 335.75 62.79 347.07L101.38 323.92C98.1299 316.42 95.39 308.6 93.21 300.47C69.17 210.87 122.41 118.77 212.13 94.7601C229.13 90.2101 246.23 88.4401 262.93 89.1501L255.19 133C244.73 133.05 234.11 134.42 223.53 137.25C157.31 154.98 118.01 222.95 135.75 289.09C136.85 293.16 138.13 297.13 139.59 300.99L188.94 271.38L174.07 231.95L220.67 184.08L279.57 171.39L296.62 192.38L269.47 219.88L245.79 227.33L228.87 244.72L237.16 267.79C237.16 267.79 253.95 285.63 253.98 285.64L277.7 279.33L294.58 260.79L331.44 249.12L342.42 273.82L304.39 320.45L240.66 340.63L212.08 308.81L162.26 338.7C187.8 367.78 226.2 383.93 266.01 380.56L277.54 423.55C218.13 431.41 160.1 406.82 124.05 361.64L85.6399 384.68C136.25 451.17 223.84 484.11 309.61 461.16C371.35 444.64 419.4 402.56 445.42 349.38L488.06 364.88C457.17 431.16 398.22 483.82 321.99 504.22Z" fill="#30b27b"/>
+</svg>

launcher/resources/multimc/scalable/instances/polymc.svg

@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- Created with Inkscape (http://www.inkscape.org/) -->
+<svg width="64" height="64" version="1.1" viewBox="0 0 16.933 16.933" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+ <defs>
+  <linearGradient id="linearGradient84726" x1="4.4979" x2="12.435" y1="3.8011" y2="9.5681" gradientUnits="userSpaceOnUse">
+   <stop stop-color="#88b858" offset="0"/>
+   <stop stop-color="#72b147" offset=".5"/>
+   <stop stop-color="#5a9a30" offset="1"/>
+  </linearGradient>
+ </defs>
+ <g>
+  <path d="m3.561 16.016s0-3.5642 4.9056-3.5642c4.9069 0 4.9056 3.5642 4.9056 3.5642z" fill="#765338"/>
+  <path d="m8.4667 12.452-4.9056 3.5642-3.0319-9.3311z" fill="#b7835a"/>
+  <path d="m8.4667 12.452 7.9375-5.7669-3.0319 9.3311z" fill="#5b422d"/>
+  <path d="m8.8308 12.716-0.36417 0.26458-0.36417-0.26458c0-0.26458 0.36417-0.26458 0.36417-0.26458s0.36417 0 0.36417 0.26458z" fill="#72b147"/>
+  <path d="m8.4667 12.452s-2e-7 -5.7669 7.9375-5.7669l-0.22507 0.69269-0.91853 1.1965-0.91853 0.13819-0.91853 1.1965-0.91853 0.13819-0.91853 1.1965-0.91853 0.13819-0.91853 1.1965-0.91853 0.13819z" fill="#5a9a30"/>
+  <path d="m8.1025 12.716-0.91853-0.13819-0.91853-1.1965-0.91853-0.13819-0.91853-1.1965-0.91853-0.13819-0.91853-1.1965-0.91853-0.13819-0.91853-1.1965-0.22507-0.69269c7.9375 1e-7 7.9375 5.7669 7.9375 5.7669z" fill="#88b858"/>
+  <path d="m0.52917 6.6846 7.9375 5.7669 7.9375-5.7669-7.9375-5.7669z" fill="url(#linearGradient84726)"/>
+ </g>
+ <path d="m0.75424 7.3773-0.22507-0.69269 7.9375 5.7669 7.9375-5.7669-0.22507 0.69269-7.7124 5.6034z" fill-opacity="0"/>
+</svg>

launcher/screenshots/ImgurAlbumCreation.cpp

@@ -1,3 +1,38 @@
+// SPDX-License-Identifier: GPL-3.0-only
+/*
+ *  PolyMC - Minecraft Launcher
+ *  Copyright (c) 2022 flowln <flowlnlnln@gmail.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/>.
+ *
+ * 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.
+ */
+
 #include "ImgurAlbumCreation.h"
 
 #include <QNetworkRequest>
@@ -13,12 +48,12 @@
 ImgurAlbumCreation::ImgurAlbumCreation(QList<ScreenShot::Ptr> screenshots) : NetAction(), m_screenshots(screenshots)
 {
     m_url = BuildConfig.IMGUR_BASE_URL + "album.json";
-    m_status = Job_NotStarted;
+    m_state = State::Inactive;
 }
 
-void ImgurAlbumCreation::startImpl()
+void ImgurAlbumCreation::executeTask()
 {
-    m_status = Job_InProgress;
+    m_state = State::Running;
     QNetworkRequest request(m_url);
     request.setHeader(QNetworkRequest::UserAgentHeader, BuildConfig.USER_AGENT_UNCACHED);
     request.setHeader(QNetworkRequest::ContentTypeHeader, "application/x-www-form-urlencoded");
@@ -43,11 +78,11 @@ void ImgurAlbumCreation::startImpl()
 void ImgurAlbumCreation::downloadError(QNetworkReply::NetworkError error)
 {
     qDebug() << m_reply->errorString();
-    m_status = Job_Failed;
+    m_state = State::Failed;
 }
 void ImgurAlbumCreation::downloadFinished()
 {
-    if (m_status != Job_Failed)
+    if (m_state != State::Failed)
     {
         QByteArray data = m_reply->readAll();
         m_reply.reset();
@@ -56,33 +91,32 @@ void ImgurAlbumCreation::downloadFinished()
         if (jsonError.error != QJsonParseError::NoError)
         {
             qDebug() << jsonError.errorString();
-            emit failed(m_index_within_job);
+            emitFailed();
             return;
         }
         auto object = doc.object();
         if (!object.value("success").toBool())
         {
             qDebug() << doc.toJson();
-            emit failed(m_index_within_job);
+            emitFailed();
             return;
         }
         m_deleteHash = object.value("data").toObject().value("deletehash").toString();
         m_id = object.value("data").toObject().value("id").toString();
-        m_status = Job_Finished;
-        emit succeeded(m_index_within_job);
+        m_state = State::Succeeded;
+        emit succeeded();
         return;
     }
     else
     {
         qDebug() << m_reply->readAll();
         m_reply.reset();
-        emit failed(m_index_within_job);
+        emitFailed();
         return;
     }
 }
 void ImgurAlbumCreation::downloadProgress(qint64 bytesReceived, qint64 bytesTotal)
 {
-    m_total_progress = bytesTotal;
-    m_progress = bytesReceived;
-    emit netActionProgress(m_index_within_job, bytesReceived, bytesTotal);
+    setProgress(bytesReceived, bytesTotal);
+    emit progress(bytesReceived, bytesTotal);
 }