--- qsampler/trunk/src/qsamplerChannel.cpp	2005/01/18 12:32:01	343
+++ qsampler/trunk/src/qsamplerChannel.cpp	2012/12/29 00:21:11	2387
@@ -1,7 +1,8 @@
 // qsamplerChannel.cpp
 //
 /****************************************************************************
-   Copyright (C) 2003-2005, rncbc aka Rui Nuno Capela. All rights reserved.
+   Copyright (C) 2004-2012, rncbc aka Rui Nuno Capela. All rights reserved.
+   Copyright (C) 2007, 2008 Christian Schoenebeck
 
    This program is free software; you can redistribute it and/or
    modify it under the terms of the GNU General Public License
@@ -13,521 +14,1077 @@
    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 this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+   You should have received a copy of the GNU General Public License along
+   with this program; if not, write to the Free Software Foundation, Inc.,
+   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 *****************************************************************************/
 
+#include "qsamplerAbout.h"
 #include "qsamplerChannel.h"
+#include "qsamplerUtilities.h"
 
 #include "qsamplerMainForm.h"
 #include "qsamplerChannelForm.h"
 
-#include "config.h"
-
-#include <qfileinfo.h>
+#include <QFileInfo>
+#include <QComboBox>
 
 #ifdef CONFIG_LIBGIG
 #include "gig.h"
 #endif
 
-#define QSAMPLER_INSTRUMENT_MAX 8
+namespace QSampler {
+
+#define QSAMPLER_INSTRUMENT_MAX 100
+
+#define UNICODE_RIGHT_ARROW	QChar(char(0x92), char(0x21))
 
 
 //-------------------------------------------------------------------------
-// qsamplerChannel - Sampler channel structure.
+// QSampler::Channel - Sampler channel structure.
 //
-bool qsamplerChannel::g_bInstrumentNames = false;
 
 // Constructor.
-qsamplerChannel::qsamplerChannel ( qsamplerMainForm *pMainForm, int iChannelID )
+Channel::Channel ( int iChannelID )
 {
-    m_pMainForm  = pMainForm;
-    m_iChannelID = iChannelID;
-
-//  m_sEngineName       = QObject::tr("(No engine)");
-//  m_sInstrumentFile   = QObject::tr("(No instrument)");
-    m_iInstrumentNr     = -1;
-    m_iInstrumentStatus = -1;
-    m_sMidiDriver       = "Alsa";   // DEPRECATED.
-    m_iMidiDevice       = -1;
-    m_iMidiPort         = -1;
-    m_iMidiChannel      = -1;
-    m_sAudioDriver      = "Alsa";   // DEPRECATED.
-    m_iAudioDevice      = -1;
-    m_fVolume           = 0.0;
+	m_iChannelID = iChannelID;
 
+//  m_sEngineName       = noEngineName();
+//  m_sInstrumentName   = noInstrumentName();
+//  m_sInstrumentFile   = m_sInstrumentName;
+	m_iInstrumentNr     = -1;
+	m_iInstrumentStatus = -1;
+	m_sMidiDriver       = "ALSA";
+	m_iMidiDevice       = -1;
+	m_iMidiPort         = -1;
+	m_iMidiChannel      = -1;
+	m_iMidiMap          = -1;
+	m_sAudioDriver      = "ALSA";
+	m_iAudioDevice      = -1;
+	m_fVolume           = 0.0f;
+	m_bMute             = false;
+	m_bSolo             = false;
 }
 
 // Default destructor.
-qsamplerChannel::~qsamplerChannel (void)
-{
-}
-
-
-// The global options settings delegated property.
-qsamplerOptions *qsamplerChannel::options (void)
+Channel::~Channel (void)
 {
-    if (m_pMainForm == NULL)
-        return NULL;
-
-    return m_pMainForm->options();
-}
-
-
-// The client descriptor delegated property.
-lscp_client_t *qsamplerChannel::client (void)
-{
-    if (m_pMainForm == NULL)
-        return NULL;
-
-    return m_pMainForm->client();
 }
 
 
 // Create a new sampler channel, if not already.
-bool qsamplerChannel::addChannel (void)
+bool Channel::addChannel (void)
 {
-    if (client() == NULL)
-        return false;
-
-    // Are we a new channel?
-    if (m_iChannelID < 0) {
-        m_iChannelID = ::lscp_add_channel(client());
-        if (m_iChannelID < 0) {
-            appendMessagesClient("lscp_add_channel");
-            appendMessagesError(QObject::tr("Could not create the new channel.\n\nSorry."));
-        }   // Otherwise it's created...
-        else appendMessages(QObject::tr("Channel %1 created.").arg(m_iChannelID));
-    }
+	MainForm* pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL)
+		return false;
+
+	// Are we a new channel?
+	if (m_iChannelID < 0) {
+		m_iChannelID = ::lscp_add_channel(pMainForm->client());
+		if (m_iChannelID < 0) {
+			appendMessagesClient("lscp_add_channel");
+			appendMessagesError(
+				QObject::tr("Could not add channel.\n\nSorry."));
+		}   // Otherwise it's created...
+		else appendMessages(QObject::tr("added."));
+	}
 
-    // Return whether we're a valid channel...
-    return (m_iChannelID >= 0);
+	// Return whether we're a valid channel...
+	return (m_iChannelID >= 0);
 }
 
 
 // Remove sampler channel.
-bool qsamplerChannel::removeChannel (void)
+bool Channel::removeChannel (void)
 {
-    if (client() == NULL)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL)
+		return false;
+
+	// Are we an existing channel?
+	if (m_iChannelID >= 0) {
+		if (::lscp_remove_channel(pMainForm->client(), m_iChannelID) != LSCP_OK) {
+			appendMessagesClient("lscp_remove_channel");
+			appendMessagesError(QObject::tr("Could not remove channel.\n\nSorry."));
+		} else {
+			// Otherwise it's removed.
+			appendMessages(QObject::tr("removed."));
+			m_iChannelID = -1;
+		}
+	}
 
-    // Are we an existing channel?
-    if (m_iChannelID >= 0) {
-        if (::lscp_remove_channel(client(), m_iChannelID) != LSCP_OK) {
-            appendMessagesClient("lscp_remove_channel");
-            appendMessagesError(QObject::tr("Could not remove channel.\n\nSorry."));
-        } else {
-            // Otherwise it's removed.
-            appendMessages(QObject::tr("Channel %1 removed.").arg(m_iChannelID));
-            m_iChannelID = -1;
-        }
-    }
-    
-    // Return whether we've removed the channel...
-    return (m_iChannelID < 0);
+	// Return whether we've removed the channel...
+	return (m_iChannelID < 0);
 }
 
 
 // Channel-ID (aka Sammpler-Channel) accessors.
-int qsamplerChannel::channelID (void)
+int Channel::channelID (void) const
 {
-    return m_iChannelID;
+	return m_iChannelID;
 }
 
-void qsamplerChannel::setChannelID ( int iChannelID )
+void Channel::setChannelID ( int iChannelID )
 {
-    m_iChannelID = iChannelID;
+	m_iChannelID = iChannelID;
 }
 
 
 // Readable channel name.
-QString qsamplerChannel::channelName (void)
+QString Channel::channelName (void) const
 {
-    return (m_iChannelID < 0 ? QObject::tr("New Channel") : QObject::tr("Channel %1").arg(m_iChannelID));
+	return (m_iChannelID < 0 ? QObject::tr("New Channel") : QObject::tr("Channel %1").arg(m_iChannelID));
 }
 
 
 // Engine name accessors.
-QString& qsamplerChannel::engineName (void)
+const QString& Channel::engineName (void) const
 {
-    return m_sEngineName;
+	return m_sEngineName;
 }
 
-bool qsamplerChannel::loadEngine ( const QString& sEngineName )
+bool Channel::loadEngine ( const QString& sEngineName )
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && m_sEngineName == sEngineName)
+		return true;
+
+	if (::lscp_load_engine(pMainForm->client(),
+			sEngineName.toUtf8().constData(), m_iChannelID) != LSCP_OK) {
+		appendMessagesClient("lscp_load_engine");
+		return false;
+	}
 
-    if (::lscp_load_engine(client(), sEngineName.latin1(), m_iChannelID) != LSCP_OK) {
-        appendMessagesClient("lscp_load_engine");
-        return false;
-    }
+	appendMessages(QObject::tr("Engine: %1.").arg(sEngineName));
 
-    m_sEngineName = sEngineName;
-    return true;
+	m_sEngineName = sEngineName;
+	return true;
 }
 
 
 // Instrument filename accessor.
-QString& qsamplerChannel::instrumentFile (void)
+const QString& Channel::instrumentFile (void) const
 {
-    return m_sInstrumentFile;
+	return m_sInstrumentFile;
 }
 
 // Instrument index accessor.
-int qsamplerChannel::instrumentNr (void)
+int Channel::instrumentNr (void) const
 {
-    return m_iInstrumentNr;
+	return m_iInstrumentNr;
+}
+
+// Instrument name accessor.
+const QString& Channel::instrumentName (void) const
+{
+	return m_sInstrumentName;
 }
 
 // Instrument status accessor.
-int qsamplerChannel::instrumentStatus (void)
+int Channel::instrumentStatus (void) const
 {
-    return m_iInstrumentStatus;
+	return m_iInstrumentStatus;
 }
 
 // Instrument file loader.
-bool qsamplerChannel::loadInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
+bool Channel::loadInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (!QFileInfo(sInstrumentFile).exists())
+		return false;
+	if (m_iInstrumentStatus == 100
+		&& m_sInstrumentFile == sInstrumentFile
+		&& m_iInstrumentNr == iInstrumentNr)
+		return true;
+
+	if (::lscp_load_instrument_non_modal(
+			pMainForm->client(),
+			qsamplerUtilities::lscpEscapePath(
+				sInstrumentFile).toUtf8().constData(),
+			iInstrumentNr, m_iChannelID
+		) != LSCP_OK) {
+		appendMessagesClient("lscp_load_instrument");
+		return false;
+	}
+
+	appendMessages(QObject::tr("Instrument: \"%1\" (%2).")
+		.arg(sInstrumentFile).arg(iInstrumentNr));
+
+	return setInstrument(sInstrumentFile, iInstrumentNr);
+}
 
-    if (::lscp_load_instrument_non_modal(client(), sInstrumentFile.latin1(), iInstrumentNr, m_iChannelID) != LSCP_OK) {
-        appendMessagesClient("lscp_load_instrument");
-        return false;
-    }
 
-    m_sInstrumentFile = sInstrumentFile;
-    m_iInstrumentNr = iInstrumentNr;
-    m_iInstrumentStatus = 0;
+// Special instrument file/name/number settler.
+bool Channel::setInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
+{
+	m_sInstrumentFile = sInstrumentFile;
+	m_iInstrumentNr = iInstrumentNr;
+#ifdef CONFIG_INSTRUMENT_NAME
+	m_sInstrumentName = QString::null;  // We'll get it, maybe later, on channel_info...
+#else
+	m_sInstrumentName = getInstrumentName(sInstrumentFile, iInstrumentNr, true);
+#endif
+	m_iInstrumentStatus = 0;
 
-    return true;
+	return true;
 }
 
 
 // MIDI driver type accessors (DEPRECATED).
-QString& qsamplerChannel::midiDriver (void)
+const QString& Channel::midiDriver (void) const
 {
-    return m_sMidiDriver;
+	return m_sMidiDriver;
 }
 
-bool qsamplerChannel::setMidiDriver ( const QString& sMidiDriver )
+bool Channel::setMidiDriver ( const QString& sMidiDriver )
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && m_sMidiDriver == sMidiDriver)
+		return true;
+
+	if (::lscp_set_channel_midi_type(pMainForm->client(),
+			m_iChannelID, sMidiDriver.toUtf8().constData()) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_midi_type");
+		return false;
+	}
 
-    if (::lscp_set_channel_midi_type(client(), m_iChannelID, sMidiDriver.latin1()) != LSCP_OK) {
-        appendMessagesClient("lscp_set_channel_midi_type");
-        return false;
-    }
+	appendMessages(QObject::tr("MIDI driver: %1.").arg(sMidiDriver));
 
-    m_sMidiDriver = sMidiDriver;
-    return true;
+	m_sMidiDriver = sMidiDriver;
+	return true;
 }
 
 
 // MIDI device accessors.
-int qsamplerChannel::midiDevice (void)
+int Channel::midiDevice (void) const
 {
-    return m_iMidiDevice;
+	return m_iMidiDevice;
 }
 
-bool qsamplerChannel::setMidiDevice ( int iMidiDevice )
+bool Channel::setMidiDevice ( int iMidiDevice )
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && m_iMidiDevice == iMidiDevice)
+		return true;
 
-    if (::lscp_set_channel_midi_device(client(), m_iChannelID, iMidiDevice) != LSCP_OK) {
-        appendMessagesClient("lscp_set_channel_midi_device");
-        return false;
-    }
+	if (::lscp_set_channel_midi_device(pMainForm->client(), m_iChannelID, iMidiDevice) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_midi_device");
+		return false;
+	}
 
-    m_iMidiDevice = iMidiDevice;
-    return true;
+	appendMessages(QObject::tr("MIDI device: %1.").arg(iMidiDevice));
+
+	m_iMidiDevice = iMidiDevice;
+	return true;
 }
 
 
 // MIDI port number accessor.
-int qsamplerChannel::midiPort (void)
+int Channel::midiPort (void) const
 {
-    return m_iMidiPort;
+	return m_iMidiPort;
 }
 
-bool qsamplerChannel::setMidiPort ( int iMidiPort )
+bool Channel::setMidiPort ( int iMidiPort )
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && m_iMidiPort == iMidiPort)
+		return true;
+
+	if (::lscp_set_channel_midi_port(pMainForm->client(), m_iChannelID, iMidiPort) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_midi_port");
+		return false;
+	}
 
-    if (::lscp_set_channel_midi_port(client(), m_iChannelID, iMidiPort) != LSCP_OK) {
-        appendMessagesClient("lscp_set_channel_midi_port");
-        return false;
-    }
+	appendMessages(QObject::tr("MIDI port: %1.").arg(iMidiPort));
 
-    m_iMidiPort = iMidiPort;
-    return true;
+	m_iMidiPort = iMidiPort;
+	return true;
 }
 
 
 // MIDI channel accessor.
-int qsamplerChannel::midiChannel (void)
+int Channel::midiChannel (void) const
 {
-    return m_iMidiChannel;
+	return m_iMidiChannel;
 }
 
-bool qsamplerChannel::setMidiChannel ( int iMidiChannel )
+bool Channel::setMidiChannel ( int iMidiChannel )
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && m_iMidiChannel == iMidiChannel)
+		return true;
+
+	if (::lscp_set_channel_midi_channel(pMainForm->client(), m_iChannelID, iMidiChannel) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_midi_channel");
+		return false;
+	}
+
+	appendMessages(QObject::tr("MIDI channel: %1.").arg(iMidiChannel));
+
+	m_iMidiChannel = iMidiChannel;
+	return true;
+}
 
-    if (::lscp_set_channel_midi_channel(client(), m_iChannelID, iMidiChannel) != LSCP_OK) {
-        appendMessagesClient("lscp_set_channel_midi_channel");
-        return false;
-    }
 
-    m_iMidiChannel = iMidiChannel;
-    return true;
+// MIDI instrument map accessor.
+int Channel::midiMap (void) const
+{
+	return m_iMidiMap;
+}
+
+bool Channel::setMidiMap ( int iMidiMap )
+{
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && m_iMidiMap == iMidiMap)
+		return true;
+#ifdef CONFIG_MIDI_INSTRUMENT
+	if (::lscp_set_channel_midi_map(pMainForm->client(), m_iChannelID, iMidiMap) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_midi_map");
+		return false;
+	}
+#endif
+	appendMessages(QObject::tr("MIDI map: %1.").arg(iMidiMap));
+
+	m_iMidiMap = iMidiMap;
+	return true;
 }
 
 
 // Audio device accessor.
-int qsamplerChannel::audioDevice (void)
+int Channel::audioDevice (void) const
 {
-    return m_iAudioDevice;
+	return m_iAudioDevice;
 }
 
-bool qsamplerChannel::setAudioDevice ( int iAudioDevice )
+bool Channel::setAudioDevice ( int iAudioDevice )
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && m_iAudioDevice == iAudioDevice)
+		return true;
+
+	if (::lscp_set_channel_audio_device(pMainForm->client(), m_iChannelID, iAudioDevice) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_audio_device");
+		return false;
+	}
 
-    if (::lscp_set_channel_audio_device(client(), m_iChannelID, iAudioDevice) != LSCP_OK) {
-        appendMessagesClient("lscp_set_channel_audio_device");
-        return false;
-    }
+	appendMessages(QObject::tr("Audio device: %1.").arg(iAudioDevice));
 
-    m_iAudioDevice = iAudioDevice;
-    return true;
+	m_iAudioDevice = iAudioDevice;
+	return true;
 }
 
 
 // Audio driver type accessors (DEPRECATED).
-QString& qsamplerChannel::audioDriver (void)
+const QString& Channel::audioDriver (void) const
 {
-    return m_sAudioDriver;
+	return m_sAudioDriver;
 }
 
-bool qsamplerChannel::setAudioDriver ( const QString& sAudioDriver )
+bool Channel::setAudioDriver ( const QString& sAudioDriver )
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && m_sAudioDriver == sAudioDriver)
+		return true;
+
+	if (::lscp_set_channel_audio_type(pMainForm->client(),
+			m_iChannelID, sAudioDriver.toUtf8().constData()) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_audio_type");
+		return false;
+	}
 
-    if (::lscp_set_channel_audio_type(client(), m_iChannelID, sAudioDriver.latin1()) != LSCP_OK) {
-        appendMessagesClient("lscp_set_channel_audio_type");
-        return false;
-    }
+	appendMessages(QObject::tr("Audio driver: %1.").arg(sAudioDriver));
 
-    m_sAudioDriver = sAudioDriver;
-    return true;
+	m_sAudioDriver = sAudioDriver;
+	return true;
 }
 
 
 // Channel volume accessors.
-float qsamplerChannel::volume (void)
+float Channel::volume (void) const
 {
-    return m_fVolume;
+	return m_fVolume;
 }
 
-bool qsamplerChannel::setVolume ( float fVolume )
+bool Channel::setVolume ( float fVolume )
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && m_fVolume == fVolume)
+		return true;
 
-    if (::lscp_set_channel_volume(client(), m_iChannelID, fVolume) != LSCP_OK) {
-        appendMessagesClient("lscp_set_channel_volume");
-        return false;
-    }
+	if (::lscp_set_channel_volume(pMainForm->client(), m_iChannelID, fVolume) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_volume");
+		return false;
+	}
 
-    m_fVolume = fVolume;
-    return true;
+	appendMessages(QObject::tr("Volume: %1.").arg(fVolume));
+
+	m_fVolume = fVolume;
+	return true;
 }
 
 
-// Update whole channel info state.
-bool qsamplerChannel::updateChannelInfo (void)
+// Sampler channel mute state.
+bool Channel::channelMute (void) const
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	return m_bMute;
+}
 
-    // Read channel information.
-    lscp_channel_info_t *pChannelInfo = ::lscp_get_channel_info(client(), m_iChannelID);
-    if (pChannelInfo == NULL) {
-        appendMessagesClient("lscp_get_channel_info");
-        appendMessagesError(QObject::tr("Could not get channel information.\n\nSorry."));
-        return false;
-    }
-
-    // Cache in channel information.
-    m_sEngineName       = pChannelInfo->engine_name;
-    m_sInstrumentFile   = pChannelInfo->instrument_file;
-    m_iInstrumentNr     = pChannelInfo->instrument_nr;
-    m_iInstrumentStatus = pChannelInfo->instrument_status;
-    m_iMidiDevice       = pChannelInfo->midi_device;
-    m_iMidiPort         = pChannelInfo->midi_port;
-    m_iMidiChannel      = pChannelInfo->midi_channel;
-    m_iAudioDevice      = pChannelInfo->audio_device;
-    m_fVolume           = pChannelInfo->volume;
-    // Some sanity checks.
-    if (m_sEngineName == "NONE")
-        m_sEngineName = QString::null;
-    if (m_sInstrumentFile == "NONE")
-        m_sInstrumentFile = QString::null;
+bool Channel::setChannelMute ( bool bMute )
+{
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && ((m_bMute && bMute) || (!m_bMute && !bMute)))
+		return true;
 
-    return true;
+#ifdef CONFIG_MUTE_SOLO
+	if (::lscp_set_channel_mute(pMainForm->client(), m_iChannelID, bMute) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_mute");
+		return false;
+	}
+	appendMessages(QObject::tr("Mute: %1.").arg((int) bMute));
+	m_bMute = bMute;
+	return true;
+#else
+	return false;
+#endif
+}
+
+
+// Sampler channel solo state.
+bool Channel::channelSolo (void) const
+{
+	return m_bSolo;
+}
+
+bool Channel::setChannelSolo ( bool bSolo )
+{
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 && ((m_bSolo && bSolo) || (!m_bSolo && !bSolo)))
+		return true;
+
+#ifdef CONFIG_MUTE_SOLO
+	if (::lscp_set_channel_solo(pMainForm->client(), m_iChannelID, bSolo) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_solo");
+		return false;
+	}
+	appendMessages(QObject::tr("Solo: %1.").arg((int) bSolo));
+	m_bSolo = bSolo;
+	return true;
+#else
+	return false;
+#endif
+}
+
+
+// Audio routing accessors.
+int Channel::audioChannel ( int iAudioOut ) const
+{
+	return m_audioRouting[iAudioOut];
+}
+
+bool Channel::setAudioChannel ( int iAudioOut, int iAudioIn )
+{
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+	if (m_iInstrumentStatus == 100 &&
+			m_audioRouting[iAudioOut] == iAudioIn)
+		return true;
+
+	if (::lscp_set_channel_audio_channel(pMainForm->client(),
+			m_iChannelID, iAudioOut, iAudioIn) != LSCP_OK) {
+		appendMessagesClient("lscp_set_channel_audio_channel");
+		return false;
+	}
+
+	appendMessages(QObject::tr("Audio Channel: %1 -> %2.")
+		.arg(iAudioOut).arg(iAudioIn));
+
+	m_audioRouting[iAudioOut] = iAudioIn;
+	return true;
+}
+
+// The audio routing map itself.
+const ChannelRoutingMap& Channel::audioRouting (void) const
+{
+	return m_audioRouting;
+}
+
+
+// Istrument name remapper.
+void Channel::updateInstrumentName (void)
+{
+#ifndef CONFIG_INSTRUMENT_NAME
+	m_sInstrumentName = getInstrumentName(m_sInstrumentFile,
+		m_iInstrumentNr, (options() && options()->bInstrumentNames));
+#endif
+}
+
+
+// Update whole channel info state.
+bool Channel::updateChannelInfo (void)
+{
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+
+	// Read channel information.
+	lscp_channel_info_t *pChannelInfo = ::lscp_get_channel_info(pMainForm->client(), m_iChannelID);
+	if (pChannelInfo == NULL) {
+		appendMessagesClient("lscp_get_channel_info");
+		appendMessagesError(QObject::tr("Could not get channel information.\n\nSorry."));
+		return false;
+	}
+
+#ifdef CONFIG_INSTRUMENT_NAME
+	// We got all actual instrument datum...
+	m_sInstrumentFile =
+		qsamplerUtilities::lscpEscapedPathToPosix(pChannelInfo->instrument_file);
+	m_iInstrumentNr   = pChannelInfo->instrument_nr;
+	m_sInstrumentName =
+		qsamplerUtilities::lscpEscapedTextToRaw(pChannelInfo->instrument_name);
+#else
+	// First, check if intrument name has changed,
+	// taking care that instrument name lookup might be expensive,
+	// so we better make it only once and when really needed...
+	if ((m_sInstrumentFile != pChannelInfo->instrument_file) ||
+		(m_iInstrumentNr   != pChannelInfo->instrument_nr)) {
+		m_sInstrumentFile = pChannelInfo->instrument_file;
+		m_iInstrumentNr   = pChannelInfo->instrument_nr;
+		updateInstrumentName();
+	}
+#endif
+	// Cache in other channel information.
+	m_sEngineName       = pChannelInfo->engine_name;
+	m_iInstrumentStatus = pChannelInfo->instrument_status;
+	m_iMidiDevice       = pChannelInfo->midi_device;
+	m_iMidiPort         = pChannelInfo->midi_port;
+	m_iMidiChannel      = pChannelInfo->midi_channel;
+#ifdef CONFIG_MIDI_INSTRUMENT
+	m_iMidiMap          = pChannelInfo->midi_map;
+#endif
+	m_iAudioDevice      = pChannelInfo->audio_device;
+	m_fVolume           = pChannelInfo->volume;
+#ifdef CONFIG_MUTE_SOLO
+	m_bMute             = pChannelInfo->mute;
+	m_bSolo             = pChannelInfo->solo;
+#endif
+	// Some sanity checks.
+	if (m_sEngineName == "NONE" || m_sEngineName.isEmpty())
+		m_sEngineName = QString::null;
+	if (m_sInstrumentFile == "NONE" || m_sInstrumentFile.isEmpty()) {
+		m_sInstrumentFile = QString::null;
+		m_sInstrumentName = QString::null;
+	}
+
+	// Time for device info grabbing...
+	lscp_device_info_t *pDeviceInfo;
+	const QString sNone = QObject::tr("(none)");
+	// Audio device driver type.
+	pDeviceInfo = ::lscp_get_audio_device_info(pMainForm->client(), m_iAudioDevice);
+	if (pDeviceInfo == NULL) {
+		appendMessagesClient("lscp_get_audio_device_info");
+		m_sAudioDriver = sNone;
+	} else {
+		m_sAudioDriver = pDeviceInfo->driver;
+	}
+	// MIDI device driver type.
+	pDeviceInfo = ::lscp_get_midi_device_info(pMainForm->client(), m_iMidiDevice);
+	if (pDeviceInfo == NULL) {
+		appendMessagesClient("lscp_get_midi_device_info");
+		m_sMidiDriver = sNone;
+	} else {
+		m_sMidiDriver = pDeviceInfo->driver;
+	}
+
+	// Set the audio routing map.
+	m_audioRouting.clear();
+#ifdef CONFIG_AUDIO_ROUTING
+	int *piAudioRouting = pChannelInfo->audio_routing;
+	for (int i = 0; piAudioRouting && piAudioRouting[i] >= 0; i++)
+		m_audioRouting[i] = piAudioRouting[i];
+#else
+	char **ppszAudioRouting = pChannelInfo->audio_routing;
+	for (int i = 0; ppszAudioRouting && ppszAudioRouting[i]; i++)
+		m_audioRouting[i] = ::atoi(ppszAudioRouting[i]);
+#endif
+
+	return true;
 }
 
 
 // Reset channel method.
-bool qsamplerChannel::resetChannel (void)
+bool Channel::channelReset (void)
 {
-    if (client() == NULL || m_iChannelID < 0)
-        return false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+
+	if (::lscp_reset_channel(pMainForm->client(), m_iChannelID) != LSCP_OK) {
+		appendMessagesClient("lscp_reset_channel");
+		return false;
+	}
+
+	appendMessages(QObject::tr("reset."));
+
+	return true;
+}
+
+
+// Spawn instrument editor method.
+bool Channel::editChannel (void)
+{
+#ifdef CONFIG_EDIT_INSTRUMENT
+
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
+	if (pMainForm->client() == NULL || m_iChannelID < 0)
+		return false;
+
+	if (::lscp_edit_channel_instrument(pMainForm->client(), m_iChannelID)
+		!= LSCP_OK) {
+		appendMessagesClient("lscp_edit_channel_instrument");
+		appendMessagesError(QObject::tr(
+			"Could not launch an appropriate instrument editor "
+			"for the given instrument!\n\n"
+			"Make sure you have an appropriate "
+			"instrument editor like 'gigedit' installed "
+			"and that it placed its mandatory DLL file "
+			"into the sampler's plugin directory.")
+		);
+		return false;
+	}
+
+	appendMessages(QObject::tr("edit instrument."));
+
+	return true;
 
-    if (::lscp_reset_channel(client(), m_iChannelID) != LSCP_OK) {
-        appendMessagesClient("lscp_reset_channel");
-        return false;
-    }
+#else
 
-    appendMessages(QObject::tr("Channel %1 reset.").arg(m_iChannelID));
-    return true;
+	appendMessagesError(QObject::tr(
+		"Sorry, QSampler was compiled for a version of liblscp "
+		"which lacks this feature.\n\n"
+		"You may want to update liblscp and recompile QSampler afterwards.")
+	);
+
+	return false;
+
+#endif
 }
 
 
 // Channel setup dialog form.
-bool qsamplerChannel::channelSetup ( QWidget *pParent )
+bool Channel::channelSetup ( QWidget *pParent )
 {
-    bool bResult = false;
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm == NULL)
+		return false;
 
-    qsamplerChannelForm *pChannelForm = new qsamplerChannelForm(pParent);
-    if (pChannelForm) {
-        pChannelForm->setup(this);
-        bResult = pChannelForm->exec();
-        delete pChannelForm;
-    }
+	bool bResult = false;
 
-    return bResult;
+	appendMessages(QObject::tr("setup..."));
+
+	ChannelForm *pChannelForm = new ChannelForm(pParent);
+	if (pChannelForm) {
+		pChannelForm->setup(this);
+		bResult = pChannelForm->exec();
+		delete pChannelForm;
+	}
+
+	return bResult;
 }
 
 
 // Redirected messages output methods.
-void qsamplerChannel::appendMessages( const QString& s )
+void Channel::appendMessages( const QString& s ) const
 {
-    if (m_pMainForm) m_pMainForm->appendMessages(s);
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm)
+		pMainForm->appendMessages(channelName() + ' ' + s);
 }
 
-void qsamplerChannel::appendMessagesColor( const QString& s, const QString& c )
+void Channel::appendMessagesColor( const QString& s,
+	const QString& c ) const
 {
-    if (m_pMainForm) m_pMainForm->appendMessagesColor(s, c);
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm)
+		pMainForm->appendMessagesColor(channelName() + ' ' + s, c);
 }
 
-void qsamplerChannel::appendMessagesText( const QString& s )
+void Channel::appendMessagesText( const QString& s ) const
 {
-    if (m_pMainForm) m_pMainForm->appendMessagesText(s);
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm)
+		pMainForm->appendMessagesText(channelName() + ' ' + s);
 }
 
-void qsamplerChannel::appendMessagesError( const QString& s )
+void Channel::appendMessagesError( const QString& s ) const
 {
-    if (m_pMainForm) m_pMainForm->appendMessagesError(s);
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm)
+		pMainForm->appendMessagesError(channelName() + "\n\n" + s);
 }
 
-void qsamplerChannel::appendMessagesClient( const QString& s )
+void Channel::appendMessagesClient( const QString& s ) const
 {
-    if (m_pMainForm) m_pMainForm->appendMessagesClient(s);
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm)
+		pMainForm->appendMessagesClient(channelName() + ' ' + s);
 }
 
 
 // Context menu event handler.
-void qsamplerChannel::contextMenuEvent( QContextMenuEvent *pEvent )
+void Channel::contextMenuEvent( QContextMenuEvent *pEvent )
+{
+	MainForm *pMainForm = MainForm::getInstance();
+	if (pMainForm)
+		pMainForm->contextMenuEvent(pEvent);
+}
+
+
+// FIXME: Check whether a given file is an instrument file (DLS only).
+bool Channel::isDlsInstrumentFile ( const QString& sInstrumentFile )
 {
-    if (m_pMainForm) m_pMainForm->contextMenuEvent(pEvent);
+	bool bResult = false;
+
+	QFile file(sInstrumentFile);
+	if (file.open(QIODevice::ReadOnly)) {
+		char achHeader[16];
+		if (file.read(achHeader, 16) > 0) {
+			bResult = (::memcmp(&achHeader[0], "RIFF", 4)     == 0
+					&& ::memcmp(&achHeader[8], "DLS LIST", 8) == 0);
+		}
+		file.close();
+	}
+
+	return bResult;
 }
 
 
 // Retrieve the instrument list of a instrument file (.gig).
-QStringList qsamplerChannel::getInstrumentList( const QString& sInstrumentFile )
+QStringList Channel::getInstrumentList( const QString& sInstrumentFile,
+	bool bInstrumentNames )
 {
-    QFileInfo fileinfo(sInstrumentFile);
-    QString sInstrumentName = fileinfo.fileName();
-    QStringList instlist;
+	QStringList instlist;
 
-    if (fileinfo.exists()) {
-#ifdef CONFIG_LIBGIG
-		if (g_bInstrumentNames) {
-	        RIFF::File *pRiff = new RIFF::File(sInstrumentFile);
-	        gig::File  *pGig  = new gig::File(pRiff);
-	        gig::Instrument *pInstrument = pGig->GetFirstInstrument();
-	        while (pInstrument) {
-	            instlist.append((pInstrument->pInfo)->Name.c_str());
-	            pInstrument = pGig->GetNextInstrument();
-	        }
-	        delete pGig;
-	        delete pRiff;
+	if (isDlsInstrumentFile(sInstrumentFile)) {
+	#ifdef CONFIG_LIBGIG
+		if (bInstrumentNames) {
+			RIFF::File *pRiff
+				= new RIFF::File(sInstrumentFile.toUtf8().constData());
+			gig::File  *pGig  = new gig::File(pRiff);
+		#if HAVE_LIBGIG_SETAUTOLOAD
+			// prevent sleepy response time on large .gig files
+			pGig->SetAutoLoad(false);
+		#endif
+			gig::Instrument *pInstrument = pGig->GetFirstInstrument();
+			while (pInstrument) {
+				instlist.append((pInstrument->pInfo)->Name.c_str());
+				pInstrument = pGig->GetNextInstrument();
+			}
+			delete pGig;
+			delete pRiff;
 		}
-		else
-#endif
-        for (int iInstrumentNr = 0; iInstrumentNr < QSAMPLER_INSTRUMENT_MAX; iInstrumentNr++)
-            instlist.append(sInstrumentName + " [" + QString::number(iInstrumentNr) + "]");
-    }
-    else instlist.append(sInstrumentName);
+	#endif
+	}
+
+	if (instlist.isEmpty()) {
+		QFileInfo fi(sInstrumentFile);
+		if (fi.exists()) {
+			QString sInstrumentName = fi.fileName();
+			int iInstrumentNr = 0;
+			while (iInstrumentNr < QSAMPLER_INSTRUMENT_MAX) {
+				instlist.append(sInstrumentName
+					+ " [" + QString::number(++iInstrumentNr) + "]");
+			}
+		}
+		else instlist.append(noInstrumentName());
+	}
 
-    return instlist;
+	return instlist;
 }
 
 
 // Retrieve the spacific instrument name of a instrument file (.gig), given its index.
-QString qsamplerChannel::getInstrumentName( const QString& sInstrumentFile, int iInstrumentNr )
+QString Channel::getInstrumentName( const QString& sInstrumentFile,
+	int iInstrumentNr, bool bInstrumentNames )
 {
-    QFileInfo fileinfo(sInstrumentFile);
-    QString sInstrumentName = fileinfo.fileName();
+	QString sInstrumentName;
 
-    if (fileinfo.exists()) {
-#ifdef CONFIG_LIBGIG
-		if (g_bInstrumentNames) {
-	        RIFF::File *pRiff = new RIFF::File(sInstrumentFile);
-	        gig::File  *pGig  = new gig::File(pRiff);
-	        int iIndex = 0;
-	        gig::Instrument *pInstrument = pGig->GetFirstInstrument();
-	        while (pInstrument) {
-	            if (iIndex == iInstrumentNr) {
-	                sInstrumentName = (pInstrument->pInfo)->Name.c_str();
-	                break;
-	            }
-	            iIndex++;
-	            pInstrument = pGig->GetNextInstrument();
-	        }
-	        delete pGig;
-	        delete pRiff;
+	if (isDlsInstrumentFile(sInstrumentFile)) {
+	#ifdef CONFIG_LIBGIG
+		if (bInstrumentNames) {
+			RIFF::File *pRiff
+				= new RIFF::File(sInstrumentFile.toUtf8().constData());
+			gig::File *pGig = new gig::File(pRiff);
+		#if HAVE_LIBGIG_SETAUTOLOAD
+			// prevent sleepy response time on large .gig files
+			pGig->SetAutoLoad(false);
+		#endif
+			int iIndex = 0;
+			gig::Instrument *pInstrument = pGig->GetFirstInstrument();
+			while (pInstrument) {
+				if (iIndex == iInstrumentNr) {
+					sInstrumentName = (pInstrument->pInfo)->Name.c_str();
+					break;
+				}
+				iIndex++;
+				pInstrument = pGig->GetNextInstrument();
+			}
+			delete pGig;
+			delete pRiff;
 		}
-		else
+	#endif
+	}
+
+	if (sInstrumentName.isEmpty()) {
+		QFileInfo fi(sInstrumentFile);
+		if (fi.exists()) {
+			sInstrumentName  = fi.fileName();
+			sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";
+		}
+		else sInstrumentName = noInstrumentName();
+	}
+
+	return sInstrumentName;
+}
+
+
+// Common invalid name-helpers.
+QString Channel::noEngineName (void)
+{
+	return QObject::tr("(No engine)");
+}
+
+QString Channel::noInstrumentName (void)
+{
+	return QObject::tr("(No instrument)");
+}
+
+QString Channel::loadingInstrument (void) {
+	return QObject::tr("(Loading instrument...)");
+}
+
+
+//-------------------------------------------------------------------------
+// QSampler::ChannelRoutingModel - data model for audio routing
+//                                 (used for QTableView)
+
+ChannelRoutingModel::ChannelRoutingModel ( QObject *pParent )
+	: QAbstractTableModel(pParent), m_pDevice(NULL)
+{
+}
+
+
+int ChannelRoutingModel::rowCount ( const QModelIndex& /*parent*/) const
+{
+	return (m_pDevice) ? m_routing.size() : 0;
+}
+
+
+int ChannelRoutingModel::columnCount ( const QModelIndex& /*parent*/) const
+{
+	return 1;
+}
+
+
+Qt::ItemFlags ChannelRoutingModel::flags ( const QModelIndex& /*index*/) const
+{
+	return Qt::ItemIsSelectable | Qt::ItemIsEditable | Qt::ItemIsEnabled;
+}
+
+
+bool ChannelRoutingModel::setData ( const QModelIndex& index,
+	const QVariant& value, int /*role*/)
+{
+	if (!index.isValid())
+		return false;
+
+	m_routing[index.row()] = value.toInt();
+
+	emit dataChanged(index, index);
+	return true;
+}
+
+
+QVariant ChannelRoutingModel::data ( const QModelIndex &index, int role ) const
+{
+	if (!index.isValid())
+		return QVariant();
+	if (role != Qt::DisplayRole)
+		return QVariant();
+	if (index.column() != 0)
+		return QVariant();
+
+	ChannelRoutingItem item;
+
+	// The common device port item list.
+	DevicePortList& ports = m_pDevice->ports();
+	QListIterator<DevicePort *> iter(ports);
+	while (iter.hasNext()) {
+		DevicePort *pPort = iter.next();
+		item.options.append(
+			m_pDevice->deviceTypeName()
+			+ ' ' + m_pDevice->driverName()
+			+ ' ' + pPort->portName()
+		);
+	}
+
+	item.selection = m_routing[index.row()];
+
+	return QVariant::fromValue(item);
+}
+
+
+QVariant ChannelRoutingModel::headerData ( int section,
+	Qt::Orientation orientation, int role) const
+{
+	if (role != Qt::DisplayRole)
+		return QVariant();
+
+	switch (orientation) {
+		case Qt::Horizontal:
+			return UNICODE_RIGHT_ARROW + QObject::tr(" Device Channel");
+		case Qt::Vertical:
+			return QObject::tr("Audio Channel ") +
+				QString::number(section) + " " + UNICODE_RIGHT_ARROW;
+		default:
+			return QVariant();
+	}
+}
+
+
+void ChannelRoutingModel::refresh ( Device *pDevice,
+	const ChannelRoutingMap& routing )
+{
+	m_pDevice = pDevice;
+	m_routing = routing;
+	// inform the outer world (QTableView) that our data changed
+#if QT_VERSION < 0x050000
+	QAbstractTableModel::reset();
+#else
+	QAbstractTableModel::beginResetModel();
+	QAbstractTableModel::endResetModel();
 #endif
-        sInstrumentName += " [" + QString::number(iInstrumentNr) + "]";
-    }
+}
+
+
+//-------------------------------------------------------------------------
+// QSampler::ChannelRoutingDelegate - table cell renderer for audio routing
+//
+
+ChannelRoutingDelegate::ChannelRoutingDelegate ( QObject *pParent )
+	: QItemDelegate(pParent)
+{
+}
 
-    return sInstrumentName;
+
+QWidget* ChannelRoutingDelegate::createEditor ( QWidget *pParent,
+	const QStyleOptionViewItem & option, const QModelIndex& index ) const
+{
+	if (!index.isValid())
+		return NULL;
+
+	if (index.column() != 0)
+		return NULL;
+
+	ChannelRoutingItem item = index.model()->data(index, Qt::DisplayRole).value<ChannelRoutingItem>();
+
+	QComboBox* pComboBox = new QComboBox(pParent);
+	pComboBox->addItems(item.options);
+	pComboBox->setCurrentIndex(item.selection);
+	pComboBox->setEnabled(true);
+	pComboBox->setGeometry(option.rect);
+	return pComboBox;
 }
 
 
-// Instrument name(s) retrieval mode--global option.
-bool qsamplerChannel::instrumentNames (void)
+void ChannelRoutingDelegate::setEditorData ( QWidget *pEditor,
+	const QModelIndex &index) const
 {
-	return g_bInstrumentNames;
+	ChannelRoutingItem item = index.model()->data(index,
+		Qt::DisplayRole).value<ChannelRoutingItem> ();
+	QComboBox* pComboBox = static_cast<QComboBox*> (pEditor);
+	pComboBox->setCurrentIndex(item.selection);
 }
 
-void qsamplerChannel::setInstrumentNames ( bool bInstrumentNames )
+
+void ChannelRoutingDelegate::setModelData ( QWidget* pEditor,
+	QAbstractItemModel *pModel, const QModelIndex& index ) const
 {
-	g_bInstrumentNames = bInstrumentNames;
+	QComboBox *pComboBox = static_cast<QComboBox*> (pEditor);
+	pModel->setData(index, pComboBox->currentIndex());
 }
 
 
+void ChannelRoutingDelegate::updateEditorGeometry ( QWidget *pEditor,
+	const QStyleOptionViewItem& option, const QModelIndex &/* index */) const
+{
+	pEditor->setGeometry(option.rect);
+}
+
+} // namespace QSampler
+
+
 // end of qsamplerChannel.cpp