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

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

Parent Directory Parent Directory | Revision Log Revision Log


Revision 467 - (show annotations) (download)
Tue Mar 15 23:54:14 2005 UTC (19 years ago) by capela
File size: 21409 byte(s)
Device port/channel configuration refreshing fix.

1 // qsamplerDevice.cpp
2 //
3 /****************************************************************************
4 Copyright (C) 2005, rncbc aka Rui Nuno Capela. All rights reserved.
5
6 This program is free software; you can redistribute it and/or
7 modify it under the terms of the GNU General Public License
8 as published by the Free Software Foundation; either version 2
9 of the License, or (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19
20 *****************************************************************************/
21
22 #include "qsamplerDevice.h"
23
24 #include <qspinbox.h>
25 #include <qlineedit.h>
26
27 #include "qsamplerMainForm.h"
28 #include "qsamplerDeviceForm.h"
29
30 #include "config.h"
31
32
33 //-------------------------------------------------------------------------
34 // qsamplerDeviceParam - MIDI/Audio Device parameter structure.
35 //
36
37 // Constructors.
38 qsamplerDeviceParam::qsamplerDeviceParam ( lscp_param_info_t *pParamInfo,
39 const char *pszValue )
40 {
41 setParam(pParamInfo, pszValue);
42 }
43
44
45 // Default destructor.
46 qsamplerDeviceParam::~qsamplerDeviceParam (void)
47 {
48 }
49
50
51 // Initializer.
52 void qsamplerDeviceParam::setParam ( lscp_param_info_t *pParamInfo,
53 const char *pszValue )
54 {
55 if (pParamInfo == NULL)
56 return;
57
58 // Info structure field members.
59
60 type = pParamInfo->type;
61
62 if (pParamInfo->description)
63 description = pParamInfo->description;
64 else
65 description = QString::null;
66
67 mandatory = (bool) pParamInfo->multiplicity;
68 fix = (bool) pParamInfo->fix;
69 multiplicity = (bool) pParamInfo->multiplicity;
70
71 depends.clear();
72 for (int i = 0; pParamInfo->depends && pParamInfo->depends[i]; i++)
73 depends.append(pParamInfo->depends[i]);
74
75 if (pParamInfo->defaultv)
76 defaultv = pParamInfo->defaultv;
77 else
78 defaultv = QString::null;
79
80 if (pParamInfo->range_min)
81 range_min = pParamInfo->range_min;
82 else
83 range_min = QString::null;
84
85 if (pParamInfo->range_max)
86 range_max = pParamInfo->range_max;
87 else
88 range_max = QString::null;
89
90 possibilities.clear();
91 for (int i = 0; pParamInfo->possibilities && pParamInfo->possibilities[i]; i++)
92 possibilities.append(pParamInfo->possibilities[i]);
93
94 // The current parameter value.
95 if (pszValue)
96 value = pszValue;
97 else
98 value = QString::null;
99 }
100
101
102 //-------------------------------------------------------------------------
103 // qsamplerDevice - MIDI/Audio Device structure.
104 //
105
106 // Constructor.
107 qsamplerDevice::qsamplerDevice ( lscp_client_t *pClient,
108 qsamplerDeviceType deviceType, int iDeviceID )
109 {
110 m_ports.setAutoDelete(true);
111
112 setDevice(pClient, deviceType, iDeviceID);
113 }
114
115 // Default destructor.
116 qsamplerDevice::~qsamplerDevice (void)
117 {
118 }
119
120
121 // Initializer.
122 void qsamplerDevice::setDevice ( lscp_client_t *pClient,
123 qsamplerDeviceType deviceType, int iDeviceID )
124 {
125 // Device id and type should be always set.
126 m_iDeviceID = iDeviceID;
127 m_deviceType = deviceType;
128
129 // Reset device parameters and ports anyway.
130 m_params.clear();
131 m_ports.clear();
132
133 // Retrieve device info, if any.
134 lscp_device_info_t *pDeviceInfo = NULL;
135 switch (deviceType) {
136 case qsamplerDevice::Audio:
137 m_sDeviceType = QObject::tr("Audio");
138 pDeviceInfo = ::lscp_get_audio_device_info(pClient, iDeviceID);
139 break;
140 case qsamplerDevice::Midi:
141 m_sDeviceType = QObject::tr("MIDI");
142 pDeviceInfo = ::lscp_get_midi_device_info(pClient, iDeviceID);
143 break;
144 case qsamplerDevice::None:
145 m_sDeviceType = QString::null;
146 break;
147 }
148
149 // If we're bogus, bail out...
150 if (pDeviceInfo == NULL) {
151 m_sDriverName = QString::null;
152 m_sDeviceName = QObject::tr("New %1 device").arg(m_sDeviceType);
153 return;
154 }
155
156 // Other device properties...
157 m_sDriverName = pDeviceInfo->driver;
158 m_sDeviceName = m_sDriverName + ' '
159 + QObject::tr("Device %1").arg(m_iDeviceID);
160
161 // Grab device parameters...
162 for (int i = 0; pDeviceInfo->params && pDeviceInfo->params[i].key; i++) {
163 const QString sParam = pDeviceInfo->params[i].key;
164 lscp_param_info_t *pParamInfo = NULL;
165 switch (deviceType) {
166 case qsamplerDevice::Audio:
167 pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
168 m_sDriverName.latin1(), sParam.latin1(), NULL);
169 break;
170 case qsamplerDevice::Midi:
171 pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
172 m_sDriverName.latin1(), sParam.latin1(), NULL);
173 break;
174 case qsamplerDevice::None:
175 break;
176 }
177 if (pParamInfo) {
178 m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
179 pDeviceInfo->params[i].value);
180 }
181 }
182
183 // Refresh parameter dependencies...
184 refreshParams(pClient);
185 // Set port/channel list...
186 refreshPorts(pClient);
187 }
188
189
190 // Driver name initializer/settler.
191 void qsamplerDevice::setDriver ( lscp_client_t *pClient,
192 const QString& sDriverName )
193 {
194 // Valid only for scratch devices.
195 if (m_sDriverName == sDriverName)
196 return;
197
198 // Reset device parameters and ports anyway.
199 m_params.clear();
200 m_ports.clear();
201
202 // Retrieve driver info, if any.
203 lscp_driver_info_t *pDriverInfo = NULL;
204 switch (m_deviceType) {
205 case qsamplerDevice::Audio:
206 pDriverInfo = ::lscp_get_audio_driver_info(pClient,
207 sDriverName.latin1());
208 break;
209 case qsamplerDevice::Midi:
210 pDriverInfo = ::lscp_get_midi_driver_info(pClient,
211 sDriverName.latin1());
212 break;
213 case qsamplerDevice::None:
214 break;
215 }
216
217 // If we're bogus, bail out...
218 if (pDriverInfo == NULL)
219 return;
220
221 // Remember device parameters...
222 m_sDriverName = sDriverName;
223
224 // Grab driver parameters...
225 for (int i = 0; pDriverInfo->parameters && pDriverInfo->parameters[i]; i++) {
226 const QString sParam = pDriverInfo->parameters[i];
227 lscp_param_info_t *pParamInfo = NULL;
228 switch (m_deviceType) {
229 case qsamplerDevice::Audio:
230 pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
231 sDriverName.latin1(), sParam.latin1(), NULL);
232 break;
233 case qsamplerDevice::Midi:
234 pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
235 sDriverName.latin1(), sParam.latin1(), NULL);
236 break;
237 case qsamplerDevice::None:
238 break;
239 }
240 if (pParamInfo) {
241 m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
242 pParamInfo->defaultv);
243 }
244 }
245
246 // Refresh parameter dependencies...
247 refreshParams(pClient);
248 // Set port/channel list...
249 refreshPorts(pClient);
250 }
251
252
253 // Device property accessors.
254 int qsamplerDevice::deviceID (void) const
255 {
256 return m_iDeviceID;
257 }
258
259 qsamplerDevice::qsamplerDeviceType qsamplerDevice::deviceType (void) const
260 {
261 return m_deviceType;
262 }
263
264 const QString& qsamplerDevice::deviceTypeName (void) const
265 {
266 return m_sDeviceType;
267 }
268
269 const QString& qsamplerDevice::driverName (void) const
270 {
271 return m_sDriverName;
272 }
273
274 const QString& qsamplerDevice::deviceName (void) const
275 {
276 return m_sDeviceName;
277 }
278
279
280 // Set the proper device parameter value.
281 void qsamplerDevice::setParam ( const QString& sParam,
282 const QString& sValue )
283 {
284 m_params[sParam.upper()].value = sValue;
285 }
286
287
288 // Device parameter accessor.
289 const qsamplerDeviceParamMap& qsamplerDevice::params (void) const
290 {
291 return m_params;
292 }
293
294
295 // Device port/channel list accessor.
296 qsamplerDevicePortList& qsamplerDevice::ports (void)
297 {
298 return m_ports;
299 }
300
301
302 // Device parameter dependencies refreshner.
303 int qsamplerDevice::refreshParams ( lscp_client_t *pClient )
304 {
305 // Refresh all parameters that have dependencies...
306 int iParams = 0;
307 qsamplerDeviceParamMap::ConstIterator iter;
308 for (iter = m_params.begin(); iter != m_params.end(); ++iter)
309 iParams += refreshParam(pClient, iter.key());
310 // Return how many parameters have been refreshed...
311 return iParams;
312 }
313
314
315 // Device port/channel list refreshner.
316 int qsamplerDevice::refreshPorts ( lscp_client_t *pClient )
317 {
318 // Port/channel count determination...
319 int iPorts = 0;
320 switch (m_deviceType) {
321 case qsamplerDevice::Audio:
322 iPorts = m_params["CHANNELS"].value.toInt();
323 break;
324 case qsamplerDevice::Midi:
325 iPorts = m_params["PORTS"].value.toInt();
326 break;
327 case qsamplerDevice::None:
328 break;
329 }
330 // Retrieve port/channel information...
331 m_ports.clear();
332 for (int iPort = 0; iPort < iPorts; iPort++)
333 m_ports.append(new qsamplerDevicePort(pClient, *this, iPort));
334 // Return how many ports have been refreshed...
335 return iPorts;
336 }
337
338
339 // Refresh/set dependencies given that some parameter has changed.
340 int qsamplerDevice::refreshDepends ( lscp_client_t *pClient,
341 const QString& sParam )
342 {
343 // Refresh all parameters that depend on this one...
344 int iDepends = 0;
345 qsamplerDeviceParamMap::ConstIterator iter;
346 for (iter = m_params.begin(); iter != m_params.end(); ++iter) {
347 const QStringList& depends = iter.data().depends;
348 if (depends.find(sParam) != depends.end())
349 iDepends += refreshParam(pClient, iter.key());
350 }
351 // Return how many dependencies have been refreshed...
352 return iDepends;
353 }
354
355
356 // Refresh/set given parameter based on driver supplied dependencies.
357 int qsamplerDevice::refreshParam ( lscp_client_t *pClient,
358 const QString& sParam )
359 {
360 // Check if we have dependencies...
361 qsamplerDeviceParam& param = m_params[sParam.upper()];
362 if (param.depends.isEmpty())
363 return 0;
364
365 int iRefresh = 0;
366
367 // Build dependency list...
368 lscp_param_t *pDepends = new lscp_param_t [param.depends.count() + 1];
369 int iDepend = 0;
370 QStringList::ConstIterator iter;
371 for (iter = param.depends.begin(); iter != param.depends.end(); ++iter) {
372 const QString& sDepend = *iter;
373 pDepends[iDepend].key = (char *) sDepend.latin1();
374 pDepends[iDepend].value = (char *) m_params[sDepend.upper()].value.latin1();
375 ++iDepend;
376 }
377 // Null terminated.
378 pDepends[iDepend].key = NULL;
379 pDepends[iDepend].value = NULL;
380
381 #if 0
382 // FIXME: Some parameter dependencies (e.g.ALSA CARD)
383 // are blocking for no reason, causing timeout-crashes.
384
385 // Retrieve some modern parameters...
386 lscp_param_info_t *pParamInfo = NULL;
387 switch (m_deviceType) {
388 case qsamplerDevice::Audio:
389 pParamInfo = ::lscp_get_audio_driver_param_info(pClient,
390 m_sDriverName.latin1(), sParam.latin1(), pDepends);
391 break;
392 case qsamplerDevice::Midi:
393 pParamInfo = ::lscp_get_midi_driver_param_info(pClient,
394 m_sDriverName.latin1(), sParam.latin1(), pDepends);
395 break;
396 case qsamplerDevice::None:
397 break;
398 }
399 if (pParamInfo) {
400 param = qsamplerDeviceParam(pParamInfo, QString(param.value));
401 iRefresh++;
402 }
403 #endif
404 // Free used parameter array.
405 delete pDepends;
406
407 // Return whether the parameters has been changed...
408 return iRefresh;
409 }
410
411
412 // Device ids enumerator.
413 int *qsamplerDevice::getDevices ( lscp_client_t *pClient,
414 qsamplerDeviceType deviceType )
415 {
416 int *piDeviceIDs = NULL;
417 switch (deviceType) {
418 case qsamplerDevice::Audio:
419 piDeviceIDs = ::lscp_list_audio_devices(pClient);
420 break;
421 case qsamplerDevice::Midi:
422 piDeviceIDs = ::lscp_list_midi_devices(pClient);
423 break;
424 case qsamplerDevice::None:
425 break;
426 }
427 return piDeviceIDs;
428 }
429
430
431 // Driver names enumerator.
432 QStringList qsamplerDevice::getDrivers ( lscp_client_t *pClient,
433 qsamplerDeviceType deviceType )
434 {
435 QStringList drivers;
436
437 const char **ppszDrivers = NULL;
438 switch (deviceType) {
439 case qsamplerDevice::Audio:
440 ppszDrivers = ::lscp_get_available_audio_drivers(pClient);
441 break;
442 case qsamplerDevice::Midi:
443 ppszDrivers = ::lscp_get_available_midi_drivers(pClient);
444 break;
445 case qsamplerDevice::None:
446 break;
447 }
448
449 for (int iDriver = 0; ppszDrivers[iDriver]; iDriver++)
450 drivers.append(ppszDrivers[iDriver]);
451
452 return drivers;
453 }
454
455
456 //-------------------------------------------------------------------------
457 // qsamplerDevicePort - MIDI/Audio Device port/channel structure.
458 //
459
460 // Constructor.
461 qsamplerDevicePort::qsamplerDevicePort ( lscp_client_t *pClient,
462 const qsamplerDevice& device, int iPortID )
463 {
464 setDevicePort(pClient, device, iPortID);
465 }
466
467 // Default destructor.
468 qsamplerDevicePort::~qsamplerDevicePort (void)
469 {
470 }
471
472
473 // Initializer.
474 void qsamplerDevicePort::setDevicePort ( lscp_client_t *pClient,
475 const qsamplerDevice& device, int iPortID )
476 {
477 // Device port id should be always set.
478 m_iPortID = iPortID;
479
480 // Reset port parameters anyway.
481 m_params.clear();
482
483 // Retrieve device port/channel info, if any.
484 QString sPrefix = device.driverName() + ' ';
485 lscp_device_port_info_t *pPortInfo = NULL;
486 switch (device.deviceType()) {
487 case qsamplerDevice::Audio:
488 sPrefix += QObject::tr("Channel");
489 pPortInfo = ::lscp_get_audio_channel_info(pClient, device.deviceID(), iPortID);
490 break;
491 case qsamplerDevice::Midi:
492 sPrefix += QObject::tr("Port");
493 pPortInfo = ::lscp_get_midi_port_info(pClient, device.deviceID(), iPortID);
494 break;
495 case qsamplerDevice::None:
496 break;
497 }
498
499 // If we're bogus, bail out...
500 if (pPortInfo == NULL) {
501 m_sPortName = QString::null;
502 return;
503 }
504
505 // Set device port/channel properties...
506 sPrefix += " %1:";
507 m_sPortName = sPrefix.arg(m_iPortID) + ' ' + pPortInfo->name;
508
509 // Grab device port/channel parameters...
510 m_params.clear();
511 for (int i = 0; pPortInfo->params && pPortInfo->params[i].key; i++) {
512 const QString sParam = pPortInfo->params[i].key;
513 lscp_param_info_t *pParamInfo = NULL;
514 switch (device.deviceType()) {
515 case qsamplerDevice::Audio:
516 pParamInfo = ::lscp_get_audio_channel_param_info(pClient,
517 device.deviceID(), iPortID, sParam.latin1());
518 break;
519 case qsamplerDevice::Midi:
520 pParamInfo = ::lscp_get_midi_port_param_info(pClient,
521 device.deviceID(), iPortID, sParam.latin1());
522 break;
523 case qsamplerDevice::None:
524 break;
525 }
526 if (pParamInfo) {
527 m_params[sParam.upper()] = qsamplerDeviceParam(pParamInfo,
528 pPortInfo->params[i].value);
529 }
530 }
531 }
532
533
534 // Device port/channel property accessors.
535 int qsamplerDevicePort::portID (void) const
536 {
537 return m_iPortID;
538 }
539
540 const QString& qsamplerDevicePort::portName (void) const
541 {
542 return m_sPortName;
543 }
544
545 // Device port/channel parameter accessor.
546 const qsamplerDeviceParamMap& qsamplerDevicePort::params (void) const
547 {
548 return m_params;
549 }
550
551
552 // Set the proper device port/channel parameter value.
553 void qsamplerDevicePort::setParam ( const QString& sParam,
554 const QString& sValue )
555 {
556 m_params[sParam.upper()].value = sValue;
557 }
558
559
560 //-------------------------------------------------------------------------
561 // qsamplerDeviceItem - QListView device item.
562 //
563
564 // Constructors.
565 qsamplerDeviceItem::qsamplerDeviceItem ( QListView *pListView,
566 lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType )
567 : QListViewItem(pListView), m_device(pClient, deviceType)
568 {
569 switch(m_device.deviceType()) {
570 case qsamplerDevice::Audio:
571 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio1.png"));
572 QListViewItem::setText(0, QObject::tr("Audio devices"));
573 break;
574 case qsamplerDevice::Midi:
575 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi1.png"));
576 QListViewItem::setText(0, QObject::tr("MIDI devices"));
577 break;
578 case qsamplerDevice::None:
579 break;
580 }
581 }
582
583 qsamplerDeviceItem::qsamplerDeviceItem ( QListViewItem *pItem,
584 lscp_client_t *pClient, qsamplerDevice::qsamplerDeviceType deviceType,
585 int iDeviceID )
586 : QListViewItem(pItem), m_device(pClient, deviceType, iDeviceID)
587 {
588 switch(m_device.deviceType()) {
589 case qsamplerDevice::Audio:
590 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("audio2.png"));
591 break;
592 case qsamplerDevice::Midi:
593 QListViewItem::setPixmap(0, QPixmap::fromMimeSource("midi2.png"));
594 break;
595 case qsamplerDevice::None:
596 break;
597 }
598
599 QListViewItem::setText(0, m_device.deviceName());
600 }
601
602 // Default destructor.
603 qsamplerDeviceItem::~qsamplerDeviceItem (void)
604 {
605 }
606
607 // Instance accessors.
608 qsamplerDevice& qsamplerDeviceItem::device (void)
609 {
610 return m_device;
611 }
612
613 // To virtually distinguish between list view items.
614 int qsamplerDeviceItem::rtti() const
615 {
616 return QSAMPLER_DEVICE_ITEM;
617 }
618
619
620
621 //-------------------------------------------------------------------------
622 // qsamplerDeviceParamTable - Device parameter view table.
623 //
624
625 // Constructor.
626 qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
627 const char *pszName )
628 : QTable(pParent, pszName)
629 {
630 // Set fixed number of columns.
631 QTable::setNumCols(3);
632 QTable::setShowGrid(false);
633 QTable::setSorting(false);
634 QTable::setFocusStyle(QTable::FollowStyle);
635 QTable::setSelectionMode(QTable::NoSelection);
636 // No vertical header.
637 QTable::verticalHeader()->hide();
638 QTable::setLeftMargin(0);
639 // Initialize the fixed table column headings.
640 QHeader *pHeader = QTable::horizontalHeader();
641 pHeader->setLabel(0, tr("Parameter"));
642 pHeader->setLabel(1, tr("Description"));
643 pHeader->setLabel(2, tr("Value"));
644 // Set read-onlyness of each column
645 QTable::setColumnReadOnly(0, true);
646 QTable::setColumnReadOnly(1, true);
647 // QTable::setColumnReadOnly(2, true); -- of course not.
648 QTable::setColumnStretchable(1, true);
649 }
650
651 // Default destructor.
652 qsamplerDeviceParamTable::~qsamplerDeviceParamTable (void)
653 {
654 }
655
656
657 // Common parameter table renderer.
658 void qsamplerDeviceParamTable::refresh ( const qsamplerDeviceParamMap& params,
659 bool bEditable )
660 {
661 // Always (re)start it empty.
662 QTable::setUpdatesEnabled(false);
663 QTable::setNumRows(0);
664
665 // Fill the parameter table...
666 QTable::insertRows(0, params.count());
667 int iRow = 0;
668 qsamplerDeviceParamMap::ConstIterator iter;
669 for (iter = params.begin(); iter != params.end(); ++iter) {
670 const qsamplerDeviceParam& param = iter.data();
671 bool bEnabled = (bEditable || !param.fix);
672 QTable::setText(iRow, 0, iter.key());
673 QTable::setText(iRow, 1, param.description);
674 if (param.type == LSCP_TYPE_BOOL) {
675 QStringList opts;
676 opts.append(tr("false"));
677 opts.append(tr("true"));
678 QComboTableItem *pComboItem = new QComboTableItem(this, opts);
679 pComboItem->setCurrentItem(param.value.lower() == "true" ? 1 : 0);
680 pComboItem->setEnabled(bEnabled);
681 QTable::setItem(iRow, 2, pComboItem);
682 } else if (param.possibilities.count() > 0 && bEnabled) {
683 QComboTableItem *pComboItem = new QComboTableItem(this,
684 param.possibilities);
685 pComboItem->setCurrentItem(param.value);
686 pComboItem->setEnabled(bEnabled);
687 pComboItem->setEditable(bEnabled && param.multiplicity);
688 QTable::setItem(iRow, 2, pComboItem);
689 } else if (param.type == LSCP_TYPE_INT && bEnabled
690 && !param.range_min.isEmpty()
691 && !param.range_max.isEmpty()) {
692 qsamplerDeviceParamTableSpinBox *pSpinItem =
693 new qsamplerDeviceParamTableSpinBox(this,
694 bEnabled ? QTableItem::OnTyping : QTableItem::Never,
695 param.value);
696 pSpinItem->setMinValue(param.range_min.toInt());
697 pSpinItem->setMaxValue(param.range_max.toInt());
698 QTable::setItem(iRow, 2, pSpinItem);
699 } else {
700 qsamplerDeviceParamTableEditBox *pEditItem =
701 new qsamplerDeviceParamTableEditBox(this,
702 bEnabled ? QTableItem::OnTyping : QTableItem::Never,
703 param.value);
704 QTable::setItem(iRow, 2, pEditItem);
705 }
706 ++iRow;
707 }
708
709 // Adjust optimal column widths.
710 QTable::adjustColumn(0);
711 QTable::adjustColumn(2);
712
713 QTable::setUpdatesEnabled(true);
714 QTable::updateContents();
715 }
716
717
718 //-------------------------------------------------------------------------
719 // qsamplerDeviceParamTableSpinBox - Custom spin box for parameter table.
720 //
721
722 // Constructor.
723 qsamplerDeviceParamTableSpinBox::qsamplerDeviceParamTableSpinBox (
724 QTable *pTable, EditType editType, const QString& sText )
725 : QTableItem(pTable, editType, sText)
726 {
727 m_iValue = sText.toInt();
728 m_iMinValue = m_iMaxValue = 0;
729 }
730
731 // Public accessors.
732 void qsamplerDeviceParamTableSpinBox::setValue ( int iValue )
733 {
734 m_iValue = iValue;
735 QTableItem::setText(QString::number(m_iValue));
736 }
737
738 void qsamplerDeviceParamTableSpinBox::setMinValue ( int iMinValue )
739 {
740 m_iMinValue = iMinValue;
741 }
742
743 void qsamplerDeviceParamTableSpinBox::setMaxValue ( int iMaxValue )
744 {
745 m_iMaxValue = iMaxValue;
746 }
747
748 // Virtual implemetations.
749 QWidget *qsamplerDeviceParamTableSpinBox::createEditor (void) const
750 {
751 QSpinBox *pSpinBox = new QSpinBox(QTableItem::table()->viewport());
752 QObject::connect(pSpinBox, SIGNAL(valueChanged(int)),
753 QTableItem::table(), SLOT(doValueChanged()));
754 if (m_iValue >= m_iMinValue && m_iMaxValue >= m_iValue) {
755 pSpinBox->setMinValue(m_iMinValue);
756 pSpinBox->setMaxValue(m_iMaxValue);
757 }
758 pSpinBox->setValue(m_iValue);
759 return pSpinBox;
760 }
761
762 void qsamplerDeviceParamTableSpinBox::setContentFromEditor ( QWidget *pWidget )
763 {
764 if (pWidget->inherits("QSpinBox"))
765 QTableItem::setText(QString::number(((QSpinBox *) pWidget)->value()));
766 else
767 QTableItem::setContentFromEditor(pWidget);
768 }
769
770
771 //-------------------------------------------------------------------------
772 // qsamplerDeviceParamTableEditBox - Custom edit box for parameter table.
773 //
774
775 // Constructor.
776 qsamplerDeviceParamTableEditBox::qsamplerDeviceParamTableEditBox (
777 QTable *pTable, EditType editType, const QString& sText )
778 : QTableItem(pTable, editType, sText)
779 {
780 }
781
782 // Virtual implemetations.
783 QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
784 {
785 QLineEdit *pEditBox = new QLineEdit(QTableItem::table()->viewport());
786 QObject::connect(pEditBox, SIGNAL(returnPressed()),
787 QTableItem::table(), SLOT(doValueChanged()));
788 pEditBox->setText(QTableItem::text());
789 return pEditBox;
790 }
791
792 void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
793 {
794 if (pWidget->inherits("QLineEdit"))
795 QTableItem::setText(((QLineEdit *) pWidget)->text());
796 else
797 QTableItem::setContentFromEditor(pWidget);
798 }
799
800
801 // end of qsamplerDevice.cpp

  ViewVC Help
Powered by ViewVC