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() {
                InstrumentsDbTableModel m = getModel();
                TableColumnModel tcm = getColumnModel();
                
                for(int i = 0; i < m.getColumnCount(); i++) {
                        switch(m.getColumnType(i)) {
                        case NAME:
                                String s = "DbInstrumentsTable.nameColumnWidth";
                                int w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case SIZE:
                                s = "DbInstrumentsTable.sizeColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case FORMAT_FAMILY:
                                s = "DbInstrumentsTable.formatFamilyColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case FORMAT_VERSION:
                                s = "DbInstrumentsTable.formatVersionColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case IS_DRUM:
                                s = "DbInstrumentsTable.isDrumColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case CREATED:
                                s = "DbInstrumentsTable.createdColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case MODIFIED:
                                s = "DbInstrumentsTable.modifiedColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case PRODUCT:
                                s = "DbInstrumentsTable.productColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case ARTISTS:
                                s = "DbInstrumentsTable.artistsColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case INSTRUMENT_FILE:
                                s = "DbInstrumentsTable.instrumentFileColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case INSTRUMENT_NR:
                                s = "DbInstrumentsTable.instrumentNrColumnWidth";
                                w = preferences().getIntProperty(s);
                                if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
                                break;
                        case KEYWORDS:
                                s = "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() {
                InstrumentsDbTableModel m = getModel();
                TableColumnModel tcm = getColumnModel();
                
                for(int i = 0; i < m.getColumnCount(); i++) {
                        switch(m.getColumnType(i)) {
                        case NAME:
                                String s = "DbInstrumentsTable.nameColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case SIZE:
                                s = "DbInstrumentsTable.sizeColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case FORMAT_FAMILY:
                                s = "DbInstrumentsTable.formatFamilyColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case FORMAT_VERSION:
                                s = "DbInstrumentsTable.formatVersionColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case IS_DRUM:
                                s = "DbInstrumentsTable.isDrumColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case CREATED:
                                s = "DbInstrumentsTable.createdColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case MODIFIED:
                                s = "DbInstrumentsTable.modifiedColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case PRODUCT:
                                s = "DbInstrumentsTable.productColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case ARTISTS:
                                s = "DbInstrumentsTable.artistsColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case INSTRUMENT_FILE:
                                s = "DbInstrumentsTable.instrumentFileColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case INSTRUMENT_NR:
                                s = "DbInstrumentsTable.instrumentNrColumnWidth";
                                preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
                                break;
                        case KEYWORDS:
                                s = "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	iliev	1204	/*
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	iliev	1285	import javax.swing.table.TableColumnModel;
48	iliev	1204	import javax.swing.table.TableRowSorter;
49
50	iliev	1285	import org.jsampler.CC;
51			import org.jsampler.JSPrefs;
52
53	iliev	1204	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	iliev	1285	private InstrumentsDbTableView view = null;
74
75	iliev	1204	/**
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	iliev	1285	setView(CC.getViewConfig().getInstrumentsDbTableView());
88	iliev	1204
89	iliev	1285	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	iliev	1204	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	iliev	1285
125			if(m.getShowDummyColumn()) {
126			TableColumn dummy;
127			dummy = getColumnModel().getColumn(getModel().getDummyColumnIndex());
128			dummy.setPreferredWidth(10);
129			}
130	iliev	1204	}
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	iliev	1285	/** 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			InstrumentsDbTableModel m = getModel();
286			TableColumnModel tcm = getColumnModel();
287
288			for(int i = 0; i < m.getColumnCount(); i++) {
289			switch(m.getColumnType(i)) {
290			case NAME:
291			String s = "DbInstrumentsTable.nameColumnWidth";
292			int w = preferences().getIntProperty(s);
293			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
294			break;
295			case SIZE:
296			s = "DbInstrumentsTable.sizeColumnWidth";
297			w = preferences().getIntProperty(s);
298			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
299			break;
300			case FORMAT_FAMILY:
301			s = "DbInstrumentsTable.formatFamilyColumnWidth";
302			w = preferences().getIntProperty(s);
303			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
304			break;
305			case FORMAT_VERSION:
306			s = "DbInstrumentsTable.formatVersionColumnWidth";
307			w = preferences().getIntProperty(s);
308			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
309			break;
310			case IS_DRUM:
311			s = "DbInstrumentsTable.isDrumColumnWidth";
312			w = preferences().getIntProperty(s);
313			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
314			break;
315			case CREATED:
316			s = "DbInstrumentsTable.createdColumnWidth";
317			w = preferences().getIntProperty(s);
318			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
319			break;
320			case MODIFIED:
321			s = "DbInstrumentsTable.modifiedColumnWidth";
322			w = preferences().getIntProperty(s);
323			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
324			break;
325			case PRODUCT:
326			s = "DbInstrumentsTable.productColumnWidth";
327			w = preferences().getIntProperty(s);
328			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
329			break;
330			case ARTISTS:
331			s = "DbInstrumentsTable.artistsColumnWidth";
332			w = preferences().getIntProperty(s);
333			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
334			break;
335			case INSTRUMENT_FILE:
336			s = "DbInstrumentsTable.instrumentFileColumnWidth";
337			w = preferences().getIntProperty(s);
338			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
339			break;
340			case INSTRUMENT_NR:
341			s = "DbInstrumentsTable.instrumentNrColumnWidth";
342			w = preferences().getIntProperty(s);
343			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
344			break;
345			case KEYWORDS:
346			s = "DbInstrumentsTable.keywordsColumnWidth";
347			w = preferences().getIntProperty(s);
348			if(w > 0) tcm.getColumn(i).setPreferredWidth(w);
349			break;
350			case DUMMY:
351			tcm.getColumn(i).setPreferredWidth(10);
352			break;
353			}
354			}
355			}
356
357			public void
358			saveColumnWidths() {
359			InstrumentsDbTableModel m = getModel();
360			TableColumnModel tcm = getColumnModel();
361
362			for(int i = 0; i < m.getColumnCount(); i++) {
363			switch(m.getColumnType(i)) {
364			case NAME:
365			String s = "DbInstrumentsTable.nameColumnWidth";
366			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
367			break;
368			case SIZE:
369			s = "DbInstrumentsTable.sizeColumnWidth";
370			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
371			break;
372			case FORMAT_FAMILY:
373			s = "DbInstrumentsTable.formatFamilyColumnWidth";
374			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
375			break;
376			case FORMAT_VERSION:
377			s = "DbInstrumentsTable.formatVersionColumnWidth";
378			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
379			break;
380			case IS_DRUM:
381			s = "DbInstrumentsTable.isDrumColumnWidth";
382			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
383			break;
384			case CREATED:
385			s = "DbInstrumentsTable.createdColumnWidth";
386			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
387			break;
388			case MODIFIED:
389			s = "DbInstrumentsTable.modifiedColumnWidth";
390			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
391			break;
392			case PRODUCT:
393			s = "DbInstrumentsTable.productColumnWidth";
394			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
395			break;
396			case ARTISTS:
397			s = "DbInstrumentsTable.artistsColumnWidth";
398			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
399			break;
400			case INSTRUMENT_FILE:
401			s = "DbInstrumentsTable.instrumentFileColumnWidth";
402			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
403			break;
404			case INSTRUMENT_NR:
405			s = "DbInstrumentsTable.instrumentNrColumnWidth";
406			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
407			break;
408			case KEYWORDS:
409			s = "DbInstrumentsTable.keywordsColumnWidth";
410			preferences().setIntProperty(s, tcm.getColumn(i).getWidth());
411			break;
412
413			}
414			}
415			}
416
417			public void
418			saveColumnsVisibleState() {
419			InstrumentsDbTableModel m = getModel();
420
421			String s = "DbInstrumentsTable.ShowSizeColumn";
422			preferences().setBoolProperty(s, m.getShowSizeColumn());
423			s = "DbInstrumentsTable.ShowFormatFamilyColumn";
424			preferences().setBoolProperty(s, m.getShowFormatFamilyColumn());
425			s = "DbInstrumentsTable.ShowFormatVersionColumn";
426			preferences().setBoolProperty(s, m.getShowFormatVersionColumn());
427			s = "DbInstrumentsTable.ShowIsDrumColumn";
428			preferences().setBoolProperty(s, m.getShowIsDrumColumn());
429			s = "DbInstrumentsTable.ShowCreatedColumn";
430			preferences().setBoolProperty(s, m.getShowCreatedColumn());
431			s = "DbInstrumentsTable.ShowModifiedColumn";
432			preferences().setBoolProperty(s, m.getShowModifiedColumn());
433			s = "DbInstrumentsTable.ShowProductColumn";
434			preferences().setBoolProperty(s, m.getShowProductColumn());
435			s = "DbInstrumentsTable.ShowArtistsColumn";
436			preferences().setBoolProperty(s, m.getShowArtistsColumn());
437			s = "DbInstrumentsTable.ShowInstrumentFileColumn";
438			preferences().setBoolProperty(s, m.getShowInstrumentFileColumn());
439			s = "DbInstrumentsTable.ShowInstrumentNrColumn";
440			preferences().setBoolProperty(s, m.getShowInstrumentNrColumn());
441			s = "DbInstrumentsTable.ShowKeywordsColumn";
442			preferences().setBoolProperty(s, m.getShowKeywordsColumn());
443			}
444
445	iliev	1204	/*public void
446			columnMarginChanged(ChangeEvent e) {
447			if(isEditing()) removeEditor();
448			TableColumn resizingColumn = null;
449			if(getTableHeader() != null) resizingColumn = getTableHeader().getResizingColumn();
450			if (resizingColumn != null && autoResizeMode == AUTO_RESIZE_OFF) {
451			resizingColumn.setPreferredWidth(resizingColumn.getWidth());
452			}
453			setAutoResizeMode();
454			resizeAndRepaint();
455			}
456
457			public boolean
458			getScrollableTracksViewportWidth() {
459			return getPreferredSize().width < getParent().getWidth();
460			}
461
462			private void
463			setAutoResizeMode() {
464			Container c = getParent();
465			if (!(c instanceof JViewport)) return;
466
467			JViewport vp = (JViewport)c;
468			int w = vp.getWidth();
469			TableColumn dummy = getColumnModel().getColumn(getModel().getDummyColumnIndex());
470			int i = w - (getColumnModel().getTotalColumnWidth() - dummy.getWidth());
471			if(i > 5) {
472			if(getAutoResizeMode() != AUTO_RESIZE_LAST_COLUMN)
473			setAutoResizeMode(AUTO_RESIZE_LAST_COLUMN);
474			} else {
475			if(getAutoResizeMode() != AUTO_RESIZE_OFF)
476			setAutoResizeMode(AUTO_RESIZE_OFF);
477			}
478			}*/
479
480			private class InstrumentsDbTableRowSorter extends TableRowSorter<InstrumentsDbTableModel> {
481			InstrumentsDbTableRowSorter(InstrumentsDbTableModel model) {
482			super(model);
483			}
484
485			public Comparator<?>
486			getComparator(int column) {
487			Comparator c = getModel().getComparator(column);
488			if(c != null) return c;
489
490			return super.getComparator(column);
491			}
492
493			protected boolean
494			useToString(int column) {
495			return getModel().getComparator(column) == null;
496			}
497
498			public boolean
499			isSortable(int column) {
500			return getModel().isSortable(column);
501			}
502			}
503
504			private final EventHandler eventHandler = new EventHandler();
505
506			private EventHandler
507			getHandler() { return eventHandler; }
508
509			private class EventHandler extends InstrumentsDbAdapter {
510
511			/**
512			* Invoked when the number of instrument
513			* directories in a specific directory has changed.
514			*/
515			public void
516			directoryCountChanged(InstrumentsDbEvent e) {
517			String rd = getModel().getRenamedDirectory();
518			int idx = getModel().getDirectoryRowIndex(rd);
519			if(idx != -1) {
520			setSelectedDirectory(rd);
521			getModel().setRenamedDirectory(null);
522			}
523
524			idx = getModel().getDirectoryRowIndex(getCreatedDirectoryName());
525			if(idx != -1) {
526			idx = convertRowIndexToView(idx);
527			if(idx != -1) {
528			getSelectionModel().setSelectionInterval(idx, idx);
529			editCellAt(idx, 0);
530			Component c = nameEditor.getComponent();
531			if(c instanceof JTextField) ((JTextField)c).selectAll();
532			setCreatedDirectoryName(null);
533			}
534			}
535			}
536
537			/**
538			* Invoked when the number of instruments
539			* in a specific directory has changed.
540			*/
541			public void
542			instrumentCountChanged(InstrumentsDbEvent e) {
543			String ri = getModel().getRenamedInstrument();
544			int idx = getModel().getInstrumentRowIndex(ri);
545			if(idx != -1) {
546			setSelectedInstrument(ri);
547			getModel().setRenamedInstrument(null);
548			}
549			}
550			}
551			}