aeinstaller/gui/MainWin.java

package net.oni2.aeinstaller.gui;

import java.awt.Desktop;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.ResourceBundle;
import java.util.TreeMap;
import java.util.TreeSet;
import java.util.Vector;

import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JComponent;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.JSplitPane;
import javax.swing.JTable;
import javax.swing.ListSelectionModel;
import javax.swing.RowSorter;
import javax.swing.SortOrder;
import javax.swing.SwingUtilities;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;
import javax.swing.filechooser.FileFilter;
import javax.swing.table.TableRowSorter;

import net.oni2.aeinstaller.backend.Paths;
import net.oni2.aeinstaller.backend.Settings;
import net.oni2.aeinstaller.backend.Settings.Platform;
import net.oni2.aeinstaller.backend.SizeFormatter;
import net.oni2.aeinstaller.backend.depot.DepotCacheUpdateProgressListener;
import net.oni2.aeinstaller.backend.depot.DepotManager;
import net.oni2.aeinstaller.backend.mods.Mod;
import net.oni2.aeinstaller.backend.mods.ModManager;
import net.oni2.aeinstaller.backend.mods.Type;
import net.oni2.aeinstaller.backend.mods.download.ModDownloader;
import net.oni2.aeinstaller.backend.mods.download.ModDownloader.State;
import net.oni2.aeinstaller.backend.mods.download.ModDownloaderListener;
import net.oni2.aeinstaller.backend.oni.InstallProgressListener;
import net.oni2.aeinstaller.backend.oni.Installer;
import net.oni2.aeinstaller.backend.oni.OniSplit;
import net.oni2.aeinstaller.gui.about.AboutDialog;
import net.oni2.aeinstaller.gui.downloadwindow.Downloader;
import net.oni2.aeinstaller.gui.modtable.DownloadSizeListener;
import net.oni2.aeinstaller.gui.modtable.ModTableFilter;
import net.oni2.aeinstaller.gui.modtable.ModTableModel;
import net.oni2.aeinstaller.gui.settings.SettingsDialog;

import org.javabuilders.BuildResult;
import org.javabuilders.annotations.DoInBackground;
import org.javabuilders.event.BackgroundEvent;
import org.javabuilders.swing.SwingJavaBuilder;
import org.simplericity.macify.eawt.ApplicationEvent;
import org.simplericity.macify.eawt.ApplicationListener;

/**
 * @author Christian Illy
 */
public class MainWin extends JFrame implements ApplicationListener,
                DownloadSizeListener {
        private static final long serialVersionUID = -4027395051382659650L;

        private ResourceBundle bundle = ResourceBundle.getBundle(getClass()
                        .getName());
        @SuppressWarnings("unused")
        private BuildResult result = SwingJavaBuilder.build(this, bundle);

        private JMenu mainMenu;

        private JSplitPane contents;

        private JComboBox cmbModTypes;
        private JTable tblMods;
        private ModTableModel model;
        private TableRowSorter<ModTableModel> sorter;
        private JLabel lblDownloadSizeVal;

        private JLabel lblSubmitterVal;
        private JLabel lblCreatorVal;
        private JLabel lblTypesVal;
        private JLabel lblPlatformVal;
        private JLabel lblPackageNumberVal;
        private HTMLLinkLabel lblDescriptionVal;

        private JButton btnInstall;

        private TreeSet<Mod> execUpdates = null;

        private enum EInstallResult {
                DONE,
                OFFLINE,
                INCOMPATIBLE
        };

        private EInstallResult installDone = EInstallResult.DONE;

        /**
         * Constructor of main window.
         */
        public MainWin() {
                this.setTitle(SwingJavaBuilder.getConfig().getResource("appname")
                                + " - v"
                                + SwingJavaBuilder.getConfig().getResource("appversion"));

                contents.setDividerLocation(400);

                if (Settings.getPlatform() == Platform.MACOS) {
                        mainMenu.setVisible(false);
                }

                getRootPane().setDefaultButton(btnInstall);
                lblDownloadSizeVal.setText(SizeFormatter.format(0, 2));
        }

        private void initModTypeBox() {
                cmbModTypes.removeAllItems();

                TreeMap<String, Type> types = new TreeMap<String, Type>();
                for (Type t : ModManager.getInstance().getTypesWithContent()) {
                        types.put(t.getName(), t);
                }
                for (Type t : types.values()) {
                        cmbModTypes.addItem(t);
                }
                cmbModTypes.setSelectedIndex(0);
        }

        private void initTable() {
                tblMods.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
                tblMods.getSelectionModel().addListSelectionListener(
                                new ListSelectionListener() {
                                        @Override
                                        public void valueChanged(ListSelectionEvent e) {
                                                int viewRow = tblMods.getSelectedRow();
                                                if (viewRow < 0) {
                                                        modSelection(null);
                                                } else {
                                                        int modelRow = tblMods
                                                                        .convertRowIndexToModel(viewRow);
                                                        Mod mod = (Mod) model.getValueAt(modelRow, -1);
                                                        modSelection(mod);
                                                }
                                        }
                                });
                tblMods.addMouseListener(new MouseAdapter() {
                        private void common(MouseEvent e) {
                                int r = tblMods.rowAtPoint(e.getPoint());
                                if (r >= 0 && r < tblMods.getRowCount())
                                        tblMods.setRowSelectionInterval(r, r);
                                else
                                        tblMods.clearSelection();

                                int rowindex = tblMods.getSelectedRow();
                                if (rowindex >= 0) {
                                        if (e.isPopupTrigger()
                                                        && e.getComponent() instanceof JTable) {
                                                int modelRow = tblMods.convertRowIndexToModel(rowindex);
                                                final Mod mod = (Mod) model.getValueAt(modelRow, -1);

                                                if (mod.isLocalAvailable()) {
                                                        JPopupMenu popup = new JPopupMenu();
                                                        JMenuItem openModFolder = new JMenuItem(bundle
                                                                        .getString("openModFolder.text"));
                                                        openModFolder
                                                                        .addActionListener(new ActionListener() {
                                                                                @Override
                                                                                public void actionPerformed(
                                                                                                ActionEvent arg0) {
                                                                                        try {
                                                                                                Desktop.getDesktop().open(
                                                                                                                mod.getLocalPath());
                                                                                        } catch (IOException e) {
                                                                                                e.printStackTrace();
                                                                                        }
                                                                                }
                                                                        });
                                                        popup.add(openModFolder);
                                                        popup.show(e.getComponent(), e.getX(), e.getY());
                                                }
                                        }
                                }
                        }

                        @Override
                        public void mousePressed(MouseEvent e) {
                                common(e);
                        }

                        @Override
                        public void mouseReleased(MouseEvent e) {
                                common(e);
                        }
                });
                // To get checkbox-cells with background of row
                ((JComponent) tblMods.getDefaultRenderer(Boolean.class))
                                .setOpaque(true);

                model = new ModTableModel();
                model.addDownloadSizeListener(this);

                tblMods.setModel(model);

                sorter = new TableRowSorter<ModTableModel>(model);
                tblMods.setRowSorter(sorter);

                sorter.setRowFilter(new ModTableFilter(null));

                List<RowSorter.SortKey> sortKeys = new ArrayList<RowSorter.SortKey>();
                sortKeys.add(new RowSorter.SortKey(1, SortOrder.ASCENDING));
                sorter.setSortKeys(sortKeys);

                for (int i = 0; i < model.getColumnCount(); i++) {
                        model.setColumnConstraints(i, tblMods.getColumnModel().getColumn(i));
                }
        }

        private void exit() {
                dispose();
                System.exit(0);
        }

        private void saveLocalData() {
                Settings.getInstance().serializeToFile();
                DepotManager.getInstance().saveToFile(Settings.getDepotCacheFilename());
        }

        @DoInBackground(progressMessage = "updateDepot.title", cancelable = false, indeterminateProgress = false)
        private void execDepotUpdate(final BackgroundEvent evt) {
                if (!Settings.getInstance().isOfflineMode()) {
                        try {
                                DepotManager.getInstance().updateInformation(false,
                                                new DepotCacheUpdateProgressListener() {

                                                        @Override
                                                        public void cacheUpdateProgress(String stepName,
                                                                        int current, int total) {
                                                                evt.setProgressEnd(total);
                                                                evt.setProgressValue(current);
                                                                evt.setProgressMessage(stepName);
                                                        }
                                                });
                        } catch (Exception e) {
                                e.printStackTrace();
                        }
                }
                ModManager.getInstance().init();
                initTable();
                initModTypeBox();

                tblMods.setVisible(true);
        }

        @SuppressWarnings("unused")
        private void checkUpdates(Object evtSource) {
                if ((evtSource != this)
                                || Settings.getInstance().get("notifyupdates", true)) {
                        if (Settings.getInstance().isOfflineMode()) {
                                if (evtSource != this) {
                                        JOptionPane.showMessageDialog(this,
                                                        bundle.getString("offlineMode.text"),
                                                        bundle.getString("offlineMode.title"),
                                                        JOptionPane.WARNING_MESSAGE);
                                }
                        } else {
                                TreeSet<Mod> mods = ModManager.getInstance().getUpdatableMods();
                                TreeSet<Mod> tools = ModManager.getInstance()
                                                .getUpdatableTools();
                                int size = 0;
                                String strMods = "";
                                for (Mod m : mods) {
                                        size += m.getZipSize();
                                        if (strMods.length() > 0)
                                                strMods += "<br>";
                                        strMods += " - " + m.getName();
                                }
                                String strTools = "";
                                for (Mod m : tools) {
                                        size += m.getZipSize();
                                        if (strTools.length() > 0)
                                                strTools += "<br>";
                                        strTools += " - " + m.getName();
                                }
                                if (size > 0) {
                                        String message = "<html>";
                                        message += String.format(
                                                        bundle.getString("updatesAvailable.text"), strMods,
                                                        strTools, SizeFormatter.format(size, 3));
                                        message += "</html>";
                                        int res = JOptionPane.showConfirmDialog(this, message,
                                                        bundle.getString("updatesAvailable.title"),
                                                        JOptionPane.YES_NO_OPTION,
                                                        JOptionPane.QUESTION_MESSAGE);
                                        if (res == JOptionPane.YES_OPTION) {
                                                execUpdates = new TreeSet<Mod>();
                                                execUpdates.addAll(mods);
                                                execUpdates.addAll(tools);
                                        }
                                }
                        }
                }
        }

        @DoInBackground(progressMessage = "doUpdate.title", cancelable = false, indeterminateProgress = false)
        private void doUpdate(final BackgroundEvent evt) {
                if (execUpdates != null) {
                        // TODO
                        System.out.println("Update: " + execUpdates.toString());
                        // TODO: install new tools if previously installed
                }
                execUpdates = null;
        }

        @SuppressWarnings("unused")
        private void focus() {
                SwingUtilities.invokeLater(new Runnable() {

                        @Override
                        public void run() {
                                toFront();
                                repaint();
                        }
                });

        }

        private void showSettings() {
                new SettingsDialog().setVisible(true);
        }

        private void showAbout() {
                new AboutDialog().setVisible(true);
        }

        private JFileChooser getConfigOpenSaveDialog(boolean save) {
                JFileChooser fc = new JFileChooser();
                fc.setCurrentDirectory(Paths.getEditionBasePath());
                if (save)
                        fc.setDialogType(JFileChooser.SAVE_DIALOG);
                else
                        fc.setDialogType(JFileChooser.OPEN_DIALOG);
                fc.setFileSelectionMode(JFileChooser.FILES_ONLY);
                fc.setFileFilter(new FileFilter() {
                        @Override
                        public String getDescription() {
                                return "XML files";
                        }

                        @Override
                        public boolean accept(File arg0) {
                                return (arg0.isDirectory())
                                                || (arg0.getName().toLowerCase().endsWith(".xml"));
                        }
                });
                fc.setMultiSelectionEnabled(false);
                return fc;
        }

        @SuppressWarnings("unused")
        private void loadConfig() {
                JFileChooser fc = getConfigOpenSaveDialog(false);
                int res = fc.showOpenDialog(this);
                if (res == JFileChooser.APPROVE_OPTION) {
                        if (fc.getSelectedFile().exists())
                                model.reloadSelection(fc.getSelectedFile());
                }
        }

        @SuppressWarnings("unused")
        private void saveConfig() {
                JFileChooser fc = getConfigOpenSaveDialog(true);
                int res = fc.showSaveDialog(this);
                if (res == JFileChooser.APPROVE_OPTION) {
                        File f = fc.getSelectedFile();
                        if (!f.getName().endsWith(".xml"))
                                f = new File(f.getParentFile(), f.getName() + ".xml");
                        ModManager.getInstance().saveModSelection(f,
                                        model.getSelectedMods());
                }
        }

        @DoInBackground(progressMessage = "initializingEdition.title", cancelable = false, indeterminateProgress = false)
        private void reglobalize(final BackgroundEvent evt) {
                Installer.initializeEdition(new InstallProgressListener() {
                        @Override
                        public void installProgressUpdate(int done, int total, String step) {
                                evt.setProgressEnd(total);
                                evt.setProgressValue(done);
                                evt.setProgressMessage(step);
                        }
                });
        }

        @SuppressWarnings("unused")
        private void tools() {
                // TODO method stub
                JOptionPane.showMessageDialog(this, "tools", "todo",
                                JOptionPane.INFORMATION_MESSAGE);
        }

        @SuppressWarnings("unused")
        private void revertSelection() {
                model.revertSelection();
        }

        @DoInBackground(progressMessage = "mandatoryFiles.title", cancelable = false, indeterminateProgress = false)
        private void checkMandatoryFiles(final BackgroundEvent evt) {
                if (!Settings.getInstance().isOfflineMode()) {
                        TreeSet<Mod> mand = new TreeSet<Mod>();
                        for (Mod m : ModManager.getInstance().getMandatoryTools()) {
                                if (m.isNewerAvailable()) {
                                        mand.add(m);
                                }
                        }
                        for (Mod m : ModManager.getInstance().getMandatoryMods()) {
                                if (m.isNewerAvailable()) {
                                        mand.add(m);
                                }
                        }
                        if (mand.size() > 0) {
                                ModDownloader m = new ModDownloader(mand,
                                                new ModDownloaderListener() {
                                                        @Override
                                                        public void updateStatus(ModDownloader source,
                                                                        State state, int filesDown, int filesTotal,
                                                                        int bytesDown, int bytesTotal,
                                                                        int duration, int remaining, int speed) {
                                                                evt.setProgressEnd(filesTotal);
                                                                evt.setProgressValue(filesDown);
                                                        }
                                                });
                                while (!m.isFinished()) {
                                        try {
                                                Thread.sleep(10);
                                        } catch (InterruptedException e) {
                                                e.printStackTrace();
                                        }
                                }
                        }
                        evt.setProgressMessage(bundle
                                        .getString("mandatoryToolsInstall.title"));
                        Installer
                                        .installTools(ModManager.getInstance().getMandatoryTools());
                }
        }

        @DoInBackground(progressMessage = "installing.title", cancelable = false, indeterminateProgress = false)
        private void install(final BackgroundEvent evt) {
                TreeSet<Mod> mods = new TreeSet<Mod>();
                mods.addAll(ModManager.getInstance().getMandatoryMods());
                mods.addAll(model.getSelectedMods());

                boolean instReady = false;
                installDone = EInstallResult.DONE;

                while (!instReady) {
                        TreeSet<Mod> toDownload = new TreeSet<Mod>();
                        for (Mod m : mods) {
                                if (!m.isLocalAvailable())
                                        toDownload.add(m);
                        }
                        if (Settings.getInstance().isOfflineMode()) {
                                installDone = EInstallResult.OFFLINE;
                                break;
                        }
                        if (toDownload.size() > 0) {
                                Downloader dl = new Downloader(toDownload);
                                try {
                                        dl.setVisible(true);
                                        if (!dl.isFinished())
                                                break;
                                } finally {
                                        dl.dispose();
                                }
                        }
                        HashMap<Mod, HashSet<Mod>> dependencies = ModManager.getInstance()
                                        .checkDependencies(mods);
                        if (dependencies.size() > 0) {
                                System.out.println("Unmet dependencies: "
                                                + dependencies.toString());
                                for (Mod m : dependencies.keySet()) {
                                        for (Mod mDep : dependencies.get(m))
                                                mods.add(mDep);
                                }
                        } else {
                                HashMap<Mod, HashSet<Mod>> conflicts = ModManager.getInstance()
                                                .checkIncompabitilites(mods);
                                if (conflicts.size() > 0) {
                                        installDone = EInstallResult.INCOMPATIBLE;
                                        System.err.println("Incompatible mods: "
                                                        + conflicts.toString());
                                        break;
                                } else {
                                        instReady = true;
                                }
                        }
                }

                if (instReady) {
                        Installer.install(mods, new InstallProgressListener() {
                                @Override
                                public void installProgressUpdate(int done, int total,
                                                String step) {
                                        evt.setProgressEnd(total);
                                        evt.setProgressValue(done);
                                        evt.setProgressMessage(step);
                                }
                        });
                        installDone = EInstallResult.DONE;
                }
        }

        @SuppressWarnings("unused")
        private void installDone() {
                switch (installDone) {
                        case DONE:
                                JOptionPane.showMessageDialog(this,
                                                bundle.getString("installDone.text"),
                                                bundle.getString("installDone.title"),
                                                JOptionPane.INFORMATION_MESSAGE);
                                break;
                        case OFFLINE:
                                JOptionPane.showMessageDialog(this,
                                                bundle.getString("offlineMode.text"),
                                                bundle.getString("offlineMode.title"),
                                                JOptionPane.WARNING_MESSAGE);
                                break;
                        case INCOMPATIBLE:
                                break;
                }
        }

        private void modSelection(Mod m) {
                lblSubmitterVal.setText("");
                lblCreatorVal.setText("");
                lblDescriptionVal.setText("");
                lblTypesVal.setText("");
                lblPlatformVal.setText("");
                lblPackageNumberVal.setText("");
                if (m != null) {
                        lblSubmitterVal.setText(m.getName());
                        lblCreatorVal.setText(m.getCreator());
                        lblDescriptionVal.setText(m.getDescription());

                        String types = "";
                        for (Type t : m.getTypes()) {
                                if (types.length() > 0)
                                        types += ", ";
                                types += t.getName();
                        }
                        lblTypesVal.setText(types);
                        lblPlatformVal.setText(m.getPlatform().toString());
                        lblPackageNumberVal.setText(m.getPackageNumberString());
                }
        }

        @SuppressWarnings("unused")
        private void modTypeSelection() {
                Type t = (Type) cmbModTypes.getSelectedItem();
                if (t != null)
                        sorter.setRowFilter(new ModTableFilter(t));
                else
                        sorter.setRowFilter(new ModTableFilter(null));
        }

        @Override
        public void downloadSizeChanged(int newSize) {
                lblDownloadSizeVal.setText(SizeFormatter.format(newSize, 2));
        }

        @SuppressWarnings("unused")
        private void checkInitialize() {
                if (!Installer.isEditionInitialized()) {
                        if (!OniSplit.isOniSplitInstalled()) {
                                JOptionPane.showMessageDialog(this,
                                                bundle.getString("noOniSplit.text"),
                                                bundle.getString("noOniSplit.title"),
                                                JOptionPane.ERROR_MESSAGE);
                                exit();
                        } else {
                                int res = JOptionPane
                                                .showConfirmDialog(this,
                                                                bundle.getString("askInitialize.text"),
                                                                bundle.getString("askInitialize.title"),
                                                                JOptionPane.YES_NO_OPTION,
                                                                JOptionPane.QUESTION_MESSAGE);
                                if (res == JOptionPane.NO_OPTION) {
                                        saveLocalData();
                                        exit();
                                }
                        }
                }
        }

        @DoInBackground(progressMessage = "initializingEdition.title", cancelable = false, indeterminateProgress = false)
        private void initialize(final BackgroundEvent evt) {
                if (!Installer.isEditionInitialized()) {
                        Installer.initializeEdition(new InstallProgressListener() {
                                @Override
                                public void installProgressUpdate(int done, int total,
                                                String step) {
                                        evt.setProgressEnd(total);
                                        evt.setProgressValue(done);
                                        evt.setProgressMessage(step);
                                }
                        });
                }
        }

        private Vector<String> getBasicOniLaunchParams() {
                Vector<String> params = new Vector<String>();
                File exe = null;
                switch (Settings.getPlatform()) {
                        case WIN:
                                exe = new File(Paths.getEditionBasePath(), "Oni.exe");
                                if (exe.exists())
                                        params.add(exe.getPath());
                                break;
                        case MACOS:
                                exe = new File(Paths.getEditionBasePath(),
                                                "Oni.app/Contents/MacOS/Oni");
                                if (exe.exists())
                                        params.add(exe.getPath());
                                break;
                        case LINUX:
                                String wine = Settings.getWinePath();
                                exe = new File(Paths.getEditionBasePath(), "Oni.exe");
                                if (exe.exists()) {
                                        if (wine != null) {
                                                params.add(wine);
                                                params.add(exe.getPath());
                                        }
                                }
                                break;
                        default:
                }
                if (params.size() > 0) {
                        params.add("-debugfiles");
                }
                return params;
        }

        @SuppressWarnings("unused")
        private void oniFull() {
                Vector<String> params = getBasicOniLaunchParams();
                if (params.size() > 0) {
                        try {
                                ProcessBuilder pb = new ProcessBuilder(params);
                                pb.directory(Paths.getEditionBasePath());
                                pb.start();
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
        }

        @SuppressWarnings("unused")
        private void oniWin() {
                Vector<String> params = getBasicOniLaunchParams();
                if (params.size() > 0) {
                        params.add("-noswitch");
                        try {
                                ProcessBuilder pb = new ProcessBuilder(params);
                                pb.directory(Paths.getEditionBasePath());
                                pb.start();
                        } catch (IOException e) {
                                e.printStackTrace();
                        }
                }
        }

        @SuppressWarnings("unused")
        private void openEditionFolder() {
                try {
                        Desktop.getDesktop().open(Paths.getEditionBasePath());
                } catch (IOException e) {
                        e.printStackTrace();
                }
        }

        @Override
        public void handleAbout(ApplicationEvent event) {
                event.setHandled(true);
                showAbout();
        }

        @Override
        public void handleOpenApplication(ApplicationEvent event) {
        }

        @Override
        public void handleOpenFile(ApplicationEvent event) {
        }

        @Override
        public void handlePreferences(ApplicationEvent event) {
                showSettings();
        }

        @Override
        public void handlePrintFile(ApplicationEvent event) {
        }

        @Override
        public void handleQuit(ApplicationEvent event) {
                event.setHandled(true);
                saveLocalData();
                exit();
        }

        @Override
        public void handleReOpenApplication(ApplicationEvent event) {
        }

}
Revision:	622
Committed:	Wed Jan 16 07:35:08 2013 UTC (12 years, 9 months ago) by alloc
Content type:	text/x-java
Original Path:	*AE/installer2/src/net/oni2/aeinstaller/gui/MainWin.java*
File size:	20919 byte(s)
Log Message:	AEI2: - Fixed update-window always popping up - Fixed unpacker not unpacking over existing packages - Fixed type-counter (did count mandatory mods)
#	Content
1	package net.oni2.aeinstaller.gui;
2
3	import java.awt.Desktop;
4	import java.awt.event.ActionEvent;
5	import java.awt.event.ActionListener;
6	import java.awt.event.MouseAdapter;
7	import java.awt.event.MouseEvent;
8	import java.io.File;
9	import java.io.IOException;
10	import java.util.ArrayList;
11	import java.util.HashMap;
12	import java.util.HashSet;
13	import java.util.List;
14	import java.util.ResourceBundle;
15	import java.util.TreeMap;
16	import java.util.TreeSet;
17	import java.util.Vector;
18
19	import javax.swing.JButton;
20	import javax.swing.JComboBox;
21	import javax.swing.JComponent;
22	import javax.swing.JFileChooser;
23	import javax.swing.JFrame;
24	import javax.swing.JLabel;
25	import javax.swing.JMenu;
26	import javax.swing.JMenuItem;
27	import javax.swing.JOptionPane;
28	import javax.swing.JPopupMenu;
29	import javax.swing.JSplitPane;
30	import javax.swing.JTable;
31	import javax.swing.ListSelectionModel;
32	import javax.swing.RowSorter;
33	import javax.swing.SortOrder;
34	import javax.swing.SwingUtilities;
35	import javax.swing.event.ListSelectionEvent;
36	import javax.swing.event.ListSelectionListener;
37	import javax.swing.filechooser.FileFilter;
38	import javax.swing.table.TableRowSorter;
39
40	import net.oni2.aeinstaller.backend.Paths;
41	import net.oni2.aeinstaller.backend.Settings;
42	import net.oni2.aeinstaller.backend.Settings.Platform;
43	import net.oni2.aeinstaller.backend.SizeFormatter;
44	import net.oni2.aeinstaller.backend.depot.DepotCacheUpdateProgressListener;
45	import net.oni2.aeinstaller.backend.depot.DepotManager;
46	import net.oni2.aeinstaller.backend.mods.Mod;
47	import net.oni2.aeinstaller.backend.mods.ModManager;
48	import net.oni2.aeinstaller.backend.mods.Type;
49	import net.oni2.aeinstaller.backend.mods.download.ModDownloader;
50	import net.oni2.aeinstaller.backend.mods.download.ModDownloader.State;
51	import net.oni2.aeinstaller.backend.mods.download.ModDownloaderListener;
52	import net.oni2.aeinstaller.backend.oni.InstallProgressListener;
53	import net.oni2.aeinstaller.backend.oni.Installer;
54	import net.oni2.aeinstaller.backend.oni.OniSplit;
55	import net.oni2.aeinstaller.gui.about.AboutDialog;
56	import net.oni2.aeinstaller.gui.downloadwindow.Downloader;
57	import net.oni2.aeinstaller.gui.modtable.DownloadSizeListener;
58	import net.oni2.aeinstaller.gui.modtable.ModTableFilter;
59	import net.oni2.aeinstaller.gui.modtable.ModTableModel;
60	import net.oni2.aeinstaller.gui.settings.SettingsDialog;
61
62	import org.javabuilders.BuildResult;
63	import org.javabuilders.annotations.DoInBackground;
64	import org.javabuilders.event.BackgroundEvent;
65	import org.javabuilders.swing.SwingJavaBuilder;
66	import org.simplericity.macify.eawt.ApplicationEvent;
67	import org.simplericity.macify.eawt.ApplicationListener;
68
69	/**
70	* @author Christian Illy
71	*/
72	public class MainWin extends JFrame implements ApplicationListener,
73	DownloadSizeListener {
74	private static final long serialVersionUID = -4027395051382659650L;
75
76	private ResourceBundle bundle = ResourceBundle.getBundle(getClass()
77	.getName());
78	@SuppressWarnings("unused")
79	private BuildResult result = SwingJavaBuilder.build(this, bundle);
80
81	private JMenu mainMenu;
82
83	private JSplitPane contents;
84
85	private JComboBox cmbModTypes;
86	private JTable tblMods;
87	private ModTableModel model;
88	private TableRowSorter<ModTableModel> sorter;
89	private JLabel lblDownloadSizeVal;
90
91	private JLabel lblSubmitterVal;
92	private JLabel lblCreatorVal;
93	private JLabel lblTypesVal;
94	private JLabel lblPlatformVal;
95	private JLabel lblPackageNumberVal;
96	private HTMLLinkLabel lblDescriptionVal;
97
98	private JButton btnInstall;
99
100	private TreeSet<Mod> execUpdates = null;
101
102	private enum EInstallResult {
103	DONE,
104	OFFLINE,
105	INCOMPATIBLE
106	};
107
108	private EInstallResult installDone = EInstallResult.DONE;
109
110	/**
111	* Constructor of main window.
112	*/
113	public MainWin() {
114	this.setTitle(SwingJavaBuilder.getConfig().getResource("appname")
115	+ " - v"
116	+ SwingJavaBuilder.getConfig().getResource("appversion"));
117
118	contents.setDividerLocation(400);
119
120	if (Settings.getPlatform() == Platform.MACOS) {
121	mainMenu.setVisible(false);
122	}
123
124	getRootPane().setDefaultButton(btnInstall);
125	lblDownloadSizeVal.setText(SizeFormatter.format(0, 2));
126	}
127
128	private void initModTypeBox() {
129	cmbModTypes.removeAllItems();
130
131	TreeMap<String, Type> types = new TreeMap<String, Type>();
132	for (Type t : ModManager.getInstance().getTypesWithContent()) {
133	types.put(t.getName(), t);
134	}
135	for (Type t : types.values()) {
136	cmbModTypes.addItem(t);
137	}
138	cmbModTypes.setSelectedIndex(0);
139	}
140
141	private void initTable() {
142	tblMods.setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
143	tblMods.getSelectionModel().addListSelectionListener(
144	new ListSelectionListener() {
145	@Override
146	public void valueChanged(ListSelectionEvent e) {
147	int viewRow = tblMods.getSelectedRow();
148	if (viewRow < 0) {
149	modSelection(null);
150	} else {
151	int modelRow = tblMods
152	.convertRowIndexToModel(viewRow);
153	Mod mod = (Mod) model.getValueAt(modelRow, -1);
154	modSelection(mod);
155	}
156	}
157	});
158	tblMods.addMouseListener(new MouseAdapter() {
159	private void common(MouseEvent e) {
160	int r = tblMods.rowAtPoint(e.getPoint());
161	if (r >= 0 && r < tblMods.getRowCount())
162	tblMods.setRowSelectionInterval(r, r);
163	else
164	tblMods.clearSelection();
165
166	int rowindex = tblMods.getSelectedRow();
167	if (rowindex >= 0) {
168	if (e.isPopupTrigger()
169	&& e.getComponent() instanceof JTable) {
170	int modelRow = tblMods.convertRowIndexToModel(rowindex);
171	final Mod mod = (Mod) model.getValueAt(modelRow, -1);
172
173	if (mod.isLocalAvailable()) {
174	JPopupMenu popup = new JPopupMenu();
175	JMenuItem openModFolder = new JMenuItem(bundle
176	.getString("openModFolder.text"));
177	openModFolder
178	.addActionListener(new ActionListener() {
179	@Override
180	public void actionPerformed(
181	ActionEvent arg0) {
182	try {
183	Desktop.getDesktop().open(
184	mod.getLocalPath());
185	} catch (IOException e) {
186	e.printStackTrace();
187	}
188	}
189	});
190	popup.add(openModFolder);
191	popup.show(e.getComponent(), e.getX(), e.getY());
192	}
193	}
194	}
195	}
196
197	@Override
198	public void mousePressed(MouseEvent e) {
199	common(e);
200	}
201
202	@Override
203	public void mouseReleased(MouseEvent e) {
204	common(e);
205	}
206	});
207	// To get checkbox-cells with background of row
208	((JComponent) tblMods.getDefaultRenderer(Boolean.class))
209	.setOpaque(true);
210
211	model = new ModTableModel();
212	model.addDownloadSizeListener(this);
213
214	tblMods.setModel(model);
215
216	sorter = new TableRowSorter<ModTableModel>(model);
217	tblMods.setRowSorter(sorter);
218
219	sorter.setRowFilter(new ModTableFilter(null));
220
221	List<RowSorter.SortKey> sortKeys = new ArrayList<RowSorter.SortKey>();
222	sortKeys.add(new RowSorter.SortKey(1, SortOrder.ASCENDING));
223	sorter.setSortKeys(sortKeys);
224
225	for (int i = 0; i < model.getColumnCount(); i++) {
226	model.setColumnConstraints(i, tblMods.getColumnModel().getColumn(i));
227	}
228	}
229
230	private void exit() {
231	dispose();
232	System.exit(0);
233	}
234
235	private void saveLocalData() {
236	Settings.getInstance().serializeToFile();
237	DepotManager.getInstance().saveToFile(Settings.getDepotCacheFilename());
238	}
239
240	@DoInBackground(progressMessage = "updateDepot.title", cancelable = false, indeterminateProgress = false)
241	private void execDepotUpdate(final BackgroundEvent evt) {
242	if (!Settings.getInstance().isOfflineMode()) {
243	try {
244	DepotManager.getInstance().updateInformation(false,
245	new DepotCacheUpdateProgressListener() {
246
247	@Override
248	public void cacheUpdateProgress(String stepName,
249	int current, int total) {
250	evt.setProgressEnd(total);
251	evt.setProgressValue(current);
252	evt.setProgressMessage(stepName);
253	}
254	});
255	} catch (Exception e) {
256	e.printStackTrace();
257	}
258	}
259	ModManager.getInstance().init();
260	initTable();
261	initModTypeBox();
262
263	tblMods.setVisible(true);
264	}
265
266	@SuppressWarnings("unused")
267	private void checkUpdates(Object evtSource) {
268	if ((evtSource != this)
269	\|\| Settings.getInstance().get("notifyupdates", true)) {
270	if (Settings.getInstance().isOfflineMode()) {
271	if (evtSource != this) {
272	JOptionPane.showMessageDialog(this,
273	bundle.getString("offlineMode.text"),
274	bundle.getString("offlineMode.title"),
275	JOptionPane.WARNING_MESSAGE);
276	}
277	} else {
278	TreeSet<Mod> mods = ModManager.getInstance().getUpdatableMods();
279	TreeSet<Mod> tools = ModManager.getInstance()
280	.getUpdatableTools();
281	int size = 0;
282	String strMods = "";
283	for (Mod m : mods) {
284	size += m.getZipSize();
285	if (strMods.length() > 0)
286	strMods += "<br>";
287	strMods += " - " + m.getName();
288	}
289	String strTools = "";
290	for (Mod m : tools) {
291	size += m.getZipSize();
292	if (strTools.length() > 0)
293	strTools += "<br>";
294	strTools += " - " + m.getName();
295	}
296	if (size > 0) {
297	String message = "<html>";
298	message += String.format(
299	bundle.getString("updatesAvailable.text"), strMods,
300	strTools, SizeFormatter.format(size, 3));
301	message += "</html>";
302	int res = JOptionPane.showConfirmDialog(this, message,
303	bundle.getString("updatesAvailable.title"),
304	JOptionPane.YES_NO_OPTION,
305	JOptionPane.QUESTION_MESSAGE);
306	if (res == JOptionPane.YES_OPTION) {
307	execUpdates = new TreeSet<Mod>();
308	execUpdates.addAll(mods);
309	execUpdates.addAll(tools);
310	}
311	}
312	}
313	}
314	}
315
316	@DoInBackground(progressMessage = "doUpdate.title", cancelable = false, indeterminateProgress = false)
317	private void doUpdate(final BackgroundEvent evt) {
318	if (execUpdates != null) {
319	// TODO
320	System.out.println("Update: " + execUpdates.toString());
321	// TODO: install new tools if previously installed
322	}
323	execUpdates = null;
324	}
325
326	@SuppressWarnings("unused")
327	private void focus() {
328	SwingUtilities.invokeLater(new Runnable() {
329
330	@Override
331	public void run() {
332	toFront();
333	repaint();
334	}
335	});
336
337	}
338
339	private void showSettings() {
340	new SettingsDialog().setVisible(true);
341	}
342
343	private void showAbout() {
344	new AboutDialog().setVisible(true);
345	}
346
347	private JFileChooser getConfigOpenSaveDialog(boolean save) {
348	JFileChooser fc = new JFileChooser();
349	fc.setCurrentDirectory(Paths.getEditionBasePath());
350	if (save)
351	fc.setDialogType(JFileChooser.SAVE_DIALOG);
352	else
353	fc.setDialogType(JFileChooser.OPEN_DIALOG);
354	fc.setFileSelectionMode(JFileChooser.FILES_ONLY);
355	fc.setFileFilter(new FileFilter() {
356	@Override
357	public String getDescription() {
358	return "XML files";
359	}
360
361	@Override
362	public boolean accept(File arg0) {
363	return (arg0.isDirectory())
364	\|\| (arg0.getName().toLowerCase().endsWith(".xml"));
365	}
366	});
367	fc.setMultiSelectionEnabled(false);
368	return fc;
369	}
370
371	@SuppressWarnings("unused")
372	private void loadConfig() {
373	JFileChooser fc = getConfigOpenSaveDialog(false);
374	int res = fc.showOpenDialog(this);
375	if (res == JFileChooser.APPROVE_OPTION) {
376	if (fc.getSelectedFile().exists())
377	model.reloadSelection(fc.getSelectedFile());
378	}
379	}
380
381	@SuppressWarnings("unused")
382	private void saveConfig() {
383	JFileChooser fc = getConfigOpenSaveDialog(true);
384	int res = fc.showSaveDialog(this);
385	if (res == JFileChooser.APPROVE_OPTION) {
386	File f = fc.getSelectedFile();
387	if (!f.getName().endsWith(".xml"))
388	f = new File(f.getParentFile(), f.getName() + ".xml");
389	ModManager.getInstance().saveModSelection(f,
390	model.getSelectedMods());
391	}
392	}
393
394	@DoInBackground(progressMessage = "initializingEdition.title", cancelable = false, indeterminateProgress = false)
395	private void reglobalize(final BackgroundEvent evt) {
396	Installer.initializeEdition(new InstallProgressListener() {
397	@Override
398	public void installProgressUpdate(int done, int total, String step) {
399	evt.setProgressEnd(total);
400	evt.setProgressValue(done);
401	evt.setProgressMessage(step);
402	}
403	});
404	}
405
406	@SuppressWarnings("unused")
407	private void tools() {
408	// TODO method stub
409	JOptionPane.showMessageDialog(this, "tools", "todo",
410	JOptionPane.INFORMATION_MESSAGE);
411	}
412
413	@SuppressWarnings("unused")
414	private void revertSelection() {
415	model.revertSelection();
416	}
417
418	@DoInBackground(progressMessage = "mandatoryFiles.title", cancelable = false, indeterminateProgress = false)
419	private void checkMandatoryFiles(final BackgroundEvent evt) {
420	if (!Settings.getInstance().isOfflineMode()) {
421	TreeSet<Mod> mand = new TreeSet<Mod>();
422	for (Mod m : ModManager.getInstance().getMandatoryTools()) {
423	if (m.isNewerAvailable()) {
424	mand.add(m);
425	}
426	}
427	for (Mod m : ModManager.getInstance().getMandatoryMods()) {
428	if (m.isNewerAvailable()) {
429	mand.add(m);
430	}
431	}
432	if (mand.size() > 0) {
433	ModDownloader m = new ModDownloader(mand,
434	new ModDownloaderListener() {
435	@Override
436	public void updateStatus(ModDownloader source,
437	State state, int filesDown, int filesTotal,
438	int bytesDown, int bytesTotal,
439	int duration, int remaining, int speed) {
440	evt.setProgressEnd(filesTotal);
441	evt.setProgressValue(filesDown);
442	}
443	});
444	while (!m.isFinished()) {
445	try {
446	Thread.sleep(10);
447	} catch (InterruptedException e) {
448	e.printStackTrace();
449	}
450	}
451	}
452	evt.setProgressMessage(bundle
453	.getString("mandatoryToolsInstall.title"));
454	Installer
455	.installTools(ModManager.getInstance().getMandatoryTools());
456	}
457	}
458
459	@DoInBackground(progressMessage = "installing.title", cancelable = false, indeterminateProgress = false)
460	private void install(final BackgroundEvent evt) {
461	TreeSet<Mod> mods = new TreeSet<Mod>();
462	mods.addAll(ModManager.getInstance().getMandatoryMods());
463	mods.addAll(model.getSelectedMods());
464
465	boolean instReady = false;
466	installDone = EInstallResult.DONE;
467
468	while (!instReady) {
469	TreeSet<Mod> toDownload = new TreeSet<Mod>();
470	for (Mod m : mods) {
471	if (!m.isLocalAvailable())
472	toDownload.add(m);
473	}
474	if (Settings.getInstance().isOfflineMode()) {
475	installDone = EInstallResult.OFFLINE;
476	break;
477	}
478	if (toDownload.size() > 0) {
479	Downloader dl = new Downloader(toDownload);
480	try {
481	dl.setVisible(true);
482	if (!dl.isFinished())
483	break;
484	} finally {
485	dl.dispose();
486	}
487	}
488	HashMap<Mod, HashSet<Mod>> dependencies = ModManager.getInstance()
489	.checkDependencies(mods);
490	if (dependencies.size() > 0) {
491	System.out.println("Unmet dependencies: "
492	+ dependencies.toString());
493	for (Mod m : dependencies.keySet()) {
494	for (Mod mDep : dependencies.get(m))
495	mods.add(mDep);
496	}
497	} else {
498	HashMap<Mod, HashSet<Mod>> conflicts = ModManager.getInstance()
499	.checkIncompabitilites(mods);
500	if (conflicts.size() > 0) {
501	installDone = EInstallResult.INCOMPATIBLE;
502	System.err.println("Incompatible mods: "
503	+ conflicts.toString());
504	break;
505	} else {
506	instReady = true;
507	}
508	}
509	}
510
511	if (instReady) {
512	Installer.install(mods, new InstallProgressListener() {
513	@Override
514	public void installProgressUpdate(int done, int total,
515	String step) {
516	evt.setProgressEnd(total);
517	evt.setProgressValue(done);
518	evt.setProgressMessage(step);
519	}
520	});
521	installDone = EInstallResult.DONE;
522	}
523	}
524
525	@SuppressWarnings("unused")
526	private void installDone() {
527	switch (installDone) {
528	case DONE:
529	JOptionPane.showMessageDialog(this,
530	bundle.getString("installDone.text"),
531	bundle.getString("installDone.title"),
532	JOptionPane.INFORMATION_MESSAGE);
533	break;
534	case OFFLINE:
535	JOptionPane.showMessageDialog(this,
536	bundle.getString("offlineMode.text"),
537	bundle.getString("offlineMode.title"),
538	JOptionPane.WARNING_MESSAGE);
539	break;
540	case INCOMPATIBLE:
541	break;
542	}
543	}
544
545	private void modSelection(Mod m) {
546	lblSubmitterVal.setText("");
547	lblCreatorVal.setText("");
548	lblDescriptionVal.setText("");
549	lblTypesVal.setText("");
550	lblPlatformVal.setText("");
551	lblPackageNumberVal.setText("");
552	if (m != null) {
553	lblSubmitterVal.setText(m.getName());
554	lblCreatorVal.setText(m.getCreator());
555	lblDescriptionVal.setText(m.getDescription());
556
557	String types = "";
558	for (Type t : m.getTypes()) {
559	if (types.length() > 0)
560	types += ", ";
561	types += t.getName();
562	}
563	lblTypesVal.setText(types);
564	lblPlatformVal.setText(m.getPlatform().toString());
565	lblPackageNumberVal.setText(m.getPackageNumberString());
566	}
567	}
568
569	@SuppressWarnings("unused")
570	private void modTypeSelection() {
571	Type t = (Type) cmbModTypes.getSelectedItem();
572	if (t != null)
573	sorter.setRowFilter(new ModTableFilter(t));
574	else
575	sorter.setRowFilter(new ModTableFilter(null));
576	}
577
578	@Override
579	public void downloadSizeChanged(int newSize) {
580	lblDownloadSizeVal.setText(SizeFormatter.format(newSize, 2));
581	}
582
583	@SuppressWarnings("unused")
584	private void checkInitialize() {
585	if (!Installer.isEditionInitialized()) {
586	if (!OniSplit.isOniSplitInstalled()) {
587	JOptionPane.showMessageDialog(this,
588	bundle.getString("noOniSplit.text"),
589	bundle.getString("noOniSplit.title"),
590	JOptionPane.ERROR_MESSAGE);
591	exit();
592	} else {
593	int res = JOptionPane
594	.showConfirmDialog(this,
595	bundle.getString("askInitialize.text"),
596	bundle.getString("askInitialize.title"),
597	JOptionPane.YES_NO_OPTION,
598	JOptionPane.QUESTION_MESSAGE);
599	if (res == JOptionPane.NO_OPTION) {
600	saveLocalData();
601	exit();
602	}
603	}
604	}
605	}
606
607	@DoInBackground(progressMessage = "initializingEdition.title", cancelable = false, indeterminateProgress = false)
608	private void initialize(final BackgroundEvent evt) {
609	if (!Installer.isEditionInitialized()) {
610	Installer.initializeEdition(new InstallProgressListener() {
611	@Override
612	public void installProgressUpdate(int done, int total,
613	String step) {
614	evt.setProgressEnd(total);
615	evt.setProgressValue(done);
616	evt.setProgressMessage(step);
617	}
618	});
619	}
620	}
621
622	private Vector<String> getBasicOniLaunchParams() {
623	Vector<String> params = new Vector<String>();
624	File exe = null;
625	switch (Settings.getPlatform()) {
626	case WIN:
627	exe = new File(Paths.getEditionBasePath(), "Oni.exe");
628	if (exe.exists())
629	params.add(exe.getPath());
630	break;
631	case MACOS:
632	exe = new File(Paths.getEditionBasePath(),
633	"Oni.app/Contents/MacOS/Oni");
634	if (exe.exists())
635	params.add(exe.getPath());
636	break;
637	case LINUX:
638	String wine = Settings.getWinePath();
639	exe = new File(Paths.getEditionBasePath(), "Oni.exe");
640	if (exe.exists()) {
641	if (wine != null) {
642	params.add(wine);
643	params.add(exe.getPath());
644	}
645	}
646	break;
647	default:
648	}
649	if (params.size() > 0) {
650	params.add("-debugfiles");
651	}
652	return params;
653	}
654
655	@SuppressWarnings("unused")
656	private void oniFull() {
657	Vector<String> params = getBasicOniLaunchParams();
658	if (params.size() > 0) {
659	try {
660	ProcessBuilder pb = new ProcessBuilder(params);
661	pb.directory(Paths.getEditionBasePath());
662	pb.start();
663	} catch (IOException e) {
664	e.printStackTrace();
665	}
666	}
667	}
668
669	@SuppressWarnings("unused")
670	private void oniWin() {
671	Vector<String> params = getBasicOniLaunchParams();
672	if (params.size() > 0) {
673	params.add("-noswitch");
674	try {
675	ProcessBuilder pb = new ProcessBuilder(params);
676	pb.directory(Paths.getEditionBasePath());
677	pb.start();
678	} catch (IOException e) {
679	e.printStackTrace();
680	}
681	}
682	}
683
684	@SuppressWarnings("unused")
685	private void openEditionFolder() {
686	try {
687	Desktop.getDesktop().open(Paths.getEditionBasePath());
688	} catch (IOException e) {
689	e.printStackTrace();
690	}
691	}
692
693	@Override
694	public void handleAbout(ApplicationEvent event) {
695	event.setHandled(true);
696	showAbout();
697	}
698
699	@Override
700	public void handleOpenApplication(ApplicationEvent event) {
701	}
702
703	@Override
704	public void handleOpenFile(ApplicationEvent event) {
705	}
706
707	@Override
708	public void handlePreferences(ApplicationEvent event) {
709	showSettings();
710	}
711
712	@Override
713	public void handlePrintFile(ApplicationEvent event) {
714	}
715
716	@Override
717	public void handleQuit(ApplicationEvent event) {
718	event.setHandled(true);
719	saveLocalData();
720	exit();
721	}
722
723	@Override
724	public void handleReOpenApplication(ApplicationEvent event) {
725	}
726
727	}