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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 3555 - (show annotations) (download)
Tue Aug 13 10:19:32 2019 UTC (8 days, 11 hours ago) by capela
File size: 20516 byte(s)
- In late compliance to C++11, all NULL constants replaced for nullptr.
1 // qsamplerDeviceForm.cpp
2 //
3 /****************************************************************************
4 Copyright (C) 2004-2019, rncbc aka Rui Nuno Capela. All rights reserved.
5 Copyright (C) 2007, 2008 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 "qsamplerDeviceForm.h"
24
25 #include "qsamplerAbout.h"
26 #include "qsamplerMainForm.h"
27
28 #include <QHeaderView>
29 #include <QMessageBox>
30
31 #include <QCheckBox>
32
33
34 namespace QSampler {
35
36 //-------------------------------------------------------------------------
37 // QSampler::DeviceForm -- Device form implementation.
38 //
39
40 DeviceForm::DeviceForm ( QWidget *pParent, Qt::WindowFlags wflags )
41 : QDialog(pParent, wflags)
42 {
43 m_ui.setupUi(this);
44
45 // Initialize locals.
46 m_iDirtySetup = 0;
47 m_iDirtyCount = 0;
48 m_bNewDevice = false;
49 m_deviceType = Device::None;
50 m_pAudioItems = nullptr;
51 m_pMidiItems = nullptr;
52 // No exclusive mode as default.
53 m_deviceTypeMode = Device::None;
54
55 m_ui.DeviceListView->header()->hide();
56
57 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 m_ui.DeviceParamTable->setModel(&m_deviceParamModel);
64 m_ui.DeviceParamTable->setItemDelegate(&m_deviceParamDelegate);
65 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
66 m_ui.DeviceParamTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::Stretch);
67 #else
68 m_ui.DeviceParamTable->horizontalHeader()->setResizeMode(2, QHeaderView::Stretch);
69 #endif
70 m_ui.DeviceParamTable->verticalHeader()->hide();
71
72 m_ui.DevicePortParamTable->setModel(&m_devicePortParamModel);
73 m_ui.DevicePortParamTable->setItemDelegate(&m_devicePortParamDelegate);
74 #if QT_VERSION >= QT_VERSION_CHECK(5, 0, 0)
75 m_ui.DevicePortParamTable->horizontalHeader()->setSectionResizeMode(2, QHeaderView::Stretch);
76 #else
77 m_ui.DevicePortParamTable->horizontalHeader()->setResizeMode(2, QHeaderView::Stretch);
78 #endif
79 m_ui.DevicePortParamTable->verticalHeader()->hide();
80
81 // Initial contents.
82 refreshDevices();
83 // Try to restore normal window positioning.
84 adjustSize();
85
86 QObject::connect(m_ui.DeviceListView,
87 SIGNAL(currentItemChanged(QTreeWidgetItem*,QTreeWidgetItem*)),
88 SLOT(selectDevice()));
89 QObject::connect(m_ui.DeviceListView,
90 SIGNAL(customContextMenuRequested(const QPoint&)),
91 SLOT(deviceListViewContextMenu(const QPoint&)));
92 QObject::connect(m_ui.RefreshDevicesPushButton,
93 SIGNAL(clicked()),
94 SLOT(refreshDevices()));
95 QObject::connect(m_ui.DriverNameComboBox,
96 SIGNAL(activated(const QString&)),
97 SLOT(selectDriver(const QString&)));
98 QObject::connect(m_ui.DevicePortComboBox,
99 SIGNAL(activated(int)),
100 SLOT(selectDevicePort(int)));
101 QObject::connect(m_ui.CreateDevicePushButton,
102 SIGNAL(clicked()),
103 SLOT(createDevice()));
104 QObject::connect(m_ui.DeleteDevicePushButton,
105 SIGNAL(clicked()),
106 SLOT(deleteDevice()));
107 QObject::connect(m_ui.ClosePushButton,
108 SIGNAL(clicked()),
109 SLOT(close()));
110 QObject::connect(&m_deviceParamModel,
111 SIGNAL(modelReset()),
112 SLOT(updateCellRenderers()));
113 QObject::connect(&m_deviceParamModel,
114 SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
115 SLOT(updateCellRenderers(const QModelIndex&, const QModelIndex&)));
116 QObject::connect(&m_devicePortParamModel,
117 SIGNAL(modelReset()),
118 SLOT(updatePortCellRenderers()));
119 QObject::connect(&m_devicePortParamModel,
120 SIGNAL(dataChanged(const QModelIndex&, const QModelIndex&)),
121 SLOT(updatePortCellRenderers(const QModelIndex&, const QModelIndex&)));
122 }
123
124
125 DeviceForm::~DeviceForm (void)
126 {
127 }
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 QWidget::showEvent(pShowEvent);
138
139 refreshDevices();
140 }
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 Device::DeviceType deviceTypeMode )
163 {
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 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 sDriverName);
183 }
184
185
186 // Set current selected device by type and id.
187 void DeviceForm::setDevice ( Device *pDevice )
188 {
189 // In case no device is given...
190 Device::DeviceType deviceType = m_deviceTypeMode;
191 if (pDevice)
192 deviceType = pDevice->deviceType();
193
194 // Get the device view root item...
195 DeviceItem *pRootItem = nullptr;
196 switch (deviceType) {
197 case Device::Audio:
198 pRootItem = m_pAudioItems;
199 break;
200 case Device::Midi:
201 pRootItem = m_pMidiItems;
202 break;
203 case Device::None:
204 break;
205 }
206
207 // Is the root present?
208 if (pRootItem == nullptr)
209 return;
210
211 // So there's no device huh?
212 if (pDevice == nullptr) {
213 m_ui.DeviceListView->setCurrentItem(pRootItem);
214 return;
215 }
216
217 // For each child, test for identity...
218 for (int i = 0; i < pRootItem->childCount(); i++) {
219 DeviceItem* pDeviceItem =
220 (DeviceItem*) pRootItem->child(i);
221
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 if (pMainForm == nullptr)
237 return;
238
239 QTreeWidgetItem *pItem = m_ui.DeviceListView->currentItem();
240 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
241 return;
242
243 // About a brand new device instance...
244 Device device(((DeviceItem *) pItem)->device());
245 if (device.createDevice()) {
246 // Now it depends on the device type...
247 DeviceItem *pRootItem = nullptr;
248 switch (device.deviceType()) {
249 case Device::Audio:
250 pRootItem = m_pAudioItems;
251 break;
252 case Device::Midi:
253 pRootItem = m_pMidiItems;
254 break;
255 case Device::None:
256 break;
257 }
258 // Append the new device item.
259 DeviceItem *pDeviceItem = new DeviceItem(pRootItem,
260 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 if (pMainForm == nullptr)
275 return;
276
277 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
278 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
279 return;
280
281 Device& device = ((DeviceItem *) pItem)->device();
282
283 // Prompt user if this is for real...
284 Options *pOptions = pMainForm->options();
285 if (pOptions && pOptions->bConfirmRemove) {
286 const QString& sTitle = QSAMPLER_TITLE ": " + tr("Warning");
287 const QString& sText = tr(
288 "About to delete device:\n\n"
289 "%1\n\n"
290 "Are you sure?")
291 .arg(device.deviceName());
292 #if 0
293 if (QMessageBox::warning(this, sTitle, sText,
294 QMessageBox::Ok | QMessageBox::Cancel) == QMessageBox::Cancel)
295 return;
296 #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 }
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 if (pMainForm == nullptr)
329 return;
330
331 // Avoid nested changes.
332 m_iDirtySetup++;
333
334 //
335 // (Re)Load complete device configuration data ...
336 //
337 m_pAudioItems = nullptr;
338 m_pMidiItems = nullptr;
339 m_ui.DeviceListView->clear();
340 if (pMainForm->client()) {
341 int *piDeviceIDs;
342 // Grab and pop Audio devices...
343 if (m_deviceTypeMode == Device::None ||
344 m_deviceTypeMode == Device::Audio) {
345 m_pAudioItems = new DeviceItem(m_ui.DeviceListView,
346 Device::Audio);
347 }
348 if (m_pAudioItems) {
349 piDeviceIDs = Device::getDevices(pMainForm->client(),
350 Device::Audio);
351 for (int i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; i++) {
352 new DeviceItem(m_pAudioItems,
353 Device::Audio, piDeviceIDs[i]);
354 }
355 m_pAudioItems->setExpanded(true);
356 }
357 // Grab and pop MIDI devices...
358 if (m_deviceTypeMode == Device::None ||
359 m_deviceTypeMode == Device::Midi) {
360 m_pMidiItems = new DeviceItem(m_ui.DeviceListView,
361 Device::Midi);
362 }
363 if (m_pMidiItems) {
364 piDeviceIDs = Device::getDevices(pMainForm->client(),
365 Device::Midi);
366 for (int i = 0; piDeviceIDs && piDeviceIDs[i] >= 0; i++) {
367 new DeviceItem(m_pMidiItems,
368 Device::Midi, piDeviceIDs[i]);
369 }
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 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
393 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
394 return;
395
396 Device& device = ((DeviceItem *) pItem)->device();
397
398 // Driver change is only valid for scratch devices...
399 if (m_bNewDevice) {
400 m_iDirtySetup++;
401 device.setDriver(sDriverName);
402 m_deviceParamModel.refresh(&device, m_bNewDevice);
403 m_iDirtySetup--;
404 // Done.
405 stabilizeForm();
406 }
407 }
408
409
410 // Device selection slot.
411 void DeviceForm::selectDevice ()
412 {
413 MainForm *pMainForm = MainForm::getInstance();
414 if (pMainForm == nullptr)
415 return;
416
417 if (m_iDirtySetup > 0)
418 return;
419
420 //
421 // Device selection has changed...
422 //
423
424 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
425 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM) {
426 m_deviceType = Device::None;
427 m_ui.DeviceNameTextLabel->setText(QString());
428 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 stabilizeForm();
435 return;
436 }
437
438 Device& device = ((DeviceItem *) pItem)->device();
439
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 m_ui.DeviceNameTextLabel->setText(device.deviceName());
446 // The driver combobox is only rebuilt if device type has changed...
447 if (device.deviceType() != m_deviceType) {
448 m_ui.DriverNameComboBox->clear();
449 m_ui.DriverNameComboBox->insertItems(0,
450 Device::getDrivers(pMainForm->client(), device.deviceType()));
451 m_deviceType = device.deviceType();
452 }
453 // Do we need a driver name?
454 if (m_bNewDevice || device.driverName().isEmpty())
455 device.setDriver(m_ui.DriverNameComboBox->currentText());
456 setDriverName(device.driverName());
457 m_ui.DriverNameTextLabel->setEnabled(m_bNewDevice);
458 m_ui.DriverNameComboBox->setEnabled(m_bNewDevice);
459 // Fill the device parameter table...
460 m_deviceParamModel.refresh(&device, m_bNewDevice);
461 // And now the device port/channel parameter table...
462 switch (device.deviceType()) {
463 case Device::Audio:
464 m_ui.DevicePortTextLabel->setText(tr("Ch&annel:"));
465 break;
466 case Device::Midi:
467 m_ui.DevicePortTextLabel->setText(tr("P&ort:"));
468 break;
469 case Device::None:
470 break;
471 }
472 m_ui.DevicePortComboBox->clear();
473 m_devicePortParamModel.clear();
474 if (m_bNewDevice) {
475 m_ui.DevicePortTextLabel->setEnabled(false);
476 m_ui.DevicePortComboBox->setEnabled(false);
477 m_ui.DevicePortParamTable->setEnabled(false);
478 } else {
479 QPixmap pixmap;
480 switch (device.deviceType()) {
481 case Device::Audio:
482 pixmap = QPixmap(":/images/audio2.png");
483 break;
484 case Device::Midi:
485 pixmap = QPixmap(":/images/midi2.png");
486 break;
487 case Device::None:
488 break;
489 }
490 DevicePortList& ports = device.ports();
491 QListIterator<DevicePort *> iter(ports);
492 while (iter.hasNext()) {
493 DevicePort *pPort = iter.next();
494 m_ui.DevicePortComboBox->addItem(pixmap,
495 device.deviceTypeName()
496 + ' ' + device.driverName()
497 + ' ' + pPort->portName());
498 }
499 bool bEnabled = (ports.count() > 0);
500 m_ui.DevicePortTextLabel->setEnabled(bEnabled);
501 m_ui.DevicePortComboBox->setEnabled(bEnabled);
502 m_ui.DevicePortParamTable->setEnabled(bEnabled);
503 }
504 // Done.
505 m_iDirtySetup--;
506
507 // Make the device port/channel selection effective.
508 selectDevicePort(m_ui.DevicePortComboBox->currentIndex());
509 }
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 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
523 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
524 return;
525
526 Device& device = ((DeviceItem *) pItem)->device();
527 DevicePort *pPort = nullptr;
528 if (iPort >= 0 && iPort < device.ports().count())
529 pPort = device.ports().at(iPort);
530 if (pPort) {
531 m_iDirtySetup++;
532 m_devicePortParamModel.refresh(pPort, false);
533 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 /* we do that in the model class now ...
553 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
554 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
555 return;
556
557 Device& device = ((DeviceItem *) pItem)->device();
558
559 // Table 1st column has the parameter name;
560 //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 // Set the local device parameter value.
565 if (device.setParam(sParam, sValue)) {
566 selectDevice();
567 } else {
568 stabilizeForm();
569 }
570 */
571
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 /* we do that in the model class now ...
592 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
593 if (pItem == nullptr || pItem->type() != QSAMPLER_DEVICE_ITEM)
594 return;
595
596 Device& device = ((DeviceItem *) pItem)->device();
597
598 int iPort = m_ui.DevicePortComboBox->currentIndex();
599 DevicePort *pPort = nullptr;
600 if (iPort >= 0 && iPort < device.ports().count())
601 pPort = device.ports().at(iPort);
602 if (pPort == nullptr)
603 return;
604
605 // Table 1st column has the parameter name;
606 //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
611 // Set the local device port/channel parameter value.
612 pPort->setParam(sParam, sValue);
613 */
614
615 // 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 void DeviceForm::deviceListViewContextMenu ( const QPoint& pos )
627 {
628 MainForm *pMainForm = MainForm::getInstance();
629 if (pMainForm == nullptr)
630 return;
631
632 QTreeWidgetItem* pItem = m_ui.DeviceListView->itemAt(pos);
633 if (pItem == nullptr)
634 return;
635
636 // Build the device context menu...
637 QMenu menu(this);
638 QAction *pAction;
639
640 bool bClient = (pMainForm->client() != nullptr);
641 bool bEnabled = (pItem != nullptr);
642 pAction = menu.addAction(
643 QIcon(":/images/deviceCreate.png"),
644 tr("&Create device"), this, SLOT(createDevice()));
645 pAction->setEnabled(bEnabled || (bClient && m_bNewDevice));
646 pAction = menu.addAction(
647 QIcon(":/images/deviceDelete.png"),
648 tr("&Delete device"), this, SLOT(deleteDevice()));
649 pAction->setEnabled(bEnabled && !m_bNewDevice);
650 menu.addSeparator();
651 pAction = menu.addAction(
652 QIcon(":/images/formRefresh.png"),
653 tr("&Refresh"), this, SLOT(refreshDevices()));
654 pAction->setEnabled(bClient);
655
656 menu.exec(pos);
657 }
658
659
660 // Stabilize current form state.
661 void DeviceForm::stabilizeForm (void)
662 {
663 MainForm* pMainForm = MainForm::getInstance();
664 QTreeWidgetItem* pItem = m_ui.DeviceListView->currentItem();
665 bool bClient = (pMainForm && pMainForm->client() != nullptr);
666 bool bEnabled = (pItem != nullptr);
667 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 }
675
676
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 }
685
686
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 }
697
698
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 }
707
708
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 }
719
720 } // namespace QSampler
721
722
723 // end of qsamplerDeviceForm.cpp

  ViewVC Help
Powered by ViewVC