org/jsampler/SamplerModel.java

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

import org.jsampler.event.ListListener;
import org.jsampler.event.MidiDeviceListListener;
import org.jsampler.event.SamplerChannelListListener;
import org.jsampler.event.SamplerListener;

import org.linuxsampler.lscp.*;


/**
 * A data model representing a sampler.
 * Note that the setter methods does <b>not</b> alter any settings
 * on the backend side unless otherwise specified.
 * @author Grigor Iliev
 */
public interface SamplerModel {
        /**
         * Registers the specified listener for receiving event messages.
         * @param l The <code>SamplerListener</code> to register.
         */
        public void addSamplerListener(SamplerListener l);
        
        /**
         * Removes the specified listener.
         * @param l The <code>SamplerListener</code> to remove.
         */
        public void removeSamplerListener(SamplerListener l);
        
        /**
         * Registers the specified listener for receiving event messages.
         * @param listener The <code>ListListener</code> to register.
         */
        public void addAudioDeviceListListener(ListListener<AudioDeviceModel> listener);
        
        /**
         * Removes the specified listener.
         * @param listener The <code>ListListener</code> to remove.
         */
        public void removeAudioDeviceListListener(ListListener<AudioDeviceModel> listener);
        
        /**
         * Registers the specified listener for receiving event messages.
         * @param listener The <code>MidiDeviceListListener</code> to register.
         */
        public void addMidiDeviceListListener(MidiDeviceListListener listener);
        
        /**
         * Removes the specified listener.
         * @param listener The <code>MidiDeviceListListener</code> to remove.
         */
        public void removeMidiDeviceListListener(MidiDeviceListListener listener);
        
        /**
         * Registers the specified listener for receiving event messages.
         * @param listener The <code>ListListener</code> to register.
         */
        public void addMidiInstrumentMapListListener(ListListener<MidiInstrumentMap> listener);
        
        /**
         * Removes the specified listener.
         * @param listener The <code>ListListener</code> to remove.
         */
        public void removeMidiInstrumentMapListListener(ListListener<MidiInstrumentMap> listener);
        
        /**
         * Registers the specified listener for receiving event messages.
         * @param listener The <code>SamplerChannelListListener</code> to register.
         */
        public void addSamplerChannelListListener(SamplerChannelListListener listener);
        
        /**
         * Removes the specified listener.
         * @param listener The <code>SamplerChannelListListener</code> to remove.
         */
        public void removeSamplerChannelListListener(SamplerChannelListListener listener);
        
        /**
         * Gets information about the LinuxSampler instance the front-end is connected to.
         * 
         * @return <code>ServerInfo</code> instance containing
         * information about the LinuxSampler instance the front-end is connected to.
         */
        public ServerInfo getServerInfo();
        
        /**
         * Gets all audio output drivers currently available for the LinuxSampler instance.
         * 
         * @return <code>AudioOutputDriver</code> array containing all audio output drivers
         * currently available for the LinuxSampler instance.
         */
        public AudioOutputDriver[] getAudioOutputDrivers();
        
        
        /**
         * Gets the model of the audio device at the specified position.
         * @param index The position of the audio device to return.
         * @return The model of the audio device at the specified position.
         * @see #getAudioDeviceCount
         */
        public AudioDeviceModel getAudioDevice(int index);
        
        /**
         * Gets the model of the audio device with ID <code>deviceId</code>.
         * @param deviceId The ID of the audio device whose model should be obtained.
         * @return The model of the specified audio device or <code>null</code> 
         * if there is no audio device with ID <code>deviceId</code>.
         */
        public AudioDeviceModel getAudioDeviceById(int deviceId);
        
        /**
         * Gets the current number of audio devices.
         * @return The current number of audio devices.
         */
        public int getAudioDeviceCount();
        
        /**
         * Gets the current list of audio device models.
         * @return The current list of audio device models.
         */
        public AudioDeviceModel[] getAudioDevices();
        
        /**
         * Adds the specified audio device.
         * @param device The audio device to be added.
         */
        public void addAudioDevice(AudioOutputDevice device);
        
        /**
         * Removes the specified audio device.
         * @param deviceId The ID of the audio device to be removed.
         * @return <code>true</code> if the audio device is removed successfully, <code>false</code>
         * if the device list does not contain audio device with ID <code>deviceId</code>.
         */
        public boolean removeAudioDeviceById(int deviceId);
        
        /**
         * Removes (on the backend side) the specified audio device.
         * @param deviceId The ID of the audio device to be removed.
         */
        public void removeBackendAudioDevice(int deviceId);
        
        /**
         * Gets all MIDI input drivers currently available for the LinuxSampler instance.
         * 
         * @return <code>MidiInputDriver</code> array containing all MIDI input drivers currently 
         * available for the LinuxSampler instance.
         */
        public MidiInputDriver[] getMidiInputDrivers();
        
        /**
         * Gets the model of the MIDI device at the specified position.
         * @param index The position of the MIDI device to return.
         * @return The model of the MIDI device at the specified position.
         */
        public MidiDeviceModel getMidiDevice(int index);
        
        /**
         * Gets the model of the MIDI device with ID <code>deviceId</code>.
         * @param deviceId The ID of the MIDI device whose model should be obtained.
         * @return The model of the specified MIDI device or <code>null</code> 
         * if there is no MIDI device with ID <code>deviceId</code>.
         */
        public MidiDeviceModel getMidiDeviceById(int deviceId);
        
        /**
         * Gets the current number of MIDI input devices.
         * @return The current number of MIDI input devices.
         */
        public int getMidiDeviceCount();
        
        /**
         * Gets the current list of MIDI device models.
         * @return The current list of MIDI device models.
         */
        public MidiDeviceModel[] getMidiDevices();
        
        /**
         * Adds the specified MIDI device.
         * @param device The MIDI device to be added.
         */
        public void addMidiDevice(MidiInputDevice device);
        
        /**
         * Schedules a new task for adding new MIDI device.
         * @param driver The desired MIDI input system.
         * @param parameters An optional list of driver specific parameters.
         */
        public void addBackendMidiDevice(String driver, Parameter... parameters);
        
        /**
         * Removes the specified MIDI device.
         * @param deviceId The ID of the MIDI device to be removed.
         * @return <code>true</code> if the MIDI device is removed successfully, <code>false</code>
         * if the device list does not contain MIDI device with ID <code>deviceId</code>.
         */
        public boolean removeMidiDeviceById(int deviceId);
        
        /**
         * Schedules a new task for removing the specified MIDI device.
         * @param deviceId The ID of the MIDI input device to be destroyed.
         */
        public void removeBackendMidiDevice(int deviceId);
        
        /**
         * Gets the MIDI instrument map with ID <code>mapId</code>.
         * @param mapId The ID of the MIDI instrument map to obtain.
         * @return The MIDI instrument map with the specified ID or <code>null</code> 
         * if there is no MIDI instrument map with ID <code>mapId</code>.
         */
        public MidiInstrumentMap getMidiInstrumentMapById(int mapId);
        
        /**
         * Gets the MIDI instrument map at the specified position.
         * @param index The position of the MIDI instrument map to return.
         * @return The MIDI instrument map at the specified position.
         */
        public MidiInstrumentMap getMidiInstrumentMap(int index);
        
        /**
         * Gets the current number of MIDI instrument maps.
         * @return The current number of MIDI instrument maps.
         */
        public int getMidiInstrumentMapCount();
        
        /**
         * Gets the current list of MIDI instrument maps.
         * @return The current list of MIDI instrument maps.
         */
        public MidiInstrumentMap[] getMidiInstrumentMaps();
        
        /**
         * Gets the position of the specified MIDI instrument map in the list.
         * @param map The map whose index should be returned.
         * @return The position of the specified map in the list,
         * or -1 if <code>map</code> is <code>null</code> or
         * the map list does not contain the specified map.
         */
        public int getMidiInstrumentMapIndex(MidiInstrumentMap map);
        
        /**
         * Adds the specified MIDI instrument map.
         * @param map The MIDI instrument map to be added.
         */
        public void addMidiInstrumentMap(MidiInstrumentMap map);
        
        /**
         * Schedules a new task for creating a new MIDI instrument map on the backend side.
         * @param name The name of the MIDI instrument map.
         * @throws IllegalArgumentException If <code>name</code> is <code>null</code>.
         */
        public void addBackendMidiInstrumentMap(String name);
        
        /**
         * Removes the specified MIDI instrument map.
         * @param mapId The ID of the MIDI instrument map to be removed.
         * @return <code>true</code> if the MIDI instrument map is removed successfully,
         * <code>false</code> if the MIDI instrument map's list does not contain
         * MIDI instrument map with ID <code>mapId</code>.
         */
        public boolean removeMidiInstrumentMapById(int mapId);
        
        /** Removes all MIDI instrument maps. */
        public void removeAllMidiInstrumentMaps();
        
        /**
         * Schedules a new task for removing the
         * specified MIDI instrument map on the backend side.
         * @param mapId The numerical ID of the MIDI instrument map to remove.
         * @throws IllegalArgumentException If <code>mapId</code> is negative.
         */
        public void removeBackendMidiInstrumentMap(int mapId);
        
        /**
         * Schedules a new task for changing the name of
         * the specified MIDI instrument map on the backend side.
         * @param mapId The numerical ID of the MIDI instrument map.
         * @param name The new name for the specified MIDI instrument map.
         */
        public void setBackendMidiInstrumentMapName(int mapId, String name);
        
        /**
         * Gets the default MIDI instrument map.
         * @return The default MIDI instrument map or <code>null</code>
         * if there are no maps created.
         */
        public MidiInstrumentMap getDefaultMidiInstrumentMap();
        
        /**
         * Schedules a new task for mapping a MIDI instrument on the backend side.
         * @param mapId The id of the MIDI instrument map.
         * @param bank The index of the MIDI bank, which shall contain the instrument.
         * @param program The MIDI program number of the new instrument.
         * @param instrInfo Provides the MIDI instrument settings.
         */
        public void
        mapBackendMidiInstrument(int mapId, int bank, int program, MidiInstrumentInfo instrInfo);
        
        /**
         * Schedules a new task for removing a MIDI instrument on the backend side.
         * @param mapId The id of the MIDI instrument map containing the instrument to be removed.
         * @param bank The index of the MIDI bank containing the instrument to be removed.
         * @param program The MIDI program number of the instrument to be removed.
         */
        public void unmapBackendMidiInstrument(int mapId, int bank, int program);
        
        /**
         * Gets a list of all available engines.
         * @return A list of all available engines.
         */
        public SamplerEngine[] getEngines();
        
        /**
         * Gets the current list of sampler channel models.
         * @return The current list of sampler channel models.
         */
        public SamplerChannelModel[] getChannels();
        
        /**
         * Gets the model of the sampler channel in the specified position.
         * @param index The position of the channel to return.
         * @return The model of the specified sampler channel.
         * @see #getchannelCount
         */
        public SamplerChannelModel getChannel(int index);
        
        /**
         * Gets the model of the sampler channel with ID <code>channelId</code>.
         * @param channelId The ID of the sampler channel whose model should be obtained.
         * @return The model of the specified sampler channel or <code>null</code> 
         * if there is no channel with ID <code>channelId</code>.
         */
        public SamplerChannelModel getChannelById(int channelId);
        
        /**
         * Gets the position of the specified channel.
         * @param channel The model of the channel.
         * @return The position of the specified channel in the channel list or -1
         * if the channel is not in the list.
         */
        public int getChannelIndex(SamplerChannelModel channel);
        
        /**
         * Gets the current number of sampler channels.
         * @return The current number of sampler channels.
         */
        public int getChannelCount();
        
        /**
         * Adds a new sampler channel on the backend side. The channel will
         * be actually added to this model when the backend notifies for its creation.
         * @see #addChannel
         */
        public void addBackendChannel();
        
        /**
         * Adds the specified sampler channel.
         * @param channel The channel to be added.
         */
        public void addChannel(SamplerChannel channel);
        
        /**
         * Removes the specified sampler channel.
         * Note that this method doesn't remove the channel in the backend,
         * it is used to remove the channel from the model when those channel
         * is removed in the backend.
         * @param channelId The ID of the channel to be removed.
         * @return <code>true</code> if the channel is removed successfully, <code>false</code>
         * if the channel's list does not contain channel with ID <code>channelId</code>.
         */
        public boolean removeChannelById(int channelId);
        
        /**
         * Removes all sampler channels.
         * Note that this method doesn't remove the channel in the backend.
         */
        public void removeAllChannels();
        
        /**
         * Schedules a new task for removing the specified sampler channel on the backend side.
         * @param channelId The ID of the channel to be removed.
         */
        public void removeBackendChannel(int channelId);
        
        /**
         * Updates the settings of the specified channel.
         * @param channel A <code>SamplerChannel</code> instance containing the new settings
         * for the channel.
         */
        public void updateChannel(SamplerChannel channel);
        
        /**
         * Determines whether there are known upcoming changes to the 
         * channel list, which should be considered as part of a single action.
         */
        public boolean getChannelListIsAdjusting();
        
        /**
         * Sets whether the upcoming changes to the 
         * channel list should be considered part of a single action.
         */
        public void setChannelListIsAdjusting(boolean b);
        
        /**
         * Schedules a new task for starting an instrument editor for editing
         * the loaded instrument on the specified sampler channel.
         * @param channelId The sampler channel number.
         */
        public void editBackendInstrument(int channelId);
        
        /**
         * Determines whether there is at least one solo channel in the current list
         * of sampler channels.
         * @return <code>true</code> if there is at least one solo channel in the current list of 
         * sampler channels, <code>false</code> otherwise.
         */
        public boolean hasSoloChannel();
        
        /**
         * Gets the number of solo channels in the current list of sampler channels.
         * @return The number of solo channels in the current list of sampler channels.
         */
        public int getSoloChannelCount();
        
        /**
         * Gets the number of muted channels in the current list of sampler channels.
         * This number includes the channels muted because of the presence of a solo channel.
         * @return The number of muted channels in the current list of sampler channels.
         */
        public int getMutedChannelCount();
        
        /**
         * Gets the number of channels muted because of the presence of a solo channel.
         * @return The number of channels muted because of the presence of a solo channel.
         */
        public int getMutedBySoloChannelCount();
        
        /**
         * Gets the total number of active streams.
         * @return The total number of active streams.
         */
        public int getTotalStreamCount();
        
        /**
         * Gets the total number of active voices.
         * @return The total number of active voices.
         */
        public int getTotalVoiceCount();
        
        /**
         * Gets the maximum number of active voices.
         * @return The maximum number of active voices.
         */
        public int getTotalVoiceCountMax();
        
        /**
         * Gets the golobal volume of the sampler.
         * @return The golobal volume of the sampler.
         */
        public float getVolume();
        
        /**
         * Sets the global volume.
         * @param volume The new volume value.
         */
        public void setVolume(float volume);
        
        /**
         * Sets the global volume on the backend side.
         * @param volume The new volume value.
         */
        public void setBackendVolume(float volume);
        
        /** Gets the list of internal effects */
        public EffectList getEffects();
        
        public EffectInstance getEffectInstanceById(int instanceId);
        
        public void updateEffectInstance(EffectInstanceInfo instance);
        
        /**
         * Schedules a new task for resetting the sampler.
         */
        public void resetBackend();
        
        /**
         * Updates the current number of active disk streams in the sampler.
         * @param count The new number of active streams.
         */
        public void updateActiveStreamsInfo(int count);
        
        /**
         * Updates the current and the maximum number of active voices in the sampler.
         * @param count The new number of active voices.
         * @param countMax The maximum number of active voices.
         */
        public void updateActiveVoiceInfo(int count, int countMax);
        
        /**
         * Determines whether the sampler configuration is modified.
         */
        public boolean isModified();
        
        /**
         * Sets whether the sampler configuration is modified.
         */
        public void setModified(boolean b);
        
        /** Resets the model. */
        public void reset();
}
1	iliev	787	/*
2			* JSampler - a java front-end for LinuxSampler
3			*
4	iliev	2192	* Copyright (C) 2005-2011 Grigor Iliev <grigor@grigoriliev.com>
5	iliev	787	*
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	iliev	1143	import org.jsampler.event.ListListener;
26	iliev	787	import org.jsampler.event.MidiDeviceListListener;
27			import org.jsampler.event.SamplerChannelListListener;
28			import org.jsampler.event.SamplerListener;
29
30			import org.linuxsampler.lscp.*;
31
32
33			/**
34	iliev	911	* A data model representing a sampler.
35	iliev	1143	* Note that the setter methods does <b>not</b> alter any settings
36			* on the backend side unless otherwise specified.
37	iliev	787	* @author Grigor Iliev
38			*/
39			public interface SamplerModel {
40			/**
41			* Registers the specified listener for receiving event messages.
42			* @param l The <code>SamplerListener</code> to register.
43			*/
44			public void addSamplerListener(SamplerListener l);
45
46			/**
47			* Removes the specified listener.
48			* @param l The <code>SamplerListener</code> to remove.
49			*/
50			public void removeSamplerListener(SamplerListener l);
51
52			/**
53			* Registers the specified listener for receiving event messages.
54	iliev	1143	* @param listener The <code>ListListener</code> to register.
55	iliev	787	*/
56	iliev	1143	public void addAudioDeviceListListener(ListListener<AudioDeviceModel> listener);
57	iliev	787
58			/**
59			* Removes the specified listener.
60	iliev	1143	* @param listener The <code>ListListener</code> to remove.
61	iliev	787	*/
62	iliev	1143	public void removeAudioDeviceListListener(ListListener<AudioDeviceModel> listener);
63	iliev	787
64			/**
65			* Registers the specified listener for receiving event messages.
66			* @param listener The <code>MidiDeviceListListener</code> to register.
67			*/
68			public void addMidiDeviceListListener(MidiDeviceListListener listener);
69
70			/**
71			* Removes the specified listener.
72			* @param listener The <code>MidiDeviceListListener</code> to remove.
73			*/
74			public void removeMidiDeviceListListener(MidiDeviceListListener listener);
75
76			/**
77			* Registers the specified listener for receiving event messages.
78	iliev	1143	* @param listener The <code>ListListener</code> to register.
79			*/
80			public void addMidiInstrumentMapListListener(ListListener<MidiInstrumentMap> listener);
81
82			/**
83			* Removes the specified listener.
84			* @param listener The <code>ListListener</code> to remove.
85			*/
86			public void removeMidiInstrumentMapListListener(ListListener<MidiInstrumentMap> listener);
87
88			/**
89			* Registers the specified listener for receiving event messages.
90	iliev	787	* @param listener The <code>SamplerChannelListListener</code> to register.
91			*/
92			public void addSamplerChannelListListener(SamplerChannelListListener listener);
93
94			/**
95			* Removes the specified listener.
96			* @param listener The <code>SamplerChannelListListener</code> to remove.
97			*/
98			public void removeSamplerChannelListListener(SamplerChannelListListener listener);
99
100			/**
101			* Gets information about the LinuxSampler instance the front-end is connected to.
102			*
103			* @return <code>ServerInfo</code> instance containing
104			* information about the LinuxSampler instance the front-end is connected to.
105			*/
106			public ServerInfo getServerInfo();
107
108			/**
109			* Gets all audio output drivers currently available for the LinuxSampler instance.
110			*
111			* @return <code>AudioOutputDriver</code> array containing all audio output drivers
112			* currently available for the LinuxSampler instance.
113			*/
114			public AudioOutputDriver[] getAudioOutputDrivers();
115
116	iliev	1467
117
118	iliev	787	/**
119	iliev	1467	* Gets the model of the audio device at the specified position.
120			* @param index The position of the audio device to return.
121			* @return The model of the audio device at the specified position.
122			* @see #getAudioDeviceCount
123			*/
124			public AudioDeviceModel getAudioDevice(int index);
125
126			/**
127	iliev	1143	* Gets the model of the audio device with ID <code>deviceId</code>.
128			* @param deviceId The ID of the audio device whose model should be obtained.
129	iliev	787	* @return The model of the specified audio device or <code>null</code>
130	iliev	1143	* if there is no audio device with ID <code>deviceId</code>.
131	iliev	787	*/
132	iliev	1204	public AudioDeviceModel getAudioDeviceById(int deviceId);
133	iliev	787
134			/**
135			* Gets the current number of audio devices.
136			* @return The current number of audio devices.
137			*/
138			public int getAudioDeviceCount();
139
140			/**
141			* Gets the current list of audio device models.
142			* @return The current list of audio device models.
143			*/
144	iliev	1204	public AudioDeviceModel[] getAudioDevices();
145	iliev	787
146			/**
147			* Adds the specified audio device.
148			* @param device The audio device to be added.
149			*/
150			public void addAudioDevice(AudioOutputDevice device);
151
152			/**
153			* Removes the specified audio device.
154	iliev	1143	* @param deviceId The ID of the audio device to be removed.
155	iliev	787	* @return <code>true</code> if the audio device is removed successfully, <code>false</code>
156	iliev	1143	* if the device list does not contain audio device with ID <code>deviceId</code>.
157	iliev	787	*/
158	iliev	1204	public boolean removeAudioDeviceById(int deviceId);
159	iliev	787
160			/**
161	iliev	1143	* Removes (on the backend side) the specified audio device.
162			* @param deviceId The ID of the audio device to be removed.
163			*/
164			public void removeBackendAudioDevice(int deviceId);
165
166			/**
167	iliev	787	* Gets all MIDI input drivers currently available for the LinuxSampler instance.
168			*
169			* @return <code>MidiInputDriver</code> array containing all MIDI input drivers currently
170			* available for the LinuxSampler instance.
171			*/
172			public MidiInputDriver[] getMidiInputDrivers();
173
174			/**
175	iliev	1467	* Gets the model of the MIDI device at the specified position.
176			* @param index The position of the MIDI device to return.
177			* @return The model of the MIDI device at the specified position.
178			*/
179			public MidiDeviceModel getMidiDevice(int index);
180
181			/**
182	iliev	1143	* Gets the model of the MIDI device with ID <code>deviceId</code>.
183			* @param deviceId The ID of the MIDI device whose model should be obtained.
184	iliev	787	* @return The model of the specified MIDI device or <code>null</code>
185	iliev	1143	* if there is no MIDI device with ID <code>deviceId</code>.
186	iliev	787	*/
187	iliev	1204	public MidiDeviceModel getMidiDeviceById(int deviceId);
188	iliev	787
189			/**
190			* Gets the current number of MIDI input devices.
191			* @return The current number of MIDI input devices.
192			*/
193			public int getMidiDeviceCount();
194
195			/**
196			* Gets the current list of MIDI device models.
197			* @return The current list of MIDI device models.
198			*/
199	iliev	1204	public MidiDeviceModel[] getMidiDevices();
200	iliev	787
201			/**
202			* Adds the specified MIDI device.
203			* @param device The MIDI device to be added.
204			*/
205			public void addMidiDevice(MidiInputDevice device);
206
207			/**
208	iliev	1143	* Schedules a new task for adding new MIDI device.
209			* @param driver The desired MIDI input system.
210			* @param parameters An optional list of driver specific parameters.
211			*/
212			public void addBackendMidiDevice(String driver, Parameter... parameters);
213
214			/**
215	iliev	787	* Removes the specified MIDI device.
216	iliev	1143	* @param deviceId The ID of the MIDI device to be removed.
217	iliev	787	* @return <code>true</code> if the MIDI device is removed successfully, <code>false</code>
218	iliev	1143	* if the device list does not contain MIDI device with ID <code>deviceId</code>.
219	iliev	787	*/
220	iliev	1204	public boolean removeMidiDeviceById(int deviceId);
221	iliev	787
222			/**
223	iliev	1143	* Schedules a new task for removing the specified MIDI device.
224			* @param deviceId The ID of the MIDI input device to be destroyed.
225			*/
226			public void removeBackendMidiDevice(int deviceId);
227
228			/**
229			* Gets the MIDI instrument map with ID <code>mapId</code>.
230			* @param mapId The ID of the MIDI instrument map to obtain.
231			* @return The MIDI instrument map with the specified ID or <code>null</code>
232			* if there is no MIDI instrument map with ID <code>mapId</code>.
233			*/
234			public MidiInstrumentMap getMidiInstrumentMapById(int mapId);
235
236			/**
237			* Gets the MIDI instrument map at the specified position.
238			* @param index The position of the MIDI instrument map to return.
239			* @return The MIDI instrument map at the specified position.
240			*/
241			public MidiInstrumentMap getMidiInstrumentMap(int index);
242
243			/**
244			* Gets the current number of MIDI instrument maps.
245			* @return The current number of MIDI instrument maps.
246			*/
247			public int getMidiInstrumentMapCount();
248
249			/**
250			* Gets the current list of MIDI instrument maps.
251			* @return The current list of MIDI instrument maps.
252			*/
253			public MidiInstrumentMap[] getMidiInstrumentMaps();
254
255			/**
256	iliev	1285	* Gets the position of the specified MIDI instrument map in the list.
257			* @param map The map whose index should be returned.
258			* @return The position of the specified map in the list,
259			* or -1 if <code>map</code> is <code>null</code> or
260			* the map list does not contain the specified map.
261			*/
262			public int getMidiInstrumentMapIndex(MidiInstrumentMap map);
263
264			/**
265	iliev	1143	* Adds the specified MIDI instrument map.
266			* @param map The MIDI instrument map to be added.
267			*/
268			public void addMidiInstrumentMap(MidiInstrumentMap map);
269
270			/**
271			* Schedules a new task for creating a new MIDI instrument map on the backend side.
272			* @param name The name of the MIDI instrument map.
273			* @throws IllegalArgumentException If <code>name</code> is <code>null</code>.
274			*/
275			public void addBackendMidiInstrumentMap(String name);
276
277			/**
278			* Removes the specified MIDI instrument map.
279			* @param mapId The ID of the MIDI instrument map to be removed.
280			* @return <code>true</code> if the MIDI instrument map is removed successfully,
281			* <code>false</code> if the MIDI instrument map's list does not contain
282			* MIDI instrument map with ID <code>mapId</code>.
283			*/
284	iliev	1204	public boolean removeMidiInstrumentMapById(int mapId);
285	iliev	1143
286			/** Removes all MIDI instrument maps. */
287			public void removeAllMidiInstrumentMaps();
288
289			/**
290			* Schedules a new task for removing the
291			* specified MIDI instrument map on the backend side.
292			* @param mapId The numerical ID of the MIDI instrument map to remove.
293			* @throws IllegalArgumentException If <code>mapId</code> is negative.
294			*/
295			public void removeBackendMidiInstrumentMap(int mapId);
296
297			/**
298			* Schedules a new task for changing the name of
299			* the specified MIDI instrument map on the backend side.
300			* @param mapId The numerical ID of the MIDI instrument map.
301			* @param name The new name for the specified MIDI instrument map.
302			*/
303			public void setBackendMidiInstrumentMapName(int mapId, String name);
304
305			/**
306			* Gets the default MIDI instrument map.
307			* @return The default MIDI instrument map or <code>null</code>
308			* if there are no maps created.
309			*/
310			public MidiInstrumentMap getDefaultMidiInstrumentMap();
311
312			/**
313			* Schedules a new task for mapping a MIDI instrument on the backend side.
314			* @param mapId The id of the MIDI instrument map.
315			* @param bank The index of the MIDI bank, which shall contain the instrument.
316			* @param program The MIDI program number of the new instrument.
317			* @param instrInfo Provides the MIDI instrument settings.
318			*/
319			public void
320			mapBackendMidiInstrument(int mapId, int bank, int program, MidiInstrumentInfo instrInfo);
321
322			/**
323			* Schedules a new task for removing a MIDI instrument on the backend side.
324			* @param mapId The id of the MIDI instrument map containing the instrument to be removed.
325			* @param bank The index of the MIDI bank containing the instrument to be removed.
326			* @param program The MIDI program number of the instrument to be removed.
327			*/
328			public void unmapBackendMidiInstrument(int mapId, int bank, int program);
329
330			/**
331	iliev	787	* Gets a list of all available engines.
332			* @return A list of all available engines.
333			*/
334			public SamplerEngine[] getEngines();
335
336			/**
337			* Gets the current list of sampler channel models.
338			* @return The current list of sampler channel models.
339			*/
340	iliev	1204	public SamplerChannelModel[] getChannels();
341	iliev	787
342			/**
343	iliev	1467	* Gets the model of the sampler channel in the specified position.
344			* @param index The position of the channel to return.
345			* @return The model of the specified sampler channel.
346			* @see #getchannelCount
347			*/
348			public SamplerChannelModel getChannel(int index);
349
350			/**
351	iliev	1143	* Gets the model of the sampler channel with ID <code>channelId</code>.
352			* @param channelId The ID of the sampler channel whose model should be obtained.
353	iliev	787	* @return The model of the specified sampler channel or <code>null</code>
354	iliev	1143	* if there is no channel with ID <code>channelId</code>.
355	iliev	787	*/
356	iliev	1204	public SamplerChannelModel getChannelById(int channelId);
357	iliev	787
358			/**
359	iliev	1743	* Gets the position of the specified channel.
360			* @param channel The model of the channel.
361			* @return The position of the specified channel in the channel list or -1
362			* if the channel is not in the list.
363			*/
364			public int getChannelIndex(SamplerChannelModel channel);
365
366			/**
367	iliev	787	* Gets the current number of sampler channels.
368			* @return The current number of sampler channels.
369			*/
370			public int getChannelCount();
371
372			/**
373	iliev	1143	* Adds a new sampler channel on the backend side. The channel will
374			* be actually added to this model when the backend notifies for its creation.
375	iliev	787	* @see #addChannel
376			*/
377	iliev	1143	public void addBackendChannel();
378	iliev	787
379			/**
380			* Adds the specified sampler channel.
381			* @param channel The channel to be added.
382			*/
383			public void addChannel(SamplerChannel channel);
384
385			/**
386			* Removes the specified sampler channel.
387	iliev	911	* Note that this method doesn't remove the channel in the backend,
388			* it is used to remove the channel from the model when those channel
389			* is removed in the backend.
390	iliev	1143	* @param channelId The ID of the channel to be removed.
391	iliev	787	* @return <code>true</code> if the channel is removed successfully, <code>false</code>
392	iliev	1143	* if the channel's list does not contain channel with ID <code>channelId</code>.
393	iliev	787	*/
394	iliev	1204	public boolean removeChannelById(int channelId);
395	iliev	787
396			/**
397	iliev	1818	* Removes all sampler channels.
398			* Note that this method doesn't remove the channel in the backend.
399			*/
400			public void removeAllChannels();
401
402			/**
403	iliev	1143	* Schedules a new task for removing the specified sampler channel on the backend side.
404			* @param channelId The ID of the channel to be removed.
405			*/
406			public void removeBackendChannel(int channelId);
407
408			/**
409	iliev	787	* Updates the settings of the specified channel.
410			* @param channel A <code>SamplerChannel</code> instance containing the new settings
411			* for the channel.
412			*/
413	iliev	1143	public void updateChannel(SamplerChannel channel);
414	iliev	787
415			/**
416	iliev	1737	* Determines whether there are known upcoming changes to the
417			* channel list, which should be considered as part of a single action.
418			*/
419			public boolean getChannelListIsAdjusting();
420
421			/**
422			* Sets whether the upcoming changes to the
423			* channel list should be considered part of a single action.
424			*/
425			public void setChannelListIsAdjusting(boolean b);
426
427			/**
428	iliev	1341	* Schedules a new task for starting an instrument editor for editing
429			* the loaded instrument on the specified sampler channel.
430			* @param channelId The sampler channel number.
431			*/
432			public void editBackendInstrument(int channelId);
433
434			/**
435	iliev	787	* Determines whether there is at least one solo channel in the current list
436			* of sampler channels.
437			* @return <code>true</code> if there is at least one solo channel in the current list of
438			* sampler channels, <code>false</code> otherwise.
439			*/
440			public boolean hasSoloChannel();
441
442			/**
443			* Gets the number of solo channels in the current list of sampler channels.
444			* @return The number of solo channels in the current list of sampler channels.
445			*/
446			public int getSoloChannelCount();
447
448			/**
449			* Gets the number of muted channels in the current list of sampler channels.
450			* This number includes the channels muted because of the presence of a solo channel.
451			* @return The number of muted channels in the current list of sampler channels.
452			*/
453			public int getMutedChannelCount();
454
455			/**
456			* Gets the number of channels muted because of the presence of a solo channel.
457			* @return The number of channels muted because of the presence of a solo channel.
458			*/
459			public int getMutedBySoloChannelCount();
460
461			/**
462	iliev	1545	* Gets the total number of active streams.
463			* @return The total number of active streams.
464			*/
465			public int getTotalStreamCount();
466
467			/**
468	iliev	787	* Gets the total number of active voices.
469			* @return The total number of active voices.
470			*/
471			public int getTotalVoiceCount();
472
473			/**
474			* Gets the maximum number of active voices.
475			* @return The maximum number of active voices.
476			*/
477			public int getTotalVoiceCountMax();
478
479			/**
480	iliev	1143	* Gets the golobal volume of the sampler.
481			* @return The golobal volume of the sampler.
482			*/
483			public float getVolume();
484
485			/**
486			* Sets the global volume.
487			* @param volume The new volume value.
488			*/
489			public void setVolume(float volume);
490
491			/**
492			* Sets the global volume on the backend side.
493			* @param volume The new volume value.
494			*/
495			public void setBackendVolume(float volume);
496
497	iliev	2192	/** Gets the list of internal effects */
498			public EffectList getEffects();
499
500	iliev	2195	public EffectInstance getEffectInstanceById(int instanceId);
501
502			public void updateEffectInstance(EffectInstanceInfo instance);
503
504	iliev	1143	/**
505			* Schedules a new task for resetting the sampler.
506			*/
507			public void resetBackend();
508
509			/**
510	iliev	1545	* Updates the current number of active disk streams in the sampler.
511			* @param count The new number of active streams.
512			*/
513			public void updateActiveStreamsInfo(int count);
514
515			/**
516	iliev	787	* Updates the current and the maximum number of active voices in the sampler.
517			* @param count The new number of active voices.
518			* @param countMax The maximum number of active voices.
519			*/
520			public void updateActiveVoiceInfo(int count, int countMax);
521	iliev	1567
522			/**
523			* Determines whether the sampler configuration is modified.
524			*/
525			public boolean isModified();
526
527			/**
528			* Sets whether the sampler configuration is modified.
529			*/
530			public void setModified(boolean b);
531	iliev	1688
532			/** Resets the model. */
533			public void reset();
534	iliev	787	}