// Instrument map name enumerator.
QStringList Instrument::getMapNames (void)
{
QStringList maps;
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return maps;
if (pMainForm->client() == NULL)
return maps;
#ifdef CONFIG_MIDI_INSTRUMENT
int *piMaps = ::lscp_list_midi_instrument_maps(pMainForm->client());
if (piMaps == NULL) {
if (::lscp_client_get_errno(pMainForm->client()))
pMainForm->appendMessagesClient("lscp_list_midi_instruments");
} else {
for (int iMap = 0; piMaps[iMap] >= 0; iMap++) {
const QString& sMapName = getMapName(piMaps[iMap]);
if (!sMapName.isEmpty())
maps.append(sMapName);
}
}
#endif
return maps;
}
bool Instrument::unmapInstrument (void)
{
#ifdef CONFIG_MIDI_INSTRUMENT
if (m_iMap < 0 || m_iBank < 0 || m_iProg < 0)
return false;
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return false;
if (pMainForm->client() == NULL)
return false;
lscp_midi_instrument_t instr;
instr.map = m_iMap;
instr.bank = (m_iBank & 0x0fff);
instr.prog = (m_iProg & 0x7f);
if (::lscp_unmap_midi_instrument(pMainForm->client(), &instr) != LSCP_OK) {
pMainForm->appendMessagesClient("lscp_unmap_midi_instrument");
return false;
}
return true;
#else
return false;
#endif
}
// Instrument file loader.
bool Channel::loadInstrument ( const QString& sInstrumentFile, int iInstrumentNr )
{
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return false;
if (pMainForm->client() == NULL || m_iChannelID < 0)
return false;
if (!isInstrumentFile(sInstrumentFile))
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);
}
// Update whole channel usage state.
bool ChannelStrip::updateChannelUsage (void)
{
if (m_pChannel == NULL)
return false;
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm->client() == NULL)
return false;
// This only makes sense on fully loaded channels...
if (m_pChannel->instrumentStatus() < 100)
return false;
// Get current channel voice count.
int iVoiceCount = ::lscp_get_channel_voice_count(
pMainForm->client(), m_pChannel->channelID());
// Get current stream count.
int iStreamCount = ::lscp_get_channel_stream_count(
pMainForm->client(), m_pChannel->channelID());
// Get current channel buffer fill usage.
// As benno has suggested this is the percentage usage
// of the least filled buffer stream...
int iStreamUsage = ::lscp_get_channel_stream_usage(
pMainForm->client(), m_pChannel->channelID());;
// Update the GUI elements...
m_ui.StreamUsageProgressBar->setValue(iStreamUsage);
m_ui.StreamVoiceCountTextLabel->setText(
QString("%1 / %2").arg(iStreamCount).arg(iVoiceCount));
// We're clean.
return true;
}
int Options::getEffectiveMaxStreams() {
#ifndef CONFIG_MAX_VOICES
return -1;
#else
MainForm *pMainForm = MainForm::getInstance();
if (!pMainForm || !pMainForm->client())
return -1;
return ::lscp_get_streams(pMainForm->client());
#endif // CONFIG_MAX_VOICES
}
// Sync methods.
bool Instrument::mapInstrument (void)
{
#ifdef CONFIG_MIDI_INSTRUMENT
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return false;
if (pMainForm->client() == NULL)
return false;
if (m_iMap < 0 || m_iBank < 0 || m_iProg < 0)
return false;
lscp_midi_instrument_t instr;
instr.map = m_iMap;
instr.bank = (m_iBank & 0x0fff);
instr.prog = (m_iProg & 0x7f);
lscp_load_mode_t load_mode;
switch (m_iLoadMode) {
case 3:
load_mode = LSCP_LOAD_PERSISTENT;
break;
case 2:
load_mode = LSCP_LOAD_ON_DEMAND_HOLD;
break;
case 1:
load_mode = LSCP_LOAD_ON_DEMAND;
break;
case 0:
default:
load_mode = LSCP_LOAD_DEFAULT;
break;
}
if (::lscp_map_midi_instrument(pMainForm->client(), &instr,
m_sEngineName.toUtf8().constData(),
qsamplerUtilities::lscpEscapePath(
m_sInstrumentFile).toUtf8().constData(),
m_iInstrumentNr, m_fVolume, load_mode,
m_sName.toUtf8().constData()) != LSCP_OK) {
pMainForm->appendMessagesClient("lscp_map_midi_instrument");
return false;
}
return true;
#else
return false;
#endif
}
// Browse and open an instrument file.
void ChannelForm::openInstrumentFile (void)
{
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return;
if (pMainForm->client() == NULL)
return;
Options *pOptions = pMainForm->options();
if (pOptions == NULL)
return;
// FIXME: the instrument file filters should be restricted,
// depending on the current engine.
QString sInstrumentFile = QFileDialog::getOpenFileName(this,
QSAMPLER_TITLE ": " + tr("Instrument files"), // Caption.
pOptions->sInstrumentDir, // Start here.
tr("Instrument files") + " (*.gig *.dls)" // Filter (GIG and DLS files)
);
if (sInstrumentFile.isEmpty())
return;
m_ui.InstrumentFileComboBox->setEditText(sInstrumentFile);
updateInstrumentName();
}
// Show device options dialog.
void ChannelForm::setupDevice ( Device *pDevice,
Device::DeviceType deviceTypeMode,
const QString& sDriverName )
{
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return;
if (pMainForm->client() == NULL)
return;
// Create the device form if not already...
if (m_pDeviceForm == NULL) {
m_pDeviceForm = new DeviceForm(this, Qt::Dialog);
m_pDeviceForm->setAttribute(Qt::WA_ShowModal);
QObject::connect(m_pDeviceForm, SIGNAL(devicesChanged()),
this, SLOT(updateDevices()));
}
// Refresh the device form with selected data.
if (m_pDeviceForm) {
m_pDeviceForm->setDeviceTypeMode(deviceTypeMode);
m_pDeviceForm->refreshDevices();
m_pDeviceForm->setDevice(pDevice);
m_pDeviceForm->setDriverName(sDriverName);
m_pDeviceForm->show();
}
}
// Reset channel method.
bool Channel::channelReset (void)
{
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;
}
void Options::setMaxStreams(int iMaxStreams) {
#ifdef CONFIG_MAX_VOICES
if (iMaxStreams < 0) return;
MainForm *pMainForm = MainForm::getInstance();
if (!pMainForm || !pMainForm->client())
return;
lscp_status_t result =
::lscp_set_streams(pMainForm->client(), iMaxStreams);
if (result != LSCP_OK) {
pMainForm->appendMessagesClient("lscp_set_streams");
return;
}
this->iMaxStreams = iMaxStreams;
#endif // CONFIG_MAX_VOICES
}
void Options::sendFineTuningSettings() {
setMaxVoices(iMaxVoices);
setMaxStreams(iMaxStreams);
MainForm *pMainForm = MainForm::getInstance();
if (!pMainForm || !pMainForm->client())
return;
pMainForm->appendMessages(QObject::tr("Sent fine tuning settings."));
}
bool Channel::setAudioDevice ( int iAudioDevice )
{
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;
}
appendMessages(QObject::tr("Audio device: %1.").arg(iAudioDevice));
m_iAudioDevice = iAudioDevice;
return true;
}
bool Channel::setMidiChannel ( int iMidiChannel )
{
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;
}
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;
}
bool Channel::setVolume ( float fVolume )
{
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(pMainForm->client(), m_iChannelID, fVolume) != LSCP_OK) {
appendMessagesClient("lscp_set_channel_volume");
return false;
}
appendMessages(QObject::tr("Volume: %1.").arg(fVolume));
m_fVolume = fVolume;
return true;
}
QList<int> FxSend::allFxSendsOfSamplerChannel(int samplerChannelID) {
QList<int> sends;
MainForm *pMainForm = MainForm::getInstance();
if (!pMainForm || !pMainForm->client())
return sends;
#ifdef CONFIG_FXSEND
int *piSends = ::lscp_list_fxsends(pMainForm->client(), samplerChannelID);
if (!piSends) {
if (::lscp_client_get_errno(pMainForm->client()))
pMainForm->appendMessagesClient("lscp_list_fxsends");
} else {
for (int iSend = 0; piSends[iSend] >= 0; ++iSend)
sends.append(piSends[iSend]);
}
#endif // CONFIG_FXSEND
return sends;
}
bool Channel::loadEngine ( const QString& sEngineName )
{
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;
}
appendMessages(QObject::tr("Engine: %1.").arg(sEngineName));
m_sEngineName = sEngineName;
return true;
}
bool Channel::setAudioDriver ( const QString& sAudioDriver )
{
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;
}
appendMessages(QObject::tr("Audio driver: %1.").arg(sAudioDriver));
m_sAudioDriver = sAudioDriver;
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;
#else
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
}
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;
#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
}
// Create a new sampler channel, if not already.
bool Channel::addChannel (void)
{
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);
}
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
}
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;
}
// Remove sampler channel.
bool Channel::removeChannel (void)
{
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;
}
}
// Return whether we've removed the channel...
return (m_iChannelID < 0);
}
void DeviceStatusForm::onDevicesChanged (void)
{
MainForm* pMainForm = MainForm::getInstance();
if (pMainForm && pMainForm->client()) {
std::set<int> deviceIDs
= Device::getDeviceIDs(pMainForm->client(), Device::Midi);
// hide and delete status forms whose device has been destroyed
std::map<int, DeviceStatusForm *>::iterator iter = g_instances.begin();
for ( ; iter != g_instances.end(); ++iter) {
if (deviceIDs.find(iter->first) == deviceIDs.end()) {
iter->second->hide();
delete iter->second;
g_instances.erase(iter);
}
}
// create status forms for new devices
std::set<int>::iterator it = deviceIDs.begin();
for ( ; it != deviceIDs.end(); ++it) {
if (g_instances.find(*it) == g_instances.end()) {
// What style do we create these forms?
Qt::WindowFlags wflags = Qt::Window
| Qt::CustomizeWindowHint
| Qt::WindowTitleHint
| Qt::WindowSystemMenuHint
| Qt::WindowMinMaxButtonsHint
| Qt::WindowCloseButtonHint;
Options *pOptions = pMainForm->options();
if (pOptions && pOptions->bKeepOnTop)
wflags |= Qt::Tool;
// Create the form, giving it the device id.
DeviceStatusForm *pStatusForm
= new DeviceStatusForm(*it, NULL, wflags);
g_instances[*it] = pStatusForm;
}
}
}
}
bool FxSend::getFromSampler() {
#if CONFIG_FXSEND
m_bModified = false;
// in case this is a new, actually not yet existing FX send, ignore update
if (isNew())
return true;
MainForm *pMainForm = MainForm::getInstance();
if (!pMainForm || !pMainForm->client())
return false;
lscp_fxsend_info_t* pFxSendInfo =
::lscp_get_fxsend_info(
pMainForm->client(),
m_iSamplerChannelID,
m_iFxSendID);
if (!pFxSendInfo) {
pMainForm->appendMessagesClient("lscp_get_fxsend_info");
return false;
}
m_FxSendName = qsamplerUtilities::lscpEscapedTextToRaw(pFxSendInfo->name);
m_MidiCtrl = pFxSendInfo->midi_controller;
m_Depth = pFxSendInfo->level;
m_AudioRouting.clear();
if (pFxSendInfo->audio_routing)
for (int i = 0; pFxSendInfo->audio_routing[i] != -1; ++i)
m_AudioRouting[i] = pFxSendInfo->audio_routing[i];
return true;
#else // CONFIG_FXSEND
return false;
#endif // CONFIG_FXSEND
}
// Instrument map name enumerator.
QString Instrument::getMapName ( int iMidiMap )
{
QString sMapName;
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return sMapName;
if (pMainForm->client() == NULL)
return sMapName;
#ifdef CONFIG_MIDI_INSTRUMENT
const char *pszMapName
= ::lscp_get_midi_instrument_map_name(pMainForm->client(), iMidiMap);
if (pszMapName == NULL) {
pszMapName = " -";
if (::lscp_client_get_errno(pMainForm->client()))
pMainForm->appendMessagesClient("lscp_get_midi_instrument_name");
}
sMapName = QString("%1 - %2").arg(iMidiMap)
.arg(qsamplerUtilities::lscpEscapedTextToRaw(pszMapName));
#endif
return sMapName;
}
// Accept settings (OK button slot).
void InstrumentForm::accept (void)
{
if (m_pInstrument == NULL)
return;
MainForm* pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return;
if (pMainForm->client() == NULL)
return;
Options *pOptions = pMainForm->options();
if (pOptions == NULL)
return;
if (m_iDirtyCount > 0) {
m_pInstrument->setMap(m_ui.MapComboBox->currentIndex());
m_pInstrument->setBank(m_ui.BankSpinBox->value());
m_pInstrument->setProg(m_ui.ProgSpinBox->value() - 1);
m_pInstrument->setName(m_ui.NameLineEdit->text());
m_pInstrument->setEngineName(m_ui.EngineNameComboBox->currentText());
m_pInstrument->setInstrumentFile(m_ui.InstrumentFileComboBox->currentText());
m_pInstrument->setInstrumentNr(m_ui.InstrumentNrComboBox->currentIndex());
m_pInstrument->setVolume(0.01f * float(m_ui.VolumeSpinBox->value()));
m_pInstrument->setLoadMode(m_ui.LoadModeComboBox->currentIndex());
}
// Save default engine name, instrument directory and history...
pOptions->sInstrumentDir = QFileInfo(
m_ui.InstrumentFileComboBox->currentText()).dir().absolutePath();
pOptions->sEngineName = m_ui.EngineNameComboBox->currentText();
pOptions->iMidiMap = m_ui.MapComboBox->currentIndex();
pOptions->iMidiBank = m_ui.BankSpinBox->value();
pOptions->iMidiProg = m_ui.ProgSpinBox->value();
pOptions->iVolume = m_ui.VolumeSpinBox->value();
pOptions->iLoadMode = m_ui.LoadModeComboBox->currentIndex();
pOptions->saveComboBoxHistory(m_ui.InstrumentFileComboBox);
// Just go with dialog acceptance.
QDialog::accept();
}
// Refresh the actual instrument name.
void ChannelForm::updateInstrumentName (void)
{
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return;
if (pMainForm->client() == NULL)
return;
Options *pOptions = pMainForm->options();
if (pOptions == NULL)
return;
// Finally this better idea would be to use libgig
// to retrieve the REAL instrument names.
m_ui.InstrumentNrComboBox->clear();
m_ui.InstrumentNrComboBox->insertItems(0,
Channel::getInstrumentList(
m_ui.InstrumentFileComboBox->currentText(),
pOptions->bInstrumentNames)
);
optionsChanged();
}
// Refresh Audio driver item devices.
void ChannelForm::selectAudioDriverItem ( const QString& sAudioDriver )
{
MainForm *pMainForm = MainForm::getInstance();
if (pMainForm == NULL)
return;
if (pMainForm->client() == NULL)
return;
const QString sDriverName = sAudioDriver.toUpper();
// Save current device id.
int iDeviceID = 0;
Device *pDevice = NULL;
int iAudioItem = m_ui.AudioDeviceComboBox->currentIndex();
if (iAudioItem >= 0 && iAudioItem < m_audioDevices.count())
pDevice = m_audioDevices.at(iAudioItem);
if (pDevice)
iDeviceID = pDevice->deviceID();
// Clean maplist.
m_ui.AudioDeviceComboBox->clear();
qDeleteAll(m_audioDevices);
m_audioDevices.clear();
// Populate with the current ones...
const QPixmap audioPixmap(":/icons/audio2.png");
int *piDeviceIDs = Device::getDevices(pMainForm->client(),
Device::Audio);
for (int i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; i++) {
pDevice = new Device(Device::Audio, piDeviceIDs[i]);
if (pDevice->driverName().toUpper() == sDriverName) {
m_ui.AudioDeviceComboBox->insertItem(0,
audioPixmap, pDevice->deviceName());
m_audioDevices.append(pDevice);
} else {
delete pDevice;
}
}
// Do proper enabling...
bool bEnabled = !m_audioDevices.isEmpty();
if (bEnabled) {
// Select the previous current device...
iAudioItem = 0;
QListIterator<Device *> iter(m_audioDevices);
while (iter.hasNext()) {
pDevice = iter.next();
if (pDevice->deviceID() == iDeviceID) {
m_ui.AudioDeviceComboBox->setCurrentIndex(iAudioItem);
selectAudioDeviceItem(iAudioItem);
break;
}
iAudioItem++;
}
} else {
m_ui.AudioDeviceComboBox->insertItem(0,
tr("(New Audio %1 device)").arg(sAudioDriver));
//m_ui.AudioRoutingTable->setNumRows(0);
}
m_ui.AudioDeviceTextLabel->setEnabled(bEnabled);
m_ui.AudioDeviceComboBox->setEnabled(bEnabled);
m_ui.AudioRoutingTable->setEnabled(bEnabled);
}