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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1667 - (show annotations) (download)
Mon Feb 4 23:24:19 2008 UTC (12 years, 3 months ago) by schoenebeck
File size: 19542 byte(s)
* added FX Sends dialog to channel strips
  (still under construction, so far one can only create, destroy and rename
  FX sends, the rest is still to do)
* bumped version to 0.2.1.3

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

  ViewVC Help
Powered by ViewVC