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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 426 by capela, Mon Mar 7 11:09:32 2005 UTC revision 467 by capela, Tue Mar 15 23:54:14 2005 UTC
# Line 1  Line 1 
1  // qsamplerDevice.cpp  // qsamplerDevice.cpp
2  //  //
3  /****************************************************************************  /****************************************************************************
4     Copyright (C) 2003-2005, rncbc aka Rui Nuno Capela. All rights reserved.     Copyright (C) 2005, rncbc aka Rui Nuno Capela. All rights reserved.
5    
6     This program is free software; you can redistribute it and/or     This program is free software; you can redistribute it and/or
7     modify it under the terms of the GNU General Public License     modify it under the terms of the GNU General Public License
# Line 21  Line 21 
21    
22  #include "qsamplerDevice.h"  #include "qsamplerDevice.h"
23    
24    #include <qspinbox.h>
25    #include <qlineedit.h>
26    
27  #include "qsamplerMainForm.h"  #include "qsamplerMainForm.h"
28  #include "qsamplerDeviceForm.h"  #include "qsamplerDeviceForm.h"
29    
# Line 28  Line 31 
31    
32    
33  //-------------------------------------------------------------------------  //-------------------------------------------------------------------------
34  // qsamplerDeviceParameterTable - Device parameter view table.  // 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.  // Constructor.
626  qsamplerDeviceParameterTable::qsamplerDeviceParameterTable ( QWidget *pParent, const char *pszName )  qsamplerDeviceParamTable::qsamplerDeviceParamTable ( QWidget *pParent,
627            const char *pszName )
628          : QTable(pParent, pszName)          : QTable(pParent, pszName)
629  {  {
630          m_pClient = NULL;          // 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.  // Default destructor.
652  qsamplerDeviceParameterTable::~qsamplerDeviceParameterTable (void)  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  // The client descriptor property accessors.  // Virtual implemetations.
783  void qsamplerDeviceParameterTable::setClient ( lscp_client_t *pClient )  QWidget *qsamplerDeviceParamTableEditBox::createEditor (void) const
784  {  {
785      m_pClient = pClient;          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  lscp_client_t *qsamplerDeviceParameterTable::client (void)  void qsamplerDeviceParamTableEditBox::setContentFromEditor ( QWidget *pWidget )
793  {  {
794      return m_pClient;          if (pWidget->inherits("QLineEdit"))
795                    QTableItem::setText(((QLineEdit *) pWidget)->text());
796            else
797                    QTableItem::setContentFromEditor(pWidget);
798  }  }
799    
800    
Legend:
Removed from v.426  
changed lines
  Added in v.467
  ViewVC Help
Powered by ViewVC