/[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 1496 - (show annotations) (download)
Mon Nov 19 22:22:22 2007 UTC (16 years, 4 months ago) by iliev
File size: 14994 byte(s)
* Added option for turning off the custom window decoration
  (choose Edit/Preferences, then click the `View' tab)
* Added new menu item: Help/Online Tutorial
* Fantasia: first step of implementing a theme manager
* Fantasia: fixed the view of the channel's stream/voice count statistic
* some minor GUI fixes and enhancements

1 /*
2 * JSampler - a java front-end for LinuxSampler
3 *
4 * Copyright (C) 2005-2007 Grigor Iliev <grigor@grigoriliev.com>
5 *
6 * This file is part of JSampler.
7 *
8 * JSampler is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2
10 * as published by the Free Software Foundation.
11 *
12 * JSampler is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with JSampler; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
20 * MA 02111-1307 USA
21 */
22
23 package org.jsampler.view;
24
25 import java.awt.Component;
26
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 JComboBox cb = new JComboBox(p.getPossibilities());
201 cb.setSelectedItem(null);
202 return new DefaultCellEditor(cb);
203 } else if(p.getType() == ParameterType.INT) {
204 Integer i = p.hasRangeMin() ? p.getRangeMin().intValue() : null;
205 integerEditor.setMinimum(i);
206
207 i = p.hasRangeMax() ? p.getRangeMax().intValue() : null;
208 integerEditor.setMaximum(i);
209
210 return integerEditor;
211 } else if(p.getType() == ParameterType.FLOAT) {
212 Float f = p.hasRangeMin() ? p.getRangeMin().floatValue() : null;
213 floatEditor.setMinimum(f);
214
215 f = p.hasRangeMax() ? p.getRangeMax().floatValue() : null;
216 floatEditor.setMaximum(f);
217
218 return floatEditor;
219 }
220
221 return null;
222 }
223
224 /** Gets the parameters that are shown in the table. */
225 public Parameter[]
226 getParameters() { return parameters; }
227
228 /**
229 * Sets the parameters to be shown in the table.
230 * @param parameters The parameters to be shown in the table.
231 */
232 public void
233 setParameters(Parameter[] parameters) {
234 this.parameters = parameters;
235 fireTableDataChanged();
236 }
237
238 /**
239 * Gets the number of columns in the model.
240 * @return The number of columns in the model.
241 */
242 public int
243 getColumnCount() { return 2; }
244
245 /**
246 * Gets the number of rows in the model.
247 * @return The number of rows in the model.
248 */
249 public int
250 getRowCount() { return parameters.length; }
251
252 /**
253 * Gets the name of the column at <code>columnIndex</code>.
254 * @return The name of the column at <code>columnIndex</code>.
255 */
256 public String
257 getColumnName(int col) { return " "; }
258
259 /**
260 * Gets the value for the cell at <code>columnIndex</code> and
261 * <code>rowIndex</code>.
262 * @param row The row whose value is to be queried.
263 * @param col The column whose value is to be queried.
264 * @return The value for the cell at <code>columnIndex</code> and
265 * <code>rowIndex</code>.
266 */
267 public Object
268 getValueAt(int row, int col) {
269 switch(col) {
270 case PARAMETER_NAME_COLUMN:
271 return parameters[row].getName();
272 case PARAMETER_VALUE_COLUMN:
273 return parameters[row].getValue();
274 }
275
276 return null;
277 }
278
279 /**
280 * Sets the value in the cell at <code>col</code>
281 * and <code>row</code> to <code>value</code>.
282 */
283 public void
284 setValueAt(Object value, int row, int col) {
285 if(col != PARAMETER_VALUE_COLUMN) return;
286
287 parameters[row].setValue(value);
288 fireTableCellUpdated(row, col);
289 fireParameterChanged(parameters[row]);
290 }
291
292 /**
293 * Returns <code>true</code> if the cell at
294 * <code>row</code> and <code>col</code> is editable.
295 */
296 public boolean
297 isCellEditable(int row, int col) {
298 switch(col) {
299 case PARAMETER_NAME_COLUMN:
300 return false;
301 case PARAMETER_VALUE_COLUMN:
302 return canEditFixedParameters() || !parameters[row].isFixed();
303 default: return false;
304 }
305 }
306
307 private void
308 fireParameterChanged(Parameter p) {
309 ParameterEvent e = new ParameterEvent(this, p);
310 for(ParameterListener l : parameterListeners) l.parameterChanged(e);
311 }
312
313 class BooleanCellRenderer extends JCheckBox implements TableCellRenderer {
314 private final Border emptyBorder = BorderFactory.createEmptyBorder(1, 1, 1, 1);
315
316 BooleanCellRenderer() {
317 setHorizontalAlignment(CENTER);
318 setBorderPainted(true);
319 }
320
321 public Component
322 getTableCellRendererComponent (
323 JTable table,
324 Object value,
325 boolean isSelected,
326 boolean hasFocus,
327 int row,
328 int column
329 ) {
330 if (isSelected) {
331 setBackground(table.getSelectionBackground());
332 setForeground(table.getSelectionForeground());
333 } else {
334 setBackground(table.getBackground());
335 setForeground(table.getForeground());
336 }
337
338 Boolean b = (Boolean) value;
339 setSelected(b != null && b);
340
341 if(hasFocus) {
342 setBorder(UIManager.getBorder("Table.focusCellHighlightBorder"));
343 } else { setBorder(emptyBorder); }
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 class StringListCellEditor extends AbstractCellEditor implements TableCellEditor {
381 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 editor.setMargin(new java.awt.Insets(0, 0, 0, 0));
390 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 for(String s2 : vals) {
458 if(s2.equals(s)) item.setSelected(true);
459 }
460
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 }
478
479 /*private static JComboBox comboBox = new JComboBox();
480 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 }*/
508
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 }

  ViewVC Help
Powered by ViewVC