org/jsampler/DefaultSamplerChannelModel.java

/*
 *   JSampler - a java front-end for LinuxSampler
 *
 *   Copyright (C) 2005 Grigor Kirilov Iliev
 *
 *   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;

import java.util.Vector;

import javax.swing.SwingUtilities;

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

import org.jsampler.event.SamplerChannelEvent;
import org.jsampler.event.SamplerChannelListener;

import org.jsampler.task.LoadEngine;
import org.jsampler.task.LoadInstrument;
import org.jsampler.task.SetChannelAudioOutputDevice;
import org.jsampler.task.SetChannelMidiInputChannel;
import org.jsampler.task.SetChannelMidiInputDevice;
import org.jsampler.task.SetChannelMidiInputPort;
import org.jsampler.task.SetChannelVolume;
import org.jsampler.task.SetMuteChannel;
import org.jsampler.task.SetSoloChannel;

import org.linuxsampler.lscp.SamplerChannel;


/**
 *
 * @author Grigor Iliev
 */
public class DefaultSamplerChannelModel implements SamplerChannelModel {
        private SamplerChannel channel;
        private int streamCount = 0;
        private int voiceCount = 0;
        
        private final Vector<SamplerChannelListener> listeners =
                new Vector<SamplerChannelListener>();
        
        /**
         * Creates a new instance of <code>DefaultSamplerChannelModel</code> using the
         * specified channel settings.
         * @param channel A non-null <code>SamplerChannel</code> instance containing the current
         * settings of the channel which will be represented by this sampler channel model.
         * @throws IllegalArgumentException If <code>channel</code> is <code>null</code>.
         */
        public DefaultSamplerChannelModel(SamplerChannel channel) {
                if(channel == null) throw new IllegalArgumentException("channel must be non null");
                this.channel = channel;
        }
        
        /**
         * Registers the specified listener for receiving event messages.
         * @param l The <code>SamplerChannelListener</code> to register.
         */
        public void
        addSamplerChannelListener(SamplerChannelListener l) { listeners.add(l); }
        
        /**
         * Removes the specified listener.
         * @param l The <code>SamplerChannelListener</code> to remove.
         */
        public void
        removeSamplerChannelListener(SamplerChannelListener l) { listeners.remove(l); }
        
        /**
         * Gets the sampler channel number.
         * @return The sampler channel number or -1 if the sampler channel number is not set.
         */
        public int
        getChannelID() { return channel == null ? -1 : channel.getChannelID(); }
        
        /**
         * Gets the current settings of the sampler channel.
         * @return <code>SamplerChannel</code> instance containing
         * the current settings of the sampler channel.
         */
        public SamplerChannel
        getChannelInfo() { return channel; }
        
        /**
         * Sets the current settings of the sampler channel.
         * @param channel A <code>SamplerChannel</code> instance containing
         * the new settings for this sampler channel.
         * @throws IllegalArgumentException If <code>channel</code> is <code>null</code>.
         */
        public void
        setChannelInfo(SamplerChannel channel) {
                if(channel == null) throw new IllegalArgumentException("channel must be non null");
                if(this.channel == channel) return;
                
                this.channel = channel;
                fireSamplerChannelChanged();
        }
        
        /**
         * Gets the number of active disk streams.
         * @return The number of active disk streams.
         */
        public int
        getStreamCount() { return streamCount; }
        
        /**
         * Sets the number of active disk streams.
         * @param count The new number of active disk streams.
         */
        public void
        setStreamCount(int count) {
                if(streamCount == count) return;
                
                streamCount = count;
                fireStreamCountChanged();
        }
        
        /**
         * Gets the number of active voices.
         * @return The number of active voices.
         */
        public int
        getVoiceCount() { return voiceCount; }
        
        /**
         * Sets the number of active voices.
         * @param count The new number of active voices.
         */
        public void
        setVoiceCount(int count) {
                if(voiceCount == count) return;
                
                voiceCount = count;
                fireVoiceCountChanged();
        }
        
        /**
         * Sets the sampler engine type to be used.
         * @param engine The name of the engine type to be used.
         */
        public void
        setEngineType(String engine) {
                final LoadEngine loadEngine = new LoadEngine(engine, getChannelID());
                final SamplerChannelEvent event = new SamplerChannelEvent(this);
                
                loadEngine.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                /*
                                 * Because with the invokation of the method the task is considered
                                 * to be done, if the task fails, we must notify for a channel
                                 * changes. This should be done to revert the old channel settings.
                                 */
                                if(loadEngine.doneWithErrors()) fireSamplerChannelChanged(event);
                        }
                });
                CC.getTaskQueue().add(loadEngine);
                
                // We leave this event to be notified by the LinuxSampler notification system.
        }
        
        /**
         * Sets the mute mode of the channel. 
         * @param mute Specifies the mute mode. If <code>true</code> the channel is muted, else
         * the channel is unmuted.
         */
        public void
        setMute(boolean mute) {
                final SetMuteChannel smc = new SetMuteChannel(getChannelID(), mute);
                final SamplerChannelEvent event = new SamplerChannelEvent(this);
                
                smc.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                /*
                                 * Because with the invokation of the method the task is considered
                                 * to be done, if the task fails, we must notify for a channel
                                 * changes. This should be done to revert the old channel settings.
                                 */
                                if(smc.doneWithErrors()) fireSamplerChannelChanged(event);
                        }
                });
                CC.getTaskQueue().add(smc);
                
                // We leave this event to be notified by the LinuxSampler notification system.
        }
        
        /**
         * Sets the solo mode of the channel. 
         * @param solo Specifies the solo mode. If <code>true</code> the channel is soloed, else
         * the channel is unsoloed.
         */
        public void
        setSolo(boolean solo) {
                final SetSoloChannel ssc = new SetSoloChannel(getChannelID(), solo);
                final SamplerChannelEvent event = new SamplerChannelEvent(this);
                
                ssc.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                /*
                                 * Because with the invokation of the method the task is considered
                                 * to be done, if the task fails, we must notify for a channel
                                 * changes. This should be done to revert the old channel settings.
                                 */
                                if(ssc.doneWithErrors()) fireSamplerChannelChanged(event);
                        }
                });
                CC.getTaskQueue().add(ssc);
                
                // We leave this event to be notified by the LinuxSampler notification system.
        }
        
        /**
         * Sets the channel volume. 
         * @param volume Specifies the new volume value.
         */
        public void
        setVolume(float volume) {
                final SetChannelVolume scv = new SetChannelVolume(getChannelID(), volume);
                final SamplerChannelEvent event = new SamplerChannelEvent(this);
                
                scv.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                /*
                                 * Because with the invokation of the method the task is considered
                                 * to be done, if the task fails, we must notify for a channel
                                 * changes. This should be done to revert the old channel settings.
                                 */
                                if(scv.doneWithErrors()) fireSamplerChannelChanged(event);
                        }
                });
                CC.getTaskQueue().add(scv);
                
                // We leave this event to be notified by the LinuxSampler notification system.
        }
        
        /**
         * Sets the MIDI input device of the channel represented by this model. 
         * @param deviceID Specifies the numerical ID of the MIDI input device to be set.
         */
        public void
        setMidiInputDevice(int deviceID) {
                final Task scmid = new SetChannelMidiInputDevice(getChannelID(), deviceID);
                final SamplerChannelEvent event = new SamplerChannelEvent(this);
                
                scmid.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                /*
                                 * Because with the invokation of the method the task is considered
                                 * to be done, if the task fails, we must notify for a channel
                                 * changes. This should be done to revert the old channel settings.
                                 */
                                if(scmid.doneWithErrors()) fireSamplerChannelChanged(event);
                        }
                });
                CC.getTaskQueue().add(scmid);
                
                // We leave this event to be notified by the LinuxSampler notification system.
        }
        
        /**
         * Sets the MIDI input port of the channel represented by this model. 
         * @param port Specifies the number of the MIDI input port.
         */
        public void
        setMidiInputPort(int port) {
                final Task scmip = new SetChannelMidiInputPort(getChannelID(), port);
                final SamplerChannelEvent event = new SamplerChannelEvent(this);
                
                scmip.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                /*
                                 * Because with the invokation of the method the task is considered
                                 * to be done, if the task fails, we must notify for a channel
                                 * changes. This should be done to revert the old channel settings.
                                 */
                                if(scmip.doneWithErrors()) fireSamplerChannelChanged(event);
                        }
                });
                CC.getTaskQueue().add(scmip);
                
                // We leave this event to be notified by the LinuxSampler notification system.
        }
        
        /**
         * Sets the MIDI channel that the channel represented by this model should listen to. 
         * @param channel Specifies the MIDI channel that the channel
         * represented by this model should listen to.
         */
        public void
        setMidiInputChannel(int channel) {
                final Task scmic = new SetChannelMidiInputChannel(getChannelID(), channel);
                final SamplerChannelEvent event = new SamplerChannelEvent(this);
                
                scmic.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                /*
                                 * Because with the invokation of the method the task is considered
                                 * to be done, if the task fails, we must notify for a channel
                                 * changes. This should be done to revert the old channel settings.
                                 */
                                if(scmic.doneWithErrors()) fireSamplerChannelChanged(event);
                        }
                });
                CC.getTaskQueue().add(scmic);
                
                // We leave this event to be notified by the LinuxSampler notification system.
        }
        
        /**
         * Sets the audio output device of the channel represented by this model. 
         * @param deviceID Specifies the numerical ID of the audio output device to be set.
         */
        public void
        setAudioOutputDevice(int deviceID) {
                final Task scaod = new SetChannelAudioOutputDevice(getChannelID(), deviceID);
                final SamplerChannelEvent event = new SamplerChannelEvent(this);
                
                scaod.addTaskListener(new TaskListener() {
                        public void
                        taskPerformed(TaskEvent e) {
                                /*
                                 * Because with the invokation of the method the task is considered
                                 * to be done, if the task fails, we must notify for a channel
                                 * changes. This should be done to revert the old channel settings.
                                 */
                                if(scaod.doneWithErrors()) fireSamplerChannelChanged(event);
                        }
                });
                CC.getTaskQueue().add(scaod);
                
                // We leave this event to be notified by the LinuxSampler notification system.
        }
        
        /**
         * Loads and assigns the specified instrument
         * to the sampler channel represented by this model.
         * @param filename The file name of the instrument to be loaded.
         * @param InstrIndex The index of the instrument in the instrument file to be loaded.
         */
        public void
        loadInstrument(String filename, int InstrIndex) {
                final Task li = new LoadInstrument(filename, InstrIndex, getChannelID());
                CC.getTaskQueue().add(li);
                
                // We leave this event to be notified by the LinuxSampler notification system.
        }
        
        /** Notifies listeners that the sampler channel settings has changed. */
        protected void
        fireSamplerChannelChanged() {
                final SamplerChannelEvent e = new SamplerChannelEvent(this);
                
                SwingUtilities.invokeLater(new Runnable() {
                        public void
                        run() { fireSamplerChannelChanged(e); }
                });
        }
        
        /** 
         * Notifies listeners that the sampler channel settings has changed.
         * This method should be invoked from the event-dispatching thread.
         */
        protected void
        fireSamplerChannelChanged(SamplerChannelEvent e) {
                for(SamplerChannelListener l : listeners) l.channelChanged(e);
        }
        
        /** Notifies listeners that the number of active disk streams has changed. */
        protected void
        fireStreamCountChanged() {
                final SamplerChannelEvent e = new SamplerChannelEvent(this);
                
                SwingUtilities.invokeLater(new Runnable() {
                        public void
                        run() { fireStreamCountChanged(e); }
                });
        }
        
        /** 
         * Notifies listeners that the number of active disk streams has changed.
         * This method should be invoked from the event-dispatching thread.
         */
        protected void
        fireStreamCountChanged(SamplerChannelEvent e) {
                for(SamplerChannelListener l : listeners) l.streamCountChanged(e);
        }
        
        /** Notifies listeners that the number of active voices has changed. */
        protected void
        fireVoiceCountChanged() {
                final SamplerChannelEvent e = new SamplerChannelEvent(this);
                
                SwingUtilities.invokeLater(new Runnable() {
                        public void
                        run() { fireVoiceCountChanged(e); }
                });
        }
        
        /** 
         * Notifies listeners that the number of active voices has changed.
         * This method should be invoked from the event-dispatching thread.
         */
        protected void
        fireVoiceCountChanged(SamplerChannelEvent e) {
                for(SamplerChannelListener l : listeners) l.voiceCountChanged(e);
        }
}
1	iliev	787	/*
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;
24
25			import java.util.Vector;
26
27			import javax.swing.SwingUtilities;
28
29			import net.sf.juife.Task;
30			import net.sf.juife.event.TaskEvent;
31			import net.sf.juife.event.TaskListener;
32
33			import org.jsampler.event.SamplerChannelEvent;
34			import org.jsampler.event.SamplerChannelListener;
35
36			import org.jsampler.task.LoadEngine;
37			import org.jsampler.task.LoadInstrument;
38			import org.jsampler.task.SetChannelAudioOutputDevice;
39			import org.jsampler.task.SetChannelMidiInputChannel;
40			import org.jsampler.task.SetChannelMidiInputDevice;
41			import org.jsampler.task.SetChannelMidiInputPort;
42			import org.jsampler.task.SetChannelVolume;
43			import org.jsampler.task.SetMuteChannel;
44			import org.jsampler.task.SetSoloChannel;
45
46			import org.linuxsampler.lscp.SamplerChannel;
47
48
49			/**
50			*
51			* @author Grigor Iliev
52			*/
53			public class DefaultSamplerChannelModel implements SamplerChannelModel {
54			private SamplerChannel channel;
55			private int streamCount = 0;
56			private int voiceCount = 0;
57
58			private final Vector<SamplerChannelListener> listeners =
59			new Vector<SamplerChannelListener>();
60
61			/**
62			* Creates a new instance of <code>DefaultSamplerChannelModel</code> using the
63			* specified channel settings.
64			* @param channel A non-null <code>SamplerChannel</code> instance containing the current
65			* settings of the channel which will be represented by this sampler channel model.
66			* @throws IllegalArgumentException If <code>channel</code> is <code>null</code>.
67			*/
68			public DefaultSamplerChannelModel(SamplerChannel channel) {
69			if(channel == null) throw new IllegalArgumentException("channel must be non null");
70			this.channel = channel;
71			}
72
73			/**
74			* Registers the specified listener for receiving event messages.
75			* @param l The <code>SamplerChannelListener</code> to register.
76			*/
77			public void
78			addSamplerChannelListener(SamplerChannelListener l) { listeners.add(l); }
79
80			/**
81			* Removes the specified listener.
82			* @param l The <code>SamplerChannelListener</code> to remove.
83			*/
84			public void
85			removeSamplerChannelListener(SamplerChannelListener l) { listeners.remove(l); }
86
87			/**
88			* Gets the sampler channel number.
89			* @return The sampler channel number or -1 if the sampler channel number is not set.
90			*/
91			public int
92			getChannelID() { return channel == null ? -1 : channel.getChannelID(); }
93
94			/**
95			* Gets the current settings of the sampler channel.
96			* @return <code>SamplerChannel</code> instance containing
97			* the current settings of the sampler channel.
98			*/
99			public SamplerChannel
100			getChannelInfo() { return channel; }
101
102			/**
103			* Sets the current settings of the sampler channel.
104			* @param channel A <code>SamplerChannel</code> instance containing
105			* the new settings for this sampler channel.
106			* @throws IllegalArgumentException If <code>channel</code> is <code>null</code>.
107			*/
108			public void
109			setChannelInfo(SamplerChannel channel) {
110			if(channel == null) throw new IllegalArgumentException("channel must be non null");
111			if(this.channel == channel) return;
112
113			this.channel = channel;
114			fireSamplerChannelChanged();
115			}
116
117			/**
118			* Gets the number of active disk streams.
119			* @return The number of active disk streams.
120			*/
121			public int
122			getStreamCount() { return streamCount; }
123
124			/**
125			* Sets the number of active disk streams.
126			* @param count The new number of active disk streams.
127			*/
128			public void
129			setStreamCount(int count) {
130			if(streamCount == count) return;
131
132			streamCount = count;
133			fireStreamCountChanged();
134			}
135
136			/**
137			* Gets the number of active voices.
138			* @return The number of active voices.
139			*/
140			public int
141			getVoiceCount() { return voiceCount; }
142
143			/**
144			* Sets the number of active voices.
145			* @param count The new number of active voices.
146			*/
147			public void
148			setVoiceCount(int count) {
149			if(voiceCount == count) return;
150
151			voiceCount = count;
152			fireVoiceCountChanged();
153			}
154
155			/**
156			* Sets the sampler engine type to be used.
157			* @param engine The name of the engine type to be used.
158			*/
159			public void
160			setEngineType(String engine) {
161			final LoadEngine loadEngine = new LoadEngine(engine, getChannelID());
162			final SamplerChannelEvent event = new SamplerChannelEvent(this);
163
164			loadEngine.addTaskListener(new TaskListener() {
165			public void
166			taskPerformed(TaskEvent e) {
167			/*
168			* Because with the invokation of the method the task is considered
169			* to be done, if the task fails, we must notify for a channel
170			* changes. This should be done to revert the old channel settings.
171			*/
172			if(loadEngine.doneWithErrors()) fireSamplerChannelChanged(event);
173			}
174			});
175			CC.getTaskQueue().add(loadEngine);
176
177			// We leave this event to be notified by the LinuxSampler notification system.
178			}
179
180			/**
181			* Sets the mute mode of the channel.
182			* @param mute Specifies the mute mode. If <code>true</code> the channel is muted, else
183			* the channel is unmuted.
184			*/
185			public void
186			setMute(boolean mute) {
187			final SetMuteChannel smc = new SetMuteChannel(getChannelID(), mute);
188			final SamplerChannelEvent event = new SamplerChannelEvent(this);
189
190			smc.addTaskListener(new TaskListener() {
191			public void
192			taskPerformed(TaskEvent e) {
193			/*
194			* Because with the invokation of the method the task is considered
195			* to be done, if the task fails, we must notify for a channel
196			* changes. This should be done to revert the old channel settings.
197			*/
198			if(smc.doneWithErrors()) fireSamplerChannelChanged(event);
199			}
200			});
201			CC.getTaskQueue().add(smc);
202
203			// We leave this event to be notified by the LinuxSampler notification system.
204			}
205
206			/**
207			* Sets the solo mode of the channel.
208			* @param solo Specifies the solo mode. If <code>true</code> the channel is soloed, else
209			* the channel is unsoloed.
210			*/
211			public void
212			setSolo(boolean solo) {
213			final SetSoloChannel ssc = new SetSoloChannel(getChannelID(), solo);
214			final SamplerChannelEvent event = new SamplerChannelEvent(this);
215
216			ssc.addTaskListener(new TaskListener() {
217			public void
218			taskPerformed(TaskEvent e) {
219			/*
220			* Because with the invokation of the method the task is considered
221			* to be done, if the task fails, we must notify for a channel
222			* changes. This should be done to revert the old channel settings.
223			*/
224			if(ssc.doneWithErrors()) fireSamplerChannelChanged(event);
225			}
226			});
227			CC.getTaskQueue().add(ssc);
228
229			// We leave this event to be notified by the LinuxSampler notification system.
230			}
231
232			/**
233			* Sets the channel volume.
234			* @param volume Specifies the new volume value.
235			*/
236			public void
237			setVolume(float volume) {
238			final SetChannelVolume scv = new SetChannelVolume(getChannelID(), volume);
239			final SamplerChannelEvent event = new SamplerChannelEvent(this);
240
241			scv.addTaskListener(new TaskListener() {
242			public void
243			taskPerformed(TaskEvent e) {
244			/*
245			* Because with the invokation of the method the task is considered
246			* to be done, if the task fails, we must notify for a channel
247			* changes. This should be done to revert the old channel settings.
248			*/
249			if(scv.doneWithErrors()) fireSamplerChannelChanged(event);
250			}
251			});
252			CC.getTaskQueue().add(scv);
253
254			// We leave this event to be notified by the LinuxSampler notification system.
255			}
256
257			/**
258			* Sets the MIDI input device of the channel represented by this model.
259			* @param deviceID Specifies the numerical ID of the MIDI input device to be set.
260			*/
261			public void
262			setMidiInputDevice(int deviceID) {
263			final Task scmid = new SetChannelMidiInputDevice(getChannelID(), deviceID);
264			final SamplerChannelEvent event = new SamplerChannelEvent(this);
265
266			scmid.addTaskListener(new TaskListener() {
267			public void
268			taskPerformed(TaskEvent e) {
269			/*
270			* Because with the invokation of the method the task is considered
271			* to be done, if the task fails, we must notify for a channel
272			* changes. This should be done to revert the old channel settings.
273			*/
274			if(scmid.doneWithErrors()) fireSamplerChannelChanged(event);
275			}
276			});
277			CC.getTaskQueue().add(scmid);
278
279			// We leave this event to be notified by the LinuxSampler notification system.
280			}
281
282			/**
283			* Sets the MIDI input port of the channel represented by this model.
284			* @param port Specifies the number of the MIDI input port.
285			*/
286			public void
287			setMidiInputPort(int port) {
288			final Task scmip = new SetChannelMidiInputPort(getChannelID(), port);
289			final SamplerChannelEvent event = new SamplerChannelEvent(this);
290
291			scmip.addTaskListener(new TaskListener() {
292			public void
293			taskPerformed(TaskEvent e) {
294			/*
295			* Because with the invokation of the method the task is considered
296			* to be done, if the task fails, we must notify for a channel
297			* changes. This should be done to revert the old channel settings.
298			*/
299			if(scmip.doneWithErrors()) fireSamplerChannelChanged(event);
300			}
301			});
302			CC.getTaskQueue().add(scmip);
303
304			// We leave this event to be notified by the LinuxSampler notification system.
305			}
306
307			/**
308			* Sets the MIDI channel that the channel represented by this model should listen to.
309			* @param channel Specifies the MIDI channel that the channel
310			* represented by this model should listen to.
311			*/
312			public void
313			setMidiInputChannel(int channel) {
314			final Task scmic = new SetChannelMidiInputChannel(getChannelID(), channel);
315			final SamplerChannelEvent event = new SamplerChannelEvent(this);
316
317			scmic.addTaskListener(new TaskListener() {
318			public void
319			taskPerformed(TaskEvent e) {
320			/*
321			* Because with the invokation of the method the task is considered
322			* to be done, if the task fails, we must notify for a channel
323			* changes. This should be done to revert the old channel settings.
324			*/
325			if(scmic.doneWithErrors()) fireSamplerChannelChanged(event);
326			}
327			});
328			CC.getTaskQueue().add(scmic);
329
330			// We leave this event to be notified by the LinuxSampler notification system.
331			}
332
333			/**
334			* Sets the audio output device of the channel represented by this model.
335			* @param deviceID Specifies the numerical ID of the audio output device to be set.
336			*/
337			public void
338			setAudioOutputDevice(int deviceID) {
339			final Task scaod = new SetChannelAudioOutputDevice(getChannelID(), deviceID);
340			final SamplerChannelEvent event = new SamplerChannelEvent(this);
341
342			scaod.addTaskListener(new TaskListener() {
343			public void
344			taskPerformed(TaskEvent e) {
345			/*
346			* Because with the invokation of the method the task is considered
347			* to be done, if the task fails, we must notify for a channel
348			* changes. This should be done to revert the old channel settings.
349			*/
350			if(scaod.doneWithErrors()) fireSamplerChannelChanged(event);
351			}
352			});
353			CC.getTaskQueue().add(scaod);
354
355			// We leave this event to be notified by the LinuxSampler notification system.
356			}
357
358			/**
359			* Loads and assigns the specified instrument
360			* to the sampler channel represented by this model.
361			* @param filename The file name of the instrument to be loaded.
362			* @param InstrIndex The index of the instrument in the instrument file to be loaded.
363			*/
364			public void
365			loadInstrument(String filename, int InstrIndex) {
366			final Task li = new LoadInstrument(filename, InstrIndex, getChannelID());
367			CC.getTaskQueue().add(li);
368
369			// We leave this event to be notified by the LinuxSampler notification system.
370			}
371
372			/** Notifies listeners that the sampler channel settings has changed. */
373			protected void
374			fireSamplerChannelChanged() {
375			final SamplerChannelEvent e = new SamplerChannelEvent(this);
376
377			SwingUtilities.invokeLater(new Runnable() {
378			public void
379			run() { fireSamplerChannelChanged(e); }
380			});
381			}
382
383			/**
384			* Notifies listeners that the sampler channel settings has changed.
385			* This method should be invoked from the event-dispatching thread.
386			*/
387			protected void
388			fireSamplerChannelChanged(SamplerChannelEvent e) {
389			for(SamplerChannelListener l : listeners) l.channelChanged(e);
390			}
391
392			/** Notifies listeners that the number of active disk streams has changed. */
393			protected void
394			fireStreamCountChanged() {
395			final SamplerChannelEvent e = new SamplerChannelEvent(this);
396
397			SwingUtilities.invokeLater(new Runnable() {
398			public void
399			run() { fireStreamCountChanged(e); }
400			});
401			}
402
403			/**
404			* Notifies listeners that the number of active disk streams has changed.
405			* This method should be invoked from the event-dispatching thread.
406			*/
407			protected void
408			fireStreamCountChanged(SamplerChannelEvent e) {
409			for(SamplerChannelListener l : listeners) l.streamCountChanged(e);
410			}
411
412			/** Notifies listeners that the number of active voices has changed. */
413			protected void
414			fireVoiceCountChanged() {
415			final SamplerChannelEvent e = new SamplerChannelEvent(this);
416
417			SwingUtilities.invokeLater(new Runnable() {
418			public void
419			run() { fireVoiceCountChanged(e); }
420			});
421			}
422
423			/**
424			* Notifies listeners that the number of active voices has changed.
425			* This method should be invoked from the event-dispatching thread.
426			*/
427			protected void
428			fireVoiceCountChanged(SamplerChannelEvent e) {
429			for(SamplerChannelListener l : listeners) l.voiceCountChanged(e);
430			}
431			}