gui/modtable/ModTable.java

package net.oni2.aeinstaller.gui.modtable;

import java.awt.Desktop;
import java.awt.Rectangle;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
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.HashSet;
import java.util.List;
import java.util.ResourceBundle;
import java.util.TreeSet;
import java.util.Vector;

import javax.swing.JCheckBoxMenuItem;
import javax.swing.JComponent;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPopupMenu;
import javax.swing.JTable;
import javax.swing.JViewport;
import javax.swing.ListSelectionModel;
import javax.swing.RowSorter;
import javax.swing.SortOrder;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.RowSorterEvent;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableRowSorter;

import net.oni2.SettingsManager;
import net.oni2.aeinstaller.backend.packages.Package;
import net.oni2.aeinstaller.backend.packages.Type;
import net.oni2.aeinstaller.gui.downloadwindow.Downloader;

/**
 * @author Christian Illy
 */
public class ModTable extends JTable {
        private static final long serialVersionUID = 1L;

        private ResourceBundle bundle = ResourceBundle
                        .getBundle("net.oni2.aeinstaller.localization.ModTable");

        /**
         * @author Christian Illy
         */
        public enum ETableContentType {
                /**
                 * Table showing mods
                 */
                MODS,
                /**
                 * Table showing tools
                 */
                TOOLS,
                /**
                 * Table showing core packages
                 */
                CORE
        };

        private HashSet<ModSelectionListener> modSelListeners = new HashSet<ModSelectionListener>();

        private ModTableModel model;
        private TableRowSorter<ModTableModel> sorter;

        private ETableContentType contentType = ETableContentType.MODS;

        /**
         * Create a new ModTable
         * 
         * @param contentType
         *            Content to show
         */
        public ModTable(ETableContentType contentType) {
                super();

                this.contentType = contentType;

                setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
                getSelectionModel().addListSelectionListener(this);
                addMouseListener(new MouseEventHandler());
                addKeyListener(new KeyEventHandler());
                // To get checkbox-cells with background of row
                ((JComponent) getDefaultRenderer(Boolean.class)).setOpaque(true);

                model = new ModTableModel(contentType);

                setModel(model);

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

                setFilter(null, 0, null, EApplyFilterTo.ALL);

                List<RowSorter.SortKey> sortKeys = new ArrayList<RowSorter.SortKey>();

                int sortCol = SettingsManager.getInstance().get("modSortColumn", 1);
                SortOrder sortOrder = SortOrder.valueOf(SettingsManager.getInstance()
                                .get("modSortOrder", "ASCENDING"));

                sortKeys.add(new RowSorter.SortKey(sortCol, sortOrder));
                sorter.setSortKeys(sortKeys);

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

                getTableHeader().addMouseListener(new HeaderMouseEventHandler());

                if (contentType != ETableContentType.MODS) {
                        getColumnModel().removeColumn(getColumnModel().getColumn(0));
                }
        }

        @Override
        public String getToolTipText(MouseEvent e) {
                int r = rowAtPoint(e.getPoint());
                int c = columnAtPoint(e.getPoint());
                if (r >= 0 && r < getRowCount()) {
                        int modelCol = convertColumnIndexToModel(c);
                        if (modelCol == 4) {
                                final Package mod = (Package) getValueAt(r, -1);

                                String tt = "<html>";
                                tt += String.format("%s: %s<br>",
                                                bundle.getString("state.installed"),
                                                bundle.getString((mod.isInstalled() ? "yes" : "no")));
                                tt += String.format(
                                                "%s: %s<br>",
                                                bundle.getString("state.updatable"),
                                                bundle.getString((mod.isLocalAvailable()
                                                                && mod.isNewerAvailable() ? "yes" : "no")));
                                tt += String.format("%s: %s</html>", bundle
                                                .getString("state.downloaded"), bundle.getString((mod
                                                .isLocalAvailable() ? "yes" : "no")));
                                return tt;
                        }
                }
                return super.getToolTipText(e);
        }

        /**
         * @param listener
         *            Listener to add
         */
        public void addModSelectionListener(ModSelectionListener listener) {
                modSelListeners.add(listener);
        }

        /**
         * @param listener
         *            Listener to remove
         */
        public void removeModSelectionListener(ModSelectionListener listener) {
                modSelListeners.remove(listener);
        }

        private void notifyModSelectionListeners(Package m) {
                for (ModSelectionListener l : modSelListeners) {
                        l.modSelectionChanged(this, m);
                }
        }

        /**
         * @param listener
         *            Listener to add
         */
        public void addDownloadSizeListener(ModInstallSelectionListener listener) {
                model.addDownloadSizeListener(listener);
        }

        /**
         * @param listener
         *            Listener to remove
         */
        public void removeDownloadSizeListener(ModInstallSelectionListener listener) {
                model.removeDownloadSizeListener(listener);
        }

        /**
         * Reload the nodes data after an update to the cache
         */
        public void reloadData() {
                model.reloadData();
        }

        /**
         * Revert the selection to the mods that are currently installed
         */
        public void revertSelection() {
                model.revertSelection();
        }

        /**
         * Reload the selection after a config was loaded
         * 
         * @param config
         *            Config to load
         */
        public void reloadSelection(File config) {
                model.reloadSelection(config);
        }

        /**
         * @return Mods selected for installation
         */
        public TreeSet<Package> getSelectedMods() {
                return model.getSelectedMods();
        }

        /**
         * @param type
         *            Type of mods to show (null for all)
         * @param downloadState
         *            Show only: 0 = all, 1 = online, 2 = downloaded, 3 = installed
         * @param filterString
         *            String to filter on
         * @param filterTo
         *            Fields to use string filter on
         */
        public void setFilter(Type type, int downloadState, String filterString,
                        EApplyFilterTo filterTo) {
                sorter.setRowFilter(new ModTableFilter(type, downloadState,
                                filterString, filterTo, contentType == ETableContentType.CORE,
                                false));
        }

        @Override
        public void sorterChanged(RowSorterEvent evt) {
                super.sorterChanged(evt);
                if (evt.getType() == RowSorterEvent.Type.SORT_ORDER_CHANGED) {
                        @SuppressWarnings("unchecked")
                        RowSorter<ModTableModel> rs = (RowSorter<ModTableModel>) getRowSorter();
                        List<? extends RowSorter.SortKey> keys = rs.getSortKeys();
                        if (keys.size() > 0) {
                                int col = keys.get(0).getColumn();
                                SortOrder so = keys.get(0).getSortOrder();
                                SettingsManager.getInstance().put("modSortColumn", col);
                                SettingsManager.getInstance()
                                                .put("modSortOrder", so.toString());
                        }
                }
        }

        /**
         * Select/Unselect all currently visible items depending on the current
         * state of selection
         */
        public void unSelectAll() {
                boolean isAll = true;
                for (int i = 0; i < getRowCount(); i++) {
                        int modRow = convertRowIndexToModel(i);
                        boolean inst = (Boolean) model.getValueAt(modRow, 0);
                        if (!inst) {
                                isAll = false;
                                break;
                        }
                }

                for (int i = 0; i < getRowCount(); i++) {
                        int modRow = convertRowIndexToModel(i);
                        model.selectPackage(modRow, !isAll);
                }
                model.updateDownloadSize();
                invalidate();
                repaint();
        }

        @Override
        public void valueChanged(ListSelectionEvent e) {
                super.valueChanged(e);
                int viewRow = getSelectedRow();
                if (viewRow < 0) {
                        notifyModSelectionListeners(null);
                } else {
                        Package mod = (Package) getValueAt(viewRow, -1);
                        notifyModSelectionListeners(mod);
                }
        }

        private class MouseEventHandler extends MouseAdapter {
                private void mouseEventProcessing(MouseEvent e) {
                        int r = rowAtPoint(e.getPoint());
                        if (r >= 0 && r < getRowCount())
                                setRowSelectionInterval(r, r);
                        else
                                clearSelection();

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

                                        JPopupMenu popup = new JPopupMenu();

                                        if (mod.isLocalAvailable()) {
                                                // Open package folder item
                                                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);
                                        }

                                        if (mod.getUrl() != null) {
                                                // Open Depot page item
                                                JMenuItem openDepotPage = new JMenuItem(
                                                                bundle.getString("openDepotPage.text"));
                                                openDepotPage.addActionListener(new ActionListener() {
                                                        @Override
                                                        public void actionPerformed(ActionEvent arg0) {
                                                                try {
                                                                        Desktop.getDesktop().browse(mod.getUrl());
                                                                } catch (IOException e) {
                                                                        e.printStackTrace();
                                                                }
                                                        }
                                                });
                                                popup.add(openDepotPage);
                                        }

                                        if (mod.getFile() != null) {
                                                // Download package
                                                JMenuItem downloadPackage = new JMenuItem(
                                                                bundle.getString("downloadPackage.text"));
                                                downloadPackage.addActionListener(new ActionListener() {
                                                        @Override
                                                        public void actionPerformed(ActionEvent arg0) {
                                                                TreeSet<Package> toDo = new TreeSet<Package>();
                                                                TreeSet<Package> deps = new TreeSet<Package>();
                                                                toDo.add(mod);
                                                                Downloader dl = new Downloader(toDo, deps,
                                                                                false);
                                                                try {
                                                                        dl.setVisible(true);
                                                                } finally {
                                                                        dl.dispose();
                                                                }
                                                                invalidate();
                                                                repaint();
                                                        }
                                                });
                                                popup.add(downloadPackage);
                                        }

                                        if (mod.isLocalAvailable()
                                                        && contentType != ETableContentType.CORE) {
                                                // Delete package folder item
                                                JMenuItem deleteModFolder = new JMenuItem(
                                                                bundle.getString("deletePackage.text"));
                                                deleteModFolder.addActionListener(new ActionListener() {
                                                        @Override
                                                        public void actionPerformed(ActionEvent arg0) {
                                                                if (mod.getNode() == null) {
                                                                        JOptionPane.showMessageDialog(
                                                                                        null,
                                                                                        bundle.getString("deletePackageLocalOnly.text"),
                                                                                        bundle.getString("deletePackageLocalOnly.title"),
                                                                                        JOptionPane.INFORMATION_MESSAGE);
                                                                } else {
                                                                        int res = JOptionPane.showConfirmDialog(
                                                                                        null,
                                                                                        bundle.getString("deletePackageConfirm.text"),
                                                                                        bundle.getString("deletePackageConfirm.title"),
                                                                                        JOptionPane.YES_NO_OPTION,
                                                                                        JOptionPane.WARNING_MESSAGE);
                                                                        if (res == JOptionPane.YES_OPTION) {
                                                                                mod.deleteLocalPackage();
                                                                                invalidate();
                                                                                repaint();
                                                                        }
                                                                }
                                                        }
                                                });
                                                popup.add(deleteModFolder);
                                        }

                                        if (popup.getSubElements().length > 0)
                                                popup.show(e.getComponent(), e.getX(), e.getY());
                                }
                        }
                }

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

                @Override
                public void mouseReleased(MouseEvent e) {
                        mouseEventProcessing(e);
                }
        }

        private class KeyEventHandler extends KeyAdapter {
                private void goToRow(int row) {
                        setRowSelectionInterval(row, row);
                        JViewport viewport = (JViewport) getParent();
                        Rectangle rect = getCellRect(row, 0, true);
                        Rectangle r2 = viewport.getVisibleRect();
                        scrollRectToVisible(new Rectangle(rect.x, rect.y,
                                        (int) r2.getWidth(), (int) r2.getHeight()));
                }

                @Override
                public void keyTyped(KeyEvent e) {
                        super.keyTyped(e);

                        if (e.getModifiers() == 0) {
                                String key = String.valueOf(e.getKeyChar()).toLowerCase();
                                int row = getSelectedRow();
                                if (row == (getRowCount() - 1))
                                        row = -1;
                                for (int i = row + 1; i < getRowCount(); i++) {
                                        Package m = (Package) getValueAt(i, -1);
                                        if (m.getName().toLowerCase().startsWith(key)) {
                                                goToRow(i);
                                                return;
                                        }
                                }
                                if (row > 0) {
                                        for (int i = 0; i < row; i++) {
                                                Package m = (Package) getValueAt(i, -1);
                                                if (m.getName().toLowerCase().startsWith(key)) {
                                                        goToRow(i);
                                                        return;
                                                }
                                        }
                                }
                        }
                }
        }

        private class HeaderMouseEventHandler extends MouseAdapter {
                private Vector<TableColumn> columns = new Vector<TableColumn>();
                private TableColumnModel tcm = getColumnModel();

                public HeaderMouseEventHandler() {
                        super();

                        for (int i = 1; i < tcm.getColumnCount(); i++) {
                                columns.add(tcm.getColumn(i));
                        }

                        for (int i = 1; i < columns.size(); i++) {
                                TableColumn tc = columns.get(i);
                                if (!SettingsManager.getInstance().get(
                                                String.format("modShowColumn%02d", tc.getModelIndex()),
                                                true))
                                        tcm.removeColumn(tc);
                        }
                }

                private TableColumn getColumn(String name) {
                        for (TableColumn tc : columns) {
                                if (tc.getHeaderValue().equals(name)) {
                                        return tc;
                                }
                        }
                        return null;
                }

                private int headerContains(TableColumn tc) {
                        for (int col = 0; col < tcm.getColumnCount(); col++) {
                                if (tcm.getColumn(col).equals(tc))
                                        return col;
                        }
                        return -1;
                }

                private void mouseEventProcessing(MouseEvent e) {
                        if (e.isPopupTrigger() && e.getComponent() instanceof JTableHeader) {
                                JPopupMenu popup = new JPopupMenu();

                                ActionListener al = new ActionListener() {
                                        @Override
                                        public void actionPerformed(ActionEvent e) {
                                                JCheckBoxMenuItem itm = (JCheckBoxMenuItem) e
                                                                .getSource();
                                                TableColumn col = getColumn(itm.getText());
                                                if (itm.isSelected()) {
                                                        tcm.addColumn(col);
                                                        for (int i = columns.indexOf(col) - 1; i >= 0; i--) {
                                                                int pos = headerContains(columns.get(i));
                                                                if (pos >= 0) {
                                                                        tcm.moveColumn(tcm.getColumnCount() - 1,
                                                                                        pos + 1);
                                                                        break;
                                                                }
                                                        }
                                                } else {
                                                        tcm.removeColumn(col);
                                                }
                                                SettingsManager.getInstance().put(
                                                                String.format("modShowColumn%02d",
                                                                                col.getModelIndex()), itm.isSelected());
                                        }
                                };

                                for (int i = 1; i < columns.size(); i++) {
                                        JCheckBoxMenuItem itm = new JCheckBoxMenuItem(
                                                        (String) columns.get(i).getHeaderValue());
                                        itm.setSelected(headerContains(columns.get(i)) >= 0);

                                        itm.addActionListener(al);
                                        popup.add(itm);
                                }

                                if (popup.getSubElements().length > 0)
                                        popup.show(e.getComponent(), e.getX(), e.getY());
                        }
                }

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

                @Override
                public void mouseReleased(MouseEvent e) {
                        mouseEventProcessing(e);
                }
        }

}
Revision:	805
Committed:	Fri Apr 12 16:11:49 2013 UTC (12 years, 6 months ago) by alloc
Content type:	text/x-java
File size:	14652 byte(s)
Log Message:	AEI2.02: - Fixes #18
#	Content
1	package net.oni2.aeinstaller.gui.modtable;
2
3	import java.awt.Desktop;
4	import java.awt.Rectangle;
5	import java.awt.event.ActionEvent;
6	import java.awt.event.ActionListener;
7	import java.awt.event.KeyAdapter;
8	import java.awt.event.KeyEvent;
9	import java.awt.event.MouseAdapter;
10	import java.awt.event.MouseEvent;
11	import java.io.File;
12	import java.io.IOException;
13	import java.util.ArrayList;
14	import java.util.HashSet;
15	import java.util.List;
16	import java.util.ResourceBundle;
17	import java.util.TreeSet;
18	import java.util.Vector;
19
20	import javax.swing.JCheckBoxMenuItem;
21	import javax.swing.JComponent;
22	import javax.swing.JMenuItem;
23	import javax.swing.JOptionPane;
24	import javax.swing.JPopupMenu;
25	import javax.swing.JTable;
26	import javax.swing.JViewport;
27	import javax.swing.ListSelectionModel;
28	import javax.swing.RowSorter;
29	import javax.swing.SortOrder;
30	import javax.swing.event.ListSelectionEvent;
31	import javax.swing.event.RowSorterEvent;
32	import javax.swing.table.JTableHeader;
33	import javax.swing.table.TableColumn;
34	import javax.swing.table.TableColumnModel;
35	import javax.swing.table.TableRowSorter;
36
37	import net.oni2.SettingsManager;
38	import net.oni2.aeinstaller.backend.packages.Package;
39	import net.oni2.aeinstaller.backend.packages.Type;
40	import net.oni2.aeinstaller.gui.downloadwindow.Downloader;
41
42	/**
43	* @author Christian Illy
44	*/
45	public class ModTable extends JTable {
46	private static final long serialVersionUID = 1L;
47
48	private ResourceBundle bundle = ResourceBundle
49	.getBundle("net.oni2.aeinstaller.localization.ModTable");
50
51	/**
52	* @author Christian Illy
53	*/
54	public enum ETableContentType {
55	/**
56	* Table showing mods
57	*/
58	MODS,
59	/**
60	* Table showing tools
61	*/
62	TOOLS,
63	/**
64	* Table showing core packages
65	*/
66	CORE
67	};
68
69	private HashSet<ModSelectionListener> modSelListeners = new HashSet<ModSelectionListener>();
70
71	private ModTableModel model;
72	private TableRowSorter<ModTableModel> sorter;
73
74	private ETableContentType contentType = ETableContentType.MODS;
75
76	/**
77	* Create a new ModTable
78	*
79	* @param contentType
80	* Content to show
81	*/
82	public ModTable(ETableContentType contentType) {
83	super();
84
85	this.contentType = contentType;
86
87	setSelectionMode(ListSelectionModel.SINGLE_SELECTION);
88	getSelectionModel().addListSelectionListener(this);
89	addMouseListener(new MouseEventHandler());
90	addKeyListener(new KeyEventHandler());
91	// To get checkbox-cells with background of row
92	((JComponent) getDefaultRenderer(Boolean.class)).setOpaque(true);
93
94	model = new ModTableModel(contentType);
95
96	setModel(model);
97
98	sorter = new TableRowSorter<ModTableModel>(model);
99	setRowSorter(sorter);
100
101	setFilter(null, 0, null, EApplyFilterTo.ALL);
102
103	List<RowSorter.SortKey> sortKeys = new ArrayList<RowSorter.SortKey>();
104
105	int sortCol = SettingsManager.getInstance().get("modSortColumn", 1);
106	SortOrder sortOrder = SortOrder.valueOf(SettingsManager.getInstance()
107	.get("modSortOrder", "ASCENDING"));
108
109	sortKeys.add(new RowSorter.SortKey(sortCol, sortOrder));
110	sorter.setSortKeys(sortKeys);
111
112	for (int i = 0; i < model.getColumnCount(); i++) {
113	model.setColumnConstraints(i, getColumnModel().getColumn(i));
114	}
115
116	getTableHeader().addMouseListener(new HeaderMouseEventHandler());
117
118	if (contentType != ETableContentType.MODS) {
119	getColumnModel().removeColumn(getColumnModel().getColumn(0));
120	}
121	}
122
123	@Override
124	public String getToolTipText(MouseEvent e) {
125	int r = rowAtPoint(e.getPoint());
126	int c = columnAtPoint(e.getPoint());
127	if (r >= 0 && r < getRowCount()) {
128	int modelCol = convertColumnIndexToModel(c);
129	if (modelCol == 4) {
130	final Package mod = (Package) getValueAt(r, -1);
131
132	String tt = "<html>";
133	tt += String.format("%s: %s<br>",
134	bundle.getString("state.installed"),
135	bundle.getString((mod.isInstalled() ? "yes" : "no")));
136	tt += String.format(
137	"%s: %s<br>",
138	bundle.getString("state.updatable"),
139	bundle.getString((mod.isLocalAvailable()
140	&& mod.isNewerAvailable() ? "yes" : "no")));
141	tt += String.format("%s: %s</html>", bundle
142	.getString("state.downloaded"), bundle.getString((mod
143	.isLocalAvailable() ? "yes" : "no")));
144	return tt;
145	}
146	}
147	return super.getToolTipText(e);
148	}
149
150	/**
151	* @param listener
152	* Listener to add
153	*/
154	public void addModSelectionListener(ModSelectionListener listener) {
155	modSelListeners.add(listener);
156	}
157
158	/**
159	* @param listener
160	* Listener to remove
161	*/
162	public void removeModSelectionListener(ModSelectionListener listener) {
163	modSelListeners.remove(listener);
164	}
165
166	private void notifyModSelectionListeners(Package m) {
167	for (ModSelectionListener l : modSelListeners) {
168	l.modSelectionChanged(this, m);
169	}
170	}
171
172	/**
173	* @param listener
174	* Listener to add
175	*/
176	public void addDownloadSizeListener(ModInstallSelectionListener listener) {
177	model.addDownloadSizeListener(listener);
178	}
179
180	/**
181	* @param listener
182	* Listener to remove
183	*/
184	public void removeDownloadSizeListener(ModInstallSelectionListener listener) {
185	model.removeDownloadSizeListener(listener);
186	}
187
188	/**
189	* Reload the nodes data after an update to the cache
190	*/
191	public void reloadData() {
192	model.reloadData();
193	}
194
195	/**
196	* Revert the selection to the mods that are currently installed
197	*/
198	public void revertSelection() {
199	model.revertSelection();
200	}
201
202	/**
203	* Reload the selection after a config was loaded
204	*
205	* @param config
206	* Config to load
207	*/
208	public void reloadSelection(File config) {
209	model.reloadSelection(config);
210	}
211
212	/**
213	* @return Mods selected for installation
214	*/
215	public TreeSet<Package> getSelectedMods() {
216	return model.getSelectedMods();
217	}
218
219	/**
220	* @param type
221	* Type of mods to show (null for all)
222	* @param downloadState
223	* Show only: 0 = all, 1 = online, 2 = downloaded, 3 = installed
224	* @param filterString
225	* String to filter on
226	* @param filterTo
227	* Fields to use string filter on
228	*/
229	public void setFilter(Type type, int downloadState, String filterString,
230	EApplyFilterTo filterTo) {
231	sorter.setRowFilter(new ModTableFilter(type, downloadState,
232	filterString, filterTo, contentType == ETableContentType.CORE,
233	false));
234	}
235
236	@Override
237	public void sorterChanged(RowSorterEvent evt) {
238	super.sorterChanged(evt);
239	if (evt.getType() == RowSorterEvent.Type.SORT_ORDER_CHANGED) {
240	@SuppressWarnings("unchecked")
241	RowSorter<ModTableModel> rs = (RowSorter<ModTableModel>) getRowSorter();
242	List<? extends RowSorter.SortKey> keys = rs.getSortKeys();
243	if (keys.size() > 0) {
244	int col = keys.get(0).getColumn();
245	SortOrder so = keys.get(0).getSortOrder();
246	SettingsManager.getInstance().put("modSortColumn", col);
247	SettingsManager.getInstance()
248	.put("modSortOrder", so.toString());
249	}
250	}
251	}
252
253	/**
254	* Select/Unselect all currently visible items depending on the current
255	* state of selection
256	*/
257	public void unSelectAll() {
258	boolean isAll = true;
259	for (int i = 0; i < getRowCount(); i++) {
260	int modRow = convertRowIndexToModel(i);
261	boolean inst = (Boolean) model.getValueAt(modRow, 0);
262	if (!inst) {
263	isAll = false;
264	break;
265	}
266	}
267
268	for (int i = 0; i < getRowCount(); i++) {
269	int modRow = convertRowIndexToModel(i);
270	model.selectPackage(modRow, !isAll);
271	}
272	model.updateDownloadSize();
273	invalidate();
274	repaint();
275	}
276
277	@Override
278	public void valueChanged(ListSelectionEvent e) {
279	super.valueChanged(e);
280	int viewRow = getSelectedRow();
281	if (viewRow < 0) {
282	notifyModSelectionListeners(null);
283	} else {
284	Package mod = (Package) getValueAt(viewRow, -1);
285	notifyModSelectionListeners(mod);
286	}
287	}
288
289	private class MouseEventHandler extends MouseAdapter {
290	private void mouseEventProcessing(MouseEvent e) {
291	int r = rowAtPoint(e.getPoint());
292	if (r >= 0 && r < getRowCount())
293	setRowSelectionInterval(r, r);
294	else
295	clearSelection();
296
297	int rowindex = getSelectedRow();
298	if (rowindex >= 0) {
299	if (e.isPopupTrigger() && e.getComponent() instanceof JTable) {
300	final Package mod = (Package) getValueAt(rowindex, -1);
301
302	JPopupMenu popup = new JPopupMenu();
303
304	if (mod.isLocalAvailable()) {
305	// Open package folder item
306	JMenuItem openModFolder = new JMenuItem(
307	bundle.getString("openModFolder.text"));
308	openModFolder.addActionListener(new ActionListener() {
309	@Override
310	public void actionPerformed(ActionEvent arg0) {
311	try {
312	Desktop.getDesktop().open(
313	mod.getLocalPath());
314	} catch (IOException e) {
315	e.printStackTrace();
316	}
317	}
318	});
319	popup.add(openModFolder);
320	}
321
322	if (mod.getUrl() != null) {
323	// Open Depot page item
324	JMenuItem openDepotPage = new JMenuItem(
325	bundle.getString("openDepotPage.text"));
326	openDepotPage.addActionListener(new ActionListener() {
327	@Override
328	public void actionPerformed(ActionEvent arg0) {
329	try {
330	Desktop.getDesktop().browse(mod.getUrl());
331	} catch (IOException e) {
332	e.printStackTrace();
333	}
334	}
335	});
336	popup.add(openDepotPage);
337	}
338
339	if (mod.getFile() != null) {
340	// Download package
341	JMenuItem downloadPackage = new JMenuItem(
342	bundle.getString("downloadPackage.text"));
343	downloadPackage.addActionListener(new ActionListener() {
344	@Override
345	public void actionPerformed(ActionEvent arg0) {
346	TreeSet<Package> toDo = new TreeSet<Package>();
347	TreeSet<Package> deps = new TreeSet<Package>();
348	toDo.add(mod);
349	Downloader dl = new Downloader(toDo, deps,
350	false);
351	try {
352	dl.setVisible(true);
353	} finally {
354	dl.dispose();
355	}
356	invalidate();
357	repaint();
358	}
359	});
360	popup.add(downloadPackage);
361	}
362
363	if (mod.isLocalAvailable()
364	&& contentType != ETableContentType.CORE) {
365	// Delete package folder item
366	JMenuItem deleteModFolder = new JMenuItem(
367	bundle.getString("deletePackage.text"));
368	deleteModFolder.addActionListener(new ActionListener() {
369	@Override
370	public void actionPerformed(ActionEvent arg0) {
371	if (mod.getNode() == null) {
372	JOptionPane.showMessageDialog(
373	null,
374	bundle.getString("deletePackageLocalOnly.text"),
375	bundle.getString("deletePackageLocalOnly.title"),
376	JOptionPane.INFORMATION_MESSAGE);
377	} else {
378	int res = JOptionPane.showConfirmDialog(
379	null,
380	bundle.getString("deletePackageConfirm.text"),
381	bundle.getString("deletePackageConfirm.title"),
382	JOptionPane.YES_NO_OPTION,
383	JOptionPane.WARNING_MESSAGE);
384	if (res == JOptionPane.YES_OPTION) {
385	mod.deleteLocalPackage();
386	invalidate();
387	repaint();
388	}
389	}
390	}
391	});
392	popup.add(deleteModFolder);
393	}
394
395	if (popup.getSubElements().length > 0)
396	popup.show(e.getComponent(), e.getX(), e.getY());
397	}
398	}
399	}
400
401	@Override
402	public void mousePressed(MouseEvent e) {
403	mouseEventProcessing(e);
404	}
405
406	@Override
407	public void mouseReleased(MouseEvent e) {
408	mouseEventProcessing(e);
409	}
410	}
411
412	private class KeyEventHandler extends KeyAdapter {
413	private void goToRow(int row) {
414	setRowSelectionInterval(row, row);
415	JViewport viewport = (JViewport) getParent();
416	Rectangle rect = getCellRect(row, 0, true);
417	Rectangle r2 = viewport.getVisibleRect();
418	scrollRectToVisible(new Rectangle(rect.x, rect.y,
419	(int) r2.getWidth(), (int) r2.getHeight()));
420	}
421
422	@Override
423	public void keyTyped(KeyEvent e) {
424	super.keyTyped(e);
425
426	if (e.getModifiers() == 0) {
427	String key = String.valueOf(e.getKeyChar()).toLowerCase();
428	int row = getSelectedRow();
429	if (row == (getRowCount() - 1))
430	row = -1;
431	for (int i = row + 1; i < getRowCount(); i++) {
432	Package m = (Package) getValueAt(i, -1);
433	if (m.getName().toLowerCase().startsWith(key)) {
434	goToRow(i);
435	return;
436	}
437	}
438	if (row > 0) {
439	for (int i = 0; i < row; i++) {
440	Package m = (Package) getValueAt(i, -1);
441	if (m.getName().toLowerCase().startsWith(key)) {
442	goToRow(i);
443	return;
444	}
445	}
446	}
447	}
448	}
449	}
450
451	private class HeaderMouseEventHandler extends MouseAdapter {
452	private Vector<TableColumn> columns = new Vector<TableColumn>();
453	private TableColumnModel tcm = getColumnModel();
454
455	public HeaderMouseEventHandler() {
456	super();
457
458	for (int i = 1; i < tcm.getColumnCount(); i++) {
459	columns.add(tcm.getColumn(i));
460	}
461
462	for (int i = 1; i < columns.size(); i++) {
463	TableColumn tc = columns.get(i);
464	if (!SettingsManager.getInstance().get(
465	String.format("modShowColumn%02d", tc.getModelIndex()),
466	true))
467	tcm.removeColumn(tc);
468	}
469	}
470
471	private TableColumn getColumn(String name) {
472	for (TableColumn tc : columns) {
473	if (tc.getHeaderValue().equals(name)) {
474	return tc;
475	}
476	}
477	return null;
478	}
479
480	private int headerContains(TableColumn tc) {
481	for (int col = 0; col < tcm.getColumnCount(); col++) {
482	if (tcm.getColumn(col).equals(tc))
483	return col;
484	}
485	return -1;
486	}
487
488	private void mouseEventProcessing(MouseEvent e) {
489	if (e.isPopupTrigger() && e.getComponent() instanceof JTableHeader) {
490	JPopupMenu popup = new JPopupMenu();
491
492	ActionListener al = new ActionListener() {
493	@Override
494	public void actionPerformed(ActionEvent e) {
495	JCheckBoxMenuItem itm = (JCheckBoxMenuItem) e
496	.getSource();
497	TableColumn col = getColumn(itm.getText());
498	if (itm.isSelected()) {
499	tcm.addColumn(col);
500	for (int i = columns.indexOf(col) - 1; i >= 0; i--) {
501	int pos = headerContains(columns.get(i));
502	if (pos >= 0) {
503	tcm.moveColumn(tcm.getColumnCount() - 1,
504	pos + 1);
505	break;
506	}
507	}
508	} else {
509	tcm.removeColumn(col);
510	}
511	SettingsManager.getInstance().put(
512	String.format("modShowColumn%02d",
513	col.getModelIndex()), itm.isSelected());
514	}
515	};
516
517	for (int i = 1; i < columns.size(); i++) {
518	JCheckBoxMenuItem itm = new JCheckBoxMenuItem(
519	(String) columns.get(i).getHeaderValue());
520	itm.setSelected(headerContains(columns.get(i)) >= 0);
521
522	itm.addActionListener(al);
523	popup.add(itm);
524	}
525
526	if (popup.getSubElements().length > 0)
527	popup.show(e.getComponent(), e.getX(), e.getY());
528	}
529	}
530
531	@Override
532	public void mousePressed(MouseEvent e) {
533	mouseEventProcessing(e);
534	}
535
536	@Override
537	public void mouseReleased(MouseEvent e) {
538	mouseEventProcessing(e);
539	}
540	}
541
542	}