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.aeinstaller.backend.Settings;
import net.oni2.aeinstaller.backend.packages.Package;
import net.oni2.aeinstaller.backend.packages.Type;

/**
 * @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 = Settings.getInstance().get("modSortColumn", 1);
                SortOrder sortOrder = SortOrder.valueOf(Settings.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(DownloadSizeListener listener) {
                model.addDownloadSizeListener(listener);
        }

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