/[svn]/qsampler/trunk/src/qsamplerChannelForm.cpp
ViewVC logotype

Annotation of /qsampler/trunk/src/qsamplerChannelForm.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1527 - (hide annotations) (download)
Mon Nov 26 16:00:21 2007 UTC (16 years, 4 months ago) by schoenebeck
File size: 24316 byte(s)
* Added recent new support of libgig for retrieving instrument names in a
  very fast way. If libgig provides this feature, then the respective
  name retrieval setting in qsampler is enabled by default.

1 capela 1464 // qsamplerChannelForm.cpp
2     //
3     /****************************************************************************
4     Copyright (C) 2004-2007, rncbc aka Rui Nuno Capela. All rights reserved.
5     Copyright (C) 2007, Christian Schoenebeck
6    
7     This program is free software; you can redistribute it and/or
8     modify it under the terms of the GNU General Public License
9     as published by the Free Software Foundation; either version 2
10     of the License, or (at your option) any later version.
11    
12     This program 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 along
18     with this program; if not, write to the Free Software Foundation, Inc.,
19     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
20    
21     *****************************************************************************/
22    
23 schoenebeck 1461 #include "qsamplerChannelForm.h"
24    
25     #include "qsamplerAbout.h"
26     #include "qsamplerDeviceForm.h"
27    
28     #include "qsamplerMainForm.h"
29     #include "qsamplerInstrument.h"
30    
31 capela 1499 #include <QValidator>
32     #include <QMessageBox>
33     #include <QFileDialog>
34     #include <QFileInfo>
35 schoenebeck 1461
36 capela 1499 #include <QHeaderView>
37    
38    
39 schoenebeck 1461 namespace QSampler {
40    
41 capela 1509 ChannelForm::ChannelForm ( QWidget* pParent )
42     : QDialog(pParent)
43     {
44 capela 1510 m_ui.setupUi(this);
45 schoenebeck 1461
46     // Initialize locals.
47     m_pChannel = NULL;
48    
49     m_iDirtySetup = 0;
50     m_iDirtyCount = 0;
51    
52 capela 1499 // m_midiDevices.setAutoDelete(true);
53     // m_audioDevices.setAutoDelete(true);
54 schoenebeck 1461
55     m_pDeviceForm = NULL;
56    
57 capela 1519 int iRowHeight = m_ui.AudioRoutingTable->fontMetrics().height() + 4;
58     m_ui.AudioRoutingTable->verticalHeader()->setDefaultSectionSize(iRowHeight);
59     m_ui.AudioRoutingTable->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
60    
61 capela 1509 m_ui.AudioRoutingTable->setModel(&m_routingModel);
62     m_ui.AudioRoutingTable->setItemDelegate(&m_routingDelegate);
63     m_ui.AudioRoutingTable->horizontalHeader()->setResizeMode(0, QHeaderView::Stretch);
64     // m_ui.AudioRoutingTable->verticalHeader()->hide();
65    
66     // This goes initially hidden, and will be shown
67 capela 1510 // on setup() for currently existing channels...
68 capela 1509 m_ui.AudioRoutingTable->hide();
69    
70 schoenebeck 1461 // Try to restore normal window positioning.
71     adjustSize();
72 capela 1466
73 capela 1509 QObject::connect(m_ui.EngineNameComboBox,
74 capela 1466 SIGNAL(activated(int)),
75     SLOT(optionsChanged()));
76 capela 1509 QObject::connect(m_ui.InstrumentFileComboBox,
77 schoenebeck 1474 SIGNAL(activated(const QString&)),
78 capela 1466 SLOT(updateInstrumentName()));
79 capela 1509 QObject::connect(m_ui.InstrumentFileToolButton,
80 capela 1466 SIGNAL(clicked()),
81     SLOT(openInstrumentFile()));
82 capela 1509 QObject::connect(m_ui.InstrumentNrComboBox,
83 capela 1466 SIGNAL(activated(int)),
84     SLOT(optionsChanged()));
85 capela 1509 QObject::connect(m_ui.MidiDriverComboBox,
86 schoenebeck 1474 SIGNAL(activated(const QString&)),
87     SLOT(selectMidiDriver(const QString&)));
88 capela 1509 QObject::connect(m_ui.MidiDeviceComboBox,
89 capela 1466 SIGNAL(activated(int)),
90     SLOT(selectMidiDevice(int)));
91 capela 1509 QObject::connect(m_ui.MidiPortSpinBox,
92 capela 1466 SIGNAL(valueChanged(int)),
93     SLOT(optionsChanged()));
94 capela 1509 QObject::connect(m_ui.MidiChannelComboBox,
95 capela 1466 SIGNAL(activated(int)),
96     SLOT(optionsChanged()));
97 capela 1509 QObject::connect(m_ui.MidiMapComboBox,
98 capela 1466 SIGNAL(activated(int)),
99     SLOT(optionsChanged()));
100 capela 1509 QObject::connect(m_ui.AudioDriverComboBox,
101 schoenebeck 1474 SIGNAL(activated(const QString&)),
102     SLOT(selectAudioDriver(const QString&)));
103 capela 1509 QObject::connect(m_ui.AudioDeviceComboBox,
104 capela 1466 SIGNAL(activated(int)),
105     SLOT(selectAudioDevice(int)));
106 capela 1509 QObject::connect(m_ui.OkPushButton,
107 capela 1466 SIGNAL(clicked()),
108     SLOT(accept()));
109 capela 1509 QObject::connect(m_ui.CancelPushButton,
110 capela 1466 SIGNAL(clicked()),
111     SLOT(reject()));
112 capela 1509 QObject::connect(m_ui.MidiDeviceToolButton,
113 capela 1466 SIGNAL(clicked()),
114     SLOT(setupMidiDevice()));
115 capela 1509 QObject::connect(m_ui.AudioDeviceToolButton,
116 capela 1466 SIGNAL(clicked()),
117     SLOT(setupAudioDevice()));
118 capela 1509 QObject::connect(&m_routingModel,
119 schoenebeck 1489 SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
120     SLOT(optionsChanged()));
121 capela 1509 QObject::connect(&m_routingModel,
122 schoenebeck 1489 SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
123     SLOT(updateTableCellRenderers(const QModelIndex&, const QModelIndex&)));
124 capela 1509 QObject::connect(&m_routingModel,
125 schoenebeck 1489 SIGNAL(modelReset()),
126     SLOT(updateTableCellRenderers()));
127 schoenebeck 1461 }
128    
129 capela 1499 ChannelForm::~ChannelForm()
130     {
131 schoenebeck 1461 if (m_pDeviceForm)
132     delete m_pDeviceForm;
133     m_pDeviceForm = NULL;
134 capela 1499
135     qDeleteAll(m_midiDevices);
136     m_midiDevices.clear();
137    
138     qDeleteAll(m_audioDevices);
139     m_audioDevices.clear();
140 schoenebeck 1461 }
141    
142    
143     // Channel dialog setup formal initializer.
144     void ChannelForm::setup ( qsamplerChannel *pChannel )
145     {
146     m_pChannel = pChannel;
147    
148     m_iDirtySetup = 0;
149     m_iDirtyCount = 0;
150    
151     if (m_pChannel == NULL)
152     return;
153    
154     // It can be a brand new channel, remember?
155     bool bNew = (m_pChannel->channelID() < 0);
156 capela 1499 setWindowTitle(QSAMPLER_TITLE ": " + m_pChannel->channelName());
157 schoenebeck 1461
158     // Check if we're up and connected.
159     MainForm *pMainForm = MainForm::getInstance();
160     if (pMainForm == NULL)
161     return;
162     if (pMainForm->client() == NULL)
163     return;
164    
165     qsamplerOptions *pOptions = pMainForm->options();
166     if (pOptions == NULL)
167     return;
168    
169     // Avoid nested changes.
170     m_iDirtySetup++;
171    
172     // Load combo box history...
173 capela 1509 pOptions->loadComboBoxHistory(m_ui.InstrumentFileComboBox);
174 schoenebeck 1461
175     // Populate Engines list.
176     const char **ppszEngines = ::lscp_list_available_engines(pMainForm->client());
177     if (ppszEngines) {
178 capela 1509 m_ui.EngineNameComboBox->clear();
179 schoenebeck 1461 for (int iEngine = 0; ppszEngines[iEngine]; iEngine++)
180 capela 1509 m_ui.EngineNameComboBox->addItem(QString(ppszEngines[iEngine]));
181 schoenebeck 1461 }
182     else m_pChannel->appendMessagesClient("lscp_list_available_engines");
183    
184     // Populate Audio output type list.
185 capela 1509 m_ui.AudioDriverComboBox->clear();
186     m_ui.AudioDriverComboBox->insertItems(0,
187 schoenebeck 1461 qsamplerDevice::getDrivers(pMainForm->client(), qsamplerDevice::Audio));
188    
189     // Populate MIDI input type list.
190 capela 1509 m_ui.MidiDriverComboBox->clear();
191     m_ui.MidiDriverComboBox->insertItems(0,
192 schoenebeck 1461 qsamplerDevice::getDrivers(pMainForm->client(), qsamplerDevice::Midi));
193    
194     // Populate Maps list.
195 capela 1509 m_ui.MidiMapComboBox->clear();
196     m_ui.MidiMapComboBox->insertItems(0,
197 capela 1499 qsamplerInstrument::getMapNames());
198 schoenebeck 1461
199     // Read proper channel information,
200     // and populate the channel form fields.
201    
202     // Engine name...
203     QString sEngineName = pChannel->engineName();
204     if (sEngineName.isEmpty() || bNew)
205     sEngineName = pOptions->sEngineName;
206     if (sEngineName.isEmpty())
207     sEngineName = qsamplerChannel::noEngineName();
208 capela 1509 if (m_ui.EngineNameComboBox->findText(sEngineName,
209 schoenebeck 1474 Qt::MatchExactly | Qt::MatchCaseSensitive) < 0) {
210 capela 1509 m_ui.EngineNameComboBox->addItem(sEngineName);
211 schoenebeck 1461 }
212 capela 1509 m_ui.EngineNameComboBox->setCurrentIndex(
213     m_ui.EngineNameComboBox->findText(sEngineName,
214 schoenebeck 1474 Qt::MatchExactly | Qt::MatchCaseSensitive));
215 capela 1504
216 schoenebeck 1461 // Instrument filename and index...
217     QString sInstrumentFile = pChannel->instrumentFile();
218     if (sInstrumentFile.isEmpty())
219     sInstrumentFile = qsamplerChannel::noInstrumentName();
220 capela 1509 m_ui.InstrumentFileComboBox->setEditText(sInstrumentFile);
221     m_ui.InstrumentNrComboBox->clear();
222     m_ui.InstrumentNrComboBox->insertItems(0,
223 schoenebeck 1461 qsamplerChannel::getInstrumentList(sInstrumentFile,
224     pOptions->bInstrumentNames));
225 capela 1510 int iInstrumentNr = pChannel->instrumentNr();
226     if (iInstrumentNr < 0)
227     iInstrumentNr = 0;
228     m_ui.InstrumentNrComboBox->setCurrentIndex(iInstrumentNr);
229 schoenebeck 1461
230     // MIDI input device...
231     qsamplerDevice midiDevice(qsamplerDevice::Midi, m_pChannel->midiDevice());
232     // MIDI input driver...
233     QString sMidiDriver = midiDevice.driverName();
234     if (sMidiDriver.isEmpty() || bNew)
235 capela 1499 sMidiDriver = pOptions->sMidiDriver.toUpper();
236 schoenebeck 1461 if (!sMidiDriver.isEmpty()) {
237 capela 1509 if (m_ui.MidiDriverComboBox->findText(sMidiDriver,
238 schoenebeck 1474 Qt::MatchExactly | Qt::MatchCaseSensitive) < 0) {
239 capela 1509 m_ui.MidiDriverComboBox->insertItem(0, sMidiDriver);
240 schoenebeck 1461 }
241 capela 1509 m_ui.MidiDriverComboBox->setItemText(
242     m_ui.MidiDriverComboBox->currentIndex(),
243 capela 1499 sMidiDriver);
244 schoenebeck 1461 }
245     selectMidiDriverItem(sMidiDriver);
246 capela 1499 if (!bNew) {
247 capela 1509 m_ui.MidiDeviceComboBox->setItemText(
248     m_ui.MidiDeviceComboBox->currentIndex(),
249 capela 1499 midiDevice.deviceName());
250     }
251 capela 1509 selectMidiDeviceItem(m_ui.MidiDeviceComboBox->currentIndex());
252 schoenebeck 1461 // MIDI input port...
253 capela 1509 m_ui.MidiPortSpinBox->setValue(pChannel->midiPort());
254 schoenebeck 1461 // MIDI input channel...
255     int iMidiChannel = pChannel->midiChannel();
256     // When new, try to suggest a sensible MIDI channel...
257     if (iMidiChannel < 0)
258     iMidiChannel = (::lscp_get_channels(pMainForm->client()) % 16);
259 capela 1509 m_ui.MidiChannelComboBox->setCurrentIndex(iMidiChannel);
260 schoenebeck 1461 // MIDI instrument map...
261     int iMidiMap = (bNew ? pOptions->iMidiMap : pChannel->midiMap());
262     // When new, try to suggest a sensible MIDI map...
263     if (iMidiMap < 0)
264     iMidiMap = 0;
265     const QString& sMapName = qsamplerInstrument::getMapName(iMidiMap);
266 capela 1499 if (!sMapName.isEmpty()) {
267 capela 1509 m_ui.MidiMapComboBox->setItemText(
268     m_ui.MidiMapComboBox->currentIndex(),
269 capela 1499 sMapName);
270     }
271 schoenebeck 1461 // It might be no maps around...
272 capela 1509 bool bMidiMapEnabled = (m_ui.MidiMapComboBox->count() > 0);
273     m_ui.MidiMapTextLabel->setEnabled(bMidiMapEnabled);
274     m_ui.MidiMapComboBox->setEnabled(bMidiMapEnabled);
275 schoenebeck 1461
276     // Audio output device...
277     qsamplerDevice audioDevice(qsamplerDevice::Audio, m_pChannel->audioDevice());
278     // Audio output driver...
279     QString sAudioDriver = audioDevice.driverName();
280     if (sAudioDriver.isEmpty() || bNew)
281 capela 1499 sAudioDriver = pOptions->sAudioDriver.toUpper();
282 schoenebeck 1461 if (!sAudioDriver.isEmpty()) {
283 capela 1509 if (m_ui.AudioDriverComboBox->findText(sAudioDriver,
284 schoenebeck 1474 Qt::MatchExactly | Qt::MatchCaseSensitive) < 0) {
285 capela 1509 m_ui.AudioDriverComboBox->insertItem(0, sAudioDriver);
286 schoenebeck 1461 }
287 capela 1509 m_ui.AudioDriverComboBox->setItemText(
288     m_ui.AudioDriverComboBox->currentIndex(),
289 capela 1499 sAudioDriver);
290 schoenebeck 1461 }
291     selectAudioDriverItem(sAudioDriver);
292 capela 1499 if (!bNew) {
293 capela 1509 m_ui.AudioDeviceComboBox->setItemText(
294     m_ui.AudioDeviceComboBox->currentIndex(),
295 capela 1499 audioDevice.deviceName());
296     }
297 capela 1509 selectAudioDeviceItem(m_ui.AudioDeviceComboBox->currentIndex());
298 schoenebeck 1461
299 capela 1509 // Let the audio routing table see the light,
300     // if we're editing an existing sampler channel...
301     m_ui.AudioRoutingTable->setVisible(!bNew);
302    
303 schoenebeck 1527 const QString sInstrumentNrToolTip =
304     (pOptions->bInstrumentNames) ?
305     "Select an instrument of the file" :
306     "You might want to enable instrument name retrieval in the "
307     "settings dialog";
308     m_ui.InstrumentNrComboBox->setToolTip(
309     QObject::tr(sInstrumentNrToolTip.toUtf8().data())
310     );
311    
312 schoenebeck 1461 // As convenient, make it ready on stabilizeForm() for
313     // prompt acceptance, if we got the minimum required...
314     /* if (sEngineName != qsamplerChannel::noEngineName() &&
315     sInstrumentFile != qsamplerChannel::noInstrumentName())
316     m_iDirtyCount++; */
317     // Done.
318     m_iDirtySetup--;
319     stabilizeForm();
320     }
321    
322    
323     // Accept settings (OK button slot).
324     void ChannelForm::accept (void)
325     {
326     if (m_pChannel == NULL)
327     return;
328    
329     MainForm *pMainForm = MainForm::getInstance();
330     if (pMainForm == NULL)
331     return;
332     if (pMainForm->client() == NULL)
333     return;
334    
335     qsamplerOptions *pOptions = pMainForm->options();
336     if (pOptions == NULL)
337     return;
338    
339     // Flush any pending editing...
340 capela 1509 //m_ui.AudioRoutingTable->flush();
341 schoenebeck 1461
342     // We'll go for it!
343     if (m_iDirtyCount > 0) {
344     int iErrors = 0;
345     // Are we a new channel?
346     if (!m_pChannel->addChannel())
347     iErrors++;
348     // Accept Audio driver or device selection...
349     if (m_audioDevices.isEmpty()) {
350 capela 1509 if (!m_pChannel->setAudioDriver(m_ui.AudioDriverComboBox->currentText()))
351 schoenebeck 1461 iErrors++;
352     } else {
353 capela 1504 qsamplerDevice *pDevice = NULL;
354 capela 1509 int iAudioItem = m_ui.AudioDeviceComboBox->currentIndex();
355 capela 1504 if (iAudioItem >= 0 && iAudioItem < m_audioDevices.count())
356     pDevice = m_audioDevices.at(iAudioItem);
357 capela 1509 qsamplerChannelRoutingMap routingMap = m_routingModel.routingMap();
358 schoenebeck 1461 if (pDevice == NULL)
359     iErrors++;
360     else if (!m_pChannel->setAudioDevice(pDevice->deviceID()))
361     iErrors++;
362 schoenebeck 1489 else if (!routingMap.isEmpty()) {
363 schoenebeck 1461 // Set the audio route changes...
364     qsamplerChannelRoutingMap::ConstIterator iter;
365 schoenebeck 1489 for (iter = routingMap.begin();
366     iter != routingMap.end(); ++iter) {
367 capela 1499 if (!m_pChannel->setAudioChannel(iter.key(), iter.value()))
368 schoenebeck 1461 iErrors++;
369     }
370     }
371     }
372     // Accept MIDI driver or device selection...
373     if (m_midiDevices.isEmpty()) {
374 capela 1509 if (!m_pChannel->setMidiDriver(m_ui.MidiDriverComboBox->currentText()))
375 schoenebeck 1461 iErrors++;
376     } else {
377 capela 1504 qsamplerDevice *pDevice = NULL;
378 capela 1509 int iMidiItem = m_ui.MidiDeviceComboBox->currentIndex();
379 capela 1504 if (iMidiItem >= 0 && iMidiItem < m_midiDevices.count())
380     pDevice = m_midiDevices.at(iMidiItem);
381 schoenebeck 1461 if (pDevice == NULL)
382     iErrors++;
383     else if (!m_pChannel->setMidiDevice(pDevice->deviceID()))
384     iErrors++;
385     }
386     // MIDI input port number...
387 capela 1509 if (!m_pChannel->setMidiPort(m_ui.MidiPortSpinBox->value()))
388 schoenebeck 1461 iErrors++;
389     // MIDI input channel...
390 capela 1509 if (!m_pChannel->setMidiChannel(m_ui.MidiChannelComboBox->currentIndex()))
391 schoenebeck 1461 iErrors++;
392     // Engine name...
393 capela 1509 if (!m_pChannel->loadEngine(m_ui.EngineNameComboBox->currentText()))
394 schoenebeck 1461 iErrors++;
395     // Instrument file and index...
396 capela 1509 const QString& sPath = m_ui.InstrumentFileComboBox->currentText();
397 schoenebeck 1461 if (!sPath.isEmpty() && QFileInfo(sPath).exists()) {
398 capela 1509 if (!m_pChannel->loadInstrument(sPath, m_ui.InstrumentNrComboBox->currentIndex()))
399 schoenebeck 1461 iErrors++;
400     }
401     // MIDI intrument map...
402 capela 1509 if (!m_pChannel->setMidiMap(m_ui.MidiMapComboBox->currentIndex()))
403 schoenebeck 1461 iErrors++;
404     // Show error messages?
405 capela 1510 if (iErrors > 0) {
406     m_pChannel->appendMessagesError(
407     tr("Some channel settings could not be set.\n\nSorry."));
408     }
409 schoenebeck 1461 }
410    
411     // Save default engine name, instrument directory and history...
412 capela 1499 pOptions->sInstrumentDir = QFileInfo(
413 capela 1509 m_ui.InstrumentFileComboBox->currentText()).dir().absolutePath();
414     pOptions->sEngineName = m_ui.EngineNameComboBox->currentText();
415     pOptions->sAudioDriver = m_ui.AudioDriverComboBox->currentText();
416     pOptions->sMidiDriver = m_ui.MidiDriverComboBox->currentText();
417     pOptions->iMidiMap = m_ui.MidiMapComboBox->currentIndex();
418     pOptions->saveComboBoxHistory(m_ui.InstrumentFileComboBox);
419 schoenebeck 1461
420     // Just go with dialog acceptance.
421     QDialog::accept();
422     }
423    
424    
425     // Reject settings (Cancel button slot).
426     void ChannelForm::reject (void)
427     {
428     bool bReject = true;
429    
430     // Check if there's any pending changes...
431 capela 1509 if (m_iDirtyCount > 0 && m_ui.OkPushButton->isEnabled()) {
432 schoenebeck 1461 switch (QMessageBox::warning(this,
433     QSAMPLER_TITLE ": " + tr("Warning"),
434     tr("Some channel settings have been changed.\n\n"
435     "Do you want to apply the changes?"),
436     tr("Apply"), tr("Discard"), tr("Cancel"))) {
437     case 0: // Apply...
438     accept();
439     return;
440     case 1: // Discard
441     break;
442     default: // Cancel.
443     bReject = false;
444     break;
445     }
446     }
447    
448     if (bReject)
449     QDialog::reject();
450     }
451    
452    
453     // Browse and open an instrument file.
454     void ChannelForm::openInstrumentFile (void)
455     {
456     MainForm *pMainForm = MainForm::getInstance();
457     if (pMainForm == NULL)
458     return;
459     if (pMainForm->client() == NULL)
460     return;
461    
462     qsamplerOptions *pOptions = pMainForm->options();
463     if (pOptions == NULL)
464     return;
465    
466     // FIXME: the instrument file filters should be restricted,
467     // depending on the current engine.
468 capela 1499 QString sInstrumentFile = QFileDialog::getOpenFileName(this,
469     QSAMPLER_TITLE ": " + tr("Instrument files"), // Caption.
470     pOptions->sInstrumentDir, // Start here.
471     tr("Instrument files") + " (*.gig *.dls)" // Filter (GIG and DLS files)
472 schoenebeck 1461 );
473    
474     if (sInstrumentFile.isEmpty())
475     return;
476    
477 capela 1509 m_ui.InstrumentFileComboBox->setEditText(sInstrumentFile);
478 schoenebeck 1461 updateInstrumentName();
479     }
480    
481    
482     // Refresh the actual instrument name.
483     void ChannelForm::updateInstrumentName (void)
484     {
485     MainForm *pMainForm = MainForm::getInstance();
486     if (pMainForm == NULL)
487     return;
488     if (pMainForm->client() == NULL)
489     return;
490    
491     qsamplerOptions *pOptions = pMainForm->options();
492     if (pOptions == NULL)
493     return;
494    
495     // Finally this better idea would be to use libgig
496     // to retrieve the REAL instrument names.
497 capela 1509 m_ui.InstrumentNrComboBox->clear();
498     m_ui.InstrumentNrComboBox->insertItems(0,
499 schoenebeck 1461 qsamplerChannel::getInstrumentList(
500 capela 1509 m_ui.InstrumentFileComboBox->currentText(),
501 schoenebeck 1461 pOptions->bInstrumentNames)
502     );
503    
504     optionsChanged();
505     }
506    
507    
508     // Show device options dialog.
509     void ChannelForm::setupDevice ( qsamplerDevice *pDevice,
510 capela 1509 qsamplerDevice::DeviceType deviceTypeMode,
511 schoenebeck 1461 const QString& sDriverName )
512     {
513     MainForm *pMainForm = MainForm::getInstance();
514     if (pMainForm == NULL)
515     return;
516     if (pMainForm->client() == NULL)
517     return;
518    
519     // Create the device form if not already...
520     if (m_pDeviceForm == NULL) {
521     m_pDeviceForm = new DeviceForm(this, Qt::Dialog);
522 capela 1510 m_pDeviceForm->setAttribute(Qt::WA_ShowModal);
523 schoenebeck 1461 QObject::connect(m_pDeviceForm, SIGNAL(devicesChanged()),
524     this, SLOT(updateDevices()));
525     }
526    
527     // Refresh the device form with selected data.
528     if (m_pDeviceForm) {
529     m_pDeviceForm->setDeviceTypeMode(deviceTypeMode);
530     m_pDeviceForm->refreshDevices();
531     m_pDeviceForm->setDevice(pDevice);
532     m_pDeviceForm->setDriverName(sDriverName);
533     m_pDeviceForm->show();
534     }
535     }
536    
537    
538     // Refresh MIDI driver item devices.
539     void ChannelForm::selectMidiDriverItem ( const QString& sMidiDriver )
540     {
541     MainForm *pMainForm = MainForm::getInstance();
542     if (pMainForm == NULL)
543     return;
544     if (pMainForm->client() == NULL)
545     return;
546    
547 capela 1499 const QString sDriverName = sMidiDriver.toUpper();
548 schoenebeck 1461
549     // Save current device id.
550 capela 1504 // Save current device id.
551 schoenebeck 1461 int iDeviceID = 0;
552 capela 1504 qsamplerDevice *pDevice = NULL;
553 capela 1509 int iMidiItem = m_ui.MidiDeviceComboBox->currentIndex();
554 capela 1504 if (iMidiItem >= 0 && iMidiItem < m_midiDevices.count())
555     pDevice = m_midiDevices.at(iMidiItem);
556 schoenebeck 1461 if (pDevice)
557     iDeviceID = pDevice->deviceID();
558    
559     // Clean maplist.
560 capela 1509 m_ui.MidiDeviceComboBox->clear();
561 capela 1499 qDeleteAll(m_midiDevices);
562 schoenebeck 1461 m_midiDevices.clear();
563    
564     // Populate with the current ones...
565 schoenebeck 1489 const QPixmap midiPixmap(":/icons/midi2.png");
566 schoenebeck 1461 int *piDeviceIDs = qsamplerDevice::getDevices(pMainForm->client(),
567     qsamplerDevice::Midi);
568     for (int i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; i++) {
569     pDevice = new qsamplerDevice(qsamplerDevice::Midi, piDeviceIDs[i]);
570 capela 1499 if (pDevice->driverName().toUpper() == sDriverName) {
571 capela 1510 m_ui.MidiDeviceComboBox->insertItem(0,
572     midiPixmap, pDevice->deviceName());
573 schoenebeck 1461 m_midiDevices.append(pDevice);
574     } else {
575     delete pDevice;
576     }
577     }
578    
579     // Do proper enabling...
580     bool bEnabled = !m_midiDevices.isEmpty();
581     if (bEnabled) {
582     // Select the previous current device...
583 capela 1504 iMidiItem = 0;
584 capela 1499 QListIterator<qsamplerDevice *> iter(m_midiDevices);
585     while (iter.hasNext()) {
586     pDevice = iter.next();
587 schoenebeck 1461 if (pDevice->deviceID() == iDeviceID) {
588 capela 1509 m_ui.MidiDeviceComboBox->setCurrentIndex(iMidiItem);
589 schoenebeck 1461 selectMidiDeviceItem(iMidiItem);
590     break;
591     }
592     iMidiItem++;
593     }
594     } else {
595 capela 1509 m_ui.MidiDeviceComboBox->insertItem(0,
596 schoenebeck 1461 tr("(New MIDI %1 device)").arg(sMidiDriver));
597     }
598 capela 1509 m_ui.MidiDeviceTextLabel->setEnabled(bEnabled);
599     m_ui.MidiDeviceComboBox->setEnabled(bEnabled);
600 schoenebeck 1461 }
601    
602    
603     // Refresh MIDI device options slot.
604     void ChannelForm::selectMidiDriver ( const QString& sMidiDriver )
605     {
606     if (m_iDirtySetup > 0)
607     return;
608    
609     selectMidiDriverItem(sMidiDriver);
610     optionsChanged();
611     }
612    
613    
614     // Select MIDI device item.
615     void ChannelForm::selectMidiDeviceItem ( int iMidiItem )
616     {
617 capela 1504 qsamplerDevice *pDevice = NULL;
618     if (iMidiItem >= 0 && iMidiItem < m_midiDevices.count())
619     pDevice = m_midiDevices.at(iMidiItem);
620 schoenebeck 1461 if (pDevice) {
621     const qsamplerDeviceParamMap& params = pDevice->params();
622     int iPorts = params["PORTS"].value.toInt();
623 capela 1509 m_ui.MidiPortTextLabel->setEnabled(iPorts > 0);
624     m_ui.MidiPortSpinBox->setEnabled(iPorts > 0);
625 schoenebeck 1461 if (iPorts > 0)
626 capela 1509 m_ui.MidiPortSpinBox->setMaximum(iPorts - 1);
627 schoenebeck 1461 }
628     }
629    
630    
631     // Select MIDI device options slot.
632     void ChannelForm::selectMidiDevice ( int iMidiItem )
633     {
634     if (m_iDirtySetup > 0)
635     return;
636    
637     selectMidiDeviceItem(iMidiItem);
638     optionsChanged();
639     }
640    
641    
642     // MIDI device options.
643     void ChannelForm::setupMidiDevice (void)
644     {
645 capela 1504 qsamplerDevice *pDevice = NULL;
646 capela 1509 int iMidiItem = m_ui.MidiDeviceComboBox->currentIndex();
647 capela 1504 if (iMidiItem >= 0 && iMidiItem < m_midiDevices.count())
648     pDevice = m_midiDevices.at(iMidiItem);
649     setupDevice(pDevice,
650 capela 1509 qsamplerDevice::Midi, m_ui.MidiDriverComboBox->currentText());
651 schoenebeck 1461 }
652    
653    
654     // Refresh Audio driver item devices.
655     void ChannelForm::selectAudioDriverItem ( const QString& sAudioDriver )
656     {
657     MainForm *pMainForm = MainForm::getInstance();
658     if (pMainForm == NULL)
659     return;
660     if (pMainForm->client() == NULL)
661     return;
662    
663 capela 1499 const QString sDriverName = sAudioDriver.toUpper();
664 schoenebeck 1461
665     // Save current device id.
666     int iDeviceID = 0;
667 capela 1504 qsamplerDevice *pDevice = NULL;
668 capela 1509 int iAudioItem = m_ui.AudioDeviceComboBox->currentIndex();
669 capela 1504 if (iAudioItem >= 0 && iAudioItem < m_audioDevices.count())
670     pDevice = m_audioDevices.at(iAudioItem);
671 schoenebeck 1461 if (pDevice)
672     iDeviceID = pDevice->deviceID();
673    
674     // Clean maplist.
675 capela 1509 m_ui.AudioDeviceComboBox->clear();
676 capela 1499 qDeleteAll(m_audioDevices);
677 schoenebeck 1461 m_audioDevices.clear();
678    
679     // Populate with the current ones...
680 schoenebeck 1489 const QPixmap audioPixmap(":/icons/audio2.png");
681 schoenebeck 1461 int *piDeviceIDs = qsamplerDevice::getDevices(pMainForm->client(),
682     qsamplerDevice::Audio);
683     for (int i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; i++) {
684     pDevice = new qsamplerDevice(qsamplerDevice::Audio, piDeviceIDs[i]);
685 capela 1499 if (pDevice->driverName().toUpper() == sDriverName) {
686 capela 1510 m_ui.AudioDeviceComboBox->insertItem(0,
687     audioPixmap, pDevice->deviceName());
688 schoenebeck 1461 m_audioDevices.append(pDevice);
689     } else {
690     delete pDevice;
691     }
692     }
693    
694     // Do proper enabling...
695     bool bEnabled = !m_audioDevices.isEmpty();
696     if (bEnabled) {
697     // Select the previous current device...
698 capela 1504 iAudioItem = 0;
699 capela 1499 QListIterator<qsamplerDevice *> iter(m_audioDevices);
700     while (iter.hasNext()) {
701     pDevice = iter.next();
702 schoenebeck 1461 if (pDevice->deviceID() == iDeviceID) {
703 capela 1509 m_ui.AudioDeviceComboBox->setCurrentIndex(iAudioItem);
704 schoenebeck 1461 selectAudioDeviceItem(iAudioItem);
705     break;
706     }
707     iAudioItem++;
708     }
709     } else {
710 capela 1509 m_ui.AudioDeviceComboBox->insertItem(0,
711 schoenebeck 1461 tr("(New Audio %1 device)").arg(sAudioDriver));
712 capela 1509 //m_ui.AudioRoutingTable->setNumRows(0);
713 schoenebeck 1461 }
714 capela 1509 m_ui.AudioDeviceTextLabel->setEnabled(bEnabled);
715     m_ui.AudioDeviceComboBox->setEnabled(bEnabled);
716     m_ui.AudioRoutingTable->setEnabled(bEnabled);
717 schoenebeck 1461 }
718    
719    
720     // Refresh Audio device options slot.
721     void ChannelForm::selectAudioDriver ( const QString& sAudioDriver )
722     {
723     if (m_iDirtySetup > 0)
724     return;
725    
726     selectAudioDriverItem(sAudioDriver);
727     optionsChanged();
728     }
729    
730    
731     // Select Audio device item.
732     void ChannelForm::selectAudioDeviceItem ( int iAudioItem )
733     {
734 capela 1504 qsamplerDevice *pDevice = NULL;
735     if (iAudioItem >= 0 && iAudioItem < m_audioDevices.count())
736     pDevice = m_audioDevices.at(iAudioItem);
737 schoenebeck 1461 if (pDevice) {
738     // Refresh the audio routing table.
739 capela 1509 m_routingModel.refresh(pDevice, m_pChannel->audioRouting());
740 schoenebeck 1461 // Reset routing change map.
741 capela 1509 m_routingModel.clear();
742 schoenebeck 1461 }
743     }
744    
745    
746     // Select Audio device options slot.
747     void ChannelForm::selectAudioDevice ( int iAudioItem )
748     {
749     if (m_iDirtySetup > 0)
750     return;
751    
752     selectAudioDeviceItem(iAudioItem);
753     optionsChanged();
754     }
755    
756    
757     // Audio device options.
758     void ChannelForm::setupAudioDevice (void)
759     {
760 capela 1504 qsamplerDevice *pDevice = NULL;
761 capela 1509 int iAudioItem = m_ui.AudioDeviceComboBox->currentIndex();
762 capela 1504 if (iAudioItem >= 0 && iAudioItem < m_audioDevices.count())
763     pDevice = m_audioDevices.at(iAudioItem);
764     setupDevice(pDevice,
765 capela 1509 qsamplerDevice::Audio, m_ui.AudioDriverComboBox->currentText());
766 schoenebeck 1461 }
767    
768     // UPdate all device lists slot.
769     void ChannelForm::updateDevices (void)
770     {
771     if (m_iDirtySetup > 0)
772     return;
773    
774 capela 1509 selectMidiDriverItem(m_ui.MidiDriverComboBox->currentText());
775     selectAudioDriverItem(m_ui.AudioDriverComboBox->currentText());
776 schoenebeck 1461 optionsChanged();
777     }
778    
779    
780     // Dirty up settings.
781     void ChannelForm::optionsChanged (void)
782     {
783     if (m_iDirtySetup > 0)
784     return;
785    
786     m_iDirtyCount++;
787     stabilizeForm();
788     }
789    
790    
791     // Stabilize current form state.
792     void ChannelForm::stabilizeForm (void)
793     {
794 schoenebeck 1506 const bool bValid =
795 capela 1509 m_ui.EngineNameComboBox->currentIndex() >= 0 &&
796 capela 1510 m_ui.EngineNameComboBox->currentText()
797     != qsamplerChannel::noEngineName();
798 schoenebeck 1461 #if 0
799     const QString& sPath = InstrumentFileComboBox->currentText();
800     bValid = bValid && !sPath.isEmpty() && QFileInfo(sPath).exists();
801     #endif
802 capela 1509 m_ui.OkPushButton->setEnabled(m_iDirtyCount > 0 && bValid);
803 schoenebeck 1461 }
804    
805 capela 1509
806     void ChannelForm::updateTableCellRenderers (void)
807     {
808 capela 1510 const int rows = m_routingModel.rowCount();
809     const int cols = m_routingModel.columnCount();
810     updateTableCellRenderers(
811 capela 1509 m_routingModel.index(0, 0),
812     m_routingModel.index(rows - 1, cols - 1));
813 schoenebeck 1489 }
814 schoenebeck 1461
815 capela 1509
816     void ChannelForm::updateTableCellRenderers (
817     const QModelIndex& topLeft, const QModelIndex& bottomRight )
818     {
819 capela 1510 for (int r = topLeft.row(); r <= bottomRight.row(); r++) {
820     for (int c = topLeft.column(); c <= bottomRight.column(); c++) {
821     const QModelIndex index = m_routingModel.index(r, c);
822     m_ui.AudioRoutingTable->openPersistentEditor(index);
823     }
824     }
825 schoenebeck 1489 }
826    
827 schoenebeck 1461 } // namespace QSampler
828 capela 1464
829    
830     // end of qsamplerChannelForm.cpp

  ViewVC Help
Powered by ViewVC