jsampler/view/ParameterTableModel.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.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;

import java.util.Vector;

import javax.swing.AbstractCellEditor;
import javax.swing.BorderFactory;
import javax.swing.DefaultCellEditor;
import javax.swing.JButton;
import javax.swing.JCheckBox;
import javax.swing.JCheckBoxMenuItem;
import javax.swing.JComboBox;
import javax.swing.JMenu;
import javax.swing.JMenuItem;
import javax.swing.JPopupMenu;
import javax.swing.JTable;
import javax.swing.SpinnerNumberModel;
import javax.swing.UIManager;

import javax.swing.border.Border;

import javax.swing.event.PopupMenuEvent;
import javax.swing.event.PopupMenuListener;

import javax.swing.table.AbstractTableModel;
import javax.swing.table.DefaultTableCellRenderer;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableCellEditor;

import org.jsampler.event.ParameterEvent;
import org.jsampler.event.ParameterListener;

import org.linuxsampler.lscp.Parameter;
import org.linuxsampler.lscp.ParameterType;
import org.linuxsampler.lscp.StringListParameter;


/**
 * A tabular data model for representing LSCP parameters.
 * @see ParameterTable
 * @author Grigor Iliev
 */
public class ParameterTableModel extends AbstractTableModel {
        public final static int PARAMETER_NAME_COLUMN = 0;
        public final static int PARAMETER_VALUE_COLUMN = 1;
        
        private Parameter[] parameters;
        
        private final BooleanCellRenderer booleanRenderer = new BooleanCellRenderer();
        private final BooleanCellEditor booleanEditor = new BooleanCellEditor();
        
        private final IntegerCellRenderer integerRenderer = new IntegerCellRenderer();
        private final IntegerCellEditor integerEditor = new IntegerCellEditor();
        
        private final FloatCellRenderer floatRenderer = new FloatCellRenderer();
        private final FloatCellEditor floatEditor = new FloatCellEditor();
        
        private final StringListCellRenderer stringListRenderer = new StringListCellRenderer();
        private final StringListCellEditor stringListEditor = new StringListCellEditor();
        
        private boolean editFixedParameters;
        
        
        /**
         * Creates a new instance of <code>ParameterTableModel</code>.
         * @param parameters The parameters to be provided by this model.
         */
        public
        ParameterTableModel(Parameter[] parameters) {
                this(parameters, false);
        }
        
        /**
         * Creates a new instance of <code>ParameterTableModel</code>.
         * @param parameters The parameters to be provided by this model.
         * @param editFixedParameters Determines whether fixed parameters are editable.
         * Specify <code>true</code> to enable the editing of fixed parameters.
         */
        public
        ParameterTableModel(Parameter[] parameters, boolean editFixedParameters) {
                setParameters(parameters);
                setEditFixedParameters(editFixedParameters);
        }
        
        private final Vector<ParameterListener> parameterListeners =
                new Vector<ParameterListener>();
        
        /**
         * Registers the specified listener for receiving event messages.
         * @param l The <code>ParameterListener</code> to register.
         */
        public void
        addParameterListener(ParameterListener l) { parameterListeners.add(l); }
        
        /**
         * Removes the specified listener.
         * @param l The <code>ParameterListener</code> to remove.
         */
        public void
        removeParameterListener(ParameterListener l) { parameterListeners.remove(l); }
        
        /**
         * Sets whether fixed parameters are editable.
         * @param b Specify <code>true</code> to enable the editing of fixed parameters.
         * @see org.linuxsampler.lscp.Parameter#isFixed
         */
        public void
        setEditFixedParameters(boolean b) { editFixedParameters = b; }
        
        /**
         * Determines whether fixed parameters are editable.
         * @return <code>true</code> if the fixed parameters are
         * editable, <code>false</code> otherwise.
         * @see org.linuxsampler.lscp.Parameter#isFixed
         */
        public boolean
        canEditFixedParameters() { return editFixedParameters; }
        
        /**
         * Gets the parameter at the specified row.
         * @param row The row number of the parameter to be provided.
         * @return The parameter at the specified row.
         */
        public Parameter
        getParameter(int row) { return parameters[row]; }
        
        /**
         * Returns an appropriate renderer for the cell specified by
         * <code>row</code> and <code>column</code>.
         * @param row The row of the cell to render, where 0 is the first row.
         * @param column The column of the cell to render, where 0 is the first column.
         */
        public TableCellRenderer
        getCellRenderer(int row, int column) {
                if(column != PARAMETER_VALUE_COLUMN) return null;
                
                if(parameters[row].getType() == ParameterType.BOOL) return booleanRenderer;
                else if(parameters[row].getType() == ParameterType.INT) return integerRenderer;
                else if(parameters[row].getType() == ParameterType.FLOAT) return floatRenderer;
                else if(parameters[row].getType() == ParameterType.STRING_LIST) {
                        return stringListRenderer;
                }
                
                return null;
        }
        
        /**
         * Returns an appropriate editor for the cell specified by
         * <code>row</code> and <code>column</code>.
         * @param row The row of the cell to edit, where 0 is the first row.
         * @param column The column of the cell to edit, where 0 is the first column.
         */
        public TableCellEditor
        getCellEditor(int row, int column) {
                if(column != PARAMETER_VALUE_COLUMN) return null;
                
                Parameter p = parameters[row];
                if(p.getType() == ParameterType.BOOL) return booleanEditor;
                
                if(p.getType() == ParameterType.BOOL_LIST) {
                        
                } if(p.getType() == ParameterType.FLOAT_LIST) {
                        
                } if(p.getType() == ParameterType.INT_LIST) {
                        
                } if(p.getType() == ParameterType.STRING_LIST) {
                        StringListParameter slp = (StringListParameter)p;
                        if(slp.hasPossibilities()) {
                                return stringListEditor;
                        }
                } else if(p.hasPossibilities()) {
                        return new DefaultCellEditor(new JComboBox(p.getPossibilities()));
                } else if(p.getType() == ParameterType.INT) {
                        Integer i = p.hasRangeMin() ? p.getRangeMin().intValue() : null;
                        integerEditor.setMinimum(i);
                        
                        i = p.hasRangeMax() ? p.getRangeMax().intValue() : null;
                        integerEditor.setMaximum(i);
                        
                        return integerEditor;
                } else if(p.getType() == ParameterType.FLOAT) {
                        Float f = p.hasRangeMin() ? p.getRangeMin().floatValue() : null;
                        floatEditor.setMinimum(f);
                        
                        f = p.hasRangeMax() ? p.getRangeMax().floatValue() : null;
                        floatEditor.setMaximum(f);
                        
                        return floatEditor;
                }
                
                return null;
        }
        
        /** Gets the parameters that are shown in the table. */
        public Parameter[]
        getParameters() { return parameters; }
        
        /**
         * Sets the parameters to be shown in the table.
         * @param parameters The parameters to be shown in the table.
         */
        public void
        setParameters(Parameter[] parameters) {
                this.parameters = parameters;
                fireTableDataChanged();
        }
        
        /**
         * Gets the number of columns in the model.
         * @return The number of columns in the model.
         */
        public int
        getColumnCount() { return 2; }
        
        /**
         * Gets the number of rows in the model.
         * @return The number of rows in the model.
         */
        public int
        getRowCount() { return parameters.length; }
        
        /**
         * Gets the name of the column at <code>columnIndex</code>.
         * @return The name of the column at <code>columnIndex</code>.
         */
        public String
        getColumnName(int col) { return " "; }
        
        /**
         * Gets the value for the cell at <code>columnIndex</code> and
         * <code>rowIndex</code>.
         * @param row The row whose value is to be queried.
         * @param col The column whose value is to be queried.
         * @return The value for the cell at <code>columnIndex</code> and
         * <code>rowIndex</code>.
         */
        public Object
        getValueAt(int row, int col) {
                switch(col) {
                case PARAMETER_NAME_COLUMN:
                        return parameters[row].getName();
                case PARAMETER_VALUE_COLUMN:
                        return parameters[row].getValue();
                }
                
                return null;
        }
        
        /**
         * Sets the value in the cell at <code>col</code>
         * and <code>row</code> to <code>value</code>.
         */
        public void
        setValueAt(Object value, int row, int col) {
                if(col != PARAMETER_VALUE_COLUMN) return;
                
                parameters[row].setValue(value);
                fireTableCellUpdated(row,  col);
                fireParameterChanged(parameters[row]);
        }
        
        /**
         * Returns <code>true</code> if the cell at
         * <code>row</code> and <code>col</code> is editable.
         */
        public boolean
        isCellEditable(int row, int col) {
                switch(col) {
                case PARAMETER_NAME_COLUMN:
                        return false;
                case PARAMETER_VALUE_COLUMN:
                        return canEditFixedParameters() || !parameters[row].isFixed();
                default: return false;
                }
        }
        
        private void
        fireParameterChanged(Parameter p) {
                ParameterEvent e = new ParameterEvent(this, p);
                for(ParameterListener l : parameterListeners) l.parameterChanged(e);
        }
        
        class BooleanCellRenderer extends JCheckBox implements TableCellRenderer {
                private final Border emptyBorder = BorderFactory.createEmptyBorder(1, 1, 1, 1);
                
                BooleanCellRenderer() {
                        setHorizontalAlignment(CENTER);
                        setBorderPainted(true);
                }
                
                public Component
                getTableCellRendererComponent (
                        JTable table,
                        Object value,
                        boolean isSelected,
                        boolean hasFocus,
                        int row,
                        int column
                ) {
                        if (isSelected) {
                                setBackground(table.getSelectionBackground());
                                setForeground(table.getSelectionForeground());
                        } else {
                                setBackground(table.getBackground());
                                setForeground(table.getForeground());
                        }
                        
                        Boolean b = (Boolean) value;
                        setSelected(b != null && b);
                        
                        if(hasFocus) {
                                setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
                        } else { setBorder(emptyBorder); }
                        
                        setToolTipText(parameters[row].getDescription());
                        
                        return this;
                }
        }
        
        class BooleanCellEditor extends DefaultCellEditor {
                BooleanCellEditor() {
                        super(new JCheckBox());
                        JCheckBox cb = (JCheckBox)getComponent();
                        cb.setHorizontalAlignment(JCheckBox.CENTER);
                }
        }
        
        class IntegerCellEditor extends NumberCellEditor {
                
        }
        
        class IntegerCellRenderer extends DefaultTableCellRenderer {
                IntegerCellRenderer() {
                        setHorizontalAlignment(RIGHT);
                }
        }
        
        class FloatCellEditor extends NumberCellEditor {
                FloatCellEditor() {
                        SpinnerNumberModel model = new SpinnerNumberModel(0.0, 0.0, 0.0, 1.0);
                        setModel(model);
                }
        }
        
        class FloatCellRenderer extends DefaultTableCellRenderer {
                FloatCellRenderer() {
                        setHorizontalAlignment(RIGHT);
                }
        }
        
        class StringListCellEditor extends AbstractCellEditor implements TableCellEditor {
                private final JButton editor = new JButton();
                private final JPopupMenu menu = new JPopupMenu();
                private final Vector<JCheckBoxMenuItem> menuItems = new Vector<JCheckBoxMenuItem>();
                
                StringListCellEditor() {
                        editor.setBorderPainted(false);
                        editor.setContentAreaFilled(false);
                        editor.setFocusPainted(false);
                        editor.setMargin(new java.awt.Insets(0, 0, 0, 0));
                        editor.setFont(editor.getFont().deriveFont(java.awt.Font.PLAIN));
                        
                        editor.addActionListener(new ActionListener() {
                                public void
                                actionPerformed(ActionEvent e) { menu.show(editor, 0, 0); } 
                        });
                        
                        menu.addPopupMenuListener(new PopupMenuListener() {
                                public void
                                popupMenuCanceled(PopupMenuEvent e) {
                                        StringListCellEditor.this.cancelCellEditing();
                                }
                                
                                public void
                                popupMenuWillBecomeInvisible(PopupMenuEvent e) { }
                                
                                public void
                                popupMenuWillBecomeVisible(PopupMenuEvent e) { }
                        });
                }
                
                private final Vector<String> strings = new Vector<String>();
                
                public Object
                getCellEditorValue() {
                        strings.removeAllElements();
                        
                        for(JCheckBoxMenuItem i : menuItems) {
                                if(i.isSelected()) strings.add(i.getText());
                        }
                        
                        return strings.toArray(new String[strings.size()]);
                }
                
                private final StringBuffer sb = new StringBuffer();
                
                public Component
                getTableCellEditorComponent (
                        JTable table,
                        Object value,
                        boolean isSelected,
                        int row,
                        int column
                ) {
                        StringListParameter slp = (StringListParameter)parameters[row];
                        String[] poss = slp.getPossibilities()[0];
                        String[] vals = (String[])value;
                        
                        sb.setLength(0);
                        
                        if(vals != null) {
                                if(vals.length > 0) sb.append(vals[0]);
                                
                                for(int i = 1; i < vals.length; i++) {
                                        sb.append(", ").append(vals[i]);
                                }
                        }
                        
                        editor.setText(sb.toString());
                        
                        menu.removeAll();
                        menuItems.removeAllElements();
                        
                        for(String s : poss) {
                                JCheckBoxMenuItem item = new JCheckBoxMenuItem(s);
                                setListener(item);
                                
                                for(String s2 : vals) {
                                        if(s2.equals(s)) item.setSelected(true);
                                }
                                
                                menu.add(item);
                                menuItems.add(item);
                        }
                        
                        return editor;
                }
                
                private void
                setListener(JCheckBoxMenuItem i) {
                        i.addItemListener(new ItemListener() {
                                public void
                                itemStateChanged(ItemEvent e) { 
                                        StringListCellEditor.this.stopCellEditing();
                                }
                        });
                }
        }
        
        /*private static JComboBox comboBox = new JComboBox();
        class StringListCellEditor extends DefaultCellEditor {
                StringListCellEditor() {
                        super(comboBox);
                }
                
                public Object
                getCellEditorValue() {
                        Object o = comboBox.getSelectedItem();
                        if(o == null) return null;
                        String[] sS = new String[1];
                        sS[0] = (String)o;
                        return sS;
                }
                
                public Component
                getTableCellEditorComponent (
                        JTable table,
                        Object value,
                        boolean isSelected,
                        int row,
                        int column
                ) {
                        StringListParameter slp = (StringListParameter)parameters[row];
                        comboBox.removeAllItems();
                        for(String s : slp.getPossibilities()[0]) comboBox.addItem(s);
                        return comboBox;
                }
        }*/
        
        class StringListCellRenderer extends DefaultTableCellRenderer {
                private final StringBuffer sb = new StringBuffer();
                
                public Component
                getTableCellRendererComponent (
                        JTable table,
                        Object value,
                        boolean isSelected,
                        boolean hasFocus,
                        int row,
                        int column
                ) {
                        if(value instanceof String) return super.getTableCellRendererComponent (
                                table, value, isSelected, hasFocus, row, column
                        );
                        
                        String[] s = (String[])value;
                        
                        sb.setLength(0);
                        
                        if(s != null) {
                                if(s.length > 0) sb.append(s[0]);
                                for(int i = 1; i < s.length; i++) sb.append(", ").append(s[i]);
                        }
                        
                        return super.getTableCellRendererComponent (
                                table, sb.toString(), isSelected, hasFocus, row, column
                        );
                }
        }
}
1	iliev	787	/*
2			* JSampler - a java front-end for LinuxSampler
3			*
4	iliev	1327	* Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
5	iliev	787	*
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
27			import java.awt.event.ActionEvent;
28			import java.awt.event.ActionListener;
29			import java.awt.event.ItemEvent;
30			import java.awt.event.ItemListener;
31
32			import java.util.Vector;
33
34			import javax.swing.AbstractCellEditor;
35			import javax.swing.BorderFactory;
36			import javax.swing.DefaultCellEditor;
37			import javax.swing.JButton;
38			import javax.swing.JCheckBox;
39			import javax.swing.JCheckBoxMenuItem;
40			import javax.swing.JComboBox;
41			import javax.swing.JMenu;
42			import javax.swing.JMenuItem;
43			import javax.swing.JPopupMenu;
44			import javax.swing.JTable;
45			import javax.swing.SpinnerNumberModel;
46			import javax.swing.UIManager;
47
48			import javax.swing.border.Border;
49
50			import javax.swing.event.PopupMenuEvent;
51			import javax.swing.event.PopupMenuListener;
52
53			import javax.swing.table.AbstractTableModel;
54			import javax.swing.table.DefaultTableCellRenderer;
55			import javax.swing.table.TableCellRenderer;
56			import javax.swing.table.TableCellEditor;
57
58			import org.jsampler.event.ParameterEvent;
59			import org.jsampler.event.ParameterListener;
60
61			import org.linuxsampler.lscp.Parameter;
62			import org.linuxsampler.lscp.ParameterType;
63			import org.linuxsampler.lscp.StringListParameter;
64
65
66			/**
67	iliev	911	* A tabular data model for representing LSCP parameters.
68			* @see ParameterTable
69	iliev	787	* @author Grigor Iliev
70			*/
71			public class ParameterTableModel extends AbstractTableModel {
72			public final static int PARAMETER_NAME_COLUMN = 0;
73			public final static int PARAMETER_VALUE_COLUMN = 1;
74
75	iliev	911	private Parameter[] parameters;
76	iliev	787
77			private final BooleanCellRenderer booleanRenderer = new BooleanCellRenderer();
78			private final BooleanCellEditor booleanEditor = new BooleanCellEditor();
79
80			private final IntegerCellRenderer integerRenderer = new IntegerCellRenderer();
81			private final IntegerCellEditor integerEditor = new IntegerCellEditor();
82
83			private final FloatCellRenderer floatRenderer = new FloatCellRenderer();
84			private final FloatCellEditor floatEditor = new FloatCellEditor();
85
86			private final StringListCellRenderer stringListRenderer = new StringListCellRenderer();
87			private final StringListCellEditor stringListEditor = new StringListCellEditor();
88
89			private boolean editFixedParameters;
90
91
92			/**
93			* Creates a new instance of <code>ParameterTableModel</code>.
94			* @param parameters The parameters to be provided by this model.
95			*/
96			public
97			ParameterTableModel(Parameter[] parameters) {
98			this(parameters, false);
99			}
100
101			/**
102			* Creates a new instance of <code>ParameterTableModel</code>.
103			* @param parameters The parameters to be provided by this model.
104			* @param editFixedParameters Determines whether fixed parameters are editable.
105			* Specify <code>true</code> to enable the editing of fixed parameters.
106			*/
107			public
108			ParameterTableModel(Parameter[] parameters, boolean editFixedParameters) {
109			setParameters(parameters);
110			setEditFixedParameters(editFixedParameters);
111			}
112
113			private final Vector<ParameterListener> parameterListeners =
114			new Vector<ParameterListener>();
115
116			/**
117			* Registers the specified listener for receiving event messages.
118			* @param l The <code>ParameterListener</code> to register.
119			*/
120			public void
121			addParameterListener(ParameterListener l) { parameterListeners.add(l); }
122
123			/**
124			* Removes the specified listener.
125			* @param l The <code>ParameterListener</code> to remove.
126			*/
127			public void
128			removeParameterListener(ParameterListener l) { parameterListeners.remove(l); }
129
130			/**
131			* Sets whether fixed parameters are editable.
132			* @param b Specify <code>true</code> to enable the editing of fixed parameters.
133			* @see org.linuxsampler.lscp.Parameter#isFixed
134			*/
135			public void
136			setEditFixedParameters(boolean b) { editFixedParameters = b; }
137
138			/**
139			* Determines whether fixed parameters are editable.
140			* @return <code>true</code> if the fixed parameters are
141			* editable, <code>false</code> otherwise.
142			* @see org.linuxsampler.lscp.Parameter#isFixed
143			*/
144			public boolean
145			canEditFixedParameters() { return editFixedParameters; }
146
147			/**
148			* Gets the parameter at the specified row.
149			* @param row The row number of the parameter to be provided.
150			* @return The parameter at the specified row.
151			*/
152			public Parameter
153			getParameter(int row) { return parameters[row]; }
154
155	iliev	911	/**
156			* Returns an appropriate renderer for the cell specified by
157			* <code>row</code> and <code>column</code>.
158			* @param row The row of the cell to render, where 0 is the first row.
159			* @param column The column of the cell to render, where 0 is the first column.
160			*/
161	iliev	787	public TableCellRenderer
162			getCellRenderer(int row, int column) {
163			if(column != PARAMETER_VALUE_COLUMN) return null;
164
165			if(parameters[row].getType() == ParameterType.BOOL) return booleanRenderer;
166			else if(parameters[row].getType() == ParameterType.INT) return integerRenderer;
167			else if(parameters[row].getType() == ParameterType.FLOAT) return floatRenderer;
168			else if(parameters[row].getType() == ParameterType.STRING_LIST) {
169			return stringListRenderer;
170			}
171
172			return null;
173			}
174
175	iliev	911	/**
176			* Returns an appropriate editor for the cell specified by
177			* <code>row</code> and <code>column</code>.
178			* @param row The row of the cell to edit, where 0 is the first row.
179			* @param column The column of the cell to edit, where 0 is the first column.
180			*/
181	iliev	787	public TableCellEditor
182			getCellEditor(int row, int column) {
183			if(column != PARAMETER_VALUE_COLUMN) return null;
184
185			Parameter p = parameters[row];
186			if(p.getType() == ParameterType.BOOL) return booleanEditor;
187
188			if(p.getType() == ParameterType.BOOL_LIST) {
189
190			} if(p.getType() == ParameterType.FLOAT_LIST) {
191
192			} if(p.getType() == ParameterType.INT_LIST) {
193
194			} if(p.getType() == ParameterType.STRING_LIST) {
195			StringListParameter slp = (StringListParameter)p;
196			if(slp.hasPossibilities()) {
197			return stringListEditor;
198			}
199			} else if(p.hasPossibilities()) {
200			return new DefaultCellEditor(new JComboBox(p.getPossibilities()));
201			} else if(p.getType() == ParameterType.INT) {
202			Integer i = p.hasRangeMin() ? p.getRangeMin().intValue() : null;
203			integerEditor.setMinimum(i);
204
205			i = p.hasRangeMax() ? p.getRangeMax().intValue() : null;
206			integerEditor.setMaximum(i);
207
208			return integerEditor;
209			} else if(p.getType() == ParameterType.FLOAT) {
210			Float f = p.hasRangeMin() ? p.getRangeMin().floatValue() : null;
211			floatEditor.setMinimum(f);
212
213			f = p.hasRangeMax() ? p.getRangeMax().floatValue() : null;
214			floatEditor.setMaximum(f);
215
216			return floatEditor;
217			}
218
219			return null;
220			}
221
222	iliev	1327	/** Gets the parameters that are shown in the table. */
223			public Parameter[]
224			getParameters() { return parameters; }
225
226	iliev	787	/**
227			* Sets the parameters to be shown in the table.
228			* @param parameters The parameters to be shown in the table.
229			*/
230			public void
231			setParameters(Parameter[] parameters) {
232			this.parameters = parameters;
233			fireTableDataChanged();
234			}
235
236			/**
237			* Gets the number of columns in the model.
238			* @return The number of columns in the model.
239			*/
240			public int
241			getColumnCount() { return 2; }
242
243			/**
244			* Gets the number of rows in the model.
245			* @return The number of rows in the model.
246			*/
247			public int
248			getRowCount() { return parameters.length; }
249
250			/**
251			* Gets the name of the column at <code>columnIndex</code>.
252			* @return The name of the column at <code>columnIndex</code>.
253			*/
254			public String
255			getColumnName(int col) { return " "; }
256
257			/**
258			* Gets the value for the cell at <code>columnIndex</code> and
259			* <code>rowIndex</code>.
260			* @param row The row whose value is to be queried.
261			* @param col The column whose value is to be queried.
262			* @return The value for the cell at <code>columnIndex</code> and
263			* <code>rowIndex</code>.
264			*/
265			public Object
266			getValueAt(int row, int col) {
267			switch(col) {
268			case PARAMETER_NAME_COLUMN:
269			return parameters[row].getName();
270			case PARAMETER_VALUE_COLUMN:
271			return parameters[row].getValue();
272			}
273
274			return null;
275			}
276
277			/**
278	iliev	911	* Sets the value in the cell at <code>col</code>
279			* and <code>row</code> to <code>value</code>.
280	iliev	787	*/
281			public void
282			setValueAt(Object value, int row, int col) {
283			if(col != PARAMETER_VALUE_COLUMN) return;
284
285			parameters[row].setValue(value);
286			fireTableCellUpdated(row, col);
287			fireParameterChanged(parameters[row]);
288			}
289
290			/**
291			* Returns <code>true</code> if the cell at
292	iliev	911	* <code>row</code> and <code>col</code> is editable.
293	iliev	787	*/
294			public boolean
295			isCellEditable(int row, int col) {
296			switch(col) {
297			case PARAMETER_NAME_COLUMN:
298			return false;
299			case PARAMETER_VALUE_COLUMN:
300			return canEditFixedParameters() \|\| !parameters[row].isFixed();
301			default: return false;
302			}
303			}
304
305			private void
306			fireParameterChanged(Parameter p) {
307			ParameterEvent e = new ParameterEvent(this, p);
308			for(ParameterListener l : parameterListeners) l.parameterChanged(e);
309			}
310
311			class BooleanCellRenderer extends JCheckBox implements TableCellRenderer {
312			private final Border emptyBorder = BorderFactory.createEmptyBorder(1, 1, 1, 1);
313
314			BooleanCellRenderer() {
315			setHorizontalAlignment(CENTER);
316			setBorderPainted(true);
317			}
318
319			public Component
320			getTableCellRendererComponent (
321			JTable table,
322			Object value,
323			boolean isSelected,
324			boolean hasFocus,
325			int row,
326			int column
327			) {
328			if (isSelected) {
329			setBackground(table.getSelectionBackground());
330			setForeground(table.getSelectionForeground());
331			} else {
332			setBackground(table.getBackground());
333			setForeground(table.getForeground());
334			}
335
336			Boolean b = (Boolean) value;
337			setSelected(b != null && b);
338
339			if(hasFocus) {
340			setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
341			} else { setBorder(emptyBorder); }
342
343			setToolTipText(parameters[row].getDescription());
344
345			return this;
346			}
347			}
348
349			class BooleanCellEditor extends DefaultCellEditor {
350			BooleanCellEditor() {
351			super(new JCheckBox());
352			JCheckBox cb = (JCheckBox)getComponent();
353			cb.setHorizontalAlignment(JCheckBox.CENTER);
354			}
355			}
356
357			class IntegerCellEditor extends NumberCellEditor {
358
359			}
360
361			class IntegerCellRenderer extends DefaultTableCellRenderer {
362			IntegerCellRenderer() {
363			setHorizontalAlignment(RIGHT);
364			}
365			}
366
367			class FloatCellEditor extends NumberCellEditor {
368			FloatCellEditor() {
369			SpinnerNumberModel model = new SpinnerNumberModel(0.0, 0.0, 0.0, 1.0);
370			setModel(model);
371			}
372			}
373
374			class FloatCellRenderer extends DefaultTableCellRenderer {
375			FloatCellRenderer() {
376			setHorizontalAlignment(RIGHT);
377			}
378			}
379
380	iliev	1327	class StringListCellEditor extends AbstractCellEditor implements TableCellEditor {
381	iliev	787	private final JButton editor = new JButton();
382			private final JPopupMenu menu = new JPopupMenu();
383			private final Vector<JCheckBoxMenuItem> menuItems = new Vector<JCheckBoxMenuItem>();
384
385			StringListCellEditor() {
386			editor.setBorderPainted(false);
387			editor.setContentAreaFilled(false);
388			editor.setFocusPainted(false);
389	iliev	1327	editor.setMargin(new java.awt.Insets(0, 0, 0, 0));
390	iliev	787	editor.setFont(editor.getFont().deriveFont(java.awt.Font.PLAIN));
391
392			editor.addActionListener(new ActionListener() {
393			public void
394			actionPerformed(ActionEvent e) { menu.show(editor, 0, 0); }
395			});
396
397			menu.addPopupMenuListener(new PopupMenuListener() {
398			public void
399			popupMenuCanceled(PopupMenuEvent e) {
400			StringListCellEditor.this.cancelCellEditing();
401			}
402
403			public void
404			popupMenuWillBecomeInvisible(PopupMenuEvent e) { }
405
406			public void
407			popupMenuWillBecomeVisible(PopupMenuEvent e) { }
408			});
409			}
410
411			private final Vector<String> strings = new Vector<String>();
412
413			public Object
414			getCellEditorValue() {
415			strings.removeAllElements();
416
417			for(JCheckBoxMenuItem i : menuItems) {
418			if(i.isSelected()) strings.add(i.getText());
419			}
420
421			return strings.toArray(new String[strings.size()]);
422			}
423
424			private final StringBuffer sb = new StringBuffer();
425
426			public Component
427			getTableCellEditorComponent (
428			JTable table,
429			Object value,
430			boolean isSelected,
431			int row,
432			int column
433			) {
434			StringListParameter slp = (StringListParameter)parameters[row];
435			String[] poss = slp.getPossibilities()[0];
436			String[] vals = (String[])value;
437
438			sb.setLength(0);
439
440			if(vals != null) {
441			if(vals.length > 0) sb.append(vals[0]);
442
443			for(int i = 1; i < vals.length; i++) {
444			sb.append(", ").append(vals[i]);
445			}
446			}
447
448			editor.setText(sb.toString());
449
450			menu.removeAll();
451			menuItems.removeAllElements();
452
453			for(String s : poss) {
454			JCheckBoxMenuItem item = new JCheckBoxMenuItem(s);
455			setListener(item);
456
457	iliev	1327	for(String s2 : vals) {
458			if(s2.equals(s)) item.setSelected(true);
459			}
460	iliev	787
461			menu.add(item);
462			menuItems.add(item);
463			}
464
465			return editor;
466			}
467
468			private void
469			setListener(JCheckBoxMenuItem i) {
470			i.addItemListener(new ItemListener() {
471			public void
472			itemStateChanged(ItemEvent e) {
473			StringListCellEditor.this.stopCellEditing();
474			}
475			});
476			}
477	iliev	1327	}
478	iliev	787
479	iliev	1327	/*private static JComboBox comboBox = new JComboBox();
480	iliev	787	class StringListCellEditor extends DefaultCellEditor {
481			StringListCellEditor() {
482			super(comboBox);
483			}
484
485			public Object
486			getCellEditorValue() {
487			Object o = comboBox.getSelectedItem();
488			if(o == null) return null;
489			String[] sS = new String[1];
490			sS[0] = (String)o;
491			return sS;
492			}
493
494			public Component
495			getTableCellEditorComponent (
496			JTable table,
497			Object value,
498			boolean isSelected,
499			int row,
500			int column
501			) {
502			StringListParameter slp = (StringListParameter)parameters[row];
503			comboBox.removeAllItems();
504			for(String s : slp.getPossibilities()[0]) comboBox.addItem(s);
505			return comboBox;
506			}
507	iliev	1327	}*/
508	iliev	787
509			class StringListCellRenderer extends DefaultTableCellRenderer {
510			private final StringBuffer sb = new StringBuffer();
511
512			public Component
513			getTableCellRendererComponent (
514			JTable table,
515			Object value,
516			boolean isSelected,
517			boolean hasFocus,
518			int row,
519			int column
520			) {
521			if(value instanceof String) return super.getTableCellRendererComponent (
522			table, value, isSelected, hasFocus, row, column
523			);
524
525			String[] s = (String[])value;
526
527			sb.setLength(0);
528
529			if(s != null) {
530			if(s.length > 0) sb.append(s[0]);
531			for(int i = 1; i < s.length; i++) sb.append(", ").append(s[i]);
532			}
533
534			return super.getTableCellRendererComponent (
535			table, sb.toString(), isSelected, hasFocus, row, column
536			);
537			}
538			}
539			}