Filter preview version of OptiFine

Fix selected account is not loaded

HMCL/build.gradle

@@ -1,8 +1,10 @@
+import org.apache.tools.ant.filters.ReplaceTokens
+import proguard.gradle.ProGuardTask
+
 import java.security.MessageDigest
 import java.util.jar.JarFile
 import java.util.jar.Pack200
 import java.util.zip.GZIPOutputStream
-import java.io.File
 
 if (!hasProperty('mainClass')) {
     ext.mainClass = 'org.jackhuang.hmcl.Main'
@@ -16,11 +18,9 @@ if (buildnumber == null)
 
 def versionroot = System.getenv("VERSION_ROOT")
 if (versionroot == null)
-    versionroot = "3.0"
+    versionroot = "3.1"
 
-String mavenGroupId = 'HMCL'
 String mavenVersion = versionroot + '.' + buildnumber
-String bundleName = "Hello Minecraft! Launcher"
 version = mavenVersion
 
 dependencies {
@@ -31,7 +31,7 @@ dependencies {
 task generateSources(type: Sync) {
     from 'src/main/java'
     into "$buildDir/generated-src"
-    filter(org.apache.tools.ant.filters.ReplaceTokens, tokens: [
+    filter(ReplaceTokens, tokens: [
             'HELLO_MINECRAFT_LAUNCHER_VERSION_FOR_GRADLE_REPLACING': mavenVersion
     ])
 }
@@ -48,20 +48,20 @@ jar {
     from { configurations.compile.collect { it.isDirectory() ? it : zipTree(it) } }
 
     manifest {
-        attributes 'Created-By'        : 'Copyright(c) 2013-2017 huangyuhui.',
+        attributes 'Created-By'        : 'Copyright(c) 2013-2018 huangyuhui.',
                 'Main-Class'        : mainClass,
                 'Multi-Release': "true"
     }
 
     doLast {
-        new File("build/signed").mkdirs()
-        ant.signjar(signedjar: archivePath, jar: archivePath,
-                keystore: "HMCL.keystore", storepass: "123456",
-                alias: "HMCL")
+        //new File("build/signed").mkdirs()
+        //ant.signjar(signedjar: archivePath, jar: archivePath,
+        //        keystore: "HMCL.keystore", storepass: "123456",
+        //        alias: "HMCL")
 
         def messageDigest = MessageDigest.getInstance("SHA1")
         archivePath.eachByte 1024 * 1024, { byte[] buf, int bytesRead ->
-            messageDigest.update(buf, 0, bytesRead);
+            messageDigest.update(buf, 0, bytesRead)
         }
         def sha1Hex = new BigInteger(1, messageDigest.digest()).toString(16).padLeft(40, '0')
         def fileEx = new File(project.buildDir, "libs/" + archivePath.getName() + ".sha1")
@@ -90,11 +90,11 @@ task makeExecutable(dependsOn: jar) doLast {
     int read
     def bytes = new byte[8192]
     while((read = is.read(bytes)) != -1)
-        fos.write(bytes, 0, read);
+        fos.write(bytes, 0, read)
     is.close()
     is = new FileInputStream(makeExecutableoutjar)
     while((read = is.read(bytes)) != -1)
-        fos.write(bytes, 0, read);
+        fos.write(bytes, 0, read)
     is.close()
     fos.close()
 
@@ -115,7 +115,7 @@ task makePackGZ(dependsOn: jar) doLast {
 
     def messageDigest = MessageDigest.getInstance("SHA1")
     loc.eachByte 1024 * 1024, { byte[] buf, int bytesRead ->
-        messageDigest.update(buf, 0, bytesRead);
+        messageDigest.update(buf, 0, bytesRead)
     }
     def sha1Hex = new BigInteger(1, messageDigest.digest()).toString(16).padLeft(40, '0')
     def fileEx = new File(project.buildDir, "libs/" + makeExecutableoutjar.getName().substring(0, makeExecutableoutjar.getName().length()-4)+".pack.gz.sha1")
@@ -123,7 +123,7 @@ task makePackGZ(dependsOn: jar) doLast {
     fileEx.append sha1Hex
 }
 
-task proguard(type: proguard.gradle.ProGuardTask, dependsOn: jar) {
+task proguard(type: ProGuardTask, dependsOn: jar) {
     ext {
         def re = jar.classifier
         injar = jar.archivePath
@@ -160,5 +160,4 @@ task combineMETA_INF(type: Jar) {
 }
 
 build.dependsOn makeExecutable
-//build.dependsOn makePackGZ
-//Kotlin classes will be ignored by Pack200 due to class unrecognized attribute
+build.dependsOn makePackGZ

HMCL/src/main/java/org/jackhuang/hmcl/Launcher.java

@@ -0,0 +1,154 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2017  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import javafx.application.Application;
+import javafx.application.Platform;
+import javafx.stage.Stage;
+
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.Controllers;
+import org.jackhuang.hmcl.upgrade.AppDataUpgrader;
+import org.jackhuang.hmcl.upgrade.IUpgrader;
+import org.jackhuang.hmcl.upgrade.UpdateChecker;
+import org.jackhuang.hmcl.util.*;
+
+import java.io.File;
+import java.net.URISyntaxException;
+import java.net.URL;
+import java.net.URLClassLoader;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.concurrent.TimeUnit;
+
+public final class Launcher extends Application {
+
+    @Override
+    public void start(Stage primaryStage) {
+        Thread.currentThread().setUncaughtExceptionHandler(CRASH_REPORTER);
+
+        try {
+            // When launcher visibility is set to "hide and reopen" without Platform.implicitExit = false,
+            // Stage.show() cannot work again because JavaFX Toolkit have already shut down.
+            Platform.setImplicitExit(false);
+            Controllers.initialize(primaryStage);
+            primaryStage.setResizable(false);
+            primaryStage.setScene(Controllers.getScene());
+
+            UPDATE_CHECKER.process(false)
+                    .then(Task.of(Schedulers.javafx(), () -> {
+                        if (UPDATE_CHECKER.isOutOfDate())
+                            Controllers.showUpdate();
+                    }))
+                    .start();
+
+            primaryStage.show();
+        } catch (Throwable e) {
+            CRASH_REPORTER.uncaughtException(Thread.currentThread(), e);
+        }
+    }
+
+    public static void main(String[] args) {
+        Thread.setDefaultUncaughtExceptionHandler(CRASH_REPORTER);
+
+        if (!FileUtils.makeDirectory(LOG_DIRECTORY))
+            System.out.println("Unable to create log directory " + LOG_DIRECTORY + ", log files cannot be generated.");
+
+        try {
+            Logging.start(LOG_DIRECTORY);
+
+            // NetworkUtils.setUserAgentSupplier(() -> "Hello Minecraft! Launcher");
+            Constants.UI_THREAD_SCHEDULER = Constants.JAVAFX_UI_THREAD_SCHEDULER;
+            UPGRADER.parseArguments(VersionNumber.asVersion(VERSION), Arrays.asList(args));
+
+            Logging.LOG.info("*** " + TITLE + " ***");
+            Logging.LOG.info("Operating System: " + System.getProperty("os.name") + ' ' + OperatingSystem.SYSTEM_VERSION);
+            Logging.LOG.info("Java Version: " + System.getProperty("java.version") + ", " + System.getProperty("java.vendor"));
+            Logging.LOG.info("Java VM Version: " + System.getProperty("java.vm.name") + " (" + System.getProperty("java.vm.info") + "), " + System.getProperty("java.vm.vendor"));
+            Logging.LOG.info("Java Home: " + System.getProperty("java.home"));
+
+            launch(args);
+        } catch (Throwable e) { // Fucking JavaFX will suppress the exception and will break our crash reporter.
+            CRASH_REPORTER.uncaughtException(Thread.currentThread(), e);
+        }
+    }
+
+    public static void stopApplication() {
+        Logging.LOG.info("Stopping application.\n" + StringUtils.getStackTrace(Thread.currentThread().getStackTrace()));
+
+        JFXUtilities.runInFX(() -> {
+            if (Controllers.getStage() == null)
+                return;
+            Controllers.getStage().close();
+            Schedulers.shutdown();
+            Controllers.shutdown();
+            Platform.exit();
+            Lang.executeDelayed(OperatingSystem::forceGC, TimeUnit.SECONDS, 5, true);
+        });
+    }
+
+    public static void stopWithoutPlatform() {
+        Logging.LOG.info("Stopping application without JavaFX Toolkit.\n" + StringUtils.getStackTrace(Thread.currentThread().getStackTrace()));
+
+        JFXUtilities.runInFX(() -> {
+            if (Controllers.getStage() == null)
+                return;
+            Controllers.getStage().close();
+            Schedulers.shutdown();
+            Controllers.shutdown();
+            Lang.executeDelayed(OperatingSystem::forceGC, TimeUnit.SECONDS, 5, true);
+        });
+    }
+
+    public static List<File> getCurrentJarFiles() {
+        List<File> result = new LinkedList<>();
+        if (Launcher.class.getClassLoader() instanceof URLClassLoader) {
+            URL[] urls = ((URLClassLoader) Launcher.class.getClassLoader()).getURLs();
+            for (URL u : urls)
+                try {
+                    File f = new File(u.toURI());
+                    if (f.isFile() && (f.getName().endsWith(".exe") || f.getName().endsWith(".jar")))
+                        result.add(f);
+                } catch (URISyntaxException e) {
+                    return null;
+                }
+        }
+        if (result.isEmpty())
+            return null;
+        else
+            return result;
+    }
+
+    public static final File MINECRAFT_DIRECTORY = OperatingSystem.getWorkingDirectory("minecraft");
+    public static final File HMCL_DIRECTORY = OperatingSystem.getWorkingDirectory("hmcl");
+    public static final File LOG_DIRECTORY = new File(Launcher.HMCL_DIRECTORY, "logs");
+
+    public static final String VERSION = System.getProperty("hmcl.version.override", "@HELLO_MINECRAFT_LAUNCHER_VERSION_FOR_GRADLE_REPLACING@");
+    public static final String NAME = "HMCL";
+    public static final String TITLE = NAME + " " + VERSION;
+    public static final UpdateChecker UPDATE_CHECKER = new UpdateChecker(VersionNumber.asVersion(VERSION));
+    public static final IUpgrader UPGRADER = new AppDataUpgrader();
+    public static final CrashReporter CRASH_REPORTER = new CrashReporter();
+
+    public static final String UPDATE_SERVER = "https://www.huangyuhui.net";
+    public static final String CONTACT = UPDATE_SERVER + "/hmcl.php";
+    public static final String PUBLISH = "http://www.mcbbs.net/thread-142335-1-1.html";
+}

HMCL/src/main/java/org/jackhuang/hmcl/Main.java

@@ -0,0 +1,102 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl;
+
+import static org.jackhuang.hmcl.util.Logging.LOG;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.File;
+import java.security.KeyStore;
+import java.security.KeyStoreException;
+import java.security.NoSuchAlgorithmException;
+import java.security.cert.X509Certificate;
+import java.util.logging.Level;
+
+import javax.net.ssl.TrustManager;
+import javax.net.ssl.TrustManagerFactory;
+import javax.net.ssl.X509TrustManager;
+import javax.swing.JOptionPane;
+
+public final class Main {
+
+    public static void main(String[] args) {
+        checkJavaFX();
+        checkDirectoryPath();
+        checkDSTRootCAX3();
+        Launcher.main(args);
+    }
+
+    private static void checkDirectoryPath() {
+        String currentDirectory = new File("").getAbsolutePath();
+        if (currentDirectory.contains("!")) {
+            // No Chinese translation because both Swing and JavaFX cannot render Chinese character properly when exclamation mark exists in the path.
+            showErrorAndExit("Exclamation mark(!) is not allowed in the path where HMCL is in.\n"
+                    + "The path is " + currentDirectory);
+        }
+    }
+
+    private static void checkJavaFX() {
+        try {
+            Class.forName("javafx.application.Application");
+        } catch (ClassNotFoundException e) {
+            showErrorAndExit(i18n("fatal.missing_javafx"));
+        }
+    }
+
+    private static void checkDSTRootCAX3() {
+        TrustManagerFactory tmf;
+        try {
+            tmf = TrustManagerFactory.getInstance(TrustManagerFactory.getDefaultAlgorithm());
+            tmf.init((KeyStore) null);
+        } catch (NoSuchAlgorithmException | KeyStoreException e) {
+            LOG.log(Level.WARNING, "Failed to init TrustManagerFactory", e);
+            // don't know what to do here
+            return;
+        }
+        for (TrustManager tm : tmf.getTrustManagers()) {
+            if (tm instanceof X509TrustManager) {
+                for (X509Certificate cert : ((X509TrustManager) tm).getAcceptedIssuers()) {
+                    if ("CN=DST Root CA X3, O=Digital Signature Trust Co.".equals((cert.getSubjectDN().getName()))) {
+                        return;
+                    }
+                }
+            }
+        }
+        showWarningAndContinue(i18n("fatal.missing_dst_root_ca_x3"));
+    }
+
+    /**
+     * Indicates that a fatal error has occurred, and that the application cannot start.
+     */
+    private static void showErrorAndExit(String message) {
+        System.err.println(message);
+        System.err.println("A fatal error has occurred, forcibly exiting.");
+        JOptionPane.showMessageDialog(null, message, "Error", JOptionPane.ERROR_MESSAGE);
+        System.exit(1);
+    }
+
+    /**
+     * Indicates that potential issues have been detected, and that the application may not function properly (but it can still run).
+     */
+    private static void showWarningAndContinue(String message) {
+        System.err.println(message);
+        System.err.println("Potential issues have been detected.");
+        JOptionPane.showMessageDialog(null, message, "Warning", JOptionPane.WARNING_MESSAGE);
+    }
+
+}

HMCL/src/main/java/org/jackhuang/hmcl/event/AccountAddedEvent.java

@@ -0,0 +1,57 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.event;
+
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.util.ToStringBuilder;
+
+/**
+ * This event gets fired when added accounts.
+ * <br>
+ * This event is fired on the {@link org.jackhuang.hmcl.event.EventBus#EVENT_BUS}
+ *
+ * @author huangyuhui
+ */
+public class AccountAddedEvent extends Event {
+
+    private final Account account;
+
+    /**
+     * Constructor.
+     *
+     * @param source {@link org.jackhuang.hmcl.setting.Settings}
+     */
+    public AccountAddedEvent(Object source, Account account) {
+        super(source);
+        this.account = account;
+    }
+
+
+    public Account getAccount() {
+        return account;
+    }
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this)
+                .append("source", source)
+                .append("account", account)
+                .toString();
+    }
+}
+

HMCL/src/main/java/org/jackhuang/hmcl/event/AccountLoadingEvent.java

@@ -0,0 +1,60 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.event;
+
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.util.ToStringBuilder;
+
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * This event gets fired when loading accounts.
+ * <br>
+ * This event is fired on the {@link org.jackhuang.hmcl.event.EventBus#EVENT_BUS}
+ *
+ * @author huangyuhui
+ */
+public class AccountLoadingEvent extends Event {
+
+    private final Collection<Account> accounts;
+
+    /**
+     * Constructor.
+     *
+     * @param source {@link org.jackhuang.hmcl.setting.Settings}
+     */
+    public AccountLoadingEvent(Object source, Collection<Account> accounts) {
+        super(source);
+        this.accounts = Collections.unmodifiableCollection(accounts);
+    }
+
+
+    public Collection<Account> getAccounts() {
+        return accounts;
+    }
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this)
+                .append("source", source)
+                .append("accounts", accounts)
+                .toString();
+    }
+}
+

HMCL/src/main/java/org/jackhuang/hmcl/event/OutOfDateEvent.java

@@ -0,0 +1,53 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.event;
+
+import org.jackhuang.hmcl.util.ToStringBuilder;
+import org.jackhuang.hmcl.util.VersionNumber;
+
+/**
+ *
+ * Result: Deny if do not upgrade HMCL.
+ *
+ * @author huangyuhui
+ */
+public final class OutOfDateEvent extends Event {
+    private final VersionNumber version;
+
+    public OutOfDateEvent(Object source, VersionNumber version) {
+        super(source);
+        this.version = version;
+    }
+
+    public VersionNumber getVersion() {
+        return version;
+    }
+
+    @Override
+    public boolean hasResult() {
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this)
+                .append("source", getSource())
+                .append("version", getVersion())
+                .toString();
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/event/ProfileChangedEvent.java

@@ -0,0 +1,55 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.event;
+
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.util.ToStringBuilder;
+
+/**
+ * This event gets fired when the selected profile changed.
+ * <br>
+ * This event is fired on the {@link org.jackhuang.hmcl.event.EventBus#EVENT_BUS}
+ * @author huangyuhui
+ */
+public final class ProfileChangedEvent extends Event {
+    private final Profile profile;
+
+    /**
+     * Constructor.
+     *
+     * @param source {@link org.jackhuang.hmcl.setting.Settings}
+     * @param profile the new profile.
+     */
+    public ProfileChangedEvent(Object source, Profile profile) {
+        super(source);
+
+        this.profile = profile;
+    }
+
+    public Profile getProfile() {
+        return profile;
+    }
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this)
+                .append("source", source)
+                .append("profile", profile)
+                .toString();
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/event/ProfileLoadingEvent.java

@@ -0,0 +1,60 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.event;
+
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.util.ToStringBuilder;
+
+import java.util.Collection;
+import java.util.Collections;
+
+/**
+ * This event gets fired when loading profiles.
+ * <br>
+ * This event is fired on the {@link org.jackhuang.hmcl.event.EventBus#EVENT_BUS}
+ *
+ * @author huangyuhui
+ */
+public class ProfileLoadingEvent extends Event {
+
+    private final Collection<Profile> profiles;
+
+    /**
+     * Constructor.
+     *
+     * @param source {@link org.jackhuang.hmcl.setting.Settings}
+     */
+    public ProfileLoadingEvent(Object source, Collection<Profile> profiles) {
+        super(source);
+
+        this.profiles = Collections.unmodifiableCollection(profiles);
+    }
+
+    public Collection<Profile> getProfiles() {
+        return profiles;
+    }
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this)
+                .append("source", source)
+                .append("profiles", profiles)
+                .toString();
+    }
+}
+

HMCL/src/main/java/org/jackhuang/hmcl/game/AccountHelper.java

@@ -0,0 +1,195 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import javafx.geometry.Rectangle2D;
+import javafx.scene.image.Image;
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.auth.yggdrasil.GameProfile;
+import org.jackhuang.hmcl.auth.yggdrasil.Texture;
+import org.jackhuang.hmcl.auth.yggdrasil.YggdrasilAccount;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.task.FileDownloadTask;
+import org.jackhuang.hmcl.task.Scheduler;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.DialogController;
+import org.jackhuang.hmcl.util.NetworkUtils;
+
+import java.io.File;
+import java.net.Proxy;
+import java.util.*;
+
+public final class AccountHelper {
+
+    private AccountHelper() {}
+
+    public static final File SKIN_DIR = new File(Launcher.HMCL_DIRECTORY, "skins");
+
+    public static void loadSkins() {
+        loadSkins(Proxy.NO_PROXY);
+    }
+
+    public static void loadSkins(Proxy proxy) {
+        for (Account account : Settings.INSTANCE.getAccounts()) {
+            if (account instanceof YggdrasilAccount) {
+                new SkinLoadTask((YggdrasilAccount) account, proxy, false).start();
+            }
+        }
+    }
+
+    public static Task loadSkinAsync(YggdrasilAccount account) {
+        return loadSkinAsync(account, Settings.INSTANCE.getProxy());
+    }
+
+    public static Task loadSkinAsync(YggdrasilAccount account, Proxy proxy) {
+        return new SkinLoadTask(account, proxy, false);
+    }
+
+    public static Task refreshSkinAsync(YggdrasilAccount account) {
+        return refreshSkinAsync(account, Settings.INSTANCE.getProxy());
+    }
+
+    public static Task refreshSkinAsync(YggdrasilAccount account, Proxy proxy) {
+        return new SkinLoadTask(account, proxy, true);
+    }
+
+    private static File getSkinFile(UUID uuid) {
+        return new File(SKIN_DIR, uuid + ".png");
+    }
+
+    public static Image getSkin(YggdrasilAccount account) {
+        return getSkin(account, 1);
+    }
+
+    public static Image getSkin(YggdrasilAccount account, double scaleRatio) {
+        UUID uuid = account.getUUID();
+        if (uuid == null)
+            return getSteveSkin(scaleRatio);
+
+        File file = getSkinFile(uuid);
+        if (file.exists()) {
+            Image original = new Image("file:" + file.getAbsolutePath());
+            return new Image("file:" + file.getAbsolutePath(),
+                    original.getWidth() * scaleRatio,
+                    original.getHeight() * scaleRatio,
+                    false, false);
+        }
+        return getDefaultSkin(uuid, scaleRatio);
+    }
+
+    public static Image getSkinImmediately(YggdrasilAccount account, GameProfile profile, double scaleRatio, Proxy proxy) throws Exception {
+        File file = getSkinFile(profile.getId());
+        downloadSkin(account, profile, true, proxy);
+        if (!file.exists())
+            return getDefaultSkin(profile.getId(), scaleRatio);
+
+        String url = "file:" + file.getAbsolutePath();
+        return scale(url, scaleRatio);
+    }
+
+    public static Rectangle2D getViewport(double scaleRatio) {
+        double size = 8.0 * scaleRatio;
+        return new Rectangle2D(size, size, size, size);
+    }
+
+    private static class SkinLoadTask extends Task {
+        private final YggdrasilAccount account;
+        private final Proxy proxy;
+        private final boolean refresh;
+        private final List<Task> dependencies = new LinkedList<>();
+
+        public SkinLoadTask(YggdrasilAccount account, Proxy proxy) {
+            this(account, proxy, false);
+        }
+
+        public SkinLoadTask(YggdrasilAccount account, Proxy proxy, boolean refresh) {
+            this.account = account;
+            this.proxy = proxy;
+            this.refresh = refresh;
+        }
+
+        @Override
+        public Scheduler getScheduler() {
+            return Schedulers.io();
+        }
+
+        @Override
+        public Collection<Task> getDependencies() {
+            return dependencies;
+        }
+
+        @Override
+        public void execute() throws Exception {
+            if (!account.isLoggedIn() && (account.getCharacter() == null || refresh))
+                DialogController.logIn(account);
+
+            downloadSkin(account, refresh, proxy);
+        }
+    }
+
+    private static void downloadSkin(YggdrasilAccount account, GameProfile profile, boolean refresh, Proxy proxy) throws Exception {
+        account.clearCache();
+
+        Optional<Texture> texture = account.getSkin(profile);
+        if (!texture.isPresent()) return;
+        String url = texture.get().getUrl();
+        File file = getSkinFile(profile.getId());
+        if (!refresh && file.exists())
+            return;
+        new FileDownloadTask(NetworkUtils.toURL(url), file, proxy).run();
+    }
+
+    private static void downloadSkin(YggdrasilAccount account, boolean refresh, Proxy proxy) throws Exception {
+        account.clearCache();
+
+        if (account.getCharacter() == null) return;
+        Optional<Texture> texture = account.getSkin();
+        if (!texture.isPresent()) return;
+        String url = texture.get().getUrl();
+        File file = getSkinFile(account.getUUID());
+        if (!refresh && file.exists())
+            return;
+        new FileDownloadTask(NetworkUtils.toURL(url), file, proxy).run();
+    }
+
+    public static Image scale(String url, double scaleRatio) {
+        Image origin = new Image(url);
+        return new Image(url,
+                origin.getWidth() * scaleRatio,
+                origin.getHeight() * scaleRatio,
+                false, false);
+    }
+
+    public static Image getSteveSkin(double scaleRatio) {
+         return scale("/assets/img/steve.png", 4);
+    }
+
+    public static Image getAlexSkin(double scaleRatio) {
+        return scale("/assets/img/alex.png", 4);
+    }
+
+    public static Image getDefaultSkin(UUID uuid, double scaleRatio) {
+        int type = uuid.hashCode() & 1;
+        if (type == 1)
+            return getAlexSkin(scaleRatio);
+        else
+            return getSteveSkin(scaleRatio);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLDependencyManager.java

@@ -0,0 +1,47 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import org.jackhuang.hmcl.download.DefaultDependencyManager;
+import org.jackhuang.hmcl.download.DownloadProvider;
+import org.jackhuang.hmcl.download.GameBuilder;
+import org.jackhuang.hmcl.setting.Profile;
+
+import java.net.Proxy;
+
+/**
+ * @author huangyuhui
+ */
+public class HMCLDependencyManager extends DefaultDependencyManager {
+    private final Profile profile;
+
+    public HMCLDependencyManager(Profile profile, DownloadProvider downloadProvider) {
+        this(profile, downloadProvider, Proxy.NO_PROXY);
+    }
+
+    public HMCLDependencyManager(Profile profile, DownloadProvider downloadProvider, Proxy proxy) {
+        super(profile.getRepository(), downloadProvider, proxy);
+
+        this.profile = profile;
+    }
+
+    @Override
+    public GameBuilder gameBuilder() {
+        return new HMCLGameBuilder(profile);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLGameBuilder.java

@@ -0,0 +1,40 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import org.jackhuang.hmcl.download.DefaultGameBuilder;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.task.Task;
+
+/**
+ * @author huangyuhui
+ */
+public class HMCLGameBuilder extends DefaultGameBuilder {
+    private final Profile profile;
+
+    public HMCLGameBuilder(Profile profile) {
+        super(profile.getDependency());
+
+        this.profile = profile;
+    }
+
+    @Override
+    protected Task downloadGameAsync(String gameVersion, Version version) {
+        return new HMCLGameDownloadTask(profile, gameVersion, version);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLGameDownloadTask.java

@@ -0,0 +1,78 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.task.FileDownloadTask;
+import org.jackhuang.hmcl.task.FileDownloadTask.IntegrityCheck;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.util.FileUtils;
+import org.jackhuang.hmcl.util.Logging;
+import org.jackhuang.hmcl.util.NetworkUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Level;
+
+/**
+ * @author huangyuhui
+ */
+public class HMCLGameDownloadTask extends Task {
+    private final Profile profile;
+    private final String gameVersion;
+    private final Version version;
+    private final List<Task> dependencies = new LinkedList<>();
+
+    public HMCLGameDownloadTask(Profile profile, String gameVersion, Version version) {
+        this.profile = profile;
+        this.gameVersion = gameVersion;
+        this.version = version;
+
+        setSignificance(TaskSignificance.MINOR);
+    }
+
+    @Override
+    public List<Task> getDependencies() {
+        return dependencies;
+    }
+
+    @Override
+    public void execute() {
+        File jar = profile.getRepository().getVersionJar(version);
+
+        File cache = new File(Settings.INSTANCE.getCommonPath(), "jars/" + gameVersion + ".jar");
+        if (cache.exists())
+            try {
+                FileUtils.copyFile(cache, jar);
+                return;
+            } catch (IOException e) {
+                Logging.LOG.log(Level.SEVERE, "Unable to copy cached Minecraft jar from " + cache + " to " + jar, e);
+            }
+
+        dependencies.add(new FileDownloadTask(
+                NetworkUtils.toURL(profile.getDependency().getDownloadProvider().injectURL(version.getDownloadInfo().getUrl())),
+                cache,
+                profile.getDependency().getProxy(),
+                new IntegrityCheck("SHA-1", version.getDownloadInfo().getSha1())
+        ).then(Task.of(v -> FileUtils.copyFile(cache, jar))));
+    }
+
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLGameLauncher.java

@@ -0,0 +1,51 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.auth.AuthInfo;
+import org.jackhuang.hmcl.launch.DefaultLauncher;
+import org.jackhuang.hmcl.launch.ProcessListener;
+
+import java.util.List;
+
+/**
+ * @author huangyuhui
+ */
+public final class HMCLGameLauncher extends DefaultLauncher {
+
+    public HMCLGameLauncher(GameRepository repository, String versionId, AuthInfo authInfo, LaunchOptions options) {
+        this(repository, versionId, authInfo, options, null);
+    }
+
+    public HMCLGameLauncher(GameRepository repository, String versionId, AuthInfo authInfo, LaunchOptions options, ProcessListener listener) {
+        this(repository, versionId, authInfo, options, listener, true);
+    }
+
+    public HMCLGameLauncher(GameRepository repository, String versionId, AuthInfo authInfo, LaunchOptions options, ProcessListener listener, boolean daemon) {
+        super(repository, versionId, authInfo, options, listener, daemon);
+    }
+
+    @Override
+    protected void appendJvmArgs(List<String> result) {
+        super.appendJvmArgs(result);
+
+        result.add("-Dminecraft.launcher.version=" + Launcher.VERSION);
+        result.add("-Dminecraft.launcher.brand=" + Launcher.NAME);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLGameRepository.java

@@ -0,0 +1,215 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import org.jackhuang.hmcl.event.EventBus;
+import org.jackhuang.hmcl.event.RefreshedVersionsEvent;
+import org.jackhuang.hmcl.event.RefreshingVersionsEvent;
+import org.jackhuang.hmcl.setting.EnumGameDirectory;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.setting.VersionSetting;
+import org.jackhuang.hmcl.util.FileUtils;
+import org.jackhuang.hmcl.util.Logging;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.*;
+import java.util.logging.Level;
+
+public class HMCLGameRepository extends DefaultGameRepository {
+    private final Profile profile;
+    private final Map<String, VersionSetting> versionSettings = new HashMap<>();
+    private final Set<String> beingModpackVersions = new HashSet<>();
+
+    public boolean checkedModpack = false, checkingModpack = false;
+
+    public HMCLGameRepository(Profile profile, File baseDirectory) {
+        super(baseDirectory);
+        this.profile = profile;
+    }
+
+    public Profile getProfile() {
+        return profile;
+    }
+
+    private boolean useSelf(String version, String assetId) {
+        VersionSetting vs = profile.getVersionSetting(version);
+        return new File(getBaseDirectory(), "assets/indexes/" + assetId + ".json").exists() || vs.isNoCommon();
+    }
+
+    @Override
+    public File getAssetDirectory(String version, String assetId) {
+        if (useSelf(version, assetId))
+            return super.getAssetDirectory(version, assetId);
+        else
+            return new File(Settings.INSTANCE.getCommonPath(), "assets");
+    }
+
+    @Override
+    public File getRunDirectory(String id) {
+        if (beingModpackVersions.contains(id) || isModpack(id))
+            return getVersionRoot(id);
+        else {
+            VersionSetting vs = profile.getVersionSetting(id);
+            switch (vs.getGameDirType()) {
+                case VERSION_FOLDER: return getVersionRoot(id);
+                case ROOT_FOLDER: return super.getRunDirectory(id);
+                case CUSTOM: return new File(vs.getGameDir());
+                default: throw new Error();
+            }
+        }
+    }
+
+    @Override
+    public File getLibraryFile(Version version, Library lib) {
+        VersionSetting vs = profile.getVersionSetting(version.getId());
+        File self = super.getLibraryFile(version, lib);
+        if (self.exists() || vs.isNoCommon())
+            return self;
+        else
+            return new File(Settings.INSTANCE.getCommonPath(), "libraries/" + lib.getPath());
+    }
+
+
+    @Override
+    protected void refreshVersionsImpl() {
+        versionSettings.clear();
+        super.refreshVersionsImpl();
+        versions.keySet().forEach(this::loadVersionSetting);
+
+        try {
+            File file = new File(getBaseDirectory(), "launcher_profiles.json");
+            if (!file.exists() && !versions.isEmpty())
+                FileUtils.writeText(file, PROFILE);
+        } catch (IOException ex) {
+            Logging.LOG.log(Level.WARNING, "Unable to create launcher_profiles.json, Forge/LiteLoader installer will not work.", ex);
+        }
+    }
+
+    @Override
+    public void refreshVersions() {
+        EventBus.EVENT_BUS.fireEvent(new RefreshingVersionsEvent(this));
+        refreshVersionsImpl();
+        EventBus.EVENT_BUS.fireEvent(new RefreshedVersionsEvent(this));
+    }
+
+    public void changeDirectory(File newDirectory) {
+        setBaseDirectory(newDirectory);
+        refreshVersionsAsync().start();
+    }
+
+    private File getVersionSettingFile(String id) {
+        return new File(getVersionRoot(id), "hmclversion.cfg");
+    }
+
+    private void loadVersionSetting(String id) {
+        File file = getVersionSettingFile(id);
+        if (file.exists())
+            try {
+                VersionSetting versionSetting = GSON.fromJson(FileUtils.readText(file), VersionSetting.class);
+                initVersionSetting(id, versionSetting);
+            } catch (Exception ex) {
+                // If [JsonParseException], [IOException] or [NullPointerException] happens, the json file is malformed and needed to be recreated.
+                initVersionSetting(id, new VersionSetting());
+            }
+    }
+
+    /**
+     * Create new version setting if version id has no version setting.
+     * @param id the version id.
+     * @return new version setting, null if given version does not exist.
+     */
+    public VersionSetting createVersionSetting(String id) {
+        if (!hasVersion(id))
+            return null;
+        if (versionSettings.containsKey(id))
+            return getVersionSetting(id);
+        else
+            return initVersionSetting(id, new VersionSetting());
+    }
+
+    private VersionSetting initVersionSetting(String id, VersionSetting vs) {
+        vs.addPropertyChangedListener(a -> saveVersionSetting(id));
+        versionSettings.put(id, vs);
+        return vs;
+    }
+
+    /**
+     * Get the version setting for version id.
+     *
+     * @param id version id
+     *
+     * @return may return null if the id not exists
+     */
+    public VersionSetting getVersionSetting(String id) {
+        if (!versionSettings.containsKey(id))
+            loadVersionSetting(id);
+        VersionSetting setting = versionSettings.get(id);
+        if (setting != null && isModpack(id))
+            setting.setGameDirType(EnumGameDirectory.VERSION_FOLDER);
+        return setting;
+    }
+
+    public File getVersionIcon(String id) {
+        return new File(getVersionRoot(id), "icon.png");
+    }
+
+    public boolean saveVersionSetting(String id) {
+        if (!versionSettings.containsKey(id))
+            return false;
+        File file = getVersionSettingFile(id);
+        if (!FileUtils.makeDirectory(file.getAbsoluteFile().getParentFile()))
+            return false;
+
+        try {
+            FileUtils.writeText(file, GSON.toJson(versionSettings.get(id)));
+            return true;
+        } catch (IOException e) {
+            Logging.LOG.log(Level.SEVERE, "Unable to save version setting of " + id, e);
+            return false;
+        }
+    }
+
+    public boolean forbidsVersion(String id) {
+        return FORBIDDEN.contains(id);
+    }
+
+    @Override
+    public File getModpackConfiguration(String version) {
+        return new File(getVersionRoot(version), "modpack.cfg");
+    }
+
+    public void markVersionAsModpack(String id) {
+        beingModpackVersions.add(id);
+    }
+
+    public void undoMark(String id) {
+        beingModpackVersions.remove(id);
+    }
+
+    private static final Gson GSON = new GsonBuilder().setPrettyPrinting()
+            .registerTypeAdapter(VersionSetting.class, VersionSetting.Serializer.INSTANCE)
+            .create();
+
+    private static final HashSet<String> FORBIDDEN = new HashSet<>(Arrays.asList("modpack", "minecraftinstance", "manifest"));
+
+    private static final String PROFILE = "{\"selectedProfile\": \"(Default)\",\"profiles\": {\"(Default)\": {\"name\": \"(Default)\"}},\"clientToken\": \"88888888-8888-8888-8888-888888888888\"}";
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLModpackExportTask.java

@@ -0,0 +1,97 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+
+import org.jackhuang.hmcl.mod.Modpack;
+import org.jackhuang.hmcl.task.TaskResult;
+import org.jackhuang.hmcl.util.Constants;
+import org.jackhuang.hmcl.util.Logging;
+import org.jackhuang.hmcl.util.ZipEngine;
+
+import java.io.File;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Export the game to a mod pack file.
+ */
+public class HMCLModpackExportTask extends TaskResult<ZipEngine> {
+    private final DefaultGameRepository repository;
+    private final String version;
+    private final List<String> whitelist;
+    private final Modpack modpack;
+    private final File output;
+    private final String id;
+
+    public HMCLModpackExportTask(DefaultGameRepository repository, String version, List<String> whitelist, Modpack modpack, File output) {
+        this(repository, version, whitelist, modpack, output, ID);
+    }
+
+    /**
+     * @param output  mod pack file.
+     * @param version to locate version.json
+     */
+    public HMCLModpackExportTask(DefaultGameRepository repository, String version, List<String> whitelist, Modpack modpack, File output, String id) {
+        this.repository = repository;
+        this.version = version;
+        this.whitelist = whitelist;
+        this.modpack = modpack;
+        this.output = output;
+        this.id = id;
+
+        onDone().register(event -> {
+            if (event.isFailed()) output.delete();
+        });
+    }
+
+    @Override
+    public String getId() {
+        return id;
+    }
+
+    @Override
+    public void execute() throws Exception {
+        ArrayList<String> blackList = new ArrayList<>(HMCLModpackManager.MODPACK_BLACK_LIST);
+        blackList.add(version + ".jar");
+        blackList.add(version + ".json");
+        Logging.LOG.info("Compressing game files without some files in blacklist, including files or directories: usernamecache.json, asm, logs, backups, versions, assets, usercache.json, libraries, crash-reports, launcher_profiles.json, NVIDIA, TCNodeTracker");
+        try (ZipEngine zip = new ZipEngine(output)) {
+            zip.putDirectory(repository.getRunDirectory(version), (String pathName, Boolean isDirectory) -> {
+                for (String s : blackList)
+                    if (isDirectory) {
+                        if (pathName.startsWith(s + "/"))
+                            return null;
+                    } else if (pathName.equals(s))
+                        return null;
+                for (String s : whitelist)
+                    if (pathName.equals(s + (isDirectory ? "/" : "")))
+                        return "minecraft/" + pathName;
+                return null;
+            });
+
+            Version mv = repository.getResolvedVersion(version);
+            String gameVersion = GameVersion.minecraftVersion(repository.getVersionJar(version))
+                    .orElseThrow(() ->  new IllegalStateException("Cannot parse the version of " + version));
+            zip.putTextFile(Constants.GSON.toJson(mv.setJar(gameVersion)), "minecraft/pack.json"); // Making "jar" to gameVersion is to be compatible with old HMCL.
+            zip.putTextFile(Constants.GSON.toJson(modpack.setGameVersion(gameVersion)), "modpack.json"); // Newer HMCL only reads 'gameVersion' field.
+        }
+    }
+
+    public static final String ID = "zip_engine";
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLModpackInstallTask.java

@@ -0,0 +1,99 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import com.google.gson.JsonParseException;
+import com.google.gson.reflect.TypeToken;
+import org.jackhuang.hmcl.download.DependencyManager;
+import org.jackhuang.hmcl.download.game.VersionJsonSaveTask;
+import org.jackhuang.hmcl.mod.MinecraftInstanceTask;
+import org.jackhuang.hmcl.mod.Modpack;
+import org.jackhuang.hmcl.mod.ModpackConfiguration;
+import org.jackhuang.hmcl.mod.ModpackInstallTask;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.util.CompressingUtils;
+import org.jackhuang.hmcl.util.Constants;
+import org.jackhuang.hmcl.util.FileUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Objects;
+
+public final class HMCLModpackInstallTask extends Task {
+    private final File zipFile;
+    private final String name;
+    private final HMCLGameRepository repository;
+    private final Modpack modpack;
+    private final List<Task> dependencies = new LinkedList<>();
+    private final List<Task> dependents = new LinkedList<>();
+
+    public HMCLModpackInstallTask(Profile profile, File zipFile, Modpack modpack, String name) {
+        DependencyManager dependency = profile.getDependency();
+        repository = profile.getRepository();
+        this.zipFile = zipFile;
+        this.name = name;
+        this.modpack = modpack;
+
+        File run = repository.getRunDirectory(name);
+        File json = repository.getModpackConfiguration(name);
+        if (repository.hasVersion(name) && !json.exists())
+            throw new IllegalArgumentException("Version " + name + " already exists");
+
+        dependents.add(dependency.gameBuilder().name(name).gameVersion(modpack.getGameVersion()).buildAsync());
+
+        onDone().register(event -> {
+            if (event.isFailed()) repository.removeVersionFromDisk(name);
+        });
+
+        ModpackConfiguration<Modpack> config = null;
+        try {
+            if (json.exists()) {
+                config = Constants.GSON.fromJson(FileUtils.readText(json), new TypeToken<ModpackConfiguration<Modpack>>() {
+                }.getType());
+
+                if (!MODPACK_TYPE.equals(config.getType()))
+                    throw new IllegalArgumentException("Version " + name + " is not a HMCL modpack. Cannot update this version.");
+            }
+        } catch (JsonParseException | IOException ignore) {
+        }
+        dependents.add(new ModpackInstallTask<>(zipFile, run, "minecraft/", it -> !Objects.equals(it, "minecraft/pack.json"), config));
+    }
+
+    @Override
+    public List<Task> getDependencies() {
+        return dependencies;
+    }
+
+    @Override
+    public List<Task> getDependents() {
+        return dependents;
+    }
+
+    @Override
+    public void execute() throws Exception {
+        String json = CompressingUtils.readTextZipEntry(zipFile, "minecraft/pack.json");
+        Version version = Constants.GSON.fromJson(json, Version.class).setJar(null);
+        dependencies.add(new VersionJsonSaveTask(repository, version));
+        dependencies.add(new MinecraftInstanceTask<>(zipFile, "minecraft/", modpack, MODPACK_TYPE, repository.getModpackConfiguration(name)));
+    }
+
+    public static final String MODPACK_TYPE = "HMCL";
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLModpackManager.java

@@ -0,0 +1,95 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import com.google.gson.JsonParseException;
+import org.jackhuang.hmcl.mod.Modpack;
+import org.jackhuang.hmcl.util.CompressingUtils;
+import org.jackhuang.hmcl.util.JsonUtils;
+import org.jackhuang.hmcl.util.Lang;
+import org.jackhuang.hmcl.util.StringUtils;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+
+/**
+ * @author huangyuhui
+ */
+public final class HMCLModpackManager {
+
+    public static final List<String> MODPACK_BLACK_LIST = Lang.immutableListOf(
+            "usernamecache.json", "usercache.json", // Minecraft
+            "launcher_profiles.json", "launcher.pack.lzma", // Minecraft Launcher
+            "pack.json", "launcher.jar", "hmclmc.log", // HMCL
+            "manifest.json", "minecraftinstance.json", ".curseclient", // Curse
+            "minetweaker.log", // Mods
+            "logs", "versions", "assets", "libraries", "crash-reports", "NVIDIA", "AMD", "screenshots", "natives", "native", "$native", "server-resource-packs", // Minecraft
+            "downloads", // Curse
+            "asm", "backups", "TCNodeTracker", "CustomDISkins", "data" // Mods
+    );
+    public static final List<String> MODPACK_SUGGESTED_BLACK_LIST = Lang.immutableListOf(
+            "fonts", // BetterFonts
+            "saves", "servers.dat", "options.txt", // Minecraft
+            "blueprints" /* BuildCraft */,
+            "optionsof.txt" /* OptiFine */,
+            "journeymap" /* JourneyMap */,
+            "optionsshaders.txt",
+            "mods/VoxelMods");
+
+    public static ModAdviser.ModSuggestion suggestMod(String fileName, boolean isDirectory) {
+        if (match(MODPACK_BLACK_LIST, fileName, isDirectory))
+            return ModAdviser.ModSuggestion.HIDDEN;
+        if (match(MODPACK_SUGGESTED_BLACK_LIST, fileName, isDirectory))
+            return ModAdviser.ModSuggestion.NORMAL;
+        else
+            return ModAdviser.ModSuggestion.SUGGESTED;
+    }
+
+    private static boolean match(List<String> l, String fileName, boolean isDirectory) {
+        for (String s : l)
+            if (isDirectory) {
+                if (fileName.startsWith(s + "/"))
+                    return true;
+            } else if (fileName.equals(s))
+                return true;
+        return false;
+    }
+
+    /**
+     * Read the manifest in a HMCL modpack.
+     *
+     * @param file a HMCL modpack file.
+     * @throws IOException if the file is not a valid zip file.
+     * @throws JsonParseException if the manifest.json is missing or malformed.
+     * @return the manifest of HMCL modpack.
+     */
+    public static Modpack readHMCLModpackManifest(File file) throws IOException, JsonParseException {
+        String manifestJson = CompressingUtils.readTextZipEntry(file, "modpack.json");
+        Modpack manifest = JsonUtils.fromNonNullJson(manifestJson, Modpack.class);
+        String gameJson = CompressingUtils.readTextZipEntry(file, "minecraft/pack.json");
+        Version game = JsonUtils.fromNonNullJson(gameJson, Version.class);
+        if (game.getJar() == null)
+            if (StringUtils.isBlank(manifest.getVersion()))
+                throw new JsonParseException("Cannot recognize the game version of modpack " + file + ".");
+            else
+                return manifest.setManifest(HMCLModpackManifest.INSTANCE);
+        else
+            return manifest.setManifest(HMCLModpackManifest.INSTANCE).setGameVersion(game.getJar());
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/HMCLModpackManifest.java

@@ -1,6 +1,6 @@
 /*
  * Hello Minecraft! Launcher.
- * Copyright (C) 2017  huangyuhui <[email protected]>
+ * Copyright (C) 2018  huangyuhui <[email protected]>
  * 
  * 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
@@ -15,9 +15,10 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see {http://www.gnu.org/licenses/}.
  */
-package org.jackhuang.hmcl.auth
+package org.jackhuang.hmcl.game;
 
-interface AccountFactory<T : Account> {
-    fun fromUsername(username: String, password: String = ""): T
-    fun fromStorage(storage: Map<Any, Any>): T
-}
+public final class HMCLModpackManifest {
+    public static final HMCLModpackManifest INSTANCE = new HMCLModpackManifest();
+
+    private HMCLModpackManifest() {}
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/LauncherHelper.java

@@ -0,0 +1,447 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import javafx.application.Platform;
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.auth.AuthInfo;
+import org.jackhuang.hmcl.auth.AuthenticationException;
+import org.jackhuang.hmcl.auth.CredentialExpiredException;
+import org.jackhuang.hmcl.download.DefaultDependencyManager;
+import org.jackhuang.hmcl.download.MaintainTask;
+import org.jackhuang.hmcl.launch.*;
+import org.jackhuang.hmcl.mod.CurseCompletionException;
+import org.jackhuang.hmcl.mod.CurseCompletionTask;
+import org.jackhuang.hmcl.mod.ModpackConfiguration;
+import org.jackhuang.hmcl.setting.LauncherVisibility;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.setting.VersionSetting;
+import org.jackhuang.hmcl.task.*;
+import org.jackhuang.hmcl.ui.Controllers;
+import org.jackhuang.hmcl.ui.DialogController;
+import org.jackhuang.hmcl.ui.LogWindow;
+import org.jackhuang.hmcl.ui.construct.DialogCloseEvent;
+import org.jackhuang.hmcl.ui.construct.MessageBox;
+import org.jackhuang.hmcl.ui.construct.TaskExecutorDialogPane;
+import org.jackhuang.hmcl.util.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.*;
+import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static org.jackhuang.hmcl.util.Lang.mapOf;
+import static org.jackhuang.hmcl.util.Pair.pair;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+public final class LauncherHelper {
+    public static final LauncherHelper INSTANCE = new LauncherHelper();
+    private LauncherHelper(){}
+
+    public static final Queue<ManagedProcess> PROCESSES = new ConcurrentLinkedQueue<>();
+    private final TaskExecutorDialogPane launchingStepsPane = new TaskExecutorDialogPane(it -> {});
+
+    public void launch(Profile profile, Account account, String selectedVersion, File scriptFile) {
+        if (account == null)
+            throw new IllegalArgumentException("No account");
+
+        GameRepository repository = profile.getRepository();
+
+        Version version = repository.getResolvedVersion(selectedVersion);
+        VersionSetting setting = profile.getVersionSetting(selectedVersion);
+
+        Platform.runLater(() -> {
+            try {
+                checkGameState(profile, setting, version, () -> {
+                    Controllers.dialog(launchingStepsPane);
+                    Schedulers.newThread().schedule(() -> launch0(profile, account, selectedVersion, scriptFile));
+                });
+            } catch (InterruptedException ignore) {
+            }
+        });
+    }
+
+    private void launch0(Profile profile, Account account, String selectedVersion, File scriptFile) {
+        HMCLGameRepository repository = profile.getRepository();
+        DefaultDependencyManager dependencyManager = profile.getDependency();
+        Version version = MaintainTask.maintain(repository.getResolvedVersion(selectedVersion));
+        VersionSetting setting = profile.getVersionSetting(selectedVersion);
+        Optional<String> gameVersion = GameVersion.minecraftVersion(repository.getVersionJar(version));
+
+        TaskExecutor executor = Task.of(Schedulers.javafx(), () -> emitStatus(LoadingState.DEPENDENCIES))
+                .then(variables -> {
+                    if (setting.isNotCheckGame())
+                        return null;
+                    else
+                        return dependencyManager.checkGameCompletionAsync(version);
+                })
+                .then(Task.of(Schedulers.javafx(), () -> emitStatus(LoadingState.MODS)))
+                .then(var -> {
+                    try {
+                        ModpackConfiguration<?> configuration = ModpackHelper.readModpackConfiguration(repository.getModpackConfiguration(selectedVersion));
+                        if ("Curse".equals(configuration.getType()))
+                            return new CurseCompletionTask(dependencyManager, selectedVersion);
+                        else
+                            return null;
+                    } catch (IOException e) {
+                        return null;
+                    }
+                })
+                .then(Task.of(Schedulers.javafx(), () -> emitStatus(LoadingState.LOGGING_IN)))
+                .then(Task.of(i18n("account.methods"), variables -> {
+                    try {
+                        variables.set("account", account.logIn());
+                    } catch (CredentialExpiredException e) {
+                        variables.set("account", DialogController.logIn(account));
+                    } catch (AuthenticationException e) {
+                        variables.set("account",
+                                account.playOffline().orElseThrow(() -> e));
+                    }
+                }))
+                .then(Task.of(Schedulers.javafx(), () -> emitStatus(LoadingState.LAUNCHING)))
+                .then(Task.of(variables -> {
+                    variables.set("launcher", new HMCLGameLauncher(
+                            repository,
+                            selectedVersion,
+                            variables.get("account"),
+                            setting.toLaunchOptions(profile.getGameDir()),
+                            setting.getLauncherVisibility() == LauncherVisibility.CLOSE
+                                    ? null // Unnecessary to start listening to game process output when close launcher immediately after game launched.
+                                    : new HMCLProcessListener(variables.get("account"), setting, gameVersion.isPresent())
+                    ));
+                }))
+                .then(variables -> {
+                    DefaultLauncher launcher = variables.get("launcher");
+                    if (scriptFile == null) {
+                        return new LaunchTask<>(launcher::launch).setName(i18n("version.launch"));
+                    } else {
+                        return new LaunchTask<>(() -> {
+                            launcher.makeLaunchScript(scriptFile);
+                            return null;
+                        }).setName(i18n("version.launch_script"));
+                    }
+                })
+                .then(Task.of(variables -> {
+                    if (scriptFile == null) {
+                        ManagedProcess process = variables.get(LaunchTask.LAUNCH_ID);
+                        PROCESSES.add(process);
+                        if (setting.getLauncherVisibility() == LauncherVisibility.CLOSE)
+                            Launcher.stopApplication();
+                        else
+                            launchingStepsPane.setCancel(it -> {
+                                process.stop();
+                                it.fireEvent(new DialogCloseEvent());
+                            });
+                    } else
+                        Platform.runLater(() -> {
+                            launchingStepsPane.fireEvent(new DialogCloseEvent());
+                            Controllers.dialog(i18n("version.launch_script.success", scriptFile.getAbsolutePath()));
+                        });
+
+                }))
+                .executor();
+
+        launchingStepsPane.setExecutor(executor);
+        executor.addTaskListener(new TaskListener() {
+            final AtomicInteger finished = new AtomicInteger(0);
+
+            @Override
+            public void onFinished(Task task) {
+                finished.incrementAndGet();
+                int runningTasks = executor.getRunningTasks();
+                Platform.runLater(() -> launchingStepsPane.setProgress(1.0 * finished.get() / runningTasks));
+            }
+
+            @Override
+            public void onStop(boolean success, TaskExecutor executor) {
+                if (!success && !Controllers.isStopped()) {
+                    Platform.runLater(() -> {
+                        // Check if the application has stopped
+                        // because onStop will be invoked if tasks fail when the executor service shut down.
+                        if (!Controllers.isStopped()) {
+                            launchingStepsPane.fireEvent(new DialogCloseEvent());
+                            Exception ex = executor.getLastException();
+                            if (ex != null) {
+                                String message;
+                                if (ex instanceof CurseCompletionException) {
+                                    message = i18n("modpack.type.curse.error");
+                                } else if (ex instanceof PermissionException) {
+                                    message = i18n("launch.failed.executable_permission");
+                                } else if (ex instanceof ProcessCreationException) {
+                                    message = i18n("launch.failed.creating_process") + ex.getLocalizedMessage();
+                                } else if (ex instanceof NotDecompressingNativesException) {
+                                    message = i18n("launch.failed.decompressing_natives") + ex.getLocalizedMessage();
+                                } else {
+                                    message = StringUtils.getStackTrace(ex);
+                                }
+                                Controllers.dialog(message,
+                                        scriptFile == null ? i18n("launch.failed") : i18n("version.launch_script.failed"),
+                                        MessageBox.ERROR_MESSAGE);
+                            }
+                        }
+                    });
+                }
+                launchingStepsPane.setExecutor(null);
+            }
+        });
+
+        executor.start();
+    }
+
+    private static void checkGameState(Profile profile, VersionSetting setting, Version version, Runnable onAccept) throws InterruptedException {
+        boolean flag = false;
+
+        // Without onAccept called, the launching operation will be terminated.
+
+        VersionNumber gameVersion = VersionNumber.asVersion(GameVersion.minecraftVersion(profile.getRepository().getVersionJar(version)).orElse("Unknown"));
+        JavaVersion java = setting.getJavaVersion();
+        if (java == null) {
+            Controllers.dialog(i18n("launch.wrong_javadir"), i18n("message.error"), MessageBox.WARNING_MESSAGE, onAccept);
+            setting.setJava(null);
+            setting.setDefaultJavaPath(null);
+            java = JavaVersion.fromCurrentEnvironment();
+            flag = true;
+        }
+
+        if (!flag && java.getParsedVersion() < JavaVersion.JAVA_8) {
+            if (gameVersion.compareTo(VersionNumber.asVersion("1.13")) >= 0) {
+                // Minecraft 1.13 and later versions only support Java 8 or later.
+                // Terminate launching operation.
+                Controllers.dialog(i18n("launch.advice.java8_1_13"), i18n("message.error"), MessageBox.ERROR_MESSAGE, null);
+            } else {
+                // Most mods require Java 8 or later version.
+                Controllers.dialog(i18n("launch.advice.newer_java"), i18n("message.error"), MessageBox.WARNING_MESSAGE, onAccept);
+            }
+            flag = true;
+        }
+
+        // LaunchWrapper will crash because of assuming the system class loader is an instance of URLClassLoader.
+        // cpw has claimed that he will make MinecraftForge of 1.13 and later versions able to run on Java 9.
+        if (!flag && java.getParsedVersion() >= JavaVersion.JAVA_9 && gameVersion.compareTo(VersionNumber.asVersion("1.12.5")) < 0 && version.getMainClass().contains("launchwrapper")) {
+            Controllers.dialog(i18n("launch.advice.java9"), i18n("message.error"), MessageBox.ERROR_MESSAGE, null);
+            flag = true;
+        }
+
+        if (!flag && java.getPlatform() == org.jackhuang.hmcl.util.Platform.BIT_32 &&
+                org.jackhuang.hmcl.util.Platform.IS_64_BIT) {
+            Controllers.dialog(i18n("launch.advice.different_platform"), i18n("message.error"), MessageBox.ERROR_MESSAGE, onAccept);
+            flag = true;
+        }
+        if (!flag && java.getPlatform() == org.jackhuang.hmcl.util.Platform.BIT_32 &&
+                setting.getMaxMemory() > 1.5 * 1024) {
+            // 1.5 * 1024 is an inaccurate number.
+            // Actual memory limit depends on operating system and memory.
+            Controllers.dialog(i18n("launch.advice.too_large_memory_for_32bit"), i18n("message.error"), MessageBox.ERROR_MESSAGE, onAccept);
+            flag = true;
+        }
+        if (!flag && OperatingSystem.TOTAL_MEMORY > 0 && OperatingSystem.TOTAL_MEMORY < setting.getMaxMemory()) {
+            Controllers.dialog(i18n("launch.advice.not_enough_space", OperatingSystem.TOTAL_MEMORY), i18n("message.error"), MessageBox.ERROR_MESSAGE, onAccept);
+            flag = true;
+        }
+
+        if (!flag)
+            onAccept.run();
+    }
+
+    public static void stopManagedProcesses() {
+        while (!PROCESSES.isEmpty())
+            Optional.ofNullable(PROCESSES.poll()).ifPresent(ManagedProcess::stop);
+    }
+
+    public void emitStatus(LoadingState state) {
+        if (state == LoadingState.DONE) {
+            launchingStepsPane.fireEvent(new DialogCloseEvent());
+        }
+
+        launchingStepsPane.setTitle(state.getLocalizedMessage());
+        launchingStepsPane.setSubtitle((state.ordinal() + 1) + " / " + LoadingState.values().length);
+    }
+
+    private void checkExit(LauncherVisibility v) {
+        switch (v) {
+            case HIDE_AND_REOPEN:
+                Platform.runLater(Controllers.getStage()::show);
+                break;
+            case KEEP:
+                // No operations here
+                break;
+            case CLOSE:
+                throw new Error("Never get to here");
+            case HIDE:
+                Platform.runLater(() -> {
+                    // Shut down the platform when user closed log window.
+                    Platform.setImplicitExit(true);
+                    // If we use Launcher.stop(), log window will be halt immediately.
+                    Launcher.stopWithoutPlatform();
+                });
+                break;
+        }
+    }
+
+    private static class LaunchTask<T> extends TaskResult<T> {
+        private final ExceptionalSupplier<T, Exception> supplier;
+
+        public LaunchTask(ExceptionalSupplier<T, Exception> supplier) {
+            this.supplier = supplier;
+        }
+
+        @Override
+        public void execute() throws Exception {
+            setResult(supplier.get());
+        }
+
+        @Override
+        public String getId() {
+            return LAUNCH_ID;
+        }
+
+        static final String LAUNCH_ID = "launch";
+    }
+
+    /**
+     * The managed process listener.
+     * Guarantee that one [JavaProcess], one [HMCLProcessListener].
+     * Because every time we launched a game, we generates a new [HMCLProcessListener]
+     */
+    class HMCLProcessListener implements ProcessListener {
+
+        private final VersionSetting setting;
+        private final Map<String, String> forbiddenTokens;
+        private final LauncherVisibility visibility;
+        private ManagedProcess process;
+        private boolean lwjgl;
+        private LogWindow logWindow;
+        private final boolean detectWindow;
+        private final LinkedList<Pair<String, Log4jLevel>> logs;
+        private final CountDownLatch latch = new CountDownLatch(1);
+
+        public HMCLProcessListener(AuthInfo authInfo, VersionSetting setting, boolean detectWindow) {
+            this.setting = setting;
+            this.detectWindow = detectWindow;
+
+            if (authInfo == null)
+                forbiddenTokens = Collections.emptyMap();
+            else
+                forbiddenTokens = mapOf(
+                        pair(authInfo.getAccessToken(), "<access token>"),
+                        pair(UUIDTypeAdapter.fromUUID(authInfo.getUUID()), "<uuid>"),
+                        pair(authInfo.getUsername(), "<player>")
+                );
+
+            visibility = setting.getLauncherVisibility();
+            logs = new LinkedList<>();
+        }
+
+        @Override
+        public void setProcess(ManagedProcess process) {
+            this.process = process;
+
+            if (setting.isShowLogs())
+                Platform.runLater(() -> {
+                    logWindow = new LogWindow();
+                    logWindow.show();
+                    latch.countDown();
+                });
+        }
+
+        @Override
+        public synchronized void onLog(String log, Log4jLevel level) {
+            String newLog = log;
+            for (Map.Entry<String, String> entry : forbiddenTokens.entrySet())
+                newLog = newLog.replace(entry.getKey(), entry.getValue());
+
+            if (level.lessOrEqual(Log4jLevel.ERROR))
+                System.err.print(log);
+            else
+                System.out.print(log);
+
+            logs.add(pair(log, level));
+            if (logs.size() > Settings.INSTANCE.getLogLines())
+                logs.removeFirst();
+
+            if (setting.isShowLogs()) {
+                Lang.invoke(() -> {
+                    latch.await();
+                    logWindow.waitForLoaded();
+                });
+
+                Platform.runLater(() -> logWindow.logLine(log, level));
+            }
+
+            if (!lwjgl && log.contains("LWJGL Version: ") || !detectWindow) {
+                lwjgl = true;
+                switch (visibility) {
+                    case HIDE_AND_REOPEN:
+                        Platform.runLater(() -> {
+                            Controllers.getStage().hide();
+                            emitStatus(LoadingState.DONE);
+                        });
+                        break;
+                    case CLOSE:
+                        // Never come to here.
+                        break;
+                    case KEEP:
+                        Platform.runLater(() -> {
+                            emitStatus(LoadingState.DONE);
+                        });
+                        break;
+                    case HIDE:
+                        Platform.runLater(() -> {
+                            Controllers.getStage().close();
+                            emitStatus(LoadingState.DONE);
+                        });
+                        break;
+                }
+            }
+        }
+
+        @Override
+        public void onExit(int exitCode, ExitType exitType) {
+            if (exitType == ExitType.INTERRUPTED)
+                return;
+
+            if (exitType != ExitType.NORMAL && logWindow == null)
+                Platform.runLater(() -> {
+                    logWindow = new LogWindow();
+
+                    switch (exitType) {
+                        case JVM_ERROR:
+                            logWindow.setTitle(i18n("launch.failed.cannot_create_jvm"));
+                            break;
+                        case APPLICATION_ERROR:
+                            logWindow.setTitle(i18n("launch.failed.exited_abnormally"));
+                            break;
+                    }
+
+                    logWindow.show();
+                    logWindow.onDone.register(() -> {
+                        logWindow.logLine("Commands: " + StringUtils.makeCommand(process.getCommands()), Log4jLevel.INFO);
+                        for (Map.Entry<String, Log4jLevel> entry : logs)
+                            logWindow.logLine(entry.getKey(), entry.getValue());
+                    });
+                });
+
+            checkExit(visibility);
+        }
+
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/LoadingState.java

@@ -0,0 +1,38 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+public enum LoadingState {
+    DEPENDENCIES("launch.state.dependencies"),
+    MODS("launch.state.modpack"),
+    LOGGING_IN("launch.state.logging_in"),
+    LAUNCHING("launch.state.waiting_launching"),
+    DONE("launch.state.done");
+
+    private final String key;
+
+    LoadingState(String key) {
+        this.key = key;
+    }
+
+    public String getLocalizedMessage() {
+        return i18n(key);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/ModAdviser.java

@@ -1,6 +1,6 @@
 /*
  * Hello Minecraft! Launcher.
- * Copyright (C) 2017  huangyuhui <[email protected]>
+ * Copyright (C) 2018  huangyuhui <[email protected]>
  * 
  * 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
@@ -15,11 +15,17 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see {http://www.gnu.org/licenses/}.
  */
-package org.jackhuang.hmcl.util
+package org.jackhuang.hmcl.game;
 
 /**
- * Mark if the model is immutable.
+ * @author huangyuhui
  */
-@Target(AnnotationTarget.CLASS)
-@Retention(AnnotationRetention.SOURCE)
-annotation class Immutable
+public interface ModAdviser {
+    ModSuggestion advise(String fileName, boolean isDirectory);
+
+    enum ModSuggestion {
+        SUGGESTED,
+        NORMAL,
+        HIDDEN
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/ModpackHelper.java

@@ -0,0 +1,171 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import com.google.gson.JsonParseException;
+import com.google.gson.reflect.TypeToken;
+import org.jackhuang.hmcl.mod.*;
+import org.jackhuang.hmcl.setting.EnumGameDirectory;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.setting.VersionSetting;
+import org.jackhuang.hmcl.task.FinalizedCallback;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.util.Constants;
+import org.jackhuang.hmcl.util.FileUtils;
+import org.jackhuang.hmcl.util.Lang;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Optional;
+
+public final class ModpackHelper {
+    private ModpackHelper() {}
+
+    public static Modpack readModpackManifest(File file) throws UnsupportedModpackException {
+        try {
+            return CurseManifest.readCurseForgeModpackManifest(file);
+        } catch (Exception e) {
+            // ignore it, not a valid CurseForge modpack.
+        }
+
+        try {
+            return HMCLModpackManager.readHMCLModpackManifest(file);
+        } catch (Exception e) {
+            // ignore it, not a valid HMCL modpack.
+        }
+
+        try {
+            return MultiMCInstanceConfiguration.readMultiMCModpackManifest(file);
+        } catch (Exception e) {
+            // ignore it, not a valid MultiMC modpack.
+        }
+
+        throw new UnsupportedModpackException(file.toString());
+    }
+
+    public static ModpackConfiguration<?> readModpackConfiguration(File file) throws IOException {
+        if (!file.exists())
+            throw new FileNotFoundException(file.getPath());
+        else
+            try {
+                return Constants.GSON.fromJson(FileUtils.readText(file), new TypeToken<ModpackConfiguration<?>>() {
+                }.getType());
+            } catch (JsonParseException e) {
+                throw new IOException("Malformed modpack configuration");
+            }
+    }
+
+    private static String getManifestType(Object manifest) throws UnsupportedModpackException {
+        if (manifest instanceof HMCLModpackManifest)
+            return HMCLModpackInstallTask.MODPACK_TYPE;
+        else if (manifest instanceof MultiMCInstanceConfiguration)
+            return MultiMCModpackInstallTask.MODPACK_TYPE;
+        else if (manifest instanceof CurseManifest)
+            return CurseInstallTask.MODPACK_TYPE;
+        else
+            throw new UnsupportedModpackException();
+    }
+
+    public static Task getInstallTask(Profile profile, File zipFile, String name, Modpack modpack) {
+        profile.getRepository().markVersionAsModpack(name);
+
+        FinalizedCallback finalizeTask = (variables, isDependentsSucceeded) -> {
+            profile.getRepository().refreshVersions();
+            VersionSetting vs = profile.specializeVersionSetting(name);
+            profile.getRepository().undoMark(name);
+            if (vs != null)
+                vs.setGameDirType(EnumGameDirectory.VERSION_FOLDER);
+        };
+
+        if (modpack.getManifest() instanceof CurseManifest)
+            return new CurseInstallTask(profile.getDependency(), zipFile, ((CurseManifest) modpack.getManifest()), name)
+                    .finalized(finalizeTask);
+        else if (modpack.getManifest() instanceof HMCLModpackManifest)
+            return new HMCLModpackInstallTask(profile, zipFile, modpack, name)
+                    .finalized(finalizeTask);
+        else if (modpack.getManifest() instanceof MultiMCInstanceConfiguration)
+            return new MultiMCModpackInstallTask(profile.getDependency(), zipFile, ((MultiMCInstanceConfiguration) modpack.getManifest()), name)
+                    .finalized(finalizeTask)
+                    .with(new MultiMCInstallVersionSettingTask(profile, ((MultiMCInstanceConfiguration) modpack.getManifest()), name));
+        else throw new IllegalStateException("Unrecognized modpack: " + modpack);
+    }
+
+    public static Task getUpdateTask(Profile profile, File zipFile, String name, ModpackConfiguration<?> configuration) throws UnsupportedModpackException, MismatchedModpackTypeException {
+        Modpack modpack = ModpackHelper.readModpackManifest(zipFile);
+
+        switch (configuration.getType()) {
+            case CurseInstallTask.MODPACK_TYPE:
+                if (!(modpack.getManifest() instanceof CurseManifest))
+                    throw new MismatchedModpackTypeException(CurseInstallTask.MODPACK_TYPE, getManifestType(modpack.getManifest()));
+
+                return new CurseInstallTask(profile.getDependency(), zipFile, (CurseManifest) modpack.getManifest(), name);
+            case MultiMCModpackInstallTask.MODPACK_TYPE:
+                if (!(modpack.getManifest() instanceof MultiMCInstanceConfiguration))
+                    throw new MismatchedModpackTypeException(MultiMCModpackInstallTask.MODPACK_TYPE, getManifestType(modpack.getManifest()));
+
+                return new MultiMCModpackInstallTask(profile.getDependency(), zipFile, (MultiMCInstanceConfiguration) modpack.getManifest(), name);
+            case HMCLModpackInstallTask.MODPACK_TYPE:
+                if (!(modpack.getManifest() instanceof HMCLModpackManifest))
+                    throw new MismatchedModpackTypeException(HMCLModpackInstallTask.MODPACK_TYPE, getManifestType(modpack.getManifest()));
+
+                return new HMCLModpackInstallTask(profile, zipFile, modpack, name);
+            default:
+                throw new UnsupportedModpackException();
+        }
+    }
+
+    public static void toVersionSetting(MultiMCInstanceConfiguration c, VersionSetting vs) {
+        vs.setUsesGlobal(false);
+        vs.setGameDirType(EnumGameDirectory.VERSION_FOLDER);
+
+        if (c.isOverrideJavaLocation()) {
+            vs.setJavaDir(Lang.nonNull(c.getJavaPath(), ""));
+        }
+
+        if (c.isOverrideMemory()) {
+            vs.setPermSize(Optional.ofNullable(c.getPermGen()).map(Object::toString).orElse(""));
+            if (c.getMaxMemory() != null)
+                vs.setMaxMemory(c.getMaxMemory());
+            vs.setMinMemory(c.getMinMemory());
+        }
+
+        if (c.isOverrideCommands()) {
+            vs.setWrapper(Lang.nonNull(c.getWrapperCommand(), ""));
+            vs.setPreLaunchCommand(Lang.nonNull(c.getPreLaunchCommand(), ""));
+        }
+
+        if (c.isOverrideJavaArgs()) {
+            vs.setJavaArgs(Lang.nonNull(c.getJvmArgs(), ""));
+        }
+
+        if (c.isOverrideConsole()) {
+            vs.setShowLogs(c.isShowConsole());
+        }
+
+        if (c.isOverrideWindow()) {
+            vs.setFullscreen(c.isFullscreen());
+            if (c.getWidth() != null)
+                vs.setWidth(c.getWidth());
+            if (c.getHeight() != null)
+                vs.setHeight(c.getHeight());
+        }
+    }
+
+
+}

HMCL/src/main/java/org/jackhuang/hmcl/game/MultiMCInstallVersionSettingTask.java

@@ -0,0 +1,50 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.game;
+
+import org.jackhuang.hmcl.mod.MultiMCInstanceConfiguration;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.setting.VersionSetting;
+import org.jackhuang.hmcl.task.Scheduler;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+
+import java.util.Objects;
+
+public final class MultiMCInstallVersionSettingTask extends Task {
+    private final Profile profile;
+    private final MultiMCInstanceConfiguration manifest;
+    private final String version;
+
+    public MultiMCInstallVersionSettingTask(Profile profile, MultiMCInstanceConfiguration manifest, String version) {
+        this.profile = profile;
+        this.manifest = manifest;
+        this.version = version;
+    }
+
+    @Override
+    public Scheduler getScheduler() {
+        return Schedulers.javafx();
+    }
+
+    @Override
+    public void execute() {
+        VersionSetting vs = Objects.requireNonNull(profile.specializeVersionSetting(version));
+        ModpackHelper.toVersionSetting(manifest, vs);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/Accounts.java

@@ -0,0 +1,92 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.auth.AccountFactory;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorAccount;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorAccountFactory;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorDownloader;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorServer;
+import org.jackhuang.hmcl.auth.offline.OfflineAccount;
+import org.jackhuang.hmcl.auth.offline.OfflineAccountFactory;
+import org.jackhuang.hmcl.auth.yggdrasil.MojangYggdrasilProvider;
+import org.jackhuang.hmcl.auth.yggdrasil.YggdrasilAccount;
+import org.jackhuang.hmcl.auth.yggdrasil.YggdrasilAccountFactory;
+import java.io.IOException;
+import java.util.Map;
+import java.util.logging.Level;
+
+import static org.jackhuang.hmcl.util.Lang.mapOf;
+import static org.jackhuang.hmcl.util.Logging.LOG;
+import static org.jackhuang.hmcl.util.Pair.pair;
+
+/**
+ * @author huangyuhui
+ */
+public final class Accounts {
+    private Accounts() {}
+
+    public static final String OFFLINE_ACCOUNT_KEY = "offline";
+    public static final String YGGDRASIL_ACCOUNT_KEY = "yggdrasil";
+    public static final String AUTHLIB_INJECTOR_ACCOUNT_KEY = "authlibInjector";
+
+    public static final Map<String, AccountFactory<?>> ACCOUNT_FACTORY = mapOf(
+            pair(OFFLINE_ACCOUNT_KEY, OfflineAccountFactory.INSTANCE),
+            pair(YGGDRASIL_ACCOUNT_KEY, new YggdrasilAccountFactory(MojangYggdrasilProvider.INSTANCE)),
+            pair(AUTHLIB_INJECTOR_ACCOUNT_KEY, new AuthlibInjectorAccountFactory(
+                    new AuthlibInjectorDownloader(Launcher.HMCL_DIRECTORY.toPath(), () -> Settings.INSTANCE.getDownloadProvider())::getArtifactInfo,
+                    Accounts::getOrCreateAuthlibInjectorServer))
+    );
+
+    public static String getAccountType(Account account) {
+        if (account instanceof OfflineAccount) return OFFLINE_ACCOUNT_KEY;
+        else if (account instanceof AuthlibInjectorAccount) return AUTHLIB_INJECTOR_ACCOUNT_KEY;
+        else if (account instanceof YggdrasilAccount) return YGGDRASIL_ACCOUNT_KEY;
+        else return YGGDRASIL_ACCOUNT_KEY;
+    }
+
+    static String getAccountId(Account account) {
+        return getAccountId(account.getUsername(), account.getCharacter());
+    }
+
+    static String getAccountId(String username, String character) {
+        return username + ":" + character;
+    }
+
+    private static AuthlibInjectorServer getOrCreateAuthlibInjectorServer(String url) {
+        return ConfigHolder.CONFIG.authlibInjectorServers.stream()
+                .filter(server -> url.equals(server.getUrl()))
+                .findFirst()
+                .orElseGet(() -> {
+                    // this usually happens when migrating data from an older version
+                    AuthlibInjectorServer server;
+                    try {
+                        server = AuthlibInjectorServer.fetchServerInfo(url);
+                        LOG.info("Migrated authlib injector server " + server);
+                    } catch (IOException e) {
+                        server = new AuthlibInjectorServer(url, url);
+                        LOG.log(Level.WARNING, "Failed to migrate authlib injector server " + url, e);
+                    }
+
+                    ConfigHolder.CONFIG.authlibInjectorServers.add(server);
+                    return server;
+                });
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/Config.java

@@ -0,0 +1,140 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+import java.io.File;
+import java.util.Map;
+import java.util.TreeMap;
+
+import org.hildan.fxgson.creators.ObservableListCreator;
+import org.hildan.fxgson.creators.ObservableMapCreator;
+import org.hildan.fxgson.creators.ObservableSetCreator;
+import org.hildan.fxgson.factories.JavaFxPropertyTypeAdapterFactory;
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorServer;
+import org.jackhuang.hmcl.util.FileTypeAdapter;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.JsonParseException;
+import com.google.gson.annotations.SerializedName;
+
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.DoubleProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleDoubleProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.collections.ObservableMap;
+import javafx.collections.ObservableSet;
+
+public final class Config implements Cloneable {
+
+    private static final Gson CONFIG_GSON = new GsonBuilder()
+            .registerTypeAdapter(VersionSetting.class, VersionSetting.Serializer.INSTANCE)
+            .registerTypeAdapter(Profile.class, Profile.Serializer.INSTANCE)
+            .registerTypeAdapter(File.class, FileTypeAdapter.INSTANCE)
+            .registerTypeAdapter(ObservableList.class, new ObservableListCreator())
+            .registerTypeAdapter(ObservableSet.class, new ObservableSetCreator())
+            .registerTypeAdapter(ObservableMap.class, new ObservableMapCreator())
+            .registerTypeAdapterFactory(new JavaFxPropertyTypeAdapterFactory(true, true))
+            .setPrettyPrinting()
+            .create();
+
+    public static Config fromJson(String json) throws JsonParseException {
+        return CONFIG_GSON.fromJson(json, Config.class);
+    }
+
+    @SerializedName("last")
+    public final StringProperty selectedProfile = new SimpleStringProperty("");
+
+    @SerializedName("backgroundType")
+    public final IntegerProperty backgroundImageType = new SimpleIntegerProperty(0);
+
+    @SerializedName("bgpath")
+    public final StringProperty backgroundImage = new SimpleStringProperty();
+
+    @SerializedName("commonpath")
+    public final StringProperty commonDirectory = new SimpleStringProperty(Launcher.MINECRAFT_DIRECTORY.getAbsolutePath());
+
+    @SerializedName("hasProxy")
+    public final BooleanProperty hasProxy = new SimpleBooleanProperty();
+
+    @SerializedName("hasProxyAuth")
+    public final BooleanProperty hasProxyAuth = new SimpleBooleanProperty();
+
+    @SerializedName("proxyType")
+    public final IntegerProperty proxyType = new SimpleIntegerProperty();
+
+    @SerializedName("proxyHost")
+    public final StringProperty proxyHost = new SimpleStringProperty();
+
+    @SerializedName("proxyPort")
+    public final StringProperty proxyPort = new SimpleStringProperty();
+
+    @SerializedName("proxyUserName")
+    public final StringProperty proxyUser = new SimpleStringProperty();
+
+    @SerializedName("proxyPassword")
+    public final StringProperty proxyPass = new SimpleStringProperty();
+
+    @SerializedName("theme")
+    public final StringProperty theme = new SimpleStringProperty();
+
+    @SerializedName("localization")
+    public final StringProperty localization = new SimpleStringProperty();
+
+    @SerializedName("downloadtype")
+    public final IntegerProperty downloadType = new SimpleIntegerProperty(1);
+
+    @SerializedName("configurations")
+    public final ObservableMap<String, Profile> configurations = FXCollections.observableMap(new TreeMap<>());
+
+    @SerializedName("accounts")
+    public final ObservableList<Map<Object, Object>> accounts = FXCollections.observableArrayList();
+
+    @SerializedName("selectedAccount")
+    public final StringProperty selectedAccount = new SimpleStringProperty("");
+
+    @SerializedName("fontFamily")
+    public final StringProperty fontFamily = new SimpleStringProperty("Consolas");
+
+    @SerializedName("fontSize")
+    public final DoubleProperty fontSize = new SimpleDoubleProperty(12);
+
+    @SerializedName("logLines")
+    public final IntegerProperty logLines = new SimpleIntegerProperty(100);
+
+    @SerializedName("firstLaunch")
+    public final BooleanProperty firstLaunch = new SimpleBooleanProperty(true);
+
+    public final ObservableList<AuthlibInjectorServer> authlibInjectorServers = FXCollections.observableArrayList();
+
+    public String toJson() {
+        return CONFIG_GSON.toJson(this);
+    }
+
+    @Override
+    public Config clone() {
+        return fromJson(this.toJson());
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/ConfigHolder.java

@@ -0,0 +1,65 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+import static java.nio.charset.StandardCharsets.UTF_8;
+import static org.jackhuang.hmcl.util.Logging.LOG;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.logging.Level;
+
+import com.google.gson.JsonParseException;
+
+public final class ConfigHolder {
+
+    private ConfigHolder() {}
+
+    public static final String CONFIG_FILENAME = "hmcl.json";
+    public static final Path CONFIG_PATH = Paths.get(CONFIG_FILENAME).toAbsolutePath();
+    public static final Config CONFIG = initSettings();
+
+    private static Config initSettings() {
+        Config config = new Config();
+        if (Files.exists(CONFIG_PATH)) {
+            try {
+                Config deserialized = Config.fromJson(new String(Files.readAllBytes(CONFIG_PATH), UTF_8));
+                if (deserialized == null) {
+                    LOG.finer("Settings file is empty, use the default settings.");
+                } else {
+                    config = deserialized;
+                }
+                LOG.finest("Initialized settings.");
+            } catch (IOException | JsonParseException e) {
+                LOG.log(Level.WARNING, "Something happened wrongly when load settings.", e);
+            }
+        }
+        return config;
+    }
+
+    static void saveConfig(Config config) {
+        try {
+            Files.write(CONFIG_PATH, config.toJson().getBytes(UTF_8));
+        } catch (IOException ex) {
+            LOG.log(Level.SEVERE, "Failed to save config", ex);
+        }
+    }
+
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/DownloadProviders.java

@@ -0,0 +1,36 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+import org.jackhuang.hmcl.download.BMCLAPIDownloadProvider;
+import org.jackhuang.hmcl.download.CurseCDNDownloadProvider;
+import org.jackhuang.hmcl.download.DownloadProvider;
+import org.jackhuang.hmcl.download.MojangDownloadProvider;
+import org.jackhuang.hmcl.util.Lang;
+
+import java.util.List;
+
+public final class DownloadProviders {
+    private DownloadProviders() {}
+
+    public static final List<DownloadProvider> DOWNLOAD_PROVIDERS = Lang.immutableListOf(new MojangDownloadProvider(), BMCLAPIDownloadProvider.INSTANCE, CurseCDNDownloadProvider.INSTANCE);
+
+    public static DownloadProvider getDownloadProvider(int index) {
+        return Lang.get(DOWNLOAD_PROVIDERS, index).orElse(DOWNLOAD_PROVIDERS.get(0));
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/EnumBackgroundImage.java

@@ -1,7 +1,7 @@
 /*
  * Hello Minecraft! Launcher.
- * Copyright (C) 2017  huangyuhui <[email protected]>
- * 
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
  * 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, either version 3 of the License, or
@@ -15,14 +15,16 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see {http://www.gnu.org/licenses/}.
  */
-package org.jackhuang.hmcl.download
+package org.jackhuang.hmcl.setting;
 
-abstract class AbstractDependencyManager
-    : DependencyManager {
-    abstract val downloadProvider: DownloadProvider
+public enum EnumBackgroundImage {
+    DEFAULT,
+    CUSTOM;
 
-    override fun getVersionList(id: String): VersionList<*> {
-        return downloadProvider.getVersionListById(id)
+    public static EnumBackgroundImage indexOf(int index) {
+        if (index >= values().length || index < 0)
+            return DEFAULT;
+        else
+            return values()[index];
     }
-
-}
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/EnumGameDirectory.java

@@ -0,0 +1,38 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+/**
+ * Determines where game runs in and game files such as mods.
+ *
+ * @author huangyuhui
+ */
+public enum EnumGameDirectory {
+    /**
+     * .minecraft
+     */
+    ROOT_FOLDER,
+    /**
+     * .minecraft/versions/&lt;version name&gt;
+     */
+    VERSION_FOLDER,
+    /**
+     * user customized directory.
+     */
+    CUSTOM
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/Fonts.java

@@ -1,6 +1,6 @@
 /*
  * Hello Minecraft! Launcher.
- * Copyright (C) 2017  huangyuhui <[email protected]>
+ * Copyright (C) 2018  huangyuhui <[email protected]>
  * 
  * 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
@@ -15,10 +15,14 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see {http://www.gnu.org/licenses/}.
  */
-package org.jackhuang.hmcl.ui.wizard
+package org.jackhuang.hmcl.setting;
 
-import javafx.scene.Node
+import javafx.scene.text.Font;
 
-object Wizard {
-    fun createWizard(namespace: String = "", provider: WizardProvider): Node = DefaultWizardDisplayer(namespace, provider)
-}
+import java.util.List;
+
+public final class Fonts {
+    private Fonts() {}
+
+    public static final List<String> FONTS = Font.getFamilies();
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/LauncherVisibility.java

@@ -1,6 +1,6 @@
 /*
  * Hello Minecraft! Launcher.
- * Copyright (C) 2017  huangyuhui <[email protected]>
+ * Copyright (C) 2018  huangyuhui <[email protected]>
  * 
  * 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
@@ -15,13 +15,13 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see {http://www.gnu.org/licenses/}.
  */
-package org.jackhuang.hmcl.setting
+package org.jackhuang.hmcl.setting;
 
 /**
  * The visibility of launcher.
  * @author huangyuhui
  */
-enum class LauncherVisibility {
+public enum LauncherVisibility {
 
     /**
      * Close the launcher anyway when the game process created even if failed to
@@ -44,4 +44,4 @@ enum class LauncherVisibility {
      * Hide the launcher and reopen it when game closes.
      */
     HIDE_AND_REOPEN
-}
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/Profile.java

@@ -0,0 +1,195 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+import com.google.gson.*;
+import javafx.beans.InvalidationListener;
+import org.jackhuang.hmcl.game.HMCLDependencyManager;
+import org.jackhuang.hmcl.game.HMCLGameRepository;
+import org.jackhuang.hmcl.mod.ModManager;
+import org.jackhuang.hmcl.util.ImmediateObjectProperty;
+import org.jackhuang.hmcl.util.ImmediateStringProperty;
+import org.jackhuang.hmcl.util.ToStringBuilder;
+
+import java.io.File;
+import java.lang.reflect.Type;
+import java.util.Optional;
+
+/**
+ *
+ * @author huangyuhui
+ */
+public final class Profile {
+
+    private final HMCLGameRepository repository;
+    private final ModManager modManager;
+
+    private final ImmediateObjectProperty<File> gameDirProperty;
+
+    public ImmediateObjectProperty<File> gameDirProperty() {
+        return gameDirProperty;
+    }
+
+    public File getGameDir() {
+        return gameDirProperty.get();
+    }
+
+    public void setGameDir(File gameDir) {
+        gameDirProperty.set(gameDir);
+    }
+
+    private final ImmediateObjectProperty<VersionSetting> globalProperty = new ImmediateObjectProperty<>(this, "global", new VersionSetting());
+
+    public ImmediateObjectProperty<VersionSetting> globalProperty() {
+        return globalProperty;
+    }
+
+    public VersionSetting getGlobal() {
+        return globalProperty.get();
+    }
+
+    public void setGlobal(VersionSetting global) {
+        if (global == null)
+            global = new VersionSetting();
+        globalProperty.set(global);
+    }
+
+    private final ImmediateStringProperty nameProperty;
+
+    public ImmediateStringProperty nameProperty() {
+        return nameProperty;
+    }
+
+    public String getName() {
+        return nameProperty.get();
+    }
+
+    public void setName(String name) {
+        nameProperty.set(name);
+    }
+
+    public Profile() {
+        this("Default");
+    }
+
+    public Profile(String name) {
+        this(name, new File(".minecraft"));
+    }
+
+    public Profile(String name, File initialGameDir) {
+        nameProperty = new ImmediateStringProperty(this, "name", name);
+        gameDirProperty = new ImmediateObjectProperty<>(this, "gameDir", initialGameDir);
+        repository = new HMCLGameRepository(this, initialGameDir);
+        modManager = new ModManager(repository);
+
+        gameDirProperty.addListener((a, b, newValue) -> repository.changeDirectory(newValue));
+    }
+
+    public HMCLGameRepository getRepository() {
+        return repository;
+    }
+
+    public ModManager getModManager() {
+        return modManager;
+    }
+
+    public HMCLDependencyManager getDependency() {
+        return new HMCLDependencyManager(this, Settings.INSTANCE.getDownloadProvider(), Settings.INSTANCE.getProxy());
+    }
+
+    public VersionSetting getVersionSetting(String id) {
+        VersionSetting vs = repository.getVersionSetting(id);
+        if (vs == null || vs.isUsesGlobal()) {
+            getGlobal().setGlobal(true); // always keep global.isGlobal = true
+            getGlobal().setUsesGlobal(true);
+            return getGlobal();
+        } else
+            return vs;
+    }
+
+    public boolean isVersionGlobal(String id) {
+        VersionSetting vs = repository.getVersionSetting(id);
+        return vs == null || vs.isUsesGlobal();
+    }
+
+    /**
+     * Make version use self version settings instead of the global one.
+     * @param id the version id.
+     * @return specialized version setting, null if given version does not exist.
+     */
+    public VersionSetting specializeVersionSetting(String id) {
+        VersionSetting vs = repository.getVersionSetting(id);
+        if (vs == null)
+            vs = repository.createVersionSetting(id);
+        if (vs == null)
+            return null;
+        vs.setUsesGlobal(false);
+        return vs;
+    }
+
+    public void globalizeVersionSetting(String id) {
+        VersionSetting vs = repository.getVersionSetting(id);
+        if (vs != null)
+            vs.setUsesGlobal(true);
+    }
+
+    @Override
+    public String toString() {
+        return new ToStringBuilder(this)
+                .append("gameDir", getGameDir())
+                .append("name", getName())
+                .toString();
+    }
+
+    public void addPropertyChangedListener(InvalidationListener listener) {
+        nameProperty.addListener(listener);
+        globalProperty.addListener(listener);
+        gameDirProperty.addListener(listener);
+    }
+
+    public static final class Serializer implements JsonSerializer<Profile>, JsonDeserializer<Profile> {
+        public static final Serializer INSTANCE = new Serializer();
+
+        private Serializer() {
+        }
+
+        @Override
+        public JsonElement serialize(Profile src, Type typeOfSrc, JsonSerializationContext context) {
+            if (src == null)
+                return JsonNull.INSTANCE;
+
+            JsonObject jsonObject = new JsonObject();
+            jsonObject.add("global", context.serialize(src.getGlobal()));
+            jsonObject.addProperty("gameDir", src.getGameDir().getPath());
+
+            return jsonObject;
+        }
+
+        @Override
+        public Profile deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+            if (json == null || json == JsonNull.INSTANCE || !(json instanceof JsonObject)) return null;
+            JsonObject obj = (JsonObject) json;
+            String gameDir = Optional.ofNullable(obj.get("gameDir")).map(JsonElement::getAsString).orElse("");
+
+            Profile profile = new Profile("Default", new File(gameDir));
+            profile.setGlobal(context.deserialize(obj.get("global"), VersionSetting.class));
+            return profile;
+        }
+
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/Profiles.java

@@ -1,7 +1,7 @@
 /*
  * Hello Minecraft! Launcher.
- * Copyright (C) 2017  huangyuhui <[email protected]>
- * 
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
  * 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, either version 3 of the License, or
@@ -15,22 +15,26 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see {http://www.gnu.org/licenses/}.
  */
-package org.jackhuang.hmcl.game
+package org.jackhuang.hmcl.setting;
 
-import java.util.*
-import java.util.regex.Pattern
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
 
-class StringArgument(val argument: String) : Argument {
+public final class Profiles {
 
-    override fun toString(keys: Map<String, String>, features: Map<String, Boolean>): List<String> {
-        var res = argument
-        val pattern = Pattern.compile("\\$\\{(.*?)\\}")
-        val m = pattern.matcher(argument)
-        while (m.find()) {
-            val entry = m.group()
-            res = res.replace(entry, keys.getOrDefault(entry, entry))
-        }
-        return Collections.singletonList(res)
+    public static final String DEFAULT_PROFILE = "Default";
+    public static final String HOME_PROFILE = "Home";
+
+    private Profiles() {
     }
 
-}
+    public static String getProfileDisplayName(Profile profile) {
+        switch (profile.getName()) {
+            case Profiles.DEFAULT_PROFILE:
+                return i18n("profile.default");
+            case Profiles.HOME_PROFILE:
+                return i18n("profile.home");
+            default:
+                return profile.getName();
+        }
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/Proxies.java

@@ -0,0 +1,36 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+import org.jackhuang.hmcl.util.Lang;
+
+import java.net.Proxy;
+import java.util.List;
+
+/**
+ * @author huangyuhui
+ */
+public final class Proxies {
+    private Proxies() {}
+
+    public static final List<Proxy.Type> PROXIES = Lang.immutableListOf(Proxy.Type.DIRECT, Proxy.Type.HTTP, Proxy.Type.SOCKS);
+
+    public static Proxy.Type getProxyType(int index) {
+        return Lang.get(PROXIES, index).orElse(null);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/Settings.java

@@ -0,0 +1,545 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.StringProperty;
+import javafx.beans.value.ObservableValue;
+import javafx.scene.text.Font;
+
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.auth.AccountFactory;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorAccount;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorServer;
+import org.jackhuang.hmcl.download.DownloadProvider;
+import org.jackhuang.hmcl.event.*;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.util.*;
+import org.jackhuang.hmcl.util.i18n.Locales;
+
+import java.net.Authenticator;
+import java.net.InetSocketAddress;
+import java.net.PasswordAuthentication;
+import java.net.Proxy;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+import static java.util.stream.Collectors.toList;
+import static org.jackhuang.hmcl.ui.FXUtils.onInvalidating;
+import static org.jackhuang.hmcl.util.Lang.tryCast;
+import static org.jackhuang.hmcl.util.Logging.LOG;
+
+public class Settings {
+
+    public static final Settings INSTANCE = new Settings();
+
+    private final Map<String, Account> accounts = new ConcurrentHashMap<>();
+
+    private final boolean firstLaunch;
+
+    private Settings() {
+        firstLaunch = ConfigHolder.CONFIG.firstLaunch.get();
+        ConfigHolder.CONFIG.firstLaunch.set(false);
+
+        loadProxy();
+
+        for (Iterator<Map<Object, Object>> iterator = ConfigHolder.CONFIG.accounts.iterator(); iterator.hasNext();) {
+            Map<Object, Object> settings = iterator.next();
+            AccountFactory<?> factory = Accounts.ACCOUNT_FACTORY.get(tryCast(settings.get("type"), String.class).orElse(""));
+            if (factory == null) {
+                LOG.warning("Unrecognized account type, removing: " + settings);
+                iterator.remove();
+                continue;
+            }
+
+            Account account;
+            try {
+                account = factory.fromStorage(settings, getProxy());
+            } catch (Exception e) {
+                LOG.log(Level.WARNING, "Malformed account storage, removing: " + settings, e);
+                iterator.remove();
+                continue;
+            }
+
+            accounts.put(Accounts.getAccountId(account), account);
+        }
+
+        ConfigHolder.CONFIG.authlibInjectorServers.addListener(onInvalidating(this::removeDanglingAuthlibInjectorAccounts));
+
+        this.selectedAccount.set(accounts.get(ConfigHolder.CONFIG.selectedAccount.get()));
+
+        checkProfileMap();
+
+        save();
+
+        for (Map.Entry<String, Profile> entry2 : getProfileMap().entrySet()) {
+            entry2.getValue().setName(entry2.getKey());
+            entry2.getValue().nameProperty().setChangedListener(this::profileNameChanged);
+            entry2.getValue().addPropertyChangedListener(e -> save());
+        }
+
+        Lang.ignoringException(() -> Runtime.getRuntime().addShutdownHook(new Thread(this::save)));
+    }
+
+    public void save() {
+        ConfigHolder.CONFIG.accounts.clear();
+        for (Account account : accounts.values()) {
+            Map<Object, Object> storage = account.toStorage();
+            storage.put("type", Accounts.getAccountType(account));
+            ConfigHolder.CONFIG.accounts.add(storage);
+        }
+        ConfigHolder.saveConfig(ConfigHolder.CONFIG);
+    }
+
+    public boolean isFirstLaunch() {
+        return firstLaunch;
+    }
+
+    private final StringProperty commonPath = new ImmediateStringProperty(this, "commonPath", ConfigHolder.CONFIG.commonDirectory.get()) {
+        @Override
+        public void invalidated() {
+            super.invalidated();
+
+            ConfigHolder.CONFIG.commonDirectory.set(get());
+            save();
+        }
+    };
+
+    public String getCommonPath() {
+        return commonPath.get();
+    }
+
+    public StringProperty commonPathProperty() {
+        return commonPath;
+    }
+
+    public void setCommonPath(String commonPath) {
+        this.commonPath.set(commonPath);
+    }
+
+    private Locales.SupportedLocale locale = Locales.getLocaleByName(ConfigHolder.CONFIG.localization.get());
+
+    public Locales.SupportedLocale getLocale() {
+        return locale;
+    }
+
+    public void setLocale(Locales.SupportedLocale locale) {
+        this.locale = locale;
+        ConfigHolder.CONFIG.localization.set(Locales.getNameByLocale(locale));
+        save();
+    }
+
+    private Proxy proxy = Proxy.NO_PROXY;
+
+    public Proxy getProxy() {
+        return proxy;
+    }
+
+    private Proxy.Type proxyType = Proxies.getProxyType(ConfigHolder.CONFIG.proxyType.get());
+
+    public Proxy.Type getProxyType() {
+        return proxyType;
+    }
+
+    public void setProxyType(Proxy.Type proxyType) {
+        this.proxyType = proxyType;
+        ConfigHolder.CONFIG.proxyType.set(Proxies.PROXIES.indexOf(proxyType));
+        save();
+        loadProxy();
+    }
+
+    public String getProxyHost() {
+        return ConfigHolder.CONFIG.proxyHost.get();
+    }
+
+    public void setProxyHost(String proxyHost) {
+        ConfigHolder.CONFIG.proxyHost.set(proxyHost);
+        save();
+    }
+
+    public String getProxyPort() {
+        return ConfigHolder.CONFIG.proxyPort.get();
+    }
+
+    public void setProxyPort(String proxyPort) {
+        ConfigHolder.CONFIG.proxyPort.set(proxyPort);
+        save();
+    }
+
+    public String getProxyUser() {
+        return ConfigHolder.CONFIG.proxyUser.get();
+    }
+
+    public void setProxyUser(String proxyUser) {
+        ConfigHolder.CONFIG.proxyUser.set(proxyUser);
+        save();
+    }
+
+    public String getProxyPass() {
+        return ConfigHolder.CONFIG.proxyPass.get();
+    }
+
+    public void setProxyPass(String proxyPass) {
+        ConfigHolder.CONFIG.proxyPass.set(proxyPass);
+        save();
+    }
+
+    public boolean hasProxy() {
+        return ConfigHolder.CONFIG.hasProxy.get();
+    }
+
+    public void setHasProxy(boolean hasProxy) {
+        ConfigHolder.CONFIG.hasProxy.set(hasProxy);
+        save();
+    }
+
+    public boolean hasProxyAuth() {
+        return ConfigHolder.CONFIG.hasProxyAuth.get();
+    }
+
+    public void setHasProxyAuth(boolean hasProxyAuth) {
+        ConfigHolder.CONFIG.hasProxyAuth.set(hasProxyAuth);
+        save();
+    }
+
+    private void loadProxy() {
+        String host = getProxyHost();
+        Integer port = Lang.toIntOrNull(getProxyPort());
+        if (!hasProxy() || StringUtils.isBlank(host) || port == null || getProxyType() == Proxy.Type.DIRECT)
+            proxy = Proxy.NO_PROXY;
+        else {
+            System.setProperty("http.proxyHost", getProxyHost());
+            System.setProperty("http.proxyPort", getProxyPort());
+            proxy = new Proxy(proxyType, new InetSocketAddress(host, port));
+
+            String user = getProxyUser();
+            String pass = getProxyPass();
+            if (hasProxyAuth() && StringUtils.isNotBlank(user) && StringUtils.isNotBlank(pass)) {
+                System.setProperty("http.proxyUser", user);
+                System.setProperty("http.proxyPassword", pass);
+
+                Authenticator.setDefault(new Authenticator() {
+                    @Override
+                    public PasswordAuthentication getPasswordAuthentication() {
+                        return new PasswordAuthentication(user, pass.toCharArray());
+                    }
+                });
+            }
+        }
+    }
+
+    public Font getFont() {
+        return Font.font(ConfigHolder.CONFIG.fontFamily.get(), ConfigHolder.CONFIG.fontSize.get());
+    }
+
+    public void setFont(Font font) {
+        ConfigHolder.CONFIG.fontFamily.set(font.getFamily());
+        ConfigHolder.CONFIG.fontSize.set(font.getSize());
+        save();
+    }
+
+    public int getLogLines() {
+        return Math.max(ConfigHolder.CONFIG.logLines.get(), 100);
+    }
+
+    public void setLogLines(int logLines) {
+        ConfigHolder.CONFIG.logLines.set(logLines);
+        save();
+    }
+
+    /****************************************
+     *           AUTHLIB INJECTORS          *
+     ****************************************/
+
+    /**
+     * After an {@link AuthlibInjectorServer} is removed, the associated accounts should also be removed.
+     * This method performs a check and removes the dangling accounts.
+     * Don't call this before {@link #migrateAuthlibInjectorServers()} is called, otherwise old data would be lost.
+     */
+    private void removeDanglingAuthlibInjectorAccounts() {
+        accounts.values().stream()
+                .filter(AuthlibInjectorAccount.class::isInstance)
+                .filter(it -> !ConfigHolder.CONFIG.authlibInjectorServers.contains(((AuthlibInjectorAccount) it).getServer()))
+                .collect(toList())
+                .forEach(this::deleteAccount);
+    }
+
+    /****************************************
+     *        DOWNLOAD PROVIDERS            *
+     ****************************************/
+
+    public DownloadProvider getDownloadProvider() {
+        return DownloadProviders.getDownloadProvider(ConfigHolder.CONFIG.downloadType.get());
+    }
+
+    public void setDownloadProvider(DownloadProvider downloadProvider) {
+        int index = DownloadProviders.DOWNLOAD_PROVIDERS.indexOf(downloadProvider);
+        if (index == -1)
+            throw new IllegalArgumentException("Unknown download provider: " + downloadProvider);
+        ConfigHolder.CONFIG.downloadType.set(index);
+        save();
+    }
+
+    /****************************************
+     *               ACCOUNTS               *
+     ****************************************/
+
+    private final ImmediateObjectProperty<Account> selectedAccount = new ImmediateObjectProperty<Account>(this, "selectedAccount", null) {
+        @Override
+        public Account get() {
+            Account a = super.get();
+            if (a == null || !accounts.containsKey(Accounts.getAccountId(a))) {
+                Account acc = accounts.values().stream().findAny().orElse(null);
+                set(acc);
+                return acc;
+            } else return a;
+        }
+
+        @Override
+        public void set(Account newValue) {
+            if (newValue == null || accounts.containsKey(Accounts.getAccountId(newValue))) {
+                super.set(newValue);
+            }
+        }
+
+        @Override
+        public void invalidated() {
+            super.invalidated();
+
+            ConfigHolder.CONFIG.selectedAccount.set(getValue() == null ? "" : Accounts.getAccountId(getValue()));
+            save();
+        }
+    };
+
+    public Account getSelectedAccount() {
+        return selectedAccount.get();
+    }
+
+    public ObjectProperty<Account> selectedAccountProperty() {
+        return selectedAccount;
+    }
+
+    public void setSelectedAccount(Account selectedAccount) {
+        this.selectedAccount.set(selectedAccount);
+    }
+
+    public void addAccount(Account account) {
+        accounts.put(Accounts.getAccountId(account), account);
+        onAccountLoading();
+
+        EventBus.EVENT_BUS.fireEvent(new AccountAddedEvent(this, account));
+    }
+
+    public Account getAccount(String name, String character) {
+        return accounts.get(Accounts.getAccountId(name, character));
+    }
+
+    public Collection<Account> getAccounts() {
+        return Collections.unmodifiableCollection(accounts.values());
+    }
+
+    public void deleteAccount(String name, String character) {
+        accounts.remove(Accounts.getAccountId(name, character));
+
+        onAccountLoading();
+        selectedAccount.get();
+    }
+
+    public void deleteAccount(Account account) {
+        accounts.remove(Accounts.getAccountId(account));
+
+        onAccountLoading();
+        selectedAccount.get();
+    }
+
+    /****************************************
+     *              BACKGROUND              *
+     ****************************************/
+
+    private final ImmediateStringProperty backgroundImage = new ImmediateStringProperty(this, "backgroundImage", ConfigHolder.CONFIG.backgroundImage.get()) {
+        @Override
+        public void invalidated() {
+            super.invalidated();
+
+            ConfigHolder.CONFIG.backgroundImage.set(get());
+            save();
+        }
+    };
+
+    public String getBackgroundImage() {
+        return backgroundImage.get();
+    }
+
+    public ImmediateStringProperty backgroundImageProperty() {
+        return backgroundImage;
+    }
+
+    public void setBackgroundImage(String backgroundImage) {
+        this.backgroundImage.set(backgroundImage);
+    }
+
+    private final ImmediateObjectProperty<EnumBackgroundImage> backgroundImageType = new ImmediateObjectProperty<EnumBackgroundImage>(this, "backgroundImageType", EnumBackgroundImage.indexOf(ConfigHolder.CONFIG.backgroundImageType.get())) {
+        @Override
+        public void invalidated() {
+            super.invalidated();
+
+            ConfigHolder.CONFIG.backgroundImageType.set(get().ordinal());
+            save();
+        }
+    };
+
+    public EnumBackgroundImage getBackgroundImageType() {
+        return backgroundImageType.get();
+    }
+
+    public ImmediateObjectProperty<EnumBackgroundImage> backgroundImageTypeProperty() {
+        return backgroundImageType;
+    }
+
+    public void setBackgroundImageType(EnumBackgroundImage backgroundImageType) {
+        this.backgroundImageType.set(backgroundImageType);
+    }
+
+    /****************************************
+     *                THEME                 *
+     ****************************************/
+
+    private final ImmediateObjectProperty<Theme> theme = new ImmediateObjectProperty<Theme>(this, "theme", Theme.getTheme(ConfigHolder.CONFIG.theme.get()).orElse(Theme.BLUE)) {
+        @Override
+        public void invalidated() {
+            super.invalidated();
+
+            ConfigHolder.CONFIG.theme.set(get().getName().toLowerCase());
+            save();
+        }
+    };
+
+    public Theme getTheme() {
+        return theme.get();
+    }
+
+    public void setTheme(Theme theme) {
+        this.theme.set(theme);
+    }
+
+    public ImmediateObjectProperty<Theme> themeProperty() {
+        return theme;
+    }
+
+    /****************************************
+     *               PROFILES               *
+     ****************************************/
+
+    public Profile getSelectedProfile() {
+        checkProfileMap();
+
+        if (!hasProfile(ConfigHolder.CONFIG.selectedProfile.get())) {
+            getProfileMap().keySet().stream().findFirst().ifPresent(selectedProfile -> {
+                ConfigHolder.CONFIG.selectedProfile.set(selectedProfile);
+                save();
+            });
+            Schedulers.computation().schedule(this::onProfileChanged);
+        }
+        return getProfile(ConfigHolder.CONFIG.selectedProfile.get());
+    }
+
+    public void setSelectedProfile(Profile selectedProfile) {
+        if (hasProfile(selectedProfile.getName()) && !Objects.equals(selectedProfile.getName(), ConfigHolder.CONFIG.selectedProfile.get())) {
+            ConfigHolder.CONFIG.selectedProfile.set(selectedProfile.getName());
+            save();
+            Schedulers.computation().schedule(this::onProfileChanged);
+        }
+    }
+
+    public Profile getProfile(String name) {
+        checkProfileMap();
+
+        Optional<Profile> p = name == null ? getProfileMap().values().stream().findFirst() : Optional.ofNullable(getProfileMap().get(name));
+        return p.orElse(null);
+    }
+
+    public boolean hasProfile(String name) {
+        return getProfileMap().containsKey(name);
+    }
+
+    public Map<String, Profile> getProfileMap() {
+        return ConfigHolder.CONFIG.configurations;
+    }
+
+    public Collection<Profile> getProfiles() {
+        return getProfileMap().values().stream().filter(t -> StringUtils.isNotBlank(t.getName())).collect(Collectors.toList());
+    }
+
+    public void putProfile(Profile ver) {
+        if (StringUtils.isBlank(ver.getName()))
+            throw new IllegalArgumentException("Profile's name is empty");
+
+        getProfileMap().put(ver.getName(), ver);
+        Schedulers.computation().schedule(this::onProfileLoading);
+
+        ver.nameProperty().setChangedListener(this::profileNameChanged);
+
+        save();
+    }
+
+    public void deleteProfile(Profile profile) {
+        deleteProfile(profile.getName());
+    }
+
+    public void deleteProfile(String profileName) {
+        getProfileMap().remove(profileName);
+        checkProfileMap();
+        Schedulers.computation().schedule(this::onProfileLoading);
+    }
+
+    private void checkProfileMap() {
+        if (getProfileMap().isEmpty()) {
+            getProfileMap().put(Profiles.DEFAULT_PROFILE, new Profile(Profiles.DEFAULT_PROFILE));
+            getProfileMap().put(Profiles.HOME_PROFILE, new Profile(Profiles.HOME_PROFILE, Launcher.MINECRAFT_DIRECTORY));
+        }
+    }
+
+    private void onProfileChanged() {
+        EventBus.EVENT_BUS.fireEvent(new ProfileChangedEvent(this, getSelectedProfile()));
+        getSelectedProfile().getRepository().refreshVersionsAsync().start();
+    }
+
+    private void profileNameChanged(ObservableValue<? extends String> observableValue, String oldValue, String newValue) {
+        getProfileMap().put(newValue, getProfileMap().remove(oldValue));
+    }
+
+    /**
+     * Start profiles loading process.
+     * Invoked by loading GUI phase.
+     */
+    public void onProfileLoading() {
+        EventBus.EVENT_BUS.fireEvent(new ProfileLoadingEvent(this, getProfiles()));
+        onProfileChanged();
+    }
+
+    public void onAccountLoading() {
+        EventBus.EVENT_BUS.fireEvent(new AccountLoadingEvent(this, getAccounts()));
+    }
+
+    public Config getRawConfig() {
+        return ConfigHolder.CONFIG.clone();
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/Theme.java

@@ -0,0 +1,130 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+import javafx.beans.binding.Bindings;
+import javafx.beans.binding.ObjectBinding;
+import javafx.scene.paint.Color;
+import org.jackhuang.hmcl.util.FileUtils;
+import org.jackhuang.hmcl.util.IOUtils;
+import org.jackhuang.hmcl.util.Logging;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Optional;
+import java.util.logging.Level;
+
+public class Theme {
+    public static final Theme BLUE = new Theme("blue", "#5C6BC0");
+    public static final Theme DARK_BLUE = new Theme("dark_blue", "#283593");
+    public static final Theme GREEN = new Theme("green", "#43A047");
+    public static final Theme ORANGE = new Theme("orange", "#E67E22");
+    public static final Theme PURPLE = new Theme("purple", "#9C27B0");
+    public static final Theme RED = new Theme("red", "#F44336");
+
+    public static final Theme[] VALUES = new Theme[]{BLUE, DARK_BLUE, GREEN, ORANGE, PURPLE, RED};
+
+    private final String color;
+    private final String name;
+
+    Theme(String name, String color) {
+        this.name = name;
+        this.color = color;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public String getColor() {
+        return color;
+    }
+
+    public boolean isCustom() {
+        return name.startsWith("#");
+    }
+
+    public boolean isLight() {
+        return Color.web(color).grayscale().getRed() >= 0.5;
+    }
+
+    public Color getForegroundColor() {
+        return isLight() ? Color.BLACK : Color.WHITE;
+    }
+
+    public String[] getStylesheets() {
+        String name = isCustom() ? BLUE.getName() : this.name;
+        String css = Theme.class.getResource("/assets/css/" + name + ".css").toExternalForm();
+        try {
+            File temp = File.createTempFile("hmcl", ".css");
+            FileUtils.writeText(temp, IOUtils.readFullyAsString(Theme.class.getResourceAsStream("/assets/css/custom.css"))
+                    .replace("%base-color%", color)
+                    .replace("%font-color%", getColorDisplayName(getForegroundColor())));
+            css = temp.toURI().toString();
+        } catch (IOException e) {
+            Logging.LOG.log(Level.SEVERE, "Unable to create theme stylesheet", e);
+        }
+
+        return new String[]{
+                Theme.class.getResource("/css/jfoenix-fonts.css").toExternalForm(),
+                Theme.class.getResource("/css/jfoenix-design.css").toExternalForm(),
+                css,
+                Theme.class.getResource("/assets/css/root.css").toExternalForm()
+        };
+    }
+
+    public static Theme custom(String color) {
+        if (!color.startsWith("#"))
+            throw new IllegalArgumentException();
+        return new Theme(color, color);
+    }
+
+    public static Optional<Theme> getTheme(String name) {
+        if (name == null)
+            return Optional.empty();
+
+        for (Theme theme : VALUES)
+            if (theme.name.equalsIgnoreCase(name))
+                return Optional.of(theme);
+
+        if (name.startsWith("#"))
+            try {
+                Color.web(name);
+                return Optional.of(custom(name));
+            } catch (IllegalArgumentException ignore) {
+            }
+
+        return Optional.empty();
+    }
+
+    public static String getColorDisplayName(Color c) {
+        return c != null ? String.format("#%02x%02x%02x", Math.round(c.getRed() * 255.0D), Math.round(c.getGreen() * 255.0D), Math.round(c.getBlue() * 255.0D)).toUpperCase() : null;
+    }
+
+    public static ObjectBinding<Color> foregroundFillBinding() {
+        return Bindings.createObjectBinding(() -> Settings.INSTANCE.getTheme().getForegroundColor(), Settings.INSTANCE.themeProperty());
+    }
+
+    public static ObjectBinding<Color> blackFillBinding() {
+        return Bindings.createObjectBinding(() -> Color.BLACK);
+    }
+
+    public static ObjectBinding<Color> whiteFillBinding() {
+        return Bindings.createObjectBinding(() -> Color.WHITE);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/setting/VersionSetting.java

@@ -0,0 +1,614 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.setting;
+
+import com.google.gson.*;
+import javafx.beans.InvalidationListener;
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.game.LaunchOptions;
+import org.jackhuang.hmcl.util.*;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.List;
+import java.util.Optional;
+import java.util.stream.Collectors;
+
+/**
+ *
+ * @author huangyuhui
+ */
+public final class VersionSetting {
+
+    public transient String id;
+
+    private boolean global = false;
+
+    public boolean isGlobal() {
+        return global;
+    }
+
+    public void setGlobal(boolean global) {
+        this.global = global;
+    }
+
+    private final ImmediateBooleanProperty usesGlobalProperty = new ImmediateBooleanProperty(this, "usesGlobal", false);
+
+    public ImmediateBooleanProperty usesGlobalProperty() {
+        return usesGlobalProperty;
+    }
+
+    /**
+     * HMCL Version Settings have been divided into 2 parts.
+     * 1. Global settings.
+     * 2. Version settings.
+     * If a version claims that it uses global settings, its version setting will be disabled.
+     *
+     * Defaults false because if one version uses global first, custom version file will not be generated.
+     */
+    public boolean isUsesGlobal() {
+        return usesGlobalProperty.get();
+    }
+
+    public void setUsesGlobal(boolean usesGlobal) {
+        usesGlobalProperty.set(usesGlobal);
+    }
+
+    // java
+
+    private final ImmediateStringProperty javaProperty = new ImmediateStringProperty(this, "java", "");
+
+    public ImmediateStringProperty javaProperty() {
+        return javaProperty;
+    }
+
+    /**
+     * Java version or null if user customizes java directory.
+     */
+    public String getJava() {
+        return javaProperty.get();
+    }
+
+    public void setJava(String java) {
+        javaProperty.set(java);
+    }
+
+    private final ImmediateStringProperty defaultJavaPathProperty = new ImmediateStringProperty(this, "defaultJavaPath", "");
+
+    /**
+     * Path to Java executable, or null if user customizes java directory.
+     * It's used to determine which JRE to use when multiple JREs match the selected Java version.
+     */
+    public String getDefaultJavaPath() {
+        return defaultJavaPathProperty.get();
+    }
+
+    public void setDefaultJavaPath(String defaultJavaPath) {
+        defaultJavaPathProperty.set(defaultJavaPath);
+    }
+
+    private final ImmediateStringProperty javaDirProperty = new ImmediateStringProperty(this, "javaDir", "");
+
+    public ImmediateStringProperty javaDirProperty() {
+        return javaDirProperty;
+    }
+
+    /**
+     * User customized java directory or null if user uses system Java.
+     */
+    public String getJavaDir() {
+        return javaDirProperty.get();
+    }
+
+    public void setJavaDir(String javaDir) {
+        javaDirProperty.set(javaDir);
+    }
+
+    private final ImmediateStringProperty wrapperProperty = new ImmediateStringProperty(this, "wrapper", "");
+
+    public ImmediateStringProperty wrapperProperty() {
+        return wrapperProperty;
+    }
+
+    /**
+     * The command to launch java, i.e. optirun.
+     */
+    public String getWrapper() {
+        return wrapperProperty.get();
+    }
+
+    public void setWrapper(String wrapper) {
+        wrapperProperty.set(wrapper);
+    }
+
+    private final ImmediateStringProperty permSizeProperty = new ImmediateStringProperty(this, "permSize", "");
+
+    public ImmediateStringProperty permSizeProperty() {
+        return permSizeProperty;
+    }
+
+    /**
+     * The permanent generation size of JVM garbage collection.
+     */
+    public String getPermSize() {
+        return permSizeProperty.get();
+    }
+
+    public void setPermSize(String permSize) {
+        permSizeProperty.set(permSize);
+    }
+
+    private final ImmediateIntegerProperty maxMemoryProperty = new ImmediateIntegerProperty(this, "maxMemory", OperatingSystem.SUGGESTED_MEMORY);
+
+    public ImmediateIntegerProperty maxMemoryProperty() {
+        return maxMemoryProperty;
+    }
+
+    /**
+     * The maximum memory/MB that JVM can allocate for heap.
+     */
+    public int getMaxMemory() {
+        return maxMemoryProperty.get();
+    }
+
+    public void setMaxMemory(int maxMemory) {
+        maxMemoryProperty.set(maxMemory);
+    }
+
+    /**
+     * The minimum memory that JVM can allocate for heap.
+     */
+    private final ImmediateObjectProperty<Integer> minMemoryProperty = new ImmediateObjectProperty<>(this, "minMemory", null);
+
+    public ImmediateObjectProperty<Integer> minMemoryProperty() {
+        return minMemoryProperty;
+    }
+
+    public Integer getMinMemory() {
+        return minMemoryProperty.get();
+    }
+
+    public void setMinMemory(Integer minMemory) {
+        minMemoryProperty.set(minMemory);
+    }
+
+    private final ImmediateStringProperty preLaunchCommandProperty = new ImmediateStringProperty(this, "precalledCommand", "");
+
+    public ImmediateStringProperty preLaunchCommandProperty() {
+        return preLaunchCommandProperty;
+    }
+
+    /**
+     * The command that will be executed before launching the Minecraft.
+     * Operating system relevant.
+     */
+    public String getPreLaunchCommand() {
+        return preLaunchCommandProperty.get();
+    }
+
+    public void setPreLaunchCommand(String preLaunchCommand) {
+        preLaunchCommandProperty.set(preLaunchCommand);
+    }
+
+    // options
+
+    private final ImmediateStringProperty javaArgsProperty = new ImmediateStringProperty(this, "javaArgs", "");
+
+    public ImmediateStringProperty javaArgsProperty() {
+        return javaArgsProperty;
+    }
+
+    /**
+     * The user customized arguments passed to JVM.
+     */
+    public String getJavaArgs() {
+        return javaArgsProperty.get();
+    }
+
+    public void setJavaArgs(String javaArgs) {
+        javaArgsProperty.set(javaArgs);
+    }
+
+    private final ImmediateStringProperty minecraftArgsProperty = new ImmediateStringProperty(this, "minecraftArgs", "");
+
+    public ImmediateStringProperty minecraftArgsProperty() {
+        return minecraftArgsProperty;
+    }
+
+    /**
+     * The user customized arguments passed to Minecraft.
+     */
+    public String getMinecraftArgs() {
+        return minecraftArgsProperty.get();
+    }
+
+    public void setMinecraftArgs(String minecraftArgs) {
+        minecraftArgsProperty.set(minecraftArgs);
+    }
+
+    private final ImmediateBooleanProperty noJVMArgsProperty = new ImmediateBooleanProperty(this, "noJVMArgs", false);
+
+    public ImmediateBooleanProperty noJVMArgsProperty() {
+        return noJVMArgsProperty;
+    }
+
+    /**
+     * True if disallow HMCL use default JVM arguments.
+     */
+    public boolean isNoJVMArgs() {
+        return noJVMArgsProperty.get();
+    }
+
+    public void setNoJVMArgs(boolean noJVMArgs) {
+        noJVMArgsProperty.set(noJVMArgs);
+    }
+
+    private final ImmediateBooleanProperty notCheckGameProperty = new ImmediateBooleanProperty(this, "notCheckGame", false);
+
+    public ImmediateBooleanProperty notCheckGameProperty() {
+        return notCheckGameProperty;
+    }
+
+    /**
+     * True if HMCL does not check game's completeness.
+     */
+    public boolean isNotCheckGame() {
+        return notCheckGameProperty.get();
+    }
+
+    public void setNotCheckGame(boolean notCheckGame) {
+        notCheckGameProperty.set(notCheckGame);
+    }
+
+    private final ImmediateBooleanProperty noCommonProperty = new ImmediateBooleanProperty(this, "noCommon", false);
+
+    public ImmediateBooleanProperty noCommonProperty() {
+        return noCommonProperty;
+    }
+
+    /**
+     * True if HMCL does not find/download libraries in/to common path.
+     */
+    public boolean isNoCommon() {
+        return noCommonProperty.get();
+    }
+
+    public void setNoCommon(boolean noCommon) {
+        noCommonProperty.set(noCommon);
+    }
+
+    private final ImmediateBooleanProperty showLogsProperty = new ImmediateBooleanProperty(this, "showLogs", false);
+
+    public ImmediateBooleanProperty showLogsProperty() {
+        return showLogsProperty;
+    }
+
+    /**
+     * True if show the logs after game launched.
+     */
+    public boolean isShowLogs() {
+        return showLogsProperty.get();
+    }
+
+    public void setShowLogs(boolean showLogs) {
+        showLogsProperty.set(showLogs);
+    }
+
+    // Minecraft settings.
+
+    private final ImmediateStringProperty serverIpProperty = new ImmediateStringProperty(this, "serverIp", "");
+
+    public ImmediateStringProperty serverIpProperty() {
+        return serverIpProperty;
+    }
+
+    /**
+     * The server ip that will be entered after Minecraft successfully loaded immediately.
+     *
+     * Format: ip:port or without port.
+     */
+    public String getServerIp() {
+        return serverIpProperty.get();
+    }
+
+    public void setServerIp(String serverIp) {
+        serverIpProperty.set(serverIp);
+    }
+
+
+    private final ImmediateBooleanProperty fullscreenProperty = new ImmediateBooleanProperty(this, "fullscreen", false);
+
+    public ImmediateBooleanProperty fullscreenProperty() {
+        return fullscreenProperty;
+    }
+
+    /**
+     * True if Minecraft started in fullscreen mode.
+     */
+    public boolean isFullscreen() {
+        return fullscreenProperty.get();
+    }
+
+    public void setFullscreen(boolean fullscreen) {
+        fullscreenProperty.set(fullscreen);
+    }
+
+    private final ImmediateIntegerProperty widthProperty = new ImmediateIntegerProperty(this, "width", 854);
+
+    public ImmediateIntegerProperty widthProperty() {
+        return widthProperty;
+    }
+
+    /**
+     * The width of Minecraft window, defaults 800.
+     *
+     * The field saves int value.
+     * String type prevents unexpected value from JsonParseException.
+     * We can only reset this field instead of recreating the whole setting file.
+     */
+    public int getWidth() {
+        return widthProperty.get();
+    }
+
+    public void setWidth(int width) {
+        widthProperty.set(width);
+    }
+
+
+    private final ImmediateIntegerProperty heightProperty = new ImmediateIntegerProperty(this, "height", 480);
+
+    public ImmediateIntegerProperty heightProperty() {
+        return heightProperty;
+    }
+
+    /**
+     * The height of Minecraft window, defaults 480.
+     *
+     * The field saves int value.
+     * String type prevents unexpected value from JsonParseException.
+     * We can only reset this field instead of recreating the whole setting file.
+     */
+    public int getHeight() {
+        return heightProperty.get();
+    }
+
+    public void setHeight(int height) {
+        heightProperty.set(height);
+    }
+
+    /**
+     * 0 - .minecraft<br/>
+     * 1 - .minecraft/versions/&lt;version&gt;/<br/>
+     */
+    private final ImmediateObjectProperty<EnumGameDirectory> gameDirTypeProperty = new ImmediateObjectProperty<>(this, "gameDirType", EnumGameDirectory.ROOT_FOLDER);
+
+    public ImmediateObjectProperty<EnumGameDirectory> gameDirTypeProperty() {
+        return gameDirTypeProperty;
+    }
+
+    public EnumGameDirectory getGameDirType() {
+        return gameDirTypeProperty.get();
+    }
+
+    public void setGameDirType(EnumGameDirectory gameDirType) {
+        gameDirTypeProperty.set(gameDirType);
+    }
+
+    /**
+     * Your custom gameDir
+     */
+    private final ImmediateStringProperty gameDirProperty = new ImmediateStringProperty(this, "gameDir", "");
+
+    public ImmediateStringProperty gameDirProperty() {
+        return gameDirProperty;
+    }
+
+    public String getGameDir() {
+        return gameDirProperty.get();
+    }
+
+    public void setGameDir(String gameDir) {
+        gameDirProperty.set(gameDir);
+    }
+
+    // launcher settings
+
+    /**
+     * 0 - Close the launcher when the game starts.<br/>
+     * 1 - Hide the launcher when the game starts.<br/>
+     * 2 - Keep the launcher open.<br/>
+     */
+    private final ImmediateObjectProperty<LauncherVisibility> launcherVisibilityProperty = new ImmediateObjectProperty<>(this, "launcherVisibility", LauncherVisibility.HIDE);
+
+    public ImmediateObjectProperty<LauncherVisibility> launcherVisibilityProperty() {
+        return launcherVisibilityProperty;
+    }
+
+    public LauncherVisibility getLauncherVisibility() {
+        return launcherVisibilityProperty.get();
+    }
+
+    public void setLauncherVisibility(LauncherVisibility launcherVisibility) {
+        launcherVisibilityProperty.set(launcherVisibility);
+    }
+
+    public JavaVersion getJavaVersion() throws InterruptedException {
+        // TODO: lazy initialization may result in UI suspension.
+        if (StringUtils.isBlank(getJava()))
+            setJava(StringUtils.isBlank(getJavaDir()) ? "Default" : "Custom");
+        if ("Default".equals(getJava())) return JavaVersion.fromCurrentEnvironment();
+        else if ("Custom".equals(getJava())) {
+            try {
+                return JavaVersion.fromExecutable(new File(getJavaDir()));
+            } catch (IOException e) {
+                return null; // Custom Java Directory not found,
+            }
+        } else if (StringUtils.isNotBlank(getJava())) {
+            List<JavaVersion> matchedJava = JavaVersion.getJREs().stream()
+                    .filter(java -> java.getVersion().equals(getJava()))
+                    .collect(Collectors.toList());
+            if (matchedJava.isEmpty()) {
+                setJava("Default");
+                return JavaVersion.fromCurrentEnvironment();
+            } else {
+                return matchedJava.stream()
+                        .filter(java -> java.getBinary().toString().equals(getDefaultJavaPath()))
+                        .findFirst()
+                        .orElse(matchedJava.get(0));
+            }
+        } else throw new Error();
+    }
+
+    public void addPropertyChangedListener(InvalidationListener listener) {
+        usesGlobalProperty.addListener(listener);
+        javaProperty.addListener(listener);
+        javaDirProperty.addListener(listener);
+        wrapperProperty.addListener(listener);
+        permSizeProperty.addListener(listener);
+        maxMemoryProperty.addListener(listener);
+        minMemoryProperty.addListener(listener);
+        preLaunchCommandProperty.addListener(listener);
+        javaArgsProperty.addListener(listener);
+        minecraftArgsProperty.addListener(listener);
+        noJVMArgsProperty.addListener(listener);
+        notCheckGameProperty.addListener(listener);
+        noCommonProperty.addListener(listener);
+        showLogsProperty.addListener(listener);
+        serverIpProperty.addListener(listener);
+        fullscreenProperty.addListener(listener);
+        widthProperty.addListener(listener);
+        heightProperty.addListener(listener);
+        gameDirTypeProperty.addListener(listener);
+        gameDirProperty.addListener(listener);
+        launcherVisibilityProperty.addListener(listener);
+        defaultJavaPathProperty.addListener(listener);
+    }
+
+    public LaunchOptions toLaunchOptions(File gameDir) throws InterruptedException {
+        JavaVersion javaVersion = Optional.ofNullable(getJavaVersion()).orElse(JavaVersion.fromCurrentEnvironment());
+        return new LaunchOptions.Builder()
+                .setGameDir(gameDir)
+                .setJava(javaVersion)
+                .setVersionName(Launcher.TITLE)
+                .setProfileName(Launcher.TITLE)
+                .setMinecraftArgs(getMinecraftArgs())
+                .setJavaArgs(getJavaArgs())
+                .setMaxMemory(getMaxMemory())
+                .setMinMemory(getMinMemory())
+                .setMetaspace(Lang.toIntOrNull(getPermSize()))
+                .setWidth(getWidth())
+                .setHeight(getHeight())
+                .setFullscreen(isFullscreen())
+                .setServerIp(getServerIp())
+                .setWrapper(getWrapper())
+                .setProxyHost(Settings.INSTANCE.getProxyHost())
+                .setProxyPort(Settings.INSTANCE.getProxyPort())
+                .setProxyUser(Settings.INSTANCE.getProxyUser())
+                .setProxyPass(Settings.INSTANCE.getProxyPass())
+                .setPrecalledCommand(getPreLaunchCommand())
+                .setNoGeneratedJVMArgs(isNoJVMArgs())
+                .create();
+    }
+
+    public static class Serializer implements JsonSerializer<VersionSetting>, JsonDeserializer<VersionSetting> {
+        public static final Serializer INSTANCE = new Serializer();
+
+        private Serializer() {
+        }
+
+        @Override
+        public JsonElement serialize(VersionSetting src, Type typeOfSrc, JsonSerializationContext context) {
+            if (src == null) return JsonNull.INSTANCE;
+            JsonObject obj = new JsonObject();
+
+            obj.addProperty("usesGlobal", src.isUsesGlobal());
+            obj.addProperty("javaArgs", src.getJavaArgs());
+            obj.addProperty("minecraftArgs", src.getMinecraftArgs());
+            obj.addProperty("maxMemory", src.getMaxMemory() <= 0 ? OperatingSystem.SUGGESTED_MEMORY : src.getMaxMemory());
+            obj.addProperty("minMemory", src.getMinMemory());
+            obj.addProperty("permSize", src.getPermSize());
+            obj.addProperty("width", src.getWidth());
+            obj.addProperty("height", src.getHeight());
+            obj.addProperty("javaDir", src.getJavaDir());
+            obj.addProperty("precalledCommand", src.getPreLaunchCommand());
+            obj.addProperty("serverIp", src.getServerIp());
+            obj.addProperty("java", src.getJava());
+            obj.addProperty("wrapper", src.getWrapper());
+            obj.addProperty("fullscreen", src.isFullscreen());
+            obj.addProperty("noJVMArgs", src.isNoJVMArgs());
+            obj.addProperty("notCheckGame", src.isNotCheckGame());
+            obj.addProperty("noCommon", src.isNoCommon());
+            obj.addProperty("showLogs", src.isShowLogs());
+            obj.addProperty("gameDir", src.getGameDir());
+            obj.addProperty("launcherVisibility", src.getLauncherVisibility().ordinal());
+            obj.addProperty("gameDirType", src.getGameDirType().ordinal());
+            obj.addProperty("defaultJavaPath", src.getDefaultJavaPath());
+
+            return obj;
+        }
+
+        @Override
+        public VersionSetting deserialize(JsonElement json, Type typeOfT, JsonDeserializationContext context) throws JsonParseException {
+            if (json == null || json == JsonNull.INSTANCE || !(json instanceof JsonObject))
+                return null;
+            JsonObject obj = (JsonObject) json;
+
+            int maxMemoryN = parseJsonPrimitive(Optional.ofNullable(obj.get("maxMemory")).map(JsonElement::getAsJsonPrimitive).orElse(null), OperatingSystem.SUGGESTED_MEMORY);
+            if (maxMemoryN <= 0) maxMemoryN = OperatingSystem.SUGGESTED_MEMORY;
+
+            VersionSetting vs = new VersionSetting();
+
+            vs.setUsesGlobal(Optional.ofNullable(obj.get("usesGlobal")).map(JsonElement::getAsBoolean).orElse(false));
+            vs.setJavaArgs(Optional.ofNullable(obj.get("javaArgs")).map(JsonElement::getAsString).orElse(""));
+            vs.setMinecraftArgs(Optional.ofNullable(obj.get("minecraftArgs")).map(JsonElement::getAsString).orElse(""));
+            vs.setMaxMemory(maxMemoryN);
+            vs.setMinMemory(Optional.ofNullable(obj.get("minMemory")).map(JsonElement::getAsInt).orElse(null));
+            vs.setPermSize(Optional.ofNullable(obj.get("permSize")).map(JsonElement::getAsString).orElse(""));
+            vs.setWidth(Optional.ofNullable(obj.get("width")).map(JsonElement::getAsJsonPrimitive).map(this::parseJsonPrimitive).orElse(0));
+            vs.setHeight(Optional.ofNullable(obj.get("height")).map(JsonElement::getAsJsonPrimitive).map(this::parseJsonPrimitive).orElse(0));
+            vs.setJavaDir(Optional.ofNullable(obj.get("javaDir")).map(JsonElement::getAsString).orElse(""));
+            vs.setPreLaunchCommand(Optional.ofNullable(obj.get("precalledCommand")).map(JsonElement::getAsString).orElse(""));
+            vs.setServerIp(Optional.ofNullable(obj.get("serverIp")).map(JsonElement::getAsString).orElse(""));
+            vs.setJava(Optional.ofNullable(obj.get("java")).map(JsonElement::getAsString).orElse(""));
+            vs.setWrapper(Optional.ofNullable(obj.get("wrapper")).map(JsonElement::getAsString).orElse(""));
+            vs.setGameDir(Optional.ofNullable(obj.get("gameDir")).map(JsonElement::getAsString).orElse(""));
+            vs.setFullscreen(Optional.ofNullable(obj.get("fullscreen")).map(JsonElement::getAsBoolean).orElse(false));
+            vs.setNoJVMArgs(Optional.ofNullable(obj.get("noJVMArgs")).map(JsonElement::getAsBoolean).orElse(false));
+            vs.setNotCheckGame(Optional.ofNullable(obj.get("notCheckGame")).map(JsonElement::getAsBoolean).orElse(false));
+            vs.setNoCommon(Optional.ofNullable(obj.get("noCommon")).map(JsonElement::getAsBoolean).orElse(false));
+            vs.setShowLogs(Optional.ofNullable(obj.get("showLogs")).map(JsonElement::getAsBoolean).orElse(false));
+            vs.setLauncherVisibility(LauncherVisibility.values()[Optional.ofNullable(obj.get("launcherVisibility")).map(JsonElement::getAsInt).orElse(1)]);
+            vs.setGameDirType(EnumGameDirectory.values()[Optional.ofNullable(obj.get("gameDirType")).map(JsonElement::getAsInt).orElse(0)]);
+            vs.setDefaultJavaPath(Optional.ofNullable(obj.get("defaultJavaPath")).map(JsonElement::getAsString).orElse(null));
+
+            return vs;
+        }
+
+        private int parseJsonPrimitive(JsonPrimitive primitive) {
+            return parseJsonPrimitive(primitive, 0);
+        }
+
+        private int parseJsonPrimitive(JsonPrimitive primitive, int defaultValue) {
+            if (primitive.isNumber())
+                return primitive.getAsInt();
+            else
+                return Lang.parseInt(primitive.getAsString(), defaultValue);
+        }
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/AccountLoginPane.java

@@ -0,0 +1,87 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.JFXPasswordField;
+import com.jfoenix.controls.JFXProgressBar;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.layout.StackPane;
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.auth.AuthInfo;
+import org.jackhuang.hmcl.auth.NoSelectedCharacterException;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.construct.DialogCloseEvent;
+
+import java.util.function.Consumer;
+
+public class AccountLoginPane extends StackPane {
+    private final Account oldAccount;
+    private final Consumer<AuthInfo> success;
+    private final Runnable failed;
+
+    @FXML
+    private Label lblUsername;
+    @FXML private JFXPasswordField txtPassword;
+    @FXML private Label lblCreationWarning;
+    @FXML private JFXProgressBar progressBar;
+
+    public AccountLoginPane(Account oldAccount, Consumer<AuthInfo> success, Runnable failed) {
+        this.oldAccount = oldAccount;
+        this.success = success;
+        this.failed = failed;
+
+        FXUtils.loadFXML(this, "/assets/fxml/account-login.fxml");
+
+        lblUsername.setText(oldAccount.getUsername());
+        txtPassword.setOnAction(e -> onAccept());
+    }
+
+    @FXML
+    private void onAccept() {
+        String password = txtPassword.getText();
+        progressBar.setVisible(true);
+        lblCreationWarning.setText("");
+        Task.ofResult("login", () -> {
+            try {
+                return oldAccount.logInWithPassword(password);
+            } catch (Exception e) {
+                return e;
+            }
+        }).subscribe(Schedulers.javafx(), variable -> {
+            Object account = variable.get("login");
+            if (account instanceof AuthInfo) {
+                success.accept(((AuthInfo) account));
+                fireEvent(new DialogCloseEvent());
+            } else if (account instanceof NoSelectedCharacterException) {
+                fireEvent(new DialogCloseEvent());
+            } else if (account instanceof Exception) {
+                lblCreationWarning.setText(AddAccountPane.accountException((Exception) account));
+            }
+
+            progressBar.setVisible(false);
+        });
+    }
+
+    @FXML
+    private void onCancel() {
+        failed.run();
+        fireEvent(new DialogCloseEvent());
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/AccountPage.java

@@ -0,0 +1,152 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2017  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXProgressBar;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.image.Image;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.StackPane;
+
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorAccount;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorServer;
+import org.jackhuang.hmcl.auth.offline.OfflineAccount;
+import org.jackhuang.hmcl.auth.yggdrasil.YggdrasilAccount;
+import org.jackhuang.hmcl.game.AccountHelper;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.setting.Theme;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.ui.construct.ComponentList;
+import org.jackhuang.hmcl.ui.wizard.DecoratorPage;
+
+import static org.jackhuang.hmcl.ui.FXUtils.installTooltip;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Optional;
+
+public class AccountPage extends StackPane implements DecoratorPage {
+    private final StringProperty title;
+    private final ObjectProperty<Runnable> onDelete = new SimpleObjectProperty<>(this, "onDelete");
+    private final VersionListItem item;
+    private final Account account;
+
+    @FXML
+    private Label lblType;
+    @FXML
+    private Label lblServer;
+    @FXML
+    private Label lblCharacter;
+    @FXML
+    private Label lblEmail;
+    @FXML
+    private BorderPane paneServer;
+    @FXML
+    private BorderPane paneEmail;
+    @FXML
+    private ComponentList componentList;
+    @FXML
+    private JFXButton btnDelete;
+    @FXML
+    private JFXButton btnRefresh;
+    @FXML
+    private JFXProgressBar progressBar;
+
+    public AccountPage(Account account, VersionListItem item) {
+        this.account = account;
+        this.item = item;
+
+        title = new SimpleStringProperty(this, "title", i18n("account") + " - " + account.getCharacter());
+
+        FXUtils.loadFXML(this, "/assets/fxml/account.fxml");
+
+        if (account instanceof AuthlibInjectorAccount) {
+            AuthlibInjectorServer server = ((AuthlibInjectorAccount) account).getServer();
+            lblServer.setText(server.getName());
+            installTooltip(lblServer, server.getUrl());
+        } else {
+            componentList.removeChildren(paneServer);
+
+            if (account instanceof OfflineAccount) {
+                componentList.removeChildren(paneEmail);
+            }
+        }
+
+        btnDelete.setGraphic(SVG.delete(Theme.blackFillBinding(), 15, 15));
+        btnRefresh.setGraphic(SVG.refresh(Theme.blackFillBinding(), 15, 15));
+
+        lblCharacter.setText(account.getCharacter());
+        lblType.setText(AddAccountPane.accountType(account));
+        lblEmail.setText(account.getUsername());
+
+        btnRefresh.setVisible(account instanceof YggdrasilAccount);
+    }
+
+    @FXML
+    private void onDelete() {
+        Settings.INSTANCE.deleteAccount(account);
+        Optional.ofNullable(onDelete.get()).ifPresent(Runnable::run);
+    }
+
+    @FXML
+    private void onRefresh() {
+        if (account instanceof YggdrasilAccount) {
+            progressBar.setVisible(true);
+            AccountHelper.refreshSkinAsync((YggdrasilAccount) account)
+                    .finalized(Schedulers.javafx(), (variables, isDependentsSucceeded) -> {
+                        progressBar.setVisible(false);
+
+                        if (isDependentsSucceeded) {
+                            Image image = AccountHelper.getSkin((YggdrasilAccount) account, 4);
+                            item.setImage(image, AccountHelper.getViewport(4));
+                        }
+                    }).start();
+        }
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    @Override
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+
+    public Runnable getOnDelete() {
+        return onDelete.get();
+    }
+
+    public ObjectProperty<Runnable> onDeleteProperty() {
+        return onDelete;
+    }
+
+    public void setOnDelete(Runnable onDelete) {
+        this.onDelete.set(onDelete);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/AddAccountPane.java

@@ -0,0 +1,282 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2017  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import com.jfoenix.controls.*;
+
+import javafx.beans.binding.Bindings;
+import javafx.beans.property.ReadOnlyIntegerProperty;
+import javafx.fxml.FXML;
+import javafx.geometry.Pos;
+import javafx.scene.control.Hyperlink;
+import javafx.scene.control.Label;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.StackPane;
+
+import org.jackhuang.hmcl.auth.*;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorAccount;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorServer;
+import org.jackhuang.hmcl.auth.offline.OfflineAccount;
+import org.jackhuang.hmcl.auth.yggdrasil.GameProfile;
+import org.jackhuang.hmcl.auth.yggdrasil.RemoteAuthenticationException;
+import org.jackhuang.hmcl.auth.yggdrasil.YggdrasilAccount;
+import org.jackhuang.hmcl.game.AccountHelper;
+import org.jackhuang.hmcl.setting.Accounts;
+import org.jackhuang.hmcl.setting.ConfigHolder;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.construct.AdvancedListBox;
+import org.jackhuang.hmcl.ui.construct.DialogCloseEvent;
+import org.jackhuang.hmcl.ui.construct.IconedItem;
+import org.jackhuang.hmcl.ui.construct.SpinnerPane;
+import org.jackhuang.hmcl.ui.construct.Validator;
+import org.jackhuang.hmcl.util.Constants;
+import org.jackhuang.hmcl.util.Logging;
+import static org.jackhuang.hmcl.ui.FXUtils.jfxListCellFactory;
+import static org.jackhuang.hmcl.ui.FXUtils.onInvalidating;
+import static org.jackhuang.hmcl.ui.FXUtils.stringConverter;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.CountDownLatch;
+import java.util.logging.Level;
+
+public class AddAccountPane extends StackPane {
+
+    @FXML private JFXTextField txtUsername;
+    @FXML private JFXPasswordField txtPassword;
+    @FXML private Label lblCreationWarning;
+    @FXML private Label lblPassword;
+    @FXML private JFXComboBox<String> cboType;
+    @FXML private JFXComboBox<AuthlibInjectorServer> cboServers;
+    @FXML private Label lblInjectorServer;
+    @FXML private Hyperlink linkManageInjectorServers;
+    @FXML private JFXDialogLayout layout;
+    @FXML private JFXButton btnAccept;
+    @FXML private SpinnerPane acceptPane;
+
+    public AddAccountPane() {
+        FXUtils.loadFXML(this, "/assets/fxml/account-add.fxml");
+
+        cboServers.setCellFactory(jfxListCellFactory(server -> new TwoLineListItem(server.getName(), server.getUrl())));
+        cboServers.setConverter(stringConverter(AuthlibInjectorServer::getName));
+        Bindings.bindContent(cboServers.getItems(), ConfigHolder.CONFIG.authlibInjectorServers);
+        cboServers.getItems().addListener(onInvalidating(this::selectDefaultServer));
+        selectDefaultServer();
+
+        cboType.getItems().setAll(i18n("account.methods.offline"), i18n("account.methods.yggdrasil"), i18n("account.methods.authlib_injector"));
+        cboType.getSelectionModel().select(0);
+
+        ReadOnlyIntegerProperty loginTypeIdProperty = cboType.getSelectionModel().selectedIndexProperty();
+
+        txtPassword.visibleProperty().bind(loginTypeIdProperty.isNotEqualTo(0));
+        lblPassword.visibleProperty().bind(txtPassword.visibleProperty());
+
+        cboServers.visibleProperty().bind(loginTypeIdProperty.isEqualTo(2));
+        lblInjectorServer.visibleProperty().bind(cboServers.visibleProperty());
+        linkManageInjectorServers.visibleProperty().bind(cboServers.visibleProperty());
+
+        txtUsername.getValidators().add(new Validator(i18n("input.email"), str -> !txtPassword.isVisible() || str.contains("@")));
+
+        btnAccept.disableProperty().bind(Bindings.createBooleanBinding(
+                () -> !txtUsername.validate() || (loginTypeIdProperty.get() != 0 && !txtPassword.validate()),
+                txtUsername.textProperty(), txtPassword.textProperty(), loginTypeIdProperty));
+    }
+
+    /**
+     * Selects the first server if no server is selected.
+     */
+    private void selectDefaultServer() {
+        if (!cboServers.getItems().isEmpty() && cboServers.getSelectionModel().isEmpty()) {
+            cboServers.getSelectionModel().select(0);
+        }
+    }
+
+    @FXML
+    private void onCreationAccept() {
+        if (btnAccept.isDisabled())
+            return;
+
+        String username = txtUsername.getText();
+        String password = txtPassword.getText();
+        Object addtionalData;
+
+        int type = cboType.getSelectionModel().getSelectedIndex();
+        AccountFactory<?> factory;
+        switch (type) {
+            case 0:
+                factory = Accounts.ACCOUNT_FACTORY.get(Accounts.OFFLINE_ACCOUNT_KEY);
+                addtionalData = null;
+                break;
+            case 1:
+                factory = Accounts.ACCOUNT_FACTORY.get(Accounts.YGGDRASIL_ACCOUNT_KEY);
+                addtionalData = null;
+                break;
+            case 2:
+                factory = Accounts.ACCOUNT_FACTORY.get(Accounts.AUTHLIB_INJECTOR_ACCOUNT_KEY);
+                Optional<AuthlibInjectorServer> server = Optional.ofNullable(cboServers.getSelectionModel().getSelectedItem());
+                if (server.isPresent()) {
+                    addtionalData = server.get();
+                } else {
+                    lblCreationWarning.setText(i18n("account.failed.no_selected_server"));
+                    return;
+                }
+                break;
+            default:
+                throw new Error();
+        }
+
+        acceptPane.showSpinner();
+        lblCreationWarning.setText("");
+        setDisable(true);
+
+        Task.ofResult("create_account", () -> factory.create(new Selector(), username, password, addtionalData, Settings.INSTANCE.getProxy()))
+                .finalized(Schedulers.javafx(), variables -> {
+                    Settings.INSTANCE.addAccount(variables.get("create_account"));
+                    acceptPane.hideSpinner();
+                    fireEvent(new DialogCloseEvent());
+                }, exception -> {
+                    if (exception instanceof NoSelectedCharacterException) {
+                        fireEvent(new DialogCloseEvent());
+                    } else {
+                        lblCreationWarning.setText(accountException(exception));
+                    }
+                    setDisable(false);
+                    acceptPane.hideSpinner();
+                }).start();
+    }
+
+    @FXML
+    private void onCreationCancel() {
+        fireEvent(new DialogCloseEvent());
+    }
+
+    @FXML
+    private void onManageInjecterServers() {
+        fireEvent(new DialogCloseEvent());
+        Controllers.navigate(Controllers.getServersPage());
+    }
+
+    private class Selector extends BorderPane implements CharacterSelector {
+        private final AdvancedListBox listBox = new AdvancedListBox();
+        private final JFXButton cancel = new JFXButton();
+
+        private final CountDownLatch latch = new CountDownLatch(1);
+        private GameProfile selectedProfile = null;
+
+        {
+            setStyle("-fx-padding: 8px;");
+
+            cancel.setText(i18n("button.cancel"));
+            StackPane.setAlignment(cancel, Pos.BOTTOM_RIGHT);
+            cancel.setOnMouseClicked(e -> latch.countDown());
+
+            listBox.startCategory(i18n("account.choose"));
+
+            setCenter(listBox);
+
+            HBox hbox = new HBox();
+            hbox.setAlignment(Pos.CENTER_RIGHT);
+            hbox.getChildren().add(cancel);
+            setBottom(hbox);
+        }
+
+        @Override
+        public GameProfile select(Account account, List<GameProfile> names) throws NoSelectedCharacterException {
+            if (!(account instanceof YggdrasilAccount))
+                return CharacterSelector.DEFAULT.select(account, names);
+            YggdrasilAccount yggdrasilAccount = (YggdrasilAccount) account;
+
+            for (GameProfile profile : names) {
+                Image image;
+                try {
+                    image = AccountHelper.getSkinImmediately(yggdrasilAccount, profile, 4, Settings.INSTANCE.getProxy());
+                } catch (Exception e) {
+                    Logging.LOG.log(Level.WARNING, "Failed to get skin for " + profile.getName(), e);
+                    image = null;
+                }
+                ImageView portraitView = new ImageView();
+                portraitView.setSmooth(false);
+                if (image == null) {
+                    portraitView.setImage(Constants.DEFAULT_ICON.get());
+                } else {
+                    portraitView.setImage(image);
+                    portraitView.setViewport(AccountHelper.getViewport(4));
+                }
+                FXUtils.limitSize(portraitView, 32, 32);
+
+                IconedItem accountItem = new IconedItem(portraitView, profile.getName());
+                accountItem.setOnMouseClicked(e -> {
+                    selectedProfile = profile;
+                    latch.countDown();
+                });
+                listBox.add(accountItem);
+            }
+
+            JFXUtilities.runInFX(() -> Controllers.dialog(this));
+
+            try {
+                latch.await();
+
+                if (selectedProfile == null)
+                    throw new NoSelectedCharacterException(account);
+
+                return selectedProfile;
+            } catch (InterruptedException ignore) {
+                throw new NoSelectedCharacterException(account);
+            } finally {
+                JFXUtilities.runInFX(() -> Selector.this.fireEvent(new DialogCloseEvent()));
+            }
+        }
+    }
+
+    public static String accountException(Exception exception) {
+        if (exception instanceof NoCharacterException) {
+            return i18n("account.failed.no_character");
+        } else if (exception instanceof ServerDisconnectException) {
+            return i18n("account.failed.connect_authentication_server");
+        } else if (exception instanceof RemoteAuthenticationException) {
+            RemoteAuthenticationException remoteException = (RemoteAuthenticationException) exception;
+            String remoteMessage = remoteException.getRemoteMessage();
+            if ("ForbiddenOperationException".equals(remoteException.getRemoteName()) && remoteMessage != null) {
+                if (remoteMessage.contains("Invalid credentials"))
+                    return i18n("account.failed.invalid_credentials");
+                else if (remoteMessage.contains("Invalid token"))
+                    return i18n("account.failed.invalid_token");
+                else if (remoteMessage.contains("Invalid username or password"))
+                    return i18n("account.failed.invalid_password");
+            }
+            return exception.getMessage();
+        } else {
+            return exception.getClass().getName() + ": " + exception.getLocalizedMessage();
+        }
+    }
+
+    public static String accountType(Account account) {
+        if (account instanceof OfflineAccount) return i18n("account.methods.offline");
+        else if (account instanceof AuthlibInjectorAccount) return i18n("account.methods.authlib_injector");
+        else if (account instanceof YggdrasilAccount) return i18n("account.methods.yggdrasil");
+        else throw new Error(i18n("account.methods.no_method") + ": " + account);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/AddAuthlibInjectorServerPane.java

@@ -0,0 +1,141 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import static org.jackhuang.hmcl.ui.FXUtils.loadFXML;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.IOException;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorServer;
+import org.jackhuang.hmcl.setting.ConfigHolder;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.animation.ContainerAnimations;
+import org.jackhuang.hmcl.ui.animation.TransitionHandler;
+import org.jackhuang.hmcl.ui.construct.DialogCloseEvent;
+import org.jackhuang.hmcl.ui.construct.SpinnerPane;
+import org.jackhuang.hmcl.util.NetworkUtils;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXDialogLayout;
+import com.jfoenix.controls.JFXTextField;
+
+import javafx.beans.binding.Bindings;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.layout.StackPane;
+
+public class AddAuthlibInjectorServerPane extends StackPane {
+
+    @FXML private StackPane addServerContainer;
+    @FXML private Label lblServerUrl;
+    @FXML private Label lblServerName;
+    @FXML private Label lblCreationWarning;
+    @FXML private Label lblServerWarning;
+    @FXML private JFXTextField txtServerUrl;
+    @FXML private JFXDialogLayout addServerPane;
+    @FXML private JFXDialogLayout confirmServerPane;
+    @FXML private SpinnerPane nextPane;
+    @FXML private JFXButton btnAddNext;
+
+    private TransitionHandler transitionHandler;
+
+    private AuthlibInjectorServer serverBeingAdded;
+
+    public AddAuthlibInjectorServerPane(String url) {
+        this();
+        txtServerUrl.setText(url);
+        onAddNext();
+    }
+
+    public AddAuthlibInjectorServerPane() {
+        loadFXML(this, "/assets/fxml/authlib-injector-server-add.fxml");
+        transitionHandler = new TransitionHandler(addServerContainer);
+        transitionHandler.setContent(addServerPane, ContainerAnimations.NONE.getAnimationProducer());
+
+        btnAddNext.disableProperty().bind(
+                Bindings.createBooleanBinding(txtServerUrl::validate, txtServerUrl.textProperty()).not());
+        nextPane.hideSpinner();
+    }
+
+    private String fixInputUrl(String url) {
+        if (!url.endsWith("/")) {
+            url += "/";
+        }
+        return url;
+    }
+
+    private String resolveFetchExceptionMessage(Throwable exception) {
+        if (exception instanceof IOException) {
+            return i18n("account.failed.connect_injector_server");
+        } else {
+            return exception.getClass().getName() + ": " + exception.getLocalizedMessage();
+        }
+    }
+
+    @FXML
+    private void onAddCancel() {
+        fireEvent(new DialogCloseEvent());
+    }
+
+    @FXML
+    private void onAddNext() {
+        if (btnAddNext.isDisabled())
+            return;
+
+        lblCreationWarning.setText("");
+
+        String url = fixInputUrl(txtServerUrl.getText());
+
+        nextPane.showSpinner();
+        addServerPane.setDisable(true);
+
+        Task.of(() -> {
+            serverBeingAdded = AuthlibInjectorServer.fetchServerInfo(url);
+        }).finalized(Schedulers.javafx(), (variables, isDependentsSucceeded) -> {
+            addServerPane.setDisable(false);
+            nextPane.hideSpinner();
+
+            if (isDependentsSucceeded) {
+                lblServerName.setText(serverBeingAdded.getName());
+                lblServerUrl.setText(serverBeingAdded.getUrl());
+
+                lblServerWarning.setVisible("http".equals(NetworkUtils.toURL(serverBeingAdded.getUrl()).getProtocol()));
+
+                transitionHandler.setContent(confirmServerPane, ContainerAnimations.SWIPE_LEFT.getAnimationProducer());
+            } else {
+                lblCreationWarning.setText(resolveFetchExceptionMessage(variables.<Exception>get("lastException")));
+            }
+        }).start();
+
+    }
+
+    @FXML
+    private void onAddPrev() {
+        transitionHandler.setContent(addServerPane, ContainerAnimations.SWIPE_RIGHT.getAnimationProducer());
+    }
+
+    @FXML
+    private void onAddFinish() {
+        if (!ConfigHolder.CONFIG.authlibInjectorServers.contains(serverBeingAdded)) {
+            ConfigHolder.CONFIG.authlibInjectorServers.add(serverBeingAdded);
+        }
+        fireEvent(new DialogCloseEvent());
+    }
+
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/AuthlibInjectorServerItem.java

@@ -0,0 +1,64 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.effects.JFXDepthManager;
+import javafx.geometry.Pos;
+import javafx.scene.control.Label;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.VBox;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorServer;
+import org.jackhuang.hmcl.setting.Theme;
+
+import java.util.function.Consumer;
+
+public final class AuthlibInjectorServerItem extends BorderPane {
+    private final AuthlibInjectorServer server;
+
+    private final Label lblServerName = new Label();
+    private final Label lblServerIp = new Label();
+
+    public AuthlibInjectorServerItem(AuthlibInjectorServer server, Consumer<AuthlibInjectorServerItem> deleteCallback) {
+        this.server = server;
+
+        lblServerName.setStyle("-fx-font-size: 15;");
+        lblServerIp.setStyle("-fx-font-size: 10;");
+
+        VBox center = new VBox();
+        BorderPane.setAlignment(center, Pos.CENTER);
+        center.getChildren().addAll(lblServerName, lblServerIp);
+        setCenter(center);
+
+        JFXButton right = new JFXButton();
+        right.setOnMouseClicked(e -> deleteCallback.accept(this));
+        right.getStyleClass().add("toggle-icon4");
+        BorderPane.setAlignment(right, Pos.CENTER);
+        right.setGraphic(SVG.close(Theme.blackFillBinding(), 15, 15));
+        setRight(right);
+
+        setStyle("-fx-background-radius: 2; -fx-background-color: white; -fx-padding: 8;");
+        JFXDepthManager.setDepth(this, 1);
+        lblServerName.setText(server.getName());
+        lblServerIp.setText(server.getUrl());
+    }
+
+    public AuthlibInjectorServer getServer() {
+        return server;
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/AuthlibInjectorServersPage.java

@@ -0,0 +1,81 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import static java.util.stream.Collectors.toList;
+import static org.jackhuang.hmcl.ui.FXUtils.loadFXML;
+import static org.jackhuang.hmcl.ui.FXUtils.smoothScrolling;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import org.jackhuang.hmcl.setting.ConfigHolder;
+import org.jackhuang.hmcl.ui.wizard.DecoratorPage;
+
+import javafx.beans.InvalidationListener;
+import javafx.beans.WeakInvalidationListener;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+
+public class AuthlibInjectorServersPage extends StackPane implements DecoratorPage {
+    private final StringProperty title = new SimpleStringProperty(this, "title", i18n("account.injector.manage.title"));
+
+    @FXML private ScrollPane scrollPane;
+    @FXML private VBox listPane;
+    @FXML private StackPane contentPane;
+
+    private InvalidationListener serversListener;
+
+    public AuthlibInjectorServersPage() {
+        loadFXML(this, "/assets/fxml/authlib-injector-servers.fxml");
+        smoothScrolling(scrollPane);
+
+        serversListener = observable -> updateServersList();
+        ConfigHolder.CONFIG.authlibInjectorServers.addListener(new WeakInvalidationListener(serversListener));
+        updateServersList();
+    }
+
+    private void updateServersList() {
+        listPane.getChildren().setAll(
+                ConfigHolder.CONFIG.authlibInjectorServers.stream()
+                        .map(server -> new AuthlibInjectorServerItem(server,
+                                item -> ConfigHolder.CONFIG.authlibInjectorServers.remove(item.getServer())))
+                        .collect(toList()));
+    }
+
+
+    @FXML
+    private void onAdd() {
+        Controllers.dialog(new AddAuthlibInjectorServerPane());
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    @Override
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/Controllers.java

@@ -0,0 +1,195 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.image.Image;
+import javafx.scene.layout.Region;
+import javafx.stage.Stage;
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.task.TaskExecutor;
+import org.jackhuang.hmcl.ui.construct.DialogCloseEvent;
+import org.jackhuang.hmcl.ui.construct.InputDialogPane;
+import org.jackhuang.hmcl.ui.construct.MessageBox;
+import org.jackhuang.hmcl.ui.construct.MessageDialogPane;
+import org.jackhuang.hmcl.ui.construct.TaskExecutorDialogPane;
+import org.jackhuang.hmcl.util.JavaVersion;
+
+import java.util.function.Consumer;
+
+public final class Controllers {
+
+    private static Scene scene;
+    private static Stage stage;
+    private static MainPage mainPage = null;
+    private static SettingsPage settingsPage = null;
+    private static VersionPage versionPage = null;
+    private static AuthlibInjectorServersPage serversPage = null;
+    private static LeftPaneController leftPaneController;
+    private static Decorator decorator;
+
+    public static Scene getScene() {
+        return scene;
+    }
+
+    public static Stage getStage() {
+        return stage;
+    }
+
+    // FXThread
+    public static SettingsPage getSettingsPage() {
+        if (settingsPage == null)
+            settingsPage = new SettingsPage();
+        return settingsPage;
+    }
+
+    // FXThread
+    public static VersionPage getVersionPage() {
+        if (versionPage == null)
+            versionPage = new VersionPage();
+        return versionPage;
+    }
+
+    // FXThread
+    public static AuthlibInjectorServersPage getServersPage() {
+        if (serversPage == null)
+            serversPage = new AuthlibInjectorServersPage();
+        return serversPage;
+    }
+
+    // FXThread
+    public static Decorator getDecorator() {
+        return decorator;
+    }
+
+    public static MainPage getMainPage() {
+        if (mainPage == null)
+            mainPage = new MainPage();
+        return mainPage;
+    }
+
+    public static LeftPaneController getLeftPaneController() {
+        return leftPaneController;
+    }
+
+    public static void initialize(Stage stage) {
+        Controllers.stage = stage;
+
+        stage.setOnCloseRequest(e -> Launcher.stopApplication());
+
+        decorator = new Decorator(stage, getMainPage(), Launcher.TITLE, false, true);
+        decorator.showPage(null);
+        leftPaneController = new LeftPaneController(decorator.getLeftPane());
+
+        Settings.INSTANCE.onProfileLoading();
+        Task.of(JavaVersion::initialize).start();
+
+        decorator.setCustomMaximize(false);
+
+        scene = new Scene(decorator, 804, 521);
+        scene.getStylesheets().setAll(Settings.INSTANCE.getTheme().getStylesheets());
+        stage.setMinWidth(804);
+        stage.setMaxWidth(804);
+        stage.setMinHeight(521);
+        stage.setMaxHeight(521);
+
+        stage.getIcons().add(new Image("/assets/img/icon.png"));
+        stage.setTitle(Launcher.TITLE);
+    }
+
+    public static void dialog(Region content) {
+        if (decorator != null)
+            decorator.showDialog(content);
+    }
+
+    public static void dialog(String text) {
+        dialog(text, null);
+    }
+
+    public static void dialog(String text, String title) {
+        dialog(text, title, MessageBox.INFORMATION_MESSAGE);
+    }
+
+    public static void dialog(String text, String title, int type) {
+        dialog(text, title, type, null);
+    }
+
+    public static void dialog(String text, String title, int type, Runnable onAccept) {
+        dialog(new MessageDialogPane(text, title, type, onAccept));
+    }
+
+    public static void confirmDialog(String text, String title, Runnable onAccept, Runnable onCancel) {
+        dialog(new MessageDialogPane(text, title, onAccept, onCancel));
+    }
+
+    public static void inputDialog(String text, Consumer<String> onResult) {
+        dialog(new InputDialogPane(text, onResult));
+    }
+
+    public static Region taskDialog(TaskExecutor executor, String title, String subtitle) {
+        return taskDialog(executor, title, subtitle, null);
+    }
+
+    public static Region taskDialog(TaskExecutor executor, String title, String subtitle, Consumer<Region> onCancel) {
+        TaskExecutorDialogPane pane = new TaskExecutorDialogPane(onCancel);
+        pane.setTitle(title);
+        pane.setSubtitle(subtitle);
+        pane.setExecutor(executor);
+        dialog(pane);
+        return pane;
+    }
+
+    /**
+     * Use {@link DialogCloseEvent}
+     */
+    public static void closeDialog(Region content) {
+        if (stage == null) // shut down
+            return;
+        decorator.closeDialog(content);
+    }
+
+    public static void navigate(Node node) {
+        if (decorator.getNowPage() == node)
+            decorator.showPage(null);
+        else
+            decorator.showPage(node);
+    }
+
+    public static void showUpdate() {
+        if (stage == null) // shut down
+            return;
+        getLeftPaneController().showUpdate();
+    }
+
+    public static boolean isStopped() {
+        return decorator == null;
+    }
+
+    public static void shutdown() {
+        mainPage = null;
+        settingsPage = null;
+        versionPage = null;
+        serversPage = null;
+        decorator = null;
+        stage = null;
+        scene = null;
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/CrashWindow.java

@@ -0,0 +1,76 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.TextArea;
+import javafx.scene.image.Image;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.StackPane;
+import javafx.stage.Stage;
+
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import org.jackhuang.hmcl.Launcher;
+
+/**
+ * @author huangyuhui
+ */
+public class CrashWindow extends Stage {
+
+    public CrashWindow(String text) {
+        Label lblCrash = new Label();
+        if (Launcher.UPDATE_CHECKER.isOutOfDate())
+            lblCrash.setText(i18n("launcher.crash_out_dated"));
+        else
+            lblCrash.setText(i18n("launcher.crash"));
+        lblCrash.setWrapText(true);
+
+        TextArea textArea = new TextArea();
+        textArea.setText(text);
+        textArea.setEditable(false);
+
+        Button btnContact = new Button();
+        btnContact.setText(i18n("launcher.contact"));
+        btnContact.setOnMouseClicked(event -> FXUtils.openLink(Launcher.CONTACT));
+        HBox box = new HBox();
+        box.setStyle("-fx-padding: 8px;");
+        box.getChildren().add(btnContact);
+        box.setAlignment(Pos.CENTER_RIGHT);
+
+        BorderPane pane = new BorderPane();
+        StackPane stackPane = new StackPane();
+        stackPane.setStyle("-fx-padding: 8px;");
+        stackPane.getChildren().add(lblCrash);
+        pane.setTop(stackPane);
+        pane.setCenter(textArea);
+        pane.setBottom(box);
+
+        Scene scene = new Scene(pane, 800, 480);
+        setScene(scene);
+        getIcons().add(new Image("/assets/img/icon.png"));
+        setTitle(i18n("message.error"));
+
+        setOnCloseRequest(e -> System.exit(1));
+    }
+
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/Decorator.java

@@ -0,0 +1,700 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXDialog;
+import com.jfoenix.controls.JFXDrawer;
+import com.jfoenix.controls.JFXHamburger;
+import com.jfoenix.svg.SVGGlyph;
+import javafx.animation.Interpolator;
+import javafx.animation.KeyFrame;
+import javafx.animation.KeyValue;
+import javafx.animation.Timeline;
+import javafx.application.Platform;
+import javafx.beans.binding.Bindings;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.event.EventHandler;
+import javafx.fxml.FXML;
+import javafx.geometry.BoundingBox;
+import javafx.geometry.Bounds;
+import javafx.geometry.Insets;
+import javafx.geometry.Rectangle2D;
+import javafx.scene.Cursor;
+import javafx.scene.Node;
+import javafx.scene.control.Label;
+import javafx.scene.control.Tooltip;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.input.DragEvent;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.*;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Rectangle;
+import javafx.stage.Screen;
+import javafx.stage.Stage;
+import javafx.stage.StageStyle;
+import javafx.util.Duration;
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorDnD;
+import org.jackhuang.hmcl.setting.EnumBackgroundImage;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.setting.Theme;
+import org.jackhuang.hmcl.ui.animation.AnimationProducer;
+import org.jackhuang.hmcl.ui.animation.ContainerAnimations;
+import org.jackhuang.hmcl.ui.animation.TransitionHandler;
+import org.jackhuang.hmcl.ui.construct.AdvancedListBox;
+import org.jackhuang.hmcl.ui.construct.DialogCloseEvent;
+import org.jackhuang.hmcl.ui.construct.StackContainerPane;
+import org.jackhuang.hmcl.ui.construct.TaskExecutorDialogWizardDisplayer;
+import org.jackhuang.hmcl.ui.wizard.*;
+import org.jackhuang.hmcl.util.FileUtils;
+import org.jackhuang.hmcl.util.Lang;
+import org.jackhuang.hmcl.util.StringUtils;
+import java.io.File;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.Queue;
+import java.util.Random;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public final class Decorator extends StackPane implements TaskExecutorDialogWizardDisplayer {
+    private static final SVGGlyph minus = Lang.apply(new SVGGlyph(0, "MINUS", "M804.571 420.571v109.714q0 22.857-16 38.857t-38.857 16h-694.857q-22.857 0-38.857-16t-16-38.857v-109.714q0-22.857 16-38.857t38.857-16h694.857q22.857 0 38.857 16t16 38.857z", Color.WHITE),
+            glyph -> { glyph.setSize(12, 2); glyph.setTranslateY(4); });
+    private static final SVGGlyph resizeMax = Lang.apply(new SVGGlyph(0, "RESIZE_MAX", "M726 810v-596h-428v596h428zM726 44q34 0 59 25t25 59v768q0 34-25 60t-59 26h-428q-34 0-59-26t-25-60v-768q0-34 25-60t59-26z", Color.WHITE),
+            glyph -> { glyph.setPrefSize(12, 12); glyph.setSize(12, 12); });
+    private static final SVGGlyph resizeMin = Lang.apply(new SVGGlyph(0, "RESIZE_MIN", "M80.842 943.158v-377.264h565.894v377.264h-565.894zM0 404.21v619.79h727.578v-619.79h-727.578zM377.264 161.684h565.894v377.264h-134.736v80.842h215.578v-619.79h-727.578v323.37h80.842v-161.686z", Color.WHITE),
+            glyph -> { glyph.setPrefSize(12, 12); glyph.setSize(12, 12); });
+    private static final SVGGlyph close = Lang.apply(new SVGGlyph(0, "CLOSE", "M810 274l-238 238 238 238-60 60-238-238-238 238-60-60 238-238-238-238 60-60 238 238 238-238z", Color.WHITE),
+            glyph -> { glyph.setPrefSize(12, 12); glyph.setSize(12, 12); });
+
+    private static final String PROPERTY_DIALOG_CLOSE_HANDLER = Decorator.class.getName() + ".dialog.closeListener";
+
+    private final ObjectProperty<Runnable> onCloseButtonAction;
+    private final BooleanProperty customMaximize = new SimpleBooleanProperty(false);
+
+    private final Stage primaryStage;
+    private final Node mainPage;
+    private final boolean max, min;
+    private final WizardController wizardController = new WizardController(this);
+    private final Queue<Object> cancelQueue = new ConcurrentLinkedQueue<>();
+
+    private double xOffset, yOffset, newX, newY, initX, initY;
+    private boolean allowMove, isDragging, maximized;
+    private BoundingBox originalBox, maximizedBox;
+    private final TransitionHandler animationHandler;
+
+    private JFXDialog dialog;
+    private StackContainerPane dialogPane;
+
+    @FXML
+    private StackPane contentPlaceHolder;
+    @FXML
+    private StackPane drawerWrapper;
+    @FXML
+    private BorderPane titleContainer;
+    @FXML
+    private BorderPane leftRootPane;
+    @FXML
+    private HBox buttonsContainer;
+    @FXML
+    private JFXButton backNavButton;
+    @FXML
+    private JFXButton refreshNavButton;
+    @FXML
+    private JFXButton closeNavButton;
+    @FXML
+    private JFXButton refreshMenuButton;
+    @FXML
+    private Label titleLabel;
+    @FXML
+    private Label lblTitle;
+    @FXML
+    private AdvancedListBox leftPane;
+    @FXML
+    private JFXDrawer drawer;
+    @FXML
+    private StackPane titleBurgerContainer;
+    @FXML
+    private JFXHamburger titleBurger;
+    @FXML
+    private JFXButton btnMin;
+    @FXML
+    private JFXButton btnMax;
+    @FXML
+    private JFXButton btnClose;
+    @FXML
+    private HBox navLeft;
+    @FXML
+    private ImageView welcomeView;
+
+    public Decorator(Stage primaryStage, Node mainPage, String title) {
+        this(primaryStage, mainPage, title, true, true);
+    }
+
+    public Decorator(Stage primaryStage, Node mainPage, String title, boolean max, boolean min) {
+        this.primaryStage = primaryStage;
+        this.mainPage = mainPage;
+        this.max = max;
+        this.min = min;
+
+        FXUtils.loadFXML(this, "/assets/fxml/decorator.fxml");
+
+        onCloseButtonAction = new SimpleObjectProperty<>(this, "onCloseButtonAction", Launcher::stopApplication);
+
+        primaryStage.initStyle(StageStyle.UNDECORATED);
+        btnClose.setGraphic(close);
+        btnMin.setGraphic(minus);
+        btnMax.setGraphic(resizeMax);
+
+        close.fillProperty().bind(Theme.foregroundFillBinding());
+        minus.fillProperty().bind(Theme.foregroundFillBinding());
+        resizeMax.fillProperty().bind(Theme.foregroundFillBinding());
+        resizeMin.fillProperty().bind(Theme.foregroundFillBinding());
+
+        refreshNavButton.setGraphic(SVG.refresh(Theme.foregroundFillBinding(), 15, 15));
+        closeNavButton.setGraphic(SVG.close(Theme.foregroundFillBinding(), 15, 15));
+        backNavButton.setGraphic(SVG.back(Theme.foregroundFillBinding(), 15, 15));
+
+        lblTitle.setText(title);
+
+        buttonsContainer.setBackground(new Background(new BackgroundFill(Color.BLACK, CornerRadii.EMPTY, Insets.EMPTY)));
+        titleContainer.addEventHandler(MouseEvent.MOUSE_CLICKED, event -> {
+            if (event.getClickCount() == 2)
+                btnMax.fire();
+        });
+
+        welcomeView.setCursor(Cursor.HAND);
+        welcomeView.setOnMouseClicked(e -> {
+            Timeline nowAnimation = new Timeline();
+            nowAnimation.getKeyFrames().addAll(
+                    new KeyFrame(Duration.ZERO, new KeyValue(welcomeView.opacityProperty(), 1.0D, Interpolator.EASE_BOTH)),
+                    new KeyFrame(new Duration(300), new KeyValue(welcomeView.opacityProperty(), 0.0D, Interpolator.EASE_BOTH)),
+                    new KeyFrame(new Duration(300), e2 -> drawerWrapper.getChildren().remove(welcomeView))
+            );
+            nowAnimation.play();
+        });
+        if (!Settings.INSTANCE.isFirstLaunch() || Settings.INSTANCE.getLocale().getLocale() != Locale.CHINA)
+            drawerWrapper.getChildren().remove(welcomeView);
+
+        if (!min) buttonsContainer.getChildren().remove(btnMin);
+        if (!max) buttonsContainer.getChildren().remove(btnMax);
+
+        //JFXDepthManager.setDepth(titleContainer, 1);
+        titleContainer.addEventHandler(MouseEvent.MOUSE_ENTERED, e -> allowMove = true);
+        titleContainer.addEventHandler(MouseEvent.MOUSE_EXITED, e -> {
+            if (!isDragging) allowMove = false;
+        });
+        Rectangle rectangle = new Rectangle(0, 0, 0, 0);
+        rectangle.widthProperty().bind(titleContainer.widthProperty());
+        rectangle.heightProperty().bind(Bindings.createDoubleBinding(() -> titleContainer.getHeight() + 100, titleContainer.heightProperty()));
+        titleContainer.setClip(rectangle);
+
+        animationHandler = new TransitionHandler(contentPlaceHolder);
+
+        loadBackground();
+
+        setupAuthlibInjectorDnD();
+    }
+
+    private void loadBackground() {
+        try {
+            Image background;
+
+            if (Settings.INSTANCE.getBackgroundImageType() == EnumBackgroundImage.DEFAULT)
+                background = searchBackgroundImage(new Image("/assets/img/background.jpg"), "");
+            else
+                background = searchBackgroundImage(new Image("/assets/img/background.jpg"), Settings.INSTANCE.getBackgroundImage());
+
+            drawerWrapper.setBackground(new Background(new BackgroundImage(background, BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT, BackgroundPosition.DEFAULT, new BackgroundSize(800, 480, false, false, true, true))));
+        } catch (IllegalArgumentException ignore) {
+        }
+    }
+
+    private static Image searchBackgroundImage(Image def, String customPath) {
+        Random random = new Random();
+        boolean loaded = false;
+        Image background = def;
+
+        // custom path
+        if (StringUtils.isNotBlank(customPath)) {
+            try {
+                background = new Image("file:" + customPath);
+                loaded = true;
+            } catch (IllegalArgumentException ignore) {
+            }
+        }
+
+        // images in ./bg
+        if (!loaded) {
+            File backgroundImageFile = new File("bg");
+            if (backgroundImageFile.isDirectory()) {
+                File[] backgroundPath = backgroundImageFile.listFiles(file -> StringUtils.containsOne(FileUtils.getExtension(file), "png", "jpg"));
+                if (backgroundPath != null && backgroundPath.length > 0) {
+                    int index = random.nextInt(backgroundPath.length);
+                    try {
+                        background = new Image("file:" + backgroundPath[index].getAbsolutePath());
+                        loaded = true;
+                    } catch (IllegalArgumentException ignore) {
+                    }
+                }
+            }
+        }
+
+        // background.png
+        if (!loaded) {
+            File backgroundImageFile = new File("background.png");
+            if (backgroundImageFile.exists()) {
+                try {
+                    background = new Image("file:" + backgroundImageFile.getAbsolutePath());
+                    loaded = true;
+                } catch (IllegalArgumentException ignore) {
+                }
+            }
+        }
+
+        // background.jpg
+        if (!loaded) {
+            File backgroundImageFile = new File("background.jpg");
+            if (backgroundImageFile.exists()) {
+                try {
+                    background = new Image("file:" + backgroundImageFile.getAbsolutePath());
+                    loaded = true;
+                } catch (IllegalArgumentException ignore) {
+                }
+            }
+        }
+
+        return background;
+    }
+
+    @FXML
+    private void onMouseMoved(MouseEvent mouseEvent) {
+        if (!primaryStage.isMaximized() && !primaryStage.isFullScreen() && !maximized) {
+            if (!primaryStage.isResizable())
+                updateInitMouseValues(mouseEvent);
+            else {
+                double x = mouseEvent.getX(), y = mouseEvent.getY();
+                Bounds boundsInParent = getBoundsInParent();
+                if (getBorder() != null && getBorder().getStrokes().size() > 0) {
+                    double borderWidth = this.contentPlaceHolder.snappedLeftInset();
+                    if (this.isRightEdge(x, y, boundsInParent)) {
+                        if (y < borderWidth) {
+                            setCursor(Cursor.NE_RESIZE);
+                        } else if (y > this.getHeight() - borderWidth) {
+                            setCursor(Cursor.SE_RESIZE);
+                        } else {
+                            setCursor(Cursor.E_RESIZE);
+                        }
+                    } else if (this.isLeftEdge(x, y, boundsInParent)) {
+                        if (y < borderWidth) {
+                            setCursor(Cursor.NW_RESIZE);
+                        } else if (y > this.getHeight() - borderWidth) {
+                            setCursor(Cursor.SW_RESIZE);
+                        } else {
+                            setCursor(Cursor.W_RESIZE);
+                        }
+                    } else if (this.isTopEdge(x, y, boundsInParent)) {
+                        setCursor(Cursor.N_RESIZE);
+                    } else if (this.isBottomEdge(x, y, boundsInParent)) {
+                        setCursor(Cursor.S_RESIZE);
+                    } else {
+                        setCursor(Cursor.DEFAULT);
+                    }
+
+                    this.updateInitMouseValues(mouseEvent);
+                }
+            }
+        } else {
+            setCursor(Cursor.DEFAULT);
+        }
+    }
+
+    @FXML
+    private void onMouseReleased() {
+        isDragging = false;
+    }
+
+    @FXML
+    private void onMouseDragged(MouseEvent mouseEvent) {
+        this.isDragging = true;
+        if (mouseEvent.isPrimaryButtonDown() && (this.xOffset != -1.0 || this.yOffset != -1.0)) {
+            if (!this.primaryStage.isFullScreen() && !mouseEvent.isStillSincePress() && !this.primaryStage.isMaximized() && !this.maximized) {
+                this.newX = mouseEvent.getScreenX();
+                this.newY = mouseEvent.getScreenY();
+                double deltaX = this.newX - this.initX;
+                double deltaY = this.newY - this.initY;
+                Cursor cursor = this.getCursor();
+                if (Cursor.E_RESIZE == cursor) {
+                    this.setStageWidth(this.primaryStage.getWidth() + deltaX);
+                    mouseEvent.consume();
+                } else if (Cursor.NE_RESIZE == cursor) {
+                    if (this.setStageHeight(this.primaryStage.getHeight() - deltaY)) {
+                        this.primaryStage.setY(this.primaryStage.getY() + deltaY);
+                    }
+
+                    this.setStageWidth(this.primaryStage.getWidth() + deltaX);
+                    mouseEvent.consume();
+                } else if (Cursor.SE_RESIZE == cursor) {
+                    this.setStageWidth(this.primaryStage.getWidth() + deltaX);
+                    this.setStageHeight(this.primaryStage.getHeight() + deltaY);
+                    mouseEvent.consume();
+                } else if (Cursor.S_RESIZE == cursor) {
+                    this.setStageHeight(this.primaryStage.getHeight() + deltaY);
+                    mouseEvent.consume();
+                } else if (Cursor.W_RESIZE == cursor) {
+                    if (this.setStageWidth(this.primaryStage.getWidth() - deltaX)) {
+                        this.primaryStage.setX(this.primaryStage.getX() + deltaX);
+                    }
+
+                    mouseEvent.consume();
+                } else if (Cursor.SW_RESIZE == cursor) {
+                    if (this.setStageWidth(this.primaryStage.getWidth() - deltaX)) {
+                        this.primaryStage.setX(this.primaryStage.getX() + deltaX);
+                    }
+
+                    this.setStageHeight(this.primaryStage.getHeight() + deltaY);
+                    mouseEvent.consume();
+                } else if (Cursor.NW_RESIZE == cursor) {
+                    if (this.setStageWidth(this.primaryStage.getWidth() - deltaX)) {
+                        this.primaryStage.setX(this.primaryStage.getX() + deltaX);
+                    }
+
+                    if (this.setStageHeight(this.primaryStage.getHeight() - deltaY)) {
+                        this.primaryStage.setY(this.primaryStage.getY() + deltaY);
+                    }
+
+                    mouseEvent.consume();
+                } else if (Cursor.N_RESIZE == cursor) {
+                    if (this.setStageHeight(this.primaryStage.getHeight() - deltaY)) {
+                        this.primaryStage.setY(this.primaryStage.getY() + deltaY);
+                    }
+
+                    mouseEvent.consume();
+                } else if (this.allowMove) {
+                    this.primaryStage.setX(mouseEvent.getScreenX() - this.xOffset);
+                    this.primaryStage.setY(mouseEvent.getScreenY() - this.yOffset);
+                    mouseEvent.consume();
+                }
+            }
+        }
+    }
+
+    @FXML
+    private void onMin() {
+        primaryStage.setIconified(true);
+    }
+
+    @FXML
+    private void onMax() {
+        if (!max) return;
+        if (!this.isCustomMaximize()) {
+            this.primaryStage.setMaximized(!this.primaryStage.isMaximized());
+            this.maximized = this.primaryStage.isMaximized();
+            if (this.primaryStage.isMaximized()) {
+                this.btnMax.setGraphic(resizeMin);
+                this.btnMax.setTooltip(new Tooltip("Restore Down"));
+            } else {
+                this.btnMax.setGraphic(resizeMax);
+                this.btnMax.setTooltip(new Tooltip("Maximize"));
+            }
+        } else {
+            if (!this.maximized) {
+                this.originalBox = new BoundingBox(primaryStage.getX(), primaryStage.getY(), primaryStage.getWidth(), primaryStage.getHeight());
+                Screen screen = Screen.getScreensForRectangle(primaryStage.getX(), primaryStage.getY(), primaryStage.getWidth(), primaryStage.getHeight()).get(0);
+                Rectangle2D bounds = screen.getVisualBounds();
+                this.maximizedBox = new BoundingBox(bounds.getMinX(), bounds.getMinY(), bounds.getWidth(), bounds.getHeight());
+                primaryStage.setX(this.maximizedBox.getMinX());
+                primaryStage.setY(this.maximizedBox.getMinY());
+                primaryStage.setWidth(this.maximizedBox.getWidth());
+                primaryStage.setHeight(this.maximizedBox.getHeight());
+                this.btnMax.setGraphic(resizeMin);
+                this.btnMax.setTooltip(new Tooltip("Restore Down"));
+            } else {
+                primaryStage.setX(this.originalBox.getMinX());
+                primaryStage.setY(this.originalBox.getMinY());
+                primaryStage.setWidth(this.originalBox.getWidth());
+                primaryStage.setHeight(this.originalBox.getHeight());
+                this.originalBox = null;
+                this.btnMax.setGraphic(resizeMax);
+                this.btnMax.setTooltip(new Tooltip("Maximize"));
+            }
+
+            this.maximized = !this.maximized;
+        }
+    }
+
+    @FXML
+    private void onClose() {
+        onCloseButtonAction.get().run();
+    }
+
+    private void updateInitMouseValues(MouseEvent mouseEvent) {
+        initX = mouseEvent.getScreenX();
+        initY = mouseEvent.getScreenY();
+        xOffset = mouseEvent.getSceneX();
+        yOffset = mouseEvent.getSceneY();
+    }
+
+    private boolean isRightEdge(double x, double y, Bounds boundsInParent) {
+        return x < getWidth() && x > getWidth() - contentPlaceHolder.snappedLeftInset();
+    }
+
+    private boolean isTopEdge(double x, double y, Bounds boundsInParent) {
+        return y >= 0 && y < contentPlaceHolder.snappedLeftInset();
+    }
+
+    private boolean isBottomEdge(double x, double y, Bounds boundsInParent) {
+        return y < getHeight() && y > getHeight() - contentPlaceHolder.snappedLeftInset();
+    }
+
+    private boolean isLeftEdge(double x, double y, Bounds boundsInParent) {
+        return x >= 0 && x < contentPlaceHolder.snappedLeftInset();
+    }
+
+    private boolean setStageWidth(double width) {
+        if (width >= primaryStage.getMinWidth() && width >= titleContainer.getMinWidth()) {
+            primaryStage.setWidth(width);
+            initX = newX;
+            return true;
+        } else {
+            if (width >= primaryStage.getMinWidth() && width <= titleContainer.getMinWidth())
+                primaryStage.setWidth(titleContainer.getMinWidth());
+
+            return false;
+        }
+    }
+
+    private boolean setStageHeight(double height) {
+        if (height >= primaryStage.getMinHeight() && height >= titleContainer.getHeight()) {
+            primaryStage.setHeight(height);
+            initY = newY;
+            return true;
+        } else {
+            if (height >= primaryStage.getMinHeight() && height <= titleContainer.getHeight())
+                primaryStage.setHeight(titleContainer.getHeight());
+
+            return false;
+        }
+    }
+
+    public void setMaximized(boolean maximized) {
+        if (this.maximized != maximized) {
+            Platform.runLater(btnMax::fire);
+        }
+    }
+
+    private void showCloseNavButton() {
+        navLeft.getChildren().add(closeNavButton);
+    }
+
+    private void hideCloseNavButton() {
+        navLeft.getChildren().remove(closeNavButton);
+    }
+
+    private void setContent(Node content, AnimationProducer animation) {
+        isWizardPageNow = false;
+        animationHandler.setContent(content, animation);
+
+        if (content instanceof Region) {
+            ((Region) content).setMinSize(0, 0);
+            FXUtils.setOverflowHidden((Region) content, true);
+        }
+
+        refreshNavButton.setVisible(content instanceof Refreshable);
+        backNavButton.setVisible(content != mainPage);
+
+        String prefix = category == null ? "" : category + " - ";
+
+        titleLabel.textProperty().unbind();
+
+        if (content instanceof WizardPage)
+            titleLabel.setText(prefix + ((WizardPage) content).getTitle());
+
+        if (content instanceof DecoratorPage)
+            titleLabel.textProperty().bind(((DecoratorPage) content).titleProperty());
+    }
+
+    private String category;
+    private Node nowPage;
+    private boolean isWizardPageNow;
+
+    public Node getNowPage() {
+        return nowPage;
+    }
+
+    public void showPage(Node content) {
+        FXUtils.checkFxUserThread();
+
+        contentPlaceHolder.getStyleClass().removeAll("gray-background", "white-background");
+        if (content != null)
+            contentPlaceHolder.getStyleClass().add("gray-background");
+
+        Node c = content == null ? mainPage : content;
+        onEnd();
+        if (nowPage instanceof DecoratorPage)
+            ((DecoratorPage) nowPage).onClose();
+        nowPage = content;
+
+        setContent(c, ContainerAnimations.FADE.getAnimationProducer());
+
+        if (c instanceof Region) {
+            // Let root pane fix window size.
+            StackPane parent = (StackPane) c.getParent();
+            ((Region) c).prefWidthProperty().bind(parent.widthProperty());
+            ((Region) c).prefHeightProperty().bind(parent.heightProperty());
+        }
+    }
+
+    public void showDialog(Node node) {
+        FXUtils.checkFxUserThread();
+
+        if (dialog == null) {
+            dialog = new JFXDialog();
+            dialogPane = new StackContainerPane();
+
+            dialog.setContent(dialogPane);
+            dialog.setDialogContainer(drawerWrapper);
+            dialog.setOverlayClose(false);
+            dialog.show();
+        }
+
+        dialogPane.push(node);
+
+        EventHandler<DialogCloseEvent> handler = event -> closeDialog(node);
+        node.getProperties().put(PROPERTY_DIALOG_CLOSE_HANDLER, handler);
+        node.addEventHandler(DialogCloseEvent.CLOSE, handler);
+    }
+
+    @SuppressWarnings("unchecked")
+    public void closeDialog(Node node) {
+        FXUtils.checkFxUserThread();
+
+        Optional.ofNullable(node.getProperties().get(PROPERTY_DIALOG_CLOSE_HANDLER))
+                .ifPresent(handler -> node.removeEventHandler(DialogCloseEvent.CLOSE, (EventHandler<DialogCloseEvent>) handler));
+
+        dialogPane.pop(node);
+
+        if (dialogPane.getChildren().isEmpty()) {
+            dialog.close();
+            dialog = null;
+            dialogPane = null;
+        }
+    }
+
+    public void startWizard(WizardProvider wizardProvider) {
+        startWizard(wizardProvider, null);
+    }
+
+    public void startWizard(WizardProvider wizardProvider, String category) {
+        FXUtils.checkFxUserThread();
+
+        this.category = category;
+        wizardController.setProvider(wizardProvider);
+        wizardController.onStart();
+    }
+
+    @Override
+    public void onStart() {
+        backNavButton.setVisible(true);
+        backNavButton.setDisable(false);
+        showCloseNavButton();
+        refreshNavButton.setVisible(false);
+    }
+
+    @Override
+    public void onEnd() {
+        backNavButton.setVisible(false);
+        hideCloseNavButton();
+        refreshNavButton.setVisible(false);
+    }
+
+    @Override
+    public void navigateTo(Node page, Navigation.NavigationDirection nav) {
+        contentPlaceHolder.getStyleClass().removeAll("gray-background", "white-background");
+        contentPlaceHolder.getStyleClass().add("white-background");
+        setContent(page, nav.getAnimation().getAnimationProducer());
+        isWizardPageNow = true;
+    }
+
+    @FXML
+    private void onRefresh() {
+        ((Refreshable) contentPlaceHolder.getChildren().get(0)).refresh();
+    }
+
+    @FXML
+    private void onCloseNav() {
+        wizardController.onCancel();
+        showPage(null);
+    }
+
+    @FXML
+    private void onBack() {
+        if (isWizardPageNow && wizardController.canPrev())
+            wizardController.onPrev(true);
+        else
+            onCloseNav();
+    }
+
+    @Override
+    public Queue<Object> getCancelQueue() {
+        return cancelQueue;
+    }
+
+    public Runnable getOnCloseButtonAction() {
+        return onCloseButtonAction.get();
+    }
+
+    public ObjectProperty<Runnable> onCloseButtonActionProperty() {
+        return onCloseButtonAction;
+    }
+
+    public void setOnCloseButtonAction(Runnable onCloseButtonAction) {
+        this.onCloseButtonAction.set(onCloseButtonAction);
+    }
+
+    public boolean isCustomMaximize() {
+        return customMaximize.get();
+    }
+
+    public BooleanProperty customMaximizeProperty() {
+        return customMaximize;
+    }
+
+    public void setCustomMaximize(boolean customMaximize) {
+        this.customMaximize.set(customMaximize);
+    }
+
+    @Override
+    public WizardController getWizardController() {
+        return wizardController;
+    }
+
+    public AdvancedListBox getLeftPane() {
+        return leftPane;
+    }
+
+    private void setupAuthlibInjectorDnD() {
+        addEventFilter(DragEvent.DRAG_OVER, AuthlibInjectorDnD.dragOverHandler());
+        addEventFilter(DragEvent.DRAG_DROPPED, AuthlibInjectorDnD.dragDroppedHandler(
+                url -> Controllers.dialog(new AddAuthlibInjectorServerPane(url))));
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/DialogController.java

@@ -0,0 +1,48 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.auth.AuthInfo;
+import org.jackhuang.hmcl.auth.yggdrasil.YggdrasilAccount;
+import org.jackhuang.hmcl.task.SilentException;
+
+import java.util.Optional;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+
+public final class DialogController {
+
+    public static AuthInfo logIn(Account account) throws Exception {
+        if (account instanceof YggdrasilAccount) {
+            CountDownLatch latch = new CountDownLatch(1);
+            AtomicReference<AuthInfo> res = new AtomicReference<>(null);
+            JFXUtilities.runInFX(() -> {
+                AccountLoginPane pane = new AccountLoginPane(account, it -> {
+                        res.set(it);
+                        latch.countDown();
+                }, latch::countDown);
+                Controllers.dialog(pane);
+            });
+            latch.await();
+            return Optional.ofNullable(res.get()).orElseThrow(SilentException::new);
+        }
+        return account.logIn();
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/FXUtils.java

@@ -0,0 +1,452 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.*;
+import javafx.animation.Animation;
+import javafx.animation.Interpolator;
+import javafx.animation.KeyFrame;
+import javafx.animation.Timeline;
+import javafx.application.Platform;
+import javafx.beans.InvalidationListener;
+import javafx.beans.property.Property;
+import javafx.beans.value.ChangeListener;
+import javafx.beans.value.ObservableValue;
+import javafx.beans.value.WeakChangeListener;
+import javafx.event.EventHandler;
+import javafx.fxml.FXMLLoader;
+import javafx.scene.Node;
+import javafx.scene.control.ListCell;
+import javafx.scene.control.ListView;
+import javafx.scene.control.ScrollBar;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.control.Tooltip;
+import javafx.scene.image.ImageView;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.input.ScrollEvent;
+import javafx.scene.layout.Region;
+import javafx.scene.shape.Rectangle;
+import javafx.util.Callback;
+import javafx.util.Duration;
+import javafx.util.StringConverter;
+
+import org.jackhuang.hmcl.util.*;
+import org.jackhuang.hmcl.util.i18n.I18n;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.net.URI;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+
+import static org.jackhuang.hmcl.util.Lang.tryCast;
+
+public final class FXUtils {
+    private FXUtils() {
+    }
+
+    public static void checkFxUserThread() {
+        if (!Platform.isFxApplicationThread()) {
+            throw new IllegalStateException("Not on FX application thread; currentThread = "
+                    + Thread.currentThread().getName());
+        }
+    }
+
+    public static InvalidationListener onInvalidating(Runnable action) {
+        return arg -> action.run();
+    }
+
+    public static <T> void onChange(ObservableValue<T> value, Consumer<T> consumer) {
+        value.addListener((a, b, c) -> consumer.accept(c));
+    }
+
+    public static <T> void onWeakChange(ObservableValue<T> value, Consumer<T> consumer) {
+        value.addListener(new WeakChangeListener<>((a, b, c) -> consumer.accept(c)));
+    }
+
+    public static <T> void onChangeAndOperate(ObservableValue<T> value, Consumer<T> consumer) {
+        onChange(value, consumer);
+        consumer.accept(value.getValue());
+    }
+
+    public static <T> void onWeakChangeAndOperate(ObservableValue<T> value, Consumer<T> consumer) {
+        onWeakChange(value, consumer);
+        consumer.accept(value.getValue());
+    }
+
+    public static void limitSize(ImageView imageView, double maxWidth, double maxHeight) {
+        imageView.setPreserveRatio(true);
+        onChangeAndOperate(imageView.imageProperty(), image -> {
+            if (image != null && (image.getWidth() > maxWidth || image.getHeight() > maxHeight)) {
+                imageView.setFitHeight(maxHeight);
+                imageView.setFitWidth(maxWidth);
+            } else {
+                imageView.setFitHeight(-1);
+                imageView.setFitWidth(-1);
+            }
+        });
+    }
+
+    private static class ListenerPair<T> {
+        private final ObservableValue<T> value;
+        private final ChangeListener<? super T> listener;
+
+        ListenerPair(ObservableValue<T> value, ChangeListener<? super T> listener) {
+            this.value = value;
+            this.listener = listener;
+        }
+
+        void bind() {
+            value.addListener(listener);
+        }
+
+        void unbind() {
+            value.removeListener(listener);
+        }
+    }
+
+    public static <T> void addListener(Node node, String key, ObservableValue<T> value, Consumer<? super T> callback) {
+        ListenerPair<T> pair = new ListenerPair<>(value, (a, b, newValue) -> callback.accept(newValue));
+        node.getProperties().put(key, pair);
+        pair.bind();
+    }
+
+    public static void removeListener(Node node, String key) {
+        tryCast(node.getProperties().get(key), ListenerPair.class)
+                .ifPresent(info -> {
+                    info.unbind();
+                    node.getProperties().remove(key);
+                });
+    }
+
+    public static void setValidateWhileTextChanged(Node field, boolean validate) {
+        if (field instanceof JFXTextField) {
+            if (validate) {
+                addListener(field, "FXUtils.validation", ((JFXTextField) field).textProperty(), o -> ((JFXTextField) field).validate());
+            } else {
+                removeListener(field, "FXUtils.validation");
+            }
+            ((JFXTextField) field).validate();
+        } else if (field instanceof JFXPasswordField) {
+            if (validate) {
+                addListener(field, "FXUtils.validation", ((JFXPasswordField) field).textProperty(), o -> ((JFXPasswordField) field).validate());
+            } else {
+                removeListener(field, "FXUtils.validation");
+            }
+            ((JFXPasswordField) field).validate();
+        } else
+            throw new IllegalArgumentException("Only JFXTextField and JFXPasswordField allowed");
+    }
+
+    public static boolean getValidateWhileTextChanged(Node field) {
+        return field.getProperties().containsKey("FXUtils.validation");
+    }
+
+    public static void setOverflowHidden(Region region, boolean hidden) {
+        if (hidden) {
+            Rectangle rectangle = new Rectangle();
+            rectangle.widthProperty().bind(region.widthProperty());
+            rectangle.heightProperty().bind(region.heightProperty());
+            region.setClip(rectangle);
+        } else {
+            region.setClip(null);
+        }
+    }
+
+    public static boolean getOverflowHidden(Region region) {
+        return region.getClip() != null;
+    }
+
+    public static void setLimitWidth(Region region, double width) {
+        region.setMaxWidth(width);
+        region.setMinWidth(width);
+        region.setPrefWidth(width);
+    }
+
+    public static double getLimitWidth(Region region) {
+        return region.getMaxWidth();
+    }
+
+    public static void setLimitHeight(Region region, double height) {
+        region.setMaxHeight(height);
+        region.setMinHeight(height);
+        region.setPrefHeight(height);
+    }
+
+    public static double getLimitHeight(Region region) {
+        return region.getMaxHeight();
+    }
+
+    public static void smoothScrolling(ScrollPane scrollPane) {
+        JFXScrollPane.smoothScrolling(scrollPane);
+    }
+
+    public static void loadFXML(Node node, String absolutePath) {
+        FXMLLoader loader = new FXMLLoader(node.getClass().getResource(absolutePath), I18n.getResourceBundle());
+        loader.setRoot(node);
+        loader.setController(node);
+        Lang.invoke((ExceptionalSupplier<Object, IOException>) loader::load);
+    }
+
+    public static void installTooltip(Node node, String tooltip) {
+        installTooltip(node, 0, 5000, 0, new Tooltip(tooltip));
+    }
+
+    public static void installTooltip(Node node, double openDelay, double visibleDelay, double closeDelay, Tooltip tooltip) {
+        try {
+            // Java 8
+            Class<?> behaviorClass = Class.forName("javafx.scene.control.Tooltip$TooltipBehavior");
+            Constructor<?> behaviorConstructor = behaviorClass.getDeclaredConstructor(Duration.class, Duration.class, Duration.class, boolean.class);
+            behaviorConstructor.setAccessible(true);
+            Object behavior = behaviorConstructor.newInstance(new Duration(openDelay), new Duration(visibleDelay), new Duration(closeDelay), false);
+            Method installMethod = behaviorClass.getDeclaredMethod("install", Node.class, Tooltip.class);
+            installMethod.setAccessible(true);
+            installMethod.invoke(behavior, node, tooltip);
+        } catch (ReflectiveOperationException e) {
+            try {
+                // Java 9
+                Tooltip.class.getMethod("setShowDelay", Duration.class).invoke(tooltip, new Duration(openDelay));
+                Tooltip.class.getMethod("setShowDuration", Duration.class).invoke(tooltip, new Duration(visibleDelay));
+                Tooltip.class.getMethod("setHideDelay", Duration.class).invoke(tooltip, new Duration(closeDelay));
+            } catch (ReflectiveOperationException e2) {
+                e.addSuppressed(e2);
+                Logging.LOG.log(Level.SEVERE, "Cannot install tooltip", e);
+            }
+            Tooltip.install(node, tooltip);
+        }
+    }
+
+    public static void openFolder(File file) {
+        if (!FileUtils.makeDirectory(file)) {
+            Logging.LOG.log(Level.SEVERE, "Unable to make directory " + file);
+            return;
+        }
+
+        String path = file.getAbsolutePath();
+
+        switch (OperatingSystem.CURRENT_OS) {
+            case OSX:
+                try {
+                    Runtime.getRuntime().exec(new String[]{"/usr/bin/open", path});
+                } catch (IOException e) {
+                    Logging.LOG.log(Level.SEVERE, "Unable to open " + path + " by executing /usr/bin/open", e);
+                }
+                break;
+            default:
+                try {
+                    java.awt.Desktop.getDesktop().open(file);
+                } catch (Throwable e) {
+                    Logging.LOG.log(Level.SEVERE, "Unable to open " + path + " by java.awt.Desktop.getDesktop()::open", e);
+                }
+        }
+    }
+
+    /**
+     * Open URL by java.awt.Desktop
+     *
+     * @param link null is allowed but will be ignored
+     */
+    public static void openLink(String link) {
+        if (link == null)
+            return;
+        try {
+            java.awt.Desktop.getDesktop().browse(new URI(link));
+        } catch (Throwable e) {
+            if (OperatingSystem.CURRENT_OS == OperatingSystem.OSX)
+                try {
+                    Runtime.getRuntime().exec(new String[] { "/usr/bin/open", link });
+                } catch (IOException ex) {
+                    Logging.LOG.log(Level.WARNING, "Unable to open link: " + link, ex);
+                }
+            Logging.LOG.log(Level.WARNING, "Failed to open link: " + link, e);
+        }
+    }
+
+    public static void bindInt(JFXTextField textField, Property<Number> property) {
+        textField.textProperty().bindBidirectional(property, SafeIntStringConverter.INSTANCE);
+    }
+
+    public static void unbindInt(JFXTextField textField, Property<Number> property) {
+        textField.textProperty().unbindBidirectional(property);
+    }
+
+    public static void bindString(JFXTextField textField, Property<String> property) {
+        textField.textProperty().bindBidirectional(property);
+    }
+
+    public static void unbindString(JFXTextField textField, Property<String> property) {
+        textField.textProperty().unbindBidirectional(property);
+    }
+
+    public static void bindBoolean(JFXToggleButton toggleButton, Property<Boolean> property) {
+        toggleButton.selectedProperty().bindBidirectional(property);
+    }
+
+    public static void unbindBoolean(JFXToggleButton toggleButton, Property<Boolean> property) {
+        toggleButton.selectedProperty().unbindBidirectional(property);
+    }
+
+    public static void bindBoolean(JFXCheckBox checkBox, Property<Boolean> property) {
+        checkBox.selectedProperty().bindBidirectional(property);
+    }
+
+    public static void unbindBoolean(JFXCheckBox checkBox, Property<Boolean> property) {
+        checkBox.selectedProperty().unbindBidirectional(property);
+    }
+
+    /**
+     * Bind combo box selection with given enum property bidirectionally.
+     * You should <b>only and always</b> use {@code bindEnum} as well as {@code unbindEnum} at the same time.
+     * @param comboBox the combo box being bound with {@code property}.
+     * @param property the property being bound with {@code combo box}.
+     * @see #unbindEnum(JFXComboBox)
+     */
+    @SuppressWarnings("unchecked")
+    public static void bindEnum(JFXComboBox<?> comboBox, Property<? extends Enum> property) {
+        unbindEnum(comboBox);
+        ChangeListener<Number> listener = (a, b, newValue) ->
+                ((Property) property).setValue(property.getValue().getClass().getEnumConstants()[newValue.intValue()]);
+        comboBox.getSelectionModel().select(property.getValue().ordinal());
+        comboBox.getProperties().put("FXUtils.bindEnum.listener", listener);
+        comboBox.getSelectionModel().selectedIndexProperty().addListener(listener);
+    }
+
+    /**
+     * Unbind combo box selection with given enum property bidirectionally.
+     * You should <b>only and always</b> use {@code bindEnum} as well as {@code unbindEnum} at the same time.
+     * @param comboBox the combo box being bound with the property which can be inferred by {@code bindEnum}.
+     * @see #bindEnum(JFXComboBox, Property)
+     */
+    @SuppressWarnings("unchecked")
+    public static void unbindEnum(JFXComboBox<?> comboBox) {
+        ChangeListener listener = tryCast(comboBox.getProperties().get("FXUtils.bindEnum.listener"), ChangeListener.class).orElse(null);
+        if (listener == null) return;
+        comboBox.getSelectionModel().selectedIndexProperty().removeListener(listener);
+    }
+
+    public static void smoothScrolling(ListView<?> listView) {
+        listView.skinProperty().addListener(o -> {
+            ScrollBar bar = (ScrollBar) listView.lookup(".scroll-bar");
+            Node virtualFlow = listView.lookup(".virtual-flow");
+            double[] frictions = new double[]{0.99, 0.1, 0.05, 0.04, 0.03, 0.02, 0.01, 0.04, 0.01, 0.008, 0.008, 0.008, 0.008, 0.0006, 0.0005, 0.00003, 0.00001};
+            double[] pushes = new double[]{1};
+            double[] derivatives = new double[frictions.length];
+
+            Timeline timeline = new Timeline();
+            bar.addEventHandler(MouseEvent.DRAG_DETECTED, e -> timeline.stop());
+
+            EventHandler<ScrollEvent> scrollEventHandler = event -> {
+                if (event.getEventType() == ScrollEvent.SCROLL) {
+                    int direction = event.getDeltaY() > 0 ? -1 : 1;
+                    for (int i = 0; i < pushes.length; ++i)
+                        derivatives[i] += direction * pushes[i];
+                    if (timeline.getStatus() == Animation.Status.STOPPED)
+                        timeline.play();
+                    event.consume();
+                }
+            };
+
+            bar.addEventHandler(ScrollEvent.ANY, scrollEventHandler);
+            virtualFlow.setOnScroll(scrollEventHandler);
+
+            timeline.getKeyFrames().add(new KeyFrame(Duration.millis(3), event -> {
+                for (int i = 0; i < derivatives.length; ++i)
+                    derivatives[i] *= frictions[i];
+                for (int i = 1; i < derivatives.length; ++i)
+                    derivatives[i] += derivatives[i - 1];
+                double dy = derivatives[derivatives.length - 1];
+                double height = listView.getLayoutBounds().getHeight();
+                bar.setValue(Math.min(Math.max(bar.getValue() + dy / height, 0), 1));
+                if (Math.abs(dy) < 0.001)
+                    timeline.stop();
+                listView.requestLayout();
+            }));
+            timeline.setCycleCount(Animation.INDEFINITE);
+        });
+    }
+
+    public static <T> T runInUIThread(Supplier<T> supplier) {
+        if (javafx.application.Platform.isFxApplicationThread()) {
+            return supplier.get();
+        } else {
+            CountDownLatch doneLatch = new CountDownLatch(1);
+            AtomicReference<T> reference = new AtomicReference<>();
+            Platform.runLater(() -> {
+                try {
+                    reference.set(supplier.get());
+                } finally {
+                    doneLatch.countDown();
+                }
+
+            });
+
+            try {
+                doneLatch.await();
+            } catch (InterruptedException var3) {
+                Thread.currentThread().interrupt();
+            }
+
+            return reference.get();
+        }
+    }
+
+    public static <T> StringConverter<T> stringConverter(Function<T, String> func) {
+        return new StringConverter<T>() {
+
+            @Override
+            public String toString(T object) {
+                return object == null ? "" : func.apply(object);
+            }
+
+            @Override
+            public T fromString(String string) {
+                throw new UnsupportedOperationException();
+            }
+        };
+    }
+
+    public static <T> Callback<ListView<T>, ListCell<T>> jfxListCellFactory(Function<T, Node> graphicBuilder) {
+        return view -> new JFXListCell<T>() {
+            @Override
+            public void updateItem(T item, boolean empty) {
+                super.updateItem(item, empty);
+                if (!empty) {
+                    setGraphic(graphicBuilder.apply(item));
+                }
+            }
+        };
+    }
+
+    public static final Interpolator SINE = new Interpolator() {
+        @Override
+        protected double curve(double t) {
+            return Math.sin(t * Math.PI / 2);
+        }
+
+        @Override
+        public String toString() {
+            return "Interpolator.SINE";
+        }
+    };
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/InstallerController.java

@@ -0,0 +1,98 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import javafx.fxml.FXML;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.layout.VBox;
+
+import org.jackhuang.hmcl.download.MaintainTask;
+import org.jackhuang.hmcl.download.game.VersionJsonSaveTask;
+import org.jackhuang.hmcl.game.GameVersion;
+import org.jackhuang.hmcl.game.Library;
+import org.jackhuang.hmcl.game.Version;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.download.InstallerWizardProvider;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.LinkedList;
+import java.util.Optional;
+import java.util.function.Consumer;
+
+public class InstallerController {
+    private Profile profile;
+    private String versionId;
+    private Version version;
+    @FXML
+    private ScrollPane scrollPane;
+    @FXML private VBox contentPane;
+    private String forge;
+    private String liteLoader;
+    private String optiFine;
+
+    @FXML
+    private void initialize() {
+        FXUtils.smoothScrolling(scrollPane);
+    }
+
+    public void loadVersion(Profile profile, String versionId) {
+        this.profile = profile;
+        this.versionId = versionId;
+        this.version = profile.getRepository().getResolvedVersion(versionId);
+
+        contentPane.getChildren().clear();
+        forge = liteLoader = optiFine = null;
+
+        for (Library library : version.getLibraries()) {
+            Consumer<InstallerItem> removeAction = x -> {
+                LinkedList<Library> newList = new LinkedList<>(version.getLibraries());
+                newList.remove(library);
+                new MaintainTask(version.setLibraries(newList))
+                        .then(variables -> new VersionJsonSaveTask(profile.getRepository(), variables.get(MaintainTask.ID)))
+                        .with(profile.getRepository().refreshVersionsAsync())
+                        .with(Task.of(Schedulers.javafx(), () -> loadVersion(this.profile, this.versionId)))
+                        .start();
+            };
+
+            if (library.getGroupId().equalsIgnoreCase("net.minecraftforge") && library.getArtifactId().equalsIgnoreCase("forge")) {
+                contentPane.getChildren().add(new InstallerItem("Forge", library.getVersion(), removeAction));
+                forge = library.getVersion();
+            }
+            if (library.getGroupId().equalsIgnoreCase("com.mumfrey") && library.getArtifactId().equalsIgnoreCase("liteloader")) {
+                contentPane.getChildren().add(new InstallerItem("LiteLoader", library.getVersion(), removeAction));
+                liteLoader = library.getVersion();
+            }
+            if (library.getGroupId().equalsIgnoreCase("net.optifine") && library.getArtifactId().equalsIgnoreCase("optifine")) {
+                contentPane.getChildren().add(new InstallerItem("OptiFine", library.getVersion(), removeAction));
+                optiFine = library.getVersion();
+            }
+        }
+    }
+
+    @FXML
+    private void onAdd() {
+        Optional<String> gameVersion = GameVersion.minecraftVersion(profile.getRepository().getVersionJar(version));
+
+        if (!gameVersion.isPresent())
+            Controllers.dialog(i18n("version.cannot_read"));
+        else
+            Controllers.getDecorator().startWizard(new InstallerWizardProvider(profile, gameVersion.get(), version, forge, liteLoader, optiFine));
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/InstallerItem.java

@@ -0,0 +1,55 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.effects.JFXDepthManager;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.layout.BorderPane;
+
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.function.Consumer;
+
+/**
+ * @author huangyuhui
+ */
+public class InstallerItem extends BorderPane {
+    private final Consumer<InstallerItem> deleteCallback;
+
+    @FXML
+    private Label lblInstallerArtifact;
+
+    @FXML
+    private Label lblInstallerVersion;
+
+    public InstallerItem(String artifact, String version, Consumer<InstallerItem> deleteCallback) {
+        this.deleteCallback = deleteCallback;
+        FXUtils.loadFXML(this, "/assets/fxml/version/installer-item.fxml");
+
+        setStyle("-fx-background-radius: 2; -fx-background-color: white; -fx-padding: 8;");
+        JFXDepthManager.setDepth(this, 1);
+        lblInstallerArtifact.setText(artifact);
+        lblInstallerVersion.setText(i18n("archive.version") + ": " + version);
+    }
+
+    @FXML
+    private void onDelete() {
+        deleteCallback.accept(this);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/LeftPaneController.java

@@ -0,0 +1,255 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXPopup;
+import javafx.application.Platform;
+import javafx.scene.Node;
+import javafx.scene.control.Tooltip;
+import javafx.scene.image.Image;
+import javafx.scene.input.MouseButton;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+
+import org.jackhuang.hmcl.auth.Account;
+import org.jackhuang.hmcl.auth.authlibinjector.AuthlibInjectorAccount;
+import org.jackhuang.hmcl.auth.offline.OfflineAccount;
+import org.jackhuang.hmcl.auth.yggdrasil.YggdrasilAccount;
+import org.jackhuang.hmcl.event.*;
+import org.jackhuang.hmcl.game.AccountHelper;
+import org.jackhuang.hmcl.game.HMCLGameRepository;
+import org.jackhuang.hmcl.game.ModpackHelper;
+import org.jackhuang.hmcl.mod.Modpack;
+import org.jackhuang.hmcl.mod.UnsupportedModpackException;
+import org.jackhuang.hmcl.setting.*;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.task.TaskExecutor;
+import org.jackhuang.hmcl.ui.construct.AdvancedListBox;
+import org.jackhuang.hmcl.ui.construct.ClassTitle;
+import org.jackhuang.hmcl.ui.construct.DialogCloseEvent;
+import org.jackhuang.hmcl.ui.construct.IconedItem;
+import org.jackhuang.hmcl.ui.construct.RipplerContainer;
+import org.jackhuang.hmcl.util.Lang;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.Objects;
+import java.util.concurrent.atomic.AtomicReference;
+
+public final class LeftPaneController {
+    private final AdvancedListBox leftPane;
+    private final VBox profilePane = new VBox();
+    private final VBox accountPane = new VBox();
+    private final IconedItem launcherSettingsItem;
+    private final VersionListItem missingAccountItem = new VersionListItem(i18n("account.missing"), i18n("message.unknown"));
+    private final HashMap<Account, VersionListItem> items = new HashMap<>();
+
+    public LeftPaneController(AdvancedListBox leftPane) {
+        this.leftPane = leftPane;
+
+        this.launcherSettingsItem = Lang.apply(new IconedItem(SVG.gear(Theme.blackFillBinding(), 20, 20), i18n("settings.launcher")), iconedItem -> {
+            iconedItem.prefWidthProperty().bind(leftPane.widthProperty());
+            iconedItem.setOnMouseClicked(e -> Controllers.navigate(Controllers.getSettingsPage()));
+        });
+
+        leftPane
+                .add(new ClassTitle(i18n("account").toUpperCase(), Lang.apply(new JFXButton(), button -> {
+                    button.setGraphic(SVG.plus(Theme.blackFillBinding(), 10, 10));
+                    button.getStyleClass().add("toggle-icon-tiny");
+                    button.setOnMouseClicked(e -> addNewAccount());
+                })))
+                .add(accountPane)
+                .startCategory(i18n("launcher").toUpperCase())
+                .add(launcherSettingsItem)
+                .add(new ClassTitle(i18n("profile.title").toUpperCase(), Lang.apply(new JFXButton(), button -> {
+                    button.setGraphic(SVG.plus(Theme.blackFillBinding(), 10, 10));
+                    button.getStyleClass().add("toggle-icon-tiny");
+                    button.setOnMouseClicked(e ->
+                            Controllers.getDecorator().showPage(new ProfilePage(null)));
+                })))
+                .add(profilePane);
+
+        EventBus.EVENT_BUS.channel(AccountAddedEvent.class).register(this::onAccountAdd);
+        EventBus.EVENT_BUS.channel(AccountLoadingEvent.class).register(this::onAccountsLoading);
+        EventBus.EVENT_BUS.channel(ProfileLoadingEvent.class).register(this::onProfilesLoading);
+        EventBus.EVENT_BUS.channel(ProfileChangedEvent.class).register(this::onProfileChanged);
+        EventBus.EVENT_BUS.channel(RefreshedVersionsEvent.class).register(this::onRefreshedVersions);
+
+        FXUtils.onChangeAndOperate(Settings.INSTANCE.selectedAccountProperty(), this::onSelectedAccountChanged);
+        onAccountsLoading();
+    }
+
+    private void addNewAccount() {
+        Controllers.dialog(new AddAccountPane());
+    }
+
+    private void onSelectedAccountChanged(Account newAccount) {
+        Platform.runLater(() -> {
+            for (Node node : accountPane.getChildren()) {
+                if (node instanceof RipplerContainer && node.getProperties().get("account") instanceof Account) {
+                    boolean current = Objects.equals(node.getProperties().get("account"), newAccount);
+                    ((RipplerContainer) node).setSelected(current);
+                }
+            }
+        });
+    }
+
+    private void onProfileChanged(ProfileChangedEvent event) {
+        Profile profile = event.getProfile();
+
+        Platform.runLater(() -> {
+            for (Node node : profilePane.getChildren()) {
+                if (node instanceof RipplerContainer && node.getProperties().get("profile") instanceof String) {
+                    boolean current = Objects.equals(node.getProperties().get("profile"), profile.getName());
+                    ((RipplerContainer) node).setSelected(current);
+                    ((VersionListItem) ((RipplerContainer) node).getContainer()).setGameVersion(current ? i18n("profile.selected") : "");
+                }
+            }
+        });
+    }
+
+    private void onProfilesLoading() {
+        LinkedList<RipplerContainer> list = new LinkedList<>();
+        for (Profile profile : Settings.INSTANCE.getProfiles()) {
+            VersionListItem item = new VersionListItem(Profiles.getProfileDisplayName(profile));
+            RipplerContainer ripplerContainer = new RipplerContainer(item);
+            item.setOnSettingsButtonClicked(e -> Controllers.getDecorator().showPage(new ProfilePage(profile)));
+            ripplerContainer.setOnMouseClicked(e -> Settings.INSTANCE.setSelectedProfile(profile));
+            ripplerContainer.getProperties().put("profile", profile.getName());
+            ripplerContainer.maxWidthProperty().bind(leftPane.widthProperty());
+            list.add(ripplerContainer);
+        }
+        Platform.runLater(() -> profilePane.getChildren().setAll(list));
+    }
+
+    private static String accountType(Account account) {
+        if (account instanceof OfflineAccount) return i18n("account.methods.offline");
+        else if (account instanceof YggdrasilAccount) return account.getUsername();
+        else throw new Error(i18n("account.methods.no_method") + ": " + account);
+    }
+
+    private void onAccountAdd(AccountAddedEvent event) {
+        Account account = event.getAccount();
+        VersionListItem item = items.get(account);
+        if (account instanceof YggdrasilAccount)
+            AccountHelper.refreshSkinAsync((YggdrasilAccount) account)
+                    .subscribe(Schedulers.javafx(), () -> {
+                        Image image = AccountHelper.getSkin((YggdrasilAccount) account, 4);
+                        item.setImage(image, AccountHelper.getViewport(4));
+                    });
+    }
+
+    private void onAccountsLoading() {
+        LinkedList<RipplerContainer> list = new LinkedList<>();
+        items.clear();
+        Account selectedAccount = Settings.INSTANCE.getSelectedAccount();
+        for (Account account : Settings.INSTANCE.getAccounts()) {
+            VersionListItem item = new VersionListItem(account.getCharacter(), accountType(account));
+            items.put(account, item);
+            RipplerContainer ripplerContainer = new RipplerContainer(item);
+            item.setOnSettingsButtonClicked(e -> {
+                AccountPage accountPage = new AccountPage(account, item);
+                JFXPopup popup = new JFXPopup(accountPage);
+                accountPage.setOnDelete(popup::hide);
+                popup.show((Node) e.getSource(), JFXPopup.PopupVPosition.TOP, JFXPopup.PopupHPosition.LEFT, e.getX(), e.getY());
+            });
+            ripplerContainer.setOnMouseClicked(e -> {
+                if (e.getButton() == MouseButton.PRIMARY)
+                    Settings.INSTANCE.setSelectedAccount(account);
+            });
+            ripplerContainer.getProperties().put("account", account);
+            ripplerContainer.maxWidthProperty().bind(leftPane.widthProperty());
+
+            if (account instanceof YggdrasilAccount) {
+                Image image = AccountHelper.getSkin((YggdrasilAccount) account, 4);
+                item.setImage(image, AccountHelper.getViewport(4));
+            } else
+                item.setImage(AccountHelper.getDefaultSkin(account.getUUID(), 4), AccountHelper.getViewport(4));
+
+            if (account instanceof AuthlibInjectorAccount) {
+                FXUtils.installTooltip(ripplerContainer, 500, 5000, 0, new Tooltip(((AuthlibInjectorAccount) account).getServer().getName()));
+            }
+
+            if (selectedAccount == account)
+                ripplerContainer.setSelected(true);
+
+            list.add(ripplerContainer);
+        }
+
+        if (Settings.INSTANCE.getAccounts().isEmpty()) {
+            RipplerContainer container = new RipplerContainer(missingAccountItem);
+            missingAccountItem.setOnSettingsButtonClicked(e -> addNewAccount());
+            container.setOnMouseClicked(e -> addNewAccount());
+            list.add(container);
+        }
+
+        Platform.runLater(() -> accountPane.getChildren().setAll(list));
+    }
+
+    public void showUpdate() {
+        launcherSettingsItem.setText(i18n("update.found"));
+        launcherSettingsItem.setTextFill(Color.RED);
+    }
+
+    private boolean checkedModpack = false;
+    private static boolean showNewAccount = true;
+
+    private void onRefreshedVersions(RefreshedVersionsEvent event) {
+        JFXUtilities.runInFX(() -> {
+            HMCLGameRepository repository = (HMCLGameRepository) event.getSource();
+            if (!checkedModpack) {
+                checkedModpack = true;
+
+                if (repository.getVersionCount() == 0) {
+                    File modpackFile = new File("modpack.zip").getAbsoluteFile();
+                    if (modpackFile.exists()) {
+                        try {
+                            AtomicReference<Region> region = new AtomicReference<>();
+                            Modpack modpack = ModpackHelper.readModpackManifest(modpackFile);
+                            TaskExecutor executor = ModpackHelper.getInstallTask(repository.getProfile(), modpackFile, modpack.getName(), modpack)
+                                    .with(Task.of(Schedulers.javafx(), () -> {
+                                        region.get().fireEvent(new DialogCloseEvent());
+                                        checkAccount();
+                                    })).executor();
+                            region.set(Controllers.taskDialog(executor, i18n("modpack.installing"), ""));
+                            executor.start();
+                            showNewAccount = false;
+                        } catch (UnsupportedModpackException ignore) {
+                        }
+                    }
+                }
+            }
+
+            if (showNewAccount) {
+                showNewAccount = false;
+                checkAccount();
+            }
+        });
+    }
+
+    public void checkAccount() {
+        if (Settings.INSTANCE.getAccounts().isEmpty())
+            addNewAccount();
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/LogWindow.java

@@ -0,0 +1,245 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import javafx.beans.binding.Bindings;
+import javafx.beans.property.ReadOnlyIntegerProperty;
+import javafx.beans.property.ReadOnlyIntegerWrapper;
+import javafx.concurrent.Worker;
+import javafx.fxml.FXML;
+import javafx.scene.Scene;
+import javafx.scene.control.ComboBox;
+import javafx.scene.control.ToggleButton;
+import javafx.scene.image.Image;
+import javafx.scene.layout.StackPane;
+import javafx.scene.web.WebEngine;
+import javafx.scene.web.WebView;
+import javafx.stage.Stage;
+
+import org.jackhuang.hmcl.event.Event;
+import org.jackhuang.hmcl.event.EventManager;
+import org.jackhuang.hmcl.game.LauncherHelper;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.util.IOUtils;
+import org.jackhuang.hmcl.util.Lang;
+import org.jackhuang.hmcl.util.Log4jLevel;
+import org.jackhuang.hmcl.util.StringUtils;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.concurrent.CountDownLatch;
+
+/**
+ *
+ * @author huangyuhui
+ */
+public final class LogWindow extends Stage {
+
+    private final ReadOnlyIntegerWrapper fatal = new ReadOnlyIntegerWrapper(0);
+    private final ReadOnlyIntegerWrapper error = new ReadOnlyIntegerWrapper(0);
+    private final ReadOnlyIntegerWrapper warn = new ReadOnlyIntegerWrapper(0);
+    private final ReadOnlyIntegerWrapper info = new ReadOnlyIntegerWrapper(0);
+    private final ReadOnlyIntegerWrapper debug = new ReadOnlyIntegerWrapper(0);
+    private final LogWindowImpl impl = new LogWindowImpl();
+    private final CountDownLatch latch = new CountDownLatch(1);
+    public final EventManager<Event> onDone = new EventManager<>();
+
+    public LogWindow() {
+        setScene(new Scene(impl, 800, 480));
+        getScene().getStylesheets().addAll(Settings.INSTANCE.getTheme().getStylesheets());
+        setTitle(i18n("logwindow.title"));
+        getIcons().add(new Image("/assets/img/icon.png"));
+    }
+
+    public LogWindow(String text) {
+        this();
+
+        onDone.register(() -> logLine(text, Log4jLevel.INFO));
+    }
+
+    public ReadOnlyIntegerProperty fatalProperty() {
+        return fatal.getReadOnlyProperty();
+    }
+
+    public int getFatal() {
+        return fatal.get();
+    }
+
+    public ReadOnlyIntegerProperty errorProperty() {
+        return error.getReadOnlyProperty();
+    }
+
+    public int getError() {
+        return error.get();
+    }
+
+    public ReadOnlyIntegerProperty warnProperty() {
+        return warn.getReadOnlyProperty();
+    }
+
+    public int getWarn() {
+        return warn.get();
+    }
+
+    public ReadOnlyIntegerProperty infoProperty() {
+        return info.getReadOnlyProperty();
+    }
+
+    public int getInfo() {
+        return info.get();
+    }
+
+    public ReadOnlyIntegerProperty debugProperty() {
+        return debug.getReadOnlyProperty();
+    }
+
+    public int getDebug() {
+        return debug.get();
+    }
+
+    public void logLine(String line, Log4jLevel level) {
+        Element div = impl.document.createElement("div");
+        // a <pre> element to prevent multiple spaces and tabs being removed.
+        Element pre = impl.document.createElement("pre");
+        pre.setTextContent(line);
+        div.appendChild(pre);
+        impl.body.appendChild(div);
+        impl.engine.executeScript("checkNewLog(\"" + level.name().toLowerCase() + "\");scrollToBottom();");
+
+        switch (level) {
+            case FATAL:
+                fatal.set(fatal.get() + 1);
+                break;
+            case ERROR:
+                error.set(error.get() + 1);
+                break;
+            case WARN:
+                warn.set(warn.get() + 1);
+                break;
+            case INFO:
+                info.set(info.get() + 1);
+                break;
+            case DEBUG:
+                debug.set(debug.get() + 1);
+                break;
+            default:
+                // ignore
+                break;
+        }
+    }
+
+    public void waitForLoaded() throws InterruptedException {
+        latch.await();
+    }
+
+    public class LogWindowImpl extends StackPane {
+
+        @FXML
+        private WebView webView;
+        @FXML
+        private ToggleButton btnFatals;
+        @FXML
+        private ToggleButton btnErrors;
+        @FXML
+        private ToggleButton btnWarns;
+        @FXML
+        private ToggleButton btnInfos;
+        @FXML
+        private ToggleButton btnDebugs;
+        @FXML
+        private ComboBox<String> cboLines;
+
+        final WebEngine engine;
+        Node body;
+        Document document;
+
+        LogWindowImpl() {
+            FXUtils.loadFXML(this, "/assets/fxml/log.fxml");
+
+            engine = webView.getEngine();
+            engine.loadContent(Lang.ignoringException(() -> IOUtils.readFullyAsString(getClass().getResourceAsStream("/assets/log-window-content.html")))
+                    .replace("${FONT}", Settings.INSTANCE.getFont().getSize() + "px \"" + Settings.INSTANCE.getFont().getFamily() + "\""));
+            engine.getLoadWorker().stateProperty().addListener((a, b, newValue) -> {
+                if (newValue == Worker.State.SUCCEEDED) {
+                    document = engine.getDocument();
+                    body = document.getElementsByTagName("body").item(0);
+                    engine.executeScript("limitedLogs=" + Settings.INSTANCE.getLogLines());
+                    latch.countDown();
+                    onDone.fireEvent(new Event(LogWindow.this));
+                }
+            });
+
+            boolean flag = false;
+            for (String i : cboLines.getItems())
+                if (Integer.toString(Settings.INSTANCE.getLogLines()).equals(i)) {
+                    cboLines.getSelectionModel().select(i);
+                    flag = true;
+                }
+
+            cboLines.getSelectionModel().selectedItemProperty().addListener((a, b, newValue) -> {
+                Settings.INSTANCE.setLogLines(newValue == null ? 100 : Integer.parseInt(newValue));
+                engine.executeScript("limitedLogs=" + Settings.INSTANCE.getLogLines());
+            });
+
+            if (!flag)
+                cboLines.getSelectionModel().select(0);
+
+            btnFatals.textProperty().bind(Bindings.createStringBinding(() -> Integer.toString(fatal.get()) + " fatals", fatal));
+            btnErrors.textProperty().bind(Bindings.createStringBinding(() -> Integer.toString(error.get()) + " errors", error));
+            btnWarns.textProperty().bind(Bindings.createStringBinding(() -> Integer.toString(warn.get()) + " warns", warn));
+            btnInfos.textProperty().bind(Bindings.createStringBinding(() -> Integer.toString(info.get()) + " infos", info));
+            btnDebugs.textProperty().bind(Bindings.createStringBinding(() -> Integer.toString(debug.get()) + " debugs", debug));
+
+            btnFatals.selectedProperty().addListener(o -> specificChanged());
+            btnErrors.selectedProperty().addListener(o -> specificChanged());
+            btnWarns.selectedProperty().addListener(o -> specificChanged());
+            btnInfos.selectedProperty().addListener(o -> specificChanged());
+            btnDebugs.selectedProperty().addListener(o -> specificChanged());
+        }
+
+        private void specificChanged() {
+            String res = "";
+            if (btnFatals.isSelected())
+                res += "\"fatal\", ";
+            if (btnErrors.isSelected())
+                res += "\"error\", ";
+            if (btnWarns.isSelected())
+                res += "\"warn\", ";
+            if (btnInfos.isSelected())
+                res += "\"info\", ";
+            if (btnDebugs.isSelected())
+                res += "\"debug\", ";
+            if (StringUtils.isNotBlank(res))
+                res = StringUtils.substringBeforeLast(res, ", ");
+            engine.executeScript("specific([" + res + "])");
+        }
+
+        @FXML
+        private void onTerminateGame() {
+            LauncherHelper.stopManagedProcesses();
+        }
+
+        @FXML
+        private void onClear() {
+            engine.executeScript("clear()");
+        }
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/MainPage.java

@@ -0,0 +1,258 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import com.jfoenix.controls.*;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.Node;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.image.Image;
+import javafx.scene.input.MouseButton;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.StackPane;
+import javafx.stage.FileChooser;
+
+import org.jackhuang.hmcl.event.EventBus;
+import org.jackhuang.hmcl.event.ProfileChangedEvent;
+import org.jackhuang.hmcl.event.RefreshedVersionsEvent;
+import org.jackhuang.hmcl.event.RefreshingVersionsEvent;
+import org.jackhuang.hmcl.game.*;
+import org.jackhuang.hmcl.mod.MismatchedModpackTypeException;
+import org.jackhuang.hmcl.mod.UnsupportedModpackException;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.task.TaskExecutor;
+import org.jackhuang.hmcl.ui.construct.DialogCloseEvent;
+import org.jackhuang.hmcl.ui.construct.MessageBox;
+import org.jackhuang.hmcl.ui.download.DownloadWizardProvider;
+import org.jackhuang.hmcl.ui.wizard.DecoratorPage;
+import org.jackhuang.hmcl.util.Lang;
+import org.jackhuang.hmcl.util.OperatingSystem;
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.Collectors;
+
+import static org.jackhuang.hmcl.util.StringUtils.removePrefix;
+import static org.jackhuang.hmcl.util.StringUtils.removeSuffix;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+public final class MainPage extends StackPane implements DecoratorPage {
+
+    private final StringProperty title = new SimpleStringProperty(this, "title", i18n("main_page"));
+
+    private Profile profile;
+
+    @FXML
+    private JFXButton btnRefresh;
+    @FXML
+    private StackPane contentPane;
+    @FXML
+    private JFXButton btnAdd;
+    @FXML
+    private JFXSpinner spinner;
+    @FXML
+    private JFXMasonryPane masonryPane;
+    @FXML
+    private ScrollPane scrollPane;
+
+    {
+        FXUtils.loadFXML(this, "/assets/fxml/main.fxml");
+
+        loadingVersions();
+
+        EventBus.EVENT_BUS.channel(RefreshedVersionsEvent.class).register(event -> {
+            if (event.getSource() == profile.getRepository())
+                loadVersions((HMCLGameRepository) event.getSource());
+        });
+        EventBus.EVENT_BUS.channel(RefreshingVersionsEvent.class).register(event -> {
+            if (event.getSource() == profile.getRepository())
+                // This will occupy 0.5s. Too slow!
+                JFXUtilities.runInFX(this::loadingVersions);
+        });
+        EventBus.EVENT_BUS.channel(ProfileChangedEvent.class).register(event -> {
+            this.profile = event.getProfile();
+        });
+
+        btnAdd.setOnMouseClicked(e -> Controllers.getDecorator().startWizard(new DownloadWizardProvider(), i18n("install")));
+        FXUtils.installTooltip(btnAdd, i18n("install"));
+        btnRefresh.setOnMouseClicked(e -> Settings.INSTANCE.getSelectedProfile().getRepository().refreshVersionsAsync().start());
+        FXUtils.installTooltip(btnRefresh, i18n("button.refresh"));
+    }
+
+    private String modifyVersion(String gameVersion, String version) {
+        return removeSuffix(removePrefix(removeSuffix(removePrefix(version.replace(gameVersion, "").trim(), "-"), "-"), "_"), "_");
+    }
+
+    private Node buildNode(HMCLGameRepository repository, Version version, Callable<String> gameCallable) {
+        Profile profile = repository.getProfile();
+        String id = version.getId();
+        VersionItem item = new VersionItem();
+        item.setUpdate(repository.isModpack(id));
+        Task.ofResult("game", gameCallable).subscribe(Schedulers.javafx(), vars -> {
+            String game = vars.get("game");
+            item.setGameVersion(game);
+
+            StringBuilder libraries = new StringBuilder();
+            for (Library library : version.getLibraries()) {
+                if (library.getGroupId().equalsIgnoreCase("net.minecraftforge") && library.getArtifactId().equalsIgnoreCase("forge")) {
+                    libraries.append(i18n("install.installer.forge")).append(": ").append(modifyVersion(game, library.getVersion().replaceAll("(?i)forge", ""))).append("\n");
+                }
+                if (library.getGroupId().equalsIgnoreCase("com.mumfrey") && library.getArtifactId().equalsIgnoreCase("liteloader")) {
+                    libraries.append(i18n("install.installer.liteloader")).append(": ").append(modifyVersion(game, library.getVersion().replaceAll("(?i)liteloader", ""))).append("\n");
+                }
+                if (library.getGroupId().equalsIgnoreCase("net.optifine") && library.getArtifactId().equalsIgnoreCase("optifine")) {
+                    libraries.append(i18n("install.installer.optifine")).append(": ").append(modifyVersion(game, library.getVersion().replaceAll("(?i)optifine", ""))).append("\n");
+                }
+            }
+
+            item.setLibraries(libraries.toString());
+        });
+        item.setVersionName(id);
+        item.setOnLaunchButtonClicked(e -> {
+            if (Settings.INSTANCE.getSelectedAccount() == null)
+                Controllers.getLeftPaneController().checkAccount();
+            else
+                LauncherHelper.INSTANCE.launch(profile, Settings.INSTANCE.getSelectedAccount(), id, null);
+        });
+        item.setOnScriptButtonClicked(e -> {
+            if (Settings.INSTANCE.getSelectedAccount() == null)
+                Controllers.dialog(i18n("login.empty_username"));
+            else {
+                FileChooser chooser = new FileChooser();
+                if (repository.getRunDirectory(id).isDirectory())
+                    chooser.setInitialDirectory(repository.getRunDirectory(id));
+                chooser.setTitle(i18n("version.launch_script.save"));
+                chooser.getExtensionFilters().add(OperatingSystem.CURRENT_OS == OperatingSystem.WINDOWS
+                        ? new FileChooser.ExtensionFilter(i18n("extension.bat"), "*.bat")
+                        : new FileChooser.ExtensionFilter(i18n("extension.sh"), "*.sh"));
+                File file = chooser.showSaveDialog(Controllers.getStage());
+                if (file != null)
+                    LauncherHelper.INSTANCE.launch(profile, Settings.INSTANCE.getSelectedAccount(), id, file);
+            }
+        });
+        item.setOnSettingsButtonClicked(e -> {
+            Controllers.getDecorator().showPage(Controllers.getVersionPage());
+            Controllers.getVersionPage().load(id, profile);
+        });
+        item.setOnUpdateButtonClicked(event -> {
+            FileChooser chooser = new FileChooser();
+            chooser.setTitle(i18n("modpack.choose"));
+            chooser.getExtensionFilters().add(new FileChooser.ExtensionFilter(i18n("modpack"), "*.zip"));
+            File selectedFile = chooser.showOpenDialog(Controllers.getStage());
+            if (selectedFile != null) {
+                AtomicReference<Region> region = new AtomicReference<>();
+                try {
+                    TaskExecutor executor = ModpackHelper.getUpdateTask(profile, selectedFile, id, ModpackHelper.readModpackConfiguration(repository.getModpackConfiguration(id)))
+                            .then(Task.of(Schedulers.javafx(), () -> region.get().fireEvent(new DialogCloseEvent()))).executor();
+                    region.set(Controllers.taskDialog(executor, i18n("modpack.update"), ""));
+                    executor.start();
+                } catch (UnsupportedModpackException e) {
+                    region.get().fireEvent(new DialogCloseEvent());
+                    Controllers.dialog(i18n("modpack.unsupported"), i18n("message.error"), MessageBox.ERROR_MESSAGE);
+                } catch (MismatchedModpackTypeException e) {
+                    region.get().fireEvent(new DialogCloseEvent());
+                    Controllers.dialog(i18n("modpack.mismatched_type"), i18n("message.error"), MessageBox.ERROR_MESSAGE);
+                } catch (IOException e) {
+                    region.get().fireEvent(new DialogCloseEvent());
+                    Controllers.dialog(i18n("modpack.invalid"), i18n("message.error"), MessageBox.ERROR_MESSAGE);
+                }
+            }
+        });
+        item.setOnMouseClicked(event -> {
+            if (event.getButton() == MouseButton.SECONDARY) {
+                JFXListView<String> versionList = new JFXListView<>();
+                JFXPopup versionPopup = new JFXPopup(versionList);
+                versionList.getStyleClass().add("option-list-view");
+                FXUtils.setLimitWidth(versionList, 150);
+                versionList.getItems().setAll(Lang.immutableListOf(
+                        i18n("version.manage.rename"),
+                        i18n("version.manage.remove"),
+                        i18n("modpack.export"),
+                        i18n("folder.game")
+                ));
+                versionList.setOnMouseClicked(e -> {
+                    versionPopup.hide();
+                    switch (versionList.getSelectionModel().getSelectedIndex()) {
+                        case 0:
+                            VersionPage.renameVersion(profile, id);
+                            break;
+                        case 1:
+                            VersionPage.deleteVersion(profile, id);
+                            break;
+                        case 2:
+                            VersionPage.exportVersion(profile, id);
+                            break;
+                        case 3:
+                            FXUtils.openFolder(repository.getRunDirectory(id));
+                            break;
+                        default:
+                            break;
+                    }
+                });
+                versionPopup.show(item, JFXPopup.PopupVPosition.TOP, JFXPopup.PopupHPosition.LEFT, event.getX(), event.getY());
+            } else if (event.getButton() == MouseButton.PRIMARY && event.getClickCount() == 2) {
+                if (Settings.INSTANCE.getSelectedAccount() == null)
+                    Controllers.dialog(i18n("login.empty_username"));
+                else
+                    LauncherHelper.INSTANCE.launch(profile, Settings.INSTANCE.getSelectedAccount(), id, null);
+            }
+        });
+        File iconFile = repository.getVersionIcon(id);
+        if (iconFile.exists())
+            item.setImage(new Image("file:" + iconFile.getAbsolutePath()));
+        return item;
+    }
+
+    private void loadingVersions() {
+        getChildren().setAll(spinner);
+        masonryPane.getChildren().clear();
+    }
+
+    private void loadVersions(HMCLGameRepository repository) {
+        List<Node> children = repository.getVersions().parallelStream()
+                .map(version -> buildNode(repository, version, () -> GameVersion.minecraftVersion(repository.getVersionJar(version.getId())).orElse("Unknown")))
+                .collect(Collectors.toList());
+        JFXUtilities.runInFX(() -> {
+            if (profile == repository.getProfile()) {
+                masonryPane.getChildren().setAll(children);
+                getChildren().setAll(contentPane);
+            }
+        });
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    @Override
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/ModController.java

@@ -0,0 +1,177 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import com.jfoenix.controls.JFXSpinner;
+import com.jfoenix.controls.JFXTabPane;
+import javafx.fxml.FXML;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.input.TransferMode;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.stage.FileChooser;
+
+import org.jackhuang.hmcl.mod.ModInfo;
+import org.jackhuang.hmcl.mod.ModManager;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.util.FileUtils;
+import org.jackhuang.hmcl.util.Logging;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+public final class ModController {
+    @FXML
+    private ScrollPane scrollPane;
+
+    @FXML private StackPane rootPane;
+
+    @FXML private VBox modPane;
+
+    @FXML private StackPane contentPane;
+    @FXML private JFXSpinner spinner;
+
+    private JFXTabPane parentTab;
+    private ModManager modManager;
+    private String versionId;
+
+    @FXML
+    private void initialize() {
+        FXUtils.smoothScrolling(scrollPane);
+
+        rootPane.setOnDragOver(event -> {
+            if (event.getGestureSource() != rootPane && event.getDragboard().hasFiles())
+                event.acceptTransferModes(TransferMode.COPY_OR_MOVE);
+            event.consume();
+        });
+
+        rootPane.setOnDragDropped(event -> {
+            List<File> files = event.getDragboard().getFiles();
+            if (files != null) {
+                Collection<File> mods = files.stream()
+                        .filter(it -> Arrays.asList("jar", "zip", "litemod").contains(FileUtils.getExtension(it)))
+                        .collect(Collectors.toList());
+                if (!mods.isEmpty()) {
+                    mods.forEach(it -> {
+                        try {
+                            modManager.addMod(versionId, it);
+                        } catch (IOException | IllegalArgumentException e) {
+                            Logging.LOG.log(Level.WARNING, "Unable to parse mod file " + it, e);
+                        }
+                    });
+                    loadMods(modManager, versionId);
+                    event.setDropCompleted(true);
+                }
+            }
+            event.consume();
+        });
+    }
+
+    public void loadMods(ModManager modManager, String versionId) {
+        this.modManager = modManager;
+        this.versionId = versionId;
+        Task.of(variables -> {
+            synchronized (ModController.this) {
+                JFXUtilities.runInFX(() -> {
+                    rootPane.getChildren().remove(contentPane);
+                    spinner.setVisible(true);
+                });
+
+                modManager.refreshMods(versionId);
+
+                // Surprisingly, if there are a great number of mods, this processing will cause a long UI pause,
+                // constructing UI elements.
+                // We must do this asynchronously.
+                LinkedList<ModItem> list = new LinkedList<>();
+                for (ModInfo modInfo : modManager.getMods(versionId)) {
+                    ModItem item = new ModItem(modInfo, i -> {
+                        modManager.removeMods(versionId, modInfo);
+                        loadMods(modManager, versionId);
+                    });
+                    modInfo.activeProperty().addListener((a, b, newValue) -> {
+                        if (newValue)
+                            item.getStyleClass().remove("disabled");
+                        else
+                            item.getStyleClass().add("disabled");
+                    });
+                    if (!modInfo.isActive())
+                        item.getStyleClass().add("disabled");
+
+                    list.add(item);
+                }
+
+                variables.set("list", list);
+            }
+        }).finalized(Schedulers.javafx(), (variables, isDependentsSucceeded) -> {
+            rootPane.getChildren().add(contentPane);
+            spinner.setVisible(false);
+            if (isDependentsSucceeded)
+                FXUtils.onWeakChangeAndOperate(parentTab.getSelectionModel().selectedItemProperty(), newValue -> {
+                    if (newValue != null && newValue.getUserData() == ModController.this)
+                        modPane.getChildren().setAll(variables.<List<ModItem>>get("list"));
+                });
+        }).start();
+    }
+
+    @FXML
+    private void onAdd() {
+        FileChooser chooser = new FileChooser();
+        chooser.setTitle(i18n("mods.choose_mod"));
+        chooser.getExtensionFilters().setAll(new FileChooser.ExtensionFilter(i18n("extension.mod"), "*.jar", "*.zip", "*.litemod"));
+        List<File> res = chooser.showOpenMultipleDialog(Controllers.getStage());
+
+        // It's guaranteed that succeeded and failed are thread safe here.
+        List<String> succeeded = new LinkedList<>();
+        List<String> failed = new LinkedList<>();
+        if (res == null) return;
+        Task.of(variables -> {
+            for (File file : res) {
+                try {
+                    modManager.addMod(versionId, file);
+                    succeeded.add(file.getName());
+                } catch (Exception e) {
+                    Logging.LOG.log(Level.WARNING, "Unable to add mod " + file, e);
+                    failed.add(file.getName());
+
+                    // Actually addMod will not throw exceptions because FileChooser has already filtered files.
+                }
+            }
+        }).with(Task.of(Schedulers.javafx(), variables -> {
+            List<String> prompt = new LinkedList<>();
+            if (!succeeded.isEmpty())
+                prompt.add(i18n("mods.add.success", String.join(", ", succeeded)));
+            if (!failed.isEmpty())
+                prompt.add(i18n("mods.add.failed", String.join(", ", failed)));
+            Controllers.dialog(String.join("\n", prompt), i18n("mods.add"));
+            loadMods(modManager, versionId);
+        })).start();
+    }
+
+    public void setParentTab(JFXTabPane parentTab) {
+        this.parentTab = parentTab;
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/ModItem.java

@@ -0,0 +1,62 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXCheckBox;
+import com.jfoenix.effects.JFXDepthManager;
+import javafx.geometry.Pos;
+import javafx.scene.layout.BorderPane;
+
+import org.jackhuang.hmcl.mod.ModInfo;
+import org.jackhuang.hmcl.setting.Theme;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.function.Consumer;
+
+public final class ModItem extends BorderPane {
+
+    public ModItem(ModInfo info, Consumer<ModItem> deleteCallback) {
+        JFXCheckBox chkEnabled = new JFXCheckBox();
+        BorderPane.setAlignment(chkEnabled, Pos.CENTER);
+        setLeft(chkEnabled);
+
+        TwoLineListItem modItem = new TwoLineListItem();
+        BorderPane.setAlignment(modItem, Pos.CENTER);
+        setCenter(modItem);
+
+        JFXButton btnRemove = new JFXButton();
+        JFXUtilities.runInFX(() -> {
+            FXUtils.installTooltip(btnRemove, i18n("mods.remove"));
+        });
+        btnRemove.setOnMouseClicked(e -> deleteCallback.accept(this));
+        btnRemove.getStyleClass().add("toggle-icon4");
+        BorderPane.setAlignment(btnRemove, Pos.CENTER);
+        btnRemove.setGraphic(SVG.close(Theme.blackFillBinding(), 15, 15));
+        setRight(btnRemove);
+
+        setStyle("-fx-background-radius: 2; -fx-background-color: white; -fx-padding: 8;");
+        JFXDepthManager.setDepth(this, 1);
+        modItem.setTitle(info.getFileName());
+        modItem.setSubtitle(info.getName() + ", " + i18n("archive.version") + ": " + info.getVersion() + ", " + i18n("archive.game_version") + ": " + info.getGameVersion() + ", " + i18n("archive.author") + ": " + info.getAuthors());
+        chkEnabled.setSelected(info.isActive());
+        chkEnabled.selectedProperty().addListener((a, b, newValue) ->
+                info.activeProperty().set(newValue));
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/ProfilePage.java

@@ -0,0 +1,126 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXTextField;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.layout.StackPane;
+
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.setting.Profiles;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.ui.construct.FileItem;
+import org.jackhuang.hmcl.ui.wizard.DecoratorPage;
+import org.jackhuang.hmcl.util.StringUtils;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.File;
+import java.util.Optional;
+
+public final class ProfilePage extends StackPane implements DecoratorPage {
+    private final StringProperty title;
+    private final StringProperty location;
+    private final Profile profile;
+
+    @FXML
+    private JFXTextField txtProfileName;
+    @FXML
+    private FileItem gameDir;
+    @FXML private JFXButton btnSave;
+    @FXML private JFXButton btnDelete;
+
+    /**
+     * @param profile null if creating a new profile.
+     */
+    public ProfilePage(Profile profile) {
+        this.profile = profile;
+        String profileDisplayName = Optional.ofNullable(profile).map(Profiles::getProfileDisplayName).orElse("");
+
+        title = new SimpleStringProperty(this, "title",
+                profile == null ? i18n("profile.new") : i18n("profile") + " - " + profileDisplayName);
+        location = new SimpleStringProperty(this, "location",
+                Optional.ofNullable(profile).map(Profile::getGameDir).map(File::getAbsolutePath).orElse(""));
+
+        FXUtils.loadFXML(this, "/assets/fxml/profile.fxml");
+
+        txtProfileName.setText(profileDisplayName);
+        FXUtils.onChangeAndOperate(txtProfileName.textProperty(), it -> {
+            btnSave.setDisable(!txtProfileName.validate() || StringUtils.isBlank(getLocation()));
+        });
+        gameDir.setProperty(location);
+        FXUtils.onChangeAndOperate(location, it -> {
+            btnSave.setDisable(!txtProfileName.validate() || StringUtils.isBlank(getLocation()));
+        });
+
+        if (profile == null)
+            btnDelete.setVisible(false);
+    }
+
+    @FXML
+    private void onDelete() {
+        if (profile != null) {
+            Settings.INSTANCE.deleteProfile(profile);
+            Controllers.navigate(null);
+        }
+    }
+
+    @FXML
+    private void onSave() {
+        if (profile != null) {
+            profile.setName(txtProfileName.getText());
+            if (StringUtils.isNotBlank(getLocation()))
+                profile.setGameDir(new File(getLocation()));
+        } else {
+            if (StringUtils.isBlank(getLocation())) {
+                gameDir.onExplore();
+            }
+            Settings.INSTANCE.putProfile(new Profile(txtProfileName.getText(), new File(getLocation())));
+        }
+
+        Settings.INSTANCE.onProfileLoading();
+        Controllers.navigate(null);
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    @Override
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+
+    public String getLocation() {
+        return location.get();
+    }
+
+    public StringProperty locationProperty() {
+        return location;
+    }
+
+    public void setLocation(String location) {
+        this.location.set(location);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/SVG.java

@@ -0,0 +1,130 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import javafx.beans.binding.ObjectBinding;
+import javafx.scene.Group;
+import javafx.scene.Node;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.SVGPath;
+
+public final class SVG {
+    private SVG() {
+    }
+
+    private static Node createSVGPath(String d, ObjectBinding<? extends Paint> fill, double width, double height) {
+        SVGPath path = new SVGPath();
+        path.getStyleClass().add("svg");
+        path.setContent(d);
+        path.fillProperty().bind(fill);
+
+        Group svg = new Group(path);
+        double scale = Math.min(width / svg.getBoundsInParent().getWidth(), height / svg.getBoundsInParent().getHeight());
+        svg.setScaleX(scale);
+        svg.setScaleY(scale);
+
+        return svg;
+    }
+
+    // default fill: white, width: 20, height 20
+
+    public static Node gear(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M12,15.5A3.5,3.5 0 0,1 8.5,12A3.5,3.5 0 0,1 12,8.5A3.5,3.5 0 0,1 15.5,12A3.5,3.5 0 0,1 12,15.5M19.43,12.97C19.47,12.65 19.5,12.33 19.5,12C19.5,11.67 19.47,11.34 19.43,11L21.54,9.37C21.73,9.22 21.78,8.95 21.66,8.73L19.66,5.27C19.54,5.05 19.27,4.96 19.05,5.05L16.56,6.05C16.04,5.66 15.5,5.32 14.87,5.07L14.5,2.42C14.46,2.18 14.25,2 14,2H10C9.75,2 9.54,2.18 9.5,2.42L9.13,5.07C8.5,5.32 7.96,5.66 7.44,6.05L4.95,5.05C4.73,4.96 4.46,5.05 4.34,5.27L2.34,8.73C2.21,8.95 2.27,9.22 2.46,9.37L4.57,11C4.53,11.34 4.5,11.67 4.5,12C4.5,12.33 4.53,12.65 4.57,12.97L2.46,14.63C2.27,14.78 2.21,15.05 2.34,15.27L4.34,18.73C4.46,18.95 4.73,19.03 4.95,18.95L7.44,17.94C7.96,18.34 8.5,18.68 9.13,18.93L9.5,21.58C9.54,21.82 9.75,22 10,22H14C14.25,22 14.46,21.82 14.5,21.58L14.87,18.93C15.5,18.67 16.04,18.34 16.56,17.94L19.05,18.95C19.27,19.03 19.54,18.95 19.66,18.73L21.66,15.27C21.78,15.05 21.73,14.78 21.54,14.63L19.43,12.97Z", fill, width, height);
+    }
+
+    public static Node back(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M20,11V13H8L13.5,18.5L12.08,19.92L4.16,12L12.08,4.08L13.5,5.5L8,11H20Z", fill, width, height);
+    }
+
+    public static Node close(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M19,6.41L17.59,5L12,10.59L6.41,5L5,6.41L10.59,12L5,17.59L6.41,19L12,13.41L17.59,19L19,17.59L13.41,12L19,6.41Z", fill, width, height);
+    }
+
+    public static Node dotsVertical(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M12,16A2,2 0 0,1 14,18A2,2 0 0,1 12,20A2,2 0 0,1 10,18A2,2 0 0,1 12,16M12,10A2,2 0 0,1 14,12A2,2 0 0,1 12,14A2,2 0 0,1 10,12A2,2 0 0,1 12,10M12,4A2,2 0 0,1 14,6A2,2 0 0,1 12,8A2,2 0 0,1 10,6A2,2 0 0,1 12,4Z", fill, width, height);
+    }
+
+    public static Node delete(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M19,4H15.5L14.5,3H9.5L8.5,4H5V6H19M6,19A2,2 0 0,0 8,21H16A2,2 0 0,0 18,19V7H6V19Z", fill, width, height);
+    }
+
+    public static Node accountEdit(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M21.7,13.35L20.7,14.35L18.65,12.3L19.65,11.3C19.86,11.09 20.21,11.09 20.42,11.3L21.7,12.58C21.91,12.79 21.91,13.14 21.7,13.35M12,18.94L18.06,12.88L20.11,14.93L14.06,21H12V18.94M12,14C7.58,14 4,15.79 4,18V20H10V18.11L14,14.11C13.34,14.03 12.67,14 12,14M12,4A4,4 0 0,0 8,8A4,4 0 0,0 12,12A4,4 0 0,0 16,8A4,4 0 0,0 12,4Z", fill, width, height);
+    }
+
+    public static Node expand(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M16.59 8.59L12 13.17 7.41 8.59 6 10l6 6 6-6z", fill, width, height);
+    }
+
+    public static Node collapse(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M12 8l-6 6 1.41 1.41L12 10.83l4.59 4.58L18 14z", fill, width, height);
+    }
+
+    public static Node navigate(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M14,3V5H17.59L7.76,14.83L9.17,16.24L19,6.41V10H21V3M19,19H5V5H12V3H5C3.89,3 3,3.89 3,5V19A2,2 0 0,0 5,21H19A2,2 0 0,0 21,19V12H19V19Z", fill, width, height);
+    }
+
+    public static Node launch(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M1008 6.286q18.857 13.714 15.429 36.571l-146.286 877.714q-2.857 16.571-18.286 25.714-8 4.571-17.714 4.571-6.286 0-13.714-2.857l-258.857-105.714-138.286 168.571q-10.286 13.143-28 13.143-7.429 0-12.571-2.286-10.857-4-17.429-13.429t-6.571-20.857v-199.429l493.714-605.143-610.857 528.571-225.714-92.571q-21.143-8-22.857-31.429-1.143-22.857 18.286-33.714l950.857-548.571q8.571-5.143 18.286-5.14311.429 0 20.571 6.286z", fill, width, height);
+    }
+
+    public static Node script(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M14,20A2,2 0 0,0 16,18V5H9A1,1 0 0,0 8,6V16H5V5A3,3 0 0,1 8,2H19A3,3 0 0,1 22,5V6H18V18L18,19A3,3 0 0,1 15,22H5A3,3 0 0,1 2,19V18H12A2,2 0 0,0 14,20Z", fill, width, height);
+    }
+
+    public static Node pencil(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M20.71,4.04C21.1,3.65 21.1,3 20.71,2.63L18.37,0.29C18,-0.1 17.35,-0.1 16.96,0.29L15,2.25L18.75,6M17.75,7L14,3.25L4,13.25V17H7.75L17.75,7Z", fill, width, height);
+    }
+
+    public static Node refresh(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M17.65,6.35C16.2,4.9 14.21,4 12,4A8,8 0 0,0 4,12A8,8 0 0,0 12,20C15.73,20 18.84,17.45 19.73,14H17.65C16.83,16.33 14.61,18 12,18A6,6 0 0,1 6,12A6,6 0 0,1 12,6C13.66,6 15.14,6.69 16.22,7.78L13,11H20V4L17.65,6.35Z", fill, width, height);
+    }
+
+    public static Node folderOpen(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M19,20H4C2.89,20 2,19.1 2,18V6C2,4.89 2.89,4 4,4H10L12,6H19A2,2 0 0,1 21,8H21L4,8V18L6.14,10H23.21L20.93,18.5C20.7,19.37 19.92,20 19,20Z", fill, width, height);
+    }
+
+    public static Node update(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M21,10.12H14.22L16.96,7.3C14.23,4.6 9.81,4.5 7.08,7.2C4.35,9.91 4.35,14.28 7.08,17C9.81,19.7 14.23,19.7 16.96,17C18.32,15.65 19,14.08 19,12.1H21C21,14.08 20.12,16.65 18.36,18.39C14.85,21.87 9.15,21.87 5.64,18.39C2.14,14.92 2.11,9.28 5.62,5.81C9.13,2.34 14.76,2.34 18.27,5.81L21,3V10.12M12.5,8V12.25L16,14.33L15.28,15.54L11,13V8H12.5Z", fill, width, height);
+    }
+
+    public static Node closeCircle(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M12,2C17.53,2 22,6.47 22,12C22,17.53 17.53,22 12,22C6.47,22 2,17.53 2,12C2,6.47 6.47,2 12,2M15.59,7L12,10.59L8.41,7L7,8.41L10.59,12L7,15.59L8.41,17L12,13.41L15.59,17L17,15.59L13.41,12L17,8.41L15.59,7Z", fill, width, height);
+    }
+
+    public static Node checkCircle(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M12,2A10,10 0 0,1 22,12A10,10 0 0,1 12,22A10,10 0 0,1 2,12A10,10 0 0,1 12,2M11,16.5L18,9.5L16.59,8.09L11,13.67L7.91,10.59L6.5,12L11,16.5Z", fill, width, height);
+    }
+
+    public static Node infoCircle(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M13,9H11V7H13M13,17H11V11H13M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12A10,10 0 0,0 12,2Z", fill, width, height);
+    }
+
+    public static Node helpCircle(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M15.07,11.25L14.17,12.17C13.45,12.89 13,13.5 13,15H11V14.5C11,13.39 11.45,12.39 12.17,11.67L13.41,10.41C13.78,10.05 14,9.55 14,9C14,7.89 13.1,7 12,7A2,2 0 0,0 10,9H8A4,4 0 0,1 12,5A4,4 0 0,1 16,9C16,9.88 15.64,10.67 15.07,11.25M13,19H11V17H13M12,2A10,10 0 0,0 2,12A10,10 0 0,0 12,22A10,10 0 0,0 22,12C22,6.47 17.5,2 12,2Z", fill, width, height);
+    }
+
+    public static Node alert(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M13,14H11V10H13M13,18H11V16H13M1,21H23L12,2L1,21Z", fill, width, height);
+    }
+
+    public static Node plus(ObjectBinding<? extends Paint> fill, double width, double height) {
+        return createSVGPath("M19,13H13V19H11V13H5V11H11V5H13V11H19V13Z", fill, width, height);
+    }
+
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/SafeIntStringConverter.java

@@ -1,6 +1,6 @@
 /*
  * Hello Minecraft! Launcher.
- * Copyright (C) 2017  huangyuhui <[email protected]>
+ * Copyright (C) 2018  huangyuhui <[email protected]>
  * 
  * 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
@@ -15,27 +15,29 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see {http://www.gnu.org/licenses/}.
  */
-package org.jackhuang.hmcl.event
+package org.jackhuang.hmcl.ui;
 
-import org.jackhuang.hmcl.task.Scheduler
-import java.util.*
+import javafx.util.StringConverter;
+import org.jackhuang.hmcl.util.Lang;
 
-class EventBus {
-    private val events = HashMap<Class<*>, EventManager<*>>()
+import java.util.Optional;
 
-    @Suppress("UNCHECKED_CAST")
-    fun <T : EventObject> channel(classOfT: Class<T>): EventManager<T> {
-        if (!events.containsKey(classOfT))
-            events.put(classOfT, EventManager<T>(Scheduler.COMPUTATION))
-        return events[classOfT] as EventManager<T>
+/**
+ * @author huangyuhui
+ */
+public final class SafeIntStringConverter extends StringConverter<Number> {
+    public static final SafeIntStringConverter INSTANCE = new SafeIntStringConverter();
+
+    private SafeIntStringConverter() {
     }
 
-    inline fun <reified T: EventObject> channel() = channel(T::class.java)
-
-    fun fireEvent(obj: EventObject) {
-        channel(obj.javaClass).fireEvent(obj)
+    @Override
+    public Number fromString(String string) {
+        return Optional.ofNullable(string).map(Lang::toIntOrNull).orElse(null);
     }
 
+    @Override
+    public String toString(Number object) {
+        return Optional.ofNullable(object).map(Object::toString).orElse("");
+    }
 }
-
-val EVENT_BUS = EventBus()

HMCL/src/main/java/org/jackhuang/hmcl/ui/SettingsPage.java

@@ -0,0 +1,263 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.*;
+import com.jfoenix.effects.JFXDepthManager;
+import javafx.application.Platform;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.control.Toggle;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.layout.GridPane;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.StackPane;
+import javafx.scene.paint.Color;
+import javafx.scene.text.Font;
+import org.jackhuang.hmcl.Launcher;
+import org.jackhuang.hmcl.setting.*;
+import org.jackhuang.hmcl.ui.construct.FileItem;
+import org.jackhuang.hmcl.ui.construct.FontComboBox;
+import org.jackhuang.hmcl.ui.construct.MultiFileItem;
+import org.jackhuang.hmcl.ui.construct.Validator;
+import org.jackhuang.hmcl.ui.wizard.DecoratorPage;
+import org.jackhuang.hmcl.util.Lang;
+import org.jackhuang.hmcl.util.i18n.Locales;
+
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.net.Proxy;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.stream.Collectors;
+
+public final class SettingsPage extends StackPane implements DecoratorPage {
+    private final StringProperty title = new SimpleStringProperty(this, "title", i18n("settings.launcher"));
+
+    @FXML
+    private JFXTextField txtProxyHost;
+    @FXML
+    private JFXTextField txtProxyPort;
+    @FXML
+    private JFXTextField txtProxyUsername;
+    @FXML
+    private JFXPasswordField txtProxyPassword;
+    @FXML
+    private JFXTextField txtFontSize;
+    @FXML
+    private JFXComboBox<Label> cboLanguage;
+    @FXML
+    private JFXComboBox<?> cboDownloadSource;
+    @FXML
+    private FontComboBox cboFont;
+    @FXML
+    private FileItem fileCommonLocation;
+    @FXML
+    private Label lblDisplay;
+    @FXML
+    private Label lblUpdate;
+    @FXML
+    private Label lblUpdateSub;
+    @FXML
+    private JFXButton btnUpdate;
+    @FXML
+    private ScrollPane scroll;
+    @FXML
+    private MultiFileItem backgroundItem;
+    @FXML
+    private StackPane themeColorPickerContainer;
+    @FXML
+    private JFXRadioButton chkNoProxy;
+    @FXML
+    private JFXRadioButton chkManualProxy;
+    @FXML
+    private JFXRadioButton chkProxyHttp;
+    @FXML
+    private JFXRadioButton chkProxySocks;
+    @FXML
+    private JFXCheckBox chkProxyAuthentication;
+    @FXML
+    private GridPane authPane;
+    @FXML
+    private Pane proxyPane;
+
+    {
+        FXUtils.loadFXML(this, "/assets/fxml/setting.fxml");
+
+        FXUtils.smoothScrolling(scroll);
+
+        txtProxyHost.setText(Settings.INSTANCE.getProxyHost());
+        txtProxyHost.textProperty().addListener((a, b, newValue) -> Settings.INSTANCE.setProxyHost(newValue));
+
+        txtProxyPort.setText(Settings.INSTANCE.getProxyPort());
+        txtProxyPort.textProperty().addListener((a, b, newValue) -> Settings.INSTANCE.setProxyPort(newValue));
+
+        txtProxyUsername.setText(Settings.INSTANCE.getProxyUser());
+        txtProxyUsername.textProperty().addListener((a, b, newValue) -> Settings.INSTANCE.setProxyUser(newValue));
+
+        txtProxyPassword.setText(Settings.INSTANCE.getProxyPass());
+        txtProxyPassword.textProperty().addListener((a, b, newValue) -> Settings.INSTANCE.setProxyPass(newValue));
+
+        cboDownloadSource.getSelectionModel().select(DownloadProviders.DOWNLOAD_PROVIDERS.indexOf(Settings.INSTANCE.getDownloadProvider()));
+        cboDownloadSource.getSelectionModel().selectedIndexProperty().addListener((a, b, newValue) -> Settings.INSTANCE.setDownloadProvider(DownloadProviders.getDownloadProvider(newValue.intValue())));
+
+        cboFont.getSelectionModel().select(Settings.INSTANCE.getFont().getFamily());
+        cboFont.valueProperty().addListener((a, b, newValue) -> {
+            Font font = Font.font(newValue, Settings.INSTANCE.getFont().getSize());
+            Settings.INSTANCE.setFont(font);
+            lblDisplay.setStyle("-fx-font: " + font.getSize() + " \"" + font.getFamily() + "\";");
+        });
+
+        txtFontSize.setText(Double.toString(Settings.INSTANCE.getFont().getSize()));
+        txtFontSize.getValidators().add(new Validator(it -> Lang.toDoubleOrNull(it) != null));
+        txtFontSize.textProperty().addListener((a, b, newValue) -> {
+            if (txtFontSize.validate()) {
+                Font font = Font.font(Settings.INSTANCE.getFont().getFamily(), Double.parseDouble(newValue));
+                Settings.INSTANCE.setFont(font);
+                lblDisplay.setStyle("-fx-font: " + font.getSize() + " \"" + font.getFamily() + "\";");
+            }
+        });
+
+        lblDisplay.setStyle("-fx-font: " + Settings.INSTANCE.getFont().getSize() + " \"" + Settings.INSTANCE.getFont().getFamily() + "\";");
+
+        ObservableList<Label> list = FXCollections.observableArrayList();
+        for (Locales.SupportedLocale locale : Locales.LOCALES)
+            list.add(new Label(locale.getName(Settings.INSTANCE.getLocale().getResourceBundle())));
+
+        cboLanguage.setItems(list);
+        cboLanguage.getSelectionModel().select(Locales.LOCALES.indexOf(Settings.INSTANCE.getLocale()));
+        cboLanguage.getSelectionModel().selectedIndexProperty().addListener((a, b, newValue) -> Settings.INSTANCE.setLocale(Locales.getLocale(newValue.intValue())));
+
+
+        ToggleGroup proxyConfigurationGroup = new ToggleGroup();
+        chkProxyHttp.setUserData(Proxy.Type.HTTP);
+        chkProxyHttp.setToggleGroup(proxyConfigurationGroup);
+        chkProxySocks.setUserData(Proxy.Type.SOCKS);
+        chkProxySocks.setToggleGroup(proxyConfigurationGroup);
+
+        for (Toggle toggle : proxyConfigurationGroup.getToggles())
+            if (toggle.getUserData() == Settings.INSTANCE.getProxyType())
+                toggle.setSelected(true);
+
+        ToggleGroup hasProxyGroup = new ToggleGroup();
+        chkNoProxy.setToggleGroup(hasProxyGroup);
+        chkManualProxy.setToggleGroup(hasProxyGroup);
+        if (!Settings.INSTANCE.hasProxy())
+            chkNoProxy.setSelected(true);
+        else
+            chkManualProxy.setSelected(true);
+        proxyPane.disableProperty().bind(chkNoProxy.selectedProperty());
+
+        hasProxyGroup.selectedToggleProperty().addListener((a, b, newValue) ->
+                Settings.INSTANCE.setHasProxy(newValue != chkNoProxy));
+
+        proxyConfigurationGroup.selectedToggleProperty().addListener((a, b, newValue) ->
+                Settings.INSTANCE.setProxyType((Proxy.Type) newValue.getUserData()));
+
+        chkProxyAuthentication.setSelected(Settings.INSTANCE.hasProxyAuth());
+        chkProxyAuthentication.selectedProperty().addListener((a, b, newValue) -> Settings.INSTANCE.setHasProxyAuth(newValue));
+        authPane.disableProperty().bind(chkProxyAuthentication.selectedProperty().not());
+
+        fileCommonLocation.setProperty(Settings.INSTANCE.commonPathProperty());
+
+        FXUtils.installTooltip(btnUpdate, i18n("update.tooltip"));
+        checkUpdate();
+
+        // background
+        backgroundItem.loadChildren(Collections.singletonList(
+                backgroundItem.createChildren(i18n("launcher.background.default"), EnumBackgroundImage.DEFAULT)
+        ));
+
+        FXUtils.bindString(backgroundItem.getTxtCustom(), Settings.INSTANCE.backgroundImageProperty());
+
+        backgroundItem.setCustomUserData(EnumBackgroundImage.CUSTOM);
+        backgroundItem.getGroup().getToggles().stream().filter(it -> it.getUserData() == Settings.INSTANCE.getBackgroundImageType()).findFirst().ifPresent(it -> it.setSelected(true));
+
+        Settings.INSTANCE.backgroundImageProperty().setChangedListener(it -> initBackgroundItemSubtitle());
+        Settings.INSTANCE.backgroundImageTypeProperty().setChangedListener(it -> initBackgroundItemSubtitle());
+        initBackgroundItemSubtitle();
+
+        backgroundItem.setToggleSelectedListener(newValue ->
+                Settings.INSTANCE.setBackgroundImageType((EnumBackgroundImage) newValue.getUserData()));
+
+        // theme
+        JFXColorPicker picker = new JFXColorPicker(Color.web(Settings.INSTANCE.getTheme().getColor()), null);
+        picker.setCustomColorText(i18n("color.custom"));
+        picker.setRecentColorsText(i18n("color.recent"));
+        picker.getCustomColors().setAll(Arrays.stream(Theme.VALUES).map(Theme::getColor).map(Color::web).collect(Collectors.toList()));
+        picker.setOnAction(e -> {
+            Theme theme = Theme.custom(Theme.getColorDisplayName(picker.getValue()));
+            Settings.INSTANCE.setTheme(theme);
+            Controllers.getScene().getStylesheets().setAll(theme.getStylesheets());
+        });
+        themeColorPickerContainer.getChildren().setAll(picker);
+        Platform.runLater(() -> JFXDepthManager.setDepth(picker, 0));
+    }
+
+    private void initBackgroundItemSubtitle() {
+        switch (Settings.INSTANCE.getBackgroundImageType()) {
+            case DEFAULT:
+                backgroundItem.setSubtitle(i18n("launcher.background.default"));
+                break;
+            case CUSTOM:
+                backgroundItem.setSubtitle(Settings.INSTANCE.getBackgroundImage());
+                break;
+        }
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    @Override
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+
+    public void checkUpdate() {
+        btnUpdate.setVisible(Launcher.UPDATE_CHECKER.isOutOfDate());
+
+        if (Launcher.UPDATE_CHECKER.isOutOfDate()) {
+            lblUpdateSub.setText(i18n("update.newest_version", Launcher.UPDATE_CHECKER.getNewVersion().toString()));
+            lblUpdateSub.getStyleClass().setAll("update-label");
+
+            lblUpdate.setText(i18n("update.found"));
+            lblUpdate.getStyleClass().setAll("update-label");
+        } else {
+            lblUpdateSub.setText(i18n("update.latest"));
+            lblUpdateSub.getStyleClass().setAll("subtitle-label");
+
+            lblUpdate.setText(i18n("update"));
+            lblUpdate.getStyleClass().setAll();
+        }
+    }
+
+    @FXML
+    private void onUpdate() {
+        Launcher.UPDATE_CHECKER.checkOutdate();
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/TwoLineListItem.java

@@ -0,0 +1,217 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.css.*;
+import javafx.scene.Node;
+import javafx.scene.control.Label;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.text.Font;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class TwoLineListItem extends StackPane {
+
+    private final StringProperty title = new SimpleStringProperty(this, "title");
+    private final StringProperty subtitle = new SimpleStringProperty(this, "subtitle");
+
+    private final StyleableObjectProperty<Font> titleFont = new SimpleStyleableObjectProperty<>(StyleableProperties.TITLE_FONT, this, "title-font", Font.font(15));
+    private final StyleableObjectProperty<Font> subtitleFont = new SimpleStyleableObjectProperty<>(StyleableProperties.SUBTITLE_FONT, this, "subtitle-font", Font.getDefault());
+
+    private final StyleableObjectProperty<Paint> titleFill = new SimpleStyleableObjectProperty<>(StyleableProperties.TITLE_FILL, this, "title-fill", Color.BLACK);
+    private final StyleableObjectProperty<Paint> subtitleFill = new SimpleStyleableObjectProperty<>(StyleableProperties.SUBTITLE_FILL, this, "subtitle-fill", Color.GRAY);
+
+    public TwoLineListItem(String titleString, String subtitleString) {
+        this();
+
+        title.set(titleString);
+        subtitle.set(subtitleString);
+    }
+
+    public TwoLineListItem() {
+        Label lblTitle = new Label();
+        lblTitle.textFillProperty().bind(titleFill);
+        lblTitle.fontProperty().bind(titleFont);
+        lblTitle.textProperty().bind(title);
+
+        Label lblSubtitle = new Label();
+        lblSubtitle.textFillProperty().bind(subtitleFill);
+        lblSubtitle.fontProperty().bind(subtitleFont);
+        lblSubtitle.textProperty().bind(subtitle);
+
+        VBox vbox = new VBox();
+        vbox.getChildren().setAll(lblTitle, lblSubtitle);
+        getChildren().setAll(vbox);
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+
+    public String getSubtitle() {
+        return subtitle.get();
+    }
+
+    public StringProperty subtitleProperty() {
+        return subtitle;
+    }
+
+    public void setSubtitle(String subtitle) {
+        this.subtitle.set(subtitle);
+    }
+
+    public Font getTitleFont() {
+        return titleFont.get();
+    }
+
+    public StyleableObjectProperty<Font> titleFontProperty() {
+        return titleFont;
+    }
+
+    public void setTitleFont(Font titleFont) {
+        this.titleFont.set(titleFont);
+    }
+
+    public Font getSubtitleFont() {
+        return subtitleFont.get();
+    }
+
+    public StyleableObjectProperty<Font> subtitleFontProperty() {
+        return subtitleFont;
+    }
+
+    public void setSubtitleFont(Font subtitleFont) {
+        this.subtitleFont.set(subtitleFont);
+    }
+
+    public Paint getTitleFill() {
+        return titleFill.get();
+    }
+
+    public StyleableObjectProperty<Paint> titleFillProperty() {
+        return titleFill;
+    }
+
+    public void setTitleFill(Paint titleFill) {
+        this.titleFill.set(titleFill);
+    }
+
+    public Paint getSubtitleFill() {
+        return subtitleFill.get();
+    }
+
+    public StyleableObjectProperty<Paint> subtitleFillProperty() {
+        return subtitleFill;
+    }
+
+    public void setSubtitleFill(Paint subtitleFill) {
+        this.subtitleFill.set(subtitleFill);
+    }
+
+    @Override
+    public String toString() {
+        return getTitle();
+    }
+
+    @Override
+    public List<CssMetaData<? extends Styleable, ?>> getCssMetaData() {
+        return getClassCssMetaData();
+    }
+
+    public static List<CssMetaData<? extends Styleable, ?>> getClassCssMetaData() {
+        return StyleableProperties.STYLEABLES;
+    }
+
+    private static class StyleableProperties {
+
+        private static final FontCssMetaData<TwoLineListItem> TITLE_FONT = new FontCssMetaData<TwoLineListItem>("-jfx-title-font", Font.font(15)) {
+            @Override
+            public boolean isSettable(TwoLineListItem control) {
+                return control.title == null || !control.title.isBound();
+            }
+
+            @Override
+            public StyleableProperty<Font> getStyleableProperty(TwoLineListItem control) {
+                return control.titleFontProperty();
+            }
+        };
+
+        private static final FontCssMetaData<TwoLineListItem> SUBTITLE_FONT = new FontCssMetaData<TwoLineListItem>("-jfx-subtitle-font", Font.getDefault()) {
+            @Override
+            public boolean isSettable(TwoLineListItem control) {
+                return control.subtitle == null || !control.subtitle.isBound();
+            }
+
+            @Override
+            public StyleableProperty<Font> getStyleableProperty(TwoLineListItem control) {
+                return control.subtitleFontProperty();
+            }
+        };
+
+        private static final CssMetaData<TwoLineListItem, Paint> TITLE_FILL = new CssMetaData<TwoLineListItem, Paint>("-jfx-title-fill", StyleConverter.getPaintConverter(), Color.BLACK) {
+            @Override
+            public boolean isSettable(TwoLineListItem control) {
+                return control.titleFill == null || !control.titleFill.isBound();
+            }
+
+            @Override
+            public StyleableProperty<Paint> getStyleableProperty(TwoLineListItem control) {
+                return control.titleFillProperty();
+            }
+        };
+
+        private static final CssMetaData<TwoLineListItem, Paint> SUBTITLE_FILL = new CssMetaData<TwoLineListItem, Paint>("-jfx-subtitle-fill", StyleConverter.getPaintConverter(), Color.GRAY) {
+            @Override
+            public boolean isSettable(TwoLineListItem control) {
+                return control.subtitleFill == null || !control.subtitleFill.isBound();
+            }
+
+            @Override
+            public StyleableProperty<Paint> getStyleableProperty(TwoLineListItem control) {
+                return control.subtitleFillProperty();
+            }
+        };
+
+        private static final List<CssMetaData<? extends Styleable, ?>> STYLEABLES;
+
+        private StyleableProperties() {
+        }
+
+        static {
+            List<CssMetaData<? extends Styleable, ?>> styleables = new ArrayList<>(Node.getClassCssMetaData());
+            Collections.addAll(styleables, TITLE_FONT);
+            Collections.addAll(styleables, SUBTITLE_FONT);
+            STYLEABLES = Collections.unmodifiableList(styleables);
+        }
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/VersionItem.java

@@ -0,0 +1,231 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import com.jfoenix.controls.JFXButton;
+import javafx.beans.binding.Bindings;
+import javafx.event.EventHandler;
+import javafx.fxml.FXML;
+import javafx.geometry.Insets;
+import javafx.geometry.Pos;
+import javafx.scene.control.Label;
+import javafx.scene.effect.BlurType;
+import javafx.scene.effect.DropShadow;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.input.MouseButton;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.*;
+import javafx.scene.paint.Color;
+import javafx.scene.text.TextAlignment;
+
+import org.jackhuang.hmcl.setting.Theme;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Optional;
+
+public final class VersionItem extends StackPane {
+    @FXML
+    private Pane icon;
+    @FXML
+    private VBox content;
+    @FXML
+    private StackPane header;
+    @FXML
+    private StackPane body;
+    @FXML
+    private JFXButton btnSettings;
+    @FXML
+    private JFXButton btnUpdate;
+    @FXML
+    private JFXButton btnLaunch;
+    @FXML
+    private JFXButton btnScript;
+    @FXML
+    private Label lblVersionName;
+    @FXML
+    private Label lblGameVersion;
+    @FXML
+    private Label lblLibraries;
+    @FXML
+    private ImageView iconView;
+
+    private EventHandler<? super MouseEvent> launchClickedHandler = null;
+
+    private void initializeComponents() {
+        setPickOnBounds(false);
+        FXUtils.setLimitWidth(this, 160);
+        FXUtils.setLimitHeight(this, 156);
+
+        content = new VBox();
+        {
+            header = new StackPane();
+            VBox.setVgrow(header, Priority.ALWAYS);
+            header.setPickOnBounds(false);
+            header.setPadding(new Insets(8));
+            header.setStyle("-fx-background-radius: 2 2 0 0; -fx-background-color: rgb(255,255,255,0.87);");
+            {
+                VBox headerContent = new VBox();
+                headerContent.setPadding(new Insets(8, 8, 0, 8));
+                {
+                    lblVersionName = new Label();
+                    lblVersionName.setStyle("-fx-font-size: 15;");
+                    lblVersionName.setTextAlignment(TextAlignment.JUSTIFY);
+                    lblVersionName.setWrapText(true);
+                    headerContent.getChildren().add(lblVersionName);
+
+                    lblGameVersion = new Label();
+                    lblGameVersion.setStyle("-fx-font-size: 11;");
+                    lblGameVersion.setTextAlignment(TextAlignment.JUSTIFY);
+                    lblGameVersion.setWrapText(true);
+                    headerContent.getChildren().add(lblGameVersion);
+
+                    lblLibraries = new Label();
+                    lblLibraries.setStyle("-fx-font-size: 10; -fx-text-fill: gray;");
+                    lblLibraries.setTextAlignment(TextAlignment.JUSTIFY);
+                    lblLibraries.setWrapText(true);
+                    headerContent.getChildren().add(lblLibraries);
+                }
+                header.getChildren().add(headerContent);
+            }
+            content.getChildren().add(header);
+
+            body = new StackPane();
+            body.setStyle("-fx-background-radius: 0 0 2 2; -fx-background-color: rgb(255,255,255,0.87); -fx-padding: 8;");
+            body.setMinHeight(40);
+            body.setPickOnBounds(false);
+            {
+                BorderPane bodyContent = new BorderPane();
+                {
+                    HBox hbox = new HBox();
+                    hbox.setSpacing(8);
+                    {
+                        btnSettings = new JFXButton();
+                        btnSettings.getStyleClass().add("toggle-icon4");
+                        FXUtils.setLimitWidth(btnSettings, 30);
+                        FXUtils.setLimitHeight(btnSettings, 30);
+                        hbox.getChildren().add(btnSettings);
+
+                        btnUpdate = new JFXButton();
+                        btnUpdate.getStyleClass().add("toggle-icon4");
+                        FXUtils.setLimitWidth(btnUpdate, 30);
+                        FXUtils.setLimitHeight(btnUpdate, 30);
+                        hbox.getChildren().add(btnUpdate);
+                    }
+                    bodyContent.setLeft(hbox);
+                }
+                {
+                    HBox hbox = new HBox();
+                    hbox.setSpacing(8);
+                    {
+                        btnScript = new JFXButton();
+                        btnScript.getStyleClass().add("toggle-icon4");
+                        FXUtils.setLimitWidth(btnScript, 30);
+                        FXUtils.setLimitHeight(btnScript, 30);
+                        hbox.getChildren().add(btnScript);
+
+                        btnLaunch = new JFXButton();
+                        btnLaunch.getStyleClass().add("toggle-icon4");
+                        FXUtils.setLimitWidth(btnLaunch, 30);
+                        FXUtils.setLimitHeight(btnLaunch, 30);
+                        hbox.getChildren().add(btnLaunch);
+                    }
+                    bodyContent.setRight(hbox);
+                }
+                body.getChildren().setAll(bodyContent);
+            }
+            content.getChildren().add(body);
+        }
+        getChildren().add(content);
+
+        icon = new StackPane();
+        StackPane.setAlignment(icon, Pos.TOP_RIGHT);
+        icon.setPickOnBounds(false);
+        {
+            iconView = new ImageView();
+            StackPane.setAlignment(iconView, Pos.CENTER_RIGHT);
+            StackPane.setMargin(iconView, new Insets(0, 12, 0, 0));
+            iconView.setImage(new Image("/assets/img/icon.png"));
+            icon.getChildren().add(iconView);
+        }
+        getChildren().add(icon);
+    }
+
+    public VersionItem() {
+        initializeComponents();
+        setEffect(new DropShadow(BlurType.GAUSSIAN, Color.rgb(0, 0, 0, 0.26), 5.0, 0.12, -1.0, 1.0));
+        btnSettings.setGraphic(SVG.gear(Theme.blackFillBinding(), 15, 15));
+        btnUpdate.setGraphic(SVG.update(Theme.blackFillBinding(), 15, 15));
+        btnLaunch.setGraphic(SVG.launch(Theme.blackFillBinding(), 15, 15));
+        btnScript.setGraphic(SVG.script(Theme.blackFillBinding(), 15, 15));
+
+        JFXUtilities.runInFX(() -> {
+            FXUtils.installTooltip(btnSettings, i18n("version.settings"));
+            FXUtils.installTooltip(btnUpdate, i18n("version.update"));
+            FXUtils.installTooltip(btnLaunch, i18n("version.launch"));
+            FXUtils.installTooltip(btnScript, i18n("version.launch_script"));
+        });
+
+        icon.translateYProperty().bind(Bindings.createDoubleBinding(() -> header.getBoundsInParent().getHeight() - icon.getHeight() / 2 - 16, header.boundsInParentProperty(), icon.heightProperty()));
+        FXUtils.limitSize(iconView, 32, 32);
+
+        setOnMouseClicked(e -> {
+            if (e.getButton() == MouseButton.PRIMARY)
+                if (e.getClickCount() == 2)
+                    Optional.ofNullable(launchClickedHandler).ifPresent(h -> h.handle(e));
+        });
+    }
+
+    public void setUpdate(boolean update) {
+        btnUpdate.setVisible(update);
+    }
+
+    public void setVersionName(String versionName) {
+        lblVersionName.setText(versionName);
+    }
+
+    public void setGameVersion(String gameVersion) {
+        lblGameVersion.setText(gameVersion);
+    }
+
+    public void setLibraries(String libraries) {
+        lblLibraries.setText(libraries);
+    }
+
+    public void setImage(Image image) {
+        iconView.setImage(image);
+    }
+
+    public void setOnSettingsButtonClicked(EventHandler<? super MouseEvent> handler) {
+        btnSettings.setOnMouseClicked(handler);
+    }
+
+    public void setOnScriptButtonClicked(EventHandler<? super MouseEvent> handler) {
+        btnScript.setOnMouseClicked(handler);
+    }
+
+    public void setOnLaunchButtonClicked(EventHandler<? super MouseEvent> handler) {
+        launchClickedHandler = handler;
+        btnLaunch.setOnMouseClicked(handler);
+    }
+
+    public void setOnUpdateButtonClicked(EventHandler<? super MouseEvent> handler) {
+        btnUpdate.setOnMouseClicked(handler);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/VersionListItem.java

@@ -0,0 +1,70 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.JFXButton;
+import javafx.event.EventHandler;
+import javafx.fxml.FXML;
+import javafx.geometry.Rectangle2D;
+import javafx.scene.control.Label;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.StackPane;
+
+public final class VersionListItem extends StackPane {
+    @FXML
+    private StackPane imageViewContainer;
+    @FXML
+    private Label lblVersionName;
+    @FXML
+    private Label lblGameVersion;
+    @FXML
+    private ImageView imageView;
+    @FXML private JFXButton btnSettings;
+
+    public VersionListItem(String versionName) {
+        this(versionName, "");
+    }
+
+    public VersionListItem(String versionName, String gameVersion) {
+        FXUtils.loadFXML(this, "/assets/fxml/version-list-item.fxml");
+
+        lblVersionName.setText(versionName);
+        lblGameVersion.setText(gameVersion);
+
+        FXUtils.limitSize(imageView, 32, 32);
+    }
+
+    public void setOnSettingsButtonClicked(EventHandler<? super MouseEvent> handler) {
+        btnSettings.setOnMouseClicked(handler);
+    }
+
+    public void setVersionName(String versionName) {
+        lblVersionName.setText(versionName);
+    }
+
+    public void setGameVersion(String gameVersion) {
+        lblGameVersion.setText(gameVersion);
+    }
+
+    public void setImage(Image image, Rectangle2D viewport) {
+        imageView.setImage(image);
+        imageView.setViewport(viewport);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/VersionPage.java

@@ -0,0 +1,209 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXListView;
+import com.jfoenix.controls.JFXPopup;
+import com.jfoenix.controls.JFXTabPane;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.control.Tab;
+import javafx.scene.layout.StackPane;
+
+import org.jackhuang.hmcl.download.game.GameAssetIndexDownloadTask;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.ui.export.ExportWizardProvider;
+import org.jackhuang.hmcl.ui.wizard.DecoratorPage;
+import org.jackhuang.hmcl.util.FileUtils;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.File;
+
+public final class VersionPage extends StackPane implements DecoratorPage {
+    private final StringProperty title = new SimpleStringProperty(this, "title", null);
+
+    @FXML
+    private VersionSettingsController versionSettingsController;
+    @FXML
+    private Tab modTab;
+    @FXML
+    private ModController modController;
+    @FXML
+    private InstallerController installerController;
+    @FXML
+    private JFXListView<?> browseList;
+    @FXML
+    private JFXListView<?> managementList;
+    @FXML
+    private JFXButton btnBrowseMenu;
+    @FXML
+    private JFXButton btnDelete;
+    @FXML
+    private JFXButton btnManagementMenu;
+    @FXML
+    private JFXButton btnExport;
+    @FXML
+    private StackPane rootPane;
+    @FXML
+    private StackPane contentPane;
+    @FXML
+    private JFXTabPane tabPane;
+
+    private final JFXPopup browsePopup;
+    private final JFXPopup managementPopup;
+
+    private Profile profile;
+    private String version;
+
+    {
+        FXUtils.loadFXML(this, "/assets/fxml/version/version.fxml");
+
+        getChildren().removeAll(browseList, managementList);
+
+        browsePopup = new JFXPopup(browseList);
+        managementPopup = new JFXPopup(managementList);
+
+        FXUtils.installTooltip(btnDelete, i18n("version.manage.remove"));
+        FXUtils.installTooltip(btnBrowseMenu, i18n("settings.game.exploration"));
+        FXUtils.installTooltip(btnManagementMenu, i18n("settings.game.management"));
+        FXUtils.installTooltip(btnExport, i18n("modpack.export"));
+    }
+
+    public void load(String id, Profile profile) {
+        this.version = id;
+        this.profile = profile;
+
+        title.set(i18n("settings.game") + " - " + id);
+
+        versionSettingsController.loadVersionSetting(profile, id);
+        modController.setParentTab(tabPane);
+        modTab.setUserData(modController);
+        modController.loadMods(profile.getModManager(), id);
+        installerController.loadVersion(profile, id);
+    }
+
+    @FXML
+    private void onBrowseMenu() {
+        browseList.getSelectionModel().select(-1);
+        browsePopup.show(btnBrowseMenu, JFXPopup.PopupVPosition.TOP, JFXPopup.PopupHPosition.RIGHT, -12, 15);
+    }
+
+    @FXML
+    private void onManagementMenu() {
+        managementList.getSelectionModel().select(-1);
+        managementPopup.show(btnManagementMenu, JFXPopup.PopupVPosition.TOP, JFXPopup.PopupHPosition.RIGHT, -12, 15);
+    }
+
+    @FXML
+    private void onDelete() {
+        deleteVersion(profile, version);
+    }
+
+    @FXML
+    private void onExport() {
+        exportVersion(profile, version);
+    }
+
+    @FXML
+    private void onBrowse() {
+        String sub;
+        switch (browseList.getSelectionModel().getSelectedIndex()) {
+            case 0:
+                sub = "";
+                break;
+            case 1:
+                sub = "mods";
+                break;
+            case 2:
+                sub = "coremods";
+                break;
+            case 3:
+                sub = "config";
+                break;
+            case 4:
+                sub = "resourcepacks";
+                break;
+            case 5:
+                sub = "screenshots";
+                break;
+            case 6:
+                sub = "saves";
+                break;
+            default:
+                throw new RuntimeException();
+        }
+        FXUtils.openFolder(new File(profile.getRepository().getRunDirectory(version), sub));
+    }
+
+    @FXML
+    private void onManagement() {
+        switch (managementList.getSelectionModel().getSelectedIndex()) {
+            case 0: // rename a version
+                renameVersion(profile, version);
+                break;
+            case 1: // remove a version
+                deleteVersion(profile, version);
+                break;
+            case 2: // redownload asset index
+                new GameAssetIndexDownloadTask(profile.getDependency(), profile.getRepository().getResolvedVersion(version)).start();
+                break;
+            case 3: // delete libraries
+                FileUtils.deleteDirectoryQuietly(new File(profile.getRepository().getBaseDirectory(), "libraries"));
+                break;
+            case 4:
+                throw new Error();
+        }
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    @Override
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+
+    public static void deleteVersion(Profile profile, String version) {
+        Controllers.confirmDialog(i18n("version.manage.remove.confirm", version), i18n("message.confirm"), () -> {
+            if (profile.getRepository().removeVersionFromDisk(version)) {
+                profile.getRepository().refreshVersionsAsync().start();
+                Controllers.navigate(null);
+            }
+        }, null);
+    }
+
+    public static void renameVersion(Profile profile, String version) {
+        Controllers.inputDialog(i18n("version.manage.rename.message"), res -> {
+            if (profile.getRepository().renameVersion(version, res)) {
+                profile.getRepository().refreshVersionsAsync().start();
+                Controllers.navigate(null);
+            }
+        });
+    }
+
+    public static void exportVersion(Profile profile, String version) {
+        Controllers.getDecorator().startWizard(new ExportWizardProvider(profile, version), i18n("modpack.wizard"));
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/VersionSettingsController.java

@@ -0,0 +1,270 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import com.jfoenix.controls.JFXCheckBox;
+import com.jfoenix.controls.JFXComboBox;
+import com.jfoenix.controls.JFXTextField;
+import com.jfoenix.controls.JFXToggleButton;
+import javafx.application.Platform;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.control.Toggle;
+import javafx.scene.image.Image;
+import javafx.scene.layout.VBox;
+import javafx.stage.FileChooser;
+
+import org.jackhuang.hmcl.setting.EnumGameDirectory;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.setting.VersionSetting;
+import org.jackhuang.hmcl.task.Schedulers;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.construct.ComponentList;
+import org.jackhuang.hmcl.ui.construct.ImagePickerItem;
+import org.jackhuang.hmcl.ui.construct.MultiFileItem;
+import org.jackhuang.hmcl.util.*;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Optional;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+
+public final class VersionSettingsController {
+    private VersionSetting lastVersionSetting = null;
+    private Profile profile;
+    private String versionId;
+
+    @FXML private VBox rootPane;
+    @FXML private ScrollPane scroll;
+    @FXML private JFXTextField txtWidth;
+    @FXML private JFXTextField txtHeight;
+    @FXML private JFXTextField txtMaxMemory;
+    @FXML private JFXTextField txtJVMArgs;
+    @FXML private JFXTextField txtGameArgs;
+    @FXML private JFXTextField txtMetaspace;
+    @FXML private JFXTextField txtWrapper;
+    @FXML private JFXTextField txtPrecallingCommand;
+    @FXML private JFXTextField txtServerIP;
+    @FXML private ComponentList advancedSettingsPane;
+    @FXML private JFXComboBox<?> cboLauncherVisibility;
+    @FXML private JFXCheckBox chkFullscreen;
+    @FXML private Label lblPhysicalMemory;
+    @FXML private JFXToggleButton chkNoJVMArgs;
+    @FXML private JFXToggleButton chkNoCommon;
+    @FXML private JFXToggleButton chkNoGameCheck;
+    @FXML private MultiFileItem globalItem;
+    @FXML private MultiFileItem javaItem;
+    @FXML private MultiFileItem gameDirItem;
+    @FXML private JFXToggleButton chkShowLogs;
+    @FXML private ImagePickerItem iconPickerItem;
+
+    @FXML
+    private void initialize() {
+        lblPhysicalMemory.setText(i18n("settings.physical_memory") + ": " + OperatingSystem.TOTAL_MEMORY + "MB");
+
+        FXUtils.smoothScrolling(scroll);
+
+        Task.of(variables -> variables.set("list", JavaVersion.getJREs()))
+                .subscribe(Schedulers.javafx(), variables -> {
+                    javaItem.loadChildren(
+                            (variables.<List<JavaVersion>>get("list")).stream()
+                                    .map(javaVersion -> javaItem.createChildren(javaVersion.getVersion(), javaVersion.getBinary().getAbsolutePath(), javaVersion))
+                                    .collect(Collectors.toList()));
+                    initializeSelectedJava();
+                });
+
+        if (OperatingSystem.CURRENT_OS == OperatingSystem.WINDOWS)
+            javaItem.getExtensionFilters().add(new FileChooser.ExtensionFilter("Java", "java.exe", "javaw.exe"));
+
+        gameDirItem.loadChildren(Arrays.asList(
+                gameDirItem.createChildren(i18n("settings.advanced.game_dir.default"), EnumGameDirectory.ROOT_FOLDER),
+                gameDirItem.createChildren(i18n("settings.advanced.game_dir.independent"), EnumGameDirectory.VERSION_FOLDER)
+        ));
+
+        globalItem.loadChildren(Arrays.asList(
+                globalItem.createChildren(i18n("settings.type.global"), true),
+                globalItem.createChildren(i18n("settings.type.special"), false)
+        ));
+    }
+
+    public void loadVersionSetting(Profile profile, String versionId) {
+        this.profile = profile;
+        this.versionId = versionId;
+
+        VersionSetting versionSetting = profile.getVersionSetting(versionId);
+
+        gameDirItem.setDisable(profile.getRepository().isModpack(versionId));
+        globalItem.setDisable(profile.getRepository().isModpack(versionId));
+
+        // unbind data fields
+        if (lastVersionSetting != null) {
+            FXUtils.unbindInt(txtWidth, lastVersionSetting.widthProperty());
+            FXUtils.unbindInt(txtHeight, lastVersionSetting.heightProperty());
+            FXUtils.unbindInt(txtMaxMemory, lastVersionSetting.maxMemoryProperty());
+            FXUtils.unbindString(javaItem.getTxtCustom(), lastVersionSetting.javaDirProperty());
+            FXUtils.unbindString(gameDirItem.getTxtCustom(), lastVersionSetting.gameDirProperty());
+            FXUtils.unbindString(txtJVMArgs, lastVersionSetting.javaArgsProperty());
+            FXUtils.unbindString(txtGameArgs, lastVersionSetting.minecraftArgsProperty());
+            FXUtils.unbindString(txtMetaspace, lastVersionSetting.permSizeProperty());
+            FXUtils.unbindString(txtWrapper, lastVersionSetting.wrapperProperty());
+            FXUtils.unbindString(txtPrecallingCommand, lastVersionSetting.preLaunchCommandProperty());
+            FXUtils.unbindString(txtServerIP, lastVersionSetting.serverIpProperty());
+            FXUtils.unbindBoolean(chkFullscreen, lastVersionSetting.fullscreenProperty());
+            FXUtils.unbindBoolean(chkNoGameCheck, lastVersionSetting.notCheckGameProperty());
+            FXUtils.unbindBoolean(chkNoCommon, lastVersionSetting.noCommonProperty());
+            FXUtils.unbindBoolean(chkShowLogs, lastVersionSetting.showLogsProperty());
+            FXUtils.unbindEnum(cboLauncherVisibility);
+        }
+
+        // unbind data fields
+        globalItem.setToggleSelectedListener(null);
+        javaItem.setToggleSelectedListener(null);
+        gameDirItem.setToggleSelectedListener(null);
+
+        // bind new data fields
+        FXUtils.bindInt(txtWidth, versionSetting.widthProperty());
+        FXUtils.bindInt(txtHeight, versionSetting.heightProperty());
+        FXUtils.bindInt(txtMaxMemory, versionSetting.maxMemoryProperty());
+        FXUtils.bindString(javaItem.getTxtCustom(), versionSetting.javaDirProperty());
+        FXUtils.bindString(gameDirItem.getTxtCustom(), versionSetting.gameDirProperty());
+        FXUtils.bindString(txtJVMArgs, versionSetting.javaArgsProperty());
+        FXUtils.bindString(txtGameArgs, versionSetting.minecraftArgsProperty());
+        FXUtils.bindString(txtMetaspace, versionSetting.permSizeProperty());
+        FXUtils.bindString(txtWrapper, versionSetting.wrapperProperty());
+        FXUtils.bindString(txtPrecallingCommand, versionSetting.preLaunchCommandProperty());
+        FXUtils.bindString(txtServerIP, versionSetting.serverIpProperty());
+        FXUtils.bindBoolean(chkFullscreen, versionSetting.fullscreenProperty());
+        FXUtils.bindBoolean(chkNoGameCheck, versionSetting.notCheckGameProperty());
+        FXUtils.bindBoolean(chkNoCommon, versionSetting.noCommonProperty());
+        FXUtils.bindBoolean(chkShowLogs, versionSetting.showLogsProperty());
+        FXUtils.bindEnum(cboLauncherVisibility, versionSetting.launcherVisibilityProperty());
+
+        javaItem.setToggleSelectedListener(newValue -> {
+            if (javaItem.isCustomToggle(newValue)) {
+                versionSetting.setJava("Custom");
+                versionSetting.setDefaultJavaPath(null);
+            } else {
+                JavaVersion java = (JavaVersion) newValue.getUserData();
+                versionSetting.setJava(java.getVersion());
+                versionSetting.setDefaultJavaPath(java.getBinary().toString());
+            }
+        });
+
+        versionSetting.javaDirProperty().setChangedListener(it -> initJavaSubtitle(versionSetting));
+        versionSetting.javaProperty().setChangedListener(it -> initJavaSubtitle(versionSetting));
+        initJavaSubtitle(versionSetting);
+
+        if (versionSetting.isUsesGlobal())
+            globalItem.getGroup().getToggles().stream().filter(it -> it.getUserData() == Boolean.TRUE).findFirst().ifPresent(it -> it.setSelected(true));
+        else
+            globalItem.getGroup().getToggles().stream().filter(it -> it.getUserData() == Boolean.FALSE).findFirst().ifPresent(it -> it.setSelected(true));
+        globalItem.setToggleSelectedListener(newValue -> {
+            // do not call versionSettings.setUsesGlobal(true/false)
+            // because versionSettings can be the global one.
+            if ((Boolean) newValue.getUserData())
+                profile.globalizeVersionSetting(versionId);
+            else
+                profile.specializeVersionSetting(versionId);
+
+            Platform.runLater(() -> loadVersionSetting(profile, versionId));
+        });
+
+        versionSetting.usesGlobalProperty().setChangedListenerAndOperate(it ->
+                globalItem.setSubtitle(i18n(versionSetting.isUsesGlobal() ? "settings.type.global" : "settings.type.special")));
+
+        gameDirItem.getGroup().getToggles().stream()
+                .filter(it -> it.getUserData() == versionSetting.getGameDirType())
+                .findFirst().ifPresent(toggle -> toggle.setSelected(true));
+
+        gameDirItem.setCustomUserData(EnumGameDirectory.CUSTOM);
+        gameDirItem.setToggleSelectedListener(newValue -> versionSetting.setGameDirType((EnumGameDirectory) newValue.getUserData()));
+
+        versionSetting.gameDirProperty().setChangedListener(it -> initGameDirSubtitle(versionSetting));
+        versionSetting.gameDirTypeProperty().setChangedListener(it -> initGameDirSubtitle(versionSetting));
+        initGameDirSubtitle(versionSetting);
+
+        lastVersionSetting = versionSetting;
+
+        initializeSelectedJava();
+
+        loadIcon();
+    }
+
+    private void initializeSelectedJava() {
+        if (lastVersionSetting == null
+                || !JavaVersion.getJREsImmediately().isPresent() /* JREs are still being loaded */) {
+            return;
+        }
+
+        boolean flag = false;
+        Toggle defaultToggle = null;
+        for (Toggle toggle : javaItem.getGroup().getToggles()) {
+            if (toggle.getUserData() == Lang.invoke(lastVersionSetting::getJavaVersion)) {
+                toggle.setSelected(true);
+                flag = true;
+            } else if (toggle.getUserData() == JavaVersion.fromCurrentEnvironment()) {
+                defaultToggle = toggle;
+            }
+        }
+
+        if (!flag) {
+            Optional.ofNullable(defaultToggle).ifPresent(t -> t.setSelected(true));
+        }
+    }
+
+    private void initJavaSubtitle(VersionSetting versionSetting) {
+        Task.of(variables -> variables.set("java", versionSetting.getJavaVersion()))
+                .subscribe(Task.of(Schedulers.javafx(),
+                        variables -> javaItem.setSubtitle(variables.<JavaVersion>getOptional("java")
+                                .map(JavaVersion::getBinary).map(File::getAbsolutePath).orElse("Invalid Java Directory"))));
+    }
+
+    private void initGameDirSubtitle(VersionSetting versionSetting) {
+        gameDirItem.setSubtitle(profile.getRepository().getRunDirectory(versionId).getAbsolutePath());
+    }
+
+    @FXML
+    private void onExploreIcon() {
+        FileChooser chooser = new FileChooser();
+        chooser.getExtensionFilters().add(new FileChooser.ExtensionFilter(i18n("extension.png"), "*.png"));
+        File selectedFile = chooser.showOpenDialog(Controllers.getStage());
+        if (selectedFile != null) {
+            File iconFile = profile.getRepository().getVersionIcon(versionId);
+            try {
+                FileUtils.copyFile(selectedFile, iconFile);
+                loadIcon();
+            } catch (IOException e) {
+                Logging.LOG.log(Level.SEVERE, "Failed to copy icon file from " + selectedFile + " to " + iconFile, e);
+            }
+        }
+    }
+
+    private void loadIcon() {
+        File iconFile = profile.getRepository().getVersionIcon(versionId);
+        if (iconFile.exists())
+            iconPickerItem.setImage(new Image("file:" + iconFile.getAbsolutePath()));
+        else
+            iconPickerItem.setImage(Constants.DEFAULT_ICON.get());
+        FXUtils.limitSize(iconPickerItem.getImageView(), 32, 32);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/WebStage.java

@@ -0,0 +1,38 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui;
+
+import javafx.scene.Scene;
+import javafx.scene.image.Image;
+import javafx.scene.web.WebView;
+import javafx.stage.Stage;
+import org.jackhuang.hmcl.setting.Settings;
+
+public class WebStage extends Stage {
+    private final WebView webView = new WebView();
+
+    public WebStage() {
+        setScene(new Scene(webView, 800, 480));
+        getScene().getStylesheets().addAll(Settings.INSTANCE.getTheme().getStylesheets());
+        getIcons().add(new Image("/assets/img/icon.png"));
+    }
+
+    public WebView getWebView() {
+        return webView;
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/animation/AnimationHandler.java

@@ -0,0 +1,29 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.animation;
+
+import javafx.scene.Node;
+import javafx.scene.layout.Pane;
+import javafx.util.Duration;
+
+public interface AnimationHandler {
+    Duration getDuration();
+    Pane getCurrentRoot();
+    Node getPreviousNode();
+    Node getCurrentNode();
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/animation/AnimationProducer.java

@@ -1,6 +1,6 @@
 /*
  * Hello Minecraft! Launcher.
- * Copyright (C) 2017  huangyuhui <[email protected]>
+ * Copyright (C) 2018  huangyuhui <[email protected]>
  * 
  * 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
@@ -15,14 +15,15 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see {http://www.gnu.org/licenses/}.
  */
-package org.jackhuang.hmcl.ui.animation
+package org.jackhuang.hmcl.ui.animation;
 
-import javafx.scene.Node
-import javafx.scene.layout.Pane
-import javafx.util.Duration
+import javafx.animation.KeyFrame;
+import javafx.util.Duration;
 
-interface AnimationHandler {
-    val snapshot: Node
-    val duration: Duration
-    val view: Pane
-}
+import java.util.List;
+
+public interface AnimationProducer {
+    void init(AnimationHandler handler);
+
+    List<KeyFrame> animate(AnimationHandler handler);
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/animation/ContainerAnimations.java

@@ -0,0 +1,155 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright c 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.animation;
+
+import javafx.animation.Interpolator;
+import javafx.animation.KeyFrame;
+import javafx.animation.KeyValue;
+import javafx.scene.Node;
+import javafx.util.Duration;
+import org.jackhuang.hmcl.util.Lang;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public enum ContainerAnimations {
+    NONE(c -> {
+        c.getPreviousNode().setTranslateX(0);
+        c.getPreviousNode().setTranslateY(0);
+        c.getPreviousNode().setScaleX(1);
+        c.getPreviousNode().setScaleY(1);
+        c.getPreviousNode().setOpacity(1);
+        c.getCurrentNode().setTranslateX(0);
+        c.getCurrentNode().setTranslateY(0);
+        c.getCurrentNode().setScaleX(1);
+        c.getCurrentNode().setScaleY(1);
+        c.getCurrentNode().setOpacity(1);
+    }, c -> Collections.emptyList()),
+    /**
+     * A fade between the old and new view
+     */
+    FADE(c -> {
+        c.getPreviousNode().setTranslateX(0);
+        c.getPreviousNode().setTranslateY(0);
+        c.getPreviousNode().setScaleX(1);
+        c.getPreviousNode().setScaleY(1);
+        c.getCurrentNode().setTranslateX(0);
+        c.getCurrentNode().setTranslateY(0);
+        c.getCurrentNode().setScaleX(1);
+        c.getCurrentNode().setScaleY(1);
+    }, c ->
+            Arrays.asList(new KeyFrame(Duration.ZERO,
+                            new KeyValue(c.getPreviousNode().opacityProperty(), 1.0D, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getCurrentNode().opacityProperty(), 0.0D, Interpolator.EASE_BOTH)),
+                    new KeyFrame(c.getDuration(),
+                            new KeyValue(c.getPreviousNode().opacityProperty(), 0.0D, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getCurrentNode().opacityProperty(), 1.0D, Interpolator.EASE_BOTH)))),
+    /**
+     * A zoom effect
+     */
+    ZOOM_IN(c -> {
+        c.getPreviousNode().setTranslateX(0);
+        c.getPreviousNode().setTranslateY(0);
+        c.getCurrentNode().setTranslateX(0);
+        c.getCurrentNode().setTranslateY(0);
+    }, c ->
+            Arrays.asList(new KeyFrame(Duration.ZERO,
+                            new KeyValue(c.getPreviousNode().scaleXProperty(), 1, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().scaleYProperty(), 1, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().opacityProperty(), 1.0D, Interpolator.EASE_BOTH)),
+                    new KeyFrame(c.getDuration(),
+                            new KeyValue(c.getPreviousNode().scaleXProperty(), 4, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().scaleYProperty(), 4, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().opacityProperty(), 0, Interpolator.EASE_BOTH)))),
+    /**
+     * A zoom effect
+     */
+    ZOOM_OUT(c -> {
+        c.getPreviousNode().setTranslateX(0);
+        c.getPreviousNode().setTranslateY(0);
+        c.getCurrentNode().setTranslateX(0);
+        c.getCurrentNode().setTranslateY(0);
+    }, c ->
+            (Arrays.asList(new KeyFrame(Duration.ZERO,
+                            new KeyValue(c.getPreviousNode().scaleXProperty(), 1, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().scaleYProperty(), 1, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().opacityProperty(), 1.0D, Interpolator.EASE_BOTH)),
+                    new KeyFrame(c.getDuration(),
+                            new KeyValue(c.getPreviousNode().scaleXProperty(), 0, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().scaleYProperty(), 0, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().opacityProperty(), 0, Interpolator.EASE_BOTH))))),
+    /**
+     * A swipe effect
+     */
+    SWIPE_LEFT(c -> {
+        c.getPreviousNode().setScaleX(1);
+        c.getPreviousNode().setScaleY(1);
+        c.getPreviousNode().setOpacity(0);
+        c.getCurrentNode().setScaleX(1);
+        c.getCurrentNode().setScaleY(1);
+        c.getCurrentNode().setOpacity(1);
+    }, c ->
+            Arrays.asList(new KeyFrame(Duration.ZERO,
+                            new KeyValue(c.getCurrentNode().translateXProperty(), c.getCurrentRoot().getWidth(), Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().translateXProperty(), 0, Interpolator.EASE_BOTH)),
+                    new KeyFrame(c.getDuration(),
+                            new KeyValue(c.getCurrentNode().translateXProperty(), 0, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().translateXProperty(), -c.getCurrentRoot().getWidth(), Interpolator.EASE_BOTH)))),
+
+    /**
+     * A swipe effect
+     */
+    SWIPE_RIGHT(c -> {
+        c.getPreviousNode().setScaleX(1);
+        c.getPreviousNode().setScaleY(1);
+        c.getPreviousNode().setOpacity(0);
+        c.getCurrentNode().setScaleX(1);
+        c.getCurrentNode().setScaleY(1);
+        c.getCurrentNode().setOpacity(1);
+    }, c ->
+            Arrays.asList(new KeyFrame(Duration.ZERO,
+                            new KeyValue(c.getCurrentNode().translateXProperty(), -c.getCurrentRoot().getWidth(), Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().translateXProperty(), 0, Interpolator.EASE_BOTH)),
+                    new KeyFrame(c.getDuration(),
+                            new KeyValue(c.getCurrentNode().translateXProperty(), 0, Interpolator.EASE_BOTH),
+                            new KeyValue(c.getPreviousNode().translateXProperty(), c.getCurrentRoot().getWidth(), Interpolator.EASE_BOTH))));
+
+    private final AnimationProducer animationProducer;
+
+    ContainerAnimations(Consumer<AnimationHandler> init, Function<AnimationHandler, List<KeyFrame>> animationProducer) {
+        this.animationProducer = new AnimationProducer() {
+            @Override
+            public void init(AnimationHandler handler) {
+                init.accept(handler);
+            }
+
+            @Override
+            public List<KeyFrame> animate(AnimationHandler handler) {
+                return animationProducer.apply(handler);
+            }
+        };
+    }
+
+    public AnimationProducer getAnimationProducer() {
+        return animationProducer;
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/animation/TransitionHandler.java

@@ -0,0 +1,116 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.animation;
+
+import javafx.animation.KeyFrame;
+import javafx.animation.Timeline;
+import javafx.application.Platform;
+import javafx.scene.Node;
+import javafx.scene.Parent;
+import javafx.scene.layout.StackPane;
+import javafx.scene.shape.Rectangle;
+import javafx.util.Duration;
+
+public final class TransitionHandler implements AnimationHandler {
+    private final StackPane view;
+    private Timeline animation;
+    private Duration duration;
+    private Node previousNode, currentNode;
+
+    /**
+     * @param view A stack pane that contains another control that is {@link Parent}
+     */
+    public TransitionHandler(StackPane view) {
+        this.view = view;
+        currentNode = view.getChildren().stream().findFirst().orElse(null);
+
+        // prevent content overflow
+        Rectangle clip = new Rectangle();
+        clip.widthProperty().bind(view.widthProperty());
+        clip.heightProperty().bind(view.heightProperty());
+        view.setClip(clip);
+    }
+
+    @Override
+    public Node getPreviousNode() {
+        return previousNode;
+    }
+
+    @Override
+    public Node getCurrentNode() {
+        return currentNode;
+    }
+
+    @Override
+    public StackPane getCurrentRoot() {
+        return view;
+    }
+
+    @Override
+    public Duration getDuration() {
+        return duration;
+    }
+
+    public void setContent(Node newView, AnimationProducer transition) {
+        setContent(newView, transition, Duration.millis(320));
+    }
+
+    public void setContent(Node newView, AnimationProducer transition, Duration duration) {
+        this.duration = duration;
+
+        Timeline prev = animation;
+        if (prev != null)
+            prev.stop();
+
+        updateContent(newView);
+
+        transition.init(this);
+
+        // runLater or "init" will not work
+        Platform.runLater(() -> {
+            Timeline nowAnimation = new Timeline();
+            nowAnimation.getKeyFrames().addAll(transition.animate(this));
+            nowAnimation.getKeyFrames().add(new KeyFrame(duration, e -> {
+                view.setMouseTransparent(false);
+                view.getChildren().remove(previousNode);
+            }));
+            nowAnimation.play();
+            animation = nowAnimation;
+        });
+    }
+
+    private void updateContent(Node newView) {
+        if (view.getWidth() > 0 && view.getHeight() > 0) {
+            previousNode = currentNode;
+            if (previousNode == null)
+                previousNode = EMPTY_PANE;
+        } else
+            previousNode = EMPTY_PANE;
+
+        if (previousNode == newView)
+            previousNode = EMPTY_PANE;
+
+        view.setMouseTransparent(true);
+
+        currentNode = newView;
+
+        view.getChildren().setAll(previousNode, currentNode);
+    }
+
+    private final StackPane EMPTY_PANE = new StackPane();
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/AdvancedListBox.java

@@ -0,0 +1,85 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import javafx.collections.ObservableList;
+import javafx.scene.Node;
+import javafx.scene.control.ScrollPane;
+import javafx.scene.layout.Pane;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import org.jackhuang.hmcl.ui.FXUtils;
+
+public class AdvancedListBox extends ScrollPane {
+    private final VBox container = new VBox();
+
+    {
+        setContent(container);
+
+        FXUtils.smoothScrolling(this);
+
+        setFitToHeight(true);
+        setFitToWidth(true);
+        setHbarPolicy(ScrollBarPolicy.NEVER);
+
+        container.setSpacing(5);
+        container.getStyleClass().add("advanced-list-box-content");
+    }
+
+    public AdvancedListBox add(Node child) {
+        if (child instanceof Pane)
+            container.getChildren().add(child);
+        else {
+            StackPane pane = new StackPane();
+            pane.getStyleClass().add("advanced-list-box-item");
+            pane.getChildren().setAll(child);
+            container.getChildren().add(pane);
+        }
+        return this;
+    }
+
+    public AdvancedListBox remove(Node child) {
+        if (child instanceof Pane)
+            container.getChildren().remove(child);
+        else {
+            StackPane pane = null;
+            for (Node node : container.getChildren())
+                if (node instanceof StackPane) {
+                    ObservableList<Node> list = ((StackPane) node).getChildren();
+                    if (list.size() == 1 && list.get(0) == child)
+                        pane = (StackPane) node;
+                }
+            if (pane == null)
+                throw new Error();
+            container.getChildren().remove(pane);
+        }
+        return this;
+    }
+
+    public AdvancedListBox startCategory(String category) {
+        return add(new ClassTitle(category));
+    }
+
+    public void setSpacing(double spacing) {
+        container.setSpacing(spacing);
+    }
+
+    public void clear() {
+        container.getChildren().clear();
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/ClassTitle.java

@@ -0,0 +1,63 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import javafx.scene.Node;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.text.Text;
+import org.jackhuang.hmcl.util.Lang;
+
+/**
+ * @author huangyuhui
+ */
+public class ClassTitle extends StackPane {
+    private final Node content;
+
+    public ClassTitle(String text) {
+        this(new Text(text));
+    }
+
+    public ClassTitle(Node content) {
+        this.content = content;
+
+        VBox vbox = new VBox();
+        vbox.getChildren().addAll(content);
+        Rectangle rectangle = new Rectangle();
+        rectangle.widthProperty().bind(vbox.widthProperty());
+        rectangle.setHeight(1.0);
+        rectangle.setFill(Color.GRAY);
+        vbox.getChildren().add(rectangle);
+        getChildren().setAll(vbox);
+        getStyleClass().add("class-title");
+    }
+
+    public ClassTitle(String text, Node rightNode) {
+        this(Lang.apply(new BorderPane(), borderPane -> {
+            borderPane.setLeft(Lang.apply(new VBox(), vBox -> vBox.getChildren().setAll(new Text(text))));
+            borderPane.setRight(rightNode);
+        }));
+    }
+
+    public Node getContent() {
+        return content;
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/ComponentList.java

@@ -0,0 +1,118 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import javafx.beans.DefaultProperty;
+import javafx.beans.property.IntegerProperty;
+import javafx.beans.property.SimpleIntegerProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ListChangeListener;
+import javafx.collections.ObservableList;
+import javafx.scene.Node;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+
+@DefaultProperty("content")
+public class ComponentList extends StackPane {
+    private final VBox vbox = new VBox();
+    private final StringProperty title = new SimpleStringProperty(this, "title", "Group");
+    private final StringProperty subtitle = new SimpleStringProperty(this, "subtitle", "");
+    private final IntegerProperty depth = new SimpleIntegerProperty(this, "depth", 0);
+    private boolean hasSubtitle = false;
+    public final ObservableList<Node> content = FXCollections.observableArrayList();
+
+    public ComponentList() {
+        getChildren().setAll(vbox);
+        content.addListener((ListChangeListener<? super Node>) change -> {
+            while (change.next()) {
+                for (int i = change.getFrom(); i < change.getTo(); ++i)
+                    addChildren(change.getList().get(i));
+            }
+        });
+        getStyleClass().add("options-list");
+    }
+
+    public void addChildren(Node node) {
+        if (node instanceof ComponentList) {
+            node.getProperties().put("title", ((ComponentList) node).getTitle());
+            node.getProperties().put("subtitle", ((ComponentList) node).getSubtitle());
+        }
+        StackPane child = new StackPane();
+        child.getChildren().add(new ComponentListCell(node));
+        if (vbox.getChildren().isEmpty())
+            child.getStyleClass().add("options-list-item-ahead");
+        else
+            child.getStyleClass().add("options-list-item");
+        child.getProperties().put("node", node);
+        vbox.getChildren().add(child);
+    }
+
+    public void removeChildren(Node node) {
+        vbox.getChildren().removeIf(node1 -> node1.getProperties().get("node") == node);
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+
+    public String getSubtitle() {
+        return subtitle.get();
+    }
+
+    public StringProperty subtitleProperty() {
+        return subtitle;
+    }
+
+    public void setSubtitle(String subtitle) {
+        this.subtitle.set(subtitle);
+    }
+
+    public int getDepth() {
+        return depth.get();
+    }
+
+    public IntegerProperty depthProperty() {
+        return depth;
+    }
+
+    public void setDepth(int depth) {
+        this.depth.set(depth);
+    }
+
+    public boolean isHasSubtitle() {
+        return hasSubtitle;
+    }
+
+    public void setHasSubtitle(boolean hasSubtitle) {
+        this.hasSubtitle = hasSubtitle;
+    }
+
+    public ObservableList<Node> getContent() {
+        return content;
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/ComponentListCell.java

@@ -0,0 +1,163 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXButton;
+import javafx.animation.Animation;
+import javafx.animation.KeyFrame;
+import javafx.animation.KeyValue;
+import javafx.animation.Timeline;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.control.Label;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import javafx.scene.shape.Rectangle;
+import javafx.util.Duration;
+import org.jackhuang.hmcl.setting.Theme;
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.SVG;
+
+/**
+ * @author huangyuhui
+ */
+public class ComponentListCell extends StackPane {
+    private final Node content;
+    private Animation expandAnimation;
+    private Rectangle clipRect;
+    private final BooleanProperty expanded = new SimpleBooleanProperty(this, "expanded", false);
+
+    public ComponentListCell(Node content) {
+        this.content = content;
+
+        updateLayout();
+    }
+
+    private void updateClip(double newHeight) {
+        if (clipRect != null)
+            clipRect.setHeight(newHeight);
+    }
+
+    @Override
+    protected void layoutChildren() {
+        super.layoutChildren();
+
+        if (clipRect == null)
+            clipRect = new Rectangle(0, 0, getWidth(), getHeight());
+        else {
+            clipRect.setX(0);
+            clipRect.setY(0);
+            clipRect.setHeight(getHeight());
+            clipRect.setWidth(getWidth());
+        }
+    }
+
+    private void updateLayout() {
+        if (content instanceof ComponentList) {
+            ComponentList list = (ComponentList) content;
+            content.getStyleClass().remove("options-list");
+            content.getStyleClass().add("options-sublist");
+
+            StackPane groupNode = new StackPane();
+            groupNode.getStyleClass().add("options-list-item-header");
+
+            Node expandIcon = SVG.expand(Theme.blackFillBinding(), 10, 10);
+            JFXButton expandButton = new JFXButton();
+            expandButton.setGraphic(expandIcon);
+            expandButton.getStyleClass().add("options-list-item-expand-button");
+            StackPane.setAlignment(expandButton, Pos.CENTER_RIGHT);
+
+            VBox labelVBox = new VBox();
+            Label label = new Label();
+            label.textProperty().bind(list.titleProperty());
+            label.setMouseTransparent(true);
+            labelVBox.getChildren().add(label);
+
+            if (list.isHasSubtitle()) {
+                Label subtitleLabel = new Label();
+                subtitleLabel.textProperty().bind(list.subtitleProperty());
+                subtitleLabel.setMouseTransparent(true);
+                subtitleLabel.getStyleClass().add("subtitle-label");
+                labelVBox.getChildren().add(subtitleLabel);
+            }
+
+            StackPane.setAlignment(labelVBox, Pos.CENTER_LEFT);
+            groupNode.getChildren().setAll(labelVBox, expandButton);
+
+            VBox container = new VBox();
+            container.setStyle("-fx-padding: 8 0 0 0;");
+            FXUtils.setLimitHeight(container, 0);
+            Rectangle clipRect = new Rectangle();
+            clipRect.widthProperty().bind(container.widthProperty());
+            clipRect.heightProperty().bind(container.heightProperty());
+            container.setClip(clipRect);
+            container.getChildren().setAll(content);
+
+            VBox holder = new VBox();
+            holder.getChildren().setAll(groupNode, container);
+            holder.getStyleClass().add("options-list-item-container");
+
+            expandButton.setOnMouseClicked(e -> {
+                if (expandAnimation != null && expandAnimation.getStatus() == Animation.Status.RUNNING) {
+                    expandAnimation.stop();
+                }
+
+                setExpanded(!isExpanded());
+
+                double newAnimatedHeight = content.prefHeight(-1) * (isExpanded() ? 1 : -1);
+                double newHeight = isExpanded() ? getHeight() + newAnimatedHeight : prefHeight(-1);
+                double contentHeight = isExpanded() ? newAnimatedHeight : 0;
+
+                if (isExpanded()) {
+                    updateClip(newHeight);
+                }
+
+                expandAnimation = new Timeline(new KeyFrame(new Duration(320.0),
+                        new KeyValue(container.minHeightProperty(), contentHeight, FXUtils.SINE),
+                        new KeyValue(container.maxHeightProperty(), contentHeight, FXUtils.SINE)
+                ));
+
+                if (!isExpanded()) {
+                    expandAnimation.setOnFinished(e2 -> updateClip(newHeight));
+                }
+
+                expandAnimation.play();
+            });
+
+            expandedProperty().addListener((a, b, newValue) ->
+                    expandIcon.setRotate(newValue ? 180 : 0));
+
+            getChildren().setAll(holder);
+        } else
+            getChildren().setAll(content);
+    }
+
+    public boolean isExpanded() {
+        return expanded.get();
+    }
+
+    public BooleanProperty expandedProperty() {
+        return expanded;
+    }
+
+    public void setExpanded(boolean expanded) {
+        this.expanded.set(expanded);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/DialogCloseEvent.java

@@ -0,0 +1,45 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import org.jackhuang.hmcl.ui.Controllers;
+
+import javafx.event.Event;
+import javafx.event.EventTarget;
+import javafx.event.EventType;
+import javafx.scene.layout.Region;
+
+/**
+ * Indicates a close operation on the dialog.
+ *
+ * @author yushijinhun
+ * @see Controllers#dialog(Region)
+ */
+public class DialogCloseEvent extends Event {
+
+    public static final EventType<DialogCloseEvent> CLOSE = new EventType<>("CLOSE");
+
+    public DialogCloseEvent() {
+        super(CLOSE);
+    }
+
+    public DialogCloseEvent(Object source, EventTarget target) {
+        super(source, target, CLOSE);
+    }
+
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/FileItem.java

@@ -0,0 +1,125 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXButton;
+import javafx.beans.property.Property;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.scene.control.Label;
+import javafx.scene.control.Tooltip;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.VBox;
+import javafx.stage.DirectoryChooser;
+
+import org.jackhuang.hmcl.setting.Theme;
+import org.jackhuang.hmcl.ui.Controllers;
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.SVG;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.File;
+
+public class FileItem extends BorderPane {
+    private Property<String> property;
+    private final Label x = new Label();
+
+    private final SimpleStringProperty name = new SimpleStringProperty(this, "name");
+    private final SimpleStringProperty title = new SimpleStringProperty(this, "title");
+    private final SimpleStringProperty tooltip = new SimpleStringProperty(this, "tooltip");
+
+    public FileItem() {
+        VBox left = new VBox();
+        Label name = new Label();
+        name.textProperty().bind(nameProperty());
+        x.getStyleClass().addAll("subtitle-label");
+        left.getChildren().addAll(name, x);
+        setLeft(left);
+
+        JFXButton right = new JFXButton();
+        right.setGraphic(SVG.pencil(Theme.blackFillBinding(), 15, 15));
+        right.getStyleClass().add("toggle-icon4");
+        right.setOnMouseClicked(e -> onExplore());
+        FXUtils.installTooltip(right, i18n("button.edit"));
+        setRight(right);
+
+        Tooltip tip = new Tooltip();
+        tip.textProperty().bind(tooltipProperty());
+        Tooltip.install(this, tip);
+    }
+
+    public void onExplore() {
+        DirectoryChooser chooser = new DirectoryChooser();
+        if (property.getValue() != null) {
+            File file = new File(property.getValue());
+            if (file.exists()) {
+                if (file.isFile())
+                    file = file.getAbsoluteFile().getParentFile();
+                else if (file.isDirectory())
+                    file = file.getAbsoluteFile();
+                chooser.setInitialDirectory(file);
+            }
+        }
+        chooser.titleProperty().bind(titleProperty());
+        File selectedDir = chooser.showDialog(Controllers.getStage());
+        if (selectedDir != null)
+            property.setValue(selectedDir.getAbsolutePath());
+        chooser.titleProperty().unbind();
+    }
+
+    public void setProperty(Property<String> property) {
+        this.property = property;
+        x.textProperty().bind(property);
+    }
+
+    public String getName() {
+        return name.get();
+    }
+
+    public StringProperty nameProperty() {
+        return name;
+    }
+
+    public void setName(String name) {
+        this.name.set(name);
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+
+    public String getTooltip() {
+        return tooltip.get();
+    }
+
+    public StringProperty tooltipProperty() {
+        return tooltip;
+    }
+
+    public void setTooltip(String tooltip) {
+        this.tooltip.set(tooltip);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/FontComboBox.java

@@ -0,0 +1,48 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXComboBox;
+import javafx.beans.NamedArg;
+import javafx.collections.FXCollections;
+import javafx.scene.control.ListCell;
+import javafx.scene.text.Font;
+
+public class FontComboBox extends JFXComboBox<String> {
+
+    public FontComboBox(@NamedArg(value = "fontSize", defaultValue = "12.0") double fontSize,
+                        @NamedArg(value = "enableStyle", defaultValue = "false") boolean enableStyle) {
+        super(FXCollections.observableArrayList(Font.getFamilies()));
+
+        valueProperty().addListener((a, b, newValue) -> {
+            if (enableStyle)
+                setStyle("-fx-font-family: \"" + newValue + "\";");
+        });
+
+        setCellFactory(listView -> new ListCell<String>() {
+            @Override
+            protected void updateItem(String item, boolean empty) {
+                super.updateItem(item, empty);
+                if (item != null) {
+                    setText(item);
+                    setFont(new Font(item, fontSize));
+                }
+            }
+        });
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/IconedItem.java

@@ -0,0 +1,52 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.control.Label;
+import javafx.scene.layout.HBox;
+import javafx.scene.paint.Paint;
+
+public class IconedItem extends RipplerContainer {
+
+    public IconedItem(Node icon, String text) {
+        super(createHBox(icon, text));
+    }
+
+    private static HBox createHBox(Node icon, String text) {
+        HBox hBox = new HBox();
+        icon.setMouseTransparent(true);
+        Label textLabel = new Label(text);
+        textLabel.setId("label");
+        textLabel.setAlignment(Pos.CENTER);
+        textLabel.setMouseTransparent(true);
+        hBox.getChildren().addAll(icon, textLabel);
+        hBox.setStyle("-fx-padding: 10 16 10 16; -fx-spacing: 10; -fx-font-size: 14;");
+        hBox.setAlignment(Pos.CENTER_LEFT);
+        return hBox;
+    }
+
+    public void setText(String text) {
+        ((Label) lookup("#label")).setText(text);
+    }
+
+    public void setTextFill(Paint paint) {
+        ((Label) lookup("#label")).setTextFill(paint);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/ImagePickerItem.java

@@ -0,0 +1,103 @@
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXButton;
+import javafx.beans.DefaultProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.event.EventHandler;
+import javafx.geometry.Pos;
+import javafx.scene.control.Label;
+import javafx.scene.image.Image;
+import javafx.scene.image.ImageView;
+import javafx.scene.input.MouseEvent;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import org.jackhuang.hmcl.setting.Theme;
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.SVG;
+
+@DefaultProperty("image")
+public final class ImagePickerItem extends BorderPane {
+
+    private final ImageView imageView;
+    private final JFXButton selectButton;
+    private final Label label;
+
+    private final StringProperty title = new SimpleStringProperty(this, "title");
+    private final ObjectProperty<EventHandler<? super MouseEvent>> onSelectButtonClicked = new SimpleObjectProperty<>(this, "onSelectButtonClicked");
+    private final ObjectProperty<Image> image = new SimpleObjectProperty<>(this, "image");
+
+    public ImagePickerItem() {
+        imageView = new ImageView();
+        imageView.setSmooth(false);
+        imageView.setPreserveRatio(true);
+
+        selectButton = new JFXButton();
+        selectButton.setGraphic(SVG.pencil(Theme.blackFillBinding(), 15, 15));
+        selectButton.onMouseClickedProperty().bind(onSelectButtonClicked);
+        selectButton.getStyleClass().add("toggle-icon4");
+
+        FXUtils.installTooltip(selectButton, i18n("button.edit"));
+
+        HBox hBox = new HBox();
+        hBox.getChildren().setAll(imageView, selectButton);
+        hBox.setAlignment(Pos.CENTER_RIGHT);
+        hBox.setSpacing(8);
+        setRight(hBox);
+
+        VBox vBox = new VBox();
+        label = new Label();
+        label.textProperty().bind(title);
+        vBox.getChildren().setAll(label);
+        vBox.setAlignment(Pos.CENTER_LEFT);
+        setLeft(vBox);
+
+        imageView.imageProperty().bind(image);
+    }
+
+    public String getTitle() {
+        return title.get();
+    }
+
+    public StringProperty titleProperty() {
+        return title;
+    }
+
+    public void setTitle(String title) {
+        this.title.set(title);
+    }
+
+    public EventHandler<? super MouseEvent> getOnSelectButtonClicked() {
+        return onSelectButtonClicked.get();
+    }
+
+    public ObjectProperty<EventHandler<? super MouseEvent>> onSelectButtonClickedProperty() {
+        return onSelectButtonClicked;
+    }
+
+    public void setOnSelectButtonClicked(EventHandler<? super MouseEvent> onSelectButtonClicked) {
+        this.onSelectButtonClicked.set(onSelectButtonClicked);
+    }
+
+    public Image getImage() {
+        return image.get();
+    }
+
+    public ObjectProperty<Image> imageProperty() {
+        return image;
+    }
+
+    public void setImage(Image image) {
+        this.image.set(image);
+    }
+
+    public ImageView getImageView() {
+        return imageView;
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/InputDialogPane.java

@@ -0,0 +1,49 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXTextField;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.layout.StackPane;
+import org.jackhuang.hmcl.ui.FXUtils;
+
+import java.util.function.Consumer;
+
+public class InputDialogPane extends StackPane {
+
+    @FXML
+    private JFXButton acceptButton;
+    @FXML
+    private JFXButton cancelButton;
+    @FXML
+    private JFXTextField textField;
+    @FXML
+    private Label content;
+
+    public InputDialogPane(String text, Consumer<String> onResult) {
+        FXUtils.loadFXML(this, "/assets/fxml/input-dialog.fxml");
+        content.setText(text);
+        cancelButton.setOnMouseClicked(e -> fireEvent(new DialogCloseEvent()));
+        acceptButton.setOnMouseClicked(e -> {
+            onResult.accept(textField.getText());
+            fireEvent(new DialogCloseEvent());
+        });
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/MessageBox.java

@@ -0,0 +1,173 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import javafx.scene.control.Alert;
+import javafx.scene.control.ButtonType;
+import javafx.scene.control.TextInputDialog;
+
+import org.jackhuang.hmcl.ui.FXUtils;
+import javax.swing.*;
+
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Optional;
+
+public final class MessageBox {
+    private MessageBox() {
+    }
+
+    private static final String TITLE = i18n("message.info");
+
+    /**
+     * User Operation: Yes
+     */
+    public static final int YES_OPTION = 0;
+
+    /**
+     * User Operation: No
+     */
+    public static final int NO_OPTION = 1;
+
+    /**
+     * User Operation: Cancel
+     */
+    public static final int CANCEL_OPTION = 2;
+
+    /**
+     * User Operation: OK
+     */
+    public static final int OK_OPTION = 0;
+
+    /**
+     * User Operation: Closed Message Box
+     */
+    public static final int CLOSED_OPTION = -1;
+
+    /**
+     * Buttons: Yes No
+     */
+    public static final int YES_NO_OPTION = 10;
+    /**
+     * Buttons: Yes No Cancel
+     */
+    public static final int YES_NO_CANCEL_OPTION = 11;
+    /**
+     * Buttons: OK Cancel
+     */
+    public static final int OK_CANCEL_OPTION = 12;
+
+    /**
+     * Message Box Type: Error
+     */
+    public static final int ERROR_MESSAGE = 0;
+    /**
+     * Message Box Type: Info
+     */
+    public static final int INFORMATION_MESSAGE = 1;
+    /**
+     * Message Box Type: Warning
+     */
+    public static final int WARNING_MESSAGE = 2;
+    /**
+     * Message Box Type: Question
+     */
+    public static final int QUESTION_MESSAGE = 3;
+    /**
+     * Message Box Type: Fine
+     */
+    public static final int FINE_MESSAGE = 4;
+    /**
+     * Message Box Type: Plain
+     */
+    public static final int PLAIN_MESSAGE = -1;
+
+
+    public static void show(String message) {
+        show(message, TITLE);
+    }
+
+    /**
+     * Show MsgBox with title and options
+     *
+     * @param message The Message
+     * @param title   The title of MsgBox.
+     * @return user operation.
+     */
+    public static Optional<ButtonType> show(String message, String title) {
+        Alert alert = new Alert(Alert.AlertType.INFORMATION);
+        alert.setTitle(title);
+        alert.setHeaderText(title);
+        alert.setContentText(message);
+        return alert.showAndWait();
+    }
+
+    public static int confirm(String message, String title) {
+        return confirm(message, title, -1);
+    }
+
+    public static int confirm(String message, int option) {
+        return confirm(message, TITLE, option);
+    }
+
+    public static int confirm(String message, String title, int option) {
+        return FXUtils.runInUIThread(() -> {
+            Alert alert = new Alert(Alert.AlertType.CONFIRMATION);
+            alert.setTitle(title);
+            alert.setHeaderText(title);
+            alert.setContentText(message);
+            switch (option) {
+                case YES_NO_OPTION:
+                    alert.getButtonTypes().setAll(ButtonType.YES, ButtonType.NO);
+                    break;
+                case YES_NO_CANCEL_OPTION:
+                    alert.getButtonTypes().setAll(ButtonType.YES, ButtonType.NO, ButtonType.CANCEL);
+                    break;
+                case OK_CANCEL_OPTION:
+                    alert.getButtonTypes().setAll(ButtonType.OK, ButtonType.CANCEL);
+                    break;
+                default:
+                    throw new IllegalArgumentException("Unrecognized message box option " + option);
+            }
+            Optional<ButtonType> buttonType = alert.showAndWait();
+            if (!buttonType.isPresent()) return CLOSED_OPTION;
+            else if (buttonType.get() == ButtonType.OK) return OK_OPTION;
+            else if (buttonType.get() == ButtonType.YES) return YES_OPTION;
+            else if (buttonType.get() == ButtonType.NO) return NO_OPTION;
+            else if (buttonType.get() == ButtonType.CANCEL) return CANCEL_OPTION;
+            else throw new IllegalStateException("Unexpected button type:" + buttonType.get());
+        });
+    }
+
+    public static Optional<String> input(String message) {
+        return input(message, UIManager.getString("OptionPane.inputDialogTitle"));
+    }
+
+    public static Optional<String> input(String message, String title) {
+        return input(message, title, "");
+    }
+
+    public static Optional<String> input(String message, String title, String initialValue) {
+        TextInputDialog dialog = new TextInputDialog(initialValue);
+        dialog.setTitle(title);
+        dialog.setHeaderText(message);
+        dialog.setContentText(message);
+
+        return dialog.showAndWait();
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/MessageDialogPane.java

@@ -0,0 +1,97 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXButton;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.StackPane;
+
+import org.jackhuang.hmcl.setting.Theme;
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.SVG;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Optional;
+
+public final class MessageDialogPane extends StackPane {
+
+    @FXML
+    private JFXButton acceptButton;
+    @FXML
+    private JFXButton cancelButton;
+    @FXML
+    private Label content;
+    @FXML
+    private Label graphic;
+    @FXML
+    private Label title;
+    @FXML
+    private HBox actions;
+
+    public MessageDialogPane(String text, String title, int type, Runnable onAccept) {
+        FXUtils.loadFXML(this, "/assets/fxml/message-dialog.fxml");
+
+        if (title != null)
+            this.title.setText(title);
+
+        content.setText(text);
+        acceptButton.setOnMouseClicked(e -> {
+            fireEvent(new DialogCloseEvent());
+            Optional.ofNullable(onAccept).ifPresent(Runnable::run);
+        });
+
+        actions.getChildren().remove(cancelButton);
+
+        switch (type) {
+            case MessageBox.INFORMATION_MESSAGE:
+                graphic.setGraphic(SVG.infoCircle(Theme.blackFillBinding(), 40, 40));
+                break;
+            case MessageBox.ERROR_MESSAGE:
+                graphic.setGraphic(SVG.closeCircle(Theme.blackFillBinding(), 40, 40));
+                break;
+            case MessageBox.FINE_MESSAGE:
+                graphic.setGraphic(SVG.checkCircle(Theme.blackFillBinding(), 40, 40));
+                break;
+            case MessageBox.WARNING_MESSAGE:
+                graphic.setGraphic(SVG.alert(Theme.blackFillBinding(), 40, 40));
+                break;
+            case MessageBox.QUESTION_MESSAGE:
+                graphic.setGraphic(SVG.helpCircle(Theme.blackFillBinding(), 40, 40));
+                break;
+            default:
+                throw new IllegalArgumentException("Unrecognized message box message type " + type);
+        }
+    }
+
+    public MessageDialogPane(String text, String title, Runnable onAccept, Runnable onCancel) {
+        this(text, title, MessageBox.QUESTION_MESSAGE, onAccept);
+
+        cancelButton.setVisible(true);
+        cancelButton.setOnMouseClicked(e -> {
+            fireEvent(new DialogCloseEvent());
+            Optional.ofNullable(onCancel).ifPresent(Runnable::run);
+        });
+
+        acceptButton.setText(i18n("button.yes"));
+        cancelButton.setText(i18n("button.no"));
+
+        actions.getChildren().add(cancelButton);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/MultiColorItem.java

@@ -0,0 +1,147 @@
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXColorPicker;
+import com.jfoenix.controls.JFXRadioButton;
+import javafx.beans.NamedArg;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.scene.Node;
+import javafx.scene.control.Label;
+import javafx.scene.control.Toggle;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.scene.paint.Color;
+
+import org.jackhuang.hmcl.ui.FXUtils;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Collection;
+import java.util.Optional;
+import java.util.function.Consumer;
+
+public class MultiColorItem extends ComponentList {
+    private final StringProperty customTitle = new SimpleStringProperty(this, "customTitle", i18n("selector.custom"));
+    private final StringProperty chooserTitle = new SimpleStringProperty(this, "chooserTitle", i18n("selector.choose_file"));
+
+    private final ToggleGroup group = new ToggleGroup();
+    private final JFXColorPicker colorPicker = new JFXColorPicker();
+    private final JFXRadioButton radioCustom = new JFXRadioButton();
+    private final BorderPane custom = new BorderPane();
+    private final VBox pane = new VBox();
+    private final boolean hasCustom;
+
+    private Consumer<Toggle> toggleSelectedListener;
+    private Consumer<Color> colorConsumer;
+
+    public MultiColorItem(@NamedArg(value = "hasCustom", defaultValue = "true") boolean hasCustom) {
+        this.hasCustom = hasCustom;
+
+        radioCustom.textProperty().bind(customTitleProperty());
+        radioCustom.setToggleGroup(group);
+        colorPicker.disableProperty().bind(radioCustom.selectedProperty().not());
+
+        colorPicker.setOnAction(e -> Optional.ofNullable(colorConsumer).ifPresent(c -> c.accept(colorPicker.getValue())));
+
+        custom.setLeft(radioCustom);
+        custom.setStyle("-fx-padding: 3;");
+        HBox right = new HBox();
+        right.setSpacing(3);
+        right.getChildren().addAll(colorPicker);
+        custom.setRight(right);
+        FXUtils.setLimitHeight(custom, 40);
+
+        pane.setStyle("-fx-padding: 0 0 10 0;");
+        pane.setSpacing(8);
+
+        if (hasCustom)
+            pane.getChildren().add(custom);
+        addChildren(pane);
+
+        group.selectedToggleProperty().addListener((a, b, newValue) -> {
+            if (toggleSelectedListener != null)
+                toggleSelectedListener.accept(newValue);
+        });
+    }
+
+    public Node createChildren(String title) {
+        return createChildren(title, null);
+    }
+
+    public Node createChildren(String title, Object userData) {
+        return createChildren(title, "", userData);
+    }
+
+    public Node createChildren(String title, String subtitle, Object userData) {
+        BorderPane pane = new BorderPane();
+        pane.setStyle("-fx-padding: 3;");
+
+        JFXRadioButton left = new JFXRadioButton(title);
+        left.setToggleGroup(group);
+        left.setUserData(userData);
+        pane.setLeft(left);
+
+        Label right = new Label(subtitle);
+        right.getStyleClass().add("subtitle-label");
+        right.setStyle("-fx-font-size: 10;");
+        pane.setRight(right);
+
+        return pane;
+    }
+
+    public void loadChildren(Collection<Node> list) {
+        pane.getChildren().setAll(list);
+
+        if (hasCustom)
+            pane.getChildren().add(custom);
+    }
+
+    public ToggleGroup getGroup() {
+        return group;
+    }
+
+    public String getCustomTitle() {
+        return customTitle.get();
+    }
+
+    public StringProperty customTitleProperty() {
+        return customTitle;
+    }
+
+    public void setCustomTitle(String customTitle) {
+        this.customTitle.set(customTitle);
+    }
+
+    public String getChooserTitle() {
+        return chooserTitle.get();
+    }
+
+    public StringProperty chooserTitleProperty() {
+        return chooserTitle;
+    }
+
+    public void setChooserTitle(String chooserTitle) {
+        this.chooserTitle.set(chooserTitle);
+    }
+
+    public void setCustomUserData(Object userData) {
+        radioCustom.setUserData(userData);
+    }
+
+    public boolean isCustomToggle(Toggle toggle) {
+        return radioCustom == toggle;
+    }
+
+    public void setToggleSelectedListener(Consumer<Toggle> consumer) {
+        toggleSelectedListener = consumer;
+    }
+
+    public void setOnColorPickerChanged(Consumer<Color> consumer) {
+        colorConsumer = consumer;
+    }
+
+    public void setColor(Color color) {
+        colorPicker.setValue(color);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/MultiFileItem.java

@@ -0,0 +1,228 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXRadioButton;
+import com.jfoenix.controls.JFXTextField;
+import javafx.beans.NamedArg;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleStringProperty;
+import javafx.beans.property.StringProperty;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import javafx.scene.control.Label;
+import javafx.scene.control.Toggle;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.VBox;
+import javafx.stage.DirectoryChooser;
+import javafx.stage.FileChooser;
+
+import org.jackhuang.hmcl.setting.Theme;
+import org.jackhuang.hmcl.ui.Controllers;
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.SVG;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.File;
+import java.util.Collection;
+import java.util.function.Consumer;
+
+public class MultiFileItem extends ComponentList {
+    private final StringProperty customTitle = new SimpleStringProperty(this, "customTitle", i18n("selector.custom"));
+    private final StringProperty chooserTitle = new SimpleStringProperty(this, "chooserTitle", i18n("selector.choose_file"));
+    private final BooleanProperty directory = new SimpleBooleanProperty(this, "directory", false);
+    private final ObservableList<FileChooser.ExtensionFilter> extensionFilters = FXCollections.observableArrayList();
+
+    private final ToggleGroup group = new ToggleGroup();
+    private final JFXTextField txtCustom = new JFXTextField();
+    private final JFXButton btnSelect = new JFXButton();
+    private final JFXRadioButton radioCustom = new JFXRadioButton();
+    private final BorderPane custom = new BorderPane();
+    private final VBox pane = new VBox();
+    private final boolean hasCustom;
+
+    private Consumer<Toggle> toggleSelectedListener;
+
+    public MultiFileItem(@NamedArg(value = "hasCustom", defaultValue = "true") boolean hasCustom) {
+        this.hasCustom = hasCustom;
+
+        BorderPane.setAlignment(txtCustom, Pos.CENTER_RIGHT);
+
+        btnSelect.setGraphic(SVG.folderOpen(Theme.blackFillBinding(), 15, 15));
+        btnSelect.setOnMouseClicked(e -> {
+            if (isDirectory()) {
+                DirectoryChooser chooser = new DirectoryChooser();
+                chooser.titleProperty().bind(chooserTitle);
+                File dir = chooser.showDialog(Controllers.getStage());
+                if (dir != null)
+                    txtCustom.setText(dir.getAbsolutePath());
+            } else {
+                FileChooser chooser = new FileChooser();
+                chooser.getExtensionFilters().addAll(getExtensionFilters());
+                chooser.titleProperty().bind(chooserTitle);
+                File file = chooser.showOpenDialog(Controllers.getStage());
+                if (file != null)
+                    txtCustom.setText(file.getAbsolutePath());
+            }
+        });
+
+        radioCustom.textProperty().bind(customTitleProperty());
+        radioCustom.setToggleGroup(group);
+        txtCustom.disableProperty().bind(radioCustom.selectedProperty().not());
+        btnSelect.disableProperty().bind(radioCustom.selectedProperty().not());
+
+        custom.setLeft(radioCustom);
+        custom.setStyle("-fx-padding: 3;");
+        HBox right = new HBox();
+        right.setSpacing(3);
+        right.getChildren().addAll(txtCustom, btnSelect);
+        custom.setRight(right);
+        FXUtils.setLimitHeight(custom, 20);
+
+        pane.setStyle("-fx-padding: 0 0 10 0;");
+        pane.setSpacing(8);
+
+        if (hasCustom)
+            pane.getChildren().add(custom);
+        addChildren(pane);
+
+        group.selectedToggleProperty().addListener((a, b, newValue) -> {
+            if (toggleSelectedListener != null)
+                toggleSelectedListener.accept(newValue);
+        });
+    }
+
+    public Node createChildren(String title) {
+        return createChildren(title, null);
+    }
+
+    public Node createChildren(String title, Object userData) {
+        return createChildren(title, "", userData);
+    }
+
+    public Node createChildren(String title, String subtitle, Object userData) {
+        BorderPane pane = new BorderPane();
+        pane.setStyle("-fx-padding: 3;");
+        FXUtils.setLimitHeight(pane, 20);
+
+        JFXRadioButton left = new JFXRadioButton(title);
+        left.setToggleGroup(group);
+        left.setUserData(userData);
+        pane.setLeft(left);
+
+        Label right = new Label(subtitle);
+        right.getStyleClass().add("subtitle-label");
+        right.setStyle("-fx-font-size: 10;");
+        pane.setRight(right);
+
+        return pane;
+    }
+
+    public void loadChildren(Collection<Node> list) {
+        pane.getChildren().setAll(list);
+
+        if (hasCustom)
+            pane.getChildren().add(custom);
+    }
+
+    public void onExploreJavaDir() {
+        DirectoryChooser chooser = new DirectoryChooser();
+        chooser.setTitle(i18n(getChooserTitle()));
+        File selectedDir = chooser.showDialog(Controllers.getStage());
+        if (selectedDir != null)
+            txtCustom.setText(selectedDir.getAbsolutePath());
+    }
+
+    public ToggleGroup getGroup() {
+        return group;
+    }
+
+    public String getCustomTitle() {
+        return customTitle.get();
+    }
+
+    public StringProperty customTitleProperty() {
+        return customTitle;
+    }
+
+    public void setCustomTitle(String customTitle) {
+        this.customTitle.set(customTitle);
+    }
+
+    public String getChooserTitle() {
+        return chooserTitle.get();
+    }
+
+    public StringProperty chooserTitleProperty() {
+        return chooserTitle;
+    }
+
+    public void setChooserTitle(String chooserTitle) {
+        this.chooserTitle.set(chooserTitle);
+    }
+
+    public void setCustomUserData(Object userData) {
+        radioCustom.setUserData(userData);
+    }
+
+    public boolean isCustomToggle(Toggle toggle) {
+        return radioCustom == toggle;
+    }
+
+    public void setToggleSelectedListener(Consumer<Toggle> consumer) {
+        toggleSelectedListener = consumer;
+    }
+
+    public StringProperty customTextProperty() {
+        return txtCustom.textProperty();
+    }
+
+    public String getCustomText() {
+        return txtCustom.getText();
+    }
+
+    public void setCustomText(String customText) {
+        txtCustom.setText(customText);
+    }
+
+    public JFXTextField getTxtCustom() {
+        return txtCustom;
+    }
+
+    public boolean isDirectory() {
+        return directory.get();
+    }
+
+    public BooleanProperty directoryProperty() {
+        return directory;
+    }
+
+    public void setDirectory(boolean directory) {
+        this.directory.set(directory);
+    }
+
+    public ObservableList<FileChooser.ExtensionFilter> getExtensionFilters() {
+        return extensionFilters;
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/NoneMultipleSelectionModel.java

@@ -0,0 +1,92 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.scene.control.MultipleSelectionModel;
+
+public class NoneMultipleSelectionModel<T> extends MultipleSelectionModel<T> {
+
+    public NoneMultipleSelectionModel() {
+    }
+
+    @Override
+    public ObservableList<Integer> getSelectedIndices() {
+        return FXCollections.emptyObservableList();
+    }
+
+    @Override
+    public ObservableList<T> getSelectedItems() {
+        return FXCollections.emptyObservableList();
+    }
+
+    @Override
+    public void selectIndices(int index, int... indices) {
+    }
+
+    @Override
+    public void selectAll() {
+    }
+
+    @Override
+    public void clearAndSelect(int index) {
+    }
+
+    @Override
+    public void select(int index) {
+    }
+
+    @Override
+    public void select(T obj) {
+    }
+
+    @Override
+    public void clearSelection(int index) {
+    }
+
+    @Override
+    public void clearSelection() {
+    }
+
+    @Override
+    public boolean isSelected(int index) {
+        return false;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return true;
+    }
+
+    @Override
+    public void selectPrevious() {
+    }
+
+    @Override
+    public void selectNext() {
+    }
+
+    @Override
+    public void selectFirst() {
+    }
+
+    @Override
+    public void selectLast() {
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/NumberValidator.java

@@ -0,0 +1,57 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.validation.base.ValidatorBase;
+import javafx.beans.NamedArg;
+import javafx.scene.control.TextInputControl;
+import org.jackhuang.hmcl.util.Lang;
+import org.jackhuang.hmcl.util.StringUtils;
+
+public class NumberValidator extends ValidatorBase {
+    private final boolean nullable;
+
+    public NumberValidator() {
+        this(false);
+    }
+
+    public NumberValidator(@NamedArg("nullable") boolean nullable) {
+        this.nullable = nullable;
+    }
+
+    public NumberValidator(@NamedArg("message") String message, @NamedArg("nullable") boolean nullable) {
+        super(message);
+        this.nullable = nullable;
+    }
+
+    @Override
+    protected void eval() {
+        if (srcControl.get() instanceof TextInputControl) {
+            evalTextInputField();
+        }
+    }
+
+    private void evalTextInputField() {
+        TextInputControl textField = ((TextInputControl) srcControl.get());
+
+        if (StringUtils.isBlank(textField.getText()))
+            hasErrors.set(!nullable);
+        else
+            hasErrors.set(Lang.toIntOrNull(textField.getText()) == null);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/RipplerContainer.java

@@ -0,0 +1,241 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXRippler;
+import javafx.animation.Transition;
+import javafx.beans.DefaultProperty;
+import javafx.beans.InvalidationListener;
+import javafx.beans.NamedArg;
+import javafx.beans.binding.Bindings;
+import javafx.beans.property.BooleanProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleBooleanProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.css.*;
+import javafx.geometry.Insets;
+import javafx.scene.Node;
+import javafx.scene.layout.Background;
+import javafx.scene.layout.BackgroundFill;
+import javafx.scene.layout.CornerRadii;
+import javafx.scene.layout.StackPane;
+import javafx.scene.paint.Color;
+import javafx.scene.paint.Paint;
+import javafx.scene.shape.Rectangle;
+import org.jackhuang.hmcl.util.Lang;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@DefaultProperty("container")
+public class RipplerContainer extends StackPane {
+    private static final String DEFAULT_STYLE_CLASS = "rippler-container";
+
+    private final ObjectProperty<Node> container = new SimpleObjectProperty<>(this, "container", null);
+    private final StyleableObjectProperty<Paint> ripplerFill = new SimpleStyleableObjectProperty<>(StyleableProperties.RIPPLER_FILL,this, "ripplerFill", null);
+    private final BooleanProperty selected = new SimpleBooleanProperty(this, "selected", false);
+
+    private final StackPane buttonContainer = new StackPane();
+    private final JFXRippler buttonRippler = new JFXRippler(new StackPane()) {
+        @Override
+        protected Node getMask() {
+            StackPane mask = new StackPane();
+            mask.shapeProperty().bind(buttonContainer.shapeProperty());
+            mask.backgroundProperty().bind(Bindings.createObjectBinding(() -> new Background(new BackgroundFill(Color.WHITE, buttonContainer.getBackground() != null && buttonContainer.getBackground().getFills().size() > 0 ? buttonContainer.getBackground().getFills().get(0).getRadii() : defaultRadii, buttonContainer.getBackground() != null && buttonContainer.getBackground().getFills().size() > 0 ? buttonContainer.getBackground().getFills().get(0).getInsets() : Insets.EMPTY)), buttonContainer.backgroundProperty()));
+            mask.resize(buttonContainer.getWidth() - buttonContainer.snappedRightInset() - buttonContainer.snappedLeftInset(), buttonContainer.getHeight() - buttonContainer.snappedBottomInset() - buttonContainer.snappedTopInset());
+            return mask;
+        }
+
+        @Override
+        protected void initListeners() {
+            this.ripplerPane.setOnMousePressed(event -> {
+                if (releaseManualRippler != null)
+                    releaseManualRippler.run();
+                releaseManualRippler = null;
+                createRipple(event.getX(), event.getY());
+            });
+        }
+    };
+
+    private Transition clickedAnimation;
+    private final CornerRadii defaultRadii = new CornerRadii(3);
+    private Runnable releaseManualRippler;
+
+    public RipplerContainer(@NamedArg("container") Node container) {
+        setContainer(container);
+
+        getStyleClass().add(DEFAULT_STYLE_CLASS);
+        buttonContainer.getChildren().add(buttonRippler);
+        setOnMousePressed(event -> {
+            if (clickedAnimation != null) {
+                clickedAnimation.setRate(1);
+                clickedAnimation.play();
+            }
+        });
+        setOnMouseReleased(event -> {
+            if (clickedAnimation != null) {
+                clickedAnimation.setRate(-1);
+                clickedAnimation.play();
+            }
+        });
+        focusedProperty().addListener((a, b, newValue) -> {
+            if (newValue) {
+                if (!isPressed())
+                    buttonRippler.showOverlay();
+            } else {
+                buttonRippler.hideOverlay();
+            }
+        });
+        pressedProperty().addListener(o -> buttonRippler.hideOverlay());
+        setPickOnBounds(false);
+
+        buttonContainer.setPickOnBounds(false);
+        buttonContainer.shapeProperty().bind(shapeProperty());
+        buttonContainer.borderProperty().bind(borderProperty());
+        buttonContainer.backgroundProperty().bind(Bindings.createObjectBinding(() -> {
+            if (getBackground() == null || isJavaDefaultBackground(getBackground()) || isJavaDefaultClickedBackground(getBackground()))
+                setBackground(new Background(new BackgroundFill(Color.TRANSPARENT, defaultRadii, null)));
+
+            try {
+                return new Background(new BackgroundFill(getBackground() != null ? getBackground().getFills().get(0).getFill() : Color.TRANSPARENT,
+                        getBackground() != null ? getBackground().getFills().get(0).getRadii() : defaultRadii, Insets.EMPTY));
+            } catch (Exception e) {
+                return getBackground();
+            }
+        }, backgroundProperty()));
+
+        ripplerFillProperty().addListener((a, b, newValue) -> buttonRippler.setRipplerFill(newValue));
+        if (getBackground() == null || isJavaDefaultBackground(getBackground()))
+            setBackground(new Background(new BackgroundFill(Color.TRANSPARENT, defaultRadii, null)));
+
+        containerProperty().addListener(o -> updateChildren());
+        updateChildren();
+
+        InvalidationListener listener = o -> {
+            if (isSelected()) setBackground(new Background(new BackgroundFill(getRipplerFill(), defaultRadii, null)));
+            else setBackground(new Background(new BackgroundFill(Color.TRANSPARENT, defaultRadii, null)));
+        };
+
+        selectedProperty().addListener(listener);
+        selectedProperty().addListener((a, b, newValue) ->
+                pseudoClassStateChanged(PseudoClass.getPseudoClass("selected"), newValue));
+        ripplerFillProperty().addListener(listener);
+
+        setShape(Lang.apply(new Rectangle(), rectangle -> {
+            rectangle.widthProperty().bind(widthProperty());
+            rectangle.heightProperty().bind(heightProperty());
+        }));
+    }
+
+    protected void updateChildren() {
+        getChildren().addAll(buttonContainer, getContainer());
+
+        for (int i = 1; i < getChildren().size(); ++i)
+            getChildren().get(i).setPickOnBounds(false);
+    }
+
+    private boolean isJavaDefaultBackground(Background background) {
+        try {
+            String firstFill = background.getFills().get(0).getFill().toString();
+            return "0xffffffba".equals(firstFill) || "0xffffffbf".equals(firstFill) || "0xffffffbd".equals(firstFill);
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    private boolean isJavaDefaultClickedBackground(Background background) {
+        try {
+            String firstFill = background.getFills().get(0).getFill().toString();
+            return "0x039ed3ff".equals(firstFill);
+        } catch (Exception e) {
+            return false;
+        }
+    }
+
+    public Node getContainer() {
+        return container.get();
+    }
+
+    public ObjectProperty<Node> containerProperty() {
+        return container;
+    }
+
+    public void setContainer(Node container) {
+        this.container.set(container);
+    }
+
+    public Paint getRipplerFill() {
+        return ripplerFill.get();
+    }
+
+    public StyleableObjectProperty<Paint> ripplerFillProperty() {
+        return ripplerFill;
+    }
+
+    public void setRipplerFill(Paint ripplerFill) {
+        this.ripplerFill.set(ripplerFill);
+    }
+
+    public boolean isSelected() {
+        return selected.get();
+    }
+
+    public BooleanProperty selectedProperty() {
+        return selected;
+    }
+
+    public void setSelected(boolean selected) {
+        this.selected.set(selected);
+    }
+
+    @Override
+    public List<CssMetaData<? extends Styleable, ?>> getCssMetaData() {
+        return getClassCssMetaData();
+    }
+
+    public static List<CssMetaData<? extends Styleable, ?>> getClassCssMetaData() {
+        return StyleableProperties.STYLEABLES;
+    }
+
+    private static class StyleableProperties {
+
+        private static final CssMetaData<RipplerContainer, Paint> RIPPLER_FILL = new CssMetaData<RipplerContainer, Paint>("-jfx-rippler-fill", StyleConverter.getPaintConverter(), Color.rgb(0, 200, 255)) {
+            @Override
+            public boolean isSettable(RipplerContainer control) {
+                return control.ripplerFill == null || !control.ripplerFill.isBound();
+            }
+
+            @Override
+            public StyleableProperty<Paint> getStyleableProperty(RipplerContainer control) {
+                return control.ripplerFillProperty();
+            }
+        };
+
+        private static final List<CssMetaData<? extends Styleable, ?>> STYLEABLES;
+
+        private StyleableProperties() {
+        }
+
+        static {
+            List<CssMetaData<? extends Styleable, ?>> styleables = new ArrayList<>(Node.getClassCssMetaData());
+            Collections.addAll(styleables, RIPPLER_FILL);
+            STYLEABLES = Collections.unmodifiableList(styleables);
+        }
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/SpinnerPane.java

@@ -0,0 +1,61 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2017  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXSpinner;
+import javafx.beans.DefaultProperty;
+import javafx.beans.property.ObjectProperty;
+import javafx.beans.property.SimpleObjectProperty;
+import javafx.scene.Node;
+import javafx.scene.layout.StackPane;
+import org.jackhuang.hmcl.ui.animation.ContainerAnimations;
+import org.jackhuang.hmcl.ui.animation.TransitionHandler;
+
+@DefaultProperty("content")
+public class SpinnerPane extends StackPane {
+    private final TransitionHandler transitionHandler = new TransitionHandler(this);
+    private final JFXSpinner spinner = new JFXSpinner();
+    private final StackPane contentPane = new StackPane();
+    private final ObjectProperty<Node> content = new SimpleObjectProperty<>(this, "content");
+
+    public SpinnerPane() {
+        getChildren().setAll(contentPane);
+
+        content.addListener((a, b, newValue) -> contentPane.getChildren().setAll(newValue));
+    }
+
+    public void showSpinner() {
+        transitionHandler.setContent(spinner, ContainerAnimations.FADE.getAnimationProducer());
+    }
+
+    public void hideSpinner() {
+        transitionHandler.setContent(contentPane, ContainerAnimations.FADE.getAnimationProducer());
+    }
+
+    public Node getContent() {
+        return content.get();
+    }
+
+    public ObjectProperty<Node> contentProperty() {
+        return content;
+    }
+
+    public void setContent(Node content) {
+        this.content.set(content);
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/StackContainerPane.java

@@ -1,7 +1,7 @@
 /*
  * Hello Minecraft! Launcher.
  * Copyright (C) 2017  huangyuhui <[email protected]>
- * 
+ *
  * 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, either version 3 of the License, or
@@ -15,32 +15,35 @@
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see {http://www.gnu.org/licenses/}.
  */
-package org.jackhuang.hmcl.ui.construct
+package org.jackhuang.hmcl.ui.construct;
 
-import com.jfoenix.validation.base.ValidatorBase
-import javafx.scene.control.TextInputControl
+import javafx.scene.Node;
+import javafx.scene.layout.StackPane;
+import org.jackhuang.hmcl.util.Logging;
 
-class NumberValidator @JvmOverloads constructor(val nullable: Boolean = false) : ValidatorBase() {
+import java.util.Stack;
 
-    override fun eval() {
-        if (this.srcControl.get() is TextInputControl) {
-            this.evalTextInputField()
-        }
+public class StackContainerPane extends StackPane {
+    private final Stack<Node> stack = new Stack<>();
 
+    public void push(Node node) {
+        stack.push(node);
+        getChildren().setAll(node);
+
+        Logging.LOG.info(this + " " + stack);
     }
 
-    private fun evalTextInputField() {
-        val textField = this.srcControl.get() as TextInputControl
-
-        if (textField.text.isBlank())
-            hasErrors.set(false)
+    public void pop(Node node) {
+        boolean flag = stack.remove(node);
+        if (stack.isEmpty())
+            getChildren().setAll();
         else
-            try {
-                Integer.parseInt(textField.text)
-                this.hasErrors.set(false)
-            } catch (var3: Exception) {
-                this.hasErrors.set(true)
-            }
+            getChildren().setAll(stack.peek());
 
+        Logging.LOG.info(this + " " + stack + ", removed: " + flag + ", object: " + node);
     }
-}
+
+    public boolean isEmpty() {
+        return stack.isEmpty();
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/TaskExecutorDialogPane.java

@@ -0,0 +1,103 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXProgressBar;
+import javafx.beans.property.StringProperty;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.StackPane;
+import org.jackhuang.hmcl.task.TaskExecutor;
+import org.jackhuang.hmcl.ui.FXUtils;
+
+import java.util.Optional;
+import java.util.function.Consumer;
+
+public class TaskExecutorDialogPane extends StackPane {
+    private TaskExecutor executor;
+    private Consumer<Region> onCancel;
+
+    @FXML
+    private JFXProgressBar progressBar;
+    @FXML
+    private Label lblTitle;
+    @FXML
+    private Label lblSubtitle;
+    @FXML
+    private JFXButton btnCancel;
+    @FXML
+    private TaskListPane taskListPane;
+
+    public TaskExecutorDialogPane(Consumer<Region> cancel) {
+        FXUtils.loadFXML(this, "/assets/fxml/task-dialog.fxml");
+
+        setCancel(cancel);
+
+        btnCancel.setOnMouseClicked(e -> {
+            Optional.ofNullable(executor).ifPresent(TaskExecutor::cancel);
+            onCancel.accept(this);
+        });
+    }
+
+    public void setExecutor(TaskExecutor executor) {
+        this.executor = executor;
+
+        if (executor != null)
+            taskListPane.setExecutor(executor);
+    }
+
+    public StringProperty titleProperty() {
+        return lblTitle.textProperty();
+    }
+
+    public String getTitle() {
+        return lblTitle.getText();
+    }
+
+    public void setTitle(String currentState) {
+        lblTitle.setText(currentState);
+    }
+
+    public StringProperty subtitleProperty() {
+        return lblSubtitle.textProperty();
+    }
+
+    public String getSubtitle() {
+        return lblSubtitle.getText();
+    }
+
+    public void setSubtitle(String subtitle) {
+        lblSubtitle.setText(subtitle);
+    }
+
+    public void setProgress(double progress) {
+        if (progress == Double.MAX_VALUE)
+            progressBar.setVisible(false);
+        else
+            progressBar.setProgress(progress);
+    }
+
+    public void setCancel(Consumer<Region> onCancel) {
+        this.onCancel = onCancel;
+
+        JFXUtilities.runInFX(() -> btnCancel.setDisable(onCancel == null));
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/TaskExecutorDialogWizardDisplayer.java

@@ -0,0 +1,89 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.concurrency.JFXUtilities;
+import javafx.beans.property.StringProperty;
+
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.task.TaskExecutor;
+import org.jackhuang.hmcl.task.TaskListener;
+import org.jackhuang.hmcl.ui.Controllers;
+import org.jackhuang.hmcl.ui.wizard.AbstractWizardDisplayer;
+import org.jackhuang.hmcl.util.StringUtils;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Map;
+
+public interface TaskExecutorDialogWizardDisplayer extends AbstractWizardDisplayer {
+
+    @Override
+    default void handleTask(Map<String, Object> settings, Task task) {
+        TaskExecutorDialogPane pane = new TaskExecutorDialogPane(it -> {
+            it.fireEvent(new DialogCloseEvent());
+            Controllers.navigate(null);
+        });
+
+        pane.setTitle(i18n("message.doing"));
+        pane.setProgress(Double.MAX_VALUE);
+        if (settings.containsKey("title")) {
+            Object title = settings.get("title");
+            if (title instanceof StringProperty)
+                pane.titleProperty().bind((StringProperty) title);
+            else if (title instanceof String)
+                pane.setTitle((String) title);
+        }
+
+        if (settings.containsKey("subtitle")) {
+            Object subtitle = settings.get("subtitle");
+            if (subtitle instanceof StringProperty)
+                pane.subtitleProperty().bind((StringProperty) subtitle);
+            else if (subtitle instanceof String)
+                pane.setSubtitle((String) subtitle);
+        }
+
+        JFXUtilities.runInFX(() -> {
+            TaskExecutor executor = task.executor(new TaskListener() {
+                @Override
+                public void onStop(boolean success, TaskExecutor executor) {
+                    JFXUtilities.runInFX(() -> {
+                        pane.fireEvent(new DialogCloseEvent());
+                        if (success) {
+                            if (settings.containsKey("success_message") && settings.get("success_message") instanceof String)
+                                Controllers.dialog((String) settings.get("success_message"), null, MessageBox.FINE_MESSAGE, () -> Controllers.navigate(null));
+                            else if (!settings.containsKey("forbid_success_message"))
+                                Controllers.dialog(i18n("message.success"), null, MessageBox.FINE_MESSAGE, () -> Controllers.navigate(null));
+                        } else {
+                            if (executor.getLastException() == null)
+                                return;
+                            String appendix = StringUtils.getStackTrace(executor.getLastException());
+                            if (settings.containsKey("failure_message") && settings.get("failure_message") instanceof String)
+                                Controllers.dialog(appendix, (String) settings.get("failure_message"), MessageBox.ERROR_MESSAGE, () -> Controllers.navigate(null));
+                            else if (!settings.containsKey("forbid_failure_message"))
+                                Controllers.dialog(appendix, i18n("wizard.failed"), MessageBox.ERROR_MESSAGE, () -> Controllers.navigate(null));
+                        }
+
+                    });
+                }
+            });
+            pane.setExecutor(executor);
+            Controllers.dialog(pane);
+            executor.start();
+        });
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/TaskListPane.java

@@ -0,0 +1,147 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ *
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.controls.JFXProgressBar;
+import javafx.application.Platform;
+import javafx.scene.control.Label;
+import javafx.scene.layout.BorderPane;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+
+import org.jackhuang.hmcl.download.forge.ForgeInstallTask;
+import org.jackhuang.hmcl.download.game.GameAssetDownloadTask;
+import org.jackhuang.hmcl.download.game.GameAssetRefreshTask;
+import org.jackhuang.hmcl.download.liteloader.LiteLoaderInstallTask;
+import org.jackhuang.hmcl.download.optifine.OptiFineInstallTask;
+import org.jackhuang.hmcl.game.HMCLModpackExportTask;
+import org.jackhuang.hmcl.game.HMCLModpackInstallTask;
+import org.jackhuang.hmcl.mod.*;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.task.TaskExecutor;
+import org.jackhuang.hmcl.task.TaskListener;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public final class TaskListPane extends StackPane {
+    private final AdvancedListBox listBox = new AdvancedListBox();
+    private final Map<Task, ProgressListNode> nodes = new HashMap<>();
+
+    public TaskListPane() {
+        listBox.setSpacing(0);
+
+        getChildren().setAll(listBox);
+    }
+
+    public void setExecutor(TaskExecutor executor) {
+        executor.addTaskListener(new TaskListener() {
+            @Override
+            public void onStart() {
+                Platform.runLater(listBox::clear);
+            }
+
+            @Override
+            public void onRunning(Task task) {
+                if (!task.getSignificance().shouldShow())
+                    return;
+
+                if (task instanceof GameAssetRefreshTask) {
+                    task.setName(i18n("assets.download"));
+                } else if (task instanceof GameAssetDownloadTask) {
+                    task.setName(i18n("assets.download_all"));
+                } else if (task instanceof ForgeInstallTask) {
+                    task.setName(i18n("install.installer.install", i18n("install.installer.forge")));
+                } else if (task instanceof LiteLoaderInstallTask) {
+                    task.setName(i18n("install.installer.install", i18n("install.installer.liteloader")));
+                } else if (task instanceof OptiFineInstallTask) {
+                    task.setName(i18n("install.installer.install", i18n("install.installer.optifine")));
+                } else if (task instanceof CurseCompletionTask) {
+                    task.setName(i18n("modpack.type.curse.completion"));
+                } else if (task instanceof ModpackInstallTask) {
+                    task.setName(i18n("modpack.installing"));
+                } else if (task instanceof CurseInstallTask) {
+                    task.setName(i18n("modpack.install", i18n("modpack.type.curse")));
+                } else if (task instanceof MultiMCModpackInstallTask) {
+                    task.setName(i18n("modpack.install", i18n("modpack.type.multimc")));
+                } else if (task instanceof HMCLModpackInstallTask) {
+                    task.setName(i18n("modpack.install", i18n("modpack.type.hmcl")));
+                } else if (task instanceof HMCLModpackExportTask) {
+                    task.setName(i18n("modpack.export"));
+                } else if (task instanceof MinecraftInstanceTask) {
+                    task.setName(i18n("modpack.scan"));
+                }
+
+                ProgressListNode node = new ProgressListNode(task);
+                nodes.put(task, node);
+                Platform.runLater(() -> listBox.add(node));
+
+            }
+
+            @Override
+            public void onFinished(Task task) {
+                ProgressListNode node = nodes.remove(task);
+                if (node == null)
+                    return;
+                node.unbind();
+                Platform.runLater(() -> listBox.remove(node));
+            }
+
+            @Override
+            public void onFailed(Task task, Throwable throwable) {
+                ProgressListNode node = nodes.remove(task);
+                if (node == null)
+                    return;
+                Platform.runLater(() -> node.setThrowable(throwable));
+            }
+        });
+    }
+
+    private static class ProgressListNode extends VBox {
+        private final JFXProgressBar bar = new JFXProgressBar();
+        private final Label title = new Label();
+        private final Label state = new Label();
+
+        public ProgressListNode(Task task) {
+            bar.progressProperty().bind(task.progressProperty());
+            title.setText(task.getName());
+            state.textProperty().bind(task.messageProperty());
+
+            BorderPane borderPane = new BorderPane();
+            borderPane.setLeft(title);
+            borderPane.setRight(state);
+            getChildren().addAll(borderPane, bar);
+
+            bar.minWidthProperty().bind(widthProperty());
+            bar.prefWidthProperty().bind(widthProperty());
+            bar.maxWidthProperty().bind(widthProperty());
+        }
+
+        public void unbind() {
+            bar.progressProperty().unbind();
+            state.textProperty().unbind();
+        }
+
+        public void setThrowable(Throwable throwable) {
+            unbind();
+            state.setText(throwable.getLocalizedMessage());
+            bar.setProgress(0);
+        }
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/URLValidator.java

@@ -0,0 +1,37 @@
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.validation.base.ValidatorBase;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.scene.control.TextInputControl;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+
+public class URLValidator extends ValidatorBase {
+
+    private final ObservableList<String> protocols = FXCollections.observableArrayList();
+
+    public URLValidator() {
+        super();
+    }
+
+    public ObservableList<String> getProtocols() {
+        return protocols;
+    }
+
+    @Override
+    protected void eval() {
+        if (srcControl.get() instanceof TextInputControl) {
+            try {
+                URL url = new URL(((TextInputControl) srcControl.get()).getText());
+                if (protocols.isEmpty())
+                    hasErrors.set(false);
+                else
+                    hasErrors.set(!protocols.contains(url.getProtocol()));
+            } catch (MalformedURLException e) {
+                hasErrors.set(true);
+            }
+        }
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/construct/Validator.java

@@ -0,0 +1,48 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.construct;
+
+import com.jfoenix.validation.base.ValidatorBase;
+import javafx.scene.control.TextInputControl;
+
+import java.util.function.Predicate;
+
+public final class Validator extends ValidatorBase {
+    private final Predicate<String> validator;
+
+    /**
+     * @param validator return true if the input string is valid.
+     */
+    public Validator(Predicate<String> validator) {
+        this.validator = validator;
+    }
+
+    public Validator(String message, Predicate<String> validator) {
+        this(validator);
+
+        setMessage(message);
+    }
+
+    @Override
+    protected void eval() {
+        if (this.srcControl.get() instanceof TextInputControl) {
+            String text = ((TextInputControl) srcControl.get()).getText();
+            hasErrors.set(!validator.test(text));
+        }
+    }
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/download/AdditionalInstallersPage.java

@@ -0,0 +1,138 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.download;
+
+import com.jfoenix.controls.JFXButton;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+
+import org.jackhuang.hmcl.download.DownloadProvider;
+import org.jackhuang.hmcl.download.RemoteVersion;
+import org.jackhuang.hmcl.game.GameRepository;
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.wizard.WizardController;
+import org.jackhuang.hmcl.ui.wizard.WizardPage;
+import org.jackhuang.hmcl.util.Lang;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Map;
+import java.util.Optional;
+
+class AdditionalInstallersPage extends StackPane implements WizardPage {
+    private final InstallerWizardProvider provider;
+    private final WizardController controller;
+
+    @FXML
+    private VBox list;
+    @FXML
+    private JFXButton btnForge;
+    @FXML
+    private JFXButton btnLiteLoader;
+    @FXML
+    private JFXButton btnOptiFine;
+    @FXML
+    private Label lblGameVersion;
+    @FXML
+    private Label lblVersionName;
+    @FXML
+    private Label lblForge;
+    @FXML
+    private Label lblLiteLoader;
+    @FXML
+    private Label lblOptiFine;
+    @FXML
+    private JFXButton btnInstall;
+
+    public AdditionalInstallersPage(InstallerWizardProvider provider, WizardController controller, GameRepository repository, DownloadProvider downloadProvider) {
+        this.provider = provider;
+        this.controller = controller;
+
+        FXUtils.loadFXML(this, "/assets/fxml/download/additional-installers.fxml");
+
+        lblGameVersion.setText(provider.getGameVersion());
+        lblVersionName.setText(provider.getVersion().getId());
+
+        btnForge.setOnMouseClicked(e -> {
+            controller.getSettings().put(INSTALLER_TYPE, 0);
+            controller.onNext(new VersionsPage(controller, i18n("install.installer.choose", i18n("install.installer.forge")), provider.getGameVersion(), downloadProvider, "forge", () -> {
+                controller.onPrev(false);
+            }));
+        });
+
+        btnLiteLoader.setOnMouseClicked(e -> {
+            controller.getSettings().put(INSTALLER_TYPE, 1);
+            controller.onNext(new VersionsPage(controller, i18n("install.installer.choose", i18n("install.installer.liteloader")), provider.getGameVersion(), downloadProvider, "liteloader", () -> {
+                controller.onPrev(false);
+            }));
+        });
+
+        btnOptiFine.setOnMouseClicked(e -> {
+            controller.getSettings().put(INSTALLER_TYPE, 2);
+            controller.onNext(new VersionsPage(controller, i18n("install.installer.choose", i18n("install.installer.optifine")), provider.getGameVersion(), downloadProvider, "optifine", () -> {
+                controller.onPrev(false);
+            }));
+        });
+
+        btnInstall.setOnMouseClicked(e -> onInstall());
+    }
+
+    private void onInstall() {
+        controller.onFinish();
+    }
+
+    @Override
+    public String getTitle() {
+        return i18n("settings.tabs.installers");
+    }
+
+    private String getVersion(String id) {
+        return Optional.ofNullable(controller.getSettings().get(id)).map(it -> (RemoteVersion<?>) it).map(RemoteVersion::getSelfVersion).orElse(null);
+    }
+
+    @Override
+    public void onNavigate(Map<String, Object> settings) {
+        lblGameVersion.setText(i18n("install.new_game.current_game_version") + ": " + provider.getGameVersion());
+        btnForge.setDisable(provider.getForge() != null);
+        if (provider.getForge() != null || controller.getSettings().containsKey("forge"))
+            lblForge.setText(i18n("install.installer.version", i18n("install.installer.forge")) + ": " + Lang.nonNull(provider.getForge(), getVersion("forge")));
+        else
+            lblForge.setText(i18n("install.installer.not_installed", i18n("install.installer.forge")));
+
+        btnLiteLoader.setDisable(provider.getLiteLoader() != null);
+        if (provider.getLiteLoader() != null || controller.getSettings().containsKey("liteloader"))
+            lblLiteLoader.setText(i18n("install.installer.version", i18n("install.installer.liteloader")) + ": " + Lang.nonNull(provider.getLiteLoader(), getVersion("liteloader")));
+        else
+            lblLiteLoader.setText(i18n("install.installer.not_installed", i18n("install.installer.liteloader")));
+
+        btnOptiFine.setDisable(provider.getOptiFine() != null);
+        if (provider.getOptiFine() != null || controller.getSettings().containsKey("optifine"))
+            lblOptiFine.setText(i18n("install.installer.version", i18n("install.installer.optifine")) + ": " + Lang.nonNull(provider.getOptiFine(), getVersion("optifine")));
+        else
+            lblOptiFine.setText(i18n("install.installer.not_installed", i18n("install.installer.optifine")));
+
+    }
+
+    @Override
+    public void cleanup(Map<String, Object> settings) {
+        settings.remove(INSTALLER_TYPE);
+    }
+
+    public static final String INSTALLER_TYPE = "INSTALLER_TYPE";
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/download/DownloadWizardProvider.java

@@ -0,0 +1,117 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.download;
+
+import javafx.scene.Node;
+
+import org.jackhuang.hmcl.download.DownloadProvider;
+import org.jackhuang.hmcl.download.GameBuilder;
+import org.jackhuang.hmcl.download.RemoteVersion;
+import org.jackhuang.hmcl.game.ModpackHelper;
+import org.jackhuang.hmcl.mod.Modpack;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.setting.Settings;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.wizard.WizardController;
+import org.jackhuang.hmcl.ui.wizard.WizardProvider;
+import org.jackhuang.hmcl.util.Lang;
+import java.io.File;
+import java.util.Map;
+
+import static org.jackhuang.hmcl.util.Lang.tryCast;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+public final class DownloadWizardProvider implements WizardProvider {
+    private Profile profile;
+
+    @Override
+    public void start(Map<String, Object> settings) {
+        profile = Settings.INSTANCE.getSelectedProfile();
+        settings.put(PROFILE, profile);
+    }
+
+    private Task finishVersionDownloadingAsync(Map<String, Object> settings) {
+        GameBuilder builder = profile.getDependency().gameBuilder();
+
+        builder.name((String) settings.get("name"));
+        builder.gameVersion(((RemoteVersion<?>) settings.get("game")).getGameVersion());
+
+        if (settings.containsKey("forge"))
+            builder.version((RemoteVersion<?>) settings.get("forge"));
+
+        if (settings.containsKey("liteloader"))
+            builder.version((RemoteVersion<?>) settings.get("liteloader"));
+
+        if (settings.containsKey("optifine"))
+            builder.version((RemoteVersion<?>) settings.get("optifine"));
+
+        return builder.buildAsync().finalized((a, b) -> profile.getRepository().refreshVersions());
+    }
+
+    private Task finishModpackInstallingAsync(Map<String, Object> settings) {
+        if (!settings.containsKey(ModpackPage.MODPACK_FILE))
+            return null;
+
+        File selected = tryCast(settings.get(ModpackPage.MODPACK_FILE), File.class).orElse(null);
+        Modpack modpack = tryCast(settings.get(ModpackPage.MODPACK_MANIFEST), Modpack.class).orElse(null);
+        String name = tryCast(settings.get(ModpackPage.MODPACK_NAME), String.class).orElse(null);
+        if (selected == null || modpack == null || name == null) return null;
+
+        return ModpackHelper.getInstallTask(profile, selected, name, modpack);
+    }
+
+    @Override
+    public Object finish(Map<String, Object> settings) {
+        settings.put("success_message", i18n("install.success"));
+        settings.put("failure_message", i18n("install.failed"));
+
+        switch (Lang.parseInt(settings.get(InstallTypePage.INSTALL_TYPE), -1)) {
+            case 0: return finishVersionDownloadingAsync(settings);
+            case 1: return finishModpackInstallingAsync(settings);
+            default: return null;
+        }
+    }
+
+    @Override
+    public Node createPage(WizardController controller, int step, Map<String, Object> settings) {
+        DownloadProvider provider = profile.getDependency().getDownloadProvider();
+        switch (step) {
+            case 0:
+                return new InstallTypePage(controller);
+            case 1:
+                int subStep = Lang.parseInt(settings.get(InstallTypePage.INSTALL_TYPE), -1);
+                switch (subStep) {
+                    case 0:
+                        return new VersionsPage(controller, i18n("install.installer.choose", i18n("install.installer.game")), "", provider, "game", () -> controller.onNext(new InstallersPage(controller, profile.getRepository(), provider)));
+                    case 1:
+                        return new ModpackPage(controller);
+                    default:
+                        throw new IllegalStateException("Error step " + step + ", subStep " + subStep + ", settings: " + settings + ", pages: " + controller.getPages());
+                }
+            default:
+                throw new IllegalStateException("error step " + step + ", settings: " + settings + ", pages: " + controller.getPages());
+        }
+    }
+
+    @Override
+    public boolean cancel() {
+        return true;
+    }
+
+    public static final String PROFILE = "PROFILE";
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/download/InstallTypePage.java

@@ -0,0 +1,57 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.download;
+
+import com.jfoenix.controls.JFXListView;
+import javafx.fxml.FXML;
+import javafx.scene.layout.StackPane;
+
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.wizard.WizardController;
+import org.jackhuang.hmcl.ui.wizard.WizardPage;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Map;
+
+public final class InstallTypePage extends StackPane implements WizardPage {
+
+    @FXML private JFXListView<Object> list;
+
+    public InstallTypePage(WizardController controller) {
+
+        FXUtils.loadFXML(this, "/assets/fxml/download/dltype.fxml");
+        list.setOnMouseClicked(e -> {
+            if (list.getSelectionModel().getSelectedIndex() < 0)
+                return;
+            controller.getSettings().put(INSTALL_TYPE, list.getSelectionModel().getSelectedIndex());
+            controller.onNext();
+        });
+    }
+
+    @Override
+    public void cleanup(Map<String, Object> settings) {
+        settings.remove(INSTALL_TYPE);
+    }
+
+    @Override
+    public String getTitle() {
+        return i18n("install.select");
+    }
+
+    public static final String INSTALL_TYPE = "INSTALL_TYPE";
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/download/InstallerWizardProvider.java

@@ -0,0 +1,116 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.download;
+
+import javafx.scene.Node;
+
+import org.jackhuang.hmcl.download.BMCLAPIDownloadProvider;
+import org.jackhuang.hmcl.download.RemoteVersion;
+import org.jackhuang.hmcl.game.Version;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.task.Task;
+import org.jackhuang.hmcl.ui.wizard.WizardController;
+import org.jackhuang.hmcl.ui.wizard.WizardProvider;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Map;
+
+public final class InstallerWizardProvider implements WizardProvider {
+    private final Profile profile;
+    private final String gameVersion;
+    private final Version version;
+    private final String forge;
+    private final String liteLoader;
+    private final String optiFine;
+
+    public InstallerWizardProvider(Profile profile, String gameVersion, Version version) {
+        this(profile, gameVersion, version, null, null, null);
+    }
+
+    public InstallerWizardProvider(Profile profile, String gameVersion, Version version, String forge, String liteLoader, String optiFine) {
+        this.profile = profile;
+        this.gameVersion = gameVersion;
+        this.version = version;
+        this.forge = forge;
+        this.liteLoader = liteLoader;
+        this.optiFine = optiFine;
+    }
+
+    public Profile getProfile() {
+        return profile;
+    }
+
+    public String getGameVersion() {
+        return gameVersion;
+    }
+
+    public Version getVersion() {
+        return version;
+    }
+
+    public String getForge() {
+        return forge;
+    }
+
+    public String getLiteLoader() {
+        return liteLoader;
+    }
+
+    public String getOptiFine() {
+        return optiFine;
+    }
+
+    @Override
+    public void start(Map<String, Object> settings) {
+    }
+
+    @Override
+    public Object finish(Map<String, Object> settings) {
+        settings.put("success_message", i18n("install.success"));
+        settings.put("failure_message", i18n("install.failed"));
+
+        Task ret = Task.empty();
+
+        if (settings.containsKey("forge"))
+            ret = ret.then(profile.getDependency().installLibraryAsync(version, (RemoteVersion<?>) settings.get("forge")));
+
+        if (settings.containsKey("liteloader"))
+            ret = ret.then(profile.getDependency().installLibraryAsync(version, (RemoteVersion<?>) settings.get("liteloader")));
+
+        if (settings.containsKey("optifine"))
+            ret = ret.then(profile.getDependency().installLibraryAsync(version, (RemoteVersion<?>) settings.get("optifine")));
+
+        return ret.then(profile.getRepository().refreshVersionsAsync());
+    }
+
+    @Override
+    public Node createPage(WizardController controller, int step, Map<String, Object> settings) {
+        switch (step) {
+            case 0:
+                return new AdditionalInstallersPage(this, controller, profile.getRepository(), BMCLAPIDownloadProvider.INSTANCE);
+            default:
+                throw new IllegalStateException();
+        }
+    }
+
+    @Override
+    public boolean cancel() {
+        return true;
+    }
+
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/download/InstallersPage.java

@@ -0,0 +1,140 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.download;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXTextField;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+
+import org.jackhuang.hmcl.download.DownloadProvider;
+import org.jackhuang.hmcl.download.RemoteVersion;
+import org.jackhuang.hmcl.game.GameRepository;
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.construct.Validator;
+import org.jackhuang.hmcl.ui.wizard.WizardController;
+import org.jackhuang.hmcl.ui.wizard.WizardPage;
+import org.jackhuang.hmcl.util.StringUtils;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.util.Map;
+
+public class InstallersPage extends StackPane implements WizardPage {
+    private final WizardController controller;
+
+    @FXML
+    private VBox list;
+
+    @FXML
+    private JFXButton btnForge;
+
+    @FXML
+    private JFXButton btnLiteLoader;
+
+    @FXML
+    private JFXButton btnOptiFine;
+
+    @FXML
+    private Label lblGameVersion;
+
+    @FXML
+    private Label lblForge;
+
+    @FXML
+    private Label lblLiteLoader;
+
+    @FXML
+    private Label lblOptiFine;
+
+    @FXML
+    private JFXTextField txtName;
+
+    @FXML
+    private JFXButton btnInstall;
+
+    public InstallersPage(WizardController controller, GameRepository repository, DownloadProvider downloadProvider) {
+        this.controller = controller;
+
+        FXUtils.loadFXML(this, "/assets/fxml/download/installers.fxml");
+
+        String gameVersion = ((RemoteVersion<?>) controller.getSettings().get("game")).getGameVersion();
+        Validator hasVersion = new Validator(s -> !repository.hasVersion(s) && StringUtils.isNotBlank(s));
+        hasVersion.setMessage(i18n("install.new_game.already_exists"));
+        txtName.getValidators().add(hasVersion);
+        txtName.textProperty().addListener(e -> btnInstall.setDisable(!txtName.validate()));
+        txtName.setText(gameVersion);
+
+        btnForge.setOnMouseClicked(e -> {
+            controller.getSettings().put(INSTALLER_TYPE, 0);
+            controller.onNext(new VersionsPage(controller, i18n("install.installer.choose", i18n("install.installer.forge")), gameVersion, downloadProvider, "forge", () -> controller.onPrev(false)));
+        });
+
+        btnLiteLoader.setOnMouseClicked(e -> {
+            controller.getSettings().put(INSTALLER_TYPE, 1);
+            controller.onNext(new VersionsPage(controller, i18n("install.installer.choose", i18n("install.installer.liteloader")), gameVersion, downloadProvider, "liteloader", () -> controller.onPrev(false)));
+        });
+
+        btnOptiFine.setOnMouseClicked(e -> {
+            controller.getSettings().put(INSTALLER_TYPE, 2);
+            controller.onNext(new VersionsPage(controller, i18n("install.installer.choose", i18n("install.installer.optifine")), gameVersion, downloadProvider, "optifine", () -> controller.onPrev(false)));
+        });
+    }
+
+    @Override
+    public String getTitle() {
+        return i18n("install.new_game");
+    }
+
+    private String getVersion(String id) {
+        return ((RemoteVersion<?>) controller.getSettings().get(id)).getSelfVersion();
+    }
+
+    @Override
+    public void onNavigate(Map<String, Object> settings) {
+        lblGameVersion.setText(i18n("install.new_game.current_game_version") + ": " + getVersion("game"));
+        if (controller.getSettings().containsKey("forge"))
+            lblForge.setText(i18n("install.installer.version", i18n("install.installer.forge")) + ": " + getVersion("forge"));
+        else
+            lblForge.setText(i18n("install.installer.not_installed", i18n("install.installer.forge")));
+
+        if (controller.getSettings().containsKey("liteloader"))
+            lblLiteLoader.setText(i18n("install.installer.version", i18n("install.installer.liteloader")) + ": " + getVersion("liteloader"));
+        else
+            lblLiteLoader.setText(i18n("install.installer.not_installed", i18n("install.installer.liteloader")));
+
+        if (controller.getSettings().containsKey("optifine"))
+            lblOptiFine.setText(i18n("install.installer.version", i18n("install.installer.optifine")) + ": " + getVersion("optifine"));
+        else
+            lblOptiFine.setText(i18n("install.installer.not_installed", i18n("install.installer.optifine")));
+    }
+
+    @Override
+    public void cleanup(Map<String, Object> settings) {
+        settings.remove(INSTALLER_TYPE);
+    }
+
+    @FXML
+    private void onInstall() {
+        controller.getSettings().put("name", txtName.getText());
+        controller.onFinish();
+    }
+
+    public static final String INSTALLER_TYPE = "INSTALLER_TYPE";
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/download/ModpackPage.java

@@ -0,0 +1,135 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.download;
+
+import com.jfoenix.controls.JFXButton;
+import com.jfoenix.controls.JFXTextField;
+import javafx.application.Platform;
+import javafx.fxml.FXML;
+import javafx.scene.control.Label;
+import javafx.scene.layout.Region;
+import javafx.scene.layout.StackPane;
+import javafx.stage.FileChooser;
+
+import org.jackhuang.hmcl.game.ModpackHelper;
+import org.jackhuang.hmcl.mod.Modpack;
+import org.jackhuang.hmcl.mod.UnsupportedModpackException;
+import org.jackhuang.hmcl.setting.Profile;
+import org.jackhuang.hmcl.ui.Controllers;
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.WebStage;
+import org.jackhuang.hmcl.ui.construct.Validator;
+import org.jackhuang.hmcl.ui.wizard.WizardController;
+import org.jackhuang.hmcl.ui.wizard.WizardPage;
+import org.jackhuang.hmcl.util.StringUtils;
+import static org.jackhuang.hmcl.util.i18n.I18n.i18n;
+
+import java.io.File;
+import java.util.Map;
+
+public final class ModpackPage extends StackPane implements WizardPage {
+    private final WizardController controller;
+
+    private Modpack manifest = null;
+
+    @FXML
+    private Region borderPane;
+
+    @FXML
+    private Label lblName;
+
+    @FXML
+    private Label lblVersion;
+
+    @FXML
+    private Label lblAuthor;
+
+    @FXML
+    private Label lblModpackLocation;
+
+    @FXML
+    private JFXTextField txtModpackName;
+
+    @FXML
+    private JFXButton btnInstall;
+
+    public ModpackPage(WizardController controller) {
+        this.controller = controller;
+
+        FXUtils.loadFXML(this, "/assets/fxml/download/modpack.fxml");
+
+        Profile profile = (Profile) controller.getSettings().get("PROFILE");
+
+        FileChooser chooser = new FileChooser();
+        chooser.setTitle(i18n("modpack.choose"));
+        chooser.getExtensionFilters().add(new FileChooser.ExtensionFilter(i18n("modpack"), "*.zip"));
+        File selectedFile = chooser.showOpenDialog(Controllers.getStage());
+        if (selectedFile == null) Platform.runLater(() -> Controllers.navigate(null));
+        else {
+            controller.getSettings().put(MODPACK_FILE, selectedFile);
+            lblModpackLocation.setText(selectedFile.getAbsolutePath());
+            txtModpackName.getValidators().addAll(
+                    new Validator(i18n("install.new_game.already_exists"), str -> !profile.getRepository().hasVersion(str) && StringUtils.isNotBlank(str)),
+                    new Validator(i18n("version.forbidden_name"), str -> !profile.getRepository().forbidsVersion(str))
+            );
+            txtModpackName.textProperty().addListener(e -> btnInstall.setDisable(!txtModpackName.validate()));
+
+            try {
+                manifest = ModpackHelper.readModpackManifest(selectedFile);
+                controller.getSettings().put(MODPACK_MANIFEST, manifest);
+                lblName.setText(manifest.getName());
+                lblVersion.setText(manifest.getVersion());
+                lblAuthor.setText(manifest.getAuthor());
+                txtModpackName.setText(manifest.getName() + (StringUtils.isBlank(manifest.getVersion()) ? "" : "-" + manifest.getVersion()));
+            } catch (UnsupportedModpackException e) {
+                txtModpackName.setText(i18n("modpack.task.install.error"));
+            }
+        }
+    }
+
+    @Override
+    public void cleanup(Map<String, Object> settings) {
+        settings.remove(MODPACK_FILE);
+    }
+
+    @FXML
+    private void onInstall() {
+        if (!txtModpackName.validate()) return;
+        controller.getSettings().put(MODPACK_NAME, txtModpackName.getText());
+        controller.onFinish();
+    }
+
+    @FXML
+    private void onDescribe() {
+        if (manifest != null) {
+            WebStage stage = new WebStage();
+            stage.getWebView().getEngine().loadContent(manifest.getDescription());
+            stage.setTitle(i18n("modpack.wizard.step.3"));
+            stage.showAndWait();
+        }
+    }
+
+    @Override
+    public String getTitle() {
+        return i18n("modpack.task.install");
+    }
+
+    public static final String MODPACK_FILE = "MODPACK_FILE";
+    public static final String MODPACK_NAME = "MODPACK_NAME";
+    public static final String MODPACK_MANIFEST = "MODPACK_MANIFEST";
+}

HMCL/src/main/java/org/jackhuang/hmcl/ui/download/VersionsPage.java

@@ -0,0 +1,156 @@
+/*
+ * Hello Minecraft! Launcher.
+ * Copyright (C) 2018  huangyuhui <[email protected]>
+ * 
+ * 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, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * 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 {http://www.gnu.org/licenses/}.
+ */
+package org.jackhuang.hmcl.ui.download;
+
+import com.jfoenix.controls.JFXCheckBox;
+import com.jfoenix.controls.JFXListView;
+import com.jfoenix.controls.JFXSpinner;
+import javafx.application.Platform;
+import javafx.beans.InvalidationListener;
+import javafx.fxml.FXML;
+import javafx.scene.layout.HBox;
+import javafx.scene.layout.StackPane;
+import javafx.scene.layout.VBox;
+import org.jackhuang.hmcl.download.DownloadProvider;
+import org.jackhuang.hmcl.download.VersionList;
+import org.jackhuang.hmcl.download.game.GameRemoteVersionTag;
+import org.jackhuang.hmcl.download.game.GameVersionList;
+import org.jackhuang.hmcl.task.TaskExecutor;
+import org.jackhuang.hmcl.ui.FXUtils;
+import org.jackhuang.hmcl.ui.animation.ContainerAnimations;
+import org.jackhuang.hmcl.ui.animation.TransitionHandler;
+import org.jackhuang.hmcl.ui.wizard.Refreshable;
+import org.jackhuang.hmcl.ui.wizard.WizardController;
+import org.jackhuang.hmcl.ui.wizard.WizardPage;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.stream.Collectors;
+
+public final class VersionsPage extends StackPane implements WizardPage, Refreshable {
+    private final String gameVersion;
+    private final DownloadProvider downloadProvider;
+    private final String libraryId;
+    private final String title;
+
+    @FXML
+    private JFXListView<VersionsPageItem> list;
+    @FXML
+    private JFXSpinner spinner;
+    @FXML
+    private StackPane failedPane;
+    @FXML
+    private JFXCheckBox chkRelease;
+    @FXML
+    private JFXCheckBox chkSnapshot;
+    @FXML
+    private JFXCheckBox chkOld;
+    @FXML
+    private HBox checkPane;
+    @FXML
+    private VBox centrePane;
+
+    private final TransitionHandler transitionHandler = new TransitionHandler(this);
+    private final VersionList<?> versionList;
+    private TaskExecutor executor;
+
+    public VersionsPage(WizardController controller, String title, String gameVersion, DownloadProvider downloadProvider, String libraryId, Runnable callback) {
+        this.title = title;
+        this.gameVersion = gameVersion;
+        this.downloadProvider = downloadProvider;
+        this.libraryId = libraryId;
+        this.versionList = downloadProvider.getVersionListById(libraryId);
+
+        FXUtils.loadFXML(this, "/assets/fxml/download/versions.fxml");
+
+        if (versionList instanceof GameVersionList) {
+            centrePane.getChildren().setAll(checkPane, list);
+        } else
+            centrePane.getChildren().setAll(list);
+
+        InvalidationListener listener = o -> list.getItems().setAll(loadVersions());
+        chkRelease.selectedProperty().addListener(listener);
+        chkSnapshot.selectedProperty().addListener(listener);
+        chkOld.selectedProperty().addListener(listener);
+
+        list.setOnMouseClicked(e -> {
+            if (list.getSelectionModel().getSelectedIndex() < 0)
+                return;
+            controller.getSettings().put(libraryId, list.getSelectionModel().getSelectedItem().getRemoteVersion());
+            callback.run();
+        });
+        refresh();
+    }
+
+    private List<VersionsPageItem> loadVersions() {
+        boolean isGameVersionList = versionList instanceof GameVersionList;
+        return versionList.getVersions(gameVersion).stream()
+                .filter(it -> {
+                    if (isGameVersionList)
+                        switch (((GameRemoteVersionTag) it.getTag()).getType()) {
+                            case RELEASE:
+                                return chkRelease.isSelected();
+                            case SNAPSHOT:
+                                return chkSnapshot.isSelected();
+                            default:
+                                return chkOld.isSelected();
+                        }
+                    else return true;
+                })
+                .filter(Objects::nonNull)
+                .sorted()
+                .map(VersionsPageItem::new).collect(Collectors.toList());
+    }
+
+    @Override
+    public void refresh() {
+        getChildren().setAll(spinner);
+        executor = versionList.refreshAsync(downloadProvider).finalized((variables, isDependentsSucceeded) -> {
+            if (isDependentsSucceeded) {
+                List<VersionsPageItem> items = loadVersions();
+
+                Platform.runLater(() -> {
+                    list.getItems().setAll(items);
+                    transitionHandler.setContent(centrePane, ContainerAnimations.FADE.getAnimationProducer());
+                });
+            } else {
+                Platform.runLater(() -> {
+                    transitionHandler.setContent(failedPane, ContainerAnimations.FADE.getAnimationProducer());
+                });
+            }
+        }).executor().start();
+    }
+
+    @Override
+    public String getTitle() {
+        return title;
+    }
+
+    @Override
+    public void cleanup(Map<String, Object> settings) {
+        settings.remove(libraryId);
+        if (executor != null)
+            executor.cancel();
+    }
+
+    @FXML
+    private void onRefresh() {
+        refresh();
+    }
+}