« back to all changes in this revision
Viewing changes to src/qsamplerDeviceForm.cpp
- browse files at revision 3
- compare with another revision
- download diff
- download tarball
- view history from revision 3
- Committer: Bazaar Package Importer
- Author(s): Free Ekanayaka
- Date: 2008-08-28 08:43:21 UTC
- mfrom: (1.1.1 upstream) (2.1.2 hardy)
- Revision ID: james.westby@ubuntu.com-20080828084321-guq8v04yg31co9gm
Tags: 0.2.1-1
* New upstream release
* Uploaded to Debian (Closes: #280576)
* Uploaded to Debian (Closes: #280576)
- files added:
- configure.ac
- debian/patches
- files removed:
- configure.in
- files modified:
- AUTHORS
added
removed
src/qsamplerDeviceForm.cpp
1
// qsamplerDeviceForm.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 "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(":/qsampler/pixmaps/deviceCreate.png"),
617
tr("&Create device"), this, SLOT(createDevice()));
618
pAction->setEnabled(bEnabled || (bClient && m_bNewDevice));
619
pAction = menu.addAction(
620
QIcon(":/qsampler/pixmaps/deviceDelete.png"),
621
tr("&Delete device"), this, SLOT(deleteDevice()));
622
pAction->setEnabled(bEnabled && !m_bNewDevice);
623
menu.addSeparator();
624
pAction = menu.addAction(
625
QIcon(":/qsampler/pixmaps/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
Loggerhead is a web-based interface for Breezy
Version: 2.0.1