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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 911 - (show annotations) (download)
Mon Aug 7 18:25:58 2006 UTC (17 years, 7 months ago) by iliev
File size: 14792 byte(s)
updating to JSampler 0.3a

1 /*
2 * JSampler - a java front-end for LinuxSampler
3 *
4 * Copyright (C) 2005 Grigor Kirilov Iliev
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
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 * A tabular data model for representing LSCP parameters.
68 * @see ParameterTable
69 * @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 private Parameter[] parameters;
76
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 /**
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 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 /**
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 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 * Sets the value in the cell at <code>col</code>
275 * and <code>row</code> to <code>value</code>.
276 */
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 * <code>row</code> and <code>col</code> is editable.
289 */
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