view/fantasia/PianoKeyboardPane.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2005-2008 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.fantasia;

import java.awt.BorderLayout;
import java.awt.Insets;

import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;

import javax.swing.BorderFactory;

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

import net.sf.juife.event.TaskEvent;
import net.sf.juife.event.TaskListener;

import org.jsampler.CC;
import org.jsampler.SamplerChannelModel;

import org.jsampler.event.SamplerChannelAdapter;
import org.jsampler.event.SamplerChannelEvent;
import org.jsampler.event.SamplerChannelListListener;
import org.jsampler.event.SamplerChannelListEvent;

import org.jsampler.view.JSChannel;
import org.jsampler.view.std.JSPianoRoll;

import org.linuxsampler.lscp.Instrument;

import org.linuxsampler.lscp.event.MidiDataEvent;
import org.linuxsampler.lscp.event.MidiDataListener;

import static org.jsampler.task.Global.GetFileInstrument;

/**
 *
 * @author Grigor Iliev
 */
public class PianoKeyboardPane extends PixmapPane
                               implements ListSelectionListener, SamplerChannelListListener {
        
        private final JSPianoRoll pianoRoll = new JSPianoRoll();
        private SamplerChannelModel channel = null;
        
        private String file = null;
        private int index = -1;
        
        public
        PianoKeyboardPane() {
                super(Res.gfxDeviceBg);
                setPixmapInsets(new java.awt.Insets(1, 1, 1, 1));
                setOpaque(false);
                
                setLayout(new BorderLayout());
                setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
                
                PixmapPane p2 = new PixmapPane(Res.gfxBorder);
                p2.setPixmapInsets(new Insets(1, 1, 1, 1));
                p2.setLayout(new BorderLayout());
                p2.setBorder(BorderFactory.createEmptyBorder(0, 1, 0, 1));
                p2.add(pianoRoll);
                add(p2);
                
                pianoRoll.setOpaque(false);
                disablePianoRoll();
                add(p2);
                
                CC.getSamplerModel().addSamplerChannelListListener(this);
                pianoRoll.addMidiDataListener(getHandler());
                
                updateKeyRange();
                
                PropertyChangeListener l = new PropertyChangeListener() {
                        public void
                        propertyChange(PropertyChangeEvent e) {
                                updateKeyRange();
                        }
                };
                
                CC.preferences().addPropertyChangeListener("midiKeyboard.firstKey", l);
                CC.preferences().addPropertyChangeListener("midiKeyboard.lastKey", l);
        }
        
        public JSPianoRoll
        getPianoRoll() { return pianoRoll; }
        
        private void
        updateKeyRange() {
                int firstKey = CC.preferences().getIntProperty("midiKeyboard.firstKey");
                int lastKey = CC.preferences().getIntProperty("midiKeyboard.lastKey");
                pianoRoll.setKeyRange(firstKey, lastKey);
                pianoRoll.setAllKeysDisabled(true);
                updateInstrumentInfo();
        }
        
        @Override public void
        valueChanged(ListSelectionEvent e) {
                if(e.getValueIsAdjusting()) return;
                
                JSChannel[] chnS = CC.getMainFrame().getChannelsPane(0).getSelectedChannels();
                if(chnS == null || chnS.length == 0) {
                        disconnectChannel();
                        return;
                }
                
                if(chnS[0].getModel() == channel) return;
                disconnectChannel();
                connectChannel(chnS[0].getModel());
        }
        
        private void
        updateInstrumentInfo() {
                final GetFileInstrument i = new GetFileInstrument(file, index);
                
                i.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                if(i.doneWithErrors()) return;
                                updatePianoKeyboard(i.getResult());
                        }
                });
                
                CC.getTaskQueue().add(i);
        }
        
        private void
        disablePianoRoll() {
                pianoRoll.reset(true);
                pianoRoll.setPlayingEnabled(false);
        }
        
        private void
        updatePianoKeyboard(Instrument instr) {
                // The selected channel may have changed before this update
                // due to concurency, so also checking whether file is null
                if(instr == null || file == null) {
                        disablePianoRoll();
                        return;
                }
                
                pianoRoll.setPlayingEnabled(true);
                
                pianoRoll.setShouldRepaint(false);
                pianoRoll.reset(true);
                pianoRoll.setDisabled(instr.getKeyMapping(), false);
                pianoRoll.setKeyswitches(instr.getKeyswitchMapping(), true);
                pianoRoll.setShouldRepaint(true);
                pianoRoll.repaint();
        }
        
        private void
        connectChannel(SamplerChannelModel chn) {
                channel = chn;
                channel.addMidiDataListener(pianoRoll);
                channel.addSamplerChannelListener(getHandler());
                
                file = channel.getChannelInfo().getInstrumentFile();
                if(file == null) {
                        disablePianoRoll();
                        return;
                }
                index = channel.getChannelInfo().getInstrumentIndex();
                updateInstrumentInfo();
        }
        
        private void
        disconnectChannel() {
                if(channel != null) {
                        channel.removeMidiDataListener(pianoRoll);
                        channel.removeSamplerChannelListener(getHandler());
                        channel = null;
                        file = null;
                        index = -1;
                        disablePianoRoll();
                }
        }
        
        @Override public void
        channelAdded(SamplerChannelListEvent e) { }
        
        @Override public void
        channelRemoved(SamplerChannelListEvent e) {
                if(e.getChannelModel() == channel) {
                        disconnectChannel();
                }
        }
        
        private final Handler handler = new Handler();
        
        private Handler
        getHandler() { return handler; }
        
        private class Handler extends SamplerChannelAdapter implements MidiDataListener {
                public void
                midiDataArrived(MidiDataEvent e) {
                        if(channel == null) return;
                        channel.sendBackendMidiData(e);
                }
                
                public void
                channelChanged(SamplerChannelEvent e) {
                        String newFile = channel.getChannelInfo().getInstrumentFile();
                        int newIndex = channel.getChannelInfo().getInstrumentIndex();
                        
                        if(channel.getChannelInfo().getInstrumentStatus() != 100) {
                                //don't use disablePianoRoll because of unnecessary repainting
                                pianoRoll.setAllKeysPressed(false);
                                pianoRoll.removeAllKeyswitches();
                                pianoRoll.setAllKeysDisabled(true);
                                pianoRoll.setPlayingEnabled(false);
                                return;
                        }
                        
                        if(newFile == null) {
                                if(file != null) disablePianoRoll();
                                file = null;
                                index = -1;
                                return;
                        }
                        
                        if(newFile.equals(file) && newIndex == index) return;
                        
                        file = newFile;
                        index = newIndex;
                        updateInstrumentInfo();
                }
        }
}
1	iliev	1776	/*
2			* JSampler - a java front-end for LinuxSampler
3			*
4			* Copyright (C) 2005-2008 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.fantasia;
24
25			import java.awt.BorderLayout;
26			import java.awt.Insets;
27
28			import java.beans.PropertyChangeEvent;
29			import java.beans.PropertyChangeListener;
30
31			import javax.swing.BorderFactory;
32
33			import javax.swing.event.ListSelectionEvent;
34			import javax.swing.event.ListSelectionListener;
35
36			import net.sf.juife.event.TaskEvent;
37			import net.sf.juife.event.TaskListener;
38
39			import org.jsampler.CC;
40			import org.jsampler.SamplerChannelModel;
41
42			import org.jsampler.event.SamplerChannelAdapter;
43			import org.jsampler.event.SamplerChannelEvent;
44			import org.jsampler.event.SamplerChannelListListener;
45			import org.jsampler.event.SamplerChannelListEvent;
46
47			import org.jsampler.view.JSChannel;
48			import org.jsampler.view.std.JSPianoRoll;
49
50			import org.linuxsampler.lscp.Instrument;
51
52			import org.linuxsampler.lscp.event.MidiDataEvent;
53			import org.linuxsampler.lscp.event.MidiDataListener;
54
55			import static org.jsampler.task.Global.GetFileInstrument;
56
57			/**
58			*
59			* @author Grigor Iliev
60			*/
61			public class PianoKeyboardPane extends PixmapPane
62			implements ListSelectionListener, SamplerChannelListListener {
63
64			private final JSPianoRoll pianoRoll = new JSPianoRoll();
65			private SamplerChannelModel channel = null;
66
67			private String file = null;
68			private int index = -1;
69
70			public
71			PianoKeyboardPane() {
72			super(Res.gfxDeviceBg);
73			setPixmapInsets(new java.awt.Insets(1, 1, 1, 1));
74			setOpaque(false);
75
76			setLayout(new BorderLayout());
77			setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
78
79			PixmapPane p2 = new PixmapPane(Res.gfxBorder);
80			p2.setPixmapInsets(new Insets(1, 1, 1, 1));
81			p2.setLayout(new BorderLayout());
82			p2.setBorder(BorderFactory.createEmptyBorder(0, 1, 0, 1));
83			p2.add(pianoRoll);
84			add(p2);
85
86			pianoRoll.setOpaque(false);
87			disablePianoRoll();
88			add(p2);
89
90			CC.getSamplerModel().addSamplerChannelListListener(this);
91			pianoRoll.addMidiDataListener(getHandler());
92
93			updateKeyRange();
94
95			PropertyChangeListener l = new PropertyChangeListener() {
96			public void
97			propertyChange(PropertyChangeEvent e) {
98			updateKeyRange();
99			}
100			};
101
102			CC.preferences().addPropertyChangeListener("midiKeyboard.firstKey", l);
103			CC.preferences().addPropertyChangeListener("midiKeyboard.lastKey", l);
104			}
105
106			public JSPianoRoll
107			getPianoRoll() { return pianoRoll; }
108
109			private void
110			updateKeyRange() {
111			int firstKey = CC.preferences().getIntProperty("midiKeyboard.firstKey");
112			int lastKey = CC.preferences().getIntProperty("midiKeyboard.lastKey");
113			pianoRoll.setKeyRange(firstKey, lastKey);
114			pianoRoll.setAllKeysDisabled(true);
115			updateInstrumentInfo();
116			}
117
118			@Override public void
119			valueChanged(ListSelectionEvent e) {
120			if(e.getValueIsAdjusting()) return;
121
122			JSChannel[] chnS = CC.getMainFrame().getChannelsPane(0).getSelectedChannels();
123			if(chnS == null \|\| chnS.length == 0) {
124			disconnectChannel();
125			return;
126			}
127
128			if(chnS[0].getModel() == channel) return;
129			disconnectChannel();
130			connectChannel(chnS[0].getModel());
131			}
132
133			private void
134			updateInstrumentInfo() {
135			final GetFileInstrument i = new GetFileInstrument(file, index);
136
137			i.addTaskListener(new TaskListener() {
138			public void
139			taskPerformed(TaskEvent e) {
140			if(i.doneWithErrors()) return;
141			updatePianoKeyboard(i.getResult());
142			}
143			});
144
145			CC.getTaskQueue().add(i);
146			}
147
148			private void
149			disablePianoRoll() {
150			pianoRoll.reset(true);
151			pianoRoll.setPlayingEnabled(false);
152			}
153
154			private void
155			updatePianoKeyboard(Instrument instr) {
156			// The selected channel may have changed before this update
157			// due to concurency, so also checking whether file is null
158			if(instr == null \|\| file == null) {
159			disablePianoRoll();
160			return;
161			}
162
163			pianoRoll.setPlayingEnabled(true);
164
165			pianoRoll.setShouldRepaint(false);
166			pianoRoll.reset(true);
167			pianoRoll.setDisabled(instr.getKeyMapping(), false);
168			pianoRoll.setKeyswitches(instr.getKeyswitchMapping(), true);
169			pianoRoll.setShouldRepaint(true);
170			pianoRoll.repaint();
171			}
172
173			private void
174			connectChannel(SamplerChannelModel chn) {
175			channel = chn;
176			channel.addMidiDataListener(pianoRoll);
177			channel.addSamplerChannelListener(getHandler());
178
179			file = channel.getChannelInfo().getInstrumentFile();
180			if(file == null) {
181			disablePianoRoll();
182			return;
183			}
184			index = channel.getChannelInfo().getInstrumentIndex();
185			updateInstrumentInfo();
186			}
187
188			private void
189			disconnectChannel() {
190			if(channel != null) {
191			channel.removeMidiDataListener(pianoRoll);
192			channel.removeSamplerChannelListener(getHandler());
193			channel = null;
194			file = null;
195			index = -1;
196			disablePianoRoll();
197			}
198			}
199
200			@Override public void
201			channelAdded(SamplerChannelListEvent e) { }
202
203			@Override public void
204			channelRemoved(SamplerChannelListEvent e) {
205			if(e.getChannelModel() == channel) {
206			disconnectChannel();
207			}
208			}
209
210			private final Handler handler = new Handler();
211
212			private Handler
213			getHandler() { return handler; }
214
215			private class Handler extends SamplerChannelAdapter implements MidiDataListener {
216			public void
217			midiDataArrived(MidiDataEvent e) {
218			if(channel == null) return;
219			channel.sendBackendMidiData(e);
220			}
221
222			public void
223			channelChanged(SamplerChannelEvent e) {
224			String newFile = channel.getChannelInfo().getInstrumentFile();
225			int newIndex = channel.getChannelInfo().getInstrumentIndex();
226
227			if(channel.getChannelInfo().getInstrumentStatus() != 100) {
228			//don't use disablePianoRoll because of unnecessary repainting
229			pianoRoll.setAllKeysPressed(false);
230			pianoRoll.removeAllKeyswitches();
231			pianoRoll.setAllKeysDisabled(true);
232			pianoRoll.setPlayingEnabled(false);
233			return;
234			}
235
236			if(newFile == null) {
237			if(file != null) disablePianoRoll();
238			file = null;
239			index = -1;
240			return;
241			}
242
243			if(newFile.equals(file) && newIndex == index) return;
244
245			file = newFile;
246			index = newIndex;
247			updateInstrumentInfo();
248			}
249			}
250			}