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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1466 - (show annotations) (download)
Thu Nov 1 19:25:10 2007 UTC (16 years, 4 months ago) by capela
File size: 21207 byte(s)
* Qt4 migration: added missing signal/slot connections for most forms.

1 // 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 #include "qsamplerChannelForm.h"
24
25 #include "qsamplerAbout.h"
26 #include "qsamplerDeviceForm.h"
27
28 #include "qsamplerMainForm.h"
29 #include "qsamplerInstrument.h"
30
31 #include <qvalidator.h>
32 #include <qmessagebox.h>
33 #include <qfiledialog.h>
34 #include <qfileinfo.h>
35
36 namespace QSampler {
37
38 ChannelForm::ChannelForm(QWidget* parent) : QDialog(parent) {
39 ui.setupUi(this);
40
41 // Initialize locals.
42 m_pChannel = NULL;
43
44 m_iDirtySetup = 0;
45 m_iDirtyCount = 0;
46
47 m_midiDevices.setAutoDelete(true);
48 m_audioDevices.setAutoDelete(true);
49
50 m_pDeviceForm = NULL;
51
52 // Try to restore normal window positioning.
53 adjustSize();
54
55 QObject::connect(ui.EngineNameComboBox,
56 SIGNAL(activated(int)),
57 SLOT(optionsChanged()));
58 QObject::connect(ui.InstrumentFileComboBox,
59 SIGNAL(activated(const QString&amp;)),
60 SLOT(updateInstrumentName()));
61 QObject::connect(ui.InstrumentFileToolButton,
62 SIGNAL(clicked()),
63 SLOT(openInstrumentFile()));
64 QObject::connect(ui.InstrumentNrComboBox,
65 SIGNAL(activated(int)),
66 SLOT(optionsChanged()));
67 QObject::connect(ui.MidiDriverComboBox,
68 SIGNAL(activated(const QString&amp;)),
69 SLOT(selectMidiDriver(const QString&amp;)));
70 QObject::connect(ui.MidiDeviceComboBox,
71 SIGNAL(activated(int)),
72 SLOT(selectMidiDevice(int)));
73 QObject::connect(ui.MidiPortSpinBox,
74 SIGNAL(valueChanged(int)),
75 SLOT(optionsChanged()));
76 QObject::connect(ui.MidiChannelComboBox,
77 SIGNAL(activated(int)),
78 SLOT(optionsChanged()));
79 QObject::connect(ui.MidiMapComboBox,
80 SIGNAL(activated(int)),
81 SLOT(optionsChanged()));
82 QObject::connect(ui.AudioDriverComboBox,
83 SIGNAL(activated(const QString&amp;)),
84 SLOT(selectAudioDriver(const QString&amp;)));
85 QObject::connect(ui.AudioDeviceComboBox,
86 SIGNAL(activated(int)),
87 SLOT(selectAudioDevice(int)));
88 QObject::connect(ui.OkPushButton,
89 SIGNAL(clicked()),
90 SLOT(accept()));
91 QObject::connect(ui.CancelPushButton,
92 SIGNAL(clicked()),
93 SLOT(reject()));
94 QObject::connect(ui.MidiDeviceToolButton,
95 SIGNAL(clicked()),
96 SLOT(setupMidiDevice()));
97 QObject::connect(ui.AudioDeviceToolButton,
98 SIGNAL(clicked()),
99 SLOT(setupAudioDevice()));
100 }
101
102 ChannelForm::~ChannelForm() {
103 if (m_pDeviceForm)
104 delete m_pDeviceForm;
105 m_pDeviceForm = NULL;
106 }
107
108
109 // Channel dialog setup formal initializer.
110 void ChannelForm::setup ( qsamplerChannel *pChannel )
111 {
112 m_pChannel = pChannel;
113
114 m_iDirtySetup = 0;
115 m_iDirtyCount = 0;
116
117 if (m_pChannel == NULL)
118 return;
119
120 // It can be a brand new channel, remember?
121 bool bNew = (m_pChannel->channelID() < 0);
122 setCaption(QSAMPLER_TITLE ": " + m_pChannel->channelName());
123
124 // Check if we're up and connected.
125 MainForm *pMainForm = MainForm::getInstance();
126 if (pMainForm == NULL)
127 return;
128 if (pMainForm->client() == NULL)
129 return;
130
131 qsamplerOptions *pOptions = pMainForm->options();
132 if (pOptions == NULL)
133 return;
134
135 // Avoid nested changes.
136 m_iDirtySetup++;
137
138 // Load combo box history...
139 pOptions->loadComboBoxHistory(ui.InstrumentFileComboBox);
140
141 // Notify.that we've just changed one audio route.
142 QObject::connect(ui.AudioRoutingTable, SIGNAL(valueChanged(int,int)),
143 this, SLOT(changeAudioRouting(int,int)));
144
145 // Populate Engines list.
146 const char **ppszEngines = ::lscp_list_available_engines(pMainForm->client());
147 if (ppszEngines) {
148 ui.EngineNameComboBox->clear();
149 for (int iEngine = 0; ppszEngines[iEngine]; iEngine++)
150 ui.EngineNameComboBox->insertItem(ppszEngines[iEngine]);
151 }
152 else m_pChannel->appendMessagesClient("lscp_list_available_engines");
153
154 // Populate Audio output type list.
155 ui.AudioDriverComboBox->clear();
156 ui.AudioDriverComboBox->insertStringList(
157 qsamplerDevice::getDrivers(pMainForm->client(), qsamplerDevice::Audio));
158
159 // Populate MIDI input type list.
160 ui.MidiDriverComboBox->clear();
161 ui.MidiDriverComboBox->insertStringList(
162 qsamplerDevice::getDrivers(pMainForm->client(), qsamplerDevice::Midi));
163
164 // Populate Maps list.
165 ui.MidiMapComboBox->clear();
166 ui.MidiMapComboBox->insertStringList(qsamplerInstrument::getMapNames());
167
168 // Read proper channel information,
169 // and populate the channel form fields.
170
171 // Engine name...
172 QString sEngineName = pChannel->engineName();
173 if (sEngineName.isEmpty() || bNew)
174 sEngineName = pOptions->sEngineName;
175 if (sEngineName.isEmpty())
176 sEngineName = qsamplerChannel::noEngineName();
177 if (ui.EngineNameComboBox->findText(sEngineName,
178 Qt::MatchExactly | Qt::MatchCaseSensitive) == 0) {
179 ui.EngineNameComboBox->insertItem(sEngineName);
180 }
181 ui.EngineNameComboBox->setCurrentText(sEngineName);
182 // Instrument filename and index...
183 QString sInstrumentFile = pChannel->instrumentFile();
184 if (sInstrumentFile.isEmpty())
185 sInstrumentFile = qsamplerChannel::noInstrumentName();
186 ui.InstrumentFileComboBox->setCurrentText(sInstrumentFile);
187 ui.InstrumentNrComboBox->clear();
188 ui.InstrumentNrComboBox->insertStringList(
189 qsamplerChannel::getInstrumentList(sInstrumentFile,
190 pOptions->bInstrumentNames));
191 ui.InstrumentNrComboBox->setCurrentItem(pChannel->instrumentNr());
192
193 // MIDI input device...
194 qsamplerDevice midiDevice(qsamplerDevice::Midi, m_pChannel->midiDevice());
195 // MIDI input driver...
196 QString sMidiDriver = midiDevice.driverName();
197 if (sMidiDriver.isEmpty() || bNew)
198 sMidiDriver = pOptions->sMidiDriver.upper();
199 if (!sMidiDriver.isEmpty()) {
200 if (ui.MidiDriverComboBox->findText(sMidiDriver,
201 Qt::MatchExactly | Qt::MatchCaseSensitive) == 0) {
202 ui.MidiDriverComboBox->insertItem(sMidiDriver);
203 }
204 ui.MidiDriverComboBox->setCurrentText(sMidiDriver);
205 }
206 selectMidiDriverItem(sMidiDriver);
207 if (!bNew)
208 ui.MidiDeviceComboBox->setCurrentText(midiDevice.deviceName());
209 selectMidiDeviceItem(ui.MidiDeviceComboBox->currentItem());
210 // MIDI input port...
211 ui.MidiPortSpinBox->setValue(pChannel->midiPort());
212 // MIDI input channel...
213 int iMidiChannel = pChannel->midiChannel();
214 // When new, try to suggest a sensible MIDI channel...
215 if (iMidiChannel < 0)
216 iMidiChannel = (::lscp_get_channels(pMainForm->client()) % 16);
217 ui.MidiChannelComboBox->setCurrentItem(iMidiChannel);
218 // MIDI instrument map...
219 int iMidiMap = (bNew ? pOptions->iMidiMap : pChannel->midiMap());
220 // When new, try to suggest a sensible MIDI map...
221 if (iMidiMap < 0)
222 iMidiMap = 0;
223 const QString& sMapName = qsamplerInstrument::getMapName(iMidiMap);
224 if (!sMapName.isEmpty())
225 ui.MidiMapComboBox->setCurrentText(sMapName);
226 // It might be no maps around...
227 bool bMidiMapEnabled = (ui.MidiMapComboBox->count() > 0);
228 ui.MidiMapTextLabel->setEnabled(bMidiMapEnabled);
229 ui.MidiMapComboBox->setEnabled(bMidiMapEnabled);
230
231 // Audio output device...
232 qsamplerDevice audioDevice(qsamplerDevice::Audio, m_pChannel->audioDevice());
233 // Audio output driver...
234 QString sAudioDriver = audioDevice.driverName();
235 if (sAudioDriver.isEmpty() || bNew)
236 sAudioDriver = pOptions->sAudioDriver.upper();
237 if (!sAudioDriver.isEmpty()) {
238 if (ui.AudioDriverComboBox->findText(sAudioDriver,
239 Qt::MatchExactly | Qt::MatchCaseSensitive) == 0) {
240 ui.AudioDriverComboBox->insertItem(sAudioDriver);
241 }
242 ui.AudioDriverComboBox->setCurrentText(sAudioDriver);
243 }
244 selectAudioDriverItem(sAudioDriver);
245 if (!bNew)
246 ui.AudioDeviceComboBox->setCurrentText(audioDevice.deviceName());
247 selectAudioDeviceItem(ui.AudioDeviceComboBox->currentItem());
248
249 // As convenient, make it ready on stabilizeForm() for
250 // prompt acceptance, if we got the minimum required...
251 /* if (sEngineName != qsamplerChannel::noEngineName() &&
252 sInstrumentFile != qsamplerChannel::noInstrumentName())
253 m_iDirtyCount++; */
254 // Done.
255 m_iDirtySetup--;
256 stabilizeForm();
257 }
258
259
260 // Accept settings (OK button slot).
261 void ChannelForm::accept (void)
262 {
263 if (m_pChannel == NULL)
264 return;
265
266 MainForm *pMainForm = MainForm::getInstance();
267 if (pMainForm == NULL)
268 return;
269 if (pMainForm->client() == NULL)
270 return;
271
272 qsamplerOptions *pOptions = pMainForm->options();
273 if (pOptions == NULL)
274 return;
275
276 // Flush any pending editing...
277 //ui.AudioRoutingTable->flush();
278
279 // We'll go for it!
280 if (m_iDirtyCount > 0) {
281 int iErrors = 0;
282 // Are we a new channel?
283 if (!m_pChannel->addChannel())
284 iErrors++;
285 // Accept Audio driver or device selection...
286 if (m_audioDevices.isEmpty()) {
287 if (!m_pChannel->setAudioDriver(ui.AudioDriverComboBox->currentText()))
288 iErrors++;
289 } else {
290 qsamplerDevice *pDevice = m_audioDevices.at(ui.AudioDeviceComboBox->currentItem());
291 if (pDevice == NULL)
292 iErrors++;
293 else if (!m_pChannel->setAudioDevice(pDevice->deviceID()))
294 iErrors++;
295 else if (!m_audioRouting.isEmpty()) {
296 // Set the audio route changes...
297 qsamplerChannelRoutingMap::ConstIterator iter;
298 for (iter = m_audioRouting.begin();
299 iter != m_audioRouting.end(); ++iter) {
300 if (!m_pChannel->setAudioChannel(iter.key(), iter.data()))
301 iErrors++;
302 }
303 }
304 }
305 // Accept MIDI driver or device selection...
306 if (m_midiDevices.isEmpty()) {
307 if (!m_pChannel->setMidiDriver(ui.MidiDriverComboBox->currentText()))
308 iErrors++;
309 } else {
310 qsamplerDevice *pDevice = m_midiDevices.at(ui.MidiDeviceComboBox->currentItem());
311 if (pDevice == NULL)
312 iErrors++;
313 else if (!m_pChannel->setMidiDevice(pDevice->deviceID()))
314 iErrors++;
315 }
316 // MIDI input port number...
317 if (!m_pChannel->setMidiPort(ui.MidiPortSpinBox->value()))
318 iErrors++;
319 // MIDI input channel...
320 if (!m_pChannel->setMidiChannel(ui.MidiChannelComboBox->currentItem()))
321 iErrors++;
322 // Engine name...
323 if (!m_pChannel->loadEngine(ui.EngineNameComboBox->currentText()))
324 iErrors++;
325 // Instrument file and index...
326 const QString& sPath = ui.InstrumentFileComboBox->currentText();
327 if (!sPath.isEmpty() && QFileInfo(sPath).exists()) {
328 if (!m_pChannel->loadInstrument(sPath, ui.InstrumentNrComboBox->currentItem()))
329 iErrors++;
330 }
331 // MIDI intrument map...
332 if (!m_pChannel->setMidiMap(ui.MidiMapComboBox->currentItem()))
333 iErrors++;
334 // Show error messages?
335 if (iErrors > 0)
336 m_pChannel->appendMessagesError(tr("Some channel settings could not be set.\n\nSorry."));
337 }
338
339 // Save default engine name, instrument directory and history...
340 pOptions->sInstrumentDir = QFileInfo(ui.InstrumentFileComboBox->currentText()).dirPath(true);
341 pOptions->sEngineName = ui.EngineNameComboBox->currentText();
342 pOptions->sAudioDriver = ui.AudioDriverComboBox->currentText();
343 pOptions->sMidiDriver = ui.MidiDriverComboBox->currentText();
344 pOptions->iMidiMap = ui.MidiMapComboBox->currentItem();
345 pOptions->saveComboBoxHistory(ui.InstrumentFileComboBox);
346
347 // Just go with dialog acceptance.
348 QDialog::accept();
349 }
350
351
352 // Reject settings (Cancel button slot).
353 void ChannelForm::reject (void)
354 {
355 bool bReject = true;
356
357 // Check if there's any pending changes...
358 if (m_iDirtyCount > 0 && ui.OkPushButton->isEnabled()) {
359 switch (QMessageBox::warning(this,
360 QSAMPLER_TITLE ": " + tr("Warning"),
361 tr("Some channel settings have been changed.\n\n"
362 "Do you want to apply the changes?"),
363 tr("Apply"), tr("Discard"), tr("Cancel"))) {
364 case 0: // Apply...
365 accept();
366 return;
367 case 1: // Discard
368 break;
369 default: // Cancel.
370 bReject = false;
371 break;
372 }
373 }
374
375 if (bReject)
376 QDialog::reject();
377 }
378
379
380 // Browse and open an instrument file.
381 void ChannelForm::openInstrumentFile (void)
382 {
383 MainForm *pMainForm = MainForm::getInstance();
384 if (pMainForm == NULL)
385 return;
386 if (pMainForm->client() == NULL)
387 return;
388
389 qsamplerOptions *pOptions = pMainForm->options();
390 if (pOptions == NULL)
391 return;
392
393 // FIXME: the instrument file filters should be restricted,
394 // depending on the current engine.
395 QString sInstrumentFile = QFileDialog::getOpenFileName(
396 pOptions->sInstrumentDir, // Start here.
397 tr("Instrument files") + " (*.gig *.dls)", // Filter (GIG and DLS files)
398 this, 0, // Parent and name (none)
399 QSAMPLER_TITLE ": " + tr("Instrument files") // Caption.
400 );
401
402 if (sInstrumentFile.isEmpty())
403 return;
404
405 ui.InstrumentFileComboBox->setCurrentText(sInstrumentFile);
406 updateInstrumentName();
407 }
408
409
410 // Refresh the actual instrument name.
411 void ChannelForm::updateInstrumentName (void)
412 {
413 MainForm *pMainForm = MainForm::getInstance();
414 if (pMainForm == NULL)
415 return;
416 if (pMainForm->client() == NULL)
417 return;
418
419 qsamplerOptions *pOptions = pMainForm->options();
420 if (pOptions == NULL)
421 return;
422
423 // Finally this better idea would be to use libgig
424 // to retrieve the REAL instrument names.
425 ui.InstrumentNrComboBox->clear();
426 ui.InstrumentNrComboBox->insertStringList(
427 qsamplerChannel::getInstrumentList(
428 ui.InstrumentFileComboBox->currentText(),
429 pOptions->bInstrumentNames)
430 );
431
432 optionsChanged();
433 }
434
435
436 // Show device options dialog.
437 void ChannelForm::setupDevice ( qsamplerDevice *pDevice,
438 qsamplerDevice::qsamplerDeviceType deviceTypeMode,
439 const QString& sDriverName )
440 {
441 MainForm *pMainForm = MainForm::getInstance();
442 if (pMainForm == NULL)
443 return;
444 if (pMainForm->client() == NULL)
445 return;
446
447 // Create the device form if not already...
448 if (m_pDeviceForm == NULL) {
449 m_pDeviceForm = new DeviceForm(this, Qt::Dialog);
450 m_pDeviceForm->setAttribute(Qt::WA_ShowModal);
451 QObject::connect(m_pDeviceForm, SIGNAL(devicesChanged()),
452 this, SLOT(updateDevices()));
453 }
454
455 // Refresh the device form with selected data.
456 if (m_pDeviceForm) {
457 m_pDeviceForm->setDeviceTypeMode(deviceTypeMode);
458 m_pDeviceForm->refreshDevices();
459 m_pDeviceForm->setDevice(pDevice);
460 m_pDeviceForm->setDriverName(sDriverName);
461 m_pDeviceForm->show();
462 }
463 }
464
465
466 // Refresh MIDI driver item devices.
467 void ChannelForm::selectMidiDriverItem ( const QString& sMidiDriver )
468 {
469 MainForm *pMainForm = MainForm::getInstance();
470 if (pMainForm == NULL)
471 return;
472 if (pMainForm->client() == NULL)
473 return;
474
475 const QString sDriverName = sMidiDriver.upper();
476
477 // Save current device id.
478 int iDeviceID = 0;
479 qsamplerDevice *pDevice = m_midiDevices.at(ui.MidiDeviceComboBox->currentItem());
480 if (pDevice)
481 iDeviceID = pDevice->deviceID();
482
483 // Clean maplist.
484 ui.MidiDeviceComboBox->clear();
485 m_midiDevices.clear();
486
487 // Populate with the current ones...
488 const QPixmap midiPixmap(":/qsampler/pixmaps/midi2.png");
489 int *piDeviceIDs = qsamplerDevice::getDevices(pMainForm->client(),
490 qsamplerDevice::Midi);
491 for (int i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; i++) {
492 pDevice = new qsamplerDevice(qsamplerDevice::Midi, piDeviceIDs[i]);
493 if (pDevice->driverName().upper() == sDriverName) {
494 ui.MidiDeviceComboBox->insertItem(midiPixmap, pDevice->deviceName());
495 m_midiDevices.append(pDevice);
496 } else {
497 delete pDevice;
498 }
499 }
500
501 // Do proper enabling...
502 bool bEnabled = !m_midiDevices.isEmpty();
503 if (bEnabled) {
504 // Select the previous current device...
505 int iMidiItem = 0;
506 for (pDevice = m_midiDevices.first();
507 pDevice;
508 pDevice = m_midiDevices.next()) {
509 if (pDevice->deviceID() == iDeviceID) {
510 ui.MidiDeviceComboBox->setCurrentItem(iMidiItem);
511 selectMidiDeviceItem(iMidiItem);
512 break;
513 }
514 iMidiItem++;
515 }
516 } else {
517 ui.MidiDeviceComboBox->insertItem(
518 tr("(New MIDI %1 device)").arg(sMidiDriver));
519 }
520 ui.MidiDeviceTextLabel->setEnabled(bEnabled);
521 ui.MidiDeviceComboBox->setEnabled(bEnabled);
522 }
523
524
525 // Refresh MIDI device options slot.
526 void ChannelForm::selectMidiDriver ( const QString& sMidiDriver )
527 {
528 if (m_iDirtySetup > 0)
529 return;
530
531 selectMidiDriverItem(sMidiDriver);
532 optionsChanged();
533 }
534
535
536 // Select MIDI device item.
537 void ChannelForm::selectMidiDeviceItem ( int iMidiItem )
538 {
539 qsamplerDevice *pDevice = m_midiDevices.at(iMidiItem);
540 if (pDevice) {
541 const qsamplerDeviceParamMap& params = pDevice->params();
542 int iPorts = params["PORTS"].value.toInt();
543 ui.MidiPortTextLabel->setEnabled(iPorts > 0);
544 ui.MidiPortSpinBox->setEnabled(iPorts > 0);
545 if (iPorts > 0)
546 ui.MidiPortSpinBox->setMaxValue(iPorts - 1);
547 }
548 }
549
550
551 // Select MIDI device options slot.
552 void ChannelForm::selectMidiDevice ( int iMidiItem )
553 {
554 if (m_iDirtySetup > 0)
555 return;
556
557 selectMidiDeviceItem(iMidiItem);
558 optionsChanged();
559 }
560
561
562 // MIDI device options.
563 void ChannelForm::setupMidiDevice (void)
564 {
565 setupDevice(m_midiDevices.at(ui.MidiDeviceComboBox->currentItem()),
566 qsamplerDevice::Midi, ui.MidiDriverComboBox->currentText());
567 }
568
569
570 // Refresh Audio driver item devices.
571 void ChannelForm::selectAudioDriverItem ( const QString& sAudioDriver )
572 {
573 MainForm *pMainForm = MainForm::getInstance();
574 if (pMainForm == NULL)
575 return;
576 if (pMainForm->client() == NULL)
577 return;
578
579 const QString sDriverName = sAudioDriver.upper();
580
581 // Save current device id.
582 int iDeviceID = 0;
583 qsamplerDevice *pDevice = m_audioDevices.at(ui.AudioDeviceComboBox->currentItem());
584 if (pDevice)
585 iDeviceID = pDevice->deviceID();
586
587 // Clean maplist.
588 ui.AudioDeviceComboBox->clear();
589 m_audioDevices.clear();
590
591 // Populate with the current ones...
592 const QPixmap audioPixmap(":/qsampler/pixmaps/audio2.png");
593 int *piDeviceIDs = qsamplerDevice::getDevices(pMainForm->client(),
594 qsamplerDevice::Audio);
595 for (int i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; i++) {
596 pDevice = new qsamplerDevice(qsamplerDevice::Audio, piDeviceIDs[i]);
597 if (pDevice->driverName().upper() == sDriverName) {
598 ui.AudioDeviceComboBox->insertItem(audioPixmap, pDevice->deviceName());
599 m_audioDevices.append(pDevice);
600 } else {
601 delete pDevice;
602 }
603 }
604
605 // Do proper enabling...
606 bool bEnabled = !m_audioDevices.isEmpty();
607 if (bEnabled) {
608 // Select the previous current device...
609 int iAudioItem = 0;
610 for (pDevice = m_audioDevices.first();
611 pDevice;
612 pDevice = m_audioDevices.next()) {
613 if (pDevice->deviceID() == iDeviceID) {
614 ui.AudioDeviceComboBox->setCurrentItem(iAudioItem);
615 selectAudioDeviceItem(iAudioItem);
616 break;
617 }
618 iAudioItem++;
619 }
620 } else {
621 ui.AudioDeviceComboBox->insertItem(
622 tr("(New Audio %1 device)").arg(sAudioDriver));
623 //ui.AudioRoutingTable->setNumRows(0);
624 }
625 ui.AudioDeviceTextLabel->setEnabled(bEnabled);
626 ui.AudioDeviceComboBox->setEnabled(bEnabled);
627 ui.AudioRoutingTable->setEnabled(bEnabled);
628 }
629
630
631 // Refresh Audio device options slot.
632 void ChannelForm::selectAudioDriver ( const QString& sAudioDriver )
633 {
634 if (m_iDirtySetup > 0)
635 return;
636
637 selectAudioDriverItem(sAudioDriver);
638 optionsChanged();
639 }
640
641
642 // Select Audio device item.
643 void ChannelForm::selectAudioDeviceItem ( int iAudioItem )
644 {
645 qsamplerDevice *pDevice = m_audioDevices.at(iAudioItem);
646 if (pDevice) {
647 // Refresh the audio routing table.
648 routingModel.refresh(pDevice, m_pChannel->audioRouting());
649 // Reset routing change map.
650 m_audioRouting.clear();
651 }
652 }
653
654
655 // Select Audio device options slot.
656 void ChannelForm::selectAudioDevice ( int iAudioItem )
657 {
658 if (m_iDirtySetup > 0)
659 return;
660
661 selectAudioDeviceItem(iAudioItem);
662 optionsChanged();
663 }
664
665
666 // Audio device options.
667 void ChannelForm::setupAudioDevice (void)
668 {
669 setupDevice(m_audioDevices.at(ui.AudioDeviceComboBox->currentItem()),
670 qsamplerDevice::Audio, ui.AudioDriverComboBox->currentText());
671 }
672
673
674 // Audio routing change slot.
675 void ChannelForm::changeAudioRouting ( int iRow, int iCol )
676 {
677 #if 0
678 if (m_iDirtySetup > 0)
679 return;
680 if (iRow < 0 || iCol < 0)
681 return;
682
683 // Verify that this is a QComboTableItem (magic rtti == 1)
684 QTableItem *pItem = ui.AudioRoutingTable->item(iRow, iCol);
685 if (pItem == NULL)
686 return;
687 qsamplerChannelRoutingComboBox *pComboItem =
688 static_cast<qsamplerChannelRoutingComboBox*> (pItem);
689 // FIXME: Its not garanteed that we must have
690 // iAudioOut == iRow on all times forth!
691 m_audioRouting[iRow] = pComboItem->currentItem();
692
693 // And let's get dirty...
694 optionsChanged();
695 #endif
696 }
697
698
699 // UPdate all device lists slot.
700 void ChannelForm::updateDevices (void)
701 {
702 if (m_iDirtySetup > 0)
703 return;
704
705 selectMidiDriverItem(ui.MidiDriverComboBox->currentText());
706 selectAudioDriverItem(ui.AudioDriverComboBox->currentText());
707 optionsChanged();
708 }
709
710
711 // Dirty up settings.
712 void ChannelForm::optionsChanged (void)
713 {
714 if (m_iDirtySetup > 0)
715 return;
716
717 m_iDirtyCount++;
718 stabilizeForm();
719 }
720
721
722 // Stabilize current form state.
723 void ChannelForm::stabilizeForm (void)
724 {
725 bool bValid = true;
726 #if 0
727 const QString& sPath = InstrumentFileComboBox->currentText();
728 bValid = bValid && !sPath.isEmpty() && QFileInfo(sPath).exists();
729 #endif
730 ui.OkPushButton->setEnabled(m_iDirtyCount > 0 && bValid);
731 }
732
733
734 } // namespace QSampler
735
736
737 // end of qsamplerChannelForm.cpp

  ViewVC Help
Powered by ViewVC