/[svn]/jsampler/trunk/src/org/jsampler/view/ParameterTableModel.java
ViewVC logotype

Annotation of /jsampler/trunk/src/org/jsampler/view/ParameterTableModel.java

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1143 - (hide annotations) (download)
Mon Apr 2 21:18:31 2007 UTC (17 years ago) by iliev
File size: 14814 byte(s)
* upgrading to version 0.4a

1 iliev 787 /*
2     * JSampler - a java front-end for LinuxSampler
3     *
4 iliev 1143 * Copyright (C) 2005-2006 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     /**
223     * Sets the parameters to be shown in the table.
224     * @param parameters The parameters to be shown in the table.
225     */
226     public void
227     setParameters(Parameter[] parameters) {
228     this.parameters = parameters;
229     fireTableDataChanged();
230     }
231    
232     /**
233     * Gets the number of columns in the model.
234     * @return The number of columns in the model.
235     */
236     public int
237     getColumnCount() { return 2; }
238    
239     /**
240     * Gets the number of rows in the model.
241     * @return The number of rows in the model.
242     */
243     public int
244     getRowCount() { return parameters.length; }
245    
246     /**
247     * Gets the name of the column at <code>columnIndex</code>.
248     * @return The name of the column at <code>columnIndex</code>.
249     */
250     public String
251     getColumnName(int col) { return " "; }
252    
253     /**
254     * Gets the value for the cell at <code>columnIndex</code> and
255     * <code>rowIndex</code>.
256     * @param row The row whose value is to be queried.
257     * @param col The column whose value is to be queried.
258     * @return The value for the cell at <code>columnIndex</code> and
259     * <code>rowIndex</code>.
260     */
261     public Object
262     getValueAt(int row, int col) {
263     switch(col) {
264     case PARAMETER_NAME_COLUMN:
265     return parameters[row].getName();
266     case PARAMETER_VALUE_COLUMN:
267     return parameters[row].getValue();
268     }
269    
270     return null;
271     }
272    
273     /**
274 iliev 911 * Sets the value in the cell at <code>col</code>
275     * and <code>row</code> to <code>value</code>.
276 iliev 787 */
277     public void
278     setValueAt(Object value, int row, int col) {
279     if(col != PARAMETER_VALUE_COLUMN) return;
280    
281     parameters[row].setValue(value);
282     fireTableCellUpdated(row, col);
283     fireParameterChanged(parameters[row]);
284     }
285    
286     /**
287     * Returns <code>true</code> if the cell at
288 iliev 911 * <code>row</code> and <code>col</code> is editable.
289 iliev 787 */
290     public boolean
291     isCellEditable(int row, int col) {
292     switch(col) {
293     case PARAMETER_NAME_COLUMN:
294     return false;
295     case PARAMETER_VALUE_COLUMN:
296     return canEditFixedParameters() || !parameters[row].isFixed();
297     default: return false;
298     }
299     }
300    
301     private void
302     fireParameterChanged(Parameter p) {
303     ParameterEvent e = new ParameterEvent(this, p);
304     for(ParameterListener l : parameterListeners) l.parameterChanged(e);
305     }
306    
307     class BooleanCellRenderer extends JCheckBox implements TableCellRenderer {
308     private final Border emptyBorder = BorderFactory.createEmptyBorder(1, 1, 1, 1);
309    
310     BooleanCellRenderer() {
311     setHorizontalAlignment(CENTER);
312     setBorderPainted(true);
313     }
314    
315     public Component
316     getTableCellRendererComponent (
317     JTable table,
318     Object value,
319     boolean isSelected,
320     boolean hasFocus,
321     int row,
322     int column
323     ) {
324     if (isSelected) {
325     setBackground(table.getSelectionBackground());
326     setForeground(table.getSelectionForeground());
327     } else {
328     setBackground(table.getBackground());
329     setForeground(table.getForeground());
330     }
331    
332     Boolean b = (Boolean) value;
333     setSelected(b != null && b);
334    
335     if(hasFocus) {
336     setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
337     } else { setBorder(emptyBorder); }
338    
339     setToolTipText(parameters[row].getDescription());
340    
341     return this;
342     }
343     }
344    
345     class BooleanCellEditor extends DefaultCellEditor {
346     BooleanCellEditor() {
347     super(new JCheckBox());
348     JCheckBox cb = (JCheckBox)getComponent();
349     cb.setHorizontalAlignment(JCheckBox.CENTER);
350     }
351     }
352    
353     class IntegerCellEditor extends NumberCellEditor {
354    
355     }
356    
357     class IntegerCellRenderer extends DefaultTableCellRenderer {
358     IntegerCellRenderer() {
359     setHorizontalAlignment(RIGHT);
360     }
361     }
362    
363     class FloatCellEditor extends NumberCellEditor {
364     FloatCellEditor() {
365     SpinnerNumberModel model = new SpinnerNumberModel(0.0, 0.0, 0.0, 1.0);
366     setModel(model);
367     }
368     }
369    
370     class FloatCellRenderer extends DefaultTableCellRenderer {
371     FloatCellRenderer() {
372     setHorizontalAlignment(RIGHT);
373     }
374     }
375    
376     /*class StringListCellEditor extends AbstractCellEditor implements TableCellEditor {
377     private final JButton editor = new JButton();
378     private final JPopupMenu menu = new JPopupMenu();
379     private final Vector<JCheckBoxMenuItem> menuItems = new Vector<JCheckBoxMenuItem>();
380    
381     StringListCellEditor() {
382     editor.setBorderPainted(false);
383     editor.setContentAreaFilled(false);
384     editor.setFocusPainted(false);
385     editor.setFont(editor.getFont().deriveFont(java.awt.Font.PLAIN));
386    
387     editor.addActionListener(new ActionListener() {
388     public void
389     actionPerformed(ActionEvent e) { menu.show(editor, 0, 0); }
390     });
391    
392     menu.addPopupMenuListener(new PopupMenuListener() {
393     public void
394     popupMenuCanceled(PopupMenuEvent e) {
395     StringListCellEditor.this.cancelCellEditing();
396     }
397    
398     public void
399     popupMenuWillBecomeInvisible(PopupMenuEvent e) { }
400    
401     public void
402     popupMenuWillBecomeVisible(PopupMenuEvent e) { }
403     });
404     }
405    
406     private final Vector<String> strings = new Vector<String>();
407    
408     public Object
409     getCellEditorValue() {
410     strings.removeAllElements();
411    
412     for(JCheckBoxMenuItem i : menuItems) {
413     if(i.isSelected()) strings.add(i.getText());
414     }
415    
416     return strings.toArray(new String[strings.size()]);
417     }
418    
419     private final StringBuffer sb = new StringBuffer();
420    
421     public Component
422     getTableCellEditorComponent (
423     JTable table,
424     Object value,
425     boolean isSelected,
426     int row,
427     int column
428     ) {
429     StringListParameter slp = (StringListParameter)parameters[row];
430     String[] poss = slp.getPossibilities()[0];
431     String[] vals = (String[])value;
432    
433     sb.setLength(0);
434    
435     if(vals != null) {
436     if(vals.length > 0) sb.append(vals[0]);
437    
438     for(int i = 1; i < vals.length; i++) {
439     sb.append(", ").append(vals[i]);
440     }
441     }
442    
443     editor.setText(sb.toString());
444    
445     menu.removeAll();
446     menuItems.removeAllElements();
447    
448     for(String s : poss) {
449     JCheckBoxMenuItem item = new JCheckBoxMenuItem(s);
450     setListener(item);
451    
452     for(String s2 : vals) if(s2.equals(s)) item.setSelected(true);
453    
454     menu.add(item);
455     menuItems.add(item);
456     }
457    
458     return editor;
459     }
460    
461     private void
462     setListener(JCheckBoxMenuItem i) {
463     i.addItemListener(new ItemListener() {
464     public void
465     itemStateChanged(ItemEvent e) {
466     StringListCellEditor.this.stopCellEditing();
467     }
468     });
469     }
470     }*/
471    
472     private static JComboBox comboBox = new JComboBox();
473     class StringListCellEditor extends DefaultCellEditor {
474     StringListCellEditor() {
475     super(comboBox);
476     }
477    
478     public Object
479     getCellEditorValue() {
480     Object o = comboBox.getSelectedItem();
481     if(o == null) return null;
482     String[] sS = new String[1];
483     sS[0] = (String)o;
484     return sS;
485     }
486    
487     public Component
488     getTableCellEditorComponent (
489     JTable table,
490     Object value,
491     boolean isSelected,
492     int row,
493     int column
494     ) {
495     StringListParameter slp = (StringListParameter)parameters[row];
496     comboBox.removeAllItems();
497     for(String s : slp.getPossibilities()[0]) comboBox.addItem(s);
498     return comboBox;
499     }
500     }
501    
502     class StringListCellRenderer extends DefaultTableCellRenderer {
503     private final StringBuffer sb = new StringBuffer();
504    
505     public Component
506     getTableCellRendererComponent (
507     JTable table,
508     Object value,
509     boolean isSelected,
510     boolean hasFocus,
511     int row,
512     int column
513     ) {
514     if(value instanceof String) return super.getTableCellRendererComponent (
515     table, value, isSelected, hasFocus, row, column
516     );
517    
518     String[] s = (String[])value;
519    
520     sb.setLength(0);
521    
522     if(s != null) {
523     if(s.length > 0) sb.append(s[0]);
524     for(int i = 1; i < s.length; i++) sb.append(", ").append(s[i]);
525     }
526    
527     return super.getTableCellRendererComponent (
528     table, sb.toString(), isSelected, hasFocus, row, column
529     );
530     }
531     }
532     }

  ViewVC Help
Powered by ViewVC