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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3555 - (hide annotations) (download)
Tue Aug 13 10:19:32 2019 UTC (4 years, 7 months ago) by capela
File size: 20516 byte(s)
- In late compliance to C++11, all NULL constants replaced for nullptr.
1 capela 1464 // qsamplerDeviceForm.cpp
2     //
3     /****************************************************************************
4 capela 3518 Copyright (C) 2004-2019, rncbc aka Rui Nuno Capela. All rights reserved.
5 schoenebeck 1667 Copyright (C) 2007, 2008 Christian Schoenebeck
6 capela 1464
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 "qsamplerDeviceForm.h"
24    
25     #include "qsamplerAbout.h"
26 capela 1473 #include "qsamplerMainForm.h"
27 schoenebeck 1461
28 capela 1499 #include <QHeaderView>
29     #include <QMessageBox>
30    
31 capela 2722 #include <QCheckBox>
32 capela 1499
33 capela 2722
34 schoenebeck 1461 namespace QSampler {
35    
36 capela 1558 //-------------------------------------------------------------------------
37     // QSampler::DeviceForm -- Device form implementation.
38     //
39    
40 capela 1509 DeviceForm::DeviceForm ( QWidget *pParent, Qt::WindowFlags wflags )
41     : QDialog(pParent, wflags)
42     {
43 capela 1510 m_ui.setupUi(this);
44 schoenebeck 1461
45     // Initialize locals.
46     m_iDirtySetup = 0;
47     m_iDirtyCount = 0;
48     m_bNewDevice = false;
49 capela 1558 m_deviceType = Device::None;
50 capela 3555 m_pAudioItems = nullptr;
51     m_pMidiItems = nullptr;
52 schoenebeck 1461 // No exclusive mode as default.
53 capela 1558 m_deviceTypeMode = Device::None;
54 schoenebeck 1461
55 capela 1509 m_ui.DeviceListView->header()->hide();
56 schoenebeck 1477
57 capela 1519 int iRowHeight = m_ui.DeviceParamTable->fontMetrics().height() + 4;
58     m_ui.DeviceParamTable->verticalHeader()->setDefaultSectionSize(iRowHeight);
59     m_ui.DevicePortParamTable->verticalHeader()->setDefaultSectionSize(iRowHeight);
60     m_ui.DeviceParamTable->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
61     m_ui.DevicePortParamTable->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
62    
63 capela 1509 m_ui.DeviceParamTable->setModel(&m_deviceParamModel);
64     m_ui.DeviceParamTable->setItemDelegate(&m_deviceParamDelegate);
65 capela 3520 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
66 capela 2388 m_ui.DeviceParamTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::Stretch);
67     #else
68 capela 1509 m_ui.DeviceParamTable->horizontalHeader()->setResizeMode(2, QHeaderView::Stretch);
69 capela 2387 #endif
70 capela 1509 m_ui.DeviceParamTable->verticalHeader()->hide();
71 schoenebeck 1461
72 capela 1509 m_ui.DevicePortParamTable->setModel(&m_devicePortParamModel);
73     m_ui.DevicePortParamTable->setItemDelegate(&m_devicePortParamDelegate);
74 capela 3520 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
75 capela 2388 m_ui.DevicePortParamTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::Stretch);
76     #else
77 capela 1509 m_ui.DevicePortParamTable->horizontalHeader()->setResizeMode(2, QHeaderView::Stretch);
78 capela 2387 #endif
79 capela 1509 m_ui.DevicePortParamTable->verticalHeader()->hide();
80 schoenebeck 1461
81     // Initial contents.
82     refreshDevices();
83     // Try to restore normal window positioning.
84     adjustSize();
85 capela 1466
86 capela 1509 QObject::connect(m_ui.DeviceListView,
87 schoenebeck 1486 SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
88 capela 1466 SLOT(selectDevice()));
89 capela 1509 QObject::connect(m_ui.DeviceListView,
90 schoenebeck 1470 SIGNAL(customContextMenuRequested(const QPoint&)),
91     SLOT(deviceListViewContextMenu(const QPoint&)));
92 capela 1509 QObject::connect(m_ui.RefreshDevicesPushButton,
93 capela 1466 SIGNAL(clicked()),
94     SLOT(refreshDevices()));
95 capela 1509 QObject::connect(m_ui.DriverNameComboBox,
96 schoenebeck 1470 SIGNAL(activated(const QString&)),
97     SLOT(selectDriver(const QString&)));
98 capela 1509 QObject::connect(m_ui.DevicePortComboBox,
99 capela 1466 SIGNAL(activated(int)),
100     SLOT(selectDevicePort(int)));
101 capela 1509 QObject::connect(m_ui.CreateDevicePushButton,
102 capela 1466 SIGNAL(clicked()),
103     SLOT(createDevice()));
104 capela 1509 QObject::connect(m_ui.DeleteDevicePushButton,
105 capela 1466 SIGNAL(clicked()),
106     SLOT(deleteDevice()));
107 capela 1509 QObject::connect(m_ui.ClosePushButton,
108 capela 1466 SIGNAL(clicked()),
109     SLOT(close()));
110 capela 1509 QObject::connect(&m_deviceParamModel,
111 schoenebeck 1486 SIGNAL(modelReset()),
112     SLOT(updateCellRenderers()));
113 capela 1509 QObject::connect(&m_deviceParamModel,
114 schoenebeck 1486 SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
115     SLOT(updateCellRenderers(const QModelIndex&, const QModelIndex&)));
116 capela 1509 QObject::connect(&m_devicePortParamModel,
117 schoenebeck 1486 SIGNAL(modelReset()),
118     SLOT(updatePortCellRenderers()));
119 capela 1509 QObject::connect(&m_devicePortParamModel,
120 schoenebeck 1486 SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
121     SLOT(updatePortCellRenderers(const QModelIndex&, const QModelIndex&)));
122 schoenebeck 1461 }
123    
124 capela 1520
125     DeviceForm::~DeviceForm (void)
126     {
127 schoenebeck 1461 }
128    
129    
130     // Notify our parent that we're emerging.
131     void DeviceForm::showEvent ( QShowEvent *pShowEvent )
132     {
133     MainForm* pMainForm = MainForm::getInstance();
134     if (pMainForm)
135     pMainForm->stabilizeForm();
136    
137 capela 1520 QWidget::showEvent(pShowEvent);
138 schoenebeck 1461
139 capela 1520 refreshDevices();
140 schoenebeck 1461 }
141    
142    
143     // Notify our parent that we're closing.
144     void DeviceForm::hideEvent ( QHideEvent *pHideEvent )
145     {
146     QWidget::hideEvent(pHideEvent);
147    
148     MainForm *pMainForm = MainForm::getInstance();
149     if (pMainForm)
150     pMainForm->stabilizeForm();
151    
152     // Signal special whether we changed the device set.
153     if (m_iDirtyCount > 0) {
154     m_iDirtyCount = 0;
155     emit devicesChanged();
156     }
157     }
158    
159    
160     // Set device type spacial exclusive mode.
161     void DeviceForm::setDeviceTypeMode (
162 capela 1558 Device::DeviceType deviceTypeMode )
163 schoenebeck 1461 {
164     // If it has not changed, do nothing.
165     if (m_deviceTypeMode == deviceTypeMode)
166     return;
167    
168     m_deviceTypeMode = deviceTypeMode;
169    
170     // OK. Do a whole refresh around.
171     refreshDevices();
172     }
173    
174    
175     // Device driver name setup formal initializer.
176     void DeviceForm::setDriverName ( const QString& sDriverName )
177     {
178 capela 1509 if (m_ui.DriverNameComboBox->findText(sDriverName) < 0)
179     m_ui.DriverNameComboBox->insertItem(0, sDriverName);
180     m_ui.DriverNameComboBox->setItemText(
181     m_ui.DriverNameComboBox->currentIndex(),
182 capela 1499 sDriverName);
183 schoenebeck 1461 }
184    
185    
186     // Set current selected device by type and id.
187 capela 1558 void DeviceForm::setDevice ( Device *pDevice )
188 schoenebeck 1461 {
189     // In case no device is given...
190 capela 1558 Device::DeviceType deviceType = m_deviceTypeMode;
191 schoenebeck 1461 if (pDevice)
192     deviceType = pDevice->deviceType();
193    
194     // Get the device view root item...
195 capela 3555 DeviceItem *pRootItem = nullptr;
196 schoenebeck 1461 switch (deviceType) {
197 capela 1558 case Device::Audio:
198 schoenebeck 1461 pRootItem = m_pAudioItems;
199     break;
200 capela 1558 case Device::Midi:
201 schoenebeck 1461 pRootItem = m_pMidiItems;
202     break;
203 capela 1558 case Device::None:
204 schoenebeck 1461 break;
205     }
206    
207     // Is the root present?
208 capela 3555 if (pRootItem == nullptr)
209 schoenebeck 1461 return;
210    
211     // So there's no device huh?
212 capela 3555 if (pDevice == nullptr) {
213 capela 1509 m_ui.DeviceListView->setCurrentItem(pRootItem);
214 schoenebeck 1461 return;
215     }
216    
217     // For each child, test for identity...
218     for (int i = 0; i < pRootItem->childCount(); i++) {
219 capela 1558 DeviceItem* pDeviceItem =
220     (DeviceItem*) pRootItem->child(i);
221 schoenebeck 1461
222     // If identities match, select as current device item.
223     if (pDeviceItem->device().deviceID() == pDevice->deviceID()) {
224     pDeviceItem->setSelected(true);
225     break;
226     }
227     }
228     }
229    
230    
231    
232     // Create a new device from current table view.
233     void DeviceForm::createDevice (void)
234     {
235     MainForm *pMainForm = MainForm::getInstance();
236 capela 3555 if (pMainForm == nullptr)
237 schoenebeck 1461 return;
238    
239 capela 1509 QTreeWidgetItem *pItem = m_ui.DeviceListView->currentItem();
240 capela 3555 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
241 schoenebeck 1461 return;
242    
243     // About a brand new device instance...
244 capela 1558 Device device(((DeviceItem *) pItem)->device());
245 schoenebeck 1461 if (device.createDevice()) {
246     // Now it depends on the device type...
247 capela 3555 DeviceItem *pRootItem = nullptr;
248 schoenebeck 1461 switch (device.deviceType()) {
249 capela 1558 case Device::Audio:
250 schoenebeck 1461 pRootItem = m_pAudioItems;
251     break;
252 capela 1558 case Device::Midi:
253 schoenebeck 1461 pRootItem = m_pMidiItems;
254     break;
255 capela 1558 case Device::None:
256 schoenebeck 1461 break;
257     }
258     // Append the new device item.
259 capela 1558 DeviceItem *pDeviceItem = new DeviceItem(pRootItem,
260 schoenebeck 1461 device.deviceType(), device.deviceID());
261     // Just make it the new selection...
262     pDeviceItem->setSelected(true);
263     // Main session should be marked dirty.
264     pMainForm->sessionDirty();
265     m_iDirtyCount++;
266     }
267     }
268    
269    
270     // Delete current device in table view.
271     void DeviceForm::deleteDevice (void)
272     {
273     MainForm *pMainForm = MainForm::getInstance();
274 capela 3555 if (pMainForm == nullptr)
275 schoenebeck 1461 return;
276    
277 capela 1509 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
278 capela 3555 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
279 schoenebeck 1461 return;
280    
281 capela 1558 Device& device = ((DeviceItem *) pItem)->device();
282 schoenebeck 1461
283     // Prompt user if this is for real...
284 capela 1558 Options *pOptions = pMainForm->options();
285 schoenebeck 1461 if (pOptions && pOptions->bConfirmRemove) {
286 capela 2722 const QString& sTitle = QSAMPLER_TITLE ": " + tr("Warning");
287     const QString& sText = tr(
288     "About to delete device:\n\n"
289 schoenebeck 1461 "%1\n\n"
290     "Are you sure?")
291 capela 2722 .arg(device.deviceName());
292     #if 0
293     if (QMessageBox::warning(this, sTitle, sText,
294     QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Cancel)
295 schoenebeck 1461 return;
296 capela 2722 #else
297     QMessageBox mbox(this);
298     mbox.setIcon(QMessageBox::Warning);
299     mbox.setWindowTitle(sTitle);
300     mbox.setText(sText);
301     mbox.setStandardButtons(QMessageBox::Ok | QMessageBox::Cancel);
302     QCheckBox cbox(tr("Don't ask this again"));
303     cbox.setChecked(false);
304     cbox.blockSignals(true);
305     mbox.addButton(&cbox, QMessageBox::ActionRole);
306     if (mbox.exec() == QMessageBox::Cancel)
307     return;
308     if (cbox.isChecked())
309     pOptions->bConfirmRemove = false;
310     #endif
311 schoenebeck 1461 }
312    
313     // Go and destroy...
314     if (device.deleteDevice()) {
315     // Remove it from the device view...
316     delete pItem;
317     // Main session should be marked dirty.
318     pMainForm->sessionDirty();
319     m_iDirtyCount++;
320     }
321     }
322    
323    
324     // Refresh all device list and views.
325     void DeviceForm::refreshDevices (void)
326     {
327     MainForm *pMainForm = MainForm::getInstance();
328 capela 3555 if (pMainForm == nullptr)
329 schoenebeck 1461 return;
330    
331     // Avoid nested changes.
332     m_iDirtySetup++;
333    
334     //
335     // (Re)Load complete device configuration data ...
336     //
337 capela 3555 m_pAudioItems = nullptr;
338     m_pMidiItems = nullptr;
339 capela 1509 m_ui.DeviceListView->clear();
340 schoenebeck 1461 if (pMainForm->client()) {
341     int *piDeviceIDs;
342     // Grab and pop Audio devices...
343 capela 1558 if (m_deviceTypeMode == Device::None ||
344     m_deviceTypeMode == Device::Audio) {
345     m_pAudioItems = new DeviceItem(m_ui.DeviceListView,
346     Device::Audio);
347 schoenebeck 1461 }
348     if (m_pAudioItems) {
349 capela 1558 piDeviceIDs = Device::getDevices(pMainForm->client(),
350     Device::Audio);
351 schoenebeck 1461 for (int i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; i++) {
352 capela 1558 new DeviceItem(m_pAudioItems,
353     Device::Audio, piDeviceIDs[i]);
354 schoenebeck 1461 }
355     m_pAudioItems->setExpanded(true);
356     }
357     // Grab and pop MIDI devices...
358 capela 1558 if (m_deviceTypeMode == Device::None ||
359     m_deviceTypeMode == Device::Midi) {
360     m_pMidiItems = new DeviceItem(m_ui.DeviceListView,
361     Device::Midi);
362 schoenebeck 1461 }
363     if (m_pMidiItems) {
364 capela 1558 piDeviceIDs = Device::getDevices(pMainForm->client(),
365     Device::Midi);
366 schoenebeck 1461 for (int i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; i++) {
367 capela 1558 new DeviceItem(m_pMidiItems,
368     Device::Midi, piDeviceIDs[i]);
369 schoenebeck 1461 }
370     m_pMidiItems->setExpanded(true);
371     }
372     }
373    
374     // Done.
375     m_iDirtySetup--;
376    
377     // Show something.
378     selectDevice();
379     }
380    
381    
382     // Driver selection slot.
383     void DeviceForm::selectDriver ( const QString& sDriverName )
384     {
385     if (m_iDirtySetup > 0)
386     return;
387    
388     //
389     // Driver name has changed for a new device...
390     //
391    
392 capela 1509 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
393 capela 3555 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
394 schoenebeck 1461 return;
395    
396 capela 1558 Device& device = ((DeviceItem *) pItem)->device();
397 schoenebeck 1461
398     // Driver change is only valid for scratch devices...
399     if (m_bNewDevice) {
400     m_iDirtySetup++;
401     device.setDriver(sDriverName);
402 capela 1509 m_deviceParamModel.refresh(&device, m_bNewDevice);
403 schoenebeck 1461 m_iDirtySetup--;
404     // Done.
405     stabilizeForm();
406     }
407     }
408    
409    
410     // Device selection slot.
411 schoenebeck 1477 void DeviceForm::selectDevice ()
412 schoenebeck 1461 {
413     MainForm *pMainForm = MainForm::getInstance();
414 capela 3555 if (pMainForm == nullptr)
415 schoenebeck 1461 return;
416    
417     if (m_iDirtySetup > 0)
418     return;
419    
420     //
421     // Device selection has changed...
422     //
423    
424 capela 1509 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
425 capela 3555 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM) {
426 capela 1558 m_deviceType = Device::None;
427 capela 3518 m_ui.DeviceNameTextLabel->setText(QString());
428 capela 1509 m_deviceParamModel.clear();
429     m_ui.DevicePortComboBox->clear();
430     m_devicePortParamModel.clear();
431     m_ui.DevicePortTextLabel->setEnabled(false);
432     m_ui.DevicePortComboBox->setEnabled(false);
433     m_ui.DevicePortParamTable->setEnabled(false);
434 schoenebeck 1461 stabilizeForm();
435     return;
436     }
437    
438 capela 1558 Device& device = ((DeviceItem *) pItem)->device();
439 schoenebeck 1461
440     m_iDirtySetup++;
441     // Flag whether this is a new device.
442     m_bNewDevice = (device.deviceID() < 0);
443    
444     // Fill the device/driver heading...
445 capela 1509 m_ui.DeviceNameTextLabel->setText(device.deviceName());
446 schoenebeck 1461 // The driver combobox is only rebuilt if device type has changed...
447     if (device.deviceType() != m_deviceType) {
448 capela 1509 m_ui.DriverNameComboBox->clear();
449     m_ui.DriverNameComboBox->insertItems(0,
450 capela 1558 Device::getDrivers(pMainForm->client(), device.deviceType()));
451 schoenebeck 1461 m_deviceType = device.deviceType();
452     }
453     // Do we need a driver name?
454     if (m_bNewDevice || device.driverName().isEmpty())
455 capela 1509 device.setDriver(m_ui.DriverNameComboBox->currentText());
456 schoenebeck 1461 setDriverName(device.driverName());
457 capela 1509 m_ui.DriverNameTextLabel->setEnabled(m_bNewDevice);
458     m_ui.DriverNameComboBox->setEnabled(m_bNewDevice);
459 schoenebeck 1461 // Fill the device parameter table...
460 capela 1509 m_deviceParamModel.refresh(&device, m_bNewDevice);
461 schoenebeck 1461 // And now the device port/channel parameter table...
462     switch (device.deviceType()) {
463 capela 1558 case Device::Audio:
464 capela 1509 m_ui.DevicePortTextLabel->setText(tr("Ch&annel:"));
465 schoenebeck 1461 break;
466 capela 1558 case Device::Midi:
467 capela 1509 m_ui.DevicePortTextLabel->setText(tr("P&ort:"));
468 schoenebeck 1461 break;
469 capela 1558 case Device::None:
470 schoenebeck 1461 break;
471     }
472 capela 1509 m_ui.DevicePortComboBox->clear();
473     m_devicePortParamModel.clear();
474 schoenebeck 1461 if (m_bNewDevice) {
475 capela 1509 m_ui.DevicePortTextLabel->setEnabled(false);
476     m_ui.DevicePortComboBox->setEnabled(false);
477     m_ui.DevicePortParamTable->setEnabled(false);
478 schoenebeck 1461 } else {
479     QPixmap pixmap;
480     switch (device.deviceType()) {
481 capela 1558 case Device::Audio:
482 capela 2074 pixmap = QPixmap(":/images/audio2.png");
483 schoenebeck 1461 break;
484 capela 1558 case Device::Midi:
485 capela 2074 pixmap = QPixmap(":/images/midi2.png");
486 schoenebeck 1461 break;
487 capela 1558 case Device::None:
488 schoenebeck 1461 break;
489     }
490 capela 1558 DevicePortList& ports = device.ports();
491     QListIterator<DevicePort *> iter(ports);
492 capela 1499 while (iter.hasNext()) {
493 capela 1558 DevicePort *pPort = iter.next();
494 capela 1509 m_ui.DevicePortComboBox->addItem(pixmap,
495 capela 1499 device.deviceTypeName()
496 schoenebeck 1461 + ' ' + device.driverName()
497     + ' ' + pPort->portName());
498     }
499     bool bEnabled = (ports.count() > 0);
500 capela 1509 m_ui.DevicePortTextLabel->setEnabled(bEnabled);
501     m_ui.DevicePortComboBox->setEnabled(bEnabled);
502     m_ui.DevicePortParamTable->setEnabled(bEnabled);
503 schoenebeck 1461 }
504     // Done.
505     m_iDirtySetup--;
506    
507     // Make the device port/channel selection effective.
508 capela 1509 selectDevicePort(m_ui.DevicePortComboBox->currentIndex());
509 schoenebeck 1461 }
510    
511    
512     // Device port/channel selection slot.
513     void DeviceForm::selectDevicePort ( int iPort )
514     {
515     if (m_iDirtySetup > 0)
516     return;
517    
518     //
519     // Device port/channel selection has changed...
520     //
521    
522 capela 1509 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
523 capela 3555 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
524 schoenebeck 1461 return;
525    
526 capela 1558 Device& device = ((DeviceItem *) pItem)->device();
527 capela 3555 DevicePort *pPort = nullptr;
528 capela 1504 if (iPort >= 0 && iPort < device.ports().count())
529     pPort = device.ports().at(iPort);
530 schoenebeck 1461 if (pPort) {
531     m_iDirtySetup++;
532 capela 1509 m_devicePortParamModel.refresh(pPort, false);
533 schoenebeck 1461 m_iDirtySetup--;
534     }
535     // Done.
536     stabilizeForm();
537     }
538    
539    
540     // Device parameter value change slot.
541     void DeviceForm::changeDeviceParam ( int iRow, int iCol )
542     {
543     if (m_iDirtySetup > 0)
544     return;
545     if (iRow < 0 || iCol < 0)
546     return;
547    
548     //
549     // Device parameter change...
550     //
551    
552 schoenebeck 1486 /* we do that in the model class now ...
553 capela 1509 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
554 capela 3555 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
555 schoenebeck 1461 return;
556    
557 capela 1558 Device& device = ((DeviceItem *) pItem)->device();
558 schoenebeck 1461
559     // Table 1st column has the parameter name;
560 capela 1509 //const QString sParam = m_ui.DeviceParamTable->text(iRow, 0);
561     //const QString sValue = m_ui.DeviceParamTable->text(iRow, iCol);
562     const QString sParam = m_deviceParamModel.data(m_deviceParamModel.index(iRow, 0), Qt::DisplayRole).value<DeviceParameterRow>().name;
563     const QString sValue = m_deviceParamModel.data(m_deviceParamModel.index(iRow, iCol), Qt::DisplayRole).value<DeviceParameterRow>().param.value;
564 schoenebeck 1461 // Set the local device parameter value.
565     if (device.setParam(sParam, sValue)) {
566     selectDevice();
567     } else {
568     stabilizeForm();
569     }
570 schoenebeck 1486 */
571 schoenebeck 1461
572     // Main session should be dirtier...
573     MainForm *pMainForm = MainForm::getInstance();
574     if (pMainForm)
575     pMainForm->sessionDirty();
576     }
577    
578    
579     // Device port/channel parameter value change slot.
580     void DeviceForm::changeDevicePortParam ( int iRow, int iCol )
581     {
582     if (m_iDirtySetup > 0)
583     return;
584     if (iRow < 0 || iCol < 0)
585     return;
586    
587     //
588     // Device port/channel parameter change...
589     //
590    
591 schoenebeck 1486 /* we do that in the model class now ...
592 capela 1509 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
593 capela 3555 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
594 schoenebeck 1461 return;
595    
596 capela 1558 Device& device = ((DeviceItem *) pItem)->device();
597 schoenebeck 1461
598 capela 1509 int iPort = m_ui.DevicePortComboBox->currentIndex();
599 capela 3555 DevicePort *pPort = nullptr;
600 capela 1504 if (iPort >= 0 && iPort < device.ports().count())
601     pPort = device.ports().at(iPort);
602 capela 3555 if (pPort == nullptr)
603 schoenebeck 1461 return;
604    
605     // Table 1st column has the parameter name;
606 capela 1509 //const QString sParam = m_ui.DevicePortParamTable->text(iRow, 0);
607     //const QString sValue = m_ui.DevicePortParamTable->text(iRow, iCol);
608     const QString sParam = m_devicePortParamModel.data(m_devicePortParamModel.index(iRow, 0), Qt::DisplayRole).value<DeviceParameterRow>().name;
609     const QString sValue = m_devicePortParamModel.data(m_devicePortParamModel.index(iRow, iCol), Qt::DisplayRole).value<DeviceParameterRow>().param.value;
610 schoenebeck 1461
611     // Set the local device port/channel parameter value.
612     pPort->setParam(sParam, sValue);
613 schoenebeck 1486 */
614    
615 schoenebeck 1461 // Done.
616     stabilizeForm();
617    
618     // Main session should be dirtier...
619     MainForm* pMainForm = MainForm::getInstance();
620     if (pMainForm)
621     pMainForm->sessionDirty();
622     }
623    
624    
625     // Device list view context menu handler.
626 schoenebeck 1470 void DeviceForm::deviceListViewContextMenu ( const QPoint& pos )
627 schoenebeck 1461 {
628     MainForm *pMainForm = MainForm::getInstance();
629 capela 3555 if (pMainForm == nullptr)
630 schoenebeck 1461 return;
631    
632 capela 1509 QTreeWidgetItem* pItem = m_ui.DeviceListView->itemAt(pos);
633 capela 3555 if (pItem == nullptr)
634 schoenebeck 1470 return;
635    
636 schoenebeck 1461 // Build the device context menu...
637 capela 1499 QMenu menu(this);
638     QAction *pAction;
639 schoenebeck 1461
640 capela 3555 bool bClient = (pMainForm->client() != nullptr);
641     bool bEnabled = (pItem != nullptr);
642 capela 1499 pAction = menu.addAction(
643 capela 2074 QIcon(":/images/deviceCreate.png"),
644 schoenebeck 1461 tr("&Create device"), this, SLOT(createDevice()));
645 capela 1499 pAction->setEnabled(bEnabled || (bClient && m_bNewDevice));
646     pAction = menu.addAction(
647 capela 2074 QIcon(":/images/deviceDelete.png"),
648 schoenebeck 1461 tr("&Delete device"), this, SLOT(deleteDevice()));
649 capela 1499 pAction->setEnabled(bEnabled && !m_bNewDevice);
650     menu.addSeparator();
651     pAction = menu.addAction(
652 capela 2074 QIcon(":/images/formRefresh.png"),
653 schoenebeck 1461 tr("&Refresh"), this, SLOT(refreshDevices()));
654 capela 1499 pAction->setEnabled(bClient);
655 schoenebeck 1461
656 capela 1499 menu.exec(pos);
657 schoenebeck 1461 }
658    
659    
660     // Stabilize current form state.
661     void DeviceForm::stabilizeForm (void)
662     {
663     MainForm* pMainForm = MainForm::getInstance();
664 capela 1509 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
665 capela 3555 bool bClient = (pMainForm && pMainForm->client() != nullptr);
666     bool bEnabled = (pItem != nullptr);
667 capela 1509 m_ui.DeviceNameTextLabel->setEnabled(bEnabled && !m_bNewDevice);
668     m_ui.DriverNameTextLabel->setEnabled(bEnabled && m_bNewDevice);
669     m_ui.DriverNameComboBox->setEnabled(bEnabled && m_bNewDevice);
670     m_ui.DeviceParamTable->setEnabled(bEnabled);
671     m_ui.RefreshDevicesPushButton->setEnabled(bClient);
672     m_ui.CreateDevicePushButton->setEnabled(bEnabled || (bClient && m_bNewDevice));
673     m_ui.DeleteDevicePushButton->setEnabled(bEnabled && !m_bNewDevice);
674 schoenebeck 1461 }
675    
676 capela 1509
677     void DeviceForm::updateCellRenderers (void)
678     {
679     const int rows = m_deviceParamModel.rowCount();
680     const int cols = m_deviceParamModel.columnCount();
681     updateCellRenderers(
682     m_deviceParamModel.index(0, 0),
683     m_deviceParamModel.index(rows - 1, cols - 1));
684 schoenebeck 1486 }
685    
686 capela 1509
687     void DeviceForm::updateCellRenderers (
688     const QModelIndex& topLeft, const QModelIndex& bottomRight )
689     {
690     for (int r = topLeft.row(); r <= bottomRight.row(); r++) {
691     for (int c = topLeft.column(); c <= bottomRight.column(); c++) {
692     const QModelIndex index = m_deviceParamModel.index(r, c);
693     m_ui.DeviceParamTable->openPersistentEditor(index);
694     }
695     }
696 schoenebeck 1486 }
697    
698 capela 1509
699     void DeviceForm::updatePortCellRenderers (void)
700     {
701     const int rows = m_devicePortParamModel.rowCount();
702     const int cols = m_devicePortParamModel.columnCount();
703     updatePortCellRenderers(
704     m_devicePortParamModel.index(0, 0),
705     m_devicePortParamModel.index(rows - 1, cols - 1));
706 schoenebeck 1486 }
707    
708 capela 1509
709     void DeviceForm::updatePortCellRenderers (
710     const QModelIndex& topLeft, const QModelIndex& bottomRight )
711     {
712     for (int r = topLeft.row(); r <= bottomRight.row(); r++) {
713     for (int c = topLeft.column(); c <= bottomRight.column(); c++) {
714     const QModelIndex index = m_devicePortParamModel.index(r, c);
715     m_ui.DevicePortParamTable->openPersistentEditor(index);
716     }
717     }
718 schoenebeck 1486 }
719    
720 schoenebeck 1461 } // namespace QSampler
721 capela 1464
722    
723     // end of qsamplerDeviceForm.cpp

  ViewVC Help
Powered by ViewVC