view/std/JSOrchestraPane.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.std;

import java.awt.BorderLayout;

import java.awt.event.ActionEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;

import javax.swing.AbstractAction;
import javax.swing.Action;
import javax.swing.JPanel;
import javax.swing.JScrollPane;

import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;

import org.jsampler.DefaultOrchestraModel;
import org.jsampler.Instrument;
import org.jsampler.OrchestraModel;

import org.jsampler.view.InstrumentTable;
import org.jsampler.view.InstrumentTableModel;

import static org.jsampler.view.std.StdI18n.i18n;

/**
 *
 * @author Grigor Iliev
 */
public class JSOrchestraPane extends JPanel {
        protected final InstrumentTable instrumentTable;
        
        protected final Action actionAddInstrument = new AddInstrumentAction();
        protected final Action actionEditInstrument = new EditInstrumentAction();
        protected final Action actionDeleteInstrument = new DeleteInstrumentAction();
        protected final Action actionInstrumentUp = new InstrumentUpAction();
        protected final Action actionInstrumentDown = new InstrumentDownAction();
        
        private OrchestraModel orchestra;
        
        /** Creates a new instance of <code>JSOrchestraPane</code> */
        public
        JSOrchestraPane() {
                this(null);
        }
        
        /** Creates a new instance of <code>JSOrchestraPane</code> */
        public
        JSOrchestraPane(OrchestraModel orchestra) {
                instrumentTable = new InstrumentTable();
                setOrchestra(orchestra);
                
                setLayout(new BorderLayout());
                JScrollPane sp = new JScrollPane(instrumentTable);
                add(sp);
                
                installListeneres();
        }
        
        private void
        installListeneres() {
                InstrumentSelectionHandler l = new InstrumentSelectionHandler();
                instrumentTable.getSelectionModel().addListSelectionListener(l);
                
                instrumentTable.addMouseListener(new MouseAdapter() {
                        public void
                        mouseClicked(MouseEvent e) {
                                if(e.getClickCount() < 2) return;
                                
                                if(instrumentTable.getSelectedInstrument() == null) return;
                                editInstrument(instrumentTable.getSelectedInstrument());
                        }
                });
        }
        
        public void
        setOrchestra(OrchestraModel orchestra) {
                this.orchestra = orchestra;
                if(orchestra == null) {
                        orchestra = new DefaultOrchestraModel();
                        actionAddInstrument.setEnabled(false);
                } else {
                        actionAddInstrument.setEnabled(true);
                }
                instrumentTable.getModel().setOrchestraModel(orchestra);
        }
        
        public Instrument
        getSelectedInstrument() { return instrumentTable.getSelectedInstrument(); }
        
        /**
         * Invoked when the user initiates the creation of new instrument.
         * @return The instrument to add
         * or <code>null</code> if the user cancelled the task.
         */
        public Instrument
        createInstrument() {
                JSAddOrEditInstrumentDlg dlg = new JSAddOrEditInstrumentDlg();
                dlg.setVisible(true);
                
                if(dlg.isCancelled()) return null;
                return dlg.getInstrument();
        }
        
        public void
        editInstrument(Instrument instr) {
                JSAddOrEditInstrumentDlg dlg = new JSAddOrEditInstrumentDlg(instr);
                dlg.setVisible(true);
        }
        
        private class InstrumentSelectionHandler implements ListSelectionListener {
                public void
                valueChanged(ListSelectionEvent e) {
                        if(e.getValueIsAdjusting()) return;
                        
                        if(instrumentTable.getSelectedInstrument() == null) {
                                actionEditInstrument.setEnabled(false);
                                actionDeleteInstrument.setEnabled(false);
                                actionInstrumentUp.setEnabled(false);
                                actionInstrumentDown.setEnabled(false);
                                return;
                        }
                        
                        actionEditInstrument.setEnabled(true);
                        actionDeleteInstrument.setEnabled(true);
                        
                        int idx = instrumentTable.getSelectedRow();
                        actionInstrumentUp.setEnabled(idx != 0);
                        actionInstrumentDown.setEnabled(idx != instrumentTable.getRowCount() - 1);
                }
        }
        
        private class AddInstrumentAction extends AbstractAction {
                AddInstrumentAction() {
                        super("");
                        
                        String s = i18n.getLabel("JSOrchestraPane.ttAddInstrument");
                        putValue(SHORT_DESCRIPTION, s);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        Instrument instr = createInstrument();
                        if(instr == null) return;
                        orchestra.addInstrument(instr);
                }
        }
        
        private class EditInstrumentAction extends AbstractAction {
                EditInstrumentAction() {
                        super("");
                        
                        String s = i18n.getLabel("JSOrchestraPane.ttEditInstrument");
                        putValue(SHORT_DESCRIPTION, s);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        editInstrument(instrumentTable.getSelectedInstrument());
                }
        }
        
        private class DeleteInstrumentAction extends AbstractAction {
                DeleteInstrumentAction() {
                        super("");
                        
                        String s = i18n.getLabel("JSOrchestraPane.ttDeleteInstrument");
                        putValue(SHORT_DESCRIPTION, s);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        Instrument instr = instrumentTable.getSelectedInstrument();
                        if(instr == null) return;
                        orchestra.removeInstrument(instr);
                }
        }
        
        private class InstrumentUpAction extends AbstractAction {
                InstrumentUpAction() {
                        super("");
                        
                        String s = i18n.getLabel("JSOrchestraPane.ttInstrumentUp");
                        putValue(SHORT_DESCRIPTION, s);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        Instrument instr = instrumentTable.getSelectedInstrument();
                        instrumentTable.getModel().getOrchestraModel().moveInstrumentUp(instr);
                        instrumentTable.setSelectedInstrument(instr);
                }
        }
        
        private class InstrumentDownAction extends AbstractAction {
                InstrumentDownAction() {
                        super("");
                        
                        String s = i18n.getLabel("JSOrchestraPane.ttInstrumentDown");
                        putValue(SHORT_DESCRIPTION, s);
                        
                        setEnabled(false);
                }
                
                public void
                actionPerformed(ActionEvent e) {
                        Instrument instr = instrumentTable.getSelectedInstrument();
                        instrumentTable.getModel().getOrchestraModel().moveInstrumentDown(instr);
                        instrumentTable.setSelectedInstrument(instr);
                }
        }
}
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.std;
24
25	import java.awt.BorderLayout;
26
27	import java.awt.event.ActionEvent;
28	import java.awt.event.MouseAdapter;
29	import java.awt.event.MouseEvent;
30
31	import javax.swing.AbstractAction;
32	import javax.swing.Action;
33	import javax.swing.JPanel;
34	import javax.swing.JScrollPane;
35
36	import javax.swing.event.ListSelectionEvent;
37	import javax.swing.event.ListSelectionListener;
38
39	import org.jsampler.DefaultOrchestraModel;
40	import org.jsampler.Instrument;
41	import org.jsampler.OrchestraModel;
42
43	import org.jsampler.view.InstrumentTable;
44	import org.jsampler.view.InstrumentTableModel;
45
46	import static org.jsampler.view.std.StdI18n.i18n;
47
48	/**
49	*
50	* @author Grigor Iliev
51	*/
52	public class JSOrchestraPane extends JPanel {
53	protected final InstrumentTable instrumentTable;
54
55	protected final Action actionAddInstrument = new AddInstrumentAction();
56	protected final Action actionEditInstrument = new EditInstrumentAction();
57	protected final Action actionDeleteInstrument = new DeleteInstrumentAction();
58	protected final Action actionInstrumentUp = new InstrumentUpAction();
59	protected final Action actionInstrumentDown = new InstrumentDownAction();
60
61	private OrchestraModel orchestra;
62
63	/** Creates a new instance of <code>JSOrchestraPane</code> */
64	public
65	JSOrchestraPane() {
66	this(null);
67	}
68
69	/** Creates a new instance of <code>JSOrchestraPane</code> */
70	public
71	JSOrchestraPane(OrchestraModel orchestra) {
72	instrumentTable = new InstrumentTable();
73	setOrchestra(orchestra);
74
75	setLayout(new BorderLayout());
76	JScrollPane sp = new JScrollPane(instrumentTable);
77	add(sp);
78
79	installListeneres();
80	}
81
82	private void
83	installListeneres() {
84	InstrumentSelectionHandler l = new InstrumentSelectionHandler();
85	instrumentTable.getSelectionModel().addListSelectionListener(l);
86
87	instrumentTable.addMouseListener(new MouseAdapter() {
88	public void
89	mouseClicked(MouseEvent e) {
90	if(e.getClickCount() < 2) return;
91
92	if(instrumentTable.getSelectedInstrument() == null) return;
93	editInstrument(instrumentTable.getSelectedInstrument());
94	}
95	});
96	}
97
98	public void
99	setOrchestra(OrchestraModel orchestra) {
100	this.orchestra = orchestra;
101	if(orchestra == null) {
102	orchestra = new DefaultOrchestraModel();
103	actionAddInstrument.setEnabled(false);
104	} else {
105	actionAddInstrument.setEnabled(true);
106	}
107	instrumentTable.getModel().setOrchestraModel(orchestra);
108	}
109
110	public Instrument
111	getSelectedInstrument() { return instrumentTable.getSelectedInstrument(); }
112
113	/**
114	* Invoked when the user initiates the creation of new instrument.
115	* @return The instrument to add
116	* or <code>null</code> if the user cancelled the task.
117	*/
118	public Instrument
119	createInstrument() {
120	JSAddOrEditInstrumentDlg dlg = new JSAddOrEditInstrumentDlg();
121	dlg.setVisible(true);
122
123	if(dlg.isCancelled()) return null;
124	return dlg.getInstrument();
125	}
126
127	public void
128	editInstrument(Instrument instr) {
129	JSAddOrEditInstrumentDlg dlg = new JSAddOrEditInstrumentDlg(instr);
130	dlg.setVisible(true);
131	}
132
133	private class InstrumentSelectionHandler implements ListSelectionListener {
134	public void
135	valueChanged(ListSelectionEvent e) {
136	if(e.getValueIsAdjusting()) return;
137
138	if(instrumentTable.getSelectedInstrument() == null) {
139	actionEditInstrument.setEnabled(false);
140	actionDeleteInstrument.setEnabled(false);
141	actionInstrumentUp.setEnabled(false);
142	actionInstrumentDown.setEnabled(false);
143	return;
144	}
145
146	actionEditInstrument.setEnabled(true);
147	actionDeleteInstrument.setEnabled(true);
148
149	int idx = instrumentTable.getSelectedRow();
150	actionInstrumentUp.setEnabled(idx != 0);
151	actionInstrumentDown.setEnabled(idx != instrumentTable.getRowCount() - 1);
152	}
153	}
154
155	private class AddInstrumentAction extends AbstractAction {
156	AddInstrumentAction() {
157	super("");
158
159	String s = i18n.getLabel("JSOrchestraPane.ttAddInstrument");
160	putValue(SHORT_DESCRIPTION, s);
161	}
162
163	public void
164	actionPerformed(ActionEvent e) {
165	Instrument instr = createInstrument();
166	if(instr == null) return;
167	orchestra.addInstrument(instr);
168	}
169	}
170
171	private class EditInstrumentAction extends AbstractAction {
172	EditInstrumentAction() {
173	super("");
174
175	String s = i18n.getLabel("JSOrchestraPane.ttEditInstrument");
176	putValue(SHORT_DESCRIPTION, s);
177
178	setEnabled(false);
179	}
180
181	public void
182	actionPerformed(ActionEvent e) {
183	editInstrument(instrumentTable.getSelectedInstrument());
184	}
185	}
186
187	private class DeleteInstrumentAction extends AbstractAction {
188	DeleteInstrumentAction() {
189	super("");
190
191	String s = i18n.getLabel("JSOrchestraPane.ttDeleteInstrument");
192	putValue(SHORT_DESCRIPTION, s);
193
194	setEnabled(false);
195	}
196
197	public void
198	actionPerformed(ActionEvent e) {
199	Instrument instr = instrumentTable.getSelectedInstrument();
200	if(instr == null) return;
201	orchestra.removeInstrument(instr);
202	}
203	}
204
205	private class InstrumentUpAction extends AbstractAction {
206	InstrumentUpAction() {
207	super("");
208
209	String s = i18n.getLabel("JSOrchestraPane.ttInstrumentUp");
210	putValue(SHORT_DESCRIPTION, s);
211
212	setEnabled(false);
213	}
214
215	public void
216	actionPerformed(ActionEvent e) {
217	Instrument instr = instrumentTable.getSelectedInstrument();
218	instrumentTable.getModel().getOrchestraModel().moveInstrumentUp(instr);
219	instrumentTable.setSelectedInstrument(instr);
220	}
221	}
222
223	private class InstrumentDownAction extends AbstractAction {
224	InstrumentDownAction() {
225	super("");
226
227	String s = i18n.getLabel("JSOrchestraPane.ttInstrumentDown");
228	putValue(SHORT_DESCRIPTION, s);
229
230	setEnabled(false);
231	}
232
233	public void
234	actionPerformed(ActionEvent e) {
235	Instrument instr = instrumentTable.getSelectedInstrument();
236	instrumentTable.getModel().getOrchestraModel().moveInstrumentDown(instr);
237	instrumentTable.setSelectedInstrument(instr);
238	}
239	}
240	}