jsampler/view/AbstractInstrumentsDbTable.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
 *
 *   This file is part of JSampler.
 *
 *   JSampler is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License version 2
 *   as published by the Free Software Foundation.
 *
 *   JSampler is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with JSampler; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston,
 *   MA  02111-1307  USA
 */

package org.jsampler.view;

import java.awt.Component;
import java.awt.Container;
import java.awt.Dimension;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import java.util.Comparator;
import java.util.Vector;

import javax.swing.DefaultCellEditor;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.JViewport;

import javax.swing.event.ChangeEvent;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.TableColumnModelEvent;
import javax.swing.event.TableColumnModelListener;

import javax.swing.table.TableCellEditor;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
import javax.swing.table.TableRowSorter;

import org.jsampler.CC;
import org.jsampler.JSPrefs;

import org.linuxsampler.lscp.DbDirectoryInfo;
import org.linuxsampler.lscp.DbInstrumentInfo;

import org.linuxsampler.lscp.event.InstrumentsDbAdapter;
import org.linuxsampler.lscp.event.InstrumentsDbEvent;


/**
 *
 * @author Grigor Iliev
 */
public abstract class AbstractInstrumentsDbTable extends JTable {
        private final DefaultCellEditor nameEditor;
        private final JTextField tfEditor = new JTextField();
        
        private DbDirectoryTreeNode directoryNode;
        private final InstrumentsDbTableRowSorter rowSorter;
        
        private String createdDirectoryName = null;
        
        private InstrumentsDbTableView view = null;
        
        /**
         * Creates a new instance of <code>AbstractInstrumentsDbTable</code>
         */
        public AbstractInstrumentsDbTable() {
                this(new InstrumentsDbTableModel());
        }
        
        /**
         * Creates a new instance of <code>AbstractInstrumentsDbTable</code>
         */
        public AbstractInstrumentsDbTable(InstrumentsDbTableModel model) {
                super(model);
                setView(CC.getViewConfig().getInstrumentsDbTableView());
                
                String s;
                InstrumentsDbTableModel m = getModel();
                
                s = "DbInstrumentsTable.ShowSizeColumn";
                m.setShowSizeColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowFormatFamilyColumn";
                m.setShowFormatFamilyColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowFormatVersionColumn";
                m.setShowFormatVersionColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowIsDrumColumn";
                m.setShowIsDrumColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowCreatedColumn";
                m.setShowCreatedColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowModifiedColumn";
                m.setShowModifiedColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowProductColumn";
                m.setShowProductColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowArtistsColumn";
                m.setShowArtistsColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowInstrumentFileColumn";
                m.setShowInstrumentFileColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowInstrumentNrColumn";
                m.setShowInstrumentNrColumn(preferences().getBoolProperty(s));
                s = "DbInstrumentsTable.ShowKeywordsColumn";
                m.setShowKeywordsColumn(preferences().getBoolProperty(s));
                
                setAutoResizeMode(AUTO_RESIZE_OFF);
                
                rowSorter = new InstrumentsDbTableRowSorter(getModel());
                setRowSorter(rowSorter);
                
                putClientProperty("JTable.autoStartsEdit", false);
                
                nameEditor = new DefaultCellEditor(tfEditor);
                nameEditor.setClickCountToStart(5);
                
                if(m.getShowDummyColumn()) {
                        TableColumn dummy;
                        dummy = getColumnModel().getColumn(getModel().getDummyColumnIndex());
                        dummy.setPreferredWidth(10);
                }
        }
        
        public InstrumentsDbTableModel
        getModel() { return (InstrumentsDbTableModel)super.getModel(); }
        
        public TableCellEditor
        getCellEditor(int row, int column) {
                if(column == 0) return nameEditor;
                return super.getCellEditor(row, column);
        }
        
        public DbDirectoryTreeNode
        getSelectedDirectoryNode() {
                int idx = getSelectedRow();
                if(idx == -1) return null;
                idx = convertRowIndexToModel(idx);
                return getModel().getDirectoryNode(idx);
        }
        
        /**
         * Selects the specified directory.
         * The current selection is not altered if missing directory is specified.
         * @param dir The name of the directory to select.
         */
        public void
        setSelectedDirectory(String dir) {
                int i = getModel().getDirectoryRowIndex(dir);
                if(i == -1) return;
                i = convertRowIndexToView(i);
                if(i == -1) return;
                
                getSelectionModel().setSelectionInterval(i, i);
        }
        
        /**
         * Selects the specified instrument.
         * The current selection is not altered if missing instrument is specified.
         * @param instr The name of the instrument to select.
         */
        public void
        setSelectedInstrument(String instr) {
                int i = getModel().getInstrumentRowIndex(instr);
                if(i == -1) return;
                i = convertRowIndexToView(i);
                if(i == -1) return;
                getSelectionModel().setSelectionInterval(i, i);
        }
        
        /**
         * Gets all selected directories.
         */
        public DbDirectoryInfo[]
        getSelectedDirectories() {
                int[] rows = getSelectedRows();
                if(rows.length == 0) return new DbDirectoryInfo[0];
                
                DbDirectoryTreeNode dir;
                Vector<DbDirectoryInfo> v = new Vector<DbDirectoryInfo>();
                for(int i : rows) {
                        dir = getModel().getDirectoryNode(convertRowIndexToModel(i));
                        if(dir != null) v.add(dir.getInfo());
                }
                
                return v.toArray(new DbDirectoryInfo[v.size()]);
        }
        
        /**
         * Gets all selected instruments.
         */
        public DbInstrumentInfo[]
        getSelectedInstruments() {
                int[] rows = getSelectedRows();
                if(rows.length == 0) return new DbInstrumentInfo[0];
                
                DbInstrumentInfo instr;
                Vector<DbInstrumentInfo> v = new Vector<DbInstrumentInfo>();
                for(int i : rows) {
                        instr = getModel().getInstrument(convertRowIndexToModel(i));
                        if(instr != null) v.add(instr);
                }
                
                return v.toArray(new DbInstrumentInfo[v.size()]);
        }
        
        public boolean
        editCellAt(int row, int column) {
                if(!super.editCellAt(row, column)) return false;
                
                Component c = getEditorComponent();
                if(c != null) c.requestFocusInWindow();
                
                return true;
        }
        
        /**
         * Gets the directory node, which
         * content is represented by this table.
         */
        public DbDirectoryTreeNode
        getParentDirectoryNode() { return directoryNode; }
        
        /**
         * Sets the directory node, which
         * content will be represented by this table.
         */
        public void
        setParentDirectoryNode(DbDirectoryTreeNode node) {
                getModel().setParentDirectoryNode(node);
                
                if(directoryNode != null) directoryNode.removeInstrumentsDbListener(getHandler());
                directoryNode = node;
                if(directoryNode != null) directoryNode.addInstrumentsDbListener(getHandler());
        }
        
        /**
         * Gets the name of the directory created by this frontend.
         * This method is used to determine the directories created
         * by this frontend.
         * @return The name of the directory created by this frontend.
         */
        public String
        getCreatedDirectoryName() { return createdDirectoryName; }
        
        /**
         * Sets the name of the created by this frontend.
         * @param name The name of the directory created by this frontend.
         */
        public void
        setCreatedDirectoryName(String name) { createdDirectoryName = name; }
        
        public Object
        getLeadObject() {
                if(getSelectionModel().isSelectionEmpty()) return null;
                int idx = getSelectionModel().getLeadSelectionIndex();
                if(idx < 0) return null;
                idx = this.convertRowIndexToModel(idx);
                
                return getModel().getValueAt(idx, 0);
        }
        
        /** Sets the view to be used for retrieving UI information. */
        public void
        setView(InstrumentsDbTableView view) {
                this.view = view;
        }
        
        /** Gets the view used to retrieve UI information. */
        public InstrumentsDbTableView
        getView() { return view; }
        
        private JSPrefs
        preferences() { return CC.getViewConfig().preferences(); }
                
        public void
        loadColumnWidths() {
                loadColumnWidths("");
        }
                
        public void
        loadColumnWidths(String prefix) {
                InstrumentsDbTableModel m = getModel();
                TableColumnModel tcm = getColumnModel();
                
                for(int i = 0; i < m.getColumnCount(); i++) {
                        switch(m.getColumnType(i)) {
                        case NAME:
                                String s = prefix + "DbInstrumentsTable.nameColumnWidth";
                                int w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case SIZE:
                                s = prefix + "DbInstrumentsTable.sizeColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case FORMAT_FAMILY:
                                s = prefix + "DbInstrumentsTable.formatFamilyColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case FORMAT_VERSION:
                                s = prefix + "DbInstrumentsTable.formatVersionColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case IS_DRUM:
                                s = prefix + "DbInstrumentsTable.isDrumColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case CREATED:
                                s = prefix + "DbInstrumentsTable.createdColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case MODIFIED:
                                s = prefix + "DbInstrumentsTable.modifiedColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case PRODUCT:
                                s = prefix + "DbInstrumentsTable.productColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case ARTISTS:
                                s = prefix + "DbInstrumentsTable.artistsColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case INSTRUMENT_FILE:
                                s = prefix + "DbInstrumentsTable.instrumentFileColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case INSTRUMENT_NR:
                                s = prefix + "DbInstrumentsTable.instrumentNrColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case KEYWORDS:
                                s = prefix + "DbInstrumentsTable.keywordsColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case DUMMY:
                                tcm.getColumn(i).setPreferredWidth(10);
                                break;
                        }
                }
        }
        
        public void
        saveColumnWidths() {
                saveColumnWidths("");
        }
        
        public void
        saveColumnWidths(String prefix) {
                InstrumentsDbTableModel m = getModel();
                TableColumnModel tcm = getColumnModel();
                
                for(int i = 0; i < m.getColumnCount(); i++) {
                        switch(m.getColumnType(i)) {
                        case NAME:
                                String s = prefix + "DbInstrumentsTable.nameColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case SIZE:
                                s = prefix + "DbInstrumentsTable.sizeColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case FORMAT_FAMILY:
                                s = prefix + "DbInstrumentsTable.formatFamilyColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case FORMAT_VERSION:
                                s = prefix + "DbInstrumentsTable.formatVersionColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case IS_DRUM:
                                s = prefix + "DbInstrumentsTable.isDrumColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case CREATED:
                                s = prefix + "DbInstrumentsTable.createdColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case MODIFIED:
                                s = prefix + "DbInstrumentsTable.modifiedColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case PRODUCT:
                                s = prefix + "DbInstrumentsTable.productColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case ARTISTS:
                                s = prefix + "DbInstrumentsTable.artistsColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case INSTRUMENT_FILE:
                                s = prefix + "DbInstrumentsTable.instrumentFileColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case INSTRUMENT_NR:
                                s = prefix + "DbInstrumentsTable.instrumentNrColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case KEYWORDS:
                                s = prefix + "DbInstrumentsTable.keywordsColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        }
                }
        }
        
        public void
        saveColumnsVisibleState() {
                InstrumentsDbTableModel m = getModel();
                
                String s = "DbInstrumentsTable.ShowSizeColumn";
                preferences().setBoolProperty(s, m.getShowSizeColumn());
                s = "DbInstrumentsTable.ShowFormatFamilyColumn";
                preferences().setBoolProperty(s, m.getShowFormatFamilyColumn());
                s = "DbInstrumentsTable.ShowFormatVersionColumn";
                preferences().setBoolProperty(s, m.getShowFormatVersionColumn());
                s = "DbInstrumentsTable.ShowIsDrumColumn";
                preferences().setBoolProperty(s, m.getShowIsDrumColumn());
                s = "DbInstrumentsTable.ShowCreatedColumn";
                preferences().setBoolProperty(s, m.getShowCreatedColumn());
                s = "DbInstrumentsTable.ShowModifiedColumn";
                preferences().setBoolProperty(s, m.getShowModifiedColumn());
                s = "DbInstrumentsTable.ShowProductColumn";
                preferences().setBoolProperty(s, m.getShowProductColumn());
                s = "DbInstrumentsTable.ShowArtistsColumn";
                preferences().setBoolProperty(s, m.getShowArtistsColumn());
                s = "DbInstrumentsTable.ShowInstrumentFileColumn";
                preferences().setBoolProperty(s, m.getShowInstrumentFileColumn());
                s = "DbInstrumentsTable.ShowInstrumentNrColumn";
                preferences().setBoolProperty(s, m.getShowInstrumentNrColumn());
                s = "DbInstrumentsTable.ShowKeywordsColumn";
                preferences().setBoolProperty(s, m.getShowKeywordsColumn());
        }
        
        /*public void
        columnMarginChanged(ChangeEvent e) {
                if(isEditing()) removeEditor();
                TableColumn resizingColumn = null;
                if(getTableHeader() != null) resizingColumn = getTableHeader().getResizingColumn();
                if (resizingColumn != null && autoResizeMode == AUTO_RESIZE_OFF) {
                        resizingColumn.setPreferredWidth(resizingColumn.getWidth());
                }
                setAutoResizeMode();
                resizeAndRepaint();
        }
        
        public boolean
        getScrollableTracksViewportWidth() {
                return getPreferredSize().width < getParent().getWidth();
        }
        
        private void
        setAutoResizeMode() {
                Container c = getParent();
                if (!(c instanceof JViewport)) return;
                
                JViewport vp = (JViewport)c;
                int w = vp.getWidth();
                TableColumn dummy = getColumnModel().getColumn(getModel().getDummyColumnIndex());
                int i = w - (getColumnModel().getTotalColumnWidth() - dummy.getWidth());
                if(i > 5) {
                        if(getAutoResizeMode() != AUTO_RESIZE_LAST_COLUMN)
                                setAutoResizeMode(AUTO_RESIZE_LAST_COLUMN);
                } else {
                        if(getAutoResizeMode() != AUTO_RESIZE_OFF)
                                setAutoResizeMode(AUTO_RESIZE_OFF);
                }
        }*/
        
        private class InstrumentsDbTableRowSorter extends TableRowSorter<InstrumentsDbTableModel> {
                InstrumentsDbTableRowSorter(InstrumentsDbTableModel model) {
                        super(model);
                }
                
                public Comparator<?>
                getComparator(int column) {
                        Comparator c = getModel().getComparator(column);
                        if(c != null) return c;
                        
                        return super.getComparator(column);
                }
                
                protected boolean
                useToString(int column) {
                        return getModel().getComparator(column) == null;
                }
                
                public boolean
                isSortable(int column) {
                        return getModel().isSortable(column);
                }
        }
        
        private final EventHandler eventHandler = new EventHandler();
        
        private EventHandler
        getHandler() { return eventHandler; }
        
        private class EventHandler extends InstrumentsDbAdapter {
                
                /**
                 * Invoked when the number of instrument
                 * directories in a specific directory has changed.
                 */
                public void
                directoryCountChanged(InstrumentsDbEvent e) {
                        String rd = getModel().getRenamedDirectory();
                        int idx = getModel().getDirectoryRowIndex(rd);
                        if(idx != -1) {
                                setSelectedDirectory(rd);
                                getModel().setRenamedDirectory(null);
                        }
                        
                        idx = getModel().getDirectoryRowIndex(getCreatedDirectoryName());
                        if(idx != -1) {
                                idx = convertRowIndexToView(idx);
                                if(idx != -1) {
                                        getSelectionModel().setSelectionInterval(idx, idx);
                                        editCellAt(idx, 0);
                                        Component c = nameEditor.getComponent();
                                        if(c instanceof JTextField) ((JTextField)c).selectAll();
                                        setCreatedDirectoryName(null);
                                }
                        }
                }
                
                /**
                 * Invoked when the number of instruments
                 * in a specific directory has changed.
                 */
                public void
                instrumentCountChanged(InstrumentsDbEvent e) {
                        String ri = getModel().getRenamedInstrument();
                        int idx = getModel().getInstrumentRowIndex(ri);
                        if(idx != -1) {
                                setSelectedInstrument(ri);
                                getModel().setRenamedInstrument(null);
                        }
                }
        }
}
1	/*
2	* JSampler - a java front-end for LinuxSampler
3	*
4	* Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
5	*
6	* This file is part of JSampler.
7	*
8	* JSampler is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License version 2
10	* as published by the Free Software Foundation.
11	*
12	* JSampler is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with JSampler; if not, write to the Free Software
19	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20	* MA 02111-1307 USA
21	*/
22
23	package org.jsampler.view;
24
25	import java.awt.Component;
26	import java.awt.Container;
27	import java.awt.Dimension;
28
29	import java.beans.PropertyChangeEvent;
30	import java.beans.PropertyChangeListener;
31
32	import java.util.Comparator;
33	import java.util.Vector;
34
35	import javax.swing.DefaultCellEditor;
36	import javax.swing.JTable;
37	import javax.swing.JTextField;
38	import javax.swing.JViewport;
39
40	import javax.swing.event.ChangeEvent;
41	import javax.swing.event.ListSelectionEvent;
42	import javax.swing.event.TableColumnModelEvent;
43	import javax.swing.event.TableColumnModelListener;
44
45	import javax.swing.table.TableCellEditor;
46	import javax.swing.table.TableColumn;
47	import javax.swing.table.TableColumnModel;
48	import javax.swing.table.TableRowSorter;
49
50	import org.jsampler.CC;
51	import org.jsampler.JSPrefs;
52
53	import org.linuxsampler.lscp.DbDirectoryInfo;
54	import org.linuxsampler.lscp.DbInstrumentInfo;
55
56	import org.linuxsampler.lscp.event.InstrumentsDbAdapter;
57	import org.linuxsampler.lscp.event.InstrumentsDbEvent;
58
59
60	/**
61	*
62	* @author Grigor Iliev
63	*/
64	public abstract class AbstractInstrumentsDbTable extends JTable {
65	private final DefaultCellEditor nameEditor;
66	private final JTextField tfEditor = new JTextField();
67
68	private DbDirectoryTreeNode directoryNode;
69	private final InstrumentsDbTableRowSorter rowSorter;
70
71	private String createdDirectoryName = null;
72
73	private InstrumentsDbTableView view = null;
74
75	/**
76	* Creates a new instance of <code>AbstractInstrumentsDbTable</code>
77	*/
78	public AbstractInstrumentsDbTable() {
79	this(new InstrumentsDbTableModel());
80	}
81
82	/**
83	* Creates a new instance of <code>AbstractInstrumentsDbTable</code>
84	*/
85	public AbstractInstrumentsDbTable(InstrumentsDbTableModel model) {
86	super(model);
87	setView(CC.getViewConfig().getInstrumentsDbTableView());
88
89	String s;
90	InstrumentsDbTableModel m = getModel();
91
92	s = "DbInstrumentsTable.ShowSizeColumn";
93	m.setShowSizeColumn(preferences().getBoolProperty(s));
94	s = "DbInstrumentsTable.ShowFormatFamilyColumn";
95	m.setShowFormatFamilyColumn(preferences().getBoolProperty(s));
96	s = "DbInstrumentsTable.ShowFormatVersionColumn";
97	m.setShowFormatVersionColumn(preferences().getBoolProperty(s));
98	s = "DbInstrumentsTable.ShowIsDrumColumn";
99	m.setShowIsDrumColumn(preferences().getBoolProperty(s));
100	s = "DbInstrumentsTable.ShowCreatedColumn";
101	m.setShowCreatedColumn(preferences().getBoolProperty(s));
102	s = "DbInstrumentsTable.ShowModifiedColumn";
103	m.setShowModifiedColumn(preferences().getBoolProperty(s));
104	s = "DbInstrumentsTable.ShowProductColumn";
105	m.setShowProductColumn(preferences().getBoolProperty(s));
106	s = "DbInstrumentsTable.ShowArtistsColumn";
107	m.setShowArtistsColumn(preferences().getBoolProperty(s));
108	s = "DbInstrumentsTable.ShowInstrumentFileColumn";
109	m.setShowInstrumentFileColumn(preferences().getBoolProperty(s));
110	s = "DbInstrumentsTable.ShowInstrumentNrColumn";
111	m.setShowInstrumentNrColumn(preferences().getBoolProperty(s));
112	s = "DbInstrumentsTable.ShowKeywordsColumn";
113	m.setShowKeywordsColumn(preferences().getBoolProperty(s));
114
115	setAutoResizeMode(AUTO_RESIZE_OFF);
116
117	rowSorter = new InstrumentsDbTableRowSorter(getModel());
118	setRowSorter(rowSorter);
119
120	putClientProperty("JTable.autoStartsEdit", false);
121
122	nameEditor = new DefaultCellEditor(tfEditor);
123	nameEditor.setClickCountToStart(5);
124
125	if(m.getShowDummyColumn()) {
126	TableColumn dummy;
127	dummy = getColumnModel().getColumn(getModel().getDummyColumnIndex());
128	dummy.setPreferredWidth(10);
129	}
130	}
131
132	public InstrumentsDbTableModel
133	getModel() { return (InstrumentsDbTableModel)super.getModel(); }
134
135	public TableCellEditor
136	getCellEditor(int row, int column) {
137	if(column == 0) return nameEditor;
138	return super.getCellEditor(row, column);
139	}
140
141	public DbDirectoryTreeNode
142	getSelectedDirectoryNode() {
143	int idx = getSelectedRow();
144	if(idx == -1) return null;
145	idx = convertRowIndexToModel(idx);
146	return getModel().getDirectoryNode(idx);
147	}
148
149	/**
150	* Selects the specified directory.
151	* The current selection is not altered if missing directory is specified.
152	* @param dir The name of the directory to select.
153	*/
154	public void
155	setSelectedDirectory(String dir) {
156	int i = getModel().getDirectoryRowIndex(dir);
157	if(i == -1) return;
158	i = convertRowIndexToView(i);
159	if(i == -1) return;
160
161	getSelectionModel().setSelectionInterval(i, i);
162	}
163
164	/**
165	* Selects the specified instrument.
166	* The current selection is not altered if missing instrument is specified.
167	* @param instr The name of the instrument to select.
168	*/
169	public void
170	setSelectedInstrument(String instr) {
171	int i = getModel().getInstrumentRowIndex(instr);
172	if(i == -1) return;
173	i = convertRowIndexToView(i);
174	if(i == -1) return;
175	getSelectionModel().setSelectionInterval(i, i);
176	}
177
178	/**
179	* Gets all selected directories.
180	*/
181	public DbDirectoryInfo[]
182	getSelectedDirectories() {
183	int[] rows = getSelectedRows();
184	if(rows.length == 0) return new DbDirectoryInfo[0];
185
186	DbDirectoryTreeNode dir;
187	Vector<DbDirectoryInfo> v = new Vector<DbDirectoryInfo>();
188	for(int i : rows) {
189	dir = getModel().getDirectoryNode(convertRowIndexToModel(i));
190	if(dir != null) v.add(dir.getInfo());
191	}
192
193	return v.toArray(new DbDirectoryInfo[v.size()]);
194	}
195
196	/**
197	* Gets all selected instruments.
198	*/
199	public DbInstrumentInfo[]
200	getSelectedInstruments() {
201	int[] rows = getSelectedRows();
202	if(rows.length == 0) return new DbInstrumentInfo[0];
203
204	DbInstrumentInfo instr;
205	Vector<DbInstrumentInfo> v = new Vector<DbInstrumentInfo>();
206	for(int i : rows) {
207	instr = getModel().getInstrument(convertRowIndexToModel(i));
208	if(instr != null) v.add(instr);
209	}
210
211	return v.toArray(new DbInstrumentInfo[v.size()]);
212	}
213
214	public boolean
215	editCellAt(int row, int column) {
216	if(!super.editCellAt(row, column)) return false;
217
218	Component c = getEditorComponent();
219	if(c != null) c.requestFocusInWindow();
220
221	return true;
222	}
223
224	/**
225	* Gets the directory node, which
226	* content is represented by this table.
227	*/
228	public DbDirectoryTreeNode
229	getParentDirectoryNode() { return directoryNode; }
230
231	/**
232	* Sets the directory node, which
233	* content will be represented by this table.
234	*/
235	public void
236	setParentDirectoryNode(DbDirectoryTreeNode node) {
237	getModel().setParentDirectoryNode(node);
238
239	if(directoryNode != null) directoryNode.removeInstrumentsDbListener(getHandler());
240	directoryNode = node;
241	if(directoryNode != null) directoryNode.addInstrumentsDbListener(getHandler());
242	}
243
244	/**
245	* Gets the name of the directory created by this frontend.
246	* This method is used to determine the directories created
247	* by this frontend.
248	* @return The name of the directory created by this frontend.
249	*/
250	public String
251	getCreatedDirectoryName() { return createdDirectoryName; }
252
253	/**
254	* Sets the name of the created by this frontend.
255	* @param name The name of the directory created by this frontend.
256	*/
257	public void
258	setCreatedDirectoryName(String name) { createdDirectoryName = name; }
259
260	public Object
261	getLeadObject() {
262	if(getSelectionModel().isSelectionEmpty()) return null;
263	int idx = getSelectionModel().getLeadSelectionIndex();
264	if(idx < 0) return null;
265	idx = this.convertRowIndexToModel(idx);
266
267	return getModel().getValueAt(idx, 0);
268	}
269
270	/** Sets the view to be used for retrieving UI information. */
271	public void
272	setView(InstrumentsDbTableView view) {
273	this.view = view;
274	}
275
276	/** Gets the view used to retrieve UI information. */
277	public InstrumentsDbTableView
278	getView() { return view; }
279
280	private JSPrefs
281	preferences() { return CC.getViewConfig().preferences(); }
282
283	public void
284	loadColumnWidths() {
285	loadColumnWidths("");
286	}
287
288	public void
289	loadColumnWidths(String prefix) {
290	InstrumentsDbTableModel m = getModel();
291	TableColumnModel tcm = getColumnModel();
292
293	for(int i = 0; i < m.getColumnCount(); i++) {
294	switch(m.getColumnType(i)) {
295	case NAME:
296	String s = prefix + "DbInstrumentsTable.nameColumnWidth";
297	int w = preferences().getIntProperty(s);
298	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
299	break;
300	case SIZE:
301	s = prefix + "DbInstrumentsTable.sizeColumnWidth";
302	w = preferences().getIntProperty(s);
303	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
304	break;
305	case FORMAT_FAMILY:
306	s = prefix + "DbInstrumentsTable.formatFamilyColumnWidth";
307	w = preferences().getIntProperty(s);
308	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
309	break;
310	case FORMAT_VERSION:
311	s = prefix + "DbInstrumentsTable.formatVersionColumnWidth";
312	w = preferences().getIntProperty(s);
313	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
314	break;
315	case IS_DRUM:
316	s = prefix + "DbInstrumentsTable.isDrumColumnWidth";
317	w = preferences().getIntProperty(s);
318	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
319	break;
320	case CREATED:
321	s = prefix + "DbInstrumentsTable.createdColumnWidth";
322	w = preferences().getIntProperty(s);
323	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
324	break;
325	case MODIFIED:
326	s = prefix + "DbInstrumentsTable.modifiedColumnWidth";
327	w = preferences().getIntProperty(s);
328	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
329	break;
330	case PRODUCT:
331	s = prefix + "DbInstrumentsTable.productColumnWidth";
332	w = preferences().getIntProperty(s);
333	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
334	break;
335	case ARTISTS:
336	s = prefix + "DbInstrumentsTable.artistsColumnWidth";
337	w = preferences().getIntProperty(s);
338	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
339	break;
340	case INSTRUMENT_FILE:
341	s = prefix + "DbInstrumentsTable.instrumentFileColumnWidth";
342	w = preferences().getIntProperty(s);
343	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
344	break;
345	case INSTRUMENT_NR:
346	s = prefix + "DbInstrumentsTable.instrumentNrColumnWidth";
347	w = preferences().getIntProperty(s);
348	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
349	break;
350	case KEYWORDS:
351	s = prefix + "DbInstrumentsTable.keywordsColumnWidth";
352	w = preferences().getIntProperty(s);
353	if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
354	break;
355	case DUMMY:
356	tcm.getColumn(i).setPreferredWidth(10);
357	break;
358	}
359	}
360	}
361
362	public void
363	saveColumnWidths() {
364	saveColumnWidths("");
365	}
366
367	public void
368	saveColumnWidths(String prefix) {
369	InstrumentsDbTableModel m = getModel();
370	TableColumnModel tcm = getColumnModel();
371
372	for(int i = 0; i < m.getColumnCount(); i++) {
373	switch(m.getColumnType(i)) {
374	case NAME:
375	String s = prefix + "DbInstrumentsTable.nameColumnWidth";
376	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
377	break;
378	case SIZE:
379	s = prefix + "DbInstrumentsTable.sizeColumnWidth";
380	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
381	break;
382	case FORMAT_FAMILY:
383	s = prefix + "DbInstrumentsTable.formatFamilyColumnWidth";
384	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
385	break;
386	case FORMAT_VERSION:
387	s = prefix + "DbInstrumentsTable.formatVersionColumnWidth";
388	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
389	break;
390	case IS_DRUM:
391	s = prefix + "DbInstrumentsTable.isDrumColumnWidth";
392	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
393	break;
394	case CREATED:
395	s = prefix + "DbInstrumentsTable.createdColumnWidth";
396	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
397	break;
398	case MODIFIED:
399	s = prefix + "DbInstrumentsTable.modifiedColumnWidth";
400	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
401	break;
402	case PRODUCT:
403	s = prefix + "DbInstrumentsTable.productColumnWidth";
404	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
405	break;
406	case ARTISTS:
407	s = prefix + "DbInstrumentsTable.artistsColumnWidth";
408	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
409	break;
410	case INSTRUMENT_FILE:
411	s = prefix + "DbInstrumentsTable.instrumentFileColumnWidth";
412	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
413	break;
414	case INSTRUMENT_NR:
415	s = prefix + "DbInstrumentsTable.instrumentNrColumnWidth";
416	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
417	break;
418	case KEYWORDS:
419	s = prefix + "DbInstrumentsTable.keywordsColumnWidth";
420	preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
421	break;
422	}
423	}
424	}
425
426	public void
427	saveColumnsVisibleState() {
428	InstrumentsDbTableModel m = getModel();
429
430	String s = "DbInstrumentsTable.ShowSizeColumn";
431	preferences().setBoolProperty(s, m.getShowSizeColumn());
432	s = "DbInstrumentsTable.ShowFormatFamilyColumn";
433	preferences().setBoolProperty(s, m.getShowFormatFamilyColumn());
434	s = "DbInstrumentsTable.ShowFormatVersionColumn";
435	preferences().setBoolProperty(s, m.getShowFormatVersionColumn());
436	s = "DbInstrumentsTable.ShowIsDrumColumn";
437	preferences().setBoolProperty(s, m.getShowIsDrumColumn());
438	s = "DbInstrumentsTable.ShowCreatedColumn";
439	preferences().setBoolProperty(s, m.getShowCreatedColumn());
440	s = "DbInstrumentsTable.ShowModifiedColumn";
441	preferences().setBoolProperty(s, m.getShowModifiedColumn());
442	s = "DbInstrumentsTable.ShowProductColumn";
443	preferences().setBoolProperty(s, m.getShowProductColumn());
444	s = "DbInstrumentsTable.ShowArtistsColumn";
445	preferences().setBoolProperty(s, m.getShowArtistsColumn());
446	s = "DbInstrumentsTable.ShowInstrumentFileColumn";
447	preferences().setBoolProperty(s, m.getShowInstrumentFileColumn());
448	s = "DbInstrumentsTable.ShowInstrumentNrColumn";
449	preferences().setBoolProperty(s, m.getShowInstrumentNrColumn());
450	s = "DbInstrumentsTable.ShowKeywordsColumn";
451	preferences().setBoolProperty(s, m.getShowKeywordsColumn());
452	}
453
454	/*public void
455	columnMarginChanged(ChangeEvent e) {
456	if(isEditing()) removeEditor();
457	TableColumn resizingColumn = null;
458	if(getTableHeader() != null) resizingColumn = getTableHeader().getResizingColumn();
459	if (resizingColumn != null && autoResizeMode == AUTO_RESIZE_OFF) {
460	resizingColumn.setPreferredWidth(resizingColumn.getWidth());
461	}
462	setAutoResizeMode();
463	resizeAndRepaint();
464	}
465
466	public boolean
467	getScrollableTracksViewportWidth() {
468	return getPreferredSize().width < getParent().getWidth();
469	}
470
471	private void
472	setAutoResizeMode() {
473	Container c = getParent();
474	if (!(c instanceof JViewport)) return;
475
476	JViewport vp = (JViewport)c;
477	int w = vp.getWidth();
478	TableColumn dummy = getColumnModel().getColumn(getModel().getDummyColumnIndex());
479	int i = w - (getColumnModel().getTotalColumnWidth() - dummy.getWidth());
480	if(i > 5) {
481	if(getAutoResizeMode() != AUTO_RESIZE_LAST_COLUMN)
482	setAutoResizeMode(AUTO_RESIZE_LAST_COLUMN);
483	} else {
484	if(getAutoResizeMode() != AUTO_RESIZE_OFF)
485	setAutoResizeMode(AUTO_RESIZE_OFF);
486	}
487	}*/
488
489	private class InstrumentsDbTableRowSorter extends TableRowSorter<InstrumentsDbTableModel> {
490	InstrumentsDbTableRowSorter(InstrumentsDbTableModel model) {
491	super(model);
492	}
493
494	public Comparator<?>
495	getComparator(int column) {
496	Comparator c = getModel().getComparator(column);
497	if(c != null) return c;
498
499	return super.getComparator(column);
500	}
501
502	protected boolean
503	useToString(int column) {
504	return getModel().getComparator(column) == null;
505	}
506
507	public boolean
508	isSortable(int column) {
509	return getModel().isSortable(column);
510	}
511	}
512
513	private final EventHandler eventHandler = new EventHandler();
514
515	private EventHandler
516	getHandler() { return eventHandler; }
517
518	private class EventHandler extends InstrumentsDbAdapter {
519
520	/**
521	* Invoked when the number of instrument
522	* directories in a specific directory has changed.
523	*/
524	public void
525	directoryCountChanged(InstrumentsDbEvent e) {
526	String rd = getModel().getRenamedDirectory();
527	int idx = getModel().getDirectoryRowIndex(rd);
528	if(idx != -1) {
529	setSelectedDirectory(rd);
530	getModel().setRenamedDirectory(null);
531	}
532
533	idx = getModel().getDirectoryRowIndex(getCreatedDirectoryName());
534	if(idx != -1) {
535	idx = convertRowIndexToView(idx);
536	if(idx != -1) {
537	getSelectionModel().setSelectionInterval(idx, idx);
538	editCellAt(idx, 0);
539	Component c = nameEditor.getComponent();
540	if(c instanceof JTextField) ((JTextField)c).selectAll();
541	setCreatedDirectoryName(null);
542	}
543	}
544	}
545
546	/**
547	* Invoked when the number of instruments
548	* in a specific directory has changed.
549	*/
550	public void
551	instrumentCountChanged(InstrumentsDbEvent e) {
552	String ri = getModel().getRenamedInstrument();
553	int idx = getModel().getInstrumentRowIndex(ri);
554	if(idx != -1) {
555	setSelectedInstrument(ri);
556	getModel().setRenamedInstrument(null);
557	}
558	}
559	}
560	}